| import Mathlib |
| import OAI.RepresentationTheory.Placement.Occurrence |
| import OAI.Probability.CoordinateSweeps.SparseMoment |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder |
| attribute [local instance] Classical.propDecidable |
| noncomputable section |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable |
| noncomputable section |
| open scoped BigOperators |
| open MvPolynomial |
| noncomputable section |
| open MeasureTheory ProbabilityTheory Real Set Filter |
| open scoped ENNReal NNReal BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators Matrix.Norms.L2Operator |
| attribute [local instance] Classical.propDecidable |
| noncomputable section |
| universe u v |
| open scoped ComplexConjugate |
| noncomputable section |
| open scoped BigOperators |
| open scoped Matrix.Norms.L2Operator |
| namespace CoordinateSweeps.Grid.Holes |
| open PlacementOccurrence Placement |
| variable {G : Grid} {h k : ℕ} (H : G.Holes h) |
|
|
| def inputPlacementEquiv : (Fin k ↪ H.FreeAt 0) ≃ H.InputPlacements k where |
| toFun x := ⟨fun i => (x i).val,⟨fun _ _ he => x.injective (Subtype.ext he),fun i a => (x i).property a⟩⟩ |
| invFun x := ⟨fun i => ⟨x.val i,x.property.2 i⟩,fun _ _ he => x.property.1 (congrArg Subtype.val he)⟩ |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| def outputFreePlacementEquiv : (Fin k ↪ H.FreeAt (Fin.last G.b)) ≃ H.OutputPlacements k where |
| toFun x := ⟨fun i => (x i).val,⟨fun _ _ he => x.injective (Subtype.ext he),fun i a => (x i).property a⟩⟩ |
| invFun x := ⟨fun i => ⟨x.val i,x.property.2 i⟩,fun _ _ he => x.property.1 (congrArg Subtype.val he)⟩ |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| def outputPlacementEquiv (hf : H.Feasible) : (Fin k ↪ H.FreeAt 0) ≃ H.OutputPlacements k := |
| (Equiv.embeddingCongr (Equiv.refl (Fin k)) |
| (H.freeBoundary ⟨H.reference hf,H.reference_compatible hf⟩ (Fin.last G.b))).trans H.outputFreePlacementEquiv |
|
|
| lemma outputPlacementEquiv_apply (hf : H.Feasible) (y : Fin k ↪ H.FreeAt 0) (i : Fin k) : |
| (H.outputPlacementEquiv hf y).val i=G.sweep (H.reference hf) (y i).val := rfl |
|
|
| def residualFree (hf : H.Feasible) (ω : {ω : G.Choices |
| H.stabilizerFreeEquiv (H.residual hf ω) |
|
|
| lemma residualFree_apply (hf : H.Feasible) (ω : {ω : G.Choices |
| (H.residualFree hf ω x).val=(G.sweep (H.reference hf))⁻¹ (G.sweep ω.val x.val) := rfl |
|
|
| lemma endpointEvent_residualFree (hf : H.Feasible) (x y : Fin k ↪ H.FreeAt 0) |
| (ω : {ω : G.Choices |
| G.endpointEvent (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val Finset.univ ω.val ↔ |
| H.residualFree hf ω • x=y := by |
| constructor |
| · intro he |
| apply Function.Embedding.ext |
| intro i |
| apply Subtype.ext |
| change (H.residualFree hf ω (x i)).val=(y i).val |
| rw [H.residualFree_apply] |
| apply (Equiv.symm_apply_eq (G.sweep (H.reference hf))).mpr |
| exact he i (Finset.mem_univ _) |
| · intro he i hi |
| have hh := congrArg (fun x : Fin k ↪ H.FreeAt 0 => (x i).val) he |
| change (H.residualFree hf ω (x i)).val=(y i).val at hh |
| rw [H.residualFree_apply] at hh |
| exact (Equiv.symm_apply_eq (G.sweep (H.reference hf))).mp hh |
|
|
| lemma extraProbability_eq_residual_sum (hf : H.Feasible) (x y : Fin k ↪ H.FreeAt 0) |
| {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) : |
| H.extraProbability (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val Finset.univ |
| (fun j => lineLaw (G.bits j) z hz hz') = |
| ∑ ω : {ω : G.Choices |
| if H.residualFree hf ω • x=y then G.choiceWeight z ω.val/H.probability z else 0 := by |
| rw [H.extraProbability_eq_conditionalEndpoint,conditionalEndpointProbability,H.lineMass_hole_normalizer hz hz'] |
| have hn : (∑ ω : G.Choices, if H.Compatible ω ∧ |
| G.endpointEvent (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val Finset.univ ω then |
| G.productLineMass (fun j => lineLaw (G.bits j) z hz hz') ω else 0)= |
| ∑ ω : {ω : G.Choices |
| if H.residualFree hf ω • x=y then G.choiceWeight z ω.val else 0 := by |
| symm |
| calc |
| _ = ∑ ω : {ω : G.Choices |
| if G.endpointEvent (H.inputPlacementEquiv x).val |
| (H.outputPlacementEquiv hf y).val Finset.univ ω.val then G.choiceWeight z ω.val else 0 := by |
| apply Finset.sum_congr rfl |
| intro ω _ |
| rw [H.endpointEvent_residualFree hf] |
| split_ifs <;> rfl |
| _ = _ := by |
| rw [sum_subtype_eq_sum_ite_of_iff (fun _ => Iff.rfl) |
| (fun ω : G.Choices => if G.endpointEvent (H.inputPlacementEquiv x).val |
| (H.outputPlacementEquiv hf y).val Finset.univ ω then G.choiceWeight z ω else 0)] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| split_ifs <;> try rfl |
| all_goals simp_all |
| rw [hn,Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| split_ifs <;> simp |
|
|
| /- Partial endpoint matrix written on a single placement set using the |
| reference sweep; every variable is a literal conditional path probability. -/ |
| def referencePartial (hf : H.Feasible) (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) |
| (A : Finset (Fin k)) (x y : Fin k ↪ H.FreeAt 0) : ℝ := |
| H.extraProbability (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val A μ |
|
|
| lemma referencePartial_depends (hf : H.Feasible) |
| (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) (A : Finset (Fin k)) (x : Fin k ↪ H.FreeAt 0) : |
| Placement.DependsOn (fun y : Fin k ↪ H.FreeAt 0 => y) A |
| (fun y => (H.referencePartial hf μ A x y : ℂ)) := by |
| intro y y' hy |
| apply H.extraProbability_dependsOn μ A (H.inputPlacementEquiv x) |
| intro i hi |
| simp only [outputPlacementEquiv_apply,hy i hi] |
| |
| lemma referencePartial_full (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) : |
| (show Matrix (Fin k ↪ H.FreeAt 0) (Fin k ↪ H.FreeAt 0) ℂ from fun x y => |
| (H.referencePartial hf (fun j => lineLaw (G.bits j) z hz hz') Finset.univ x y : ℂ))= |
| ∑ ω : {ω : G.Choices // H.Compatible ω}, |
| ((G.choiceWeight z ω.val/H.probability z : ℝ) : ℂ) • |
| actionMatrix (X := Fin k ↪ H.FreeAt 0) (H.residualFree hf ω)⁻¹ := by |
| ext x y |
| simp only [Matrix.sum_apply,Matrix.smul_apply,smul_eq_mul,actionMatrix_entry,inv_inv] |
| rw [referencePartial,H.extraProbability_eq_residual_sum hf x y hz hz',Complex.ofReal_sum] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| split_ifs <;> simp |
|
|
| lemma referenceAlternating_entry (hf : H.Feasible) |
| (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) (x y : Fin k ↪ H.FreeAt 0) : |
| alternatingKernel (G.size : ℝ) (H.referencePartial hf μ) x y= |
| (H.placementKernel (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val μ : ℂ) := by |
| simp only [alternatingKernel,referencePartial,placementKernel,Fintype.card_fin] |
|
|
| lemma referenceAlternating_hs (hf : H.Feasible) |
| (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) : |
| (∑ x : Fin k ↪ H.FreeAt 0, ∑ y : Fin k ↪ H.FreeAt 0, |
| ‖alternatingKernel (G.size : ℝ) (H.referencePartial hf μ) x y‖^2)=H.placementHSsq (k := k) μ := by |
| rw [H.placementHSsq_eq_subtype] |
| simp only [referenceAlternating_entry] |
| apply Fintype.sum_equiv H.inputPlacementEquiv |
| intro x |
| exact (H.outputPlacementEquiv hf).sum_comp |
| (fun y => ‖(H.placementKernel (H.inputPlacementEquiv x).val y.val μ : ℂ)‖^2) |
|
|
| /- The missing attachment of source04:eq7 to the faithful conditional |
| irreducible average, not merely an abstract stochastic matrix. -/ |
| theorem conditional_norm_le_placementHS (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) |
| (ρ : UnitaryIrrep (Equiv.Perm (H.FreeAt 0))) |
| (u : Fin ρ.dimension → ℂ) (hu : u ≠ 0) (x₀ : Fin k ↪ H.FreeAt 0) |
| (hfixed : ∀ g : Equiv.Perm (H.FreeAt 0), (∀ i, g (x₀ i)=x₀ i) → ρ.asRepresentation g u=u) |
| (hnof : ∀ A : Finset (H.FreeAt 0), A.card < k → ∀ v : Fin ρ.dimension → ℂ, |
| (∀ g : Equiv.Perm (H.FreeAt 0), (∀ a ∈ A, g a=a) → ρ.asRepresentation g v=v) → v=0) : |
| ‖H.conditionalAverage hf z (ρ.pullback H.stabilizerFreeEquiv)‖ ≤ |
| Real.sqrt (H.placementHSsq (k := k) (fun j => lineLaw (G.bits j) z hz hz')) := by |
| have hm := first_level_norm_le ρ u hu x₀ hfixed (by simpa only [Fintype.card_fin] using hnof) |
| (fun ω : {ω : G.Choices // H.Compatible ω} => ((G.choiceWeight z ω.val/H.probability z : ℝ) : ℂ)) |
| (fun ω => (H.residualFree hf ω)⁻¹) (G.size : ℝ) (by unfold Grid.size; positivity) |
| (H.referencePartial hf (fun j => lineLaw (G.bits j) z hz hz')) |
| (H.referencePartial_depends hf _) (H.referencePartial_full hf hz hz') |
| have he : (∑ ω : {ω : G.Choices |
| ((G.choiceWeight z ω.val/H.probability z : ℝ):ℂ) • ρ.matrix (H.residualFree hf ω)⁻¹)= |
| (H.conditionalAverage hf z (ρ.pullback H.stabilizerFreeEquiv)).conjTranspose := by |
| rw [H.conditionalAverage_eq_sum,Matrix.conjTranspose_sum] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| rw [Matrix.conjTranspose_smul,Complex.star_def,Complex.conj_ofReal] |
| exact congrArg (fun M => ((G.choiceWeight z ω.val/H.probability z : ℝ):ℂ) • M) |
| (ρ.matrix_inv (H.residualFree hf ω)) |
| rw [he] at hm |
| change ‖(H.conditionalAverage hf z (ρ.pullback H.stabilizerFreeEquiv)).conjTranspose‖ ≤ _ at hm |
| rw [Matrix.l2_opNorm_conjTranspose] at hm |
| apply hm.trans |
| have hh := Placement.matrix_l2_norm_le_hs (alternatingKernel (G.size : ℝ) |
| (H.referencePartial (k := k) hf (fun j => lineLaw (G.bits j) z hz hz'))) |
| rw [H.referenceAlternating_hs] at hh |
| convert hh using 1 |
| rfl |
| end CoordinateSweeps.Grid.Holes |
| |
| namespace CoordinateSweeps |
| -- Archived complete binary-sign support, reused without a new-result claim. |
| /- The real-valued sign character, not a replacement for the permutation. -/ |
| def realSign {Ω : Type*} [Fintype Ω] [DecidableEq Ω] : Equiv.Perm Ω →* ℝ where |
| toFun g := ((Equiv.Perm.sign g : ℤ) : ℝ) |
| map_one' := by simp |
| map_mul' g h := by simp |
| |
| def boolSwitch (b : Bool) : Equiv.Perm Bool := |
| if b then Equiv.swap false true else 1 |
| |
| theorem boolSwitch_apply (b x : Bool) : boolSwitch b x = Bool.xor x b := by |
| cases b <;> cases x <;> simp [boolSwitch] |
| |
| theorem sign_boolSwitch (b : Bool) : realSign (boolSwitch b) = if b then -1 else 1 := by |
| cases b <;> simp [boolSwitch, realSign] |
| |
| theorem pairSwitch_eq_prod {L : Type*} (bits : L → Bool) : |
| pairSwitch bits = Equiv.prodCongrLeft (fun l => boolSwitch (bits l)) := by |
| apply Equiv.ext |
| rintro ⟨b,l⟩ |
| change (Bool.xor b (bits l), l) = (boolSwitch (bits l) b, l) |
| rw [boolSwitch_apply] |
| |
| theorem sign_pairSwitch {L : Type*} [Fintype L] (bits : L → Bool) : |
| realSign (pairSwitch bits) = ∏ l, (if bits l then (-1 : ℝ) else 1) := by |
| rw [pairSwitch_eq_prod] |
| change (((Equiv.Perm.sign (Equiv.prodCongrLeft (fun l => boolSwitch (bits l)))) : ℤ) : ℝ) = _ |
| rw [Equiv.Perm.sign_prodCongrLeft] |
| change (((Units.coeHom ℤ) (∏ l, Equiv.Perm.sign (boolSwitch (bits l)))) : ℝ) = _ |
| rw [map_prod, Int.cast_prod] |
| apply Finset.prod_congr rfl |
| intro l _ |
| exact sign_boolSwitch (bits l) |
| |
| theorem sign_binaryLayer {d : ℕ} (j : Fin d) |
| (bits : ({k : Fin d // k ≠ j} → Bool) → Bool) : |
| realSign (binaryLayer j bits) = realSign (pairSwitch bits) := by |
| change (((Equiv.Perm.sign (_)) : ℤ) : ℝ) = _ |
| rw [binaryLayer, Equiv.Perm.sign_trans_trans] |
| simp [realSign] |
| |
| theorem sum_sign_pairSwitch {L : Type*} [Fintype L] [Nonempty L] : |
| (∑ bits : L → Bool, realSign (pairSwitch bits)) = 0 := by |
| simp_rw [sign_pairSwitch] |
| rw [← Fintype.prod_sum (fun (_ : L) (b : Bool) => if b then (-1 : ℝ) else 1)] |
| simp |
| |
| theorem sign_binarySweep (d : ℕ) (bits : BinaryChoices d) : |
| realSign (binarySweep d bits) = ∏ j, realSign (binaryLayer j (bits j)) := by |
| unfold binarySweep orderedProduct |
| rw [map_list_prod] |
| simp [List.map_reverse, List.map_ofFn, List.prod_reverse, List.prod_ofFn] |
| |
| theorem sum_sign_binarySweep {d : ℕ} (hd : 0 < d) : |
| (∑ bits : BinaryChoices d, realSign (binarySweep d bits)) = 0 := by |
| simp_rw [sign_binarySweep, sign_binaryLayer] |
| change (∑ bits : BinaryChoices d, ∏ j : Fin d, |
| realSign (pairSwitch (bits j))) = 0 |
| have hs : ∀ (j : Fin d) (b : ({k : Fin d // k ≠ j} → Bool) → Bool), |
| realSign (pairSwitch b) = ∏ l, if b l then (-1 : ℝ) else 1 := by |
| intro j b |
| convert sign_pairSwitch b using 1 |
| congr 2 |
| exact Subsingleton.elim _ _ |
| simp_rw [hs] |
| rw [← Fintype.prod_sum (fun j : Fin d => |
| fun b : ({k : Fin d // k ≠ j} → Bool) → Bool => |
| ∏ l, if b l then (-1 : ℝ) else 1)] |
| apply Finset.prod_eq_zero (i := (⟨0,hd⟩ : Fin d)) (Finset.mem_univ _) |
| rw [← Fintype.prod_sum (fun (_ : ({k : Fin d // k ≠ (⟨0,hd⟩ : Fin d)} → Bool)) |
| (b : Bool) => if b then (-1 : ℝ) else 1)] |
| simp |
| |
| end CoordinateSweeps |
| |
| namespace CoordinateSweeps |
| variable {Ω : Type*} [Fintype Ω] [DecidableEq Ω] |
| |
| lemma signed_sum_zero_of_swap (w : Equiv.Perm Ω → ℝ) (P : Equiv.Perm Ω → Prop) |
| (a b : Ω) (hab : a ≠ b) |
| (hw : ∀ σ, w (Equiv.swap a b*σ)=w σ) |
| (hP : ∀ σ, P (Equiv.swap a b*σ) ↔ P σ) : |
| (∑ σ : Equiv.Perm Ω, if P σ then w σ*realSign σ else 0)=0 := by |
| classical |
| have hs : realSign (Equiv.swap a b)=(-1:ℝ) := by |
| simp [realSign,Equiv.Perm.sign_swap hab] |
| have he := Equiv.sum_comp (Equiv.mulLeft (Equiv.swap a b)) |
| (fun σ : Equiv.Perm Ω => if P σ then w σ*realSign σ else 0) |
| have hn : (∑ σ : Equiv.Perm Ω, if P (Equiv.swap a b*σ) then |
| w (Equiv.swap a b*σ)*realSign (Equiv.swap a b*σ) else 0)= |
| -(∑ σ : Equiv.Perm Ω, if P σ then w σ*realSign σ else 0) := by |
| rw [← Finset.sum_neg_distrib] |
| apply Finset.sum_congr rfl |
| intro σ _ |
| rw [hP,hw,map_mul,hs] |
| split_ifs <;> ring |
| change (∑ σ : Equiv.Perm Ω, if P (Equiv.swap a b*σ) then |
| w (Equiv.swap a b*σ)*realSign (Equiv.swap a b*σ) else 0)=_ at he |
| linarith [hn,he] |
| |
| lemma sum_uniform_realSign [Nontrivial Ω] : |
| (∑ σ : Equiv.Perm Ω, FiniteLaw.uniform _ σ*realSign σ)=0 := by |
| obtain ⟨a,b,hab⟩ := exists_pair_ne Ω |
| simpa only [ite_true] using signed_sum_zero_of_swap (FiniteLaw.uniform _) (fun _ => True) |
| a b hab (fun _ => rfl) (fun _ => Iff.rfl) |
| |
| omit [DecidableEq Ω] in |
| lemma sum_map_mul (μ : FiniteLaw Ω) {X : Type*} [Fintype X] (f : Ω → X) (v : X → ℝ) : |
| (∑ y : X, (μ.map f) y*v y)=∑ x : Ω, μ x*v (f x) := by |
| simp only [FiniteLaw.map_apply,Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro x _ |
| simp [ite_mul] |
| |
| lemma sum_binary_realSign {d : ℕ} (hd : 0 < d) : |
| (∑ σ : Equiv.Perm (Cube d), binaryLaw d σ*realSign σ)=0 := by |
| rw [binaryLaw,sum_map_mul] |
| simp only [FiniteLaw.uniform_apply,← Finset.mul_sum,sum_sign_binarySweep hd,mul_zero] |
| |
| lemma sum_lineLaw_realSign {d : ℕ} (hd : 0 < d) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) : |
| (∑ σ : Equiv.Perm (Cube d), lineLaw d z hz hz' σ*realSign σ)=0 := by |
| let : NeZero d := ⟨hd.ne'⟩ |
| change (∑ σ : Equiv.Perm (Cube d), ((1-z)*FiniteLaw.uniform _ σ+z*binaryLaw d σ)*realSign σ)=0 |
| simp only [add_mul,mul_assoc,Finset.sum_add_distrib,← Finset.mul_sum, |
| sum_uniform_realSign,sum_binary_realSign hd,mul_zero,add_zero] |
|
|
| lemma uniform_signed_assignments_zero {I : Type*} |
| (x y : I → Ω) (a b : Ω) (hab : a ≠ b) (ha : ∀ i, y i ≠ a) (hb : ∀ i, y i ≠ b) : |
| (∑ σ : Equiv.Perm Ω, if ∀ i, σ (x i)=y i then FiniteLaw.uniform _ σ*realSign σ else 0)=0 := by |
| apply signed_sum_zero_of_swap (FiniteLaw.uniform _) _ a b hab (fun _ => rfl) |
| have hs (i : I) : Equiv.swap a b (y i)=y i := Equiv.swap_apply_of_ne_of_ne (ha i) (hb i) |
| intro σ |
| constructor |
| · intro h i |
| apply (Equiv.swap a b).injective |
| exact (h i).trans (hs i).symm |
| · intro h i |
| change Equiv.swap a b (σ (x i))=y i |
| rw [h i,hs] |
|
|
| namespace Grid |
| lemma realSign_fiberPerm {A B : Type*} [Fintype A] [Fintype B] [DecidableEq A] [DecidableEq B] |
| (g : B → Equiv.Perm A) : realSign (fiberPerm g)=∏ b, realSign (g b) := by |
| have he : fiberPerm g=Equiv.prodCongrLeft g := rfl |
| rw [he] |
| change (((Equiv.Perm.sign (Equiv.prodCongrLeft g) : ℤ):ℝ))=_ |
| rw [Equiv.Perm.sign_prodCongrLeft] |
| change (((Units.coeHom ℤ) (∏ b, Equiv.Perm.sign (g b))):ℝ)=_ |
| rw [map_prod,Int.cast_prod] |
| rfl |
|
|
| lemma realSign_stage (G : Grid) (ω : G.Choices) (j : Fin G.b) : |
| realSign (G.stage ω j)=∏ L, realSign (ω j L) := by |
| have he : realSign (G.stage ω j)=realSign (fiberPerm (ω j)) := by |
| change (((Equiv.Perm.sign (_)) : ℤ) : ℝ) = _ |
| rw [stage,Equiv.Perm.sign_trans_trans] |
| simp [realSign] |
| exact he.trans (realSign_fiberPerm (ω j)) |
|
|
| lemma realSign_sweep (G : Grid) (ω : G.Choices) : |
| realSign (G.sweep ω)=∏ j, ∏ L, realSign (ω j L) := by |
| unfold sweep boundary |
| have ht := List.take_length (l := List.ofFn (G.stage ω)) |
| simp only [List.length_ofFn] at ht |
| rw [ht] |
| rw [map_list_prod] |
| simp only [List.map_reverse,List.map_ofFn,List.prod_reverse,List.prod_ofFn,Function.comp_apply,realSign_stage] |
|
|
| lemma signed_line_factorization (G : Grid) |
| (μ : ∀ j : Fin G.b, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) |
| (P : ∀ j : Fin G.b, G.Line j → Equiv.Perm (Cube (G.bits j)) → Prop) : |
| (∑ ω : G.Choices, if ∀ j L, P j L (ω j L) then G.productLineMass μ ω*realSign (G.sweep ω) else 0)= |
| ∏ j, ∏ L, ∑ σ, if P j L σ then μ j σ*realSign σ else 0 := by |
| simp only [realSign_sweep,productLineMass,← Finset.prod_mul_distrib] |
| calc |
| _ = ∏ j, ∑ ω : G.Line j → Equiv.Perm (Cube (G.bits j)), |
| if ∀ L, P j L (ω L) then ∏ L, μ j (ω L)*realSign (ω L) else 0 := by |
| convert sum_prod_ite_all |
| (fun j (ω : G.Line j → Equiv.Perm (Cube (G.bits j))) => ∏ L, μ j (ω L)*realSign (ω L)) |
| (fun j (ω : G.Line j → Equiv.Perm (Cube (G.bits j))) => ∀ L, P j L (ω L)) using 1 <;> |
| congr! |
| _ = _ := by |
| apply Finset.prod_congr rfl |
| intro j _ |
| exact sum_prod_ite_all (fun _ σ => μ j σ*realSign σ) (P j) |
| end Grid |
| end CoordinateSweeps |
|
|
| namespace CoordinateSweeps.Grid.Holes |
| variable {G : Grid} {h k : ℕ} (H : G.Holes h) |
|
|
| def jointLineEvent (x y : Fin k → G.Slot) (A : Finset (Fin k)) |
| (j : Fin G.b) (L : G.Line j) (σ : Equiv.Perm (Cube (G.bits j))) : Prop := |
| H.LineCompatible j L σ ∧ G.extraLineEvent x y A j L σ |
|
|
| lemma signed_endpoint_factorization (x y : Fin k → G.Slot) (A : Finset (Fin k)) |
| (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) : |
| (∑ ω : G.Choices, if H.Compatible ω ∧ G.endpointEvent x y A ω then |
| G.productLineMass μ ω*realSign (G.sweep ω) else 0)= |
| ∏ j, ∏ L, ∑ σ, if H.jointLineEvent x y A j L σ then μ j σ*realSign σ else 0 := by |
| have he (ω : G.Choices) : H.Compatible ω ∧ G.endpointEvent x y A ω ↔ |
| ∀ j L, H.jointLineEvent x y A j L (ω j L) := by |
| rw [H.compatible_iff_lines,G.endpointEvent_iff_lines] |
| exact ⟨fun hh j L => ⟨hh.1 j L,hh.2 j L⟩, |
| fun hh => ⟨fun j L => (hh j L).1,fun j L => (hh j L).2⟩⟩ |
| simp_rw [he] |
| exact G.signed_line_factorization μ (H.jointLineEvent x y A) |
|
|
| lemma signed_endpoint_zero_of_unused (x y : Fin k → G.Slot) (A : Finset (Fin k)) |
| {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) (j : Fin G.b) (hj : 0 < G.bits j) |
| (L : G.Line j) (hholes : ∀ i : Fin h, ¬ H.OnLine j L i) |
| (hpaths : ∀ i ∈ A, G.pathLine (x i) (y i) j ≠ L) : |
| (∑ ω : G.Choices, if H.Compatible ω ∧ G.endpointEvent x y A ω then |
| G.choiceWeight z ω*realSign (G.sweep ω) else 0)=0 := by |
| change (∑ ω : G.Choices, if H.Compatible ω ∧ G.endpointEvent x y A ω then |
| G.productLineMass (fun j => lineLaw (G.bits j) z hz hz') ω*realSign (G.sweep ω) else 0)=0 |
| rw [H.signed_endpoint_factorization] |
| apply Finset.prod_eq_zero (Finset.mem_univ j) |
| apply Finset.prod_eq_zero (Finset.mem_univ L) |
| have he (σ : Equiv.Perm (Cube (G.bits j))) : H.jointLineEvent x y A j L σ := by |
| constructor |
| · intro i |
| exact False.elim (hholes i.val i.property) |
| · intro i hi hL |
| exact False.elim (hpaths i hi hL) |
| simp only [ite_eq_left (he _)] |
| exact sum_lineLaw_realSign hj hz hz' |
| |
| lemma exists_unused_line (x y : Fin k → G.Slot) (j : Fin G.b) |
| (hj : h+k < Fintype.card (G.Line j)) : |
| ∃ L : G.Line j, (∀ i : Fin h, ¬ H.OnLine j L i) ∧ |
| ∀ i : Fin k, G.pathLine (x i) (y i) j ≠ L := by |
| let f : Fin h ⊕ Fin k → G.Line j := Sum.elim |
| (fun i => fun t => H.path i j.castSucc t) (fun i => G.pathLine (x i) (y i) j) |
| have hn : ¬ Function.Surjective f := by |
| intro hs |
| have hc := Fintype.card_le_of_surjective f hs |
| simp only [Fintype.card_sum,Fintype.card_fin] at hc |
| omega |
| obtain ⟨L,hL⟩ := not_forall.mp hn |
| refine ⟨L,?_,?_⟩ |
| · intro i hi |
| exact hL ⟨Sum.inl i,hi⟩ |
| · intro i hi |
| exact hL ⟨Sum.inr i,hi⟩ |
| |
| /- Literal many-coordinate column cancellation; no complex conditioning. -/ |
| theorem signed_endpoint_zero_many (x y : Fin k → G.Slot) {z : ℝ} |
| (hz : 0 ≤ z) (hz' : z ≤ 1) (j : Fin G.b) (hj : 0 < G.bits j) |
| (hsize : h+k < Fintype.card (G.Line j)) : |
| (∑ ω : G.Choices, if H.Compatible ω ∧ G.endpointEvent x y Finset.univ ω then |
| G.choiceWeight z ω*realSign (G.sweep ω) else 0)=0 := by |
| obtain ⟨L,hH,hP⟩ := H.exists_unused_line x y j hsize |
| exact H.signed_endpoint_zero_of_unused x y Finset.univ hz hz' j hj L hH (fun i _ => hP i) |
| end CoordinateSweeps.Grid.Holes |
| |
| namespace CoordinateSweeps |
| /- More than one unassigned slot per line on average forces two free slots |
| on a common line. Assignments need not be injective for this counting step. -/ |
| lemma exists_two_unassigned {I U V : Type*} [Fintype I] [Fintype U] [Fintype V] |
| [DecidableEq U] [DecidableEq V] (f : I → U × V) |
| (hh : Fintype.card I+Fintype.card V < Fintype.card (U × V)) : |
| ∃ a b : U, ∃ v : V, a ≠ b ∧ (∀ i, f i ≠ (a,v)) ∧ ∀ i, f i ≠ (b,v) := by |
| classical |
| let S := (Finset.univ : Finset (U × V)) \ Finset.univ.image f |
| have hc : Fintype.card V < S.card := by |
| dsimp [S] |
| rw [Finset.card_sdiff_of_subset (Finset.subset_univ _),Finset.card_univ] |
| have hi : (Finset.univ.image f).card ≤ Fintype.card I := by |
| simpa using Finset.card_image_le (s := Finset.univ) (f := f) |
| omega |
| have hn : ¬ Function.Injective (fun u : S => u.val.2) := by |
| intro hi |
| have ht := Fintype.card_le_of_injective _ hi |
| exact (not_le.mpr hc) (by simpa only [Fintype.card_coe] using ht) |
| simp only [Function.Injective] at hn |
| push Not at hn |
| obtain ⟨a,b,hv,hab⟩ := hn |
| refine ⟨a.val.1,b.val.1,a.val.2,?_,?_,?_⟩ |
| · intro he |
| apply hab |
| exact Subtype.ext (Prod.ext he hv) |
| · intro i hi |
| have ha := (Finset.mem_sdiff.mp a.property).2 |
| exact ha (Finset.mem_image.mpr ⟨i,Finset.mem_univ _,hi⟩) |
| · intro i hi |
| have hb := (Finset.mem_sdiff.mp b.property).2 |
| apply hb |
| refine Finset.mem_image.mpr ⟨i,Finset.mem_univ _,?_⟩ |
| exact hi.trans (Prod.ext rfl hv) |
| end CoordinateSweeps |
| |
| namespace CoordinateSweeps.Grid.Holes |
| variable {G : Grid} {h k : ℕ} (H : G.Holes h) |
| lemma uniform_signed_joint_zero (x y : Fin k → G.Slot) (j : Fin G.b) |
| (L : G.Line j) (a b : Cube (G.bits j)) (hab : a ≠ b) |
| (haH : ∀ i : Fin h, H.OnLine j L i → H.path i j.succ j ≠ a) |
| (hbH : ∀ i : Fin h, H.OnLine j L i → H.path i j.succ j ≠ b) |
| (haP : ∀ i, G.pathLine (x i) (y i) j=L → y i j ≠ a) |
| (hbP : ∀ i, G.pathLine (x i) (y i) j=L → y i j ≠ b) : |
| (∑ σ, if H.jointLineEvent x y Finset.univ j L σ then |
| FiniteLaw.uniform _ σ*realSign σ else 0)=0 := by |
| apply signed_sum_zero_of_swap (FiniteLaw.uniform _) _ a b hab (fun _ => rfl) |
| have he (u v : Cube (G.bits j)) (hv : v ≠ a) (hv' : v ≠ b) (σ : Equiv.Perm (Cube (G.bits j))) : |
| (Equiv.swap a b*σ) u=v ↔ σ u=v := by |
| have hs := Equiv.swap_apply_of_ne_of_ne hv hv' |
| constructor |
| · intro hh |
| apply (Equiv.swap a b).injective |
| exact hh.trans hs.symm |
| · intro hh |
| change Equiv.swap a b (σ u)=v |
| rw [hh,hs] |
| intro σ |
| unfold jointLineEvent LineCompatible extraLineEvent |
| constructor |
| · intro hh |
| constructor |
| · intro i |
| exact (he _ _ (haH i i.property) (hbH i i.property) σ).mp (hh.1 i) |
| · intro i hi hL |
| exact (he _ _ (haP i hL) (hbP i hL) σ).mp (hh.2 i hi hL) |
| · intro hh |
| constructor |
| · intro i |
| exact (he _ _ (haH i i.property) (hbH i i.property) σ).mpr (hh.1 i) |
| · intro i hi hL |
| exact (he _ _ (haP i hL) (hbP i hL) σ).mpr (hh.2 i hi hL) |
| |
| /- Exact zero at the real uniform law, including bounded coordinate counts. -/ |
| theorem signed_endpoint_zero_uniform (x y : Fin k → G.Slot) (j : Fin G.b) |
| (hsize : h+k+Fintype.card (G.Line j) < G.size) : |
| (∑ ω : G.Choices, if H.Compatible ω ∧ G.endpointEvent x y Finset.univ ω then |
| G.choiceWeight 0 ω*realSign (G.sweep ω) else 0)=0 := by |
| let f : Fin h ⊕ Fin k → Cube (G.bits j) × G.Line j := Sum.elim |
| (fun i => (H.path i j.succ j,fun t => H.path i j.castSucc t)) |
| (fun i => (y i j,G.pathLine (x i) (y i) j)) |
| have hf : Fintype.card (Fin h ⊕ Fin k)+Fintype.card (G.Line j) < |
| Fintype.card (Cube (G.bits j) × G.Line j) := by |
| rw [← Fintype.card_congr (Equiv.piSplitAt j (fun t => Cube (G.bits t))),G.card_slot] |
| simpa using hsize |
| obtain ⟨a,b,L,hab,ha,hb⟩ := exists_two_unassigned f hf |
| have hmass : ∀ ω : G.Choices, G.choiceWeight 0 ω= |
| G.productLineMass (fun j => FiniteLaw.uniform _) ω := by |
| intro ω |
| simp [choiceWeight,productLineMass] |
| simp_rw [hmass] |
| rw [H.signed_endpoint_factorization] |
| apply Finset.prod_eq_zero (Finset.mem_univ j) |
| apply Finset.prod_eq_zero (Finset.mem_univ L) |
| apply H.uniform_signed_joint_zero x y j L a b hab |
| · intro i hL he |
| exact ha (Sum.inl i) (Prod.ext he hL) |
| · intro i hL he |
| exact hb (Sum.inl i) (Prod.ext he hL) |
| · intro i hL he |
| exact ha (Sum.inr i) (Prod.ext he hL) |
| · intro i hL he |
| exact hb (Sum.inr i) (Prod.ext he hL) |
| end CoordinateSweeps.Grid.Holes |
| |
| namespace CoordinateSweeps.UnitaryIrrep |
| open SparseDimension |
| variable {Ω : Type*} [Fintype Ω] [DecidableEq Ω] |
| def signTwist (ρ : UnitaryIrrep (Equiv.Perm Ω)) : UnitaryIrrep (Equiv.Perm Ω) where |
| dimension := ρ.dimension |
| positive := ρ.positive |
| matrix := { |
| toFun g := signScalar g • ρ.matrix g |
| map_one' := by simp |
| map_mul' g h := by simp only [map_mul,smul_mul_smul_comm] } |
| unitary g := by |
| change (signScalar g • ρ.matrix g).conjTranspose*(signScalar g • ρ.matrix g)=1 |
| simp only [Matrix.conjTranspose_smul,Matrix.smul_mul,Matrix.mul_smul,smul_smul] |
| rw [show star (signScalar g)=signScalar g by simp [signScalar_apply],signScalar_mul_self,one_smul,ρ.unitary] |
| irreducible S hS := ρ.irreducible S (by |
| intro g v hv |
| have hh := S.smul_mem (signScalar g) (hS g v hv) |
| change signScalar g • ((signScalar g • ρ.matrix g).mulVec v) ∈ S at hh |
| simpa only [Matrix.smul_mulVec,smul_smul,signScalar_mul_self,one_smul] using hh) |
| |
| @[simp] lemma signTwist_rep (ρ : UnitaryIrrep (Equiv.Perm Ω)) : |
| ρ.signTwist.asRepresentation=SparseDimension.signTwist ρ.asRepresentation := by |
| apply MonoidHom.ext |
| intro g |
| apply LinearMap.ext |
| intro v |
| change (signScalar g • ρ.matrix g).mulVec v=signScalar g • (ρ.matrix g).mulVec v |
| exact Matrix.smul_mulVec _ _ _ |
| end CoordinateSweeps.UnitaryIrrep |
| |
| namespace CoordinateSweeps.PlacementOccurrence |
| open scoped Matrix.Norms.L2Operator |
| variable {I Ω : Type*} [Fintype I] [DecidableEq I] [Fintype Ω] [DecidableEq Ω] |
| /- Vanishing on placements transfers to any actually occurring constituent. |
| No minimum-level condition is needed in the sign-zero branch. -/ |
| omit [DecidableEq I] in |
| theorem average_zero_of_placement_zero (ρ : UnitaryIrrep (Equiv.Perm Ω)) |
| (u : Fin ρ.dimension → ℂ) (hu : u ≠ 0) (x₀ : I ↪ Ω) |
| (hfixed : ∀ g : Equiv.Perm Ω, (∀ i, g (x₀ i)=x₀ i) → ρ.asRepresentation g u=u) |
| {W : Type*} [Fintype W] (w : W → ℂ) (g : W → Equiv.Perm Ω) |
| (hz : (∑ a : W, w a • actionMatrix (X := I ↪ Ω) (g a))=0) : |
| (∑ a : W, w a • ρ.matrix (g a))=0 := by |
| let B : Matrix (Fin ρ.dimension) (I ↪ Ω) ℂ := synthesisMatrix ρ u x₀ |
| have hne : B ≠ 0 := synthesisMatrix_ne_zero ρ u hu x₀ (by |
| intro σ hσ |
| exact hfixed σ (fun i => congrArg (fun x : I ↪ Ω => x i) hσ)) |
| have hn := ρ.norm_le_compression (actionMatrix (X := I ↪ Ω)) actionMatrix_unitary B hne |
| (synthesisMatrix_covariant ρ u x₀) (∑ a : W, w a • ρ.matrix (g a)) |
| (∑ a : W, w a • actionMatrix (X := I ↪ Ω) (g a)) (by |
| rw [Matrix.sum_mul,Matrix.mul_sum] |
| apply Finset.sum_congr rfl |
| intro a _ |
| rw [Matrix.smul_mul,Matrix.mul_smul] |
| congr 1 |
| exact ρ.adjoint_intertwines _ actionMatrix_unitary B (synthesisMatrix_covariant ρ u x₀) (g a)) |
| rw [hz,norm_zero] at hn |
| exact norm_eq_zero.mp (le_antisymm hn (norm_nonneg _)) |
| end CoordinateSweeps.PlacementOccurrence |
| |
| namespace CoordinateSweeps.Grid.Holes |
| open SparseDimension UnitaryIrrep PlacementOccurrence |
| variable {G : Grid} {h k : ℕ} (H : G.Holes h) |
| lemma realSign_freePerm (g : H.stabilizer) : |
| realSign (H.stabilizerFreeEquiv g)=realSign g.val := by |
| have he : Equiv.Perm.ofSubtype (H.stabilizerFreeEquiv g)=g.val := by |
| apply Equiv.ext |
| intro x |
| by_cases hx : ∀ i, x ≠ H.path i 0 |
| · rw [Equiv.Perm.ofSubtype_apply_of_mem _ hx] |
| rfl |
| · rw [Equiv.Perm.ofSubtype_apply_of_not_mem _ hx] |
| push Not at hx |
| obtain ⟨i,rfl⟩ := hx |
| exact (g.property i).symm |
| rw [← he] |
| simp [realSign,Equiv.Perm.sign_ofSubtype] |
| |
| lemma realSign_residualFree (hf : H.Feasible) (ω : {ω : G.Choices // H.Compatible ω}) : |
| realSign (H.residualFree hf ω)=realSign (G.sweep (H.reference hf))⁻¹*realSign (G.sweep ω.val) := by |
| rw [residualFree,H.realSign_freePerm] |
| change realSign ((G.sweep (H.reference hf))⁻¹*G.sweep ω.val)=_ |
| rw [map_mul] |
| |
| lemma signed_reference_entry_zero (hf : H.Feasible) (z : ℝ) |
| (hzero : ∀ x y : Fin k → G.Slot, |
| (∑ ω : G.Choices, if H.Compatible ω ∧ G.endpointEvent x y Finset.univ ω then |
| G.choiceWeight z ω*realSign (G.sweep ω) else 0)=0) |
| (x y : Fin k ↪ H.FreeAt 0) : |
| (∑ ω : {ω : G.Choices // H.Compatible ω}, |
| if H.residualFree hf ω • x=y then |
| (G.choiceWeight z ω.val/H.probability z)*realSign (H.residualFree hf ω) else 0)=0 := by |
| have hz := hzero (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val |
| have hs : (∑ ω : {ω : G.Choices // H.Compatible ω}, |
| if H.residualFree hf ω • x=y then G.choiceWeight z ω.val*realSign (G.sweep ω.val) else 0)=0 := by |
| calc |
| _ = ∑ ω : {ω : G.Choices // H.Compatible ω}, |
| if G.endpointEvent (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val Finset.univ ω.val then |
| G.choiceWeight z ω.val*realSign (G.sweep ω.val) else 0 := by |
| apply Finset.sum_congr rfl |
| intro ω _ |
| rw [H.endpointEvent_residualFree] |
| split_ifs <;> rfl |
| _ = ∑ ω : G.Choices, if H.Compatible ω ∧ |
| G.endpointEvent (H.inputPlacementEquiv x).val (H.outputPlacementEquiv hf y).val Finset.univ ω then |
| G.choiceWeight z ω*realSign (G.sweep ω) else 0 := by |
| rw [sum_subtype_eq_sum_ite_of_iff (fun _ => Iff.rfl) |
| (fun ω : G.Choices => if G.endpointEvent (H.inputPlacementEquiv x).val |
| (H.outputPlacementEquiv hf y).val Finset.univ ω then |
| G.choiceWeight z ω*realSign (G.sweep ω) else 0)] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| split_ifs <;> simp_all |
| _ = 0 := hz |
| calc |
| _ = (realSign (G.sweep (H.reference hf))⁻¹/H.probability z)* |
| (∑ ω : {ω : G.Choices // H.Compatible ω}, if H.residualFree hf ω • x=y then |
| G.choiceWeight z ω.val*realSign (G.sweep ω.val) else 0) := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| rw [H.realSign_residualFree] |
| split_ifs <;> ring |
| _ = 0 := by rw [hs,mul_zero] |
| |
| /- Column cancellation is now on the faithful conditional average, not just |
| on raw signed endpoint numerators. -/ |
| theorem conditional_zero_of_signed_endpoints (hf : H.Feasible) (z : ℝ) |
| (ρ : UnitaryIrrep (Equiv.Perm (H.FreeAt 0))) |
| (u : Fin ρ.dimension → ℂ) (hu : u ≠ 0) (x₀ : Fin k ↪ H.FreeAt 0) |
| (hfixed : ∀ g : Equiv.Perm (H.FreeAt 0), (∀ i, g (x₀ i)=x₀ i) → |
| (SparseDimension.signTwist ρ.asRepresentation) g u=u) |
| (hzero : ∀ x y : Fin k → G.Slot, |
| (∑ ω : G.Choices, if H.Compatible ω ∧ G.endpointEvent x y Finset.univ ω then |
| G.choiceWeight z ω*realSign (G.sweep ω) else 0)=0) : |
| H.conditionalAverage hf z (ρ.pullback H.stabilizerFreeEquiv)=0 := by |
| let w := fun ω : {ω : G.Choices // H.Compatible ω} => |
| (((G.choiceWeight z ω.val/H.probability z)*realSign (H.residualFree hf ω) : ℝ) : ℂ) |
| have he : (∑ ω : {ω : G.Choices // H.Compatible ω}, |
| w ω • actionMatrix (X := Fin k ↪ H.FreeAt 0) ((H.residualFree hf ω)⁻¹))=0 := by |
| ext x y |
| simp only [Matrix.sum_apply,Matrix.smul_apply,smul_eq_mul,actionMatrix_entry,inv_inv,Matrix.zero_apply] |
| have hs := H.signed_reference_entry_zero hf z hzero x y |
| have hc := congrArg (fun t : ℝ => (t : ℂ)) hs |
| simpa only [Complex.ofReal_sum,Complex.ofReal_zero,apply_ite,mul_ite,mul_one,mul_zero] using hc |
| have hh := average_zero_of_placement_zero ρ.signTwist u hu x₀ |
| (by intro g hg; rw [signTwist_rep]; exact hfixed g hg) w |
| (fun ω => (H.residualFree hf ω)⁻¹) he |
| have hid : (∑ ω : {ω : G.Choices // H.Compatible ω}, |
| w ω • ρ.signTwist.matrix ((H.residualFree hf ω)⁻¹))= |
| (H.conditionalAverage hf z (ρ.pullback H.stabilizerFreeEquiv)).conjTranspose := by |
| rw [H.conditionalAverage_eq_sum,Matrix.conjTranspose_sum] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| change w ω • (signScalar ((H.residualFree hf ω)⁻¹) • ρ.matrix ((H.residualFree hf ω)⁻¹))=_ |
| rw [smul_smul,Matrix.conjTranspose_smul,Complex.star_def,Complex.conj_ofReal,ρ.matrix_inv] |
| congr 1 |
| dsimp [w] |
| rw [Complex.ofReal_mul] |
| have hs : ((realSign (H.residualFree hf ω) : ℝ):ℂ)=signScalar (H.residualFree hf ω) := by |
| simp [realSign,signScalar_apply] |
| rw [hs,mul_assoc] |
| change ((G.choiceWeight z ω.val/H.probability z : ℝ):ℂ)* |
| (signScalar (H.residualFree hf ω)*signScalar ((H.residualFree hf ω)⁻¹))=_ |
| rw [← map_mul,mul_inv_cancel,map_one,mul_one] |
| rw [hid] at hh |
| have heq := congrArg Matrix.conjTranspose hh |
| simp only [Matrix.conjTranspose_conjTranspose] at heq |
| exact heq.trans (show (0 : Matrix (Fin ρ.dimension) (Fin ρ.dimension) ℂ).conjTranspose=0 from Matrix.conjTranspose_zero) |
| end CoordinateSweeps.Grid.Holes |
| |
| namespace CoordinateSweeps.Grid.Holes |
| open UnitaryIrrep |
| variable {G : Grid} {h k : ℕ} (H : G.Holes h) |
| theorem conditional_column_zero_many (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) |
| (ρ : UnitaryIrrep (Equiv.Perm (H.FreeAt 0))) (u : Fin ρ.dimension → ℂ) (hu : u ≠ 0) |
| (x₀ : Fin k ↪ H.FreeAt 0) |
| (hfixed : ∀ g : Equiv.Perm (H.FreeAt 0), (∀ i, g (x₀ i)=x₀ i) → |
| (SparseDimension.signTwist ρ.asRepresentation) g u=u) |
| (j : Fin G.b) (hj : 0 < G.bits j) (hsize : h+k < Fintype.card (G.Line j)) : |
| H.conditionalAverage hf z (ρ.pullback H.stabilizerFreeEquiv)=0 := |
| H.conditional_zero_of_signed_endpoints hf z ρ u hu x₀ hfixed |
| (fun x y => H.signed_endpoint_zero_many x y hz hz' j hj hsize) |
| theorem conditional_column_zero_uniform (hf : H.Feasible) |
| (ρ : UnitaryIrrep (Equiv.Perm (H.FreeAt 0))) (u : Fin ρ.dimension → ℂ) (hu : u ≠ 0) |
| (x₀ : Fin k ↪ H.FreeAt 0) |
| (hfixed : ∀ g : Equiv.Perm (H.FreeAt 0), (∀ i, g (x₀ i)=x₀ i) → |
| (SparseDimension.signTwist ρ.asRepresentation) g u=u) |
| (j : Fin G.b) (hsize : h+k+Fintype.card (G.Line j) < G.size) : |
| H.conditionalAverage hf 0 (ρ.pullback H.stabilizerFreeEquiv)=0 := |
| H.conditional_zero_of_signed_endpoints hf 0 ρ u hu x₀ hfixed |
| (fun x y => H.signed_endpoint_zero_uniform x y j hsize) |
| end CoordinateSweeps.Grid.Holes |
|
|
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| open scoped Matrix.Norms.L2Operator |
|
|
| end OAI |
|
|
