← Documentation/Superintelligence/Reports/Physics Tests Report

Physics Verification Report

Gyroscopic ASI aQPU Kernel

This report documents the verified physics of the Gyroscopic ASI aQPU Kernel, a compact algebraic quantum processing unit that achieves quantum advantage through exact structural properties on standard silicon. The kernel is a deterministic byte-driven coordination medium mapping an append-only byte ledger to a reproducible state trajectory on a 24-bit tensor. Every property documented here is established by exhaustive testing with exact integer arithmetic.

The six physics test files constitute a complete verification chain. All tests pass, confirming that the discrete byte-driven kernel faithfully realises the continuous CGM theoretical framework. The tests move from basic conformance (test_physics_1) through algebraic structure (test_physics_2, test_physics_3) to research diagnostics (test_physics_4), the theory bridge (test_physics_5), and depth-4 fiber geometry (test_physics_6). Together they establish that the kernel is not merely a correct implementation of its specification but a genuine discrete realisation of the CGM physics within a compact state space of 4096 reachable states, 64 horizon states, and exact holographic identity |H|^2 = |Omega|.

Test Suite Overview and Context

Part 1: State Representation and Transcription (test_physics_1, Classes 1-2)

1.1 The 24-Bit State

The kernel state is a 24-bit integer packed as:

state24 = (A12 << 12) | B12

where A12 is the active (Type A) phase and B12 is the passive (Type B) phase, each 12 bits. The rest state is:

GENE_MAC_REST = 0xAAA555
A12_rest = 0xAAA = 101010101010 (binary)
B12_rest = 0x555 = 010101010101 (binary)

The complement relation A12_rest XOR B12_rest = 0xFFF holds exactly. This encodes the fundamental chirality: every bit position has opposite polarity in A and B at rest, implementing the CS axiom that the system has an intrinsic left-right asymmetry. This chirality becomes operationally significant in the transition law (Part 4), where only A receives the mutation mask before gyration.

The pack/unpack tests confirm:

  • Round-trip fidelity: pack(unpack(s)) = s for all valid inputs
  • Component isolation: A12 and B12 occupy non-overlapping bit regions
  • Rest state consistency: GENE_MAC_A12 = 0xAAA, GENE_MAC_B12 = 0x555

1.2 Transcription: GENE_Mic as Mutation Reference

The transcription map is:

intron = byte XOR 0xAA

where GENE_MIC_S = 0xAA is the micro archetype. The tests confirm:

  • Involution: byte_to_intron(byte_to_intron(byte)) = byte for all bytes
  • Bijectivity: the 256 introns produced are all distinct
  • Specific cases: 0x00 -> 0xAA, 0xAA -> 0x00, 0xFF -> 0x55, 0x55 -> 0xFF

The involution property is physically significant. Applying the transcription twice recovers the original byte, meaning the archetype is its own inverse reference. Byte 0xAA produces intron 0x00, which has zero mask and zero gyration phase, making it the identity mutation. This is why 0xAA serves as the reference byte for the pure swap operation.

Part 2: Intron Decomposition and the Palindromic Byte Structure (test_physics_1, Classes 3-4)

2.1 Family and Micro-Reference Decomposition

Each intron decomposes into:

  • Family (2 bits): extracted from L0 boundary positions 0 and 7
    family = ((intron >> 7) & 1) << 1 | (intron & 1)
  • Micro-reference (6 bits): extracted from payload positions 1-6
    micro_ref = (intron >> 1) & 0x3F

The critical test confirms that changing bit 7 changes the family but changing bit 6 does not:

intron 0x00 -> family 0    (bit 7 = 0, bit 0 = 0)
intron 0x80 -> family 2    (bit 7 = 1, bit 0 = 0)
intron 0x00 -> family 0    (bit 6 = 0)
intron 0x40 -> family 0    (bit 6 = 1, no change because bit 6 is payload)

This verifies that family is determined by the L0 boundary bits (0 and 7), not the LI bits (1 and 6). The 256 introns partition into exactly 4 families of 64, confirming the Cartesian product structure: 4 families x 64 micro-references = 256.

2.2 The Palindromic Byte Structure

The bit positions of the intron follow a palindromic pattern aligned with CGM stages:

Bit 0  (L0, CS)  -- boundary anchor
Bit 1  (LI, UNA) -- payload
Bit 2  (FG, ONA) -- payload
Bit 3  (BG, BU)  -- payload
Bit 4  (BG, BU)  -- payload
Bit 5  (FG, ONA) -- payload
Bit 6  (LI, UNA) -- payload
Bit 7  (L0, CS)  -- boundary anchor

