Chapter 53 — Domain and Range

# --- Visualization: Domain restrictions for common functions ---
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-whitegrid')

fig, axes = plt.subplots(2, 3, figsize=(16, 9))

functions = [
    # (name, domain_range, fn, domain_label, range_label)
    ('f(x) = 1/x',  np.concatenate([np.linspace(-3, -0.01, 200), np.linspace(0.01, 3, 200)]),
     lambda x: 1/x, 'x ≠ 0', 'y ≠ 0'),
    ('f(x) = √x',   np.linspace(0, 9, 400),
     np.sqrt, 'x ≥ 0', 'y ≥ 0'),
    ('f(x) = log(x)', np.linspace(0.01, 10, 400),
     np.log, 'x > 0', 'all reals'),
    ('f(x) = x²',   np.linspace(-3, 3, 400),
     lambda x: x**2, 'all reals', 'y ≥ 0'),
    ('f(x) = sin(x)', np.linspace(-2*np.pi, 2*np.pi, 400),
     np.sin, 'all reals', '[-1, 1]'),
    ('f(x) = arcsin(x)', np.linspace(-1, 1, 400),
     np.arcsin, '[-1, 1]', '[-π/2, π/2]'),
]

for ax, (name, x_vals, fn, dom, rng) in zip(axes.flat, functions):
    y_vals = fn(x_vals)
    ax.plot(x_vals, y_vals, color='steelblue', linewidth=2)
    ax.set_title(f'{name}\nDomain: {dom}  |  Range: {rng}', fontsize=9)
    ax.set_xlabel('x')
    ax.set_ylabel('f(x)')
    # Shade the valid domain
    ax.axhline(0, color='black', linewidth=0.5)
    ax.axvline(0, color='black', linewidth=0.5)

plt.suptitle('Domain and Range for Common Functions', fontsize=13, fontweight='bold')
plt.tight_layout()
plt.show()

# --- Mathematical Formulation: Determining range numerically ---
import numpy as np

def numerical_range(f, domain_start, domain_end, n_samples=10000):
    """
    Estimate the range of function f over a domain interval.
    Uses dense sampling — gives approximate min and max of the range.
    
    Args:
        f: callable, function from reals to reals
        domain_start, domain_end: float, domain interval
        n_samples: int, number of sample points
    Returns:
        (min_val, max_val): approximate range bounds
    """
    x = np.linspace(domain_start, domain_end, n_samples)
    y = f(x)
    # Filter out nan/inf (undefined points)
    y_valid = y[np.isfinite(y)]
    if len(y_valid) == 0:
        return None, None
    return y_valid.min(), y_valid.max()

# Test on known functions
test_cases = [
    ('x²  on [-3, 3]',  lambda x: x**2,   -3, 3),
    ('sin(x) on [-2π, 2π]', np.sin,       -2*np.pi, 2*np.pi),
    ('log(x) on [0.01, 10]', np.log,       0.01, 10),
    ('1/x on [0.1, 5]', lambda x: 1/x,    0.1, 5),
]

for name, f, a, b in test_cases:
    lo, hi = numerical_range(f, a, b)
    print(f"Range of {name}: [{lo:.4f}, {hi:.4f}]")

# --- Implementation: Domain-aware function wrapper ---
import numpy as np

class DomainAwareFunction:
    """
    Wraps a mathematical function with explicit domain checking.
    Raises ValueError for inputs outside the domain.
    Provides a safe vectorized apply method.
    """
    
    def __init__(self, f, domain_predicate, name='f', domain_description='unknown'):
        """
        Args:
            f: callable, the underlying function
            domain_predicate: callable, returns True if x is in domain
            name: str, function name for error messages
            domain_description: str, human-readable domain description
        """
        self.f = f
        self.domain_predicate = domain_predicate
        self.name = name
        self.domain_description = domain_description
    
    def __call__(self, x):
        """Apply function, raising ValueError if x is outside domain."""
        x = np.asarray(x, dtype=float)
        valid = self.domain_predicate(x)
        if not np.all(valid):
            bad = x[~valid] if x.ndim > 0 else x
            raise ValueError(
                f"{self.name}: input {bad} outside domain ({self.domain_description})"
            )
        return self.f(x)
    
    def safe_apply(self, x, fill_value=np.nan):
        """Apply function, returning fill_value for out-of-domain inputs."""
        x = np.asarray(x, dtype=float)
        result = np.full_like(x, fill_value)
        valid = self.domain_predicate(x)
        result[valid] = self.f(x[valid])
        return result

# Create domain-aware versions of common functions
sqrt_safe = DomainAwareFunction(
    np.sqrt, lambda x: x >= 0, name='sqrt', domain_description='x >= 0'
)
log_safe = DomainAwareFunction(
    np.log, lambda x: x > 0, name='log', domain_description='x > 0'
)

