Data displays and the mean as a fair share

"""The mean as a fair share: levelling towers of cubes, one cube at a time.

Each child in a group has built a tower of cubes. To share fairly, we
repeatedly move one cube from a tallest tower to a shortest tower, until no
move can make things fairer. The program prints every step and compares the
final level with total / number of towers. Then it finds the mean of some
measurements in quarter centimetres, exactly, with fractions.

Runs unchanged in the browser (Pyodide) using only the standard library.
"""

import textwrap
from fractions import Fraction

def level_once(towers):
    """Move one cube from a tallest tower to a shortest tower, if that helps.

    Returns the new list of towers, or None when the tallest and shortest
    towers differ by at most one cube (no move can make it fairer).
    """
    tall = towers.index(max(towers))
    short = towers.index(min(towers))
    if towers[tall] - towers[short] <= 1:
        return None
    new = list(towers)
    new[tall] -= 1
    new[short] += 1
    return new

def level(towers):
    """Level the towers step by step; return the list of all stages."""
    stages = [list(towers)]
    while True:
        nxt = level_once(stages[-1])
        if nxt is None:
            return stages
        stages.append(nxt)

def mean(values):
    """The mean as an exact fraction: total divided by how many values."""
    if not values:
        raise ValueError("the mean of no values is not defined")
    return Fraction(sum(values), len(values))

def show(values):
    """Format a list of numbers or fractions compactly."""
    return " ".join(str(v) for v in values)

def main():
    names = ["Ana", "Ben", "Chen", "Dina"]
    towers = [4, 6, 8, 2]
    print("Towers:", ", ".join(f"{n} {t}" for n, t in zip(names, towers)))
    stages = level(towers)
    for i, stage in enumerate(stages[1:], start=1):
        print(f"  move {i}: {show(stage)}")
    m = mean(towers)
    answer = "yes" if m in towers else "no"
    print(f"Level {stages[-1][0]} = total {sum(towers)} / {len(towers)} towers"
          f" = {m}. Is {m} one of the towers? {answer}")
    print()
    odd = [3, 7, 2, 6]
    stages = level(odd)
    print(f"Towers {show(odd)}: after {len(stages) - 1} moves they are"
          f" {show(stages[-1])}.")
    print(f"They cannot be level with whole cubes: the fair share is"
          f" {sum(odd)}/{len(odd)} = {mean(odd)} = {float(mean(odd))}.")
    print()
    beans = [Fraction(9, 4), Fraction(5, 2), Fraction(5, 2), Fraction(11, 4),
             Fraction(13, 4), Fraction(7, 2), Fraction(7, 2), Fraction(15, 4)]
    print("Bean seedlings, heights in cm:", show(beans))
    total = sum(beans)
    mb = mean(beans)
    print(f"Total {total} cm, so the mean is {total} / {len(beans)}"
          f" = {mb} cm.")
    print(f"Check: mean x number of values = {mb * len(beans)} = total.")
    print(f"Is the mean one of the heights? {'yes' if mb in beans else 'no'}")
    print()
    print(textwrap.fill(
        "Epistemic status: exact. Whole cubes and fractions are computed "
        "exactly, with no rounding. The program checks these data sets; the "
        "lesson and the Lean module prove that levelling always ends at "
        "total / number of towers when the towers can be levelled.",
        width=78,
    ))

if __name__ == "__main__":
    main()

"""How a bar chart can mislead: an axis that does not start at zero.

Two schools collected paper for recycling: Riverside 52 kg and Hilltop
48 kg. The program draws the two bars in text twice - once with the axis
starting at 0 and once starting at 40 - and computes how many times taller
one bar *looks* than the other for several starting values. Finally it
checks, for every whole-number case up to 60, that starting the axis above
zero always makes the bigger bar look relatively bigger than it is.

Runs unchanged in the browser (Pyodide) using only the standard library.
"""

import textwrap
from fractions import Fraction

SCHOOLS = [("Riverside", 52), ("Hilltop", 48)]

def drawn_height(value, base):
    """The height of a bar when the axis starts at `base` instead of 0."""
    if value < base:
        raise ValueError("the bar would start below the axis")
    return value - base

def apparent_ratio(big, small, base):
    """How many times taller the bigger bar looks, as an exact fraction."""
    return Fraction(drawn_height(big, base), drawn_height(small, base))

def text_bar(value, base, per_char):
    """A bar of '#' characters: one '#' for every `per_char` units above base."""
    return "#" * int(drawn_height(value, base) / per_char)

def exaggeration_always(limit):
    """Check apparent ratio > true ratio for all 0 < b < c < a <= limit.

    Returns (number of cases checked, list of failures).
    """
    checked, failures = 0, []
    for a in range(1, limit + 1):
        for c in range(1, a):
            for b in range(1, c):
                checked += 1
                if not apparent_ratio(a, c, b) > Fraction(a, c):
                    failures.append((a, b, c))
    return checked, failures

def main():
    for base, per_char in ((0, 2), (40, Fraction(1, 3))):
        print(f"Axis starting at {base} kg:")
        for name, kg in SCHOOLS:
            print(f"  {name:<9} {kg} kg |{text_bar(kg, base, per_char)}")
    print()
    print("Axis starts at   bars drawn   looks this many times taller")
    for base in (0, 20, 30, 40, 44, 46, 47):
        r = apparent_ratio(52, 48, base)
        print(f"{base:>14}   {52 - base:>4} : {48 - base:<4}"
              f"   {str(r):>6} = {float(r):.2f}")
    print("True ratio: 52/48 = 13/12, only about 1.08.")
    print()
    checked, failures = exaggeration_always(60)
    print(f"Every whole-number case 0 < b < c < a <= 60: {checked} cases.")
    print(f"Cases where the raised axis did not exaggerate: {len(failures)}.")
    print()
    print(textwrap.fill(
        "Epistemic status: exact arithmetic with fractions. The table is "
        "exact for these two schools, and the final check covers every "
        "whole-number case up to 60 (finite evidence only). The lesson's "
        "argument and the Lean module prove the rule for all whole numbers.",
        width=78,
    ))

if __name__ == "__main__":
    main()