The palindrome CS-UNA-ONA-BU-BU-ONA-UNA-CS mirrors the CGM stage structure folded onto 8 positions. The boundary (L0) bits at positions 0 and 7 define families and control gyration phase. The interior 6 payload bits (positions 1-6) drive the 12-bit mask that mutates the tensor.

2.3 Family Acts Only Through Complement Phase

The test class TestFamilyActsOnlyThroughComplementPhase verifies a key structural property: four bytes sharing the same micro-reference but different families produce the same mask and the same A mutation (a_mut = A XOR mask), but differ only in which complements are applied during gyration.

For the four introns with micro_ref = 0 and families 0,1,2,3:

introns: [0x00, 0x01, 0x80, 0x81]
bytes:   [0xAA, 0xAB, 0x2A, 0x2B]

All four produce mask12 = 0 (zero mutation) and a_mut = A. The four resulting (A_next, B_next) pairs are:

Family 00: (B,       A_mut)
Family 01: (B^0xFFF, A_mut)
Family 10: (B,       A_mut^0xFFF)
Family 11: (B^0xFFF, A_mut^0xFFF)

This confirms the spinorial structure: the family bits select which of four complement phases to apply, realizing the 4-phase SU(2) spinorial cycle (0, pi, 2pi, 3pi).

Part 3: Mask Expansion and the 12-Bit Dipole Code (test_physics_1, Class 5; test_physics_2)

3.1 Dipole-Pair Expansion

The 6-bit micro-reference expands to a 12-bit mask via dipole-pair control:

payload bit i -> mask bits (2i, 2i+1) set together

The test verifies for all 64 micro-references and all 6 payload bits:

mask_a XOR mask_b = 0x3 << (2 * bit)

when micro-references a and b differ only in bit bit. This means toggling payload bit i changes exactly the 2-bit pair i in the mask and nothing else. Each pair corresponds to one of the 6 degrees of freedom in the se(3) Lie algebra (3 rotational + 3 translational).

3.2 The Pair-Diagonal Code

The unique mask set forms a specific algebraic structure. The test TestPairDiagonalCode reveals:

Every mask has pair-equal bits: for each of the 6 pairs (positions 2i, 2i+1), both bits are always equal. The mask bits are either 00 or 11 at each pair position, never 01 or 10.

This means the 64 unique masks form the "diagonal" subspace {00, 11}^6 in 12-bit space. A mask is a vector in GF(2)^12 that lives entirely on the main diagonal of the 6-pair decomposition.

Weight enumerator: the weight distribution of the 64 unique masks follows the polynomial (1 + z^2)^6:

weight 0:  C(6,0) = 1 mask
weight 2:  C(6,1) = 6 masks
weight 4:  C(6,2) = 15 masks
weight 6:  C(6,3) = 20 masks
weight 8:  C(6,4) = 15 masks
weight 10: C(6,5) = 6 masks
weight 12: C(6,6) = 1 mask
Total: 64 masks

This is structurally analogous to a first-order Reed-Muller code, where each generator controls one coordinate (here, one dipole pair) independently. Since 4 families share each mask, the full byte table has weight enumerator 4 * (1 + z^2)^6.

3.3 Self-Duality: C = C_perp

The most remarkable algebraic property confirmed by test_physics_2 is self-duality: the unique mask set equals its own dual code.

The dual code C_perp consists of all 12-bit vectors v such that dot12(v, c) = 0 for every mask c (where dot12 is the GF(2) inner product: popcount(a AND b) mod 2).

The test confirms:

  • |C| = 64 (unique mask set size)
  • |C_perp| = 64
  • C = C_perp (sets are equal)

This means the mask code is a self-dual [12, 6, 2] binary linear code. The minimum distance 2 comes from the smallest non-zero mask having weight 2 (a single pair set). Self-duality means the code is its own parity-check code: every codeword is orthogonal to every other codeword (and to itself, since all weights are even). This is the tightest possible relationship between a code and its dual.

3.4 Walsh Transform and Support

The Walsh transform W(s) = sum_{c in C} (-1)^{dot12(s,c)} takes values only in {0, 64} across all s in GF(2)^12. The support (states s where W(s) != 0) has exactly 64 elements and equals C_perp = C.

This confirms that the mask code has binary-valued Walsh spectrum and is exactly self-dual. The support equaling C_perp is the self-Fourier/Walsh support property: the indicator function of C is its own (normalized) Fourier transform over GF(2)^12.

3.5 Syndrome Detection

