lean/OAI/Probability/CoordinateSweeps/Attachment.lean

import Mathlib
import OAI.Probability.CoordinateSweeps.PlacementMoment
import OAI.RepresentationTheory.Young.Restriction
import OAI.Probability.CoordinateSweeps.Induction

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 Set Complex
open scoped BigOperators Topology
open scoped Matrix.Norms.L2Operator
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
namespace CoordinateSweeps.Grid.Holes
open YoungCorner PlacementInduction UnitaryIrrep
variable {G : Grid} {h : ℕ} (H : G.Holes h) (μ : YoungDiagram) (p : ℕ)
    (e : H.FreeAt 0 ≃ Boxes μ)
def removedPlacement : H.Placement (k := Fintype.card (Boxes (removedPart μ p))) where
  toFun i := e.symm (boxesSplit μ p (Sum.inr ((Fintype.equivFin _).symm i)))
  inj' := by
    intro i j hij
    have h₁ := e.symm.injective hij
    have h₂ := (boxesSplit μ p).injective h₁
    exact (Fintype.equivFin _).symm.injective (Sum.inr.inj h₂)
def retainedMap : Equiv.Perm (Boxes (hookPart μ p)) →* H.stabilizer :=
  H.stabilizerFreeEquiv.symm.toMonoidHom.comp
    (e.symm.permCongrHom.toMonoidHom.comp (leftPerm (boxesSplit μ p)))
lemma retainedMap_fixed (g : Equiv.Perm (Boxes (hookPart μ p))) :
    H.placementAction (H.retainedMap μ p e g) (H.removedPlacement μ p e)=H.removedPlacement μ p e := by
  apply Function.Embedding.ext
  intro i
  change H.stabilizerFreeEquiv (H.stabilizerFreeEquiv.symm
    (e.symm.permCongrHom (leftPerm (boxesSplit μ p) g)))
    (e.symm (boxesSplit μ p (Sum.inr ((Fintype.equivFin _).symm i))))=_
  rw [MulEquiv.apply_symm_apply]
  simp [leftPerm,removedPlacement]
  rfl
def retainedInto : Equiv.Perm (Boxes (hookPart μ p)) →*
    (H.placementChart (H.removedPlacement μ p e)).stabilizer where
  toFun g := ⟨H.retainedMap μ p e g,H.retainedMap_fixed μ p e g⟩
  map_one' := by apply Subtype.ext; exact map_one (H.retainedMap μ p e)
  map_mul' g g' := by apply Subtype.ext; exact map_mul (H.retainedMap μ p e) g g'