# Demonstrate safe_apply with mixed valid/invalid inputs
test_inputs = np.array([-4, -1, 0, 1, 4, 9, 16])

print("Input:", test_inputs)
print("sqrt_safe:", sqrt_safe.safe_apply(test_inputs))   # nan for negatives
print("log_safe: ", log_safe.safe_apply(test_inputs))    # nan for non-positives

# --- Experiment 1: What happens when you violate a domain? ---
# Hypothesis: NumPy silently handles domain violations with nan/inf rather than erroring.
# Try: change which function and which values you test.
import numpy as np

print("Domain violations and NumPy's responses:")
print(f"  log(0)    = {np.log(0)}")
print(f"  log(-1)   = {np.log(-1)}")
print(f"  sqrt(-1)  = {np.sqrt(-1)}")
print(f"  1/0       = {1.0/0.0 if False else 'ZeroDivisionError — use np.float64'}")  
print(f"  np.float64(1)/np.float64(0) = {np.float64(1)/np.float64(0)}")
print(f"  arcsin(2) = {np.arcsin(2)}")

# The silent nan/inf is DANGEROUS in ML — it propagates through all downstream ops
x = np.array([1.0, 0.0, -1.0, 4.0])
result = np.log(x)  # produces nan for non-positive values
print("\nlog([1, 0, -1, 4]) =", result)
print("sum =>", np.sum(result))  # NaN poisons everything!
print("\nLesson: always validate domain BEFORE applying the function.")

# --- Experiment 2: Injective, surjective, bijective ---
# Hypothesis: We can test these properties numerically for functions on finite sets.
# Try: change the function and the domain size.

import numpy as np

DOMAIN = list(range(1, 8))  # {1, 2, 3, 4, 5, 6, 7}  # <-- try changing this

def test_properties(f, domain, codomain=None):
    """Test injective and surjective properties numerically."""
    outputs = [f(x) for x in domain]
    
    # Injective: all outputs are distinct
    injective = len(outputs) == len(set(outputs))
    
    # Surjective: only testable if codomain is known
    surjective = None
    if codomain is not None:
        surjective = set(outputs) == set(codomain)
    
    return injective, surjective, outputs

# Test several functions
tests = [
    ('x → x² mod 7',  lambda x: (x**2) % 7, None),
    ('x → x mod 7',   lambda x: x % 7,      list(range(7))),
    ('x → 2x mod 7',  lambda x: (2*x) % 7,  list(range(7))),
    ('x → 3x mod 7',  lambda x: (3*x) % 7,  list(range(7))),
]

for name, f, cod in tests:
    inj, surj, out = test_properties(f, DOMAIN, cod)
    print(f"{name}:")
    print(f"  Outputs: {out}")
    print(f"  Injective: {inj}  |  Surjective: {surj}")

# --- Mini Project: Domain Boundary Detector ---
# Problem: Many ML preprocessing functions have hidden domain restrictions.
#          Build a tool that automatically detects where a function fails
#          and visualizes the valid and invalid regions.
# Dataset: Dense sample grid over a range containing edge cases.
# Task: For each test function, detect valid/invalid regions and plot them.

import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-whitegrid')

def detect_domain(f, x_min, x_max, n=5000):
    """
    Detect valid (finite) and invalid (nan/inf) input regions.
    Returns x_valid, y_valid, x_invalid.
    """
    x = np.linspace(x_min, x_max, n)
    with np.errstate(divide='ignore', invalid='ignore'):
        y = f(x)
    finite_mask = np.isfinite(y)
    return x[finite_mask], y[finite_mask], x[~finite_mask]

# Test on functions with interesting domain structures
funcs = [
    ('log(x² - 1)',  lambda x: np.log(x**2 - 1),  -3, 3),
    ('sqrt(sin(x))', lambda x: np.sqrt(np.sin(x)), -2*np.pi, 2*np.pi),
    ('1/(x²-3x+2)', lambda x: 1/(x**2 - 3*x + 2), -1, 4),
    ('arcsin(x/2)', lambda x: np.arcsin(x/2),      -3, 3),
]

fig, axes = plt.subplots(2, 2, figsize=(14, 8))

for ax, (name, f, a, b) in zip(axes.flat, funcs):
    xv, yv, xi = detect_domain(f, a, b)
    ax.plot(xv, yv, color='steelblue', linewidth=1.5, label='Defined')
    ax.scatter(xi, np.zeros_like(xi), color='crimson', s=2, alpha=0.3, label='Undefined')
    ax.axhline(0, color='black', linewidth=0.5)
    ax.set_title(f'f(x) = {name}')
    ax.set_xlabel('x')
    ax.set_ylabel('f(x)')
    ax.legend(fontsize=8)

plt.suptitle('Domain Boundary Detection', fontsize=13, fontweight='bold')
plt.tight_layout()
plt.show()