| import Mathlib |
| import OAI.Probability.CoordinateSweeps.Induction |
| import OAI.RepresentationTheory.Young.Entropy |
| import OAI.Probability.CoordinateSweeps.Scales |
|
|
| namespace OAI |
|
|
| /-! |
| Work on the genuinely missing main statements of the pinned manuscript. |
| All definitions are finite and use the source's ordinary probability and trace |
| normalizations. No result of the manuscript is assumed. |
| -/ |
|
|
| noncomputable section |
| open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder |
| attribute [local instance] Classical.propDecidable |
|
|
| namespace CoordinateSweeps.UnitaryIrrep |
|
|
| variable {Γ : Type*} [Group Γ] (ρ : UnitaryIrrep Γ) |
|
|
| lemma orbit_span_top (v : Fin ρ.dimension → ℂ) (hv : v ≠ 0) : |
| Submodule.span ℂ (Set.range (fun g => (ρ.matrix g).mulVec v)) = ⊤ := by |
| let S := Submodule.span ℂ (Set.range (fun g => (ρ.matrix g).mulVec v)) |
| have hvS : v ∈ S := by |
| have h := Submodule.subset_span (R := ℂ) (s := Set.range (fun g => (ρ.matrix g).mulVec v)) |
| (Set.mem_range_self (1 : Γ)) |
| simpa using h |
| have hne : S ≠ ⊥ := by |
| intro he; rw [he,Submodule.mem_bot] at hvS; exact hv hvS |
| apply (ρ.irreducible S ?_).resolve_left hne |
| intro g w hw |
| induction hw using Submodule.span_induction with |
| | mem w hw => |
| obtain ⟨k,rfl⟩ := hw |
| rw [Matrix.mulVec_mulVec,← map_mul] |
| exact Submodule.subset_span (Set.mem_range_self (g*k)) |
| | zero => simp |
| | add x y hx hy hix hiy => simpa only [Matrix.mulVec_add] using S.add_mem hix hiy |
| | smul c x hx hi => simpa only [Matrix.mulVec_smul] using S.smul_mem c hi |
|
|
| /- Elementary irreducible dimension bound needed for the finite base case; |
| no partition classification has been assumed. -/ |
| theorem dimension_le_card [Fintype Γ] : ρ.dimension ≤ Fintype.card Γ := by |
| let : NeZero ρ.dimension := ⟨ρ.positive.ne'⟩ |
| obtain ⟨v,hv⟩ := exists_ne (0 : Fin ρ.dimension → ℂ) |
| have h := finrank_le_of_span_eq_top (ρ.orbit_span_top v hv) |
| simpa using h |
|
|
| def fixed : Submodule ℂ (Fin ρ.dimension → ℂ) where |
| carrier := {v | ∀ g, (ρ.matrix g).mulVec v=v} |
| zero_mem' := by simp |
| add_mem' hu hv := by intro g; simp only [Matrix.mulVec_add,hu g,hv g] |
| smul_mem' c v hv := by intro g; simp only [Matrix.mulVec_smul,hv g] |
|
|
| lemma fixed_eq_bot_or_trivial : ρ.fixed = ⊥ ∨ ∀ g, ρ.matrix g = 1 := by |
| have hi := ρ.irreducible ρ.fixed (by |
| intro g v hv |
| change ∀ k, (ρ.matrix k).mulVec ((ρ.matrix g).mulVec v)=(ρ.matrix g).mulVec v |
| change ∀ k, (ρ.matrix k).mulVec v=v at hv |
| rw [hv g] |
| exact hv) |
| rcases hi with h | h |
| · exact Or.inl h |
| · right |
| intro g |
| apply Matrix.ext_iff_mulVec.mpr |
| intro v |
| have hv : v ∈ ρ.fixed := by rw [h]; trivial |
| simpa using hv g |
|
|
| /- The exact zero of a uniform group average in every nontrivial irreducible. |
| This is the strict moment bound at z=0 used in06's b=1 base case. -/ |
| theorem uniform_average_eq_zero [Fintype Γ] |
| (hρ : ¬ ∀ g, ρ.matrix g=1) : |
| (∑ g, (FiniteLaw.uniform Γ g : ℂ) • ρ.matrix g) = 0 := by |
| have hfix : ρ.fixed = ⊥ := ρ.fixed_eq_bot_or_trivial.resolve_right hρ |
| apply Matrix.ext_iff_mulVec.mpr |
| intro v |
| rw [Matrix.zero_mulVec] |
| have hmem : (∑ g, (FiniteLaw.uniform Γ g : ℂ) • ρ.matrix g).mulVec v ∈ ρ.fixed := by |
| intro k |
| simp only [Matrix.sum_mulVec,Matrix.smul_mulVec,Matrix.mulVec_sum,Matrix.mulVec_smul, |
| Matrix.mulVec_mulVec,← map_mul,FiniteLaw.uniform_apply] |
| exact Equiv.sum_comp (Equiv.mulLeft k) |
| (fun g => Complex.ofReal ((Fintype.card Γ : ℝ)⁻¹) • (ρ.matrix g).mulVec v) |
| rwa [hfix,Submodule.mem_bot] at hmem |
|
|
| end CoordinateSweeps.UnitaryIrrep |
|
|
| namespace CoordinateSweeps.UnitaryIrrep |
|
|
| variable {Γ : Type*} [Group Γ] [Fintype Γ] (ρ : UnitaryIrrep Γ) |
|
|
| lemma sum_matrix_eq_zero (hρ : ¬ ∀ g, ρ.matrix g=1) : ∑ g, ρ.matrix g=0 := by |
| have h := ρ.uniform_average_eq_zero hρ |
| simp only [FiniteLaw.uniform_apply,← Finset.smul_sum] at h |
| exact (smul_eq_zero.mp h).resolve_left (by |
| simp [Fintype.card_ne_zero]) |
|
|
| /- Uniform-in-the-irrep quantitative form of the finite one-block base |
| perturbation in06. A conditional coset has precisely these affine weights, |
| with u=1/m! and 0≤w≤1. No classification, finiteness of a chosen list of |
| representations, or continuity assumption is needed. -/ |
| theorem affine_average_norm_le (hρ : ¬ ∀ g, ρ.matrix g=1) |
| (u : ℝ) (hu : 0 < u) (w : Γ → ℝ) |
| (hw : ∀ g, 0 ≤ w g) (hw1 : ∀ g, w g ≤ 1) |
| {z : ℝ} (hz : 0 ≤ z) (hz1 : z ≤ 1/2) : |
| ‖((∑ g, ((1-z)*u+z*w g) : ℝ) : ℂ)⁻¹ • |
| ∑ g, (((1-z)*u+z*w g : ℝ) : ℂ) • ρ.matrix g‖ ≤ 2*z/u := by |
| let : NeZero ρ.dimension := ⟨ρ.positive.ne'⟩ |
| let Z : ℝ := ∑ g, ((1-z)*u+z*w g) |
| have hN : (0 : ℝ) < Fintype.card Γ := Nat.cast_pos.mpr Fintype.card_pos |
| have hZ : (Fintype.card Γ : ℝ)*(u/2) ≤ Z := by |
| calc |
| _ = ∑ _ : Γ, u/2 := by simp |
| _ ≤ Z := Finset.sum_le_sum (fun g _ => by |
| have hh := mul_nonneg hz (hw g) |
| nlinarith) |
| have hZp : 0 < Z := lt_of_lt_of_le (mul_pos hN (by positivity)) hZ |
| have hsum : (∑ g, (((1-z)*u+z*w g : ℝ) : ℂ) • ρ.matrix g) = |
| (z : ℂ) • ∑ g, (w g : ℂ) • ρ.matrix g := by |
| simp only [Complex.ofReal_add,Complex.ofReal_mul,add_smul,mul_smul, |
| Finset.sum_add_distrib,← Finset.smul_sum,ρ.sum_matrix_eq_zero hρ, |
| smul_zero,zero_add] |
| have hn : ‖∑ g, (w g : ℂ) • ρ.matrix g‖ ≤ Fintype.card Γ := by |
| calc |
| _ ≤ ∑ g, ‖(w g : ℂ) • ρ.matrix g‖ := norm_sum_le _ _ |
| _ ≤ ∑ _ : Γ, (1 : ℝ) := by |
| apply Finset.sum_le_sum |
| intro g _ |
| rw [norm_smul,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (hw g)] |
| exact (mul_le_of_le_one_right (hw g) |
| (matrix_unitary_norm_le _ (ρ.unitary g))).trans (hw1 g) |
| _ = Fintype.card Γ := by simp |
| change ‖(Z : ℂ)⁻¹ • _‖ ≤ _ |
| rw [hsum,norm_smul,norm_smul,norm_inv,Complex.norm_real,Complex.norm_real, |
| Real.norm_eq_abs,Real.norm_eq_abs,abs_of_pos hZp,abs_of_nonneg hz] |
| calc |
| Z⁻¹ * (z * ‖∑ g, (w g : ℂ) • ρ.matrix g‖) ≤ |
| Z⁻¹ * (z * Fintype.card Γ) := |
| mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left hn hz) (inv_nonneg.mpr hZp.le) |
| _ ≤ 2*z/u := by |
| rw [inv_mul_eq_div,div_le_iff₀ hZp] |
| have hmult := mul_le_mul_of_nonneg_left hZ (show 0 ≤ 2*z/u by positivity) |
| have he : 2*z/u * ((Fintype.card Γ : ℝ)*(u/2)) = z*Fintype.card Γ := by |
| field_simp |
| rw [he] at hmult |
| exact hmult |
|
|
| end CoordinateSweeps.UnitaryIrrep |
|
|
| namespace CoordinateSweeps.Grid |
|
|
| /- A one-coordinate grid, the base of06's induction. -/ |
| abbrev single (d : ℕ) : Grid := ⟨1,by decide,fun _ => d⟩ |
|
|
| instance single_line_unique (d : ℕ) (j : Fin (single d).b) : |
| Unique ((single d).Line j) := by |
| have he : IsEmpty {k : Fin (single d).b // k ≠ j} := |
| ⟨fun k => k.property (Subsingleton.elim _ _)⟩ |
| exact Pi.uniqueOfIsEmpty _ |
|
|
| /- The single coordinate slot identification is explicit. -/ |
| def singleSlot (d : ℕ) : (single d).Slot ≃ Cube d := |
| Equiv.piUnique (fun _ : Fin 1 => Cube d) |
|
|
| @[simp] theorem singleSlot_apply (d : ℕ) (x : (single d).Slot) : |
| singleSlot d x = x 0 := rfl |
|
|
| @[simp] theorem singleSlot_symm_apply (d : ℕ) (x : Cube d) (j : Fin 1) : |
| (singleSlot d).symm x j=x := rfl |
|
|
| /- Every line-choice array in a one-coordinate grid is one permutation. -/ |
| def singleChoice (d : ℕ) : (single d).Choices ≃ Equiv.Perm (Cube d) where |
| toFun ω := ω 0 default |
| invFun σ _ _ := σ |
| left_inv ω := by |
| funext j L |
| have hj : j=0 := Subsingleton.elim _ _ |
| subst j |
| exact congrArg (ω 0) (Subsingleton.elim _ _) |
| right_inv σ := rfl |
|
|
| lemma single_stage_apply (d : ℕ) (ω : (single d).Choices) (x : (single d).Slot) : |
| (single d).stage ω 0 x 0=singleChoice d ω (x 0) := by |
| have hs : (single d).stage ω 0 x 0=ω 0 (fun k => x k) (x 0) := by |
| simp [stage,fiberPerm,Equiv.piSplitAt_apply,Equiv.piSplitAt_symm_apply] |
| rw [hs] |
| change ω 0 (fun k => x k) (x 0)=ω 0 default (x 0) |
| exact congrArg (fun L => ω 0 L (x 0)) (Subsingleton.elim _ _) |
|
|
| lemma single_sweep (d : ℕ) (ω : (single d).Choices) : |
| (single d).sweep ω=(singleSlot d).symm.permCongr (singleChoice d ω) := by |
| apply Equiv.ext |
| intro x |
| funext j |
| have hj : j=0 := Subsingleton.elim _ _ |
| subst j |
| change (single d).boundary ω 1 x 0=_ |
| simp only [boundary,List.ofFn_succ,List.ofFn_zero,List.take_succ_cons,List.take_zero, |
| List.reverse_cons,List.reverse_nil,List.nil_append,List.prod_cons,List.prod_nil,mul_one] |
| exact single_stage_apply d ω x |
|
|
| /- No hidden fibers in the one-block base: all permutations are possible, |
| and each one determines the unique line-choice array. -/ |
| def singleSweepEquiv (d : ℕ) : (single d).Choices ≃ Equiv.Perm (single d).Slot := |
| (singleChoice d).trans (Equiv.permCongr (singleSlot d).symm) |
|
|
| @[simp] lemma singleSweepEquiv_apply (d : ℕ) (ω : (single d).Choices) : |
| singleSweepEquiv d ω=(single d).sweep ω := (single_sweep d ω).symm |
|
|
| lemma single_choiceWeight (d : ℕ) (z : ℝ) (ω : (single d).Choices) : |
| (single d).choiceWeight z ω= |
| (1-z)*(Fintype.card (Equiv.Perm (Cube d)) : ℝ)⁻¹+ |
| z*binaryLaw d (singleChoice d ω) := by |
| unfold choiceWeight |
| rw [Fin.prod_univ_one] |
| rw [Fintype.prod_subsingleton _ (default : (single d).Line 0)] |
| rfl |
|
|
| end CoordinateSweeps.Grid |
|
|
| namespace CoordinateSweeps.Grid.Holes |
| variable {d h : ℕ} (H : (Grid.single d).Holes h) |
|
|
| lemma single_compatible_iff (ω : (Grid.single d).Choices) : |
| H.Compatible ω ↔ ∀ i, (Grid.single d).sweep ω (H.path i 0)=H.path i 1 := by |
| constructor |
| · intro hω i |
| exact hω i 1 |
| · intro hω i t |
| fin_cases t |
| · simp [Grid.boundary] |
| · exact hω i |
|
|
| /- Exact bijection of conditioned one-block choices with the remaining |
| symmetric group, not an assumption of uniformity of that residual law. -/ |
| def singleResidualEquiv (hf : H.Feasible) : |
| {ω : (Grid.single d).Choices // H.Compatible ω} ≃ H.stabilizer where |
| toFun := H.residual hf |
| invFun g := ⟨(Grid.singleSweepEquiv d).symm |
| ((Grid.single d).sweep (H.reference hf)*g.val), by |
| apply (H.single_compatible_iff _).mpr |
| intro i |
| rw [← Grid.singleSweepEquiv_apply,Equiv.apply_symm_apply] |
| change (Grid.single d).sweep (H.reference hf) (g.val (H.path i 0))=H.path i 1 |
| rw [g.property i] |
| exact H.reference_compatible hf i 1⟩ |
| left_inv ω := by |
| apply Subtype.ext |
| apply (Grid.singleSweepEquiv d).injective |
| simp only [Equiv.apply_symm_apply,Grid.singleSweepEquiv_apply,residual, |
| mul_inv_cancel_left] |
| right_inv g := by |
| apply Subtype.ext |
| change ((Grid.single d).sweep (H.reference hf))⁻¹ * |
| (Grid.single d).sweep ((Grid.singleSweepEquiv d).symm |
| ((Grid.single d).sweep (H.reference hf)*g.val))=g.val |
| rw [← Grid.singleSweepEquiv_apply d ((Grid.singleSweepEquiv d).symm |
| ((Grid.single d).sweep (H.reference hf)*g.val)), |
| Equiv.apply_symm_apply,inv_mul_cancel_left] |
|
|
| lemma single_probability (hf : H.Feasible) (z : ℝ) : |
| H.probability z = ∑ g : H.stabilizer, |
| (Grid.single d).choiceWeight z ((H.singleResidualEquiv hf).symm g).val := |
| ((H.singleResidualEquiv hf).symm.sum_comp _).symm |
|
|
| lemma single_conditionalAverage (hf : H.Feasible) (z : ℝ) |
| (ρ : UnitaryIrrep H.stabilizer) : |
| H.conditionalAverage hf z ρ = |
| ((∑ g : H.stabilizer, (Grid.single d).choiceWeight z |
| ((H.singleResidualEquiv hf).symm g).val : ℝ) : ℂ)⁻¹ • |
| ∑ g : H.stabilizer, ((Grid.single d).choiceWeight z |
| ((H.singleResidualEquiv hf).symm g).val : ℂ) • ρ.matrix g := by |
| unfold conditionalAverage |
| rw [H.single_probability hf z] |
| congr 1 |
| rw [← (H.singleResidualEquiv hf).symm.sum_comp] |
| apply Finset.sum_congr rfl |
| intro g _ |
| congr 2 |
| exact (H.singleResidualEquiv hf).apply_symm_apply g |
|
|
| end CoordinateSweeps.Grid.Holes |
|
|
| namespace CoordinateSweeps.Grid.Holes |
| variable {d h : ℕ} (H : (Grid.single d).Holes h) |
|
|
| /- Actual conditioned single-coordinate operator, uniform in the hole family, |
| reference bijection, irrep, and representation realization. -/ |
| theorem single_conditional_norm_le (hf : H.Feasible) |
| (ρ : UnitaryIrrep H.stabilizer) (hρ : ¬ ∀ g, ρ.matrix g=1) |
| {z : ℝ} (hz : 0 ≤ z) (hz1 : z ≤ 1/2) : |
| ‖H.conditionalAverage hf z ρ‖ ≤ |
| 2*z*(Fintype.card (Equiv.Perm (Cube d)) : ℝ) := by |
| rw [H.single_conditionalAverage hf z ρ] |
| simp only [Grid.single_choiceWeight] |
| simpa only [div_inv_eq_mul] using |
| ρ.affine_average_norm_le hρ |
| ((Fintype.card (Equiv.Perm (Cube d)) : ℝ)⁻¹) |
| (inv_pos.mpr (Nat.cast_pos.mpr Fintype.card_pos)) |
| (fun g => binaryLaw d (Grid.singleChoice d ((H.singleResidualEquiv hf).symm g).val)) |
| (fun g => (binaryLaw d).nonneg _) (fun g => (binaryLaw d).mass_le_one _) hz hz1 |
|
|
| lemma single_dimension_le (ρ : UnitaryIrrep H.stabilizer) : |
| ρ.dimension ≤ Fintype.card (Equiv.Perm (Cube d)) := by |
| apply ρ.dimension_le_card.trans |
| have hc : Fintype.card H.stabilizer ≤ Fintype.card (Equiv.Perm (Grid.single d).Slot) := |
| Fintype.card_subtype_le _ |
| rwa [Fintype.card_congr (Equiv.permCongr (Grid.singleSlot d))] at hc |
|
|
| /- Exact one-block moment bound before choosing the absolute real interval. -/ |
| theorem single_conditional_moment_le (hf : H.Feasible) |
| (ρ : UnitaryIrrep H.stabilizer) (hρ : ¬ ∀ g, ρ.matrix g=1) |
| {z : ℝ} (hz : 0 ≤ z) (hz1 : z ≤ 1/2) (q : ℕ) : |
| schattenMoment q (H.conditionalAverage hf z ρ) ≤ |
| (Fintype.card (Equiv.Perm (Cube d)) : ℝ) * |
| (2*z*(Fintype.card (Equiv.Perm (Cube d)) : ℝ))^(2*q) := by |
| let : NeZero ρ.dimension := ⟨ρ.positive.ne'⟩ |
| exact (trace_moment_le _ q).trans (mul_le_mul |
| (by exact_mod_cast H.single_dimension_le ρ) |
| (pow_le_pow_left₀ (norm_nonneg _) (H.single_conditional_norm_le hf ρ hρ hz hz1) _) |
| (by positivity) (by positivity)) |
|
|
| end CoordinateSweeps.Grid.Holes |
|
|
| namespace CoordinateSweeps |
|
|
| lemma e0_pos : 0 < e0 := by norm_num [e0,a] |
| lemma c0_eq_e0 : c0=e0 := rfl |
| lemma c0_small : 2*c0 < 1 := by norm_num [c0,a] |
|
|
| namespace Grid |
|
|
| lemma log_size_lower_one (G : Grid) {r : ℕ} (hG : G.Allowed r) : |
| (r : ℝ)*Real.log 2 ≤ Real.log G.size := by |
| apply le_trans _ (G.log_size_lower hG) |
| have hb : (1 : ℝ) ≤ G.b := by exact_mod_cast G.positive |
| exact le_mul_of_one_le_left (mul_nonneg (Nat.cast_nonneg _) (Real.log_nonneg (by norm_num))) hb |
|
|
| end Grid |
|
|
| /- Exactly the two largeness requirements stated at the start of06, converted |
| from log R to bit exponent r. Both constants remain the source constants. -/ |
| def ScaleLarge (r : ℕ) : Prop := |
| 1 ≤ r ∧ (2/e0)^2 ≤ (r : ℝ)*Real.log 2 ∧ 4/e0 ≤ (r : ℝ)*Real.log 2 |
|
|
| lemma exists_scaleLarge : ∃ r, ScaleLarge r := by |
| let B : ℝ := max ((2/e0)^2) (4/e0) |
| obtain ⟨r,hr⟩ := exists_nat_gt (max 1 (B/Real.log 2)) |
| have hr1 : (1 : ℝ) < r := lt_of_le_of_lt (le_max_left _ _) hr |
| have hrB : B/Real.log 2 < r := lt_of_le_of_lt (le_max_right _ _) hr |
| have hh : B ≤ (r : ℝ)*Real.log 2 := |
| ((div_lt_iff₀ (Real.log_pos (by norm_num))).mp hrB).le |
| refine ⟨r,?_,?_,?_⟩ |
| · have hnat : 1 < r := by exact_mod_cast hr1 |
| omega |
| · exact (le_max_left _ _).trans hh |
| · exact (le_max_right _ _).trans hh |
|
|
| lemma scale_coefficients {r : ℕ} (hr : ScaleLarge r) (G : Grid) (hG : G.Allowed r) : |
| 0 < Real.log G.size ∧ c G.size ≤ 2*c0 ∧ e0/2 ≤ e G.size ∧ |
| (G.b : ℝ) ≤ (e0/4)*Real.log G.size := by |
| have he := e0_pos |
| have hroot : (2/e0)^2 ≤ Real.log G.size := hr.2.1.trans (G.log_size_lower_one hG) |
| have hlog : 0 < Real.log G.size := lt_of_lt_of_le (by positivity) hroot |
| have hs : 2/e0 ≤ Real.sqrt (Real.log G.size) := |
| (Real.le_sqrt (by positivity) hlog.le).mpr hroot |
| have hspos : 0 < Real.sqrt (Real.log G.size) := Real.sqrt_pos.mpr hlog |
| have hi : 1/Real.sqrt (Real.log G.size) ≤ e0/2 := by |
| apply (div_le_iff₀ hspos).mpr |
| have hh := mul_le_mul_of_nonneg_left hs (show 0 ≤ e0/2 by positivity) |
| field_simp at hh ⊢ |
| nlinarith |
| have hb : (G.b : ℝ)*(4/e0) ≤ Real.log G.size := |
| (mul_le_mul_of_nonneg_left hr.2.2 (Nat.cast_nonneg _)).trans (G.log_size_lower hG) |
| refine ⟨hlog,?_,?_,?_⟩ |
| · unfold c |
| rw [c0_eq_e0] |
| linarith |
| · unfold e |
| linarith |
| · have hh := mul_le_mul_of_nonneg_left hb (show 0 ≤ e0/4 by positivity) |
| field_simp at hh |
| nlinarith |
|
|
| namespace Grid.Holes |
| variable {G : Grid} {h : ℕ} (H : G.Holes h) |
|
|
| /- Exact source nonnegative allowance, including h=0 and the empty type. -/ |
| theorem allowance_lower {r : ℕ} (hr : ScaleLarge r) (hG : G.Allowed r) : |
| (e0/4) * h * Real.log G.size ≤ e G.size * h * Real.log G.size - H.cost := by |
| obtain ⟨hlog,hc,he,hb⟩ := scale_coefficients hr G hG |
| have h1 := mul_le_mul_of_nonneg_right he (show 0 ≤ (h : ℝ)*Real.log G.size by positivity) |
| have h2 := H.cost_le.trans (mul_le_mul_of_nonneg_right hb (Nat.cast_nonneg h)) |
| nlinarith |
|
|
| lemma allowance_nonneg {r : ℕ} (hr : ScaleLarge r) (hG : G.Allowed r) : |
| 0 ≤ e G.size * h * Real.log G.size - H.cost := |
| (mul_nonneg (mul_nonneg (div_nonneg e0_pos.le (by norm_num)) (Nat.cast_nonneg _)) |
| (scale_coefficients hr G hG).1.le).trans (H.allowance_lower hr hG) |
|
|
| end Grid.Holes |
|
|
| lemma logMoment_le_of_le {t u : ℝ} (ht : 0 ≤ t) (hu : 0 < u) (htu : t ≤ u) : |
| logMoment t ≤ (Real.log u : EReal) := by |
| by_cases ht0 : t=0 |
| · simp [logMoment,ht0] |
| · rw [logMoment,ite_eq_right ht0] |
| exact_mod_cast (Real.log_le_log_iff (lt_of_le_of_ne ht (Ne.symm ht0)) hu).mpr htu |
|
|
| namespace Grid.Holes |
| variable {G : Grid} {h : ℕ} (H : G.Holes h) |
|
|
| /- Entire automatic branch06 eq16, with no representation type omitted. -/ |
| theorem conditional_automatic (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz1 : z < 1) |
| (ρ : UnitaryIrrep H.stabilizer) (q : ℕ) |
| (ha : (1+c G.size)*Real.log ρ.dimension ≤ |
| e G.size*h*Real.log G.size-H.cost) : |
| logMoment (schattenMoment q (H.conditionalAverage hf z ρ)) ≤ |
| ((-c G.size*Real.log ρ.dimension+e G.size*h*Real.log G.size-H.cost : ℝ) : EReal) := by |
| apply (logMoment_le_of_le (H.conditionalMoment_nonneg hf z ρ q) |
| (Nat.cast_pos.mpr ρ.positive) (H.conditionalMoment_le_dimension hf hz hz1 ρ q)).trans |
| exact_mod_cast (show Real.log ρ.dimension ≤ |
| -c G.size*Real.log ρ.dimension+e G.size*h*Real.log G.size-H.cost by nlinarith) |
|
|
| /- All one-dimensional types (trivial, sign, empty, and M=1), as required |
| explicitly in the statement and the first branch of the main induction. -/ |
| theorem conditional_dimension_one {r : ℕ} (hr : ScaleLarge r) (hG : G.Allowed r) |
| (hf : H.Feasible) {z : ℝ} (hz : 0 ≤ z) (hz1 : z < 1) |
| (ρ : UnitaryIrrep H.stabilizer) (hρ : ρ.dimension=1) (q : ℕ) : |
| logMoment (schattenMoment q (H.conditionalAverage hf z ρ)) ≤ |
| ((-c G.size*Real.log ρ.dimension+e G.size*h*Real.log G.size-H.cost : ℝ) : EReal) := by |
| apply H.conditional_automatic hf hz hz1 ρ q |
| simpa [hρ] using H.allowance_nonneg hr hG |
|
|
| end Grid.Holes |
| end CoordinateSweeps |
|
|
| namespace CoordinateSweeps |
| namespace UnitaryIrrep |
| variable {Γ : Type*} [Group Γ] (ρ : UnitaryIrrep Γ) |
|
|
| lemma dimension_one_of_trivial (hρ : ∀ g, ρ.matrix g=1) : ρ.dimension=1 := by |
| let : NeZero ρ.dimension := ⟨ρ.positive.ne'⟩ |
| obtain ⟨v,hv⟩ := exists_ne (0 : Fin ρ.dimension → ℂ) |
| have hs := ρ.orbit_span_top v hv |
| simp only [hρ,Matrix.one_mulVec,Set.range_const] at hs |
| have hf := finrank_span_singleton (K := ℂ) hv |
| rw [hs] at hf |
| simpa using hf |
|
|
| end UnitaryIrrep |
|
|
| /- An explicit uniform base interval, so06's finiteness perturbation requires |
| no choice of a finite list of representation realizations. -/ |
| def baseWidth (r : ℕ) : ℝ := ((2^(2*r)).factorial : ℕ) |
| def baseZeta (r : ℕ) : ℝ := 1/(4*(baseWidth r)^2) |
|
|
| lemma baseWidth_one_le (r : ℕ) : 1 ≤ baseWidth r := by |
| unfold baseWidth |
| exact_mod_cast (show 1 ≤ (2^(2*r)).factorial from Nat.factorial_pos _) |
|
|
| lemma baseZeta_pos (r : ℕ) : 0 < baseZeta r := by |
| have h := baseWidth_one_le r |
| unfold baseZeta |
| positivity |
|
|
| lemma baseZeta_le_half (r : ℕ) : baseZeta r ≤ 1/2 := by |
| have h := baseWidth_one_le r |
| unfold baseZeta |
| apply (div_le_iff₀ (by positivity : 0 < 4*(baseWidth r)^2)).mpr |
| nlinarith |
|
|
| lemma single_card_le_baseWidth {r d : ℕ} (hd : d ≤ 2*r) : |
| (Fintype.card (Equiv.Perm (Cube d)) : ℝ) ≤ baseWidth r := by |
| simp only [Fintype.card_perm,Cube,Fintype.card_fun,Fintype.card_bool,Fintype.card_fin] |
| unfold baseWidth |
| exact_mod_cast Nat.factorial_le (Nat.pow_le_pow_right (by norm_num : 0 < 2) hd) |
|
|
| namespace Grid.Holes |
| variable {d h : ℕ} (H : (Grid.single d).Holes h) |
|
|
| theorem single_base_norm {r : ℕ} (hd : d ≤ 2*r) (hf : H.Feasible) |
| (ρ : UnitaryIrrep H.stabilizer) (hρ : ρ.dimension ≠ 1) |
| {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ baseZeta r) : |
| ‖H.conditionalAverage hf z ρ‖ ≤ (baseWidth r)⁻¹ := by |
| have hB := baseWidth_one_le r |
| have hc := single_card_le_baseWidth hd |
| have hZ := baseZeta_pos r |
| have hnt : ¬ ∀ g, ρ.matrix g=1 := fun hh => hρ (ρ.dimension_one_of_trivial hh) |
| apply (H.single_conditional_norm_le hf ρ hnt hz |
| (hz'.trans (baseZeta_le_half r))).trans |
| calc |
| 2*z*(Fintype.card (Equiv.Perm (Cube d)) : ℝ) ≤ 2*baseZeta r*baseWidth r := |
| mul_le_mul (mul_le_mul_of_nonneg_left hz' (by norm_num)) hc |
| (Nat.cast_nonneg _) (by positivity) |
| _ ≤ (baseWidth r)⁻¹ := by |
| unfold baseZeta |
| field_simp |
| nlinarith |
|
|
| /- A quantitative strict base estimate for all nontrivial irreducibles. -/ |
| theorem single_base_moment {r : ℕ} (hd : d ≤ 2*r) (hf : H.Feasible) |
| (ρ : UnitaryIrrep H.stabilizer) (hρ : ρ.dimension ≠ 1) |
| {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ baseZeta r) |
| {q : ℕ} (hq : 1 ≤ q) : |
| schattenMoment q (H.conditionalAverage hf z ρ) ≤ (ρ.dimension : ℝ)⁻¹ := by |
| let : NeZero ρ.dimension := ⟨ρ.positive.ne'⟩ |
| have hB := baseWidth_one_le r |
| have hBp : 0 < baseWidth r := lt_of_lt_of_le (by norm_num) hB |
| have hBi : (baseWidth r)⁻¹ ≤ 1 := inv_le_one_of_one_le₀ hB |
| have hD : (ρ.dimension : ℝ) ≤ baseWidth r := |
| (show (ρ.dimension : ℝ) ≤ (Fintype.card (Equiv.Perm (Cube d)) : ℝ) by |
| exact_mod_cast H.single_dimension_le ρ).trans (single_card_le_baseWidth hd) |
| have hnorm := H.single_base_norm hd hf ρ hρ hz hz' |
| calc |
| _ ≤ (ρ.dimension : ℝ)*‖H.conditionalAverage hf z ρ‖^(2*q) := trace_moment_le _ q |
| _ ≤ baseWidth r*((baseWidth r)⁻¹)^(2*q) := |
| mul_le_mul hD (pow_le_pow_left₀ (norm_nonneg _) hnorm _) |
| (by positivity) (by positivity) |
| _ ≤ baseWidth r*((baseWidth r)⁻¹)^2 := |
| mul_le_mul_of_nonneg_left (pow_le_pow_of_le_one (by positivity) hBi (by omega)) hBp.le |
| _ = (baseWidth r)⁻¹ := by field_simp |
| _ ≤ (ρ.dimension : ℝ)⁻¹ := (inv_le_inv₀ hBp (by exact_mod_cast ρ.positive)).mpr hD |
|
|
| /- The full06 one-coordinate base with the manuscript's precise c,e and cost. -/ |
| theorem single_conditional_main {r : ℕ} (hr : ScaleLarge r) |
| (hG : (Grid.single d).Allowed r) (hf : H.Feasible) |
| {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ baseZeta r) |
| (ρ : UnitaryIrrep H.stabilizer) {q : ℕ} (hq : 1 ≤ q) : |
| logMoment (schattenMoment q (H.conditionalAverage hf z ρ)) ≤ |
| ((-c (Grid.single d).size*Real.log ρ.dimension+ |
| e (Grid.single d).size*h*Real.log (Grid.single d).size-H.cost : ℝ) : EReal) := by |
| have hz1 : z < 1 := lt_of_le_of_lt (hz'.trans (baseZeta_le_half r)) (by norm_num) |
| by_cases hρ : ρ.dimension=1 |
| · exact H.conditional_dimension_one hr hG hf hz hz1 ρ hρ q |
| have hm := H.single_base_moment (hG 0).2 hf ρ hρ hz hz' hq |
| have hl := logMoment_le_of_le (H.conditionalMoment_nonneg hf z ρ q) |
| (inv_pos.mpr (Nat.cast_pos.mpr ρ.positive)) hm |
| rw [Real.log_inv] at hl |
| apply hl.trans |
| have hc : c (Grid.single d).size ≤ 1 := |
| (scale_coefficients hr _ hG).2.1.trans c0_small.le |
| have hfnonneg : 0 ≤ Real.log ρ.dimension := |
| Real.log_nonneg (by exact_mod_cast ρ.positive) |
| have ha := H.allowance_nonneg hr hG |
| exact_mod_cast (show -Real.log ρ.dimension ≤ |
| -c (Grid.single d).size*Real.log ρ.dimension+ |
| e (Grid.single d).size*h*Real.log (Grid.single d).size-H.cost by nlinarith) |
|
|
| end Grid.Holes |
| end CoordinateSweeps |
|
|
| namespace CoordinateSweeps.Grid |
| lemma eq_single_of_b_one (G : Grid) (hb : G.b=1) : ∃ d, G=single d := by |
| rcases G with ⟨b,hpos,bits⟩ |
| dsimp at hb |
| subst b |
| refine ⟨bits 0,?_⟩ |
| congr |
| funext i |
| exact congrArg bits (Subsingleton.elim i 0) |
|
|
| /- Full base branch for every allowed one-coordinate grid, not only a chosen |
| canonical coordinate presentation. -/ |
| theorem conditional_main_b_one {r : ℕ} (hr : ScaleLarge r) |
| (G : Grid) (hb : G.b=1) (hG : G.Allowed r) |
| {h : ℕ} (H : G.Holes h) (hf : H.Feasible) |
| {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ baseZeta r) |
| (ρ : UnitaryIrrep H.stabilizer) {q : ℕ} (hq : 1 ≤ q) : |
| logMoment (schattenMoment q (H.conditionalAverage hf z ρ)) ≤ |
| ((-c G.size*Real.log ρ.dimension+e G.size*h*Real.log G.size-H.cost : ℝ) : EReal) := by |
| obtain ⟨d,rfl⟩ := G.eq_single_of_b_one hb |
| exact H.single_conditional_main hr hG hf hz hz' ρ hq |
| end CoordinateSweeps.Grid |
| end |
|
|
| namespace CoordinateSweeps.Grid.Holes |
| open UnitaryIrrep YoungCorner |
| variable {A B : Grid} {h : ℕ} (H : (concat A B).Holes h) |
| /- The unswept free sites and the literal occupied junction board are |
| identified by the actual reference first-half sweep. -/ |
| noncomputable def initialJunctionFree (hf : H.Feasible) : H.FreeAt 0 ≃ H.JunctionFree := |
| Marked.freeEquiv (fun i => H.path i 0) (fun i => H.path i (suffixTime A B 0)) |
| (H.rowAction (H.refPair hf).1) (H.rowAction_marked hf (H.refPair hf).1) |
| lemma initialJunction_conj (hf : H.Feasible) (g : H.stabilizer) : |
| H.junctionFreeEquiv (H.junctionEquiv hf g)= |
| (H.initialJunctionFree hf).permCongrHom (H.stabilizerFreeEquiv g) := by |
| apply Equiv.ext |
| intro x |
| apply Subtype.ext |
| rfl |
| lemma junctionChart_symm_boxes (hf : H.Feasible) |
| (eF : Fin (Fintype.card H.JunctionFree) ≃ H.JunctionFree) |
| (μ : YoungDiagram) (eB : H.FreeAt 0 ≃ Boxes μ) |
| (g : Equiv.Perm (Fin (Fintype.card H.JunctionFree))) : |
| (H.junctionChart hf eF).symm g= |
| H.boxesChart μ eB ((eF.trans ((H.initialJunctionFree hf).symm.trans eB)).permCongrHom g) := by |
| apply (H.junctionChart hf eF).injective |
| rw [MulEquiv.apply_symm_apply] |
| change g=eF.symm.permCongrHom (H.junctionFreeEquiv (H.junctionEquiv hf |
| (H.boxesChart μ eB ((eF.trans ((H.initialJunctionFree hf).symm.trans eB)).permCongrHom g)))) |
| rw [H.initialJunction_conj] |
| change g=eF.symm.permCongrHom ((H.initialJunctionFree hf).permCongrHom |
| (H.stabilizerFreeEquiv (H.stabilizerFreeEquiv.symm (eB.symm.permCongrHom |
| ((eF.trans ((H.initialJunctionFree hf).symm.trans eB)).permCongrHom g))))) |
| rw [MulEquiv.apply_symm_apply] |
| apply Equiv.ext |
| intro x |
| simp [Equiv.permCongrHom,Equiv.permCongr] |
| lemma junction_hasShape (hf : H.Feasible) |
| (eF : Fin (Fintype.card H.JunctionFree) ≃ H.JunctionFree) |
| (μ : YoungDiagram) (eB : H.FreeAt 0 ≃ Boxes μ) |
| (σ : UnitaryIrrep H.stabilizer) |
| (hσ : hasShape μ (Equiv.refl _) (σ.pullback (H.boxesChart μ eB)).asRepresentation) : |
| hasShape μ (eF.trans ((H.initialJunctionFree hf).symm.trans eB)) |
| (σ.pullback (H.junctionChart hf eF).symm).asRepresentation := by |
| let t := eF.trans ((H.initialJunctionFree hf).symm.trans eB) |
| have he : (σ.pullback (H.junctionChart hf eF).symm).asRepresentation= |
| (σ.pullback (H.boxesChart μ eB)).asRepresentation.comp t.permCongrHom := by |
| apply MonoidHom.ext |
| intro g |
| change Matrix.toLinAlgEquiv' (σ.matrix ((H.junctionChart hf eF).symm g))= |
| Matrix.toLinAlgEquiv' (σ.matrix (H.boxesChart μ eB (t.permCongrHom g))) |
| rw [H.junctionChart_symm_boxes] |
| rw [he] |
| change hasShape μ t ((σ.pullback (H.boxesChart μ eB)).asRepresentation.comp t.permCongrHom) |
| simpa only [Equiv.trans_refl] using (hasShape_reparam μ t (Equiv.refl _) _).mpr hσ |
| lemma conditionalAverage_cancelChart (hf : H.Feasible) |
| (eF : Fin (Fintype.card H.JunctionFree) ≃ H.JunctionFree) |
| (σ : UnitaryIrrep H.stabilizer) (z : ℝ) : |
| H.conditionalAverage hf z ((σ.pullback (H.junctionChart hf eF).symm).pullback (H.junctionChart hf eF))= |
| H.conditionalAverage hf z σ := by |
| rw [H.conditionalAverage_eq_sum,H.conditionalAverage_eq_sum] |
| apply Finset.sum_congr rfl |
| intro ω hω |
| change (_:ℂ) • σ.matrix ((H.junctionChart hf eF).symm (H.junctionChart hf eF (H.residual hf ω)))=_ |
| rw [MulEquiv.symm_apply_apply] |
| /- Exact hooked-main estimate for the actual stabilizer representation and |
| its literal initial-site Young labeling, with arbitrary feasible holes. -/ |
| theorem actual_hook_bound (p : ℕ) (hp : 0<p) (hf : H.Feasible) |
| (z : ℝ) (q : ℕ) (hq : 0<q) (c e : ℝ) (hc : 0≤c) (hcq : c≤q) |
| (s : ℕ) (hpS : p≤ s) (hAS : A.size≤ s) (hBS : B.size≤ s) |
| (σ : UnitaryIrrep H.stabilizer) |
| (hR : ∀ y : B.Slot, ∀ τ : UnitaryIrrep (H.rowHoles y).stabilizer, |
| schattenMoment q ((H.rowHoles y).conditionalAverage (H.rowHoles y).feasible_of_disjoint z τ) ≤ |
| Real.exp (-c*Real.log τ.dimension+e*H.rowCount y*Real.log A.size-(H.rowHoles y).cost)) |
| (hC : ∀ x : A.Slot, ∀ τ : UnitaryIrrep (H.columnHoles x).stabilizer, |
| schattenMoment q ((H.columnHoles x).conditionalAverage (H.columnHoles x).feasible_of_disjoint z τ) ≤ |
| Real.exp (-c*Real.log τ.dimension+e*H.columnCount x*Real.log B.size-(H.columnHoles x).cost)) |
| (μ : YoungDiagram) (eB : H.FreeAt 0 ≃ Boxes μ) |
| (hσ : hasShape μ (Equiv.refl _) (σ.pullback (H.boxesChart μ eB)).asRepresentation) (hhook : Hook μ p) : |
| schattenMoment q (H.conditionalAverage hf z σ) ≤ |
| Real.exp (-c*Real.log σ.dimension+e*h*(Real.log A.size+Real.log B.size)-H.cost+c*h+ |
| (((2*q+1:ℕ):ℝ)*((A.size+B.size)*((2*p)*(2*p)):ℕ)+ |
| c*((A.size+B.size)*(41*p^2):ℕ))*Real.log (s+1:ℕ)) := by |
| let eF := (Fintype.equivFin H.JunctionFree).symm |
| have hh := H.grid_conditional_hook_bound p hp eF hf z q hq c e hc hcq s hpS hAS hBS |
| (σ.pullback (H.junctionChart hf eF).symm) hR hC μ |
| (eF.trans ((H.initialJunctionFree hf).symm.trans eB)) (H.junction_hasShape hf eF μ eB σ hσ) hhook |
| rw [H.conditionalAverage_cancelChart] at hh |
| exact hh |
| end CoordinateSweeps.Grid.Holes |
|
|
| open scoped Matrix.Norms.L2Operator |
|
|
| end OAI |
|
|
