introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
26.5 kB
import Mathlib
import OAI.Probability.CoordinateSweeps.Perturbation
namespace OAI
open scoped Matrix.Norms.L2Operator
namespace CoordinateSweeps
lemma moment_le_exp_of_logMoment_le {t B : ℝ} (ht : 0≤t)
(h : logMoment t ≤ (B:EReal)) : t ≤ Real.exp B := by
by_cases hz : t=0
· rw [hz]; exact (Real.exp_pos _).le
· rw [logMoment,ite_eq_right hz] at h
have hh : Real.log t ≤ B := by exact_mod_cast h
simpa only [Real.exp_log (lt_of_le_of_ne ht (Ne.symm hz))] using Real.exp_le_exp.mpr hh
lemma logMoment_le_of_moment_le_exp {t B : ℝ} (ht : 0≤t) (h : t≤Real.exp B) :
logMoment t ≤ (B:EReal) := by
simpa only [Real.log_exp] using logMoment_le_of_le ht (Real.exp_pos B) h
end CoordinateSweeps
namespace CoordinateSweeps.Grid.Holes
open SparseScalar SparseDimension ScalarInduction
variable {G : Grid} {h r : ℕ} (H : G.Holes h)
lemma conditionalAverage_free_cancel (hf : H.Feasible) (z : ℝ) (σ : UnitaryIrrep H.stabilizer) :
H.conditionalAverage hf z ((σ.pullback H.stabilizerFreeEquiv.symm).pullback H.stabilizerFreeEquiv)=
H.conditionalAverage hf z σ := by
rw [H.conditionalAverage_eq_sum,H.conditionalAverage_eq_sum]
apply Finset.sum_congr rfl
intro ω hω
change (_:ℂ) • σ.matrix (H.stabilizerFreeEquiv.symm (H.stabilizerFreeEquiv (H.residual hf ω)))=_
rw [MulEquiv.symm_apply_apply]
/-- Entire nonautomatic sparse-dimension branch of the conditional main,
with the actual stabilizer irrep, actual feasible paths and a common real z interval. -/
theorem conditional_sparse_main (hr : ScaleLarge r) (hrS : ScaleReady r)
(hG : G.Allowed r) (hS : MainSizeReady SparseScalar.q G.size)
(hf : H.Feasible) {zStar : ℝ} (hζ : SparsePerturb r zStar) {z : ℝ} (hz : z∈Set.Icc 0 zStar)
(σ : UnitaryIrrep H.stabilizer) (hσ : σ.dimension≠1)
(ha : ¬ (1+c G.size)*Real.log σ.dimension ≤ e G.size*h*Real.log G.size-H.cost)
(hF : Real.log σ.dimension < (G.size:ℝ)^(1-a/4)) :
schattenMoment SparseScalar.q (H.conditionalAverage hf z σ) ≤
Real.exp (-c G.size*Real.log σ.dimension+e G.size*h*Real.log G.size-H.cost) := by
let ρ := σ.pullback H.stabilizerFreeEquiv.symm
obtain ⟨k,t,hkt,ht,hD,hkM,⟨L⟩⟩ := exists_level ρ
have hΩ : Fintype.card (H.FreeAt 0)≤G.size := by rw [H.card_freeAt]; exact Nat.sub_le _ _
have hks := hkM.trans hΩ
have hlogs := level_log_bounds ρ G.size_pos hΩ hkt ht hD
change Real.log σ.dimension≤k*Real.log G.size ∧ (k:ℝ)≤4*Real.log σ.dimension at hlogs
have hk : 1≤k := by
by_contra hh
have he : k=0 := by omega
rw [he,pow_zero] at hD
have hdim : σ.dimension=1 := by have hh0:=σ.positive; change σ.dimension≤1 at hD; omega
exact hσ hdim
have hL := (scale_coefficients hr G hG).1
have hc := (scale_coefficients hr G hG).2.1
have hc1 : c G.size≤1 := hc.trans (by norm_num [c0,a])
have hF0 : 0≤Real.log σ.dimension := Real.log_nonneg (by exact_mod_cast σ.positive)
have hallow := H.allowance_lower hr hG
have hn := lt_of_not_ge ha
have hhh : (h:ℝ)*Real.log G.size ≤ K0*Real.log σ.dimension := by
have hm := mul_le_mul_of_nonneg_right hc1 hF0
norm_num [e0,a,K0] at hallow ⊢
nlinarith
have hh : (h:ℝ)≤K0*k := by
have hm := mul_le_mul_of_nonneg_left hlogs.1 (by norm_num [K0] : 0≤K0)
exact (mul_le_mul_iff_right₀ hL).mp (by nlinarith)
have hsp : ((h+k:ℕ):ℝ)≤(G.size:ℝ)^(1-theta) := by
have hh0 := (Nat.cast_nonneg h : (0:ℝ)≤h)
have hhle : (h:ℝ)≤K0*Real.log σ.dimension := by nlinarith [hS.one]
have hsum : ((h+k:ℕ):ℝ)≤(100004:ℝ)*Real.log σ.dimension := by
push_cast
norm_num [K0] at hhle
linarith [hlogs.2]
apply hsum.trans
apply (mul_le_mul_of_nonneg_left hF.le (by norm_num : (0:ℝ)≤100004)).trans
simpa only [theta] using hS.sparse
have hnorm := H.level_sparse_norm hrS hG hf hζ hz hk hks hh hsp ρ L
rw [show ρ=σ.pullback H.stabilizerFreeEquiv.symm from rfl,H.conditionalAverage_free_cancel] at hnorm
let : NeZero σ.dimension := ⟨σ.positive.ne'⟩
have hp := pow_le_pow_left₀ (norm_nonneg (H.conditionalAverage hf z σ)) hnorm (2*SparseScalar.q)
calc
_ ≤ (σ.dimension:ℝ)*‖H.conditionalAverage hf z σ‖^(2*SparseScalar.q) := trace_moment_le _ _
_ ≤ (σ.dimension:ℝ)*((G.size:ℝ)^(-rho*k))^(2*SparseScalar.q) :=
mul_le_mul_of_nonneg_left hp (Nat.cast_nonneg _)
_ = Real.exp (Real.log σ.dimension-4*k*Real.log G.size) := by
rw [rpow_exp _ _ (by exact_mod_cast G.size_pos),←Real.exp_nat_mul]
nth_rw 1 [←Real.exp_log (by exact_mod_cast σ.positive : (0:ℝ)<σ.dimension)]
rw [←Real.exp_add]
congr 1
norm_num [SparseScalar.q,rho]
ring
_ ≤ Real.exp (-3*Real.log σ.dimension) := Real.exp_le_exp.mpr (by nlinarith [hlogs.1])
_ ≤ _ := Real.exp_le_exp.mpr (by
have hm := mul_le_mul_of_nonneg_right hc1 hF0
have ha0 := H.allowance_nonneg hr hG
linarith)
end CoordinateSweeps.Grid.Holes
namespace CoordinateSweeps
/-- Real exponential version of the exact conditional main estimate, used only
as the induction predicate; its equivalence to logMoment includes zero moments. -/
def MomentBound (G : Grid) (q : ℕ) (z : ℝ) : Prop :=
∀ (h : ℕ) (H : G.Holes h) (hf : H.Feasible) (σ : UnitaryIrrep H.stabilizer),
schattenMoment q (H.conditionalAverage hf z σ) ≤
Real.exp (-c G.size*Real.log σ.dimension+e G.size*h*Real.log G.size-H.cost)
noncomputable def cHat (s : ℕ) : ℝ := c s+1/(20*Real.sqrt (Real.log s))
noncomputable def eHat (s : ℕ) : ℝ := e s-1/(20*Real.sqrt (Real.log s))
end CoordinateSweeps
namespace CoordinateSweeps.Grid.Holes
open ScalarInduction YoungCorner
variable {A B : Grid} {r h q : ℕ} (H : (concat A B).Holes h)
theorem hook_auxiliary (hr : ScaleLarge r) (hA : A.Allowed r) (hB : B.Allowed r)
(hAB : A.b≤B.b) (hBA : B.b≤2*A.b) (hq : 1≤q)
(hS : MainSizeReady q (concat A B).size)
(z : ℝ) (hIA : MomentBound A q z) (hIB : MomentBound B q z)
(hf : H.Feasible) (σ : UnitaryIrrep H.stabilizer)
(p : ℕ) (hp : 0<p) (hpp : (p:ℝ)≤((concat A B).size:ℝ)^a)
(μ : 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 (-cHat (concat A B).size*Real.log σ.dimension+
eHat (concat A B).size*h*Real.log (concat A B).size-H.cost+
((concat A B).size:ℝ)^((9:ℝ)/10)) := by
let G := concat A B
let L := Real.log G.size
let cStar := c0+(11/10:ℝ)/Real.sqrt L
let eStar := e0-(11/10:ℝ)/Real.sqrt L
have hG : G.Allowed r := (concat_allowed A B r).mpr ⟨hA,hB⟩
have hL : 0<L := (scale_coefficients hr G hG).1
have hLA := (scale_coefficients hr A hA).1
have hLB := (scale_coefficients hr B hB).1
have hlogs := balanced_logs hA hB hAB hBA
have hcsA : cStar≤c A.size ∧ e A.size≤eStar := improved_coefficients hL hLA hlogs.2.1
have hcsB : cStar≤c B.size ∧ e B.size≤eStar := improved_coefficients hL hLB hlogs.2.2.2
have hc : 0≤cStar := by
dsimp [cStar]
have hc0 : 0≤c0 := by norm_num [c0,a]
positivity
have hc2 : cStar≤2*c0 := hcsA.1.trans (scale_coefficients hr A hA).2.1
have hcq : cStar≤q := hc2.trans ((by norm_num [c0,a] : 2*c0≤1).trans (by exact_mod_cast hq))
have hR : ∀ y : B.Slot, ∀ τ : UnitaryIrrep (H.rowHoles y).stabilizer,
schattenMoment q ((H.rowHoles y).conditionalAverage (H.rowHoles y).feasible_of_disjoint z τ) ≤
Real.exp (-cStar*Real.log τ.dimension+eStar*H.rowCount y*Real.log A.size-(H.rowHoles y).cost) := by
intro y τ
apply (hIA _ _ _ τ).trans (Real.exp_le_exp.mpr ?_)
have hF := Real.log_nonneg (show (1:ℝ)≤τ.dimension by exact_mod_cast τ.positive)
have hc' := mul_le_mul_of_nonneg_right hcsA.1 hF
have he' := mul_le_mul_of_nonneg_right hcsA.2
(show 0≤(H.rowCount y:ℝ)*Real.log A.size by positivity)
nlinarith
have hC : ∀ x : A.Slot, ∀ τ : UnitaryIrrep (H.columnHoles x).stabilizer,
schattenMoment q ((H.columnHoles x).conditionalAverage (H.columnHoles x).feasible_of_disjoint z τ) ≤
Real.exp (-cStar*Real.log τ.dimension+eStar*H.columnCount x*Real.log B.size-(H.columnHoles x).cost) := by
intro x τ
apply (hIB _ _ _ τ).trans (Real.exp_le_exp.mpr ?_)
have hF := Real.log_nonneg (show (1:ℝ)≤τ.dimension by exact_mod_cast τ.positive)
have hc' := mul_le_mul_of_nonneg_right hcsB.1 hF
have he' := mul_le_mul_of_nonneg_right hcsB.2
(show 0≤(H.columnCount x:ℝ)*Real.log B.size by positivity)
nlinarith
have hs1 : (1:ℝ)<G.size := (Real.log_pos_iff (by exact_mod_cast G.size_pos.le)).mp hL
have hpS : p≤G.size := by
have hx : (G.size:ℝ)^a≤G.size := by
simpa only [Real.rpow_one] using Real.rpow_le_rpow_of_exponent_le hs1.le (show a≤1 by norm_num [a])
exact_mod_cast hpp.trans hx
have hAS : A.size≤G.size := by dsimp [G]; rw [concat_size]; nlinarith [A.size_pos,B.size_pos]
have hBS : B.size≤G.size := by dsimp [G]; rw [concat_size]; nlinarith [A.size_pos,B.size_pos]
have ht := H.actual_hook_bound p hp hf z q (by omega) cStar eStar hc hcq G.size hpS hAS hBS σ hR hC μ eB hσ hhook
have hsizes := balanced_sizes hA hB hAB hBA
have hErr := hook_error_bound hs1 q A.size B.size p cStar hc hc2 hsizes.2.1 hsizes.2.2.2 hpp
have hroot : 2/e0≤Real.sqrt L := (Real.le_sqrt (by norm_num [e0,a]) hL.le).mpr
(hr.2.1.trans (G.log_size_lower_one hG))
have hgap := hook_strengthening hL hroot hc2
have hcompare := hook_comparison (F:=Real.log σ.dimension) (h:=(h:ℝ)) (E:=
(((2*q+1:ℕ):ℝ)*((A.size+B.size)*((2*p)*(2*p)):ℕ)+cStar*((A.size+B.size)*(41*p^2):ℕ))*Real.log (G.size+1:ℕ))
hL (Real.log_nonneg (by exact_mod_cast σ.positive)) (Nat.cast_nonneg _) hgap.1 hgap.2
have hlogsum : Real.log A.size+Real.log B.size=L := by
dsimp [L,G]
rw [concat_size,Nat.cast_mul,Real.log_mul (by exact_mod_cast A.size_pos.ne') (by exact_mod_cast B.size_pos.ne')]
rw [hlogsum] at ht
apply ht.trans (Real.exp_le_exp.mpr ?_)
have hES : _ ≤ (G.size:ℝ)^((9:ℝ)/10) := hErr.trans hS.hook
simp only [Nat.cast_add,Nat.cast_one,Nat.cast_mul] at hcompare hES ⊢
dsimp [cHat,eHat,c,e]
change _ ≤ -(c0+1/Real.sqrt L+1/(20*Real.sqrt L))*Real.log σ.dimension+
(e0-1/Real.sqrt L-1/(20*Real.sqrt L))*h*L-H.cost+(G.size:ℝ)^((9:ℝ)/10)
dsimp [cStar,eStar] at *
nlinarith
end CoordinateSweeps.Grid.Holes
namespace CoordinateSweeps.YoungCorner
lemma log_factorial_lower (k : ℕ) (hk : 0<k) :
(k:ℝ)*Real.log k-k ≤ Real.log (k.factorial:ℝ) := by
have hs := Stirling.le_log_factorial_stirling hk.ne'
have hk1 : (1:ℝ)≤k := by exact_mod_cast hk
have hl := Real.log_nonneg hk1
have hp : 0≤Real.log (2*Real.pi) := Real.log_nonneg (by linarith [Real.pi_gt_three])
linarith
lemma shape_finrank_pos (μ : YoungDiagram) :
0 < Module.finrank ℂ (shapeSubrep μ (Equiv.refl _)).toSubmodule := by
have : Nontrivial (shapeSubrep μ (Equiv.refl _)).toSubmodule :=
by
by_contra hn
have : Subsingleton (shapeSubrep μ (Equiv.refl _)).toSubmodule := not_nontrivial_iff_subsingleton.mp hn
apply bot_ne_top (α := Subrepresentation (shapeSubrep μ (Equiv.refl _)).toRepresentation)
exact Subrepresentation.toSubmodule_injective (Subsingleton.elim _ _)
exact Module.finrank_pos
/-- The translated removed diagram has the entropy required in the large-k
branch, using the checked factorial/rank-count lower bound. -/
lemma removed_dimension_entropy (μ : YoungDiagram) (p s : ℕ)
(hs : 0<s) (hM : Fintype.card (Boxes μ) ≤ s)
(hfloor : (s:ℝ)^a ≤ p+1) (hL : 800 ≤ Real.log s)
(hk : (s:ℝ)^(1-a/2) ≤ Fintype.card (Boxes (removedPart μ p))) :
(a/4)*(Fintype.card (Boxes (removedPart μ p)):ℝ)*Real.log s ≤
Real.log (Module.finrank ℂ (shapeSubrep (removedPart μ p) (Equiv.refl _)).toSubmodule) := by
let k := Fintype.card (Boxes (removedPart μ p))
let D := Module.finrank ℂ (shapeSubrep (removedPart μ p) (Equiv.refl _)).toSubmodule
let L := 2*(Fintype.card (Boxes μ)/(p+1))
have hs0 : (0:ℝ)<s := by exact_mod_cast hs
have hk0 : 0<k := by
have hh : (0:ℝ)<k := (Real.rpow_pos_of_pos hs0 _).trans_le hk
exact_mod_cast hh
have hD0 : 0<D := shape_finrank_pos _
have hLp : 0<L := by
obtain ⟨x⟩ := Fintype.card_pos_iff.mp hk0
exact Nat.zero_le (x.val.1+x.val.2) |>.trans_lt (removedPart_rank_lt μ p x)
have hL0 : (0:ℝ)<L := by exact_mod_cast hLp
have hc := shape_dimension_entropy (removedPart μ p)
(shapeSubrep (removedPart μ p) (Equiv.refl _)).toRepresentation
(shapeSubrep_hasShape _ _) L (removedPart_rank_lt μ p)
have hc' : (k.factorial:ℝ) ≤ (L:ℝ)^k*D := by exact_mod_cast hc
have hlog := Real.log_le_log (by exact_mod_cast Nat.factorial_pos k : (0:ℝ)<k.factorial) hc'
rw [Real.log_mul (by positivity : (L:ℝ)^k≠0) (by exact_mod_cast hD0.ne'),Real.log_pow] at hlog
have hfac := log_factorial_lower k hk0
have hLp' : (L:ℝ)*(p+1) ≤ 2*s := by
have hh := Nat.div_mul_le_self (Fintype.card (Boxes μ)) (p+1)
have hh' : (Fintype.card (Boxes μ)/(p+1))*(p+1) ≤ s := hh.trans hM
dsimp [L]
exact_mod_cast (show 2*(Fintype.card (Boxes μ)/(p+1))*(p+1)≤2*s by nlinarith [hh'])
have hLupper : (L:ℝ) ≤ 2*(s:ℝ)^(1-a) := by
have hh := mul_le_mul_of_nonneg_left hfloor hL0.le
have hhs : (L:ℝ)*(s:ℝ)^a ≤ 2*s := hh.trans hLp'
apply (mul_le_mul_iff_left₀ (Real.rpow_pos_of_pos hs0 a)).mp
calc
_ ≤ 2*(s:ℝ) := hhs
_ = 2*(s:ℝ)^(1-a)*(s:ℝ)^a := by rw [mul_assoc,←Real.rpow_add hs0]; norm_num
have hLogL : Real.log L ≤ Real.log 2+(1-a)*Real.log s := by
have hh := Real.log_le_log hL0 hLupper
rw [Real.log_mul (by norm_num : (2:ℝ)≠0) (Real.rpow_pos_of_pos hs0 _).ne',Real.log_rpow hs0] at hh
exact hh
have hLogk : (1-a/2)*Real.log s ≤ Real.log k := by
have hh := Real.log_le_log (Real.rpow_pos_of_pos hs0 (1-a/2)) hk
simpa only [Real.log_rpow hs0] using hh
have hl2 : Real.log 2≤1 := by
have hh := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<2)
linarith
have hkR : (0:ℝ)≤k := Nat.cast_nonneg _
have hh1 := mul_le_mul_of_nonneg_left hLogL hkR
have hh2 := mul_le_mul_of_nonneg_left hLogk hkR
have hh3 : (a/4)*Real.log s ≥ Real.log 2+1 := by norm_num [a] at *; linarith
have hh4 := mul_le_mul_of_nonneg_left hh3 hkR
change (a/4)*(k:ℝ)*Real.log s ≤ Real.log D
nlinarith
end CoordinateSweeps.YoungCorner
namespace CoordinateSweeps.Grid.Holes
open YoungCorner ScalarInduction
variable {G : Grid} {h : ℕ} (H : G.Holes h)
lemma exists_initial_shape (σ : UnitaryIrrep H.stabilizer) :
∃ (μ : YoungDiagram) (eB : H.FreeAt 0 ≃ Boxes μ),
hasShape μ (Equiv.refl _) (σ.pullback (H.boxesChart μ eB)).asRepresentation := by
let τ := (σ.pullback H.stabilizerFreeEquiv.symm).asRepresentation
obtain ⟨p,hp⟩ := exists_partitionShape τ
refine ⟨diagramOfPartition p,partitionFilling p,?_⟩
have hh : hasShape (V:=Fin σ.dimension → ℂ) (diagramOfPartition p)
((partitionFilling p).symm.trans (partitionFilling p))
(τ.comp (partitionFilling p).symm.permCongrHom) :=
(hasShape_reparam (diagramOfPartition p) (partitionFilling p).symm (partitionFilling p) τ).mpr hp
change hasShape (V:=Fin σ.dimension → ℂ) (diagramOfPartition p) (Equiv.refl _)
(τ.comp (partitionFilling p).symm.permCongrHom)
simpa only [Equiv.symm_trans_self] using hh
lemma augmented_boxesChart (μ : YoungDiagram) (p : ℕ) (eB : H.FreeAt 0 ≃ Boxes μ)
(x : H.Placement (k := Fintype.card (Boxes (removedPart μ p))))
(ω₀ : {ω : G.Choices // H.Compatible ω}) :
(H.augmented x ω₀).boxesChart (hookPart μ p) (H.augmentedRetainedEquiv μ p eB x ω₀).symm=
H.augmentedRetainedChart μ p eB x ω₀ := by
rfl
lemma retained_log_dimension (μ : YoungDiagram) (p : ℕ) (eB : H.FreeAt 0 ≃ Boxes μ)
(σ : UnitaryIrrep H.stabilizer)
(ρ : UnitaryIrrep (H.placementChart (H.removedPlacement μ p eB)).stabilizer)
(hd : σ.dimension≤(Fintype.card (Boxes μ))^(Fintype.card (Boxes (removedPart μ p)))*ρ.dimension) :
Real.log σ.dimension≤Real.log ρ.dimension+
Fintype.card (Boxes (removedPart μ p))*Real.log G.size := by
have hM : Fintype.card (Boxes μ)≤G.size := by
rw [←Fintype.card_congr eB,H.card_freeAt]
exact Nat.sub_le _ _
have hh := hd.trans (Nat.mul_le_mul_right _ (Nat.pow_le_pow_left hM _))
have hhR : (σ.dimension:ℝ)≤(G.size:ℝ)^(Fintype.card (Boxes (removedPart μ p)))*ρ.dimension := by exact_mod_cast hh
have hlog := Real.log_le_log (by exact_mod_cast σ.positive : (0:ℝ)<σ.dimension) hhR
have hs0 : (0:ℝ)<G.size := by exact_mod_cast G.size_pos
rw [Real.log_mul (by positivity : (G.size:ℝ)^(Fintype.card (Boxes (removedPart μ p)))≠0)
(by exact_mod_cast ρ.positive.ne'),Real.log_pow] at hlog
linarith
end CoordinateSweeps.Grid.Holes
namespace CoordinateSweeps.Grid.Holes
open YoungCorner ScalarInduction
variable {A B : Grid} {r h q : ℕ} (H : (concat A B).Holes h)
/-- Large-dimension branch of the exact main: actual retained constituent,
actual augmented paths, induced placement-cycle estimate, and absorbed entropy. -/
theorem conditional_large_main (hr : ScaleLarge r) (hA : A.Allowed r) (hB : B.Allowed r)
(hAB : A.b≤B.b) (hBA : B.b≤2*A.b) (hq : 1≤q)
(hS : MainSizeReady q (concat A B).size)
(z : ℝ) (hz : 0≤z) (hz' : z<1)
(hlo : ∀ j g, (1/2:ℝ)*FiniteLaw.uniform _ g≤lineLaw ((concat A B).bits j) z hz hz'.le g)
(hhi : ∀ j g, lineLaw ((concat A B).bits j) z hz hz'.le g≤2*FiniteLaw.uniform _ g)
(hIA : MomentBound A q z) (hIB : MomentBound B q z)
(hf : H.Feasible) (σ : UnitaryIrrep H.stabilizer)
(hF : ((concat A B).size:ℝ)^(1-a/4)≤Real.log σ.dimension) :
schattenMoment q (H.conditionalAverage hf z σ)≤
Real.exp (-c (concat A B).size*Real.log σ.dimension+
e (concat A B).size*h*Real.log (concat A B).size-H.cost) := by
let G := concat A B
let p := ⌊(G.size:ℝ)^a⌋₊
let L := Real.log G.size
obtain ⟨μ,eB,hσ⟩ := H.exists_initial_shape σ
obtain ⟨ρ,hρ,hm,hd⟩ := H.exists_retained_irrep μ p eB σ hσ
let k := Fintype.card (Boxes (removedPart μ p))
let D := Module.finrank ℂ (shapeSubrep (removedPart μ p) (Equiv.refl _)).toSubmodule
have hG : G.Allowed r := (concat_allowed A B r).mpr ⟨hA,hB⟩
have hcoeff := scale_coefficients hr G hG
have hL : 0<L := hcoeff.1
have hs : (1:ℝ)<G.size := (Real.log_pos_iff (by exact_mod_cast G.size_pos.le)).mp hL
have hs0 : (0:ℝ)<G.size := by exact_mod_cast G.size_pos
have hp : 0<p := by
change 1≤⌊(G.size:ℝ)^a⌋₊
apply (Nat.one_le_floor_iff _).mpr
exact Real.one_le_rpow hs.le (by norm_num [a])
have hpp : (p:ℝ)≤(G.size:ℝ)^a := Nat.floor_le (Real.rpow_nonneg hs0.le _)
have hfloor : (G.size:ℝ)^a≤p+1 := (Nat.lt_floor_add_one _).le
let budget := -cHat G.size*Real.log ρ.dimension+eHat G.size*(h+k)*L+(G.size:ℝ)^((9:ℝ)/10)
have hT : ∀ (x : H.Placement (k:=k)) (ω₀ : {ω : G.Choices // H.Compatible ω}),
schattenMoment q ((H.augmented x ω₀).conditionalAverage (H.augmented_feasible x ω₀) z
(H.augmentedIrrep (H.removedPlacement μ p eB) x ω₀ ρ))≤Real.exp (budget-(H.augmented x ω₀).cost) := by
intro x ω₀
have hsH := H.augmented_hasShape μ p eB ρ hρ x ω₀
rw [←H.augmented_boxesChart] at hsH
have hh := (H.augmented x ω₀).hook_auxiliary hr hA hB hAB hBA hq hS z hIA hIB
(H.augmented_feasible x ω₀) (H.augmentedIrrep (H.removedPlacement μ p eB) x ω₀ ρ)
p hp hpp (hookPart μ p) (H.augmentedRetainedEquiv μ p eB x ω₀).symm hsH (hookPart_property μ p)
apply hh.trans_eq
congr 1
change -cHat (concat A B).size*Real.log ρ.dimension+
eHat (concat A B).size*((h+k:ℕ):ℝ)*Real.log (concat A B).size-
(H.augmented x ω₀).cost+((concat A B).size:ℝ)^((9:ℝ)/10)=budget-(H.augmented x ω₀).cost
dsimp [budget,L,k,G]
push_cast
ring
have hind := H.actual_induced_endgame hf (H.removedPlacement μ p eB) ρ σ hz hz' hlo hhi q (by omega) budget hT
have hMoment0 := H.conditionalMoment_nonneg hf z σ q
have hD0 : 0<D := shape_finrank_pos _
have hD0R : (0:ℝ)<D := by exact_mod_cast hD0
have hDT : (D:ℝ)*schattenMoment q (H.conditionalAverage hf z σ)≤Real.exp (budget-H.cost+Real.log 4*k*G.b) :=
(mul_le_mul_of_nonneg_right (by exact_mod_cast hm) hMoment0).trans hind
have ht : schattenMoment q (H.conditionalAverage hf z σ)≤
Real.exp (budget-H.cost+Real.log 4*k*G.b-Real.log D) := by
rw [Real.exp_sub,Real.exp_log hD0R]
exact (le_div_iff₀ hD0R).mpr (by simpa only [mul_comm] using hDT)
have hD := H.retained_log_dimension μ p eB σ ρ hd
have hM : Fintype.card (Boxes μ)≤G.size := by
rw [←Fintype.card_congr eB,H.card_freeAt]
exact Nat.sub_le _ _
have h800 : 800≤Real.log G.size := by
have hh := hr.2.1.trans (G.log_size_lower_one hG)
norm_num [e0,a] at hh
linarith
have hEnt : (G.size:ℝ)^(1-a/2)≤k → (a/4)*(k:ℝ)*L≤Real.log D := by
intro hh
exact removed_dimension_entropy μ p G.size G.size_pos hM hfloor h800 hh
have hcost := removed_cost_bound hs (Nat.cast_nonneg k) (Nat.cast_nonneg G.b) hcoeff.2.2.2 hF
(Real.log_nonneg (by exact_mod_cast hD0 : (1:ℝ)≤D)) hS hEnt
have hscalar := removed_endgame L (Real.log σ.dimension) (Real.log ρ.dimension) (Real.log D)
k h G.b H.cost G.size ((G.size:ℝ)^((9:ℝ)/10)) hL
(Real.log_nonneg (by exact_mod_cast σ.positive)) (Nat.cast_nonneg _) (Nat.cast_nonneg _) hD
(Real.sqrt_pos.mpr hL) hcost
apply ht.trans (Real.exp_le_exp.mpr ?_)
simpa only [budget,cHat,eHat,c,e,L] using hscalar
end CoordinateSweeps.Grid.Holes
namespace CoordinateSweeps
open Filter
lemma eventually_scaleLarge : ∀ᶠ r : ℕ in atTop, ScaleLarge r := by
obtain ⟨r₀,hr₀⟩ := exists_scaleLarge
filter_upwards [eventually_ge_atTop r₀] with r hr
have hh : (r₀:ℝ)*Real.log 2 ≤ (r:ℝ)*Real.log 2 :=
mul_le_mul_of_nonneg_right (by exact_mod_cast hr) (Real.log_nonneg (by norm_num))
exact ⟨hr₀.1.trans hr,hr₀.2.1.trans hh,hr₀.2.2.trans hh⟩
lemma exists_main_scale : ∃ r : ℕ, ScaleLarge r ∧ SparseScalar.ScaleReady r ∧
∀ G : Grid, G.Allowed r → ScalarInduction.MainSizeReady SparseScalar.q G.size := by
obtain ⟨S,hS⟩ := eventually_atTop.mp (ScalarInduction.eventually_mainSizeReady SparseScalar.q)
have hp : Tendsto (fun r : ℕ => (2:ℝ)^r) atTop atTop :=
tendsto_pow_atTop_atTop_of_one_lt (by norm_num)
have hall : ∀ᶠ r : ℕ in atTop, ScaleLarge r ∧ SparseScalar.ScaleReady r ∧ S≤(2:ℝ)^r := by
filter_upwards [eventually_scaleLarge,SparseScalar.eventually_scaleReady,
hp.eventually (eventually_ge_atTop S)] with r h1 h2 h3
exact ⟨h1,h2,h3⟩
obtain ⟨r,hr,hs,ht⟩ := hall.exists
exact ⟨r,hr,hs,fun G hG => hS G.size (ht.trans (G.pow_r_le_size hG))⟩
/-- Strong induction on the literal ordered coordinate count; every child is
an actual conditioned row/column grid, not a surrogate representation law. -/
theorem all_grid_moment {r : ℕ} (hr : ScaleLarge r) (hrS : SparseScalar.ScaleReady r)
(hS : ∀ G : Grid, G.Allowed r → ScalarInduction.MainSizeReady SparseScalar.q G.size)
{zStar : ℝ} (hζ : SparsePerturb r zStar) {z : ℝ} (hz : z∈Set.Icc 0 zStar) :
∀ G : Grid, G.Allowed r → MomentBound G SparseScalar.q z := by
have hzB : z≤baseZeta r := hz.2.trans hζ.2.1
have hz1 : z<1 := lt_of_le_of_lt (hzB.trans (baseZeta_le_half r)) (by norm_num)
have hq : 1≤SparseScalar.q := by norm_num [SparseScalar.q]
have aux : ∀ n : ℕ, ∀ G : Grid, G.b=n → G.Allowed r → MomentBound G SparseScalar.q z := by
intro n
induction n using Nat.strong_induction_on with
| h n ih =>
intro G hb hG h H hf σ
have hnonneg := H.conditionalMoment_nonneg hf z σ SparseScalar.q
by_cases hone : G.b=1
· exact moment_le_exp_of_logMoment_le hnonneg
(Grid.conditional_main_b_one hr G hone hG H hf hz.1 hzB σ hq)
by_cases hdim : σ.dimension=1
· exact moment_le_exp_of_logMoment_le hnonneg
(H.conditional_dimension_one hr hG hf hz.1 hz1 σ hdim SparseScalar.q)
by_cases haut : (1+c G.size)*Real.log σ.dimension ≤ e G.size*h*Real.log G.size-H.cost
· exact moment_le_exp_of_logMoment_le hnonneg
(H.conditional_automatic hf hz.1 hz1 σ SparseScalar.q haut)
by_cases hF : Real.log σ.dimension < (G.size:ℝ)^(1-a/4)
· exact H.conditional_sparse_main hr hrS hG (hS G hG) hf hζ hz σ hdim haut hF
have hlarge : (G.size:ℝ)^(1-a/4)≤Real.log σ.dimension := le_of_not_gt hF
have hb2 : 2≤G.b := by have hh:=G.positive; omega
obtain ⟨A,B,hAB,hA,hB,hab,hba⟩ := G.exists_half_concat hb2
have hallowed : A.Allowed r ∧ B.Allowed r :=
(Grid.concat_allowed A B r).mp (by simpa only [hAB] using hG)
have hIA : MomentBound A SparseScalar.q z := ih A.b (by omega) A rfl hallowed.1
have hIB : MomentBound B SparseScalar.q z := ih B.b (by omega) B rfl hallowed.2
subst G
exact H.conditional_large_main hr hallowed.1 hallowed.2 hab hba hq
(hS _ hG) z hz.1 hz1
(fun j g => (lineLaw_base_bounds (hG j).2 hz.1 hzB g).1)
(fun j g => (lineLaw_base_bounds (hG j).2 hz.1 hzB g).2)
hIA hIB hf σ hlarge
exact fun G hG => aux G.b G rfl hG
/-- Manuscript03 thm:conditional / ac:main, with c₀=e₀=a/100,
a=1/100, natural logarithms, unnormalized integer Schatten moments,
all feasible disjoint paths (including none and all), and log(0)=−∞. -/
theorem conditional_main : ConditionalMain := by
obtain ⟨r,hr,hrS,hS⟩ := exists_main_scale
obtain ⟨zStar,hζ⟩ := exists_sparsePerturb r
have hq : 1≤SparseScalar.q := by norm_num [SparseScalar.q]
refine ⟨r,SparseScalar.q,zStar,hr.1,hq,hζ.1,hζ.2.1.trans (baseZeta_le_half r),?_⟩
intro G hG h H hf z hz σ
exact logMoment_le_of_moment_le_exp (H.conditionalMoment_nonneg hf z σ SparseScalar.q)
(all_grid_moment hr hrS hS hζ hz G hG h H hf σ)
end CoordinateSweeps
end OAI