SilverSight/experiments/Breaking symmetry to create a parallel-plate.md

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
​
 <v 
k
​
 


Proof. Let x* ∈ Argmin(L|{S{k+1}}). By hypothesis, x* ∉ S_k. Since Argmin(L|{S_k}) ≠ ∅, let y* ∈ Argmin(L|{S_k}). Then y* ∈ S_k ⊆ S_{k+1}, so L(x*) ≤ L(y*). If L(x*) = L(y*), then y* ∈ Argmin(L|{S{k+1}}) ∩ S_k, contradicting the hypothesis. Therefore L(x*) < L(y*), i.e., v_{k+1} < v_k. ∎


Figure 1: Nested sets expanding, infimum arrow moving down.



§2 — Lattice Instantiation

Goal: Show what the theorem says when X carries lattice structure and C_k are symmetry predicates.


Let X be a lattice (discrete additive group ℤ/nℤ, or a graph lattice, or the probability simplex Δⁿ with its natural lattice-like structure). Let G₀ ≥ G₁ ≥ G₂ ≥ ... be a descending chain of symmetry groups acting on X. Define:


C
k
:
=
{
x
∈
X
∣
x
 is invariant under 
G
k
}
C 
k
​
 :={x∈X∣x is invariant under G 
k
​
 }


Then C_{k+1} ⊆ C_k (fewer symmetry requirements = more admissible configurations) and S_k ⊆ S_{k+1}.


Corollary (Symmetry Reduction). If L is an objective on the lattice and the symmetry groups form a descending chain, then reducing symmetry monotonically improves (or maintains) the optimal objective value. Strict improvement occurs when the global optimizer requires broken symmetry — it literally cannot exist in the higher-symmetry phase.


Three instances:


System	Lattice X	Symmetry group G_k	Constraint C_k
Bergmann	Perovskite RP layer stack	Space group with out-of-plane symmetry	Crystal structure invariant under G_k
SilverSight QUBO	Hypercube {0,1}⁸	One-hot symmetry (permutation + exclusivity)	Σx_i = 1
SilverSight metric	Probability simplex Δ⁷	Chentsov invariance (Markov embedding group)	Metric invariant under all Markov maps

Figure 2: Three columns showing the same pattern: lattice → symmetry group → constraint chain → feasible set expansion.



§3 — Application: QUBO One-Hot Relaxation

Goal: This is the headline result. Show concretely how one-hot → k-hot improves equation classification.


§3.1 — The Current System


SilverSight's QUBO encodes 8 binary variables x_i (one per Hachimoji state: Φ, Λ, Ρ, Κ, Ω, Σ, Π, Ζ). The encoding in qubo_builder.py:


Diagonal: Q_{ii} = -α(state_i) (reward for selecting state i)
Off-diagonal: Q_{ij} = CONFLICT_PENALTY = 20.0 for all i ≠ j

The conflict penalty exceeds any possible reward (max |Q_{ii}| = 15.0). Therefore the QUBO solution is forced to have at most one active variable. This is the one-hot constraint.


§3.2 — The Problem


Equations don't have single identities. The classification function equation_to_target_state uses string matching:


python
if "∀x" in equation:    return "Λ"
elif "a^2+b^2=c^2":     return "Σ"
else:                    return hash-based default

An equation with both universal quantification AND Pythagorean structure gets classified as ONE state. The other is destroyed by the conflict penalty.


§3.3 — The Relaxation


Replace the hard conflict penalty with a soft penalty:


python
# Before: CONFLICT_PENALTY = 20.0  (forces one-hot)
# After:  CONFLICT_PENALTY = 5.0   (permits k-hot when rewards justify it)

Define the constraint families:

C₀: one-hot (Σx_i = 1)
C₁: at-most-2-hot (Σx_i ≤ 2)
C₂: at-most-3-hot (Σx_i ≤ 3)
...
C₇: no constraint (any binary vector)

Each C_{k+1} ⊆ C_k. The feasible sets expand: S₀ ⊆ S₁ ⊆ ... ⊆ S₇.


§3.4 — Applying the Theorem


The objective L(x) = x^T Q x is the QUBO energy. It is bounded below (finite sum of finite terms on a finite domain). The minimum is always attained (finite domain).


By the Feasible-Set Relaxation Theorem:

v₁ ≤ v₀ (at-most-2-hot energy ≤ one-hot energy)
v₂ ≤ v₁ ≤ v₀
...
Strict improvement occurs when the true optimal characterization requires multiple states

§3.5 — Concrete Example


Take the equation: "∀x. P(x) → Q(x) ∧ a² + b² = c²"


Current one-hot QUBO: classifies as Λ (universal quantification wins string matching). Energy = Q_{ΛΛ} = -8.0 (moderate reward, since Λ is detected via "∀x").


