lean/OAI/Probability/CoordinateSweeps/Main.lean

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