Ratios, rates and proportional reasoning

"""Is this table proportional? A classifier that uses exact fractions.

A table of pairs (x, y) comes from a proportional relationship y = kx when
every row with x != 0 has the same ratio y/x and every row with x = 0 has
y = 0. It comes from a straight line when the slope between consecutive rows
is constant. The experiment classifies six real-world tables, then shows the
practical difference: in a proportional table you may add two rows to get a
third, and in a merely linear table you may not.
"""

from fractions import Fraction

TABLES = {
    "millet flour (people, cups)": [(4, 6), (6, 9), (10, 15), (14, 21)],
    "euros to CFA francs": [(1, "655.957"), (20, "13119.14"),
                            (50, "32797.85")],
    "taxi (km, fare)": [(1, 350), (2, 500), (5, 950), (8, 1400)],
    "square (side, perimeter)": [(1, 4), (2, 8), (5, 20)],
    "square (side, area)": [(1, 1), (2, 4), (3, 9), (5, 25)],
    "ages (Amara, brother)": [(5, 8), (10, 13), (20, 23)],
}

def as_pairs(table):
    """Convert table entries to exact Fractions (strings allowed)."""
    return [(Fraction(x), Fraction(y)) for x, y in table]

def constant_of_proportionality(table):
    """Return k if y = k*x for every row, else None."""
    pairs = as_pairs(table)
    ratios = {y / x for x, y in pairs if x != 0}
    if len(ratios) != 1 or any(y != 0 for x, y in pairs if x == 0):
        return None
    return ratios.pop()

def is_linear(table):
    """True if the slopes between consecutive rows (sorted by x) agree."""
    pairs = sorted(as_pairs(table))
    slopes = {(y2 - y1) / (x2 - x1)
              for (x1, y1), (x2, y2) in zip(pairs, pairs[1:])}
    return len(slopes) <= 1

def classify(table):
    """'proportional', 'linear, not proportional' or 'not linear'."""
    if constant_of_proportionality(table) is not None:
        return "proportional"
    if is_linear(table):
        return "linear, not proportional"
    return "not linear"

def add_rows(table, i, j):
    """Add rows i and j of a table: (x_i + x_j, y_i + y_j)."""
    pairs = as_pairs(table)
    return pairs[i][0] + pairs[j][0], pairs[i][1] + pairs[j][1]

def taxi_fare(km):
    """The rule behind the taxi table: 200 to start, 150 per km."""
    return 200 + 150 * Fraction(km)

def main():
    print(f"{'table':<29}{'classification':<26}k = y/x")
    for name, table in TABLES.items():
        k = constant_of_proportionality(table)
        shown = "-" if k is None else (
            str(k) if k.denominator == 1 else f"{float(k):g}")
        print(f"{name:<29}{classify(table):<26}{shown}")
    print()
    print("Adding two rows of a table:")
    x, y = add_rows(TABLES["millet flour (people, cups)"], 0, 1)
    print(f"  flour: 4 people + 6 people -> {x} people need {y} cups;")
    print(f"         the rule y = 3x/2 gives {Fraction(3, 2) * x}: it works.")
    x, y = add_rows(TABLES["taxi (km, fare)"], 0, 1)
    print(f"  taxi:  1 km + 2 km -> adding fares predicts {y} for {x} km,")
    print(f"         but the real fare is {taxi_fare(x)}: the start fee of")
    print("         200 was counted twice.")
    print()
    print("Epistemic status: exact arithmetic on the rows shown. A table only")
    print("samples a relationship: these checks cannot see what happens")
    print("between or beyond the rows. Knowing the rule (y = kx) is what")
    print("makes a relationship proportional.")

if __name__ == "__main__":
    main()

"""Percentage changes multiply: exact arithmetic with fractions.

A rise of p% multiplies an amount by 1 + p/100 and a fall of p% by
1 - p/100. So "up p%, then down p%" multiplies by (1 + p/100)(1 - p/100),
which is 1 - (p/100)**2: always a little less than 1. This experiment
computes these factors exactly with Python's Fraction type, searches for the
pairs of changes where simply adding the percentages happens to work, finds
the fall that undoes a rise (100p/(100 + p) percent), and compares five 10%
rises with one 50% rise.
"""

from fractions import Fraction

def factor(p):
    """The multiplier for a change of p percent (p may be negative)."""
    return 1 + Fraction(p) / 100

def combined(*changes):
    """The single multiplier equivalent to several percentage changes."""
    total = Fraction(1)
    for p in changes:
        total *= factor(p)
    return total

def as_percent_change(multiplier):
    """Turn a multiplier such as 99/100 into a percentage change (-1)."""
    return (Fraction(multiplier) - 1) * 100

def undo_rise(p):
    """The percentage fall that exactly undoes a rise of p percent."""
    p = Fraction(p)
    if p <= -100:
        raise ValueError("a fall of 100% or more cannot be undone")
    return 100 * p / (100 + p)

def when_adding_works(low, high):
    """Whole-number pairs (p, q) in range where adding the percentages works.

    Adding guesses the multiplier 1 + (p + q)/100; the true multiplier is
    (1 + p/100)(1 + q/100) = 1 + (p + q)/100 + pq/10000. Returns the list of
    pairs where the guess is exactly right, and the number of pairs tried.
    """
    hits = []
    tried = 0
    for p in range(low, high + 1):
        for q in range(low, high + 1):
            tried += 1
            if combined(p, q) == factor(p + q):
                hits.append((p, q))
    return hits, tried

def fmt(x):
    """Show a Fraction as a decimal when it is one, else as a fraction."""
    x = Fraction(x)
    if x.denominator == 1:
        return str(x.numerator)
    if all(p in (2, 5) for p in _prime_factors(x.denominator)):
        return f"{float(x):.6f}".rstrip("0")
    return f"{x} (about {float(x):.2f})"

def _prime_factors(n):
    """Prime factors of n > 0 (with repetition)."""
    out, d = [], 2
    while d * d <= n:
        while n % d == 0:
            out.append(d)
            n //= d
        d += 1
    if n > 1:
        out.append(n)
    return out

def main():
    print("Up p% then down p%: multiplier (1 + p/100)(1 - p/100)")
    print("    p    multiplier    overall change")
    for p in [5, 10, 20, 25, 50, 100]:
        m = combined(p, -p)
        print(f"  {p:3d}%   {fmt(m):>10}    {fmt(as_percent_change(m)):>8}%")
    hits, tried = when_adding_works(-99, 100)
    zero = all(p == 0 or q == 0 for p, q in hits)
    print(f"Adding p% and q% gives the right answer for {len(hits)} of "
          f"{tried} pairs")
    print(f"  (whole p, q in -99..100); every one has p = 0 or q = 0: {zero}")
    print()
    print("The fall that undoes a rise of p%:")
    for p in [10, 25, 50, 100, 300]:
        print(f"  rise {p:3d}%  ->  fall {fmt(undo_rise(p))}%")
    print()
    five = combined(10, 10, 10, 10, 10)
    print(f"Five rises of 10%: multiplier {fmt(five)}, "
          f"a rise of {fmt(as_percent_change(five))}%, not 50%.")
    print()
    print("Epistemic status: exact rational arithmetic. The search is")
    print("exhaustive for 40,000 whole-number pairs only; that adding works")
    print("exactly when pq = 0, for every p and q, follows from the algebra")
    print("(1 + p/100)(1 + q/100) = 1 + (p + q)/100 + pq/10000 in the lesson.")

if __name__ == "__main__":
    main()