k-hot QUBO (k=2): selects both Λ and Σ. Energy = Q_{ΛΛ} + Q_{ΣΣ} + Q_{ΛΣ} = -8.0 + (-8.0) + 5.0 = -11.0.


The k-hot energy (-11.0) < one-hot energy (-8.0). The theorem predicted this. The k-hot solution captures both semantic components of the equation.


§3.6 — Lean 4 Formalization


lean
-- Constraint families
def OneHot (x : Fin 8 → Bool) : Prop :=
  (Finset.univ.filter (fun i => 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
​
 <v 
k
​
 . The improvement is strict.


4.4.3 When Strict Improvement Occurs: A Concrete Example

Consider the equation:


∀
x
.
  
P
(
x
)
→
Q
(
x
)
  
∧
  
a
2
+
b
2
=
c
2
∀x.P(x)→Q(x)∧a 
2
 +b 
2
 =c 
2
 


This equation contains two distinct structural features:


1.
Universal quantification (
∀
x
.
  
P
(
x
)
→
Q
(
x
)
∀x.P(x)→Q(x)): This is lattice-theoretic structure, mapping to the Λ state (phase 
45
°
45°, "room/lattice regime").

2.
Pythagorean identity (
a
2
+
b
2
=
c
2
a 
2
 +b 
2
 =c 
2
 ): This is symmetric-algebraic structure, mapping to the Σ state (phase 
225
°
225°, "symmetric partner").


The current one-hot QUBO, guided by equation_to_target_state, must select exactly one. The string-matching heuristic picks whichever pattern appears first. Information about the other structural component is destroyed.


Under the 
k
k-hot relaxation with 
k
=
2
k=2, both states can be selected. The QUBO energy becomes:


L
(
x
∗
)
=
Q
Λ
Λ
+
Q
Σ
Σ
+
2
Q
Λ
Σ
L(x 
∗
 )=Q 
ΛΛ
​
 +Q 
ΣΣ
​
 +2Q 
ΛΣ
​
 


where 
Q
Λ
Λ
=
−
α
Λ
Q 
ΛΛ
​
 =−α 
Λ
​
 , 
Q
Σ
Σ
=
−
α
Σ
Q 
ΣΣ
​
 =−α 
Σ
​
 , and 
Q
Λ
Σ
=
β
Λ
Σ
⋅
d
ϕ
(
Λ
,
Σ
)
2
Q 
ΛΣ
​
 =β 
ΛΣ
​
 ⋅d 
ϕ
​
 (Λ,Σ) 
2
 . Since 
Λ
Λ and 
\<5C>
<EFBFBD>
\<5C><EFBFBD> are antipodal on 
S
1
S 
1
  (
180
°
180° apart), 
d
ϕ
(
Λ
,
Σ
)
2
=
π
2
d 
ϕ
​
 (Λ,Σ) 
2
 =π 
2
  is maximal, making the coupling term large. But the self-rewards 
−
α
Λ
−
α
Σ
−α 
Λ
​
 −α 
Σ
​
  can outweigh this if both states are strongly rewarded.


The key insight: the one-hot constraint forces 
x
Σ
=
0
x 
Σ
​
 =0 when 
x
Λ
=
1
x 
Λ
​
 =1, even though 
Q
Σ
Σ
Q 
ΣΣ
​
  is highly negative (strong reward for Σ). The conflict penalty 
Q
Λ
Σ
=
20.0
Q 
ΛΣ
​
 =20.0 exceeds 
∣
Q
Σ
Σ
∣
=
8.0
∣Q 
ΣΣ
​
 ∣=8.0 (neighbor reward), making the two-hot assignment more expensive. But this is an artifact of the penalty magnitude, not a structural truth about the equation.


Relaxing the conflict penalty from 20.0 to a value 
P
P such that:


∣
Q
Λ
Λ
∣
+
∣
Q
Σ
Σ
∣
>
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
​
 <v 
1
​
  when multi-state character exists
Mechanism: same atoms, different lattice phase	Mechanism: same QUBO, larger feasible set

In both cases:

A lattice structure imposes a symmetry constraint
The constraint forbids a specific configuration (parallel-plate geometry / multi-state assignment)
Relaxing the constraint makes the configuration admissible
The Feasible-Set Relaxation Theorem guarantees the objective improves monotonically
Strict improvement occurs when the optimal configuration requires the relaxed constraint

4.4.5 Lean 4 Formalization Path

The Q

4.4.5 Lean 4 Formalization Path

The QUBO instantiation maps cleanly to Lean 4 constructs:


lean
-- State space
def HachimojiState := Fin 8 → Bool

-- One-hot constraint
def OneHot (x : HachimojiState) : Prop :=
  ∃! i, x i = true

-- k-hot constraint
def AtMostK (k : Nat) (x : HachimojiState) : Prop :=
  (Finset.univ.filter (fun i => 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.