x̄ - > Bridging Real Analysis and Python

Bridging Real Analysis and Python

When you think of Real Analysis, you usually picture grueling proofs, \( \epsilon\)-\( \delta \) limits, and infinite sequences. Python, on the other hand, is computational. While Python cannot replace rigorous proofs, it is extremely powerful for visualizing, approximating, and verifying analytical concepts using tools like SymPy, NumPy, and Matplotlib.

Here is how you can bridge abstract real analysis with concrete Python implementations. Check my GITHUB repo for code https://github.com/Zekeriya-Ui/Zekeriya-Ui/blob/main/Real_analysis_in_python.ipynb

---

1. Limits and Continuity (\( \epsilon\)-\( \delta \) Visualized)

A function \( f(x) \) is continuous at \( c \) if for every \( \epsilon > 0 \), there exists \( \delta > 0 \) such that:

\( |x - c| < \delta \Rightarrow |f(x) - f(c)| < \epsilon \)

Symbolic Limit (SymPy)

import sympy as sp

x = sp.Symbol('x')
f = (x**2 - 1) / (x - 1)

limit_value = sp.limit(f, x, 1)
print("The symbolic limit is:", limit_value)

Visualization (Matplotlib)

import numpy as np
import matplotlib.pyplot as plt

f_num = lambda x: (x**2 - 1) / (x - 1)

c, L = 1, 2
epsilon, delta = 0.5, 0.25

x_vals = np.linspace(0.5, 1.5, 400)
y_vals = f_num(x_vals)

plt.plot(x_vals, y_vals)
plt.axvline(c, linestyle='--')
plt.axhline(L, linestyle='--')

plt.axhspan(L - epsilon, L + epsilon, alpha=0.15)
plt.axvspan(c - delta, c + delta, alpha=0.15)

plt.title("Epsilon-Delta Visualization")
plt.show()

---

2. Sequences and Convergence

Consider the sequence:

\( a_n = \left(1 + \frac{1}{n}\right)^n \rightarrow e \)

import numpy as np
import matplotlib.pyplot as plt

n = np.arange(1, 100)
a_n = (1 + 1/n)**n

plt.stem(n, a_n)
plt.axhline(np.e, linestyle='--')
plt.title("Convergence to e")
plt.show()

---

3. Riemann Integration

Approximate integrals numerically using Riemann sums:

def riemann_sum(f, a, b, n):
    dx = (b - a) / n
    x = np.linspace(a, b, n)
    return np.sum(f(x) * dx)

f = lambda x: x**2
print(riemann_sum(f, 0, 1, 100))

---

4. Taylor Series and Uniform Convergence

Taylor polynomials approximate functions like \( \sin(x) \).

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

x = sp.Symbol('x')
f = sp.sin(x)

x_vals = np.linspace(-5, 5, 200)
plt.plot(x_vals, np.sin(x_vals), label='sin(x)')

for deg in [1, 3, 5, 7]:
    poly = sp.series(f, x, 0, deg+1).removeO()
    func = sp.lambdify(x, poly, 'numpy')
    plt.plot(x_vals, func(x_vals), label=f'Degree {deg}')

plt.legend()
plt.title("Taylor Approximation")
plt.show()

---

Core Libraries for Analytical Python

• SymPy: Symbolic mathematics (limits, derivatives, series)
• NumPy: Efficient numerical computation
• Matplotlib: Visualization
• Mpmath: Arbitrary precision arithmetic

---

Conclusion:
Python does not replace rigorous proofs, but it provides an experimental playground to see real analysis concepts in action—making abstract ideas far more intuitive.