Editing Real Analysis (section)

== <span style="color: #FFFFFF;">Applying</span> ==
'''Implementing fundamental analysis concepts:'''
<syntaxhighlight lang="python">
import math
from typing import Callable, Iterator

# === Epsilon-Delta Verification ===
def verify_continuity_at(f: Callable[[float], float], c: float, epsilon: float,
                          test_delta: float, n_tests: int = 1000) -> dict:
    """
    Empirically search for a δ > 0 such that |x-c| < δ ⟹ |f(x)-f(c)| < ε.
    Illustrates the ε-δ definition (not a formal proof).
    """
    fc = f(c)
    deltas_tried = [test_delta * (0.1 ** k) for k in range(5)]
    for delta in deltas_tried:
        # Test n_tests points in (c-δ, c+δ)
        xs = [c + delta * (2*i/(n_tests-1) - 1) for i in range(n_tests)]
        violations = [x for x in xs if abs(x-c) < delta and abs(f(x)-fc) >= epsilon]
        if not violations:
            return {'epsilon': epsilon, 'delta_found': delta, 'continuous_at': c,
                    'verdict': 'Likely continuous (no violations found)'}
    return {'epsilon': epsilon, 'verdict': 'Violations found — not continuous or need smaller delta'}

# Test continuity of f(x) = x² at c=2
result = verify_continuity_at(lambda x: x**2, c=2.0, epsilon=0.1, test_delta=0.01)
print(result)

# === Sequence Convergence ===
def check_convergence(seq: Iterator[float], limit: float, epsilon: float,
                       max_n: int = 10000) -> dict:
    """Find N such that n > N ⟹ |aₙ - L| < ε."""
    for n, an in enumerate(seq):
        if n > max_n: return {'converges': False, 'N_found': None}
        if abs(an - limit) < epsilon:
            return {'converges': True, 'N': n, 'value_at_N': an}
    return {'converges': False}

# aₙ = 1/n → 0
one_over_n = (1/n for n in range(1, 100001))
print(check_convergence(one_over_n, limit=0, epsilon=0.01))

# === Taylor Series with Remainder ===
def taylor_exp(x: float, n_terms: int) -> tuple[float, float]:
    """Approximate eˣ with n-term Taylor series; compute Lagrange remainder."""
    approx = sum(x**k / math.factorial(k) for k in range(n_terms))
    # Lagrange remainder: R_n = eˢ * x^n / n! for some s between 0 and x
    max_s = abs(x)
    remainder_bound = math.exp(max_s) * abs(x)**n_terms / math.factorial(n_terms)
    return approx, remainder_bound

for n in [3, 5, 10, 15]:
    approx, bound = taylor_exp(1.0, n)
    print(f"n={n}: e≈{approx:.10f}, error≤{bound:.2e}, actual error={abs(approx-math.e):.2e}")

# === Riemann Integration ===
def riemann_integral(f: Callable[[float], float], a: float, b: float, n: int,
                      method='midpoint') -> float:
    """Approximate ∫ₐᵇ f using n-point Riemann sum."""
    dx = (b - a) / n
    if method == 'left':
        xs = [a + i*dx for i in range(n)]
    elif method == 'right':
        xs = [a + (i+1)*dx for i in range(n)]
    else:  # midpoint
        xs = [a + (i + 0.5)*dx for i in range(n)]
    return sum(f(x) * dx for x in xs)

# Verify FTC: ∫₀¹ x² dx = [x³/3]₀¹ = 1/3
for n in [10, 100, 1000, 10000]:
    approx = riemann_integral(lambda x: x**2, 0, 1, n)
    print(f"n={n}: ∫x²dx≈{approx:.6f}, error={abs(approx-1/3):.2e}")
</syntaxhighlight>

; Key texts and theorists
: '''Foundational''' → Cauchy (rigorized limits), Weierstrass (ε-δ definition), Dedekind (real number construction)
: '''Classic textbooks''' → Rudin (''Principles of Mathematical Analysis''), Apostol, Bartle
: '''Lebesgue integration''' → Lebesgue (''Leçons sur l'intégration'', 1904)
: '''Functional analysis''' → Banach, Hilbert — analysis on infinite-dimensional spaces
</div>

<div style="background-color: #8B4500; color: #FFFFFF; padding: 20px; border-radius: 8px; margin-bottom: 15px;">