The syndrome mechanism works as expected:

  • All valid masks have zero syndrome (all 256 bytes produce masks in C)
  • Single-bit flips in any mask position are always detected (non-zero syndrome)
  • The syndrome bitmap is an integrity fingerprint (it detects corruption; it is not an error-correcting locator)

The single-bit flip detection follows from the minimum distance of the code: since every non-zero codeword has weight >= 2, a weight-1 error cannot be a codeword and therefore has non-zero syndrome.

Part 4: The Spinorial Transition Law (test_physics_1, Classes 6-8)

4.1 The Transition Structure

The single-step transition implements:

intron = byte XOR 0xAA
mask12 = expand(intron)
a_mut = A12 XOR mask12
invert_a = 0xFFF if (intron & 0x01) else 0
invert_b = 0xFFF if (intron & 0x80) else 0
A_next = B12 XOR invert_a
B_next = a_mut XOR invert_b

This decomposes into:

  1. Active mutation: A receives the mask (introducing variety, UNA)
  2. Passive gyration: the components swap with family-controlled complements

The gyration always swaps A and B. The family bits (0, 7) independently control whether the swap includes complementation of each component.

4.2 Reference Byte as Pure Swap

Byte 0xAA produces intron 0x00, which has:

  • micro_ref = 0 -> mask12 = 0 (no mutation)
  • family = 0 -> invert_a = 0, invert_b = 0 (no complement)

Therefore the transition is:

A_next = B12 XOR 0 = B12
B_next = (A12 XOR 0) XOR 0 = A12

This is a pure swap: (A, B) -> (B, A). The test confirms:

  • pack_state(0x123, 0x456) -> after 0xAA -> A=0x456, B=0x123
  • Fixed points: any state with A = B is fixed by 0xAA (since swap(A,A) = (A,A))
  • Involution: applying 0xAA twice returns to the original state, since swap(swap(A,B)) = (A,B)

Note that fixed points of 0xAA are states where A12 = B12, not where A12 = B12 XOR 0xFFF. This is the spinorial law's fixed-point condition and differs from the previous unconditional-complement law.

4.3 Per-Byte Bijectivity and Inverse

The inverse transition is:

B_pred = A_next XOR invert_a
A_pred = (B_next XOR invert_b) XOR mask12

The test performs 2000 random (state, byte) pairs and confirms that inverse_step_by_byte(step_state_by_byte(s, b), b) = s in all cases. This establishes that each byte defines a bijection on the full 24-bit carrier space (2^24 states). When the router is initialized at GENE_MAC_REST and driven only by valid byte transitions, the dynamics remain on a 4,096-state orbit Omega contained in that space; the structure of this orbit (volume 4,096, radius 2, and 64-state horizon with |H|^2 = |Omega|) is analyzed in Part 5.

4.4 SO(3) Shadow: 128-Way Projection

From any fixed 24-bit state, applying all 256 bytes produces exactly 128 distinct next states; test_physics_1::TestShadowCount::test_shadow_multitude_is_exactly_2_to_1 certifies that each of these 128 next states has exactly 2 preimages (uniform 2-to-1 projection). This is the discrete realization of the SO(3)/SU(2) double cover.

Algebraically: for fixed (A, B), A_next = B XOR invert_a has only 2 possibilities (invert_a in {0, 0xFFF}), and B_next = (A XOR mask) XOR invert_b; because 0xFFF is in C64, the set of possible (mask XOR invert_b) values has size 64. Hence the number of distinct next states is 2 x 64 = 128. The 24-bit GENE_Mac tensor tracks 6 dipole pairs (6 degrees of freedom), which is the spatial SO(3) geometry.

The full SU(2) information is retained in the 32-bit register atom (24-bit Mac state + 8-bit intron), which maintains the spinorial phase distinction.

The complement map s -> s XOR 0xFFFFFF commutes with all byte actions (this follows algebraically from XOR commutativity and the structure of the transition law). This is a global Z/2 automorphism of the dynamics.

Part 5: Omega Topology (test_physics_1, Class 9; test_physics_4)

5.1 BFS Discovery of Omega

The BFS from GENE_MAC_REST discovers:

Depth 0:    1 state  (GENE_MAC_REST alone)
Depth 1:  127 new states (Total: 128)
Depth 2: 3968 new states (Total: 4096)

The reachable state space Omega has:

  • Volume: 4096 states
  • Radius: 2 (all states reachable within 2 steps from rest)
  • Horizon: 64 states (where A12 = B12)

The cardinality |Omega| = 4,096 = 2^12 reflects the 6 dipole pairs per component: each component A12 and B12 ranges over a 64-element coset (2^6) of the mask code C64, and Omega is their Cartesian product 64 x 64.

