Follow the source behind the result.

The registered Python source is shown as text. Displaying it does not execute the code.

#!/usr/bin/env python3
"""v602 -- QGEO.DUALFORMS.01: the duality-and-forms round -- the J-adjoint
exchanges the two parabolic types inside one equivariant structure, the
dictionary completes in the J-projector language, Weil positivity holds
exactly, and the canonical bilinear form exists; the corpus-transpose and
mark-local questions are honestly typed open.

Round 6 of the QGEO cover program (v597 model, v598 dictionary, v599 real
structure, v600 joint embedding, v601 equivariant dual).  Executes the
"1,2,3,4,5" slate on the J-projector presentation:

  (D1) THE DUALITY MECHANISM [E]: U_1 = 3 GJ_1 is J-self-adjoint; the
       J-adjoint of V_1 = 1 + GJ_4 - GJ_1 GJ_2 is the product reversal
       1 + GJ_4 - GJ_2 GJ_1; and (U_1, V_1^J) is EXACTLY conjugate to the
       compiler (line-stabilizer) pair while (U_1, V_1) is conjugate to
       the transposed (plane-stabilizer) pair (v601): the J-adjoint
       exchanges the two parabolic types inside ONE equivariant structure
       -- the cover's realization is J-self-dual as a pair-of-pairs.

  (D2) DICTIONARY COMPLETION [E]: in the J-projector language the
       remaining compiler objects appear verbatim or as tiny formulas:
       H = 1 + V(V-1)/2 has char (x-1)^2(x-2) (the anchor operator, same
       formula as the corpus); Q = U + V has char Q; Q_+ ~ 2 - GJ_1 +
       GJ_2 GJ_3 has char (x-1)(x-2)(x-3); the binary AnchorLadder ~
       2 - GJ_1 + 2 GJ_2 GJ_3 has char (x-1)(x-2)(x-4).  The S_0-grading
       halves of Q are computed and their chars documented.

  (D3) WEIL POSITIVITY [E, Strategy II at module level]: the Weil
       operator C = P_+ - P_- from J's spectral split (1 positive, 2
       negative directions = the Chevalley-Weil Hodge numbers) gives a
       POSITIVE DEFINITE twisted form JC with exact eigenvalues
       {2 sqrt2 - 2, 2, 2 + 2 sqrt2} = |Spec J| -- the Riemann bilinear
       positivity statement holds on the omega-sheet.

  (D4) THE CANONICAL BILINEAR FORM [E]: B(v,w) = (Rv)^dagger J w has
       matrix B = M^dagger J and is SYMMETRIC -- the curve carries a
       canonical complex orthogonal structure combining the real
       structure with the polarization.

  (D5) HONEST NEGATIVES [X/O, quantified]: (i) g^T g is NOT proportional
       to B for the compiler conjugation g -- the corpus transpose
       structure is not the (R,J)-bilinear form (the corpus RP word-Gram
       has inertia (4,3,0), documented); (ii) the naive mark-local
       cokernel map fails: the rotated cusp operators U_2, U_3 lie
       OUTSIDE the seven-word algebra of (U_1, V_1), and U_4 lies inside
       with integer coefficients (class zero) -- the carrier of the
       mark-local Z/3 mechanism stays open; (iii) the seam-plane normal
       is explicit ((-1, -1/2 - sqrt3 i/2, 1), eigenvalue pair (0,1)) but
       is NOT a deck eigenvector -- the seam identification stays open.

All checks exact (sympy) except the two documented inertia counts
(numeric eigenvalues of exact hermitian/symmetric matrices).  Verdict
enums (frozen): DUALITY-FORMS-LANDED (all), DUALITY-FORMS-FAILS, MIXED.

FIREWALL: GATE.QGEO does not move; no marker changes.  The Weil-twisted
RP comparison against the v572 Gram data, the corpus-transpose carrier and
the mark-local mechanism are typed open, not claimed.  Companion Lean
certificate: FORM.QGEO.04 (TfptCarrier/CoverEmbedding.lean, the v600
integer core via determinant-free Smith certificates, kernel decide).

PROVENANCE: discovery probe duality_forms_probe.py (2026-08-01, 17/17,
verdict DUALITY-FORMS-LANDED).  Python-only, counted per GATE.WOLFRAM.02.
"""

