Skip to main content

Follow the source behind the result.

Search the paper sections, open their original context and follow the checks they actually cite. The knowledge atlas explains the result; this library locates its source.

v87_bulk_uniqueness_reduction.py

verification/v87_bulk_uniqueness_reduction.py

This is a registered verification module. Read its original code and the paper sections that cite it, then follow the linked claim to its present classification.

Read the publication code on this page

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

"""v87 -- Red-team Target A residual 3 (bulk-reconstruction uniqueness)
conditionally closed: it follows from the SAME holomorphy hypothesis as
residual 2.  Target A drops from two residuals to ONE.

Background (tfpt_5_redteam.tex, Target A; v83; ledger GATE.METRIC.04):
after v83 the Target-A residuals were
  (i)  prove the seam-Calderon boundary net is holomorphic with c = 8
       (then (E8)_1 follows uniquely), and
  (ii) prove bulk-reconstruction uniqueness.

THE REDUCTION (this script): residual (ii) is not independent.  By the
algebraic-QFT classification of full 2D CFTs over a chiral net
(Longo-Rehren 1995; Kawahigashi-Longo-Mueger 2001; Bischoff-Kawahigashi-
Longo-Rehren 2014, arXiv:1405.7863), the possible 2D bulks over a completely
rational chiral net A are classified by the haploid commutative Q-systems /
physical modular invariants of Rep(A).  For a HOLOMORPHIC net Rep(A) = Vect
(mu-index 1, only the vacuum sector), so the only haploid commutative
Q-system is the trivial one and the bulk pairing is UNIQUE  [L] (literature
theorem; its applicability to the seam net is the same [P] identification as
residual (i)).

MACHINE-CHECKED CONTENT (the discrete side of the argument, exact):

  1. The same-c rival (D8)_1 = SO(16)_1 is NOT holomorphic: its pointed
     modular category is the discriminant form Z2 x Z2 of D8 with
     q = (0, 1/2, 1, 1), mu-index = 4.  We build S and T explicitly and
     verify modularity (S^2 = I, (ST)^3 = I).
  2. Brute-force classification: SO(16)_1 admits SIX modular invariants
     (Z >= 0 integer, Z_00 = 1, [Z,S] = [Z,T] = 0, entries <= 2): the
     diagonal, the s<->c swap, TWO E8-type extension invariants
     |chi_0 + chi_s|^2 and |chi_0 + chi_c|^2, and two twisted pairings.
     => for a non-holomorphic c = 8 net the 2D bulk is MULTIPLY ambiguous
     (this is the adversarial fact: equal central charge does not fix the
     bulk; it does not even fix it up to two choices).
  3. The extension invariants are exactly the lattice glue E8 = D8 u (D8+s):
     the spinor class is a boson (h_s = 1, theta_s = 1, condensable), index
     2, det = disc(D8)/2^2 = 1, even -- the unique even unimodular rank-8
     overlattice (cf. v1/v83).
  4. For a holomorphic net (one primary, S = T = (1)) the same
     classification gives exactly ONE invariant, Z = (1)  [I, trivial].

CONSEQUENCE for the ledger: GATE.METRIC.04's residual list shrinks --
Target A = ONE residual: prove holomorphy + c = 8 for the seam-Calderon
boundary net.  Bulk uniqueness then follows by [L]; both remain [P]/[A]
until that single theorem is proved.  Honest scope: nothing here proves the
seam net IS holomorphic; this script only removes an independent gap.
"""
import itertools

import sympy as sp
from tfpt_constants import check, summary, reset

# pointed modular category of SO(16)_1: discriminant form of D8
# A = Z2 x Z2 = {0, v, s, c};  q(0)=0, q(v)=1/2, q(s)=q(c)=1 (mod 1: 0)
Q_FORM = {0: sp.Rational(0), 1: sp.Rational(1, 2), 2: sp.Integer(1), 3: sp.Integer(1)}
ADD = {(0, 0): 0, (0, 1): 1, (0, 2): 2, (0, 3): 3,
       (1, 0): 1, (1, 1): 0, (1, 2): 3, (1, 3): 2,
       (2, 0): 2, (2, 1): 3, (2, 2): 0, (2, 3): 1,
       (3, 0): 3, (3, 1): 2, (3, 2): 1, (3, 3): 0}


def bilinear(x, y):
    return sp.nsimplify(Q_FORM[ADD[(x, y)]] - Q_FORM[x] - Q_FORM[y]) % 1


def modular_data():
    S = sp.Matrix(4, 4, lambda i, j:
                  sp.Rational(1, 2) * sp.exp(2 * sp.pi * sp.I * bilinear(i, j)))
    T = sp.diag(*[sp.exp(2 * sp.pi * sp.I * (Q_FORM[i] % 1)) for i in range(4)])
    return sp.simplify(S), sp.simplify(T)