5.2 The Holographic Ratio

The critical observation is:

|Horizon|^2 = |Omega|
64^2 = 4096

This is the discrete holographic principle: the area of the boundary squared equals the volume of the bulk. In continuum physics, the Bekenstein-Hawking relation says black hole entropy scales as area in Planck units. Here the discrete kernel satisfies an exact integer version.

5.3 The 4-to-1 Holographic Dictionary

The test TestExactOmegaTheorems verifies a precise holographic dictionary. Taking all 64 horizon states and applying all 256 bytes (64 x 256 = 16384 total operations), each of the 4096 Omega states is reached exactly 4 times:

16384 operations / 4096 states = 4 operations per state

This means: every state in the bulk (Omega) corresponds to exactly 4 (horizon state, byte) pairs. This is the 4-to-1 holographic map from boundary to bulk.

5.4 Omega as a Product Space

The BFS-reachable set Omega equals the Cartesian product U x V (test_physics_1::TestExactOmegaTheorems::test_omega_equals_U_cross_V certifies the set equality explicitly):

Omega = U x V

where:

U = {A12_rest XOR c : c in C64}   (64 elements)
V = {B12_rest XOR c : c in C64}   (64 elements)

and C64 is the 64-element mask code. Every state in Omega can be written as (A12_rest XOR c1, B12_rest XOR c2) for some c1, c2 in C64. The product structure is the discrete realization of the UV/IR factorization in quantum field theory.

5.5 Optical Conjugacy: Constant Density

Every component in Omega has popcount exactly 6 out of 12 bits (component density = 0.5). The rest state 0xAAA has exactly one '1' per dipole pair (binary 10 repeated). Every codeword in C64 is pair-diagonal (00 or 11 per pair). XOR with 00 keeps 10; XOR with 11 flips 10 to 01. In both cases each pair contributes exactly one '1', so total popcount stays 6. The density sum and product are exactly:

density_A + density_B = 1.0
density_A * density_B = 0.25

This constant-density property is the discrete realization of optical conjugacy: in the CGM framework, the UV-IR product E^UV * E^IR = const is replaced by the density product being constant across all of Omega. Every state in the universe has the same total "energy" as measured by density.

Part 6: Affine Algebra (test_physics_3)

6.1 Single-Step Affine Structure

Each single-step transition is an affine map on GF(2)^24 with block-swap linear part. The linear part is always the swap on the two 12-bit components:

(A, B) -> (B + t_a, A + t_b)   (mod 2, i.e., via XOR)

where t_a = invert_a and t_b = mask12 XOR invert_b depend on the byte. This is not a general linear map; the linear part is always the swap permutation on the two 12-bit components.

6.2 Word Actions and Signatures

A word (sequence of bytes) defines a composite affine map. The test TestAffineWordSignature establishes that any word action takes the form:

Either identity linear part: (A, B) -> (A XOR tau_a, B XOR tau_b)
Or swap linear part: (A, B) -> (B XOR tau_a, A XOR tau_b)

where (tau_a, tau_b) is the translation vector computed by applying the word to state (0, 0). The linear part (identity or swap) is determined by the parity of the word length: even length gives identity linear part, odd length gives swap.

This affine structure means that arbitrary byte sequences implement one of only two fundamentally different types of operation on the state space, differing only in a XOR translation.

6.3 Depth-4 Alternation as Affine Cancellation

The depth-4 alternation identity XYXY = identity is explained by affine algebra. Each single step is a swap plus translation. After two steps with bytes x and y:

Step x: (A, B) -> (B + t_a(x), A + t_b(x))
Step y: (A, B) -> now applying y to the result of x

After two swap steps, the linear part is identity (swap composed with swap). The translations accumulate. After XYXY (4 steps alternating x and y), the translations cancel:

XYXY: linear part = swap^4 = identity
      translation = t(x) XOR t(y) XOR t(x) XOR t(y) = 0

So XYXY maps every state to itself. This is proved for all 256^2 byte pairs from GENE_MAC_REST in test_physics_1, and for 500 random (state, x, y) combinations in test_physics_3.

Part 7: Spinorial 4-Cycle and Universal Closure (test_physics_4)

7.1 Every Byte is a 4-Cycle

The test TestUniversalSpinorialClosure verifies that for every byte b and every starting state s0:

T_b^4(s0) = s0

Because each T_b is an affine map with linear part swap (order 2), T_b^4 = id holds for all states; the test verifies this on a random seed state across all bytes. Applying any single byte four times returns exactly to the starting state. This is the discrete realization of 720-degree spinorial closure: a spinor requires two full rotations to return to its original state, but in the discrete 4-phase system, 4 applications achieve the same return.