import numpy as np
import sympy as sp

t = sp.symbols("t")
x = sp.symbols("x")
OMEGA = sp.Rational(-1, 2) + sp.sqrt(3) * sp.I / 2

CHECKS = []


def check(name, ok, detail=""):
    CHECKS.append((name, bool(ok)))
    print("[%s] %s%s" % ("PASS" if ok else "FAIL", name, (" -- " + detail) if detail else ""))


def burau_gen(i, n=4):
    m = n - 1
    M = sp.eye(m)
    if i - 2 >= 0:
        M[i - 2, i - 1] = t
    M[i - 1, i - 1] = -t
    if i < m:
        M[i, i - 1] = 1
    return M


I3 = sp.eye(3)
S = [sp.simplify(burau_gen(i).subs({t: OMEGA})) for i in (1, 2, 3)]
r = sp.simplify(S[0] * S[1] * S[2])
T = [S[0]]
for _ in range(3):
    T.append(sp.simplify(r * T[-1] * r.inv()))

J = sp.Matrix([[0, 1 + sp.sqrt(3) * sp.I, -1 + sp.sqrt(3) * sp.I],
               [1 - sp.sqrt(3) * sp.I, 2, 1 + sp.sqrt(3) * sp.I],
               [-1 - sp.sqrt(3) * sp.I, 1 - sp.sqrt(3) * sp.I, 0]])
Jinv = J.inv()
M0 = sp.Matrix([[-1, (1 + sp.sqrt(3) * sp.I) / 2, (1 - sp.sqrt(3) * sp.I) / 2],
                [0, 0, 1],
                [0, 1, 0]])
GJ = [sp.simplify((I3 - T[k]) * Jinv * (I3 - T[k]).conjugate().T * J) for k in range(4)]

U1 = sp.simplify(3 * GJ[0])
V1 = sp.simplify(I3 + GJ[3] - GJ[0] * GJ[1])
V1J = sp.simplify(I3 + GJ[3] - GJ[1] * GJ[0])
Uc = sp.Matrix([[3, 0, 0], [3, 0, 0], [3, 0, 0]])
Vc = sp.Matrix([[0, 1, 0], [0, 2, 0], [0, 2, 1]])


def charpoly(A):
    return sp.factor(sp.simplify(sp.expand((x * I3 - A).det())))


def Jadj(A):
    return sp.simplify(Jinv * A.conjugate().T * J)


def conjugation_to(A1, B1, A2, B2):
    g = sp.Matrix(3, 3, lambda i, j: sp.Symbol("h%d%d" % (i, j)))
    eqs = []
    for E_ in [sp.expand(g * A1 - A2 * g), sp.expand(g * B1 - B2 * g)]:
        eqs.extend([E_[i, j] for i in range(3) for j in range(3)])
    sol = sp.solve(eqs, list(g), dict=True)
    if not sol:
        return None
    gs = sp.simplify(g.subs(sol[0]))
    fs = sorted(gs.free_symbols, key=str)
    gn = sp.simplify(gs.subs({f: 1 for f in fs}))
    if sp.simplify(gn.det()) == 0:
        return None
    if (sp.simplify(gn * A1 * gn.inv() - A2) == sp.zeros(3, 3)
            and sp.simplify(gn * B1 * gn.inv() - B2) == sp.zeros(3, 3)):
        return gn
    return None


# ---------------------------------------------------------------- D1
print("=" * 72)
print("D1: the J-adjoint duality mechanism")
print("=" * 72)

check("D1.1 U_1 is J-self-adjoint", sp.simplify(Jadj(U1) - U1) == sp.zeros(3, 3))
check("D1.2 V_1^J = 1 + GJ_4 - GJ_2 GJ_1 (exact product reversal)",
      sp.simplify(Jadj(V1) - V1J) == sp.zeros(3, 3))
g_line = conjugation_to(U1, V1J, Uc, Vc)
check("D1.3 (U_1, V_1^J) conjugate to the compiler LINE-stabilizer pair", g_line is not None)
g_dual = conjugation_to(U1, V1, Uc.T, Vc.T)
check("D1.4 (U_1, V_1) conjugate to the transposed pair (v601 reconfirmed)", g_dual is not None)

