Mathematics as the Unique Top-Down Projection of Operational Structure: A Structural Theorem from Operatiology and Noology

from fractions import Fraction

NAMES = ("e", "A", "B")

# --- Translation into transformation monoids T(n) (n = 3, 4) -------------
def translation_T(n):
    pts = range(n)
    E = tuple(pts)
    A = tuple(1 if x == 1 else 0 for x in pts)    # fixes p = 0, q = 1
    B = tuple(0 if x == 0 else 1 for x in pts)
    comp = lambda f, g: tuple(f[g[s]] for s in pts)
    return (E, A, B), comp

# --- Translation into M_3(C): the linearised action on C[X], |X| = 3 ---------
def matrix_of(g):                      # column j of the matrix is e_{g(j)}
    return tuple(tuple(1 if g[j] == i else 0 for j in range(3))
                 for i in range(3))
def mmul(M, N):
    return tuple(tuple(sum(M[i][k] * N[k][j] for k in range(3))
                       for j in range(3)) for i in range(3))
(E3, A3, B3), comp3 = translation_T(3)
IMG_M = tuple(matrix_of(g) for g in (E3, A3, B3))

targets = {"T(3)": (translation_T(3)[0], translation_T(3)[1]),
           "T(4)": (translation_T(4)[0], translation_T(4)[1]),
           "M_3": (IMG_M, mmul)}

# Uniqueness of the translated content: the bijection psi_2 o psi_1^{-1}
# (matching the labels e, A, B) preserves composition for every pair of targets.
names = list(targets)
for i in names:
    for j in names:
        (img1, c1), (img2, c2) = targets[i], targets[j]
        eta = {img1[k]: img2[k] for k in range(3)}
        ok = all(eta[c1(a, b)] == c2(eta[a], eta[b])
                 for a in img1 for b in img1)
        print(f"{i} -> {j}: composition preserved: {ok}")
print("sizes of the ambient monoids: |T(3)| =", 3 ** 3,
      "| |T(4)| =", 4 ** 4, "| M_3 is infinite")

# --- Non-simplicity of the algebra generated by psi(Q) in M_3 ----------------
I_, A_, B_ = IMG_M
D = tuple(tuple(A_[i][j] - B_[i][j] for j in range(3)) for i in range(3))
Z = tuple(tuple(0 for _ in range(3)) for _ in range(3))
print("D = A - B:", D)
print("D != 0:", D != Z, "| D*D = 0:", mmul(D, D) == Z,
      "| A*D = D:", mmul(A_, D) == D, "| B*D = D:", mmul(B_, D) == D,
      "| D*A = 0:", mmul(D, A_) == Z, "| D*B = 0:", mmul(D, B_) == Z)

def rank(vecs):
    rows = [[Fraction(x) for x in v] for v in vecs]
    r = 0
    for c in range(len(rows[0])):
        piv = next((i for i in range(r, len(rows)) if rows[i][c] != 0), None)
        if piv is None:
            continue
        rows[r], rows[piv] = rows[piv], rows[r]
        rows[r] = [x / rows[r][c] for x in rows[r]]
        for i in range(len(rows)):
            if i != r and rows[i][c] != 0:
                rows[i] = [a - rows[i][c] * b for a, b in zip(rows[i], rows[r])]
        r += 1
    return r
flat = lambda M: [x for row in M for x in row]
dim_alg, dim_ideal = rank([flat(M) for M in IMG_M]), rank([flat(D)])
print("dim of the algebra spanned by e, A, B:", dim_alg,
      "| dim of the ideal C*D:", dim_ideal,
      "| proper non-zero ideal (not simple):", 0 < dim_ideal < dim_alg)

# --- The exchange A <-> B is realised ------------------------------------
# Four-state model of the admissible-model example: states p, q, r, r' = 0..3
S4 = range(4)
E4, A4, B4 = (0, 1, 2, 3), (0, 1, 0, 0), (0, 1, 1, 1)
c4 = lambda f, g: tuple(f[g[s]] for s in S4)
tau = tau_inv = (1, 0, 2, 3)                  # exchanges p and q (an involution)
print("tau A tau^-1 = B:", c4(tau, c4(A4, tau_inv)) == B4,
      "| tau B tau^-1 = A:", c4(tau, c4(B4, tau_inv)) == A4)
P3 = ((0, 1, 0), (1, 0, 0), (0, 0, 1))       # swaps the two fixed basis vectors
print("matrix conjugation exchanges A and B:",
      mmul(P3, mmul(A_, P3)) == B_ and mmul(P3, mmul(B_, P3)) == A_)

# --- Non-invertibility on states (class map rho) ------------------------------
def words(G):
    seen, frontier = set(), set(G)
    while frontier:
        seen |= frontier
        frontier = {c4(g, w) for g in G for w in seen} - seen
    return seen
hplus = [w for w in words((A4, B4)) if w != E4]
cls = {}
for s in S4:
    cls.setdefault(tuple(w[s] for w in hplus), []).append(s)
print("states:", len(list(S4)), "| classes:", len(cls), "| classes:",
      sorted(cls.values()))
print("rho is injective:", len(cls) == 4)