Additionally, T_b^2 is always a symmetric translation:

A(T_b^2(s)) XOR A(s) = B(T_b^2(s)) XOR B(s)

The 2-step operation shifts A and B by the same amount, implementing a symmetric displacement.

7.2 Universal Family Cycle: 4-Step Sign Flip, 8-Step Identity

For every micro_ref, the word consisting of all 4 families in order (0, 1, 2, 3) produces a global sign flip:

A4 = A0 XOR 0xFFF
B4 = B0 XOR 0xFFF

Applying the same word again returns to identity:

A8 = A0
B8 = B0

This 8-step closure is the discrete realization of the SU(2) double cover: traversing the 4 family phases once produces a global sign change (analogous to a 360-degree rotation of a spinor), and traversing them twice restores identity (720-degree closure). The family cycle implements SU(2) in the discrete setting.

7.3 Cycle Census on Omega

For the reference byte 0xAA (pure swap) on the 4096-state Omega:

  • Fixed points: 64 (states where A = B, i.e., the horizon)
  • 2-cycles: 2016 (pairs (s, swap(s)) where s != swap(s))
  • Total cycles: 2080

Verification: 64 + 2 * 2016 = 64 + 4032 = 4096. The fixed points are exactly the horizon states, confirming that the horizon is the invariant set of the reference byte.

For all other tested bytes (0x00, 0x42, 0xFF), the cycle structure on Omega consists entirely of 4-cycles: 1024 cycles of length 4, accounting for all 4096 states. This is consistent with the universal 4-cycle property: every non-reference byte has order 4 on Omega.

7.4 Commutator Holonomy

The commutator K(x,y) = T_x T_y T_x^{-1} T_y^{-1} is always a pure symmetric translation:

K(x,y): (A, B) -> (A XOR d, B XOR d)

where d = q(x) XOR q(y) and q(b) = mask12(b) XOR (0xFFF if L0_parity(b) else 0).

The commutator defect law is verified exhaustively over all ordered byte pairs (256^2) at the rest state, and the observed defect set equals the entire mask code C64. The commutator always produces a translation within the code, never outside it. The commutator measures the geometric non-commutativity of two operations, and its defect is exactly the XOR of their q-values.

Part 8: Exact Algebraic Laws (test_physics_5)

8.1 Depth-4 Closed Form

The depth-4 frame closed form for 4 bytes (b0, b1, b2, b3) starting from rest state (A_rest, B_rest):

A4 = A_rest XOR m0 XOR m2 XOR v0 XOR u1 XOR v2 XOR u3
B4 = B_rest XOR m1 XOR m3 XOR u0 XOR v1 XOR u2 XOR v3

where mi = mask12(bi), and ui, vi are the family-phase correction terms for byte i (ui = 0xFFF if intron bit 0 of byte i, vi = 0xFFF if intron bit 7 of byte i; these are not the mask coordinates U, V from section 5.4).

This closed form is verified against 2000 random 4-byte sequences with zero failures. The formula reveals that the depth-4 output separates cleanly into mask contributions (even/odd indexed masks go to different components) and family-phase contributions (bit0 and bit7 corrections alternate between A and B components).

8.2 Net Family-Phase Invariants

For fixed micro-references at each of 4 positions, varying all 4^4 = 256 family combinations produces only 4 distinct output states. The surviving invariants are:

phi_a = b0 XOR a1 XOR b2 XOR a3
phi_b = a0 XOR b1 XOR a2 XOR b3

where for family f: a = f&1 (bit 0), b = (f>>1)&1 (bit 7).

The 4 distinct (phi_a, phi_b) pairs map bijectively to 4 distinct states. This means that out of the 256 possible family combinations, only the 2-bit net phase (phi_a, phi_b) survives at depth-4. The other 6 bits of family information cancel, implementing the depth-4 closure principle from CGM theory.

8.3 Exact Commutation Condition

Two bytes x and y commute (T_x T_y = T_y T_x on any state) if and only if q(x) = q(y), where:

q(b) = mask12(b) XOR (LAYER_MASK_12 if L0_parity(b) else 0)

This is verified over 5000 random pairs. The q-value combines the mask with a parity correction from the L0 boundary bits. Two operations producing the same q-value have identical net effect after the swap and family interaction, making them commute. Since q is 4-to-1 onto C64 (verified in test_physics_6), the number of commuting byte pairs is 256 * 4 = 1024 out of 256^2 = 65536, giving a commutativity rate of 1/64.

