import Mathlib
import OAI.Probability.CoordinateSweeps.Attachment
import OAI.Probability.Moments.LineExpansion

namespace OAI

noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators
open MvPolynomial
noncomputable section
open MeasureTheory ProbabilityTheory Real Set Filter
open scoped ENNReal NNReal BigOperators
namespace CoordinateSweeps.Grid.Holes
open MomentExpansion
variable {G : Grid} {h k : ℕ}

def auxCount (x y : Fin k → G.Slot) (A : Finset (Fin k)) (j : Fin G.b) (L : G.Line j) : ℕ :=
  (A.filter (fun i => G.pathLine (x i) (y i) j = L)).card

theorem auxCount_sum (x y : Fin k → G.Slot) (A : Finset (Fin k)) (j : Fin G.b) :
    ∑ L : G.Line j, auxCount x y A j L = A.card := by
  unfold auxCount
  simp only [Finset.card_eq_sum_ones, Finset.sum_filter]
  rw [Finset.sum_comm]
  simp

theorem selected_sum {R : Type*} [AddCommMonoid R]
    (A : Finset (Fin k)) (f : Fin k → R) :
    (∑ i : Fin A.card, f (selected A i)) = ∑ a ∈ A, f a := by
  change (∑ i : Fin A.card, (fun a : A => f a.val)
    ((Fintype.equivFinOfCardEq (Fintype.card_coe A)).symm i)) = _
  calc
    _ = ∑ a : A, f a.val := by
      exact Equiv.sum_comp (Fintype.equivFinOfCardEq (Fintype.card_coe A)).symm (fun a : A => f a.val)
    _ = _ := Finset.sum_coe_sort A f

theorem augment_selected_extraCount (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (A : Finset (Fin k)) (ω : G.Choices) (hω : H.Compatible ω)
    (he : G.endpointEvent x y A ω) (j : Fin G.b) (L : G.Line j) :
    (H.augment (fun i => x (selected A i)) (fun i => y (selected A i))
      (H.validInput_selected x hx A) ω hω ((endpointEvent_iff_selected x y A ω).mp he)).extraCount j L =
      auxCount x y A j L := by
  unfold extraCount auxCount
  simp only [Finset.card_eq_sum_ones, Finset.sum_filter, OnLine, augment_new]
  change (∑ i : Fin A.card, if G.pathLine (x (selected A i)) (y (selected A i)) j = L then 1 else 0) = _
  exact selected_sum (R := ℕ) A (fun i => if G.pathLine (x i) (y i) j = L then 1 else 0)

theorem size_pow_eq_aux_product (x y : Fin k → G.Slot) (A : Finset (Fin k)) :
    (G.size : ℝ)^A.card =
      ∏ j, ∏ L : G.Line j, ((2^G.bits j : ℕ) : ℝ)^auxCount x y A j L := by
  simp only [Finset.prod_pow_eq_pow_sum, auxCount_sum]
  rw [Finset.prod_pow]
  congr 1
  simp [Grid.size]

/- Very same endpoint feasibility event as the conditioned finite sample space. -/
def EndpointPossible (H : G.Holes h) (x y : Fin k → G.Slot) (A : Finset (Fin k)) : Prop :=
  ∃ ω, H.Compatible ω ∧ G.endpointEvent x y A ω

theorem descFactorial_add_split (n a b : ℕ) :
    n.descFactorial (a+b) = n.descFactorial a * (n-a).descFactorial b := by
  induction b with
  | zero => simp
  | succ b ih =>
    rw [Nat.add_succ, Nat.descFactorial_succ, ih, Nat.descFactorial_succ,
      Nat.sub_sub]
    ring

/- Uniform scaled entries have exactly the falling-factorial moments that enter
the shared-line gamma expansion, zero for impossible simultaneous paths. -/
theorem scaled_extraProbability_uniform (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (A : Finset (Fin k)) :
    (G.size : ℝ)^A.card * H.extraProbability x y A (fun _ => FiniteLaw.uniform _) =
      if H.EndpointPossible x y A then
        ∏ j, ∏ L : G.Line j, fallingMoment (2^G.bits j) (H.lineCount j L) (auxCount x y A j L)
      else 0 := by
  classical
  rw [H.extraProbability_eq_conditionalEndpoint]
  by_cases he : H.EndpointPossible x y A
  · rw [ite_eq_left he]
    obtain ⟨ω,hω,he⟩ := he
    let J := H.augment (fun i => x (selected A i)) (fun i => y (selected A i))
      (H.validInput_selected x hx A) ω hω ((endpointEvent_iff_selected x y A ω).mp he)
    have hext : J.Extends H := H.augment_extends _ _ _ _ _ _
    have hcount (j : Fin G.b) (L : G.Line j) :
        J.lineCount j L = H.lineCount j L + auxCount x y A j L := by
      rw [J.lineCount_add H hext]
      exact congrArg (H.lineCount j L + ·) (H.augment_selected_extraCount x y hx A ω hω he j L)
    have hprob : H.conditionalEndpointProbability x y A (fun _ => FiniteLaw.uniform _) =
        J.probability 0 / H.probability 0 := by
      have hu : (fun j : Fin G.b => lineLaw (G.bits j) 0 (le_refl 0) zero_le_one) =
          (fun _ => FiniteLaw.uniform _) := by
        funext j
        ext σ
        simp [lineLaw, FiniteLaw.mix, FiniteLaw.uniform]
      rw [← hu]
      unfold conditionalEndpointProbability
      rw [H.lineMass_hole_normalizer, ← J.lineMass_hole_normalizer (le_refl 0) zero_le_one]
      congr 1
      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 [hprob, J.probability_zero, H.probability_zero, size_pow_eq_aux_product x y A,
      ← Finset.prod_div_distrib]
    simp only [← Finset.prod_div_distrib, ← Finset.prod_mul_distrib]
    apply Finset.prod_congr rfl
    intro j _
    apply Finset.prod_congr rfl
    intro L _
    rw [hcount, descFactorial_add_split]
    have hfa : ((2^G.bits j).descFactorial (H.lineCount j L) : ℝ) ≠ 0 := by
      exact_mod_cast (Nat.descFactorial_pos.mpr (H.lineCount_le j L)).ne'
    have hsub : auxCount x y A j L ≤ 2^G.bits j-H.lineCount j L := by
      have hj := J.lineCount_le j L
      rw [hcount] at hj
      omega
    have hfb : ((2^G.bits j-H.lineCount j L).descFactorial (auxCount x y A j L) : ℝ) ≠ 0 := by
      exact_mod_cast (Nat.descFactorial_pos.mpr hsub).ne'
    unfold fallingMoment
    push_cast
    field_simp
  · rw [ite_eq_right he]
    have hn : ∀ ω, ¬ (H.Compatible ω ∧ G.endpointEvent x y A ω) := by
      simpa only [EndpointPossible, not_exists] using he
    simp [conditionalEndpointProbability, hn]

end CoordinateSweeps.Grid.Holes

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

/- Geometric validity at EVERY boundary, not only at endpoints. -/
def JointDisjoint (H : G.Holes h) (x y : Fin k → G.Slot) (A : Finset (Fin k)) : Prop :=
  (∀ i ∈ A, ∀ a s, G.pathBetween (x i) (y i) s ≠ H.path a s) ∧
  (∀ i ∈ A, ∀ j ∈ A, i ≠ j → ∀ s,
    G.pathBetween (x i) (y i) s ≠ G.pathBetween (x j) (y j) s)

/- Build the augmented hole family directly from disjoint geometry. -/
def adjoin (H : G.Holes h) (x y : Fin k → G.Slot) (A : Finset (Fin k))
    (hv : H.JointDisjoint x y A) : G.Holes (h+A.card) where
  path i s := Fin.append (fun a => H.path a s)
    (fun a => G.pathBetween (x (selected A a)) (y (selected A a)) s) i
  disjoint s := by
    apply Fin.append_injective_iff.mpr
    refine ⟨H.disjoint s, ?_, ?_⟩
    · intro a b he
      apply (selected A).injective
      by_contra hab
      exact hv.2 (selected A a) (selected_mem A a) (selected A b) (selected_mem A b) hab s he
    · intro a b he
      exact hv.1 (selected A b) (selected_mem A b) a s he.symm
  coordinate_step i j l hlj := by
    cases i using Fin.addCases with
    | left a => simpa using H.coordinate_step a j l hlj
    | right a => simpa using G.pathBetween_step (x (selected A a)) (y (selected A a)) j l hlj

@[simp] theorem adjoin_old (H : G.Holes h) (x y : Fin k → G.Slot) (A : Finset (Fin k))
    (hv : H.JointDisjoint x y A) (a : Fin h) (s : Fin (G.b+1)) :
    (H.adjoin x y A hv).path (Fin.castAdd A.card a) s = H.path a s := by simp [adjoin]

@[simp] theorem adjoin_new (H : G.Holes h) (x y : Fin k → G.Slot) (A : Finset (Fin k))
    (hv : H.JointDisjoint x y A) (a : Fin A.card) (s : Fin (G.b+1)) :
    (H.adjoin x y A hv).path (Fin.natAdd h a) s =
      G.pathBetween (x (selected A a)) (y (selected A a)) s := by simp [adjoin]

/- Every geometrically specified hole family already has a positive uniform
normalizer, whose proved factorial formula yields a real completion witness. -/
theorem feasible_of_disjoint_paths (H : G.Holes h) : H.Feasible := by
  by_contra hn
  have hz : H.probability 0 = 0 := by
    unfold probability
    exact Finset.sum_eq_zero (fun ω _ => (hn ⟨ω.val,ω.property⟩).elim)
  have hp := H.probability_zero_pos
  rw [hz] at hp
  exact lt_irrefl 0 hp

theorem adjoin_compatible_iff (H : G.Holes h) (x y : Fin k → G.Slot) (A : Finset (Fin k))
    (hv : H.JointDisjoint x y A) (ω : G.Choices) :
    (H.adjoin x y A hv).Compatible ω ↔ H.Compatible ω ∧ G.endpointEvent x y A ω := by
  rw [endpointEvent_iff_selected]
  constructor
  · intro hJ
    constructor
    · intro a s
      simpa only [adjoin_old] using hJ (Fin.castAdd A.card a) s
    · intro a
      simpa only [adjoin_new, Grid.pathBetween_zero, Grid.pathBetween_last,
        Grid.sweep, Fin.val_last] using hJ (Fin.natAdd h a) (Fin.last G.b)
  · rintro ⟨hω,he⟩
    intro i s
    cases i using Fin.addCases with
    | left a => simpa only [adjoin_old] using hω a s
    | right a =>
      simp only [adjoin_new, Grid.pathBetween_zero]
      rw [G.boundary_eq_pathBetween, he a]

/- Exact event feasibility equals disjointness of the unique full trajectories. -/
theorem endpointPossible_iff_jointDisjoint (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (A : Finset (Fin k)) :
    H.EndpointPossible x y A ↔ H.JointDisjoint x y A := by
  constructor
  · rintro ⟨ω,hω,he⟩
    have hb (i : Fin k) (hi : i ∈ A) (s : Fin (G.b+1)) :
        G.boundary ω s (x i) = G.pathBetween (x i) (y i) s := by
      rw [G.boundary_eq_pathBetween, he i hi]
    constructor
    · intro i hi a s hf
      exact hx.2 i a ((G.boundary ω s).injective ((hb i hi s).trans (hf.trans (hω a s).symm)))
    · intro i hi j hj hij s hf
      exact hij (hx.1 ((G.boundary ω s).injective ((hb i hi s).trans (hf.trans (hb j hj s).symm))))
  · intro hv
    obtain ⟨ω,hω⟩ := (H.adjoin x y A hv).feasible_of_disjoint_paths
    exact ⟨ω,(H.adjoin_compatible_iff x y A hv ω).mp hω⟩

/- Precisely the vertex-isolation condition in the source's definition of good. -/
def VertexIsolated (H : G.Holes h) (x y : Fin k → G.Slot) (i : Fin k) : Prop :=
  (∀ a s, G.pathBetween (x i) (y i) s ≠ H.path a s) ∧
  (∀ j, i ≠ j → ∀ s, G.pathBetween (x i) (y i) s ≠ G.pathBetween (x j) (y j) s)

theorem jointDisjoint_mono (H : G.Holes h) (x y : Fin k → G.Slot)
    {A B : Finset (Fin k)} (hAB : A ⊆ B) (hB : H.JointDisjoint x y B) :
    H.JointDisjoint x y A :=
  ⟨fun i hi => hB.1 i (hAB hi), fun i hi j hj => hB.2 i (hAB hi) j (hAB hj)⟩

theorem jointDisjoint_union_iff (H : G.Holes h) (x y : Fin k → G.Slot)
    (A S : Finset (Fin k)) (hS : ∀ i ∈ S, H.VertexIsolated x y i) :
    H.JointDisjoint x y (A∪S) ↔ H.JointDisjoint x y A := by
  constructor
  · exact H.jointDisjoint_mono x y Finset.subset_union_left
  · intro hA
    constructor
    · intro i hi a s
      rcases Finset.mem_union.mp hi with hi | hi
      · exact hA.1 i hi a s
      · exact (hS i hi).1 a s
    · intro i hi j hj hij s
      rcases Finset.mem_union.mp hi with hi | hi
      · rcases Finset.mem_union.mp hj with hj | hj
        · exact hA.2 i hi j hj hij s
        · exact Ne.symm ((hS j hj).2 i hij.symm s)
      · exact (hS i hi).2 j hij s

/- Adding any subset of good paths CANNOT change validity, as needed before
alternation is taken inside the shared-line expectation. -/
theorem endpointPossible_union_iff (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (A S : Finset (Fin k))
    (hS : ∀ i ∈ S, H.VertexIsolated x y i) :
    H.EndpointPossible x y (A∪S) ↔ H.EndpointPossible x y A := by
  rw [H.endpointPossible_iff_jointDisjoint x y hx, H.endpointPossible_iff_jointDisjoint x y hx]
  exact H.jointDisjoint_union_iff x y A S hS

end CoordinateSweeps.Grid.Holes

namespace CoordinateSweeps.Grid
/- A line is named by both its stage and its remaining coordinates. -/
abbrev StageLine (G : Grid) := Σ j : Fin G.b, G.Line j

def stagePath (G : Grid) {k : ℕ} (x y : Fin k → G.Slot) (i : Fin k) (j : Fin G.b) : G.StageLine :=
  ⟨j, G.pathLine (x i) (y i) j⟩

namespace Holes
open MomentExpansion
variable {G : Grid} {h k : ℕ}

theorem incidenceCount_stagePath (x y : Fin k → G.Slot) (A : Finset (Fin k))
    (j : Fin G.b) (L : G.Line j) :
    incidenceCount A (G.stagePath x y) ⟨j,L⟩ = auxCount x y A j L := by
  unfold incidenceCount auxCount
  simp only [Finset.card_eq_sum_ones, Finset.sum_filter]
  apply Finset.sum_congr rfl
  intro i hi
  rw [Finset.sum_eq_single j]
  · simp [stagePath]
  · intro a ha haj
    have hn : G.stagePath x y i a ≠ ⟨j,L⟩ := fun he => haj (congrArg Sigma.fst he)
    simp [hn]
  · simp

theorem incidenceCount_stagePath_any (x y : Fin k → G.Slot) (A : Finset (Fin k))
    (l : G.StageLine) :
    incidenceCount A (G.stagePath x y) l = auxCount x y A l.1 l.2 := by
  cases l with
  | mk j L => exact incidenceCount_stagePath x y A j L

theorem incidenceCount_total (x y : Fin k → G.Slot) (A : Finset (Fin k)) :
    ∑ l : G.StageLine, incidenceCount A (G.stagePath x y) l = G.b*A.card := by
  rw [Fintype.sum_sigma]
  simp only [incidenceCount_stagePath, auxCount_sum, Finset.sum_const, Finset.card_univ,
    Fintype.card_fin, smul_eq_mul]

def Light (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ) (l : G.StageLine) : Prop :=
  ((H.lineCount l.1 l.2 + auxCount x y Finset.univ l.1 l.2 : ℕ) : ℝ) ≤
    (2^G.bits l.1 : ℕ)*η

def Good (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ) (i : Fin k) : Prop :=
  H.VertexIsolated x y i ∧ ∀ j, H.Light x y η (G.stagePath x y i j)

noncomputable def goodSet (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ) : Finset (Fin k) :=
  Finset.univ.filter (H.Good x y η)

@[simp] theorem mem_goodSet (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ) (i : Fin k) :
    i ∈ H.goodSet x y η ↔ H.Good x y η i := by simp [goodSet]

def lightMoment (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ) (l : G.StageLine) (n : ℕ) : ℝ :=
  if H.Light x y η l then fallingMoment (2^G.bits l.1) (H.lineCount l.1 l.2) n else 1

@[simp] theorem lightMoment_zero (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ) (l : G.StageLine) :
    H.lightMoment x y η l 0 = 1 := by simp [lightMoment, fallingMoment_zero]

theorem incidenceCount_good_nonlight (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ)
    (l : G.StageLine) (hl : ¬ H.Light x y η l) {A : Finset (Fin k)}
    (hA : A ⊆ H.goodSet x y η) : incidenceCount A (G.stagePath x y) l = 0 := by
  apply Finset.sum_eq_zero
  intro i hi
  apply Finset.sum_eq_zero
  intro j _
  have hn : G.stagePath x y i j ≠ l := by
    intro he
    exact hl (he ▸ ((H.mem_goodSet x y η i).mp (hA hi)).2 j)
  simp [hn]

theorem incidenceCount_mono (x y : Fin k → G.Slot) {A B : Finset (Fin k)}
    (hAB : A ⊆ B) (l : G.StageLine) :
    incidenceCount A (G.stagePath x y) l ≤ incidenceCount B (G.stagePath x y) l :=
  Finset.sum_le_sum_of_subset_of_nonneg hAB (fun _ _ _ => Nat.zero_le _)

theorem incidenceCount_union (x y : Fin k → G.Slot) {A B : Finset (Fin k)}
    (hAB : Disjoint A B) (l : G.StageLine) :
    incidenceCount (A∪B) (G.stagePath x y) l =
      incidenceCount A (G.stagePath x y) l + incidenceCount B (G.stagePath x y) l :=
  Finset.sum_union hAB

/- The actual shared-line moment bound: inactive (non-light) line variables
are set to 1, not made independent per particle. -/
theorem goodExpansion_lightMoment_le (H : G.Holes h) (x y : Fin k → G.Slot)
    {η : ℝ} (hη : 0 ≤ η) (hηsmall : η ≤ 1/8) (J : Finset (Fin k))
    (hJ : Disjoint J (H.goodSet x y η)) :
    |shiftedMoment (H.lightMoment x y η) (incidenceCount J (G.stagePath x y))
      (goodExpansion (H.goodSet x y η) (G.stagePath x y))| ≤
      (16 * Real.exp 2)^(G.b*J.card) * (1+16 * Real.exp 2)^(G.b*(H.goodSet x y η).card) *
        η^(((H.goodSet x y η).card : ℝ)/2) := by
  have hC : (1 : ℝ) ≤ 16*Real.exp 2 := by
    have := Real.one_le_exp (by norm_num : (0 : ℝ) ≤ 2)
    linarith
  have he := goodExpansion_moment_le (H.lightMoment x y η)
    (H.lightMoment_zero x y η) (incidenceCount J (G.stagePath x y))
    (H.goodSet x y η) (G.stagePath x y) (16*Real.exp 2) (Real.sqrt η)
    (by positivity) (Real.sqrt_nonneg η) (by
      apply (Real.sqrt_le_left (by norm_num : (0 : ℝ) ≤ 1)).mpr
      linarith) (by
      intro l u hu
      by_cases hl : H.Light x y η l
      · have hline : ∀ n, H.lightMoment x y η l n =
            fallingMoment (2^G.bits l.1) (H.lineCount l.1 l.2) n := by
          intro n; simp [lightMoment, hl]
        simp only [lineCenteredMoment, hline]
        apply fallingCenteredMoment_abs_le (fun l : G.StageLine => 2^G.bits l.1)
          (fun l => H.lineCount l.1 l.2) l (by positivity) _ u hη hηsmall
        apply le_trans _ hl
        have htotal := incidenceCount_mono x y (Finset.subset_univ
          (J ∪ H.goodSet x y η)) l
        rw [incidenceCount_union x y hJ l] at htotal
        simp only [incidenceCount_stagePath_any] at htotal
        change u ≤ incidenceCount (H.goodSet x y η) (G.stagePath x y) l at hu
        rw [incidenceCount_stagePath_any] at hu
        exact_mod_cast (show H.lineCount l.1 l.2 + u + incidenceCount J (G.stagePath x y) l ≤
            H.lineCount l.1 l.2 + auxCount x y Finset.univ l.1 l.2 by
          rw [incidenceCount_stagePath_any]
          omega)
      · have hzero := H.incidenceCount_good_nonlight x y η l hl (Finset.Subset.refl _)
        have hu0 : u = 0 := by change u ≤ incidenceCount _ _ l at hu; omega
        subst u
        simpa [lineCenteredMoment, lightMoment, hl] using
          (one_le_pow₀ hC : (1 : ℝ) ≤ (16*Real.exp 2)^incidenceCount J (G.stagePath x y) l))
  have hs : (Real.sqrt η)^(H.goodSet x y η).card = η^(((H.goodSet x y η).card : ℝ)/2) := by
    rw [Real.sqrt_eq_rpow, ← Real.rpow_natCast, ← Real.rpow_mul hη]
    congr 1; ring
  simpa only [incidenceCount_total, Fintype.card_fin, hs] using he

end Holes
end CoordinateSweeps.Grid

namespace CoordinateSweeps.MomentExpansion

theorem fallingMoment_one_le {m h n : ℕ} (hn : h+n ≤ m) : 1 ≤ fallingMoment m h n := by
  have hd : (0 : ℝ) < (m-h).descFactorial n := by
    exact_mod_cast Nat.descFactorial_pos.mpr (by omega : n ≤ m-h)
  unfold fallingMoment
  apply (le_div_iff₀ hd).mpr
  rw [one_mul]
  exact_mod_cast (Nat.descFactorial_le_pow (m-h) n).trans
    (Nat.pow_le_pow_left (Nat.sub_le m h) n)

end CoordinateSweeps.MomentExpansion

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

theorem endpointPossible_lineCount_le (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (A : Finset (Fin k)) (hA : H.EndpointPossible x y A)
    (l : G.StageLine) : H.lineCount l.1 l.2 + incidenceCount A (G.stagePath x y) l ≤ 2^G.bits l.1 := by
  obtain ⟨ω,hω,he⟩ := hA
  let J := H.augment (fun i => x (selected A i)) (fun i => y (selected A i))
    (H.validInput_selected x hx A) ω hω ((endpointEvent_iff_selected x y A ω).mp he)
  have hext : J.Extends H := H.augment_extends _ _ _ _ _ _
  have hc := J.lineCount_le l.1 l.2
  rw [J.lineCount_add H hext,
    H.augment_selected_extraCount x y hx A ω hω he l.1 l.2] at hc
  simpa only [incidenceCount_stagePath_any] using hc

/- Product outside the light-line expectation; zero validity is handled
separately, never by interpreting a divergent inverse-gamma moment. -/
def nonlightFactor (H : G.Holes h) (x y : Fin k → G.Slot) (η : ℝ) (J : Finset (Fin k)) : ℝ :=
  ∏ l : G.StageLine, if H.Light x y η l then 1 else
    fallingMoment (2^G.bits l.1) (H.lineCount l.1 l.2) (incidenceCount J (G.stagePath x y) l)

theorem nonlightFactor_nonneg (H : G.Holes h) (x y : Fin k → G.Slot)
    (η : ℝ) (J : Finset (Fin k)) : 0 ≤ H.nonlightFactor x y η J := by
  apply Finset.prod_nonneg
  intro l _
  split_ifs
  · norm_num
  · unfold fallingMoment; positivity

theorem nonlightFactor_le (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (η : ℝ) (J : Finset (Fin k)) (hJ : H.EndpointPossible x y J) :
    H.nonlightFactor x y η J ≤ Real.exp ((G.b : ℝ)*(h+k)+Real.log 4*k*G.b) := by
  have hu (j : Fin G.b) : lineLaw (G.bits j) 0 (le_refl 0) zero_le_one = FiniteLaw.uniform _ := by
    ext σ
    simp [lineLaw, FiniteLaw.mix, FiniteLaw.uniform]
  have he := H.scaled_extraProbability_le x y hx J (le_refl 0) zero_le_one
    (by intro j σ; rw [hu]; have := (FiniteLaw.uniform _).nonneg σ; linarith)
    (by intro j σ; rw [hu]; have := (FiniteLaw.uniform _).nonneg σ; linarith)
  simp_rw [hu] at he
  rw [H.scaled_extraProbability_uniform x y hx J, ite_eq_left hJ] at he
  apply le_trans _ he
  rw [← Fintype.prod_sigma (fun l : G.StageLine =>
    fallingMoment (2^G.bits l.1) (H.lineCount l.1 l.2) (auxCount x y J l.1 l.2))]
  unfold nonlightFactor
  apply Finset.prod_le_prod₀
  · intro l _
    split_ifs
    · norm_num
    · unfold fallingMoment; positivity
  · intro l _
    split_ifs
    · apply fallingMoment_one_le
      simpa only [incidenceCount_stagePath_any] using H.endpointPossible_lineCount_le x y hx J hJ l
    · rw [incidenceCount_stagePath_any]

/- Exact factorization for adding any collection of good paths. -/
theorem scaled_extraProbability_good_union (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (η : ℝ) (J S : Finset (Fin k))
    (hJ : Disjoint J (H.goodSet x y η)) (hS : S ⊆ H.goodSet x y η) :
    (G.size : ℝ)^(J∪S).card * H.extraProbability x y (J∪S) (fun _ => FiniteLaw.uniform _) =
      (if H.EndpointPossible x y J then H.nonlightFactor x y η J else 0) *
        ∏ l : G.StageLine, H.lightMoment x y η l
          (incidenceCount J (G.stagePath x y) l+incidenceCount S (G.stagePath x y) l) := by
  rw [H.scaled_extraProbability_uniform x y hx (J∪S)]
  have hv := H.endpointPossible_union_iff x y hx J S (fun i hi =>
    ((H.mem_goodSet x y η i).mp (hS hi)).1)
  rw [hv]
  split_ifs with hp
  · rw [← Fintype.prod_sigma (fun l : G.StageLine =>
        fallingMoment (2^G.bits l.1) (H.lineCount l.1 l.2) (auxCount x y (J∪S) l.1 l.2)),
      nonlightFactor, ← Finset.prod_mul_distrib]
    apply Finset.prod_congr rfl
    intro l _
    rw [← incidenceCount_stagePath_any, incidenceCount_union x y (hJ.mono_right hS)]
    unfold lightMoment
    split_ifs with hl
    · simp
    · rw [H.incidenceCount_good_nonlight x y η l hl hS]
      simp
  · simp

end CoordinateSweeps.Grid.Holes
/- Finite subset rearrangements needed for the actual good/non-good path
alternation in source04:eq10. -/
noncomputable section
open scoped BigOperators
namespace CoordinateSweeps
variable {I : Type*} [DecidableEq I]

theorem sum_powerset_union {R : Type*} [AddCommMonoid R]
    (A B : Finset I) (hAB : Disjoint A B) (f : Finset I → R) :
    ∑ S ∈ (A∪B).powerset, f S =
      ∑ J ∈ A.powerset, ∑ S ∈ B.powerset, f (J∪S) := by
  rw [← Finset.sum_product A.powerset B.powerset (fun p => f (p.1 ∪ p.2))]
  symm
  apply Finset.sum_bij (fun p _ => p.1 ∪ p.2)
  · intro p hp
    obtain ⟨hp1,hp2⟩ := Finset.mem_product.mp hp
    exact Finset.mem_powerset.mpr (Finset.union_subset_union
      (Finset.mem_powerset.mp hp1) (Finset.mem_powerset.mp hp2))
  · intro p hp q hq he
    obtain ⟨hp1,hp2⟩ := Finset.mem_product.mp hp
    obtain ⟨hq1,hq2⟩ := Finset.mem_product.mp hq
    have hp1 := Finset.mem_powerset.mp hp1
    have hp2 := Finset.mem_powerset.mp hp2
    have hq1 := Finset.mem_powerset.mp hq1
    have hq2 := Finset.mem_powerset.mp hq2
    apply Prod.ext
    · ext i
      constructor
      · intro hi
        have hu : i ∈ q.1 ∪ q.2 := he ▸ Finset.mem_union_left _ hi
        rcases Finset.mem_union.mp hu with h | h
        · exact h
        · exact False.elim (Finset.disjoint_left.mp hAB (hp1 hi) (hq2 h))
      · intro hi
        have hu : i ∈ p.1 ∪ p.2 := he.symm ▸ Finset.mem_union_left _ hi
        rcases Finset.mem_union.mp hu with h | h
        · exact h
        · exact False.elim (Finset.disjoint_left.mp hAB (hq1 hi) (hp2 h))
    · ext i
      constructor
      · intro hi
        have hu : i ∈ q.1 ∪ q.2 := he ▸ Finset.mem_union_right _ hi
        rcases Finset.mem_union.mp hu with h | h
        · exact False.elim (Finset.disjoint_left.mp hAB (hq1 h) (hp2 hi))
        · exact h
      · intro hi
        have hu : i ∈ p.1 ∪ p.2 := he.symm ▸ Finset.mem_union_right _ hi
        rcases Finset.mem_union.mp hu with h | h
        · exact False.elim (Finset.disjoint_left.mp hAB (hp1 h) (hq2 hi))
        · exact h
  · intro S hS
    refine ⟨(S∩A,S∩B), Finset.mem_product.mpr ⟨?_,?_⟩, ?_⟩
    · exact Finset.mem_powerset.mpr Finset.inter_subset_right
    · exact Finset.mem_powerset.mpr Finset.inter_subset_right
    · simp only [Finset.mem_powerset] at hS
      ext i
      simp only [Finset.mem_union, Finset.mem_inter]
      constructor
      · tauto
      · intro hi
        have hu := Finset.mem_union.mp (hS hi)
        tauto
  · intro p hp
    rfl

theorem sum_powerset_sdiff {R : Type*} [AddCommMonoid R]
    (A : Finset I) (f : Finset I → R) :
    ∑ S ∈ A.powerset, f (A\S) = ∑ S ∈ A.powerset, f S := by
  apply Finset.sum_bij (fun S _ => A\S)
  · intro S hS
    exact Finset.mem_powerset.mpr Finset.sdiff_subset
  · intro S hS T hT he
    have hS := Finset.mem_powerset.mp hS
    have hT := Finset.mem_powerset.mp hT
    apply_fun (fun U => A\U) at he
    simpa only [Finset.sdiff_sdiff_self_left, Finset.inter_eq_right.mpr hS,
      Finset.inter_eq_right.mpr hT] using he
  · intro S hS
    have hS := Finset.mem_powerset.mp hS
    exact ⟨A\S, Finset.mem_powerset.mpr Finset.sdiff_subset, by simp [hS]⟩
  · intro S hS
    rfl

theorem alternating_good_split [Fintype I] (G : Finset I) (f : Finset I → ℝ) :
    (∑ A ∈ (Finset.univ : Finset I).powerset,
      (-1 : ℝ)^(Fintype.card I-A.card)*f A) =
    ∑ J ∈ ((Finset.univ : Finset I)\G).powerset,
      (-1 : ℝ)^(Fintype.card I-J.card-G.card) *
        ∑ A ∈ G.powerset, (-1 : ℝ)^A.card * f (J ∪ (G\A)) := by
  have hg : ((Finset.univ : Finset I)\G) ∪ G = Finset.univ := by simp
  conv_lhs => rw [← hg, sum_powerset_union _ _ disjoint_sdiff_self_left]
  apply Finset.sum_congr rfl
  intro J hJ
  have hJ := Finset.mem_powerset.mp hJ
  have hd : Disjoint J G := Finset.disjoint_of_subset_left hJ disjoint_sdiff_self_left
  rw [← sum_powerset_sdiff G (fun S => (-1 : ℝ)^(Fintype.card I-(J∪S).card)*f (J∪S))]
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro A hA
  have hA := Finset.mem_powerset.mp hA
  have hdc : Disjoint J (G\A) := hd.mono_right Finset.sdiff_subset
  have hcard : J.card+G.card ≤ Fintype.card I := by
    rw [← Finset.card_union_of_disjoint hd]
    exact Finset.card_le_univ _
  have hAc := Finset.card_le_card hA
  rw [Finset.card_union_of_disjoint hdc, Finset.card_sdiff_of_subset hA]
  have he : Fintype.card I-(J.card+(G.card-A.card)) =
      (Fintype.card I-J.card-G.card)+A.card := by omega
  rw [he, pow_add]
  ring

end CoordinateSweeps

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

theorem alternating_good_extensions (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) (η : ℝ) (J : Finset (Fin k))
    (hJ : Disjoint J (H.goodSet x y η)) :
    (∑ A ∈ (H.goodSet x y η).powerset, (-1 : ℝ)^A.card *
      ((G.size : ℝ)^(J∪(H.goodSet x y η\A)).card *
        H.extraProbability x y (J∪(H.goodSet x y η\A)) (fun _ => FiniteLaw.uniform _))) =
      (if H.EndpointPossible x y J then H.nonlightFactor x y η J else 0) *
        shiftedMoment (H.lightMoment x y η) (incidenceCount J (G.stagePath x y))
          (goodExpansion (H.goodSet x y η) (G.stagePath x y)) := by
  rw [shiftedMoment_goodExpansion_eq, Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro A hA
  rw [H.scaled_extraProbability_good_union x y hx η J _ hJ Finset.sdiff_subset]
  ring

/- Source04:eq10, now proved for literal uniform stage-line laws and actual
conditioned path probabilities. Constants are explicit and absolute; all
non-light factors and validity indicators remain outside the moment. -/
theorem scaled_placementKernel_good_bound (H : G.Holes h) (x y : Fin k → G.Slot)
    (hx : H.ValidInput x) {η : ℝ} (hη : 0 ≤ η) (hηsmall : η ≤ 1/8) :
    |(G.size : ℝ)^k * H.placementKernel x y (fun _ => FiniteLaw.uniform _)| ≤
      (2 : ℝ)^k * Real.exp ((G.b : ℝ)*(h+k)+Real.log 4*k*G.b) *
        (16*Real.exp 2)^(G.b*k) * (1+16*Real.exp 2)^(G.b*k) *
          η^(((H.goodSet x y η).card : ℝ)/2) := by
  have hs : (G.size : ℝ) ≠ 0 := by unfold Grid.size; positivity
  have hC : (1 : ℝ) ≤ 16*Real.exp 2 := by
    have := Real.one_le_exp (by norm_num : (0 : ℝ) ≤ 2)
    linarith
  have hC' : (1 : ℝ) ≤ 1+16*Real.exp 2 := by linarith
  let GG := H.goodSet x y η
  let E := Real.exp ((G.b : ℝ)*(h+k)+Real.log 4*k*G.b)
  let U := (16*Real.exp 2)^(G.b*k) * (1+16*Real.exp 2)^(G.b*k) * η^((GG.card : ℝ)/2)
  have hU : 0 ≤ U := by dsimp [U]; positivity
  rw [placementKernel, ← mul_assoc, ← mul_pow, mul_inv_cancel₀ hs, one_pow, one_mul]
  conv_lhs => simp only [mul_assoc]
  have hsplit := alternating_good_split GG (fun A =>
    (G.size : ℝ)^A.card * H.extraProbability x y A (fun _ => FiniteLaw.uniform _))
  simp only [Fintype.card_fin] at hsplit
  rw [hsplit]
  have hterm (J : Finset (Fin k)) (hJ : J ∈ ((Finset.univ : Finset (Fin k))\GG).powerset) :
      |(-1 : ℝ)^(k-J.card-GG.card) *
        ∑ A ∈ GG.powerset, (-1 : ℝ)^A.card *
          ((G.size : ℝ)^(J∪(GG\A)).card *
            H.extraProbability x y (J∪(GG\A)) (fun _ => FiniteLaw.uniform _))| ≤ E*U := by
    have hsub := Finset.mem_powerset.mp hJ
    have hd : Disjoint J GG := Finset.disjoint_of_subset_left hsub disjoint_sdiff_self_left
    rw [abs_mul, abs_pow, abs_neg, abs_one, one_pow, one_mul,
      H.alternating_good_extensions x y hx η J hd, abs_mul]
    have hD : |if H.EndpointPossible x y J then H.nonlightFactor x y η J else 0| ≤ E := by
      split_ifs with hp
      · rw [abs_of_nonneg (H.nonlightFactor_nonneg x y η J)]
        exact H.nonlightFactor_le x y hx η J hp
      · simp only [abs_zero]
        exact (Real.exp_pos _).le
    have hM := H.goodExpansion_lightMoment_le x y hη hηsmall J hd
    have hJk : J.card ≤ k := by simpa using Finset.card_le_univ J
    have hGk : GG.card ≤ k := by simpa using Finset.card_le_univ GG
    have hM' : |shiftedMoment (H.lightMoment x y η) (incidenceCount J (G.stagePath x y))
        (goodExpansion GG (G.stagePath x y))| ≤ U := by
      apply hM.trans
      apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg hη _)
      apply mul_le_mul
      · exact pow_le_pow_right₀ hC (Nat.mul_le_mul_left G.b hJk)
      · exact pow_le_pow_right₀ hC' (Nat.mul_le_mul_left G.b hGk)
      · positivity
      · positivity
    exact mul_le_mul hD hM' (abs_nonneg _) (Real.exp_pos _).le
  calc
    _ ≤ ∑ J ∈ ((Finset.univ : Finset (Fin k))\GG).powerset,
        |(-1 : ℝ)^(k-J.card-GG.card) *
          ∑ A ∈ GG.powerset, (-1 : ℝ)^A.card *
            ((G.size : ℝ)^(J∪(GG\A)).card *
              H.extraProbability x y (J∪(GG\A)) (fun _ => FiniteLaw.uniform _))| :=
      Finset.abs_sum_le_sum_abs _ _
    _ ≤ ∑ J ∈ ((Finset.univ : Finset (Fin k))\GG).powerset, E*U :=
      Finset.sum_le_sum hterm
    _ = (2 : ℝ)^((Finset.univ : Finset (Fin k))\GG).card*(E*U) := by simp
    _ ≤ (2 : ℝ)^k*(E*U) := by
      apply mul_le_mul_of_nonneg_right _ (mul_nonneg (Real.exp_pos _).le hU)
      apply pow_le_pow_right₀ (by norm_num)
      exact le_trans (Finset.card_le_card Finset.sdiff_subset) (by simp)
    _ = _ := by dsimp [E,U,GG]; ring

end CoordinateSweeps.Grid.Holes
end
end
end
end
end
open scoped Matrix.Norms.L2Operator

end OAI