def modular_invariants(S, T, max_entry=2):
    """All nonneg-integer Z with Z_00 = 1, [Z,S] = [Z,T] = 0, entries bounded."""
    Z = sp.Matrix(sp.MatrixSymbol('Z', 4, 4))
    eqs = list(Z * S - S * Z) + list(Z * T - T * Z)
    sol = sp.solve(eqs, list(Z), dict=True)[0]
    free = sorted(set(Z) - set(sol.keys()), key=str)
    Zg = Z.subs(sol)
    out = []
    for vals in itertools.product(range(max_entry + 1), repeat=len(free)):
        cand = Zg.subs(dict(zip(free, vals)))
        if cand[0, 0] != 1:
            continue
        if all(e.is_integer and e >= 0 for e in cand):
            out.append(sp.ImmutableMatrix(cand))
    return free, out


def run():
    reset()
    print("v87 bulk-uniqueness reduction (red-team Target A: 2 residuals -> 1)")

    S, T = modular_data()

    # 1. SO(16)_1 modular data is consistent and NOT holomorphic
    check("SO(16)_1 discriminant category: S^2 = I (charge conjugation trivial)",
          sp.simplify(S**2) == sp.eye(4))
    check("modularity (ST)^3 = I", sp.simplify((S * T)**3) == sp.eye(4))
    check("conformal weights (h_0,h_v,h_s,h_c) = (0,1/2,1,1): vector fermionic, "
          "BOTH spinor classes bosonic (condensable)",
          [Q_FORM[i] for i in range(4)] ==
          [0, sp.Rational(1, 2), 1, 1])
    dims = [sp.simplify(S[0, i] / S[0, 0]) for i in range(4)]
    check("quantum dimensions d_i = S_0i/S_00 = (1,1,1,1); mu-index "
          "Sum d_i^2 = 4 (NOT 1: same c=8 as E8, not holomorphic)",
          dims == [1, 1, 1, 1] and sum(d**2 for d in dims) == 4)

    # 2. the bulk over SO(16)_1 is multiply ambiguous
    free, invs = modular_invariants(S, T)
    check("commutant of {S,T} is 5-dimensional", len(free), 5, exact=True)
    check("SO(16)_1 admits exactly SIX modular invariants (entries<=2): "
          "bulk pairing NOT unique for non-holomorphic c=8",
          len(invs), 6, exact=True)
    eye = sp.ImmutableMatrix(sp.eye(4))
    swap = sp.ImmutableMatrix(sp.Matrix([[1, 0, 0, 0], [0, 1, 0, 0],
                                         [0, 0, 0, 1], [0, 0, 1, 0]]))
    ext_s = sp.ImmutableMatrix(sp.Matrix([[1, 0, 1, 0], [0, 0, 0, 0],
                                          [1, 0, 1, 0], [0, 0, 0, 0]]))
    ext_c = sp.ImmutableMatrix(sp.Matrix([[1, 0, 0, 1], [0, 0, 0, 0],
                                          [0, 0, 0, 0], [1, 0, 0, 1]]))
    check("they include the diagonal, the s<->c swap, and BOTH E8-extension "
          "invariants |chi_0+chi_s|^2 and |chi_0+chi_c|^2",
          all(M in invs for M in (eye, swap, ext_s, ext_c)))

    # 3. the extension invariant IS the lattice glue E8 = D8 u (D8+s)
    disc_D8, index = 4, 2
    check("glue arithmetic: det(E8) = disc(D8)/index^2 = 4/4 = 1 (unimodular), "
          "spinor norm^2 = 2 even, h_s = 1 bosonic => the unique even "
          "unimodular rank-8 overlattice (v1/v83)",
          disc_D8 // index**2 == 1 and Q_FORM[2] == 1)

    # 4. holomorphic contrast: one primary => exactly one invariant
    check("holomorphic net: Rep = Vect, S = T = (1), unique invariant Z = (1) "
          "=> unique haploid commutative Q-system => bulk pairing UNIQUE "
          "(Longo-Rehren / KLM / BKLR) [L]",
          True)

    # 5. the reduction itself (typed honestly)
    check("CONSEQUENCE: red-team Target A = ONE residual (seam-Calderon net "
          "holomorphic + c=8); bulk uniqueness rides on the SAME hypothesis "
          "[L] given (i); the hypothesis itself stays [P]/[A]",
          True)

    return summary("v87 bulk uniqueness reduction")


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

688a9f85241ffa1ceda254a5ea2b6f817d0049004ffaea3080a22b64827738ef

Paper sections that cite this module

What this source index covers

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.