# ---------------------------------------------------------------- D2
print("=" * 72)
print("D2: dictionary completion in the J-projector language")
print("=" * 72)

H1 = sp.simplify(I3 + (V1J * (V1J - I3)) / 2)
check("D2.1 H = 1 + V(V-1)/2 has char (x-1)^2(x-2) (anchor operator, corpus formula verbatim)",
      sp.expand(charpoly(H1) - (x - 1) ** 2 * (x - 2)) == 0, str(charpoly(H1)))
Q1 = sp.simplify(U1 + V1J)
check("D2.2 Q = U + V has char (x-1)(x^2-5x+3)",
      sp.expand(charpoly(Q1) - sp.expand((x - 1) * (x ** 2 - 5 * x + 3))) == 0)
Qp = sp.simplify(2 * I3 - GJ[0] + GJ[1] * GJ[2])
check("D2.3 Q_+ ~ 2 - GJ_1 + GJ_2 GJ_3 has char (x-1)(x-2)(x-3)",
      sp.expand(charpoly(Qp) - (x - 1) * (x - 2) * (x - 3)) == 0, str(charpoly(Qp)))
Lad = sp.simplify(2 * I3 - GJ[0] + 2 * GJ[1] * GJ[2])
check("D2.4 ladder ~ 2 - GJ_1 + 2 GJ_2 GJ_3 has char (x-1)(x-2)(x-4)",
      sp.expand(charpoly(Lad) - (x - 1) * (x - 2) * (x - 4)) == 0, str(charpoly(Lad)))
# S0-grading halves of Q (documented, chars printed)
P_, D_ = V1J.diagonalize()
order = [D_[i, i] for i in range(3)]
signs = tuple(1 if order[i] == 0 else -1 for i in range(3))
S0c = sp.simplify(P_ * sp.diag(*signs) * P_.inv())
Qgrad_p = sp.simplify((Q1 + S0c * Q1 * S0c) / 2)
Qgrad_m = sp.simplify((Q1 - S0c * Q1 * S0c) / 2)
check("D2.5 S_0-grading halves of Q computed (chars documented)",
      True, "char Q_+^S0 = %s ; char Q_-^S0 = %s" % (charpoly(Qgrad_p), charpoly(Qgrad_m)))

# ---------------------------------------------------------------- D3
print("=" * 72)
print("D3: Weil positivity (Riemann bilinear relations at module level)")
print("=" * 72)

# exact statement: J has char (x+2)(x^2-4x-4); the Weil-twisted form JC has
# eigenvalues |Spec J| = {2, 2sqrt2-2, 2+2sqrt2}, all positive.
chJ = charpoly(J)
check("D3.1 char J = (x+2)(x^2-4x-4) (signature (1,2), v599)",
      sp.expand(chJ - sp.expand((x + 2) * (x ** 2 - 4 * x - 4))) == 0)
Jn = np.array(sp.N(J).tolist(), dtype=complex)
ev, Wv = np.linalg.eigh(Jn)
P_pos = np.outer(Wv[:, 2], Wv[:, 2].conj())
Cw = 2 * P_pos - np.eye(3)
JC = Jn @ Cw
evJC = np.linalg.eigvalsh((JC + JC.conj().T) / 2)
targets = sorted([2.0, float(2 * np.sqrt(2) - 2), float(2 + 2 * np.sqrt(2))])
check("D3.2 JC positive definite with eigenvalues {2sqrt2-2, 2, 2+2sqrt2} = |Spec J|",
      all(e > 0 for e in evJC)
      and max(abs(a - b) for a, b in zip(sorted(evJC), targets)) < 1e-9,
      str([round(float(e), 6) for e in evJC]))

# ---------------------------------------------------------------- D4
print("=" * 72)
print("D4: the canonical bilinear form B = M^dagger J")
print("=" * 72)

B = sp.simplify(M0.conjugate().T * J)
check("D4.1 B symmetric (canonical complex orthogonal structure from R and J)",
      sp.simplify(B - B.T) == sp.zeros(3, 3))
check("D4.2 det B nonzero (nondegenerate)", sp.simplify(B.det()) != 0,
      "det B = %s" % sp.nsimplify(sp.simplify(B.det())))

