Chapter 21 — The History of Numbers

# --- Visualization: The number line tower ---
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
plt.style.use('seaborn-v0_8-whitegrid')

fig, axes = plt.subplots(5, 1, figsize=(12, 8), sharex=True)

XMIN, XMAX = -4, 5
x_line = np.linspace(XMIN, XMAX, 1000)

configs = [
    # (label, color, points to mark)
    ('ℕ  Natural', '#4CAF50', [0, 1, 2, 3, 4]),
    ('ℤ  Integer', '#2196F3', [-3, -2, -1, 0, 1, 2, 3, 4]),
    ('ℚ  Rational', '#FF9800', [-3, -2, -1, -0.5, 0, 0.5, 1, 4/3, 2, 3, 4]),
    ('ℝ  Real', '#9C27B0', None),   # continuous
    ('ℂ  Complex', '#F44336', None), # note: shown as real axis only
]

for ax, (label, color, pts) in zip(axes, configs):
    ax.axhline(0, color='gray', linewidth=0.5)
    ax.set_yticks([])
    ax.set_ylabel(label, fontsize=9, rotation=0, labelpad=80, va='center')
    ax.set_xlim(XMIN, XMAX)
    ax.set_ylim(-0.5, 0.5)

    if pts is not None:
        ax.scatter(pts, [0]*len(pts), color=color, s=60, zorder=3)
        # Show special points
        for p in pts:
            ax.annotate(str(round(p, 2)), (p, 0.15), ha='center', fontsize=7, color=color)
    else:
        # Draw a dense line for continuous sets
        ax.plot(x_line, np.zeros_like(x_line), color=color, linewidth=4, alpha=0.6)
        if label.startswith('ℝ'):
            # Mark √2 and π
            for val, name in [(np.sqrt(2), '√2'), (np.pi, 'π'), (-np.sqrt(2), '-√2')]:
                ax.scatter([val], [0], color='black', s=40, zorder=4)
                ax.annotate(name, (val, 0.2), ha='center', fontsize=7)

axes[-1].set_xlabel('Value')
fig.suptitle('The Tower of Number Systems: Each Row Contains All Rows Above It', fontsize=12, y=1.01)
plt.tight_layout()
plt.show()

# --- Implementation: Number system types and closure tests ---
import math
from fractions import Fraction

def test_closure(operation_name, operands, operation_fn, type_check_fn):
    """
    Test whether a set of values is closed under an operation.

    Args:
        operation_name: str, human label
        operands: list of values representing the set
        operation_fn: function(a, b) -> result
        type_check_fn: function(result) -> bool, True if result is still in set

    Returns:
        None (prints results)
    """
    print(f"\nClosure under {operation_name}:")
    closed = True
    for a in operands:
        for b in operands:
            try:
                result = operation_fn(a, b)
                if not type_check_fn(result):
                    print(f"  FAILS: {a} op {b} = {result} (exits the set)")
                    closed = False
            except (ZeroDivisionError, ValueError):
                print(f"  FAILS: {a} op {b} = undefined")
                closed = False
    if closed:
        print(f"  CLOSED")


# Natural numbers: test subtraction
naturals = [0, 1, 2, 3, 4, 5]
test_closure(
    "subtraction (ℕ)",
    naturals,
    lambda a, b: a - b,
    lambda r: r >= 0 and isinstance(r, int)
)

# Integers: test division
integers = [-2, -1, 1, 2, 3]
test_closure(
    "division (ℤ)",
    integers,
    lambda a, b: a / b,
    lambda r: isinstance(r, int) or r == int(r)
)

# Rationals: test division (using Fraction for exact arithmetic)
rationals = [Fraction(1, 2), Fraction(3, 4), Fraction(2, 1)]
test_closure(
    "division (ℚ, using Fraction)",
    rationals,
    lambda a, b: a / b,
    lambda r: isinstance(r, Fraction)
)

print("\n--- Python's number types ---")
print(f"int(5):            {type(5)}       — approximates ℤ")
print(f"float(5.0):        {type(5.0)}     — approximates ℝ (imperfectly)")
print(f"complex(1+2j):     {type(1+2j)}    — exactly ℂ")
print(f"Fraction(1,3):     {type(Fraction(1,3))} — exactly ℚ")
print(f"Fraction(1,3):     {Fraction(1,3)} — exact representation")

# --- Experiment 1: Rational arithmetic is exact; float is not ---
# Hypothesis: Fraction objects accumulate no rounding error; floats do
# Try changing: the number of terms N

from fractions import Fraction

N = 100  # <-- modify this

# Sum 1/1 + 1/2 + 1/3 + ... + 1/N
float_sum = sum(1/k for k in range(1, N+1))
exact_sum = sum(Fraction(1, k) for k in range(1, N+1))

print(f"Float sum:    {float_sum}")
print(f"Exact sum:    {float(exact_sum):.15f}")
print(f"Error:        {abs(float_sum - float(exact_sum)):.2e}")
print(f"Exact frac:   {exact_sum}")

# --- Experiment 2: How many rationals fit between 0 and 1? ---
# Hypothesis: infinitely many, but we can enumerate pairs (p, q)
# Try changing: MAX_DENOM

MAX_DENOM = 10  # <-- modify this

rationals_in_01 = set()
for q in range(1, MAX_DENOM + 1):
    for p in range(0, q + 1):
        rationals_in_01.add(Fraction(p, q))

sorted_rats = sorted(rationals_in_01)
print(f"Distinct rationals in [0,1] with denominator ≤ {MAX_DENOM}: {len(sorted_rats)}")

# Plot them on a line
fig, ax = plt.subplots(figsize=(12, 2))
x_vals = [float(r) for r in sorted_rats]
ax.scatter(x_vals, [0]*len(x_vals), s=20, alpha=0.6, color='steelblue')
ax.set_xlim(-0.05, 1.05)
ax.set_yticks([])
ax.set_xlabel('Value')
ax.set_title(f'Rationals p/q in [0,1] with q ≤ {MAX_DENOM} — dense but countable')
plt.tight_layout()
plt.show()

# --- Mini Project: Number System Explorer ---
# Problem: Build a tool that takes a numeric expression and identifies
#          which number system its result lives in.
# Dataset: Generated test cases
# Task: Classify results and visualize the distribution

import math
from fractions import Fraction

def classify_number(x):
    """
    Classify a number into the smallest number system that contains it.

    Args:
        x: a Python number (int, float, complex, Fraction)

    Returns:
        str: one of 'Natural', 'Integer', 'Rational', 'Real', 'Complex'
    """
    # TODO: implement classification logic
    # Hint: check isinstance, then check for negativity, then check
    # if float can be expressed as Fraction with small denominator
    pass

# Test cases — your classifier should label each correctly
test_cases = [
    (42, "Natural"),
    (-7, "Integer"),
    (Fraction(1, 3), "Rational"),
    (0.5, "Rational"),
    (math.sqrt(2), "Real"),
    (math.pi, "Real"),
    (1 + 2j, "Complex"),
    (complex(0, 1), "Complex"),
]

print("Value                 Expected     Got")
print("-" * 50)
for val, expected in test_cases:
    got = classify_number(val)
    status = "✓" if got == expected else "✗"
    print(f"{str(val):<22} {expected:<12} {got} {status}")