One thing after another

"""When does the order of two actions matter?

For every pair of number actions (add 2, add 5, double, triple, square, do
nothing) the program checks whether 'f, then g' and 'g, then f' give the
same result for every starting number from 0 to 20. Then it does the same
for four moves of an L-shaped tile on a grid (quarter turn, half turn, and
two flips), comparing the positions the tile ends up in. The tables show
that swapping the order usually matters, and pick out the special pairs
for which it does not.
"""

import textwrap

NUMBER_ACTIONS = {
    "add 2": lambda n: n + 2,
    "add 5": lambda n: n + 5,
    "double": lambda n: 2 * n,
    "triple": lambda n: 3 * n,
    "square": lambda n: n * n,
    "do nothing": lambda n: n,
}
SHORT = ["+2", "+5", "x2", "x3", "sq", "id"]
STARTS = range(0, 21)

MOVES = {
    "quarter turn": lambda p: (p[1], -p[0]),
    "half turn": lambda p: (-p[0], -p[1]),
    "flip left-right": lambda p: (-p[0], p[1]),
    "flip up-down": lambda p: (p[0], -p[1]),
}
L_SHAPE = [(0, 2), (0, 1), (0, 0), (1, 0)]

def chain(f, g):
    """The chain 'f, then g'."""
    return lambda x: g(f(x))

def first_difference(f, g, starts=STARTS):
    """First start where 'f, then g' and 'g, then f' differ, or None."""
    for n in starts:
        if chain(f, g)(n) != chain(g, f)(n):
            return n
    return None

def place(move, shape=L_SHAPE):
    """Where the tile is after a move: the set of grid points it covers."""
    return frozenset(move(p) for p in shape)

def moves_commute(f, g, shape=L_SHAPE):
    """Do 'f, then g' and 'g, then f' put the tile in the same place?"""
    return place(chain(f, g), shape) == place(chain(g, f), shape)

def main():
    print("Number actions: is 'f, then g' the same as 'g, then f' for every")
    print("start from 0 to 20?   (= same, x different)")
    print(" " * 12 + "".join(f"{s:>5}" for s in SHORT))
    for name, f in NUMBER_ACTIONS.items():
        marks = ["=" if first_difference(f, g) is None else "x"
                 for g in NUMBER_ACTIONS.values()]
        print(f"{name:<12}" + "".join(f"{m:>5}" for m in marks))
    add5, double = NUMBER_ACTIONS["add 5"], NUMBER_ACTIONS["double"]
    n = first_difference(add5, double)
    print(f"add 5 and double, from {n}: add 5 first gives"
          f" {chain(add5, double)(n)}, double first gives"
          f" {chain(double, add5)(n)}.")
    print()
    print("Moves of an L-shaped tile: same place in either order?")
    names = list(MOVES)
    print(" " * 16 + "".join(f"{m.split()[0]:>11}" for m in names))
    print(" " * 16 + "".join(f"{m.split()[1]:>11}" for m in names))
    for name, f in MOVES.items():
        marks = ["=" if moves_commute(f, g) else "x" for g in MOVES.values()]
        print(f"{name:<16}" + "".join(f"{m:>11}" for m in marks))
    print()
    print(textwrap.fill(
        "Epistemic status: exact and exhaustive for what was checked - the "
        "starting numbers 0 to 20, and the four moves of one tile. An 'x' is "
        "a proof that the order matters (a counterexample was found). An '=' "
        "for numbers is evidence only; the lesson explains why, for example, "
        "two additions can always be swapped.",
        width=78,
    ))

if __name__ == "__main__":
    main()

"""Undoing chains of actions: reverse order versus the same order.

Six actions that can be undone (add 3, subtract 2, add 5, double, halve,
triple) are chained together in every possible way: 36 chains of two steps
and 216 chains of three. Each chain is run on the starting numbers 0 to 10,
then undone in two ways - undoing the steps in reverse order (last step
first), and undoing them in the same order as they were done. Fractions are
used, so halving is exact. Undoing in reverse order always gets back to the
start; undoing in the same order often does not.
"""

import textwrap
from fractions import Fraction
from itertools import product

# name: (do it, undo it)
ACTIONS = {
    "add 3": (lambda x: x + 3, lambda x: x - 3),
    "subtract 2": (lambda x: x - 2, lambda x: x + 2),
    "add 5": (lambda x: x + 5, lambda x: x - 5),
    "double": (lambda x: 2 * x, lambda x: x / 2),
    "halve": (lambda x: x / 2, lambda x: 2 * x),
    "triple": (lambda x: 3 * x, lambda x: x / 3),
}
STARTS = [Fraction(n) for n in range(11)]

def run(names, x):
    """Do the named actions one after another, first to last."""
    for name in names:
        x = ACTIONS[name][0](x)
    return x

def undo_reverse(names, x):
    """Undo the steps in reverse order: the last step first."""
    for name in reversed(names):
        x = ACTIONS[name][1](x)
    return x

def undo_same_order(names, x):
    """Undo the steps in the order they were done (the mistake)."""
    for name in names:
        x = ACTIONS[name][1](x)
    return x

def always_back(names, undo):
    """Does this way of undoing return every start to where it began?"""
    return all(undo(names, run(names, x)) == x for x in STARTS)

def count_successes(length):
    """Number of chains of this length, and how many each method undoes."""
    chains = list(product(ACTIONS, repeat=length))
    reverse = sum(always_back(c, undo_reverse) for c in chains)
    same = sum(always_back(c, undo_same_order) for c in chains)
    return len(chains), reverse, same

def show(x):
    """A fraction as 5 or 11/2."""
    return str(x)

def main():
    chain = ("add 5", "double")
    start = Fraction(3)
    end = run(chain, start)
    print(f"From {start}: add 5, then double, reaches {end}.")
    print(f"Undo in reverse order (halve, then subtract 5):"
          f" {end} -> {show(undo_reverse(chain, end))}. Back at the start.")
    print(f"Undo in the same order (subtract 5, then halve):"
          f" {end} -> {show(undo_same_order(chain, end))}. Not {start}!")
    print()
    print("Every chain of the six actions, run on the starts 0 to 10:")
    print("steps  chains  undone in reverse order  undone in the same order")
    for length in (2, 3):
        total, reverse, same = count_successes(length)
        print(f"{length:>5}  {total:>6}  {reverse:>23}  {same:>24}")
    print("The same order works only for special chains: for example when")
    print("every step is an addition, or every step is a multiplication.")
    print()
    print(textwrap.fill(
        "Epistemic status: exact (fractions) and exhaustive for these six "
        "actions, chains of two and three steps, and starting numbers 0 to "
        "10. It is strong evidence, not a proof; the socks-and-shoes rule "
        "is proved in the lesson for every chain of actions that can be "
        "undone.",
        width=78,
    ))

if __name__ == "__main__":
    main()