# ---------------------------------------------------------------- D5
print("=" * 72)
print("D5: honest negatives and typed opens")
print("=" * 72)

GtG = sp.simplify(g_line.T * g_line)
lam_c = None
for ii in range(3):
    for jj in range(3):
        if B[ii, jj] != 0 and GtG[ii, jj] != 0:
            lam_c = sp.simplify(GtG[ii, jj] / B[ii, jj])
            break
    if lam_c is not None:
        break
check("D5.1 [must-fail] g^T g is NOT proportional to B (corpus transpose != (R,J)-form)",
      lam_c is None or sp.simplify(GtG - lam_c * B) != sp.zeros(3, 3))

Sig = sp.diag(1, -1, -1)
wc = [I3, Uc, Vc, Uc * Vc, Vc * Uc, Vc * Vc, Vc * Uc * Vc]
K = sp.Matrix(7, 7, lambda i, j: sp.trace(Sig * wc[i].T * Sig * wc[j]))
Kn = np.array(sp.N(K).tolist(), dtype=float)
evK = np.linalg.eigvalsh((Kn + Kn.T) / 2)
pos = sum(1 for e in evK if e > 1e-9)
neg = sum(1 for e in evK if e < -1e-9)
check("D5.2 corpus RP word-Gram inertia documented: (4,3,0)",
      (pos, neg) == (4, 3), "(+%d, -%d, 0:%d)" % (pos, neg, 7 - pos - neg))

# naive mark-local map: rotated cusp operators vs the word algebra
words = [I3, U1, V1, sp.simplify(U1 * V1), sp.simplify(V1 * U1),
         sp.simplify(V1 * V1), sp.simplify(V1 * U1 * V1)]
Wmat = sp.Matrix([[wd[i, j] for i in range(3) for j in range(3)] for wd in words])
in_span = []
for k in range(4):
    vec = sp.Matrix(9, 1, [sp.simplify(3 * GJ[k])[i, j] for i in range(3) for j in range(3)])
    try:
        Wmat.T.gauss_jordan_solve(vec)
        in_span.append(k + 1)
    except ValueError:
        pass
check("D5.3 [must-fail for naive map] U_2, U_3 lie OUTSIDE the word algebra (U_1, U_4 inside)",
      in_span == [1, 4], "in span: %s" % in_span)

n_seam = sp.Matrix([-1, -sp.Rational(1, 2) - sp.sqrt(3) * sp.I / 2, 1])
lhsU = sp.simplify(U1.T * n_seam)
lhsV = sp.simplify(V1.T * n_seam)
ok_normal = (lhsU == sp.zeros(3, 1)
             and sp.simplify(lhsV - n_seam) == sp.zeros(3, 1))
rn = sp.simplify(r.T * n_seam)
not_deck = sp.Matrix.hstack(n_seam, rn).rank() == 2
check("D5.4 seam-plane normal explicit (U^T n = 0, V^T n = n) and NOT a deck eigenvector "
      "(identification open)", ok_normal and not_deck)

# ---------------------------------------------------------------- summary
print("=" * 72)
n_pass = sum(1 for _, ok in CHECKS if ok)
print("%d/%d checks passed" % (n_pass, len(CHECKS)))
if n_pass == len(CHECKS):
    print("ALL CHECKS PASSED")
    print("VERDICT: DUALITY-FORMS-LANDED -- the J-adjoint exchanges the two")
    print("parabolic types inside one equivariant structure; the dictionary is")
    print("complete in the J-projector language; Weil positivity holds exactly;")
    print("the canonical bilinear form exists; the corpus-transpose and mark-local")
    print("questions are honestly typed open.")
else:
    print("SOME CHECKS FAILED")


def run():
    """run_all.py entry point; the checks execute at import time above."""
    return len([1 for _, ok in CHECKS if not ok])


if __name__ == "__main__":
    raise SystemExit(1 if run() else 0)

bfce15fba2ac7fc45591539a2750d72deb236ce66eb6d92a09a8fecec50c7453

The public registry includes 116 document views, 6,693 section records and 985 physical LaTeX sources. Active publication documents, research material and archives retain their recorded roles. This is source navigation, not a new semantic review or proof run.