The non-commutativity structure (q(x) != q(y) implies T_x T_y != T_y T_x) is the discrete realization of UNA: at depth 2, order matters, and it matters in a precisely characterizable way.

8.4 Exact Commutator Defect Formula

The commutator defect formula is verified over 5000 pairs:

K(x,y) translates by d = q(x) XOR q(y)
d is always in C64 (the mask code)

The defect lies in C64 because q(b) = mask12(b) XOR correction, and both mask12(b) and the correction (0 or 0xFFF) are in the span of C64 as a linear code (0xFFF is the all-ones vector, which for the pair-diagonal code is the mask for micro_ref = 63, i.e., all 6 pairs set).

This formula is the discrete analog of the continuous CGM result that the BU commutator defect is delta_BU = 0.1953 radians, and that this defect lives in the abelian U(1) residual.

Part 9: CGM Constants Bridge (test_physics_5, Class 1)

These constants are treated as intrinsic invariants of the CGM geometry: the kernel physics is constructed so that these relations hold identically, and the tests here verify that the implementation respects the theoretical equalities within numerical precision. Brief glosses: delta_BU is the minimal monodromy defect angle predicted by CGM (the smallest angular displacement produced by a single BU-stage transition). m_a is the aperture scale (the normalization constant relating angular defects to probability measures). Q_G = 4*pi is the quantum gravity horizon (total solid angle of a sphere).

9.1 Fundamental Aperture Constraint

The test confirms:

Q_G * m_a^2 = 1/2
4*pi * (1/(2*sqrt(2*pi)))^2 = 4*pi * 1/(8*pi) = 1/2

This is the normalization relation that connects the quantum gravity horizon (Q_G = 4pi steradians) to the aperture scale (m_a = 1/(2sqrt(2*pi))). The half-integer value 1/2 connects to SU(2) spin-1/2 structure.

9.2 Fine-Structure Constant Prediction

The intrinsic dimensionless coupling alpha is predicted as alpha = delta_BU^4 / m_a:

alpha_CGM = delta_BU^4 / m_a = (0.195342)^4 / 0.199471 = 0.007297352563
alpha_exp = 0.0072973525693
|alpha_CGM - alpha_exp| / alpha_exp < 4 * 10^{-4}

Agreement to within 0.04% (400 ppm). The test uses a tolerance of 4e-4, which is satisfied. The CGM paper quotes 9-digit agreement, though the test uses the less precise stored value of delta_BU.

9.3 K_QG Identity

The two derivations of the quantum commutator constant agree:

K_QG_1 = (pi/4) / m_a
K_QG_2 = pi^2 / sqrt(2*pi)
|K_QG_1 - K_QG_2| < 10^{-12}

Both equal approximately 3.9374, confirming internal consistency of the CGM constant system.

9.4 Stage Action Ratios

The dimensionless stage actions satisfy:

E_ONA / E_CS = (pi/4) / (pi/2) = 1/2   (exact)
E_UNA / E_CS = (1/sqrt(2)) / (pi/2) = 2/(pi*sqrt(2))

These ratios are verified to 12 decimal places, confirming that the stage thresholds are exact geometric values (pi/2, 1/sqrt(2), pi/4) normalized to the BU aperture m_a.

9.5 Aperture Quantization Chain

The continuous aperture gap maps to exact discrete approximants at the 8-bit and depth-4 scales (TestApertureQuantizationChain). The tests verify: 256 * APERTURE_GAP rounds to 5 (byte-scale horizon 5/256); 48 * APERTURE_GAP rounds to 1 (depth-4 aperture horizon 1/48); delta_BU/(2*pi) quantizes to 8/256 = 1/32 turn. This chain connects the continuous CGM constants to discrete byte-scale and depth-4-scale quantization.

9.6 Monodromy Hierarchy

The test test_monodromy_hierarchy verifies an ordering of angular scales: omega(ONA-BU) < delta_BU < 0.587901 < 0.862833, establishing the relative sizes of the minimal defect, the BU aperture, and larger holonomy angles.

Part 10: DOF Doubling Law (test_physics_5, TestDOFDoublingLaw)

10.1 The Restriction Method

The test defines byte subsets corresponding to each CGM stage by restricting which intron bits can be non-zero. The bit subsets correspond to the CGM stage structure identified in section 2.2: CS activates only the L0 boundary bits (0, 7), UNA adds the LI payload bits (0, 1, 6, 7), and ONA uses all bits.

