From 2c45e55b6b094c41f4a791fc77b0ac02bb1cb337 Mon Sep 17 00:00:00 2001 From: allaun Date: Tue, 30 Jun 2026 04:49:25 -0500 Subject: [PATCH] chore: add experiment file, gitignore qc_flag backups - Breaking symmetry to create a parallel-plate.md experiment note - .gitignore: ignore mutation test backup files --- .gitignore | 1 + ...ing symmetry to create a parallel-plate.md | 1654 +++++++++++++++++ 2 files changed, 1655 insertions(+) create mode 100644 experiments/Breaking symmetry to create a parallel-plate.md diff --git a/.gitignore b/.gitignore index 9a5bead5..79944922 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,4 @@ docs/concept_map/*.jsonl *.png extraction/ scratch/ +scripts/qc_flag/.backups/ diff --git a/experiments/Breaking symmetry to create a parallel-plate.md b/experiments/Breaking symmetry to create a parallel-plate.md new file mode 100644 index 00000000..ecc8532b --- /dev/null +++ b/experiments/Breaking symmetry to create a parallel-plate.md @@ -0,0 +1,1654 @@ +https://arxiv.org/pdf/2606.20371 + +1. The Starting Point: Two Unrelated Systems That Do the Same Thing + +Bergmann et al. (arxiv 2606.20371): A materials science paper. They take Ruddlesden-Popper perovskite layers — atoms arranged in a specific crystal lattice — and break the out-of-plane symmetry. The original crystal structure forbids a parallel-plate varactor geometry. Break the symmetry → the geometry becomes possible → 10× figure-of-merit improvement at 10 GHz. + + +SilverSight (GitHub): A mathematical framework for equation search and classification. It maps equations to positions on a manifold using chaos game theory, Sidon sets, Fisher information geometry, and QUBO-QAOA optimization. Everything runs through fixed-point arithmetic (Q16_16), formalized in Lean 4. + + +These two systems share no code, no physics, no domain. What they share is a structural pattern: a constraint that forbids a useful configuration, and the act of removing that constraint to access something better. + + + +2. The Naive Analogy (and Why It Fails) + +The first-pass analogy is: + + +"Bergmann breaks symmetry → better varactor. SilverSight breaks constraints → better classification. Same thing." + + +This is true at the level of vibes. It's false at the level of math. A reviewer would destroy it: + + +Bergmann's symmetry breaking is a physical phase transition — atoms rearranging into a different crystal structure. +SilverSight's constraint relaxation is a mathematical operation — enlarging a feasible set in optimization. +These are different mechanisms in different domains. Calling them "the same" without proof is hand-waving. + +The synthesized response tried to formalize this analogy into a theorem. The Feasible-Set Relaxation Theorem says: if you have nested constraint families C₀ ⊇ C₁ ⊇ C₂ ⊇ ..., then the feasible sets S_k expand, and the optimal objective value monotonically decreases (or stays equal). Strict improvement happens when the true optimizer requires the relaxed constraint. + + +The theorem is mathematically correct. But the connection to Bergmann and SilverSight was asserted, not derived. + + + +3. The Vulnerability Audit: Four Traps That Would Kill the Theorem + +Before connecting anything, the theorem itself needed to be bulletproof. Four specific weaknesses: + + +Trap 1: The Infimum Trap. The theorem claimed: if no minimizer of the relaxed space satisfies the original constraint, then the infimum strictly decreases. Counterexample: L(x) = x on X = ℝ, S_k = (0,1], S_{k+1} = [0,1]. The infimum is 0 on both sets, but the minimizer {0} is only in S_{k+1}. The hypothesis is satisfied but the conclusion (0 < 0) is false. Fix: Require that the minimum is attained (a minimizer exists) on both sets. + + +Trap 2: The Equality-Only Trap. The original formulation only allowed equality constraints C_i(x) = 0. Standard optimization uses inequalities g(x) ≤ 0 and domain boundaries. Fix: Define constraints as abstract predicates or subsets, not equations. + + +Trap 3: The Idempotent Operator Trap. Framing expansion as an operator E(S_k) = S_{k+1} means if E is a closure operator, E(E(S)) = E(S) — you can never expand again after one step. Fix: Use nested constraint families C_{k+1} ⊆ C_k instead of operator application. + + +Trap 4: The Boundedness Trap. "L is bounded below" — but below where? On S_0? On S_{k+1}? On the union? Fix: State boundedness on ⋃_{k≥0} S_k. + + +These are all real mathematical traps. A hostile reviewer would exploit any one. The fixes are standard variational analysis — nothing exotic, just precision. + + + +4. The Bridge: Why Lattice Structure Connects Everything + +The user identified the missing piece: lattice-based mathematical structures are the shared substrate. + + +Bergmann's lattice: Ruddlesden-Popper perovskites are crystal lattices. The symmetry group of the lattice determines what device geometries are possible. Breaking out-of-plane symmetry = reducing the symmetry group of the lattice. The physical mechanism is: take the same atoms, rearrange them into a lattice with a smaller symmetry group, and access configurations that were structurally prohibited. + + +SilverSight's lattices: + +Sidon sets are defined over additive groups (ℤ/nℤ). They're combinatorial lattice structures where all pairwise sums are distinct. The addressing system is a lattice labeling scheme. +QUBO maps to Ising models on graph/lattice Hamiltonians. The optimization is over lattice-configured binary variables. +Chaos game iterates function systems over discrete address spaces with lattice structure. +Fisher metric lives on the probability simplex Δ⁷, which has the structure of a lattice-adjacent manifold (the simplex is the state space of a lattice system with 8 sites). + +The bridge formula: + + +text +Lattice symmetry group → Constraint family → Feasible set + +In all three systems: + +The lattice has a symmetry group G +Constraints C_k correspond to subgroup chains G₀ ≥ G₁ ≥ G₂ ≥ ... +Relaxing constraints = reducing the symmetry group = enlarging the feasible set +The Feasible-Set Relaxation Theorem guarantees the objective monotonically improves + + +5. The Pipeline Map: Where Does Constraint Relaxation Actually Help? + +This is where the analysis gets concrete. I pulled every file in the SilverSight pipeline and traced the constraints at each step: + + +Step 1→2: Spectral Profile → Sidon Address + +Constraint: Sidon property (all pairwise sums unique) +Relaxation would allow address collisions +Verdict: Hurts. The Sidon property is what makes addressing deterministic. Relaxing it adds noise, not signal. + +Step 2→3: Sidon Address → Chaos Game + +Constraint: 4 fixed basins (void, orbit, braid, observer), each 2 rows of the 8×8 matrix +Relaxation would allow more basins or variable topology +Verdict: Marginal. The theorem applies (more basins = larger feasible set of convergence targets), but the chaos game's convergence speed isn't covered by the theorem. You might get better classification targets but slower convergence. + +Step 3→4: Chaos Game → Finsler Metric + +Constraint: Chentsov uniqueness — the Fisher metric α is the ONLY Riemannian metric on Δ⁷ invariant under all Markov embeddings +Relaxation would allow non-Fisher metrics +Verdict: Medium potential. Chentsov pins you to exactly one metric. If that metric doesn't best separate the Hachimoji states for classification, there's a better metric in the relaxed family. The theorem guarantees you won't regress. But you'd need to show that the Fisher metric is actually suboptimal for the classification task. + +Step 4→5: Finsler Metric → QUBO ← THIS IS THE ONE + +Constraint: One-hot encoding (CONFLICT_PENALTY = 20.0 forces exactly one state selected) +Relaxation: Allow k-hot (select multiple states) +Verdict: High gain. Here's why: + +The QUBO has 8 binary variables x_i, one per Hachimoji state. The one-hot constraint forces Σx_i = 1 — you must pick exactly one state. But equations don't have single identities. An equation like "a² + b² = c²" has both symmetric structure (Pythagorean → Σ state) and topological structure (distance metric → Φ state). The one-hot constraint forces the QUBO to pick one, discarding the other. + + +Relaxing to k-hot means: select the subset of states that best characterizes the equation. The Feasible-Set Relaxation Theorem guarantees: + +The QUBO energy over k-hot assignments ≤ one-hot assignments (monotone improvement) +If the true best characterization requires multiple states, the improvement is strict + +This is the exact Bergmann parallel: + + +Bergmann SilverSight QUBO +Crystal symmetry forces in-plane device One-hot forces single-state classification +Break out-of-plane symmetry Relax to k-hot +Parallel-plate geometry becomes accessible Multi-state characterization becomes possible +10× figure-of-merit Better classification fidelity + +Step 5→6: QUBO → Optimization + +Constraint: Binary x_i ∈ {0,1} +Relaxation: Continuous x_i ∈ [0,1] +Verdict: Standard. Every QUBO practitioner already does this. The theorem applies but adds no new insight. + +Step 6→7: Solution → Receipt + +Constraint: Schema, WireFormat, Q16_16 fixed-point +Verdict: Doesn't apply. This is data integrity, not optimization. + +Step 7→8: Receipt → Formal Verification + +Constraint: 0 sorries in proof chain +Verdict: Doesn't apply. Verification is logical, not variational. + + +6. The Complete Picture + +text +6. The Complete Picture (Redone) + +The pipeline analysis reveals that constraint relaxation isn't uniformly useful — it's surgically specific. One step gets transformative improvement. Two get marginal gains. Four don't benefit at all. Here's the complete map with the actual mechanism at each point. + + +The Pipeline With Constraints Labeled + +text +EQUATION + │ + │ Step 1→2: Spectral Profile → Sidon Address + │ CONSTRAINT: Sidon property (pairwise sums unique) + │ LATTICE: Additive group ℤ/128ℤ, subset {1,2,4,8,16,32,64,128} + │ RELAXATION: Allow address collisions + │ EFFECT: ❌ DESTROY — Sidon is load-bearing; collisions break + │ deterministic strand assignment, chaos game convergence + │ depends on unique mapping from address → strand + │ + ▼ +SIDON ADDRESS [1,2,4,8,16,32,64,128] + │ + │ Step 2→3: Sidon Address → Chaos Game + │ CONSTRAINT: 4 fixed basins (2 rows each in 8×8 matrix) + │ LATTICE: Partition of ℤ/8ℤ into 4 cosets of 2ℤ + │ RELAXATION: Variable basin count, adaptive partition + │ EFFECT: ⚠️ MARGINAL — more basins = finer classification targets + │ but slower convergence; theorem guarantees energy ratio + │ won't worsen but doesn't bound convergence steps + │ + ▼ +BASIN CONVERGENCE (q_void | q_orbit | q_braid | q_observer) + │ + │ Step 3→4: Chaos Game → Finsler Metric + │ CONSTRAINT: Chentsov uniqueness (α = Fisher, the ONLY invariant metric) + │ LATTICE: Probability simplex Δ⁷ with Markov embedding symmetry + │ RELAXATION: Drop invariance, allow non-Fisher Riemannian metrics + │ EFFECT: ⚠️ MEDIUM — Chentsov pins you to ONE metric; if Fisher + │ doesn't maximally separate Hachimoji states for classification, + │ a better metric exists in the relaxed family. Theorem guarantees + │ no regression. Need empirical evidence that Fisher is suboptimal. + │ + ▼ +FINSLER DISTANCE MATRIX (8×8, F = α + β) + │ + │ Step 4→5: Finsler Metric → QUBO Encoding + │ CONSTRAINT: One-hot (Σx_i = 1, CONFLICT_PENALTY = 20.0) + │ LATTICE: Vertices of hypercube {0,1}⁸ restricted to simplex face + │ RELAXATION: k-hot (Σx_i ≤ k, or soft penalty instead of hard) + │ EFFECT: ✅✅ TRANSFORMATIVE — this is the load-bearing constraint + │ that forces single-state classification of multi-state equations + │ + ▼ +QUBO MATRIX (8 binary variables, Q_ij encoding) + │ + │ Step 5→6: QUBO → Optimization + │ CONSTRAINT: Binary x_i ∈ {0,1} + │ LATTICE: Boolean hypercube {0,1}⁸ + │ RELAXATION: Continuous [0,1]⁸ + │ EFFECT: ✅ STANDARD — textbook continuous relaxation, every QUBO + │ solver already does this; theorem applies but adds no new insight + │ + ▼ +OPTIMAL STATE ASSIGNMENT + │ + │ Step 6→7: Solution → Receipt + │ CONSTRAINT: Schema, WireFormat, Q16_16 fixed-point + │ RELAXATION: N/A — not an optimization problem + │ EFFECT: ❌ THEOREM DOESN'T APPLY — data integrity, not variational + │ + ▼ + │ Step 7→8: Receipt → Formal Verification + │ CONSTRAINT: 0 sorries, all axioms justified + │ RELAXATION: N/A — not an optimization problem + │ EFFECT: ❌ THEOREM DOESN'T APPLY — logical verification, not variational + │ + ▼ +VERIFIED CLASSIFICATION + +Why Step 4→5 Is the Critical One (Deep Dive) + +The current QUBO encoding in qubo_builder.py does this: + + +python +# Conflict penalty: selecting two states together is heavily penalized +CONFLICT_PENALTY = 20.0 + +# Off-diagonal: large positive penalty for any pair +for i in range(n): + for j in range(i + 1, n): + Q[(i, j)] = CONFLICT_PENALTY + +# Diagonal: target gets strongest reward +for i in range(n): + if i == target_idx: + Q[(i, i)] = -15.0 # strong reward for target + elif i == (target_idx + 1) % 8 or i == (target_idx - 1) % 8: + Q[(i, i)] = -8.0 # moderate reward for S¹ neighbors + elif i == (target_idx + 4) % 8: + Q[(i, i)] = -5.0 # small reward for opposite + else: + Q[(i, i)] = -3.0 # minimal reward for others + +The conflict penalty (20.0) is larger than the maximum possible reward (-3.0 for non-target states). This means: selecting ANY two states together costs more than the benefit of the weaker state. The QUBO is structurally forced to pick exactly one. + + +But consider what this does to an equation like: + + +text +∀x. P(x) → Q(x) ∧ a² + b² = c² + +This equation has: + +Universal quantification → Λ state (lattice/room regime) +Pythagorean structure → Σ state (symmetric partner) +Both are genuinely present in the equation's structure + +The one-hot QUBO picks ONE. The equation_to_target_state function does string matching: + + +python +if "∀x" in equation or "forall" in equation: + return "Λ" # picks Λ, ignores Σ +elif "a^2+b^2=c^2" in equation: + return "Σ" # picks Σ, ignores Λ + +The conflict penalty ensures the other state is never selected. Information is destroyed. + + +The k-hot relaxation: Change CONFLICT_PENALTY from 20.0 to a smaller value (say 5.0). Now the QUBO can select multiple states if their combined reward exceeds the conflict cost. The Feasible-Set Relaxation Theorem guarantees: + + +1.The k-hot minimum energy ≤ one-hot minimum energy (monotone) +2.If the true optimal characterization requires multiple states (Argmin of one-hot ∩ one-hot-constraint = ∅), improvement is strict + +The Lean 4 formalization would use: + +lean +-- One-hot constraint +def OneHot (x : Fin 8 → Bool) : Prop := ∃! i, x i = true + +-- k-hot constraint +def AtMostK (k : Nat) (x : Fin 8 → Bool) : Prop := (Finset.univ.filter (fun i => x i = true)).card ≤ k + +-- Nested: OneHot ⊆ AtMostK 2 ⊆ AtMostK 3 ⊆ ... +-- S_{oneHot} ⊆ S_{kHot} ⊆ S_{all} + +Why Steps 3→4 Is the Secondary Opportunity + +Chentsov's theorem (formalized in ChentsovFinite.lean) says: the Fisher metric g_p(u,v) = Σ u_i v_i / p_i is the UNIQUE Riemannian metric on Δ⁷ invariant under all Markov embeddings. + + +This is a uniqueness constraint. It pins α to exactly one functional form. The drift component β is then determined by the Hachimoji phase topology (the circular S¹ structure of the 8 states). + + +Relaxing Chentsov invariance means: consider metrics that are NOT invariant under all Markov embeddings. The feasible set of metrics expands from {Fisher} to {all Riemannian metrics on Δ⁷}. The theorem guarantees the optimal metric in this larger family is at least as good as Fisher for any distance-based objective. + + +When would this help? If the Fisher metric creates degenerate distances between states that should be well-separated. At the uniform distribution p_i = 1/8, the Fisher metric is g = 8·I — all directions have the same curvature. There's no preferential separation. A metric adapted to the Hachimoji structure (e.g., one that increases curvature along the S¹ phase direction) could better separate adjacent states. + + +The constraint chain: + +text +C₀ = "metric is Chentsov-invariant" → {Fisher} +C₁ = "metric is Markov-invariant on subgroups" → {Fisher + variants} +C₂ = "metric is Riemannian on Δ⁷" → {all Riemannian} +C₃ = "metric is Finsler on Δ⁷" → {all Finsler including Randers} + +Each relaxation expands the feasible set. The current SilverSight pipeline already uses Randers (F = α + β), which is in C₃ but not C₀. So the system is already partially relaxed — the β drift component is a non-Chentsov addition. The theorem would formalize why this is justified: the Randers metric is at least as good as pure Fisher for the Hachimoji classification task. + + +Why Steps 1→2, 2→3 Don't Benefit (and Why That's Informative) + +Sidon (Step 1→2): The Sidon property is a collision-avoidance constraint. It's not blocking better solutions — it's preventing address ambiguity. Relaxing it doesn't enlarge the set of "good" address assignments; it enlarges the set of "ambiguous" ones. The Feasible-Set Relaxation Theorem applies formally (more address sets = larger feasible set), but the objective function (addressing quality) gets worse, not better. This tells us: not all constraints are bottlenecks. Some are load-bearing. + + +Chaos game basins (Step 2→3): The 4-basin structure is a resolution constraint. It limits the chaos game to 4 convergence targets when there are 8 Hachimoji states. Relaxing to 8 basins would give finer classification. But the theorem only guarantees the energy ratio won't worsen — it says nothing about convergence steps. The chaos game's practical bottleneck is convergence speed, not energy quality. This tells us: the theorem guarantees improvement in the objective you're optimizing, but if the real bottleneck is a different quantity (convergence speed), the theorem doesn't help. + + +The Updated Summary + +Step Constraint Nature Relaxation Effect Theorem Role +1→2 Sidon Collision-avoidance ❌ Destructive Doesn't help (wrong objective) +2→3 4-basin Resolution limit ⚠️ Marginal Guarantees energy, not speed +3→4 Chentsov uniqueness Metric pinning ✅ Opens metric family Formalizes why Randers is justified +4→5 One-hot Exclusivity ✅✅ Multi-state Primary instantiation +5→6 Binary Domain restriction ✅ Standard Textbook, no new insight +6→7 Schema Data integrity N/A Doesn't apply +7→8 0-sorry Logical N/A Doesn't apply + + +7. What the Manuscript Needs + +**Section + +7. The Manuscript (Full Draft Plan) + +Title + +Feasible-Set Relaxation on Lattices: From Symmetry Breaking to Multi-State Optimization + + + +§1 — The Theorem + +Goal: State and prove the theorem with zero ambiguity. No interpretation, no applications — pure math. + + +Definitions: + + +Let X be a set (state space). Let {C_k}_{k≥0} be a decreasing sequence of predicates on X: + + +C +0 +⊇ +C +1 +⊇ +C +2 +⊇ +⋯ +C +0 +​ + ⊇C +1 +​ + ⊇C +2 +​ + ⊇⋯ + + +Define the admissible set at step k: + + +S +k +: += +{ +x +∈ +X +∣ +∀ +c +∈ +C +k +, + +c +( +x +) +} +S +k +​ + :={x∈X∣∀c∈C +k +​ + , c(x)} + + +Consequence of nesting: C_{k+1} ⊆ C_k means every x satisfying the larger family automatically satisfies the smaller. Therefore: + + +S +k +⊆ +S +k ++ +1 +S +k +​ + ⊆S +k+1 +​ + + + +Let L : X → ℝ be an objective functional, bounded below on ⋃_{k≥0} S_k. Define: + + +v +k +: += +inf +⁡ +x +∈ +S +k +L +( +x +) +v +k +​ + :=inf +x∈S +k +​ + +​ + L(x) + + +Theorem (Feasible-Set Relaxation): + + +Part 1 (Weak Monotonicity). For all k: + + +v +k ++ +1 +≤ +v +k +v +k+1 +​ + ≤v +k +​ + + + +Proof. S_k ⊆ S_{k+1} implies inf over a larger set ≤ inf over a smaller set. ∎ + + +Part 2 (Strict Improvement). Assume L attains its minimum on both S_k and S_{k+1} (i.e., Argmin(L|{S_k}) ≠ ∅ and Argmin(L|{S_{k+1}}) ≠ ∅). If: + + +Argmin +⁡ +( +L +∣ +S +k ++ +1 +) +∩ +S +k += +∅ +Argmin(L∣ +S +k+1 +​ + +​ + )∩S +k +​ + =∅ + + +then: + + +v +k ++ +1 +< +v +k +v +k+1 +​ + x i = true)).card = 1 + +def AtMostK (k : Nat) (x : Fin 8 → Bool) : Prop := + (Finset.univ.filter (fun i => x i = true)).card ≤ k + +-- Nesting: OneHot ⊆ AtMostK 2 ⊆ AtMostK 3 ⊆ ... +theorem oneHot_subset_atMostK : + {x | OneHot x} ⊆ {x | AtMostK 2 x} := by + intro x hx; simp at hx ⊢; linarith + +-- Application of Feasible-Set Relaxation +theorem qubo_relaxation (Q : Fin 8 → Fin 8 → ℤ) : + let v0 := sInf {x^T Q x | x, OneHot x} + let v1 := sInf {x^T Q x | x, AtMostK 2 x} + v1 ≤ v0 := sInf_le_sInf (fun _ ⟨x, hx, rfl⟩ => ⟨x, oneHot_subset_atMostK hx, rfl⟩) + +Figure 3: Bar chart showing QUBO energy for one-hot vs k-hot on 10 test equations. Most equations show improvement; none show regression (theorem guarantee). + + + +§4 — Application: Chentsov Metric Relaxation + +Goal: Show that the Fisher metric is a constraint, and relaxing it opens a family of metrics that may better separate Hachimoji states. + + +§4.1 — Chentsov as a Constraint + + +Chentsov's theorem (1972, formalized in ChentsovFinite.lean): the Fisher metric g_p(u,v) = Σ u_i v_i / p_i is the UNIQUE Riemannian metric on Δ⁷ invariant under all Markov embeddings. + + +This is a uniqueness constraint. The feasible set of "Chentsov-invariant metrics" contains exactly one element: Fisher. + + +§4.2 — The Constraint Chain + + +C₀: metric is Chentsov-invariant → {Fisher} +C₁: metric is invariant under permutations of Δ⁷ → {Fisher + diagonal variants} +C₂: metric is Riemannian on Δ⁷ → {all Riemannian metrics} +C₃: metric is Finsler on Δ⁷ → {all Finsler metrics including Randers} + +SilverSight already uses C₃ (the Randers metric F = α + β). The β drift component is a non-Chentsov addition. The theorem formalizes why this is justified: the Randers metric is in a larger feasible set than Fisher, so its optimal value is ≤ Fisher's optimal value for any distance-based objective. + + +§4.3 — When Would Non-Fisher Be Better? + + +At the uniform distribution p_i = 1/8, Fisher gives g = 8·I — isotropic curvature. All directions are equivalent. But the Hachimoji states have a natural circular topology (phases at 0°, 45°, 90°, ..., 315°). A metric with higher curvature along the S¹ phase direction would better separate adjacent states. + + +The Feasible-Set Relaxation Theorem guarantees: if there exists a non-Fisher metric that better separates the Hachimoji states (in the sense of minimum pairwise distance), then the optimal metric in the relaxed family achieves at least as good classification as Fisher. + + +§4.4 — Connection to the QUBO Application + + +§4.4 — Connection to the QUBO Application + +4.4.1 The One-Hot Constraint as a Lattice Symmetry Restriction + +The SilverSight QUBO encoding (qubo_builder.py) maps each equation to an 8-variable binary optimization problem over the Hachimoji state space {Φ, Λ, Ρ, Κ, Ω, Σ, Π, Ζ}. The encoding imposes a one-hot constraint through the conflict penalty structure: + + +Q +i +j += +{ +− +α +i +⋅ +r +i += +j + (self-reward) +β +i +j +⋅ +d +ϕ +( +i +, +j +) +2 +⋅ +w +i +≠ +j + (phase coupling) +Q +ij +​ + ={ +−α +i +​ + ⋅r +β +ij +​ + ⋅d +ϕ +​ + (i,j) +2 + ⋅w +​ + +i=j (self-reward) +i + +=j (phase coupling) +​ + + + +where the conflict penalty +P +conflict += +20.0 +P +conflict +​ + =20.0 dominates all off-diagonal terms. Since the maximum self-reward magnitude is +∣ +− +15.0 +∣ += +15.0 +∣−15.0∣=15.0 (for the target state) and the conflict penalty exceeds this, any assignment with +x +i += +x +j += +1 +x +i +​ + =x +j +​ + =1 for +i +≠ +j +i + +=j has strictly higher energy than the corresponding one-hot assignment. The QUBO is structurally constrained to the face of the hypercube +{ +0 +, +1 +} +8 +{0,1} +8 + where +∑ +i +x +i += +1 +∑ +i +​ + x +i +​ + =1. + + +This constraint can be understood as a lattice symmetry restriction. The Hachimoji state space carries a +Z +/ +8 +Z +Z/8Z phase symmetry (states are positioned at +45 +° +45° intervals on +S +1 +S +1 + ). The one-hot constraint selects exactly one element from each orbit of the trivial subgroup +{ +e +} +≤ +Z +/ +8 +Z +{e}≤Z/8Z. Relaxing to +k +k-hot corresponds to selecting subsets that are invariant under a smaller subgroup — equivalently, enlarging the admissible set of assignments. + + +4.4.2 Applying the Feasible-Set Relaxation Theorem + +We instantiate the theorem as follows. + + +State space. +X += +{ +0 +, +1 +} +8 +X={0,1} +8 + , the Boolean hypercube. + + +Objective functional. +L +: +X +→ +R +L:X→R is the QUBO energy: + + +L +( +x +) += +∑ +i +≤ +j +Q +i +j +  +x +i +  +x +j +L(x)=∑ +i≤j +​ + Q +ij +​ + x +i +​ + x +j +​ + + + +Constraint families. Define: + + +C +k += +{ +x +∈ +X +   +| +   +∑ +i += +0 +7 +x +i +≤ +k +} +, +k += +1 +, +2 +, +… +, +8 +C +k +​ + ={x∈X +​ + ∑ +i=0 +7 +​ + x +i +​ + ≤k},k=1,2,…,8 + + +Then +C +1 +⊆ +C +2 +⊆ +⋯ +⊆ +C +8 += +X +C +1 +​ + ⊆C +2 +​ + ⊆⋯⊆C +8 +​ + =X, and the corresponding admissible sets satisfy +S +1 +⊆ +S +2 +⊆ +⋯ +⊆ +S +8 +S +1 +​ + ⊆S +2 +​ + ⊆⋯⊆S +8 +​ + . + + +Attainment. +X +X is finite (256 elements), so +L +L attains its minimum on every +S +k +S +k +​ + . The attainment hypothesis is automatically satisfied. + + +Boundedness. +L +L is bounded below on +X +X (finite set, real-valued function). The boundedness hypothesis is satisfied. + + +Application. By Part 1 of the theorem: + + +v +k ++ +1 +≤ +v +k +for all +k +≥ +1 +v +k+1 +​ + ≤v +k +​ + for all k≥1 + + +where +v +k += +min +⁡ +x +∈ +S +k +L +( +x +) +v +k +​ + =min +x∈S +k +​ + +​ + L(x). The QUBO energy under +k +k-hot assignment is monotonically non-increasing as +k +k increases. + + +By Part 2: if +Argmin +⁡ +( +L +∣ +S +k ++ +1 +) +∩ +S +k += +∅ +Argmin(L∣ +S +k+1 +​ + +​ + )∩S +k +​ + =∅ — that is, if every optimal +( +k ++ +1 +) +(k+1)-hot assignment uses strictly more than +k +k states — then +v +k ++ +1 +< +v +k +v +k+1 +​ + +P +⋅ +d +ϕ +( +Λ +, +Σ +) +2 +∣Q +ΛΛ +​ + ∣+∣Q +ΣΣ +​ + ∣>P⋅d +ϕ +​ + (Λ,Σ) +2 + + + +would allow the two-hot assignment to have lower energy than the one-hot assignment. The Feasible-Set Relaxation Theorem guarantees this transition is monotone: as +P +P decreases, the optimal energy never increases. + + +4.4.4 The Parallel to Bergmann et al. + +The structural correspondence between the QUBO relaxation and the Bergmann varactor result is now precise: + + +Bergmann (2606.20371) SilverSight QUBO +Crystal lattice: RP perovskite stack Combinatorial lattice: +{ +0 +, +1 +} +8 +{0,1} +8 + hypercube +Symmetry group: out-of-plane space group Constraint: one-hot ( +∑ +x +i += +1 +∑x +i +​ + =1) +Symmetry break: reduce to subgroup Constraint relaxation: +k +k-hot ( +∑ +x +i +≤ +k +∑x +i +​ + ≤k) +Prohibited geometry: parallel-plate varactor Prohibited assignment: multi-state classification +Effect: 10× figure-of-merit at 10 GHz Effect: +v +k +< +v +1 +v +k +​ + x i = true)).card ≤ k + +-- Nested inclusion: OneHot ⊆ AtMostK 2 +theorem onehot_subset_atmost2 : + {x : HachimojiState | OneHot x} ⊆ {x | AtMostK 2 x} := by + intro x hx + simp only [Set.mem_setOf_eq] at hx ⊢ + obtain ⟨i, hi, huniq⟩ := hx + have : (Finset.univ.filter (fun j => x j = true)).card ≤ 2 := by + -- x has exactly one true entry, so card = 1 ≤ 2 + sorry -- close with Finset.card_le_one + exact this + +-- QUBO energy +def quboEnergy (Q : Fin 8 → Fin 8 → Int) (x : HachimojiState) : Int := + Finset.univ.sum (fun i => + Finset.univ.sum (fun j => + if i ≤ j ∧ x i ∧ x j then Q i j else 0)) + +-- Monotone improvement +theorem qubo_relaxation_monotone (Q : Fin 8 → Fin 8 → Int) : + -- minimum over AtMostK 1 ≤ minimum over AtMostK 2 + -- follows from OneHot ⊆ AtMostK 2 and general FSR theorem + sorry + +The sorry at onehot_subset_atmost2 is a trivial Finset cardinality argument. The qubo_relaxation_monotone follows directly from the general Feasible-Set Relaxation Theorem (§3) instantiated on the finite hypercube. + + +4.4.6 Practical Implications + +The theorem does not prescribe how much to relax the conflict penalty. It guarantees direction (never worse) and strictness (strictly better when multi-state character exists). The magnitude of improvement depends on the specific equation and the QUBO coefficients. + + +For the SilverSight pipeline, the recommended implementation is: + + +1. +Parameterize the conflict penalty. Replace the hard-coded CONFLICT_PENALTY = 20.0 with a parameter +P +P. + +2. +Sweep +P +P from 20.0 downward. For each +P +P, solve the QUBO and record the optimal energy and state assignment. + +3. +Detect the transition point. The value +P +∗ +P +∗ + where the optimal assignment transitions from one-hot to two-hot is the critical relaxation threshold. Below +P +∗ +P +∗ + , the QUBO captures multi-state character. + +4. +Use the theorem to validate. The monotone energy curve +v +( +P +) +v(P) is guaranteed non-increasing. Any violation indicates a solver error, not a theorem failure. + + +This turns the Feasible-Set Relaxation Theorem from a theoretical guarantee into a practical diagnostic tool: the shape of the +v +( +P +) +v(P) curve reveals how much structural information the one-hot constraint was destroying.