import Mathlib
import OAI.Probability.CoordinateSweeps.Kernel

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
namespace CoordinateSweeps
namespace Grid.Holes
variable {G : Grid} {h : ℕ}

theorem log_size (G : Grid) : Real.log (G.size : ℝ) =
    ∑ j, Real.log ((2 ^ G.bits j : ℕ) : ℝ) := by
  rw [size,Nat.cast_prod,Real.log_prod]
  intro j _
  positivity

theorem log_probability_zero (H : G.Holes h) :
    Real.log (H.probability 0) = H.cost - (h : ℝ) * Real.log (G.size : ℝ) := by
  have hp (j : Fin G.b) (L : G.Line j) :
      (((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 hline (j : Fin G.b) (L : G.Line j) :
      Real.log (((2 ^ G.bits j : ℕ) : ℝ)^H.lineCount j L /
        ((2 ^ G.bits j).descFactorial (H.lineCount j L) : ℝ)) =
      (H.lineCount j L : ℝ) * Real.log ((2 ^ G.bits j : ℕ) : ℝ) -
        Real.log ((2 ^ G.bits j).descFactorial (H.lineCount j L) : ℝ) := by
    rw [Real.log_div (by positivity) (hp j L),Real.log_pow]
  have hs (j : Fin G.b) : ∑ L : G.Line j, (H.lineCount j L : ℝ) = h := by
    exact_mod_cast H.sum_lineCount j
  rw [H.probability_zero, Real.log_prod (by
    intro j _
    exact Finset.prod_ne_zero_iff.mpr (fun L _ => inv_ne_zero (hp j L)))]
  have hsum (j : Fin G.b) :
      Real.log (∏ L : G.Line j, (((2 ^ G.bits j).descFactorial (H.lineCount j L) : ℝ)⁻¹)) =
        ∑ L : G.Line j, -Real.log ((2 ^ G.bits j).descFactorial (H.lineCount j L) : ℝ) := by
    rw [Real.log_prod (fun L _ => inv_ne_zero (hp j L))]
    simp only [Real.log_inv]
  simp_rw [hsum]
  unfold cost
  simp_rw [hline,Finset.sum_sub_distrib,← Finset.sum_mul,hs]
  simp only [Finset.sum_neg_distrib]
  rw [← Finset.mul_sum,log_size]
  ring

theorem probability_zero_pos (H : G.Holes h) : 0 < H.probability 0 := by
  rw [H.probability_zero]
  apply Finset.prod_pos
  intro j _
  apply Finset.prod_pos
  intro L _
  apply inv_pos.mpr
  exact_mod_cast Nat.descFactorial_pos.mpr (H.lineCount_le j L)

theorem probability_zero_eq_exp (H : G.Holes h) :
    H.probability 0 = Real.exp (H.cost - (h : ℝ)*Real.log (G.size : ℝ)) := by
  rw [← H.log_probability_zero,Real.exp_log H.probability_zero_pos]

/- Augmented holes retain the ordered first h trajectories exactly. -/
def Extends {t : ℕ} (J : G.Holes (h+t)) (H : G.Holes h) : Prop :=
  ∀ (i : Fin h) (j : Fin (G.b+1)), J.path (Fin.castAdd t i) j = H.path i j

def extraCount {t : ℕ} (J : G.Holes (h+t)) (j : Fin G.b) (L : G.Line j) : ℕ :=
  (Finset.univ.filter (fun i : Fin t => J.OnLine j L (Fin.natAdd h i))).card

theorem lineCount_add {t : ℕ} (J : G.Holes (h+t)) (H : G.Holes h)
    (he : J.Extends H) (j : Fin G.b) (L : G.Line j) :
    J.lineCount j L = H.lineCount j L + J.extraCount j L := by
  unfold Extends at he
  unfold lineCount extraCount OnLine
  simp only [Finset.card_eq_sum_ones,Finset.sum_filter]
  rw [Fin.sum_univ_add]
  congr 1 <;> apply Finset.sum_congr rfl
  · intro i _
    simp only [he i j.castSucc]
  · intro i _
    split_ifs <;> rfl

theorem sum_extraCount {t : ℕ} (J : G.Holes (h+t)) (j : Fin G.b) :
    ∑ L : G.Line j, J.extraCount j L = t := by
  unfold extraCount
  simp only [Finset.card_eq_sum_ones,Finset.sum_filter]
  rw [Finset.sum_comm]
  have hh (i : Fin t) : (∑ L : G.Line j, if J.OnLine j L (Fin.natAdd h i) then 1 else 0) = 1 := by
    let L₀ : G.Line j := fun k => J.path (Fin.natAdd h i) j.castSucc k
    rw [Finset.sum_eq_single L₀]
    · exact ite_eq_left rfl
    · intro L _ hL
      apply ite_eq_right
      intro he
      exact hL he.symm
    · simp
  simp_rw [hh]
  simp

theorem no_extra_iff {t : ℕ} (J : G.Holes (h+t)) (j : Fin G.b) (L : G.Line j) :
    J.extraCount j L = 0 ↔ ∀ i : Fin t, ¬ J.OnLine j L (Fin.natAdd h i) := by
  simp [extraCount,Finset.card_eq_zero]

theorem lineCompatible_eq_of_no_extra {t : ℕ} (J : G.Holes (h+t))
    (H : G.Holes h) (he : J.Extends H) (j : Fin G.b) (L : G.Line j)
    (hno : J.extraCount j L = 0) (σ : Equiv.Perm (Cube (G.bits j))) :
    J.LineCompatible j L σ ↔ H.LineCompatible j L σ := by
  unfold Extends at he
  have hn := (J.no_extra_iff j L).mp hno
  constructor
  · intro hj i
    have hi : J.OnLine j L (Fin.castAdd t i.val) := by
      change (fun k : {k : Fin G.b // k ≠ j} => J.path (Fin.castAdd t i.val) j.castSucc k) = L
      simpa only [OnLine,he i.val j.castSucc] using i.property
    have hh := hj ⟨Fin.castAdd t i.val,hi⟩
    simpa only [he] using hh
  · intro hh i
    have hcases : (∃ k : Fin h, i.val = Fin.castAdd t k) ∨
        (∃ k : Fin t, i.val = Fin.natAdd h k) :=
      Fin.addCases (fun k : Fin h => Or.inl ⟨k,rfl⟩)
        (fun k : Fin t => Or.inr ⟨k,rfl⟩) i.val
    rcases hcases with ⟨k,hk⟩ | ⟨k,hk⟩
    · have hi : H.OnLine j L k := by
        have hi := i.property
        rw [hk] at hi
        simpa only [OnLine,he] using hi
      have hv := hh ⟨k,hi⟩
      simpa only [hk,he] using hv
    · exact False.elim (hn k (hk ▸ i.property))

end Grid.Holes

namespace FiniteLaw
variable {Ω : Type*} [Fintype Ω] [DecidableEq Ω]

theorem assignments_pos_of_comparison {h : ℕ} (μ : FiniteLaw (Equiv.Perm Ω))
    (hlo : ∀ g, (1/2 : ℝ)*uniform (Equiv.Perm Ω) g ≤ μ g)
    (x y : Fin h ↪ Ω) : 0 < μ.assignments x y := by
  have hp := uniform_assignments_pos x y
  exact lt_of_lt_of_le (by positivity) (le_assignments μ (uniform _) (1/2) hlo x y)

theorem assignments_ratio_comparison {h h' : ℕ} (μ : FiniteLaw (Equiv.Perm Ω))
    (hlo : ∀ g, (1/2 : ℝ)*uniform (Equiv.Perm Ω) g ≤ μ g)
    (hhi : ∀ g, μ g ≤ 2*uniform (Equiv.Perm Ω) g)
    (x y : Fin h ↪ Ω) (x' y' : Fin h' ↪ Ω) :
    μ.assignments x' y' / μ.assignments x y ≤
      4 * ((uniform (Equiv.Perm Ω)).assignments x' y' /
        (uniform (Equiv.Perm Ω)).assignments x y) := by
  have hp := uniform_assignments_pos x y
  calc
    _ ≤ (2*(uniform (Equiv.Perm Ω)).assignments x' y') /
        ((1/2)*(uniform (Equiv.Perm Ω)).assignments x y) :=
      div_le_div₀ (mul_nonneg (by norm_num) ((uniform _).assignments_nonneg x' y'))
        (assignments_le μ (uniform _) 2 hhi x' y') (by positivity)
        (le_assignments μ (uniform _) (1/2) hlo x y)
    _ = _ := by ring
end FiniteLaw

namespace Grid.Holes
variable {G : Grid} {h t : ℕ}

def lineProb (H : G.Holes h) (j : Fin G.b) (L : G.Line j)
    (μ : FiniteLaw (Equiv.Perm (Cube (G.bits j)))) : ℝ :=
  μ.assignments (H.lineInput j L) (H.lineOutput j L)

theorem lineProb_nonneg (H : G.Holes h) (j : Fin G.b) (L : G.Line j)
    (μ : FiniteLaw (Equiv.Perm (Cube (G.bits j)))) : 0 ≤ H.lineProb j L μ :=
  μ.assignments_nonneg _ _

theorem uniform_lineProb_pos (H : G.Holes h) (j : Fin G.b) (L : G.Line j) :
    0 < H.lineProb j L (FiniteLaw.uniform _) := FiniteLaw.uniform_assignments_pos _ _

theorem lineProb_eq_of_no_extra (J : G.Holes (h+t)) (H : G.Holes h)
    (he : J.Extends H) (j : Fin G.b) (L : G.Line j) (hno : J.extraCount j L = 0)
    (μ : FiniteLaw (Equiv.Perm (Cube (G.bits j)))) :
    J.lineProb j L μ = H.lineProb j L μ := by
  unfold lineProb
  rw [← J.lineProbability_eq,← H.lineProbability_eq]
  let e : {σ // J.LineCompatible j L σ} ≃ {σ // H.LineCompatible j L σ} :=
    Equiv.subtypeEquivRight (J.lineCompatible_eq_of_no_extra H he j L hno)
  exact Equiv.sum_comp e (fun σ => μ σ.val)

def usedLine (J : G.Holes (h+t)) (j : Fin G.b) (L : G.Line j) : ℕ :=
  if J.extraCount j L = 0 then 0 else 1

theorem sum_usedLine_le (J : G.Holes (h+t)) :
    (∑ j, ∑ L : G.Line j, J.usedLine j L) ≤ t*G.b := by
  calc
    _ ≤ ∑ j, ∑ L : G.Line j, J.extraCount j L := by
      apply Finset.sum_le_sum
      intro j _
      apply Finset.sum_le_sum
      intro L _
      unfold usedLine
      split_ifs <;> omega
    _ = t*G.b := by simp [J.sum_extraCount,Nat.mul_comm]

theorem lineProb_ratio_le (J : G.Holes (h+t)) (H : G.Holes h)
    (he : J.Extends H) (j : Fin G.b) (L : G.Line j)
    (μ : FiniteLaw (Equiv.Perm (Cube (G.bits j))))
    (hlo : ∀ g, (1/2 : ℝ)*FiniteLaw.uniform _ g ≤ μ g)
    (hhi : ∀ g, μ g ≤ 2*FiniteLaw.uniform _ g) :
    J.lineProb j L μ / H.lineProb j L μ ≤
      (4 : ℝ) ^ J.usedLine j L *
        (J.lineProb j L (FiniteLaw.uniform _) / H.lineProb j L (FiniteLaw.uniform _)) := by
  by_cases hno : J.extraCount j L = 0
  · rw [J.lineProb_eq_of_no_extra H he j L hno μ,
      J.lineProb_eq_of_no_extra H he j L hno (FiniteLaw.uniform _)]
    have hp : 0 < H.lineProb j L μ := μ.assignments_pos_of_comparison hlo _ _
    have hu := H.uniform_lineProb_pos j L
    simp [usedLine,hno,hp.ne',hu.ne']
  · simpa only [lineProb,usedLine,ite_eq_right hno,pow_one] using
      μ.assignments_ratio_comparison hlo hhi (H.lineInput j L) (H.lineOutput j L)
        (J.lineInput j L) (J.lineOutput j L)

theorem probability_prod_lineProb (H : G.Holes h) {z : ℝ} (hz : 0 ≤ z) (hz' : z ≤ 1) :
    H.probability z = ∏ j, ∏ L : G.Line j, H.lineProb j L (lineLaw (G.bits j) z hz hz') :=
  H.probability_eq_assignments hz hz'

theorem probability_zero_prod_lineProb (H : G.Holes h) :
    H.probability 0 = ∏ j, ∏ L : G.Line j, H.lineProb j L (FiniteLaw.uniform _) := by
  rw [H.probability_prod_lineProb (le_refl 0) zero_le_one]
  congr 1
  funext j
  congr 1
  funext L
  congr 1
  ext σ
  simp [lineLaw,FiniteLaw.mix]

/- Only a line visited by a new path may spend the factor four. Thus the
factor count is at most t*b, not the total number of stage-lines. -/
theorem probability_ratio_comparison (J : G.Holes (h+t)) (H : G.Holes h)
    (he : J.Extends H) {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) :
    J.probability z / H.probability z ≤
      (4 : ℝ)^(t*G.b) * (J.probability 0 / H.probability 0) := by
  let μ (j : Fin G.b) := lineLaw (G.bits j) z hz hz'
  have heq : J.probability z / H.probability z =
      ∏ j, ∏ L : G.Line j, J.lineProb j L (μ j) / H.lineProb j L (μ j) := by
    rw [J.probability_prod_lineProb hz hz',H.probability_prod_lineProb hz hz',
      ← Finset.prod_div_distrib]
    simp_rw [← Finset.prod_div_distrib]
    rfl
  rw [heq]
  calc
    _ ≤ ∏ j, ∏ L : G.Line j, (4 : ℝ)^J.usedLine j L *
        (J.lineProb j L (FiniteLaw.uniform _) / H.lineProb j L (FiniteLaw.uniform _)) := by
      apply Finset.prod_le_prod₀
      · intro j _
        exact Finset.prod_nonneg (fun L _ => div_nonneg (J.lineProb_nonneg j L _) (H.lineProb_nonneg j L _))
      · intro j _
        apply Finset.prod_le_prod₀
        · intro L _; exact div_nonneg (J.lineProb_nonneg j L _) (H.lineProb_nonneg j L _)
        · intro L _; exact J.lineProb_ratio_le H he j L (μ j) (hlo j) (hhi j)
    _ = (4 : ℝ)^(∑ j, ∑ L : G.Line j, J.usedLine j L) *
        (J.probability 0 / H.probability 0) := by
      simp_rw [Finset.prod_mul_distrib,Finset.prod_div_distrib,Finset.prod_pow_eq_pow_sum]
      rw [← J.probability_zero_prod_lineProb,← H.probability_zero_prod_lineProb]
    _ ≤ _ := mul_le_mul_of_nonneg_right
      (pow_le_pow_right₀ (by norm_num) J.sum_usedLine_le)
      (div_nonneg J.probability_zero_pos.le H.probability_zero_pos.le)

/- Source 03-paths (4), in the exactly equal exponential notation. The ratio
is the conditional probability of the complete augmented paths. -/
theorem conditional_transition_bound (J : G.Holes (h+t)) (H : G.Holes h)
    (he : J.Extends H) {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) :
    J.probability z / H.probability z ≤
      Real.exp (-(t : ℝ)*Real.log (G.size : ℝ) + J.cost-H.cost + Real.log 4*(t : ℝ)*G.b) := by
  apply (J.probability_ratio_comparison H he hz hz' hlo hhi).trans_eq
  rw [J.probability_zero_eq_exp,H.probability_zero_eq_exp,← Real.exp_sub]
  have h4 : (4 : ℝ)^(t*G.b) = Real.exp (Real.log 4 * (t : ℝ)*G.b) := by
    rw [show Real.log 4 * (t : ℝ)*G.b = (t*G.b : ℕ)*Real.log 4 by push_cast; ring,
      Real.exp_nat_mul,Real.exp_log (by norm_num : (0 : ℝ)<4)]
  rw [h4,← Real.exp_add]
  congr 1
  push_cast
  ring
end Grid.Holes

end CoordinateSweeps

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

/- An injection into the actual available input slots. -/
def ValidInput (H : G.Holes h) (x : Fin t → G.Slot) : Prop :=
  Function.Injective x ∧ ∀ i a, x i ≠ H.path a 0

/- A feasible endpoint event augments the prescribed holes by the uniquely
determined auxiliary paths. The witness is used only to verify disjointness. -/
def augment (H : G.Holes h) (u v : Fin t → G.Slot) (hu : H.ValidInput u)
    (ω : G.Choices) (hω : H.Compatible ω) (hv : ∀ i, G.sweep ω (u i) = v i) :
    G.Holes (h+t) where
  path i s := Fin.append (fun a => H.path a s) (fun a => G.pathBetween (u a) (v a) s) i
  disjoint s := by
    apply Fin.append_injective_iff.mpr
    refine ⟨H.disjoint s, ?_, ?_⟩
    · intro a b he
      have ha := G.boundary_eq_pathBetween ω (u a) s
      have hb := G.boundary_eq_pathBetween ω (u b) s
      rw [hv a] at ha
      rw [hv b] at hb
      exact hu.1 ((G.boundary ω s).injective (ha.trans (he.trans hb.symm)))
    · intro a b he
      have hb := G.boundary_eq_pathBetween ω (u b) s
      rw [hv b] at hb
      exact hu.2 b a ((G.boundary ω s).injective ((hω a s).trans (he.trans hb.symm))).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 (u a) (v a) j l hlj

@[simp] theorem augment_old (H : G.Holes h) (u v : Fin t → G.Slot) (hu : H.ValidInput u)
    (ω : G.Choices) (hω : H.Compatible ω) (hv : ∀ i, G.sweep ω (u i) = v i)
    (i : Fin h) (s : Fin (G.b+1)) :
    (H.augment u v hu ω hω hv).path (Fin.castAdd t i) s = H.path i s := by
  simp [augment]

@[simp] theorem augment_new (H : G.Holes h) (u v : Fin t → G.Slot) (hu : H.ValidInput u)
    (ω : G.Choices) (hω : H.Compatible ω) (hv : ∀ i, G.sweep ω (u i) = v i)
    (i : Fin t) (s : Fin (G.b+1)) :
    (H.augment u v hu ω hω hv).path (Fin.natAdd h i) s =
      G.pathBetween (u i) (v i) s := by
  simp [augment]

theorem augment_extends (H : G.Holes h) (u v : Fin t → G.Slot) (hu : H.ValidInput u)
    (ω : G.Choices) (hω : H.Compatible ω) (hv : ∀ i, G.sweep ω (u i) = v i) :
    (H.augment u v hu ω hω hv).Extends H := by
  intro i s; simp

/- Exact equivalence of conditioning events, including all stage boundaries. -/
theorem augment_compatible_iff (H : G.Holes h) (u v : Fin t → G.Slot) (hu : H.ValidInput u)
    (ω : G.Choices) (hω : H.Compatible ω) (hv : ∀ i, G.sweep ω (u i) = v i)
    (ν : G.Choices) :
    (H.augment u v hu ω hω hv).Compatible ν ↔
      H.Compatible ν ∧ ∀ i, G.sweep ν (u i) = v i := by
  constructor
  · intro hJ
    constructor
    · intro a s
      have hh := hJ (Fin.castAdd t a) s
      simpa only [augment_old] using hh
    · intro a
      have hh := hJ (Fin.natAdd h a) (Fin.last G.b)
      simpa only [augment_new, Grid.pathBetween_zero, Grid.pathBetween_last, Grid.sweep, Fin.val_last] using hh
  · rintro ⟨hν,he⟩
    intro i s
    cases i using Fin.addCases with
    | left a => simpa only [augment_old] using hν a s
    | right a =>
      simp only [augment_new, Grid.pathBetween_zero]
      rw [G.boundary_eq_pathBetween, he a]

/- A canonical enumeration of a selected list of auxiliary cards. -/
def selected (A : Finset (Fin k)) : Fin A.card ↪ Fin k :=
  (Fintype.equivFinOfCardEq (Fintype.card_coe A)).symm.toEmbedding.trans (Function.Embedding.subtype _)

theorem selected_mem (A : Finset (Fin k)) (i : Fin A.card) : selected A i ∈ A :=
  ((Fintype.equivFinOfCardEq (Fintype.card_coe A)).symm i).property

theorem selected_range (A : Finset (Fin k)) (a : Fin k) (ha : a ∈ A) :
    ∃ i, selected A i = a := by
  let i := (Fintype.equivFinOfCardEq (Fintype.card_coe A)) ⟨a,ha⟩
  exact ⟨i, congrArg Subtype.val ((Fintype.equivFinOfCardEq (Fintype.card_coe A)).symm_apply_apply _)⟩

theorem validInput_selected (H : G.Holes h) (u : Fin k → G.Slot) (hu : H.ValidInput u)
    (A : Finset (Fin k)) : H.ValidInput (fun i => u (selected A i)) := by
  exact ⟨hu.1.comp (selected A).injective, fun i a => hu.2 _ a⟩

theorem endpointEvent_iff_selected (u v : Fin k → G.Slot) (A : Finset (Fin k))
    (ω : G.Choices) : G.endpointEvent u v A ω ↔
      ∀ i : Fin A.card, G.sweep ω (u (selected A i)) = v (selected A i) := by
  constructor
  · intro he i
    exact he _ (selected_mem A i)
  · intro he a ha
    obtain ⟨i,rfl⟩ := selected_range A a ha
    exact he i

end CoordinateSweeps.Grid.Holes

/- Multiplicity in a unitary matrix representation is controlled by the
commutant dimension, with exact (unnormalized) character conventions. -/

end
end
open scoped Matrix.Norms.L2Operator

end OAI