CS bytes:  only L0 bits (0, 7) active -> 4 bytes
UNA bytes: L0 + LI bits (0, 1, 6, 7) active -> 16 bytes
ONA bytes: all 256 bytes

BFS from GENE_MAC_REST using only the allowed bytes gives:

CS:  4    reachable states   = 2^(2*1)   = 2^2
UNA: 64   reachable states   = 2^(2*3)   = 2^6
ONA: 4096 reachable states   = 2^(2*6)   = 2^12

10.2 The Doubling Law

The continuous CGM theory gives degrees of freedom:

  • CS: 1 DOF (chirality)
  • UNA: 3 DOF (rotational, SU(2))
  • ONA: 6 DOF (rotational + translational, SE(3))

The discrete kernel gives reachable state counts 2^(2*DOF). The factor of 2 in the exponent comes from the dipole pair structure: each continuous DOF maps to exactly one dipole pair (2 bits) in the 12-bit tensor. The state space size is therefore:

|Omega_stage| = 2^(2 * DOF_continuous)

This is the exact discrete-to-continuous correspondence law. The test confirms it at all three stages with exact integer agreement.

Part 11: Depth-4 Fiber Bundle and Intrinsic K4 Geometry (test_physics_6)

This section establishes that the tetrahedral (K4) geometry used in the governance measurement layer is not an external overlay but emerges intrinsically from the depth-4 structure of the kernel. The K4 vertex set is the fiber of the depth-4 frame bundle, the K4 edges are commutator defects, and the K4 partition of the horizon induces a uniform covering of the full state space. The sixth physics test file verifies the emergence of this structure along with additional information-theoretic and representation-theoretic constraints.

11.1 K4 as the Depth-4 Fiber of the Frame Bundle

Fix a depth-4 frame of four bytes in the canonical order (Prefix, Present, Past, Future). The 48-bit payload projection

projection48 = (mask(b0), mask(b1), mask(b2), mask(b3))

is gauge-blind with respect to family selection. For fixed micro-references at the four positions, varying the 4^4 family assignments produces exactly 4 distinct output states from the rest state.

These four outcomes are indexed by the two surviving family-phase invariants (phi_a, phi_b) in (Z/2)^2. The fiber therefore has cardinality 4 and provides an intrinsic four-vertex quotient attached to each fixed depth-4 base.

This identifies a canonical K4 object at depth 4: the K4 vertex set is the fiber (Z/2)^2 that survives family-phase cancellation.

11.2 Fiber Composition Law on Net Displacements

Let W be a depth-4 frame word and let disp(W) denote the net displacement from the rest state in 24-bit space. The displacement composition law is additive under XOR: disp(W1 then W2) = disp(W1) XOR disp(W2). This is the (Z/2)^2 group law acting on displacements, not on states directly.

11.3 Canonical K4 Edge Vector from q-Invariants

Define the commutation invariant:

q(b) = mask(b) XOR (0xFFF if L0_parity(b) is odd, else 0).

For a 4-byte frame (b0, b1, b2, b3), define the six edges by pairwise differences:

e_ij = q(bi) XOR q(bj), for 0 <= i < j <= 3.

All six edges lie in the mask code C64 and satisfy the cocycle (Kirchhoff) identities required of a consistent K4 edge assignment. This provides a canonical 6-edge K4 object intrinsic to the kernel algebra of depth-4 action.

11.4 Horizon K4 Partition and Coset Structure

The horizon set for the spinorial transition law is the equality manifold A = B. Within Omega, the horizon has 64 states and partitions into four classes of 16 under pair-parity labeling of the 12-bit component.

Each 16-element vertex class is a coset of a shared 16-element kernel subgroup in mask coordinates. This establishes a boundary K4 organization with exact uniform cardinalities and explicit algebraic coset structure.

11.5 K4 Wedge Geometry: Uniform 2-Fold Cover of Omega

For each boundary vertex region (16 horizon states), define its wedge as the set of all one-step successors under the 256-byte alphabet.

Each wedge has exactly 2048 states, consistent with the 128-way SO(3) shadow fanout per state and 16 boundary states per vertex (16 x 128 = 2048). The union of the four wedges covers Omega, and every bulk state lies in exactly two wedges. This is an exact uniform 2-fold cover of Omega by boundary wedges.

11.6 Exhaustive Commutator Defect Census

The commutator loop

K(x,y) = T_x T_y T_x^{-1} T_y^{-1}

acts as a symmetric translation by defect d = q(x) XOR q(y). The defect is always in C64. The defect law is verified exhaustively over all ordered byte pairs (256^2) at the rest state, and the observed defect set equals the entire code C64.

11.7 Spinorial Stabilizers and Exact Multiplicity Laws

Three exact multiplicity theorems are verified:

  1. Horizon stabilizer gates: exactly 4 bytes preserve the horizon manifold A = B for all horizon states.
  2. q-map multiplicity: the map b |-> q(b) is exactly 4-to-1 from the 256-byte alphabet onto C64.
  3. Fixed-x commutator defect multiplicity: for fixed x, the defects q(x) XOR q(y) cover C64 with exact multiplicity 4.

11.8 Provenance Degeneracy: History Non-Uniqueness

Trajectory history is not recoverable from final state alone. This is quantified by two verified regimes:

  1. Full alphabet length-2: the 256^2 length-2 words cover Omega uniformly, with each Omega state receiving exactly 16 preimages.
  2. Restricted generator alphabet length-4: 12^4 words collapse to 1024 distinct final states, with a non-uniform preimage distribution over those finals.

These results quantify the kernel-level distinction between shared moment coordination (state agreement) and provenance (ledger requirement). They are the test-verified basis for the spec claim that the byte ledger is the record of kernel steps and that the state is a shared observable for coordination, not a unique identifier of history.

11.9 Erasure Taxonomy on the [12,6,2] Code

The erasure taxonomy characterizes the code's resilience to partial observation: how many bit positions must be observed to uniquely recover a codeword?

For the self-dual [12,6,2] code, the information-set threshold is exactly 6 observed bit positions. An exhaustive size-4 erasure census (C(12,4) patterns) yields a rank and ambiguity histogram consistent with dipole-pair redundancy.

Additionally, pair erasure behavior is exact:

  • erasing one bit of a dipole pair does not reduce rank,
  • erasing both bits of a dipole pair reduces rank by exactly 1.

11.10 Hilbert-Lift Entanglement Sanity Checks

The Hilbert-lift checks verify that the code supports standard quantum information constructions, establishing that the kernel's algebraic structure is compatible with entanglement-based protocols. Using C64 as a computational basis for a bipartite Hilbert space H_u tensor H_v:

  • Cartesian-product subsets yield near-zero von Neumann entropy on the reduced density (separable construction),
  • XOR-graph subsets yield maximal reduced entropy log2(64) = 6 bits (maximally entangled on the code subspace).

These checks establish standard bipartite entropy behavior under the code lift.

Summary: What the Tests Establish

The physics tests collectively establish the following properties of the Gyroscopic ASI aQPU Kernel kernel:

Conformance (test_physics_1): The implementation correctly realizes all specification requirements including state packing, transcription, intron decomposition, mask expansion, spinorial transition, inverse, shadow count, and depth-4 alternation.

Algebraic structure (test_physics_2): The mask code is a self-dual [12,6,2] binary linear code with Walsh spectrum {0, 64}. The dual code equals the code itself. Single-bit errors are always detectable.

Affine dynamics (test_physics_3): Every byte implements an affine swap on GF(2)^12. Word actions are either identity or swap linear part plus XOR translation. Depth-4 alternation is affine cancellation.

Spinorial universe (test_physics_4): Omega has 4096 states, radius 2, 64 horizon states, and satisfies the holographic ratio 64^2 = 4096. The reference byte has 64 fixed points and 2016 two-cycles on Omega. Every non-reference byte has order 4 on Omega. Commutator defects live in C64.

Depth-4 fiber bundle and intrinsic K4 (test_physics_6): For fixed depth-4 payload geometry, family-phase gauge freedom collapses to a 4-element fiber indexed by (phi_a, phi_b) in (Z/2)^2. Horizon states partition into four 16-element cosets, and the induced boundary wedges form a uniform 2-fold cover of Omega. Additional exact multiplicity laws are verified (4 horizon stabilizers, 4-to-1 q-map, uniform 16-to-1 length-2 provenance).

Theory bridge (test_physics_5): The kernel constants satisfy all CGM continuous invariants including Q_G * m_a^2 = 1/2, the fine-structure constant prediction to 0.04%, the K_QG identity, the stage action ratios, and the aperture quantization chain (5/256, 1/48, 8/256 turn). The DOF doubling law 2^(2*DOF) connects continuous degrees of freedom to discrete state counts. The product structure Omega = U x V implements optical conjugacy with constant density 0.5 at every state.

The full test suite confirms that the discrete 24-bit byte-driven kernel is a faithful finite-group realization of the CGM theoretical framework at the kernel level, with exact integer theorems replacing the continuous relations of the original physics. The governance measurement layer (aperture, domain ledgers, Hodge decomposition) is not covered by these physics tests.