import Mathlib
import OAI.Probability.Perceptron.Variational.DepthBlock

namespace OAI

noncomputable section
open MeasureTheory ProbabilityTheory Set Filter
open scoped Classical ENNReal NNReal BigOperators Topology
namespace SphericalPerceptronFreeEnergy

lemma depth_block_row_threshold (k r d : ℕ)
    (μ : Measure (FiniteOverlap (Fin (k+1)))) (A : FiniteBlock (Fin (k+1)) r)
    (i j : Fin r) :
    μ.real {R | finiteBlock r R = A ∧ d ≤ (R i j).val} =
      μ.real {R | finiteBlock r R = A} * (if d ≤ (A i j).val then 1 else 0) := by
  have he (R : FiniteOverlap (Fin (k+1))) (hR : finiteBlock r R = A) : R i j = A i j :=
    congrFun (congrFun hR i) j
  by_cases hd : d ≤ (A i j).val
  · rw [ite_eq_left hd,mul_one]
    congr 1
    ext R
    constructor
    · exact And.left
    · intro hR
      exact ⟨hR,by rw [he R hR]; exact hd⟩
  · rw [ite_eq_right hd,mul_zero]
    have hEmpty : {R : FiniteOverlap (Fin (k+1)) | finiteBlock r R = A ∧ d ≤ (R i j).val} = ∅ := by
      ext R
      simp only [Set.mem_ofPred_eq,Set.mem_empty_iff_false,iff_false,not_and]
      intro hR hD
      exact hd (by simpa only [he R hR] using hD)
    rw [hEmpty,measureReal_empty]

lemma indexedDepthLaw_block_zero_of_diagonal (k r : ℕ) (z : Fin k → ℝ)
    (A : FiniteBlock (Fin (k+1)) r) (i : Fin r) (hA : A i i ≠ Fin.last k) :
    (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))).real
      {R | finiteBlock r R = A} = 0 := by
  convert measureReal_empty (μ := (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1))))) using 1
  apply measureReal_congr
  filter_upwards [indexedDepthLaw_geometry k z] with R hR
  change (finiteBlock r R = A) = False
  apply propext
  simp only [iff_false]
  intro hB
  have he : R i i = A i i := congrFun (congrFun hB i) i
  exact hA (he.symm.trans (hR.2.1 i))

lemma indexedDepthLaw_focused_formula_real (k : ℕ) (z : Fin k → ℝ)
    (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (r d : ℕ) (hd : d ≤ k) (A : FiniteBlock (Fin (k+1)) r) (i : Fin r)
    (hA : A i i = Fin.last k) :
    (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))).real
      {R | finiteBlock r R = A ∧ d ≤ (R i r).val} =
      (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))).real {R | finiteBlock r R = A} *
        (((∑ j, if d ≤ (A i j).val then (1:ℝ) else 0) -
          (if h : d = 0 then 0 else z ⟨d-1,by omega⟩)) / r) := by
  have hb : (if h : d = 0 then (0:ℝ) else z ⟨d-1,by omega⟩) ≤ 1 := by
    split_ifs
    · norm_num
    · exact (hz1 _).le
  have hc : (1:ℝ) ≤ ∑ j, if d ≤ (A i j).val then (1:ℝ) else 0 := by
    have he := Finset.single_le_sum (s := Finset.univ)
      (f := fun j : Fin r => if d ≤ (A i j).val then (1:ℝ) else 0)
      (fun j _ => by split_ifs <;> norm_num) (Finset.mem_univ i)
    simpa only [hA,Fin.val_last,ite_eq_left hd] using he
  have hn : 0 ≤ ((∑ j, if d ≤ (A i j).val then (1:ℝ) else 0) -
      (if h : d = 0 then (0:ℝ) else z ⟨d-1,by omega⟩)) / r :=
    div_nonneg (sub_nonneg.mpr (hb.trans hc)) (Nat.cast_nonneg _)
  have he := congrArg ENNReal.toReal (indexedDepthLaw_focused_formula k z hz hz0 hz1 r d hd A i)
  simpa only [measureReal_def,ENNReal.toReal_mul,ENNReal.toReal_ofReal hn] using he

lemma indexedDepthLaw_pair_tail_real (k : ℕ) (z : Fin k → ℝ)
    (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1)
    (d : ℕ) (hd : d ≤ k) :
    (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))).real {R | d ≤ (R 0 1).val} =
      1 - (if h : d = 0 then 0 else z ⟨d-1,by omega⟩) := by
  have hb : (if h : d = 0 then (0:ℝ) else z ⟨d-1,by omega⟩) ≤ 1 := by
    split_ifs
    · norm_num
    · exact (hz1 _).le
  have he := congrArg ENNReal.toReal (indexedDepthLaw_pair_tail k z hz hz0 hz1 d hd)
  simpa only [measureReal_def,ENNReal.toReal_ofReal (sub_nonneg.mpr hb)] using he

theorem indexedDepthLaw_finiteGG (k : ℕ) (z : Fin k → ℝ)
    (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) :
    FiniteGG (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1)))) := by
  apply finiteGG_of_depth_thresholds
  intro r _hr i A d hd
  let μ := (indexedDepthLaw k z : Measure (FiniteOverlap (Fin (k+1))))
  change μ.real {R | finiteBlock r R = A ∧ d ≤ (R i r).val} =
    μ.real {R | finiteBlock r R = A} * μ.real {R | d ≤ (R 0 1).val} / r +
      (∑ j ∈ Finset.univ.erase i, μ.real {R | finiteBlock r R = A ∧ d ≤ (R i j).val}) / r
  by_cases hdk : d ≤ k
  · by_cases hA : A i i = Fin.last k
    · have he := indexedDepthLaw_focused_formula_real k z hz hz0 hz1 r d hdk A i hA
      have hp := indexedDepthLaw_pair_tail_real k z hz hz0 hz1 d hdk
      change μ.real _ = μ.real _ * _ at he
      change μ.real _ = _ at hp
      rw [he,hp]
      simp_rw [depth_block_row_threshold k r d μ A i]
      rw [← Finset.mul_sum,Finset.sum_erase_eq_sub (Finset.mem_univ i)]
      simp only [hA,Fin.val_last,ite_eq_left hdk]
      ring
    · have hB := indexedDepthLaw_block_zero_of_diagonal k r z A i hA
      change μ.real _ = 0 at hB
      have hF : μ.real {R | finiteBlock r R = A ∧ d ≤ (R i r).val} = 0 :=
        measureReal_mono_null (fun _ h => h.1) hB
      rw [hF,hB]
      simp_rw [depth_block_row_threshold k r d μ A i,hB,zero_mul]
      simp
  · have he : d = k+1 := by omega
    subst d
    have hfalse (l : Fin (k+1)) : ¬ k+1 ≤ l.val := Nat.not_le.mpr l.isLt
    simp only [hfalse,and_false]
    simp

end SphericalPerceptronFreeEnergy

end

end OAI