lemma retainedInto_bijective : Function.Bijective (H.retainedInto μ p e) := by
  constructor
  · intro g g' hh
    have heq := congrArg (fun t => e.permCongrHom (H.stabilizerFreeEquiv t.val)) hh
    change e.permCongrHom (H.stabilizerFreeEquiv (H.stabilizerFreeEquiv.symm
      (e.symm.permCongrHom (leftPerm (boxesSplit μ p) g))))=
      e.permCongrHom (H.stabilizerFreeEquiv (H.stabilizerFreeEquiv.symm
      (e.symm.permCongrHom (leftPerm (boxesSplit μ p) g')))) at heq
    simp only [MulEquiv.apply_symm_apply] at heq
    have hleft : leftPerm (boxesSplit μ p) g=leftPerm (boxesSplit μ p) g' := by simpa using heq
    apply Equiv.ext
    intro x
    have hx := congrArg (fun t : Equiv.Perm (Boxes μ) => (boxesSplit μ p).symm (t (boxesSplit μ p (Sum.inl x)))) hleft
    simpa [leftPerm] using hx
  · intro g
    have hfix : ∀ z : Boxes (removedPart μ p),
        e.permCongrHom (H.stabilizerFreeEquiv g.val) (boxesSplit μ p (Sum.inr z))=boxesSplit μ p (Sum.inr z) := by
      intro z
      have hh := congrArg (fun u : H.Placement (k := Fintype.card (Boxes (removedPart μ p))) => e (u ((Fintype.equivFin _) z))) g.property
      change e ((H.stabilizerFreeEquiv g.val) (e.symm (boxesSplit μ p (Sum.inr ((Fintype.equivFin _).symm ((Fintype.equivFin _) z))))))=e (e.symm (boxesSplit μ p (Sum.inr ((Fintype.equivFin _).symm ((Fintype.equivFin _) z))))) at hh
      change e ((H.stabilizerFreeEquiv g.val) (e.symm (boxesSplit μ p (Sum.inr z))))=_
      simpa only [Equiv.symm_apply_apply,Equiv.apply_symm_apply] using hh
    obtain ⟨a,ha⟩ := leftPerm_range_of_fix_right (boxesSplit μ p)
      (e.permCongrHom (H.stabilizerFreeEquiv g.val)) hfix
    refine ⟨a,?_⟩
    apply Subtype.ext
    apply H.stabilizerFreeEquiv.injective
    change H.stabilizerFreeEquiv (H.stabilizerFreeEquiv.symm
      (e.symm.permCongrHom (leftPerm (boxesSplit μ p) a)))=H.stabilizerFreeEquiv g.val
    rw [MulEquiv.apply_symm_apply,ha]
    apply Equiv.ext
    intro y
    simp
/- Actual retained-hook subgroup chart inside the original hole stabilizer. -/
def retainedEquiv : Equiv.Perm (Boxes (hookPart μ p)) ≃*
    (H.placementChart (H.removedPlacement μ p e)).stabilizer :=
  MulEquiv.ofBijective (H.retainedInto μ p e) (H.retainedInto_bijective μ p e)
end CoordinateSweeps.Grid.Holes

namespace CoordinateSweeps.UnitaryIrrep
variable {Γ Λ : Type*} [Group Γ] [Group Λ]
lemma asRepresentation_pullback (ρ : UnitaryIrrep Γ) (e : Λ ≃* Γ) :
    (ρ.pullback e).asRepresentation=ρ.asRepresentation.comp e.toMonoidHom := rfl
lemma dimension_eq_finrank (ρ : UnitaryIrrep Γ) :
    Module.finrank ℂ (Fin ρ.dimension → ℂ)=ρ.dimension := by simp
end CoordinateSweeps.UnitaryIrrep

namespace CoordinateSweeps.Grid.Holes
open YoungCorner PlacementInduction UnitaryIrrep
variable {G : Grid} {h : ℕ} (H : G.Holes h) (μ : YoungDiagram) (p : ℕ)
    (e : H.FreeAt 0 ≃ Boxes μ)
def boxesChart : Equiv.Perm (Boxes μ) ≃* H.stabilizer :=
  e.symm.permCongrHom.trans H.stabilizerFreeEquiv.symm

lemma retained_restrict (τ : UnitaryIrrep H.stabilizer) :
    (matrixRepresentation (τ.matrix.comp (H.placementChart (H.removedPlacement μ p e)).stabilizer.subtype)).comp
        (H.retainedEquiv μ p e).toMonoidHom=
      (τ.pullback (H.boxesChart μ e)).asRepresentation.comp (leftPerm (boxesSplit μ p)) := rfl

/- Source06:eq22 and genuine retained-hook Hom multiplicity simultaneously,
on the literal placement stabilizer used by the conditional induced cycle. -/
theorem exists_retained_irrep (τ : UnitaryIrrep H.stabilizer)
    (hτ : hasShape μ (Equiv.refl _) (τ.pullback (H.boxesChart μ e)).asRepresentation) :
    ∃ ρ : UnitaryIrrep (H.placementChart (H.removedPlacement μ p e)).stabilizer,
      hasShape (hookPart μ p) (Equiv.refl _)
        (ρ.asRepresentation.comp (H.retainedEquiv μ p e).toMonoidHom) ∧
      Module.finrank ℂ (shapeSubrep (removedPart μ p) (Equiv.refl _)).toSubmodule ≤
        Module.finrank ℂ (ρ.asRepresentation.IntertwiningMap
          (matrixRepresentation (τ.matrix.comp (H.placementChart (H.removedPlacement μ p e)).stabilizer.subtype))) ∧
      τ.dimension ≤ (Fintype.card (Boxes μ))^(Fintype.card (Boxes (removedPart μ p)))*ρ.dimension := by
  let τB := (τ.pullback (H.boxesChart μ e)).asRepresentation
  let δ := (shapeSubrep (removedPart μ p) (Equiv.refl _)).toRepresentation
  obtain ⟨S,hSi,hSh,hm⟩ := hook_removed_multiplicity μ p τB hτ δ (shapeSubrep_hasShape _ _)
  let : S.toRepresentation.IsIrreducible := hSi
  obtain ⟨σ,⟨eS⟩⟩ := UnitaryRealization.exists_unitary S.toRepresentation
  have hSdim : Module.finrank ℂ S.toSubmodule=σ.dimension := by
    have hh := eS.toLinearEquiv.finrank_eq
    simpa using hh
  have hS : S ≠ ⊥ := by
    intro hh
    rw [hh] at hSdim
    have hz : Module.finrank ℂ (⊥ : Submodule ℂ (Fin τ.dimension → ℂ))=0 := by simp
    have he : σ.dimension=0 := hSdim.symm.trans hz
    exact σ.positive.ne' he
  let ρ := σ.pullback (H.retainedEquiv μ p e).symm
  have hρ : ρ.asRepresentation.comp (H.retainedEquiv μ p e).toMonoidHom=σ.asRepresentation := by
    apply MonoidHom.ext
    intro g
    apply LinearMap.ext
    intro v
    change σ.asRepresentation ((H.retainedEquiv μ p e).symm (H.retainedEquiv μ p e g)) v=σ.asRepresentation g v
    rw [MulEquiv.symm_apply_apply]
  refine ⟨ρ,?_,?_,?_⟩
  · rw [hρ]
    exact hasShape_equiv _ _ _ _ eS hSh
  · have hsource := (Representation.IntertwiningMap.sourceEquiv eS
        (τB.comp (leftPerm (boxesSplit μ p)))).finrank_eq
    have hreparam := (Representation.IntertwiningMap.reparamEquiv ρ.asRepresentation
      (matrixRepresentation (τ.matrix.comp (H.placementChart (H.removedPlacement μ p e)).stabilizer.subtype))
        (H.retainedEquiv μ p e)).finrank_eq
    rw [hρ,H.retained_restrict μ p e τ] at hreparam
    exact hm.trans_eq (hsource.trans hreparam.symm)
  · have hh := hook_dimension_upper μ p τB S hS
    rw [hSdim] at hh
    change Module.finrank ℂ (Fin τ.dimension → ℂ) ≤ _ at hh
    rw [Module.finrank_fintype_fun_eq_card, Fintype.card_fin] at hh
    exact hh
end CoordinateSweeps.Grid.Holes

namespace CoordinateSweeps.Grid.Holes
open YoungCorner PlacementInduction UnitaryIrrep
variable {G : Grid} {h : ℕ} (H : G.Holes h) (μ : YoungDiagram) (p : ℕ)
    (e : H.FreeAt 0 ≃ Boxes μ)
def retainedSite : Boxes (hookPart μ p) ↪ H.FreeAt 0 where
  toFun a := e.symm (boxesSplit μ p (Sum.inl a))
  inj' := by intro a b hh; exact Sum.inl.inj ((boxesSplit μ p).injective (e.symm.injective hh))
lemma retainedSite_ne_removed (a : Boxes (hookPart μ p))
    (i : Fin (Fintype.card (Boxes (removedPart μ p)))) :
    H.retainedSite μ p e a ≠ H.removedPlacement μ p e i := by
  intro hh
  have he := (boxesSplit μ p).injective (e.symm.injective hh)
  cases he
lemma retainedMap_site (g : Equiv.Perm (Boxes (hookPart μ p))) (a : Boxes (hookPart μ p)) :
    H.stabilizerFreeEquiv (H.retainedMap μ p e g) (H.retainedSite μ p e a)=H.retainedSite μ p e (g a) := by
  change H.stabilizerFreeEquiv (H.stabilizerFreeEquiv.symm
    (e.symm.permCongrHom (leftPerm (boxesSplit μ p) g))) (e.symm (boxesSplit μ p (Sum.inl a)))=_
  rw [MulEquiv.apply_symm_apply]
  simp [leftPerm,retainedSite]
  rfl

def augmentedRetainedEmbedding
    (x : H.Placement (k := Fintype.card (Boxes (removedPart μ p))))
    (ω₀ : {ω : G.Choices // H.Compatible ω}) :
    Boxes (hookPart μ p) ↪ (H.augmented x ω₀).FreeAt 0 where
  toFun a := ⟨(H.stabilizerFreeEquiv ((H.placementChart (H.removedPlacement μ p e)).rep x)
    (H.retainedSite μ p e a)).val,by
    intro i
    cases i using Fin.addCases with
    | left i =>
      simpa only [augmented,augment_old] using
        (H.stabilizerFreeEquiv ((H.placementChart (H.removedPlacement μ p e)).rep x)
          (H.retainedSite μ p e a)).property i
    | right i =>
      simp only [augmented,augment_new,Grid.pathBetween_zero]
      intro he
      have hr := congrArg (fun y : H.Placement (k := Fintype.card (Boxes (removedPart μ p))) => (y i).val)
        ((H.placementChart (H.removedPlacement μ p e)).reaches x)
      change ((H.placementChart (H.removedPlacement μ p e)).rep x).val
        ((H.removedPlacement μ p e i).val)=(x i).val at hr
      have hh := ((H.placementChart (H.removedPlacement μ p e)).rep x).val.injective (he.trans hr.symm)
      exact H.retainedSite_ne_removed μ p e a i (Subtype.ext hh)⟩
  inj' := by
    intro a b hh
    have he := congrArg Subtype.val hh
    exact (H.retainedSite μ p e).injective
      ((H.stabilizerFreeEquiv ((H.placementChart (H.removedPlacement μ p e)).rep x)).injective (Subtype.ext he))

lemma augmentedRetainedEmbedding_surjective
    (x : H.Placement (k := Fintype.card (Boxes (removedPart μ p))))
    (ω₀ : {ω : G.Choices // H.Compatible ω}) :
    Function.Surjective (H.augmentedRetainedEmbedding μ p e x ω₀) := by
  have hc : Fintype.card (Boxes (hookPart μ p))=Fintype.card ((H.augmented x ω₀).FreeAt 0) := by
    have hsplit := split_card μ p
    have he := Fintype.card_congr e
    rw [H.card_freeAt] at he
    rw [(H.augmented x ω₀).card_freeAt]
    omega
  by_contra hn
  have hh := Fintype.card_lt_of_injective_not_surjective _
    (H.augmentedRetainedEmbedding μ p e x ω₀).injective hn
  omega

def augmentedRetainedEquiv
    (x : H.Placement (k := Fintype.card (Boxes (removedPart μ p))))
    (ω₀ : {ω : G.Choices // H.Compatible ω}) :
    Boxes (hookPart μ p) ≃ (H.augmented x ω₀).FreeAt 0 :=
  Equiv.ofBijective (H.augmentedRetainedEmbedding μ p e x ω₀)
    ⟨(H.augmentedRetainedEmbedding μ p e x ω₀).injective,
      H.augmentedRetainedEmbedding_surjective μ p e x ω₀⟩
end CoordinateSweeps.Grid.Holes

namespace CoordinateSweeps.Grid.Holes
open YoungCorner PlacementInduction UnitaryIrrep
variable {G : Grid} {h : ℕ} (H : G.Holes h) (μ : YoungDiagram) (p : ℕ)
    (e : H.FreeAt 0 ≃ Boxes μ)
def augmentedRetainedChart
    (x : H.Placement (k := Fintype.card (Boxes (removedPart μ p))))
    (ω₀ : {ω : G.Choices // H.Compatible ω}) :
    Equiv.Perm (Boxes (hookPart μ p)) ≃* (H.augmented x ω₀).stabilizer :=
  (H.augmentedRetainedEquiv μ p e x ω₀).permCongrHom.trans (H.augmented x ω₀).stabilizerFreeEquiv.symm
lemma augmentedRetainedChart_eq
    (x : H.Placement (k := Fintype.card (Boxes (removedPart μ p))))
    (ω₀ : {ω : G.Choices // H.Compatible ω}) (g : Equiv.Perm (Boxes (hookPart μ p))) :
    H.augmentedRetainedChart μ p e x ω₀ g=
      H.augmentFixEquiv (H.removedPlacement μ p e) x (fun i => G.sweep ω₀.val (x i).val)
        ω₀.val ω₀.property (fun _ => rfl)
        ((H.placementChart (H.removedPlacement μ p e)).pointEquiv x (H.retainedEquiv μ p e g)) := by
  apply (H.augmented x ω₀).stabilizerFreeEquiv.injective
  change (H.augmented x ω₀).stabilizerFreeEquiv
    ((H.augmented x ω₀).stabilizerFreeEquiv.symm ((H.augmentedRetainedEquiv μ p e x ω₀).permCongrHom g))=_
  rw [MulEquiv.apply_symm_apply]
  apply Equiv.ext
  intro y
  obtain ⟨a,rfl⟩ := (H.augmentedRetainedEquiv μ p e x ω₀).surjective y
  apply Subtype.ext
  change ((H.augmentedRetainedEquiv μ p e x ω₀)
    (g ((H.augmentedRetainedEquiv μ p e x ω₀).symm ((H.augmentedRetainedEquiv μ p e x ω₀) a)))).val=_
  rw [Equiv.symm_apply_apply]
  change ((H.placementChart (H.removedPlacement μ p e)).rep x).val ((H.retainedSite μ p e (g a)).val)=
    (((H.placementChart (H.removedPlacement μ p e)).rep x).val *
      (H.retainedMap μ p e g).val * (((H.placementChart (H.removedPlacement μ p e)).rep x).val)⁻¹)
      (((H.placementChart (H.removedPlacement μ p e)).rep x).val ((H.retainedSite μ p e a).val))
  simp only [Equiv.Perm.mul_apply,Equiv.Perm.inv_def,Equiv.symm_apply_apply]
  have hh := congrArg Subtype.val (H.retainedMap_site μ p e g a)
  change (H.retainedMap μ p e g).val ((H.retainedSite μ p e a).val)=(H.retainedSite μ p e (g a)).val at hh
  rw [hh]

/- The transported fiber is the same retained Young type on the *actual*
remaining sites. This rules out any unsupported abstract symmetric-group relabeling. -/
theorem augmented_hasShape
    (ρ : UnitaryIrrep (H.placementChart (H.removedPlacement μ p e)).stabilizer)
    (hρ : hasShape (hookPart μ p) (Equiv.refl _)
      (ρ.asRepresentation.comp (H.retainedEquiv μ p e).toMonoidHom))
    (x : H.Placement (k := Fintype.card (Boxes (removedPart μ p))))
    (ω₀ : {ω : G.Choices // H.Compatible ω}) :
    hasShape (hookPart μ p) (Equiv.refl _)
      ((H.augmentedIrrep (H.removedPlacement μ p e) x ω₀ ρ).pullback
        (H.augmentedRetainedChart μ p e x ω₀)).asRepresentation := by
  have he : ((H.augmentedIrrep (H.removedPlacement μ p e) x ω₀ ρ).pullback
        (H.augmentedRetainedChart μ p e x ω₀)).asRepresentation=
      ρ.asRepresentation.comp (H.retainedEquiv μ p e).toMonoidHom := by
    apply MonoidHom.ext
    intro g
    change Matrix.toLinAlgEquiv' ((H.augmentedIrrep (H.removedPlacement μ p e) x ω₀ ρ).matrix
      (H.augmentedRetainedChart μ p e x ω₀ g))=Matrix.toLinAlgEquiv' (ρ.matrix (H.retainedEquiv μ p e g))
    rw [H.augmentedRetainedChart_eq]
    change Matrix.toLinAlgEquiv' (ρ.matrix
      (((H.placementChart (H.removedPlacement μ p e)).pointEquiv x).symm
        ((H.augmentFixEquiv (H.removedPlacement μ p e) x (fun i => G.sweep ω₀.val (x i).val)
          ω₀.val ω₀.property (fun _ => rfl)).symm
          ((H.augmentFixEquiv (H.removedPlacement μ p e) x (fun i => G.sweep ω₀.val (x i).val)
            ω₀.val ω₀.property (fun _ => rfl))
            ((H.placementChart (H.removedPlacement μ p e)).pointEquiv x (H.retainedEquiv μ p e g))))))=_
    simp only [MulEquiv.symm_apply_apply]
  rw [he]
  exact hρ
end CoordinateSweeps.Grid.Holes
end
end
end
end
end
end

/-!
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

/-! New work: the actual alternating placement kernel from 04-sparse:eq7.
The preceding definitions/proofs are reused verbatim from the pinned support.
Endpoints below need not be injections; invalid specifications have probability
zero automatically. On valid endpoint placements this is exactly the source Q. -/

noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable

/- Reused exact conditional transition/potential support from pinned root-02. -/

namespace CoordinateSweeps.Grid.Holes
variable {G : Grid} {h k : ℕ}

theorem extraProbability_nonneg (H : G.Holes h) (x y : Fin k → G.Slot)
    (A : Finset (Fin k)) (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) :
    0 ≤ H.extraProbability x y A μ := by
  apply Finset.prod_nonneg
  intro j _
  apply Finset.prod_nonneg
  intro L _
  apply div_nonneg <;> apply Finset.sum_nonneg <;> intro σ _ <;>
    split_ifs <;> first | exact (μ j).nonneg σ | exact le_rfl

/- Faithful finite-event application of the transition comparison: the selected
extra paths are appended to the holes only when their joint event is possible. -/
theorem scaled_extraProbability_le (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (A : Finset (Fin k)) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1)
    (hlo : ∀ j g, (1/2 : ℝ)*FiniteLaw.uniform _ g ≤ lineLaw (G.bits j) z hz hz' g)
    (hhi : ∀ j g, lineLaw (G.bits j) z hz hz' g ≤ 2*FiniteLaw.uniform _ g) :
    (G.size : ℝ)^A.card * H.extraProbability x y A (fun j => lineLaw (G.bits j) z hz hz') ≤
      Real.exp ((G.b : ℝ)*(h+k) + Real.log 4*k*G.b) := by
  classical
  rw [H.extraProbability_eq_conditionalEndpoint]
  by_cases he : ∃ ω, H.Compatible ω ∧ G.endpointEvent x y A ω
  · obtain ⟨ω,hω,he⟩ := he
    let u := fun i => x (selected A i)
    let v := fun i => y (selected A i)
    have hv : ∀ i, G.sweep ω (u i) = v i := (endpointEvent_iff_selected x y A ω).mp he
    let J := H.augment u v (H.validInput_selected x hx A) ω hω hv
    have heq : H.conditionalEndpointProbability x y A (fun j => lineLaw (G.bits j) z hz hz') =
        J.probability z / H.probability z := by
      unfold conditionalEndpointProbability
      rw [H.lineMass_hole_normalizer hz hz']
      congr 1
      rw [← J.lineMass_hole_normalizer hz hz']
      apply Finset.sum_congr rfl
      intro ν _
      have hj : J.Compatible ν ↔ H.Compatible ν ∧ G.endpointEvent x y A ν := by
        dsimp [J]
        rw [H.augment_compatible_iff, endpointEvent_iff_selected]
      simp only [hj]
    rw [heq]
    have ht := J.conditional_transition_bound H
      (H.augment_extends u v (H.validInput_selected x hx A) ω hω hv) hz hz' hlo hhi
    have hs : (0 : ℝ) < G.size := by
      unfold Grid.size
      positivity
    have hpow : (G.size : ℝ)^A.card = Real.exp ((A.card : ℝ)*Real.log G.size) := by
      rw [Real.exp_nat_mul, Real.exp_log hs]
    calc
      _ ≤ (G.size : ℝ)^A.card *
          Real.exp (-(A.card : ℝ)*Real.log G.size + J.cost-H.cost +
            Real.log 4*(A.card : ℝ)*G.b) := mul_le_mul_of_nonneg_left ht (by positivity)
      _ = Real.exp (J.cost-H.cost + Real.log 4*(A.card : ℝ)*G.b) := by
        rw [hpow, ← Real.exp_add]
        congr 1; ring
      _ ≤ _ := by
        apply Real.exp_le_exp.mpr
        have hAk : (A.card : ℝ) ≤ k := by exact_mod_cast (show A.card ≤ k by simpa using Finset.card_le_univ A)
        have hc := J.cost_le
        have hn := H.cost_nonneg
        have hb : (0 : ℝ) ≤ G.b := by positivity
        have hl : 0 ≤ Real.log (4 : ℝ) := Real.log_nonneg (by norm_num)
        have hbk := mul_le_mul_of_nonneg_left hAk hb
        have hlk := mul_le_mul_of_nonneg_right
          (mul_le_mul_of_nonneg_left hAk hl) hb
        push_cast at hc
        nlinarith
  · have hn : ∀ ω, ¬ (H.Compatible ω ∧ G.endpointEvent x y A ω) := by
      simpa only [not_exists] using he
    simp only [conditionalEndpointProbability, ite_eq_right (hn _), Finset.sum_const_zero,
      zero_div, mul_zero]
    exact (Real.exp_pos _).le

/- Source 04:eq8, with an explicit absolute constant in place of O(·).
Only valid input placements are needed; impossible output events contribute zero. -/
theorem scaled_placementKernel_abs_le (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1)
    (hlo : ∀ j g, (1/2 : ℝ)*FiniteLaw.uniform _ g ≤ lineLaw (G.bits j) z hz hz' g)
    (hhi : ∀ j g, lineLaw (G.bits j) z hz hz' g ≤ 2*FiniteLaw.uniform _ g) :
    |(G.size : ℝ)^k * H.placementKernel x y (fun j => lineLaw (G.bits j) z hz hz')| ≤
      (2 : ℝ)^k * Real.exp ((G.b : ℝ)*(h+k) + Real.log 4*k*G.b) := by
  classical
  have hs : (G.size : ℝ) ≠ 0 := by
    unfold Grid.size
    positivity
  rw [placementKernel, ← mul_assoc, ← mul_pow, mul_inv_cancel₀ hs, one_pow, one_mul]
  calc
    _ ≤ ∑ A ∈ (Finset.univ : Finset (Fin k)).powerset,
        |(-1 : ℝ)^(k-A.card) * (G.size : ℝ)^A.card *
          H.extraProbability x y A (fun j => lineLaw (G.bits j) z hz hz')| :=
      Finset.abs_sum_le_sum_abs _ _
    _ = ∑ A ∈ (Finset.univ : Finset (Fin k)).powerset,
        (G.size : ℝ)^A.card * H.extraProbability x y A (fun j => lineLaw (G.bits j) z hz hz') := by
      apply Finset.sum_congr rfl
      intro A _
      rw [abs_mul, abs_mul, abs_pow, abs_neg, abs_one, one_pow, one_mul,
        abs_of_nonneg (by positivity : 0 ≤ (G.size : ℝ)^A.card),
        abs_of_nonneg (H.extraProbability_nonneg _ _ _ _)]
    _ ≤ ∑ A ∈ (Finset.univ : Finset (Fin k)).powerset,
        Real.exp ((G.b : ℝ)*(h+k) + Real.log 4*k*G.b) := by
      apply Finset.sum_le_sum
      intro A _
      exact H.scaled_extraProbability_le x y hx A hz hz' hlo hhi
    _ = _ := by simp

end CoordinateSweeps.Grid.Holes

namespace CoordinateSweeps.Grid.Holes
variable {G : Grid} {h k : ℕ}

def ValidOutput (H : G.Holes h) (y : Fin k → G.Slot) : Prop :=
  Function.Injective y ∧ ∀ i a, y i ≠ H.path a (Fin.last G.b)

/- Counting-measure Hilbert--Schmidt square on the actual free placements. -/
def placementHSsq (H : G.Holes h)
    (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) : ℝ :=
  ∑ x : Fin k → G.Slot, ∑ y : Fin k → G.Slot,
    if H.ValidInput x ∧ H.ValidOutput y then (H.placementKernel x y μ)^2 else 0

/- The full endpoint product weight is exactly s^(-2k). -/
theorem endpoint_productMass (p : Fin k → G.Slot × G.Slot) :
    Coverage.productMass G.endpointWeight p = (G.size : ℝ)⁻¹^(2*k) := by
  simp [Coverage.productMass, Grid.endpointWeight, FiniteLaw.uniform,
    Fintype.card_prod, G.card_slot, mul_pow, pow_mul, mul_comm, pow_two]

/- Rewriting the counting norm using independent full-grid endpoints never
conditions the auxiliary trajectories on being valid placements. -/
theorem placementHSsq_eq_full (H : G.Holes h)
    (μ : ∀ j, FiniteLaw (Equiv.Perm (Cube (G.bits j)))) :
    H.placementHSsq (k := k) μ =
      ∑ p : Fin k → G.Slot × G.Slot,
        Coverage.productMass G.endpointWeight p *
          if H.ValidInput (fun i => (p i).1) ∧ H.ValidOutput (fun i => (p i).2) then
            ((G.size : ℝ)^k * H.placementKernel (fun i => (p i).1) (fun i => (p i).2) μ)^2
          else 0 := by
  classical
  have hs : (G.size : ℝ) ≠ 0 := by unfold Grid.size; positivity
  have hterm (p : Fin k → G.Slot × G.Slot) :
      (if H.ValidInput (fun i => (p i).1) ∧ H.ValidOutput (fun i => (p i).2) then
          (H.placementKernel (fun i => (p i).1) (fun i => (p i).2) μ)^2 else 0) =
        Coverage.productMass G.endpointWeight p *
          if H.ValidInput (fun i => (p i).1) ∧ H.ValidOutput (fun i => (p i).2) then
            ((G.size : ℝ)^k * H.placementKernel (fun i => (p i).1) (fun i => (p i).2) μ)^2
          else 0 := by
    rw [endpoint_productMass]
    split_ifs
    · have hid : (G.size : ℝ)⁻¹^(2*k) * ((G.size : ℝ)^k)^2 = 1 := by
        rw [← pow_mul, Nat.mul_comm k 2, ← mul_pow, inv_mul_cancel₀ hs, one_pow]
      rw [mul_pow, ← mul_assoc, hid, one_mul]
    · simp
  let e : (Fin k → G.Slot × G.Slot) ≃ ((Fin k → G.Slot) × (Fin k → G.Slot)) :=
    ⟨fun p => (fun i => (p i).1, fun i => (p i).2),
      fun p i => (p.1 i, p.2 i), fun _ => rfl, fun _ => rfl⟩
  calc
    _ = ∑ p : (Fin k → G.Slot) × (Fin k → G.Slot),
        if H.ValidInput p.1 ∧ H.ValidOutput p.2 then (H.placementKernel p.1 p.2 μ)^2 else 0 := by
      rw [Fintype.sum_prod_type]; rfl
    _ = ∑ p : Fin k → G.Slot × G.Slot,
        if H.ValidInput (fun i => (p i).1) ∧ H.ValidOutput (fun i => (p i).2) then
          (H.placementKernel (fun i => (p i).1) (fun i => (p i).2) μ)^2 else 0 :=
      (Equiv.sum_comp e (fun p =>
        if H.ValidInput p.1 ∧ H.ValidOutput p.2 then (H.placementKernel p.1 p.2 μ)^2 else 0)).symm
    _ = _ := Finset.sum_congr rfl (fun p _ => hterm p)

/- Source 04:eqs8--9 combined, with an explicit counting HS estimate.
This is the direct, unweakened many-coordinate sparse-kernel estimate. -/
theorem placementHSsq_le (H : G.Holes h) (hH : H.Feasible)
    {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1)
    (hlo : ∀ j g, (1/2 : ℝ)*FiniteLaw.uniform _ g ≤ lineLaw (G.bits j) z hz hz' g)
    (hhi : ∀ j g, lineLaw (G.bits j) z hz hz' g ≤ 2*FiniteLaw.uniform _ g)
    (hsmall : ((k+h : ℕ) : ℝ)*G.lineSharingRate ≤ 1) :
    H.placementHSsq (k := k) (fun j => lineLaw (G.bits j) z hz hz') ≤
      ((2 : ℝ)^k * Real.exp ((G.b : ℝ)*(h+k) + Real.log 4*k*G.b))^2 *
        ((2 : ℝ)^k * (((k+h : ℕ) : ℝ)*G.lineSharingRate)^((k : ℝ)/2)) := by
  classical
  let μ := fun j => lineLaw (G.bits j) z hz hz'
  let M := (2 : ℝ)^k * Real.exp ((G.b : ℝ)*(h+k) + Real.log 4*k*G.b)
  have hM : 0 ≤ M := by positivity
  rw [H.placementHSsq_eq_full]
  calc
    _ ≤ ∑ p : Fin k → G.Slot × G.Slot,
        Coverage.productMass G.endpointWeight p *
          if H.placementKernel (fun i => (p i).1) (fun i => (p i).2) μ ≠ 0 then M^2 else 0 := by
      apply Finset.sum_le_sum
      intro p _
      apply mul_le_mul_of_nonneg_left _
        (Coverage.productMass_nonneg G.endpointWeight G.endpointWeight_nonneg p)
      by_cases he : H.placementKernel (fun i => (p i).1) (fun i => (p i).2) μ = 0
      · simp only [μ] at he
        simp [μ, he]
      · rw [ite_eq_left he]
        split_ifs with hp
        · have h := H.scaled_placementKernel_abs_le (fun i => (p i).1) (fun i => (p i).2) hp.1 hz hz' hlo hhi
          have hh := (sq_le_sq₀ (abs_nonneg _) hM).mpr h
          simpa only [sq_abs] using hh
        · positivity
    _ = M^2 * Coverage.probability G.endpointWeight (fun p : Fin k → G.Slot × G.Slot =>
        H.placementKernel (fun i => (p i).1) (fun i => (p i).2) μ ≠ 0) := by
      rw [Coverage.probability, Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro p _
      split_ifs <;> ring
    _ ≤ _ := mul_le_mul_of_nonneg_left
      (H.probability_nonzero_placementKernel_le hH z hz hz' hsmall) (sq_nonneg M)

end CoordinateSweeps.Grid.Holes

/- Necessary shared-line polynomial expansion for the sparse conditional main.
A variable names a LINE, not a particle. The tensor moment functional is merely
linear, never multiplicative when two factors use the same line. -/
end
end
open scoped Matrix.Norms.L2Operator

end OAI