import Mathlib
import OAI.Probability.SKBarriers.Replicas.ReplicaSampling
import OAI.Probability.SKBarriers.Dynamics.BankCoverage

namespace OAI

section

noncomputable section
open scoped BigOperators
open Classical
namespace SK.Analytic

theorem iid_gibbs_oriented_permuted_replica {n d : ℕ} (β : ℝ) (J : Disorder n)
    (ε : Fin d → Bool) (e : Equiv.Perm (Fin d)) (S : Finset (ReplicaConfig n d)) :
    ((gibbsFiniteLaw β J).iid (Fin d)).prob (fun z => (fun i => orient (ε i) (z (e i)))∈S)=replicaGibbsMass β J S := by
  have H := (gibbsFiniteLaw β J).iid_expect_equiv e.symm
    (fun z => if (fun i => orient (ε i) (z i))∈S then 1 else 0)
  simp only [Equiv.symm_symm,Function.comp_def,FiniteLaw.expect_indicator_eq_prob] at H
  exact H.trans (iid_gibbs_oriented_replica β J ε S)

theorem bank_pair_vertex_permuted {n : ℕ} {I : Type*} [Fintype I] [DecidableEq I]
    (β : ℝ) (J : Disorder n) (a b : I) (hab : a≠b)
    (ε : Fin 3 → Bool) (e : Equiv.Perm (Fin 3)) (S : Finset (ReplicaConfig n 3)) :
    ((gibbsFiniteLaw β J).iid I).expect (fun z => (gibbsFiniteLaw β J).prob (fun x =>
      (fun i => orient (ε i) ((![z a,z b,x] : ReplicaConfig n 3) (e i)))∈S))=
      replicaGibbsMass β J S := by
  have H := (gibbsFiniteLaw β J).iid_two_then_one a b hab
    (fun z => if (fun i => orient (ε i) (z (e i)))∈S then 1 else 0)
  simp only [FiniteLaw.expect_indicator_eq_prob] at H
  exact H.trans (iid_gibbs_oriented_permuted_replica β J ε e S)

namespace FiniteLaw
variable {X Y A : Type*} [Fintype X] [Fintype Y] [Fintype A]
theorem expect_prob_exists_le (P : FiniteLaw X) (Q : FiniteLaw Y) (E : A → X → Y → Prop) :
    P.expect (fun x => Q.prob (fun y => ∃ a,E a x y)) ≤ ∑ a, P.expect (fun x => Q.prob (E a x)) := by
  rw [← P.expect_sum]
  exact P.expect_mono (fun x => Q.prob_exists (fun a y => E a x y))
end FiniteLaw

def bankTripleBad {n : ℕ} {I : Type*} (level : I → ℕ) (S : Finset (ReplicaConfig n 3))
    (z : I → Config n) : Prop :=
  ∃ v : I × I × I × (Fin 3 → Bool),
    (level v.1≠level v.2.1 ∧ level v.1≠level v.2.2.1 ∧ level v.2.1≠level v.2.2.1) ∧
    (![orient (v.2.2.2 0) (z v.1),orient (v.2.2.2 1) (z v.2.1),orient (v.2.2.2 2) (z v.2.2.1)] : ReplicaConfig n 3)∈S

def bankVertexBad {n : ℕ} {I : Type*} (level : I → ℕ) (S : Finset (ReplicaConfig n 3))
    (z : I → Config n) (x : Config n) : Prop :=
  ∃ v : I × I × (Fin 3 → Bool) × Equiv.Perm (Fin 3),
    level v.1≠level v.2.1 ∧
    (fun i => orient (v.2.2.1 i) ((![z v.1,z v.2.1,x] : ReplicaConfig n 3) (v.2.2.2 i)))∈S

theorem bankTripleBad_prob {n : ℕ} {I : Type*} [Fintype I] [DecidableEq I]
    (β : ℝ) (J : Disorder n) (level : I → ℕ) (S : Finset (ReplicaConfig n 3)) :
    ((gibbsFiniteLaw β J).iid I).prob (bankTripleBad level S) ≤
      8*(Fintype.card I:ℝ)^3*replicaGibbsMass β J S := by
  classical
  refine (FiniteLaw.prob_exists _ _).trans ?_
  calc
    _ ≤ ∑ _v : I × I × I × (Fin 3 → Bool), replicaGibbsMass β J S := by
      apply Finset.sum_le_sum
      rintro ⟨a,b,c,ε⟩ _
      by_cases h : level a≠level b ∧ level a≠level c ∧ level b≠level c
      · refine (FiniteLaw.prob_mono _ (fun z hz => hz.2)).trans ?_
        exact (bank_triple_oriented β J a b c
          (fun he => h.1 (congrArg level he)) (fun he => h.2.1 (congrArg level he)) (fun he => h.2.2 (congrArg level he))
          (ε 0) (ε 1) (ε 2) S).le
      · simp only [h,false_and,FiniteLaw.prob_false]
        exact replicaGibbsMass_nonneg β J S
    _ = _ := by simp only [Finset.sum_const,Finset.card_univ,Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,Fintype.card_bool,nsmul_eq_mul,Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat]; ring

theorem expected_bankVertexBad {n : ℕ} {I : Type*} [Fintype I] [DecidableEq I]
    (β : ℝ) (J : Disorder n) (level : I → ℕ) (S : Finset (ReplicaConfig n 3)) :
    ((gibbsFiniteLaw β J).iid I).expect (fun z => (gibbsFiniteLaw β J).prob (bankVertexBad level S z)) ≤
      48*(Fintype.card I:ℝ)^2*replicaGibbsMass β J S := by
  classical
  refine (FiniteLaw.expect_prob_exists_le _ _ _).trans ?_
  calc
    _ ≤ ∑ _v : I × I × (Fin 3 → Bool) × Equiv.Perm (Fin 3), replicaGibbsMass β J S := by
      apply Finset.sum_le_sum
      rintro ⟨a,b,ε,e⟩ _
      by_cases h : level a≠level b
      · refine ((gibbsFiniteLaw β J).iid I).expect_mono (fun z => (gibbsFiniteLaw β J).prob_mono (fun x hx => hx.2)) |>.trans ?_
        exact (bank_pair_vertex_permuted β J a b (fun he => h (congrArg level he)) ε e S).le
      · simp only [h,false_and,FiniteLaw.prob_false,FiniteLaw.expect_const]
        exact replicaGibbsMass_nonneg β J S
    _ = _ := by simp only [Finset.sum_const,Finset.card_univ,Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,Fintype.card_bool,Fintype.card_perm,nsmul_eq_mul,Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat]; norm_num [Nat.factorial]; ring_nf; simp

theorem exists_fixed_good_bank {n p : ℕ} (β : ℝ) (J : Disorder n) (K : Fin p → ℕ)
    (pred : Fin p → Finset (Fin p)) (hpred : ∀ j, j∉pred j) (t q : ℝ) (a δ : Fin p → ℝ)
    (ha : ∀ j,0≤a j) (S : Finset (ReplicaConfig n 3))
    (hcov : ∀ j, ∀ w : BankPrior pred j → Config n,
      (gibbsFiniteLaw β J).prob (fun x => (∀i,|overlap (w i) x|≤3*t) ∧
        (gibbsFiniteLaw β J).prob (fun y => (∀i,|overlap (w i) y|≤3*t) ∧ q≤|overlap x y|)<a j)≤δ j)
    (E : ℝ)
    (hE : (8*(Fintype.card (BankIndex K):ℝ)^3+48*(Fintype.card (BankIndex K):ℝ)^2)*replicaGibbsMass β J S+
      (∑ j, Fintype.card (BankTuple K pred j)*(δ j+Real.exp (-(a j)*(K j)))) ≤ E)
    (hE1 : E<1) :
    ∃ z : BankIndex K → Config n,
      ¬bankTripleBad (fun i : BankIndex K => i.1.val) S z ∧
      (gibbsFiniteLaw β J).prob (fun x => bankCoverageBad K pred t q z x ∨
        bankVertexBad (fun i : BankIndex K => i.1.val) S z x) ≤ E := by
  classical
  let P := gibbsFiniteLaw β J
  let Q := P.iid (BankIndex K)
  let level (i : BankIndex K) := i.1.val
  let V (z : BankIndex K → Config n) (x : Config n) := bankCoverageBad K pred t q z x ∨ bankVertexBad level S z x
  let f (z : BankIndex K → Config n) : ℝ := (if bankTripleBad level S z then 1 else 0)+P.prob (V z)
  have H : Q.expect f ≤ E := by
    rw [show Q.expect f=Q.prob (bankTripleBad level S)+Q.expect (fun z => P.prob (V z)) from by
      dsimp only [f]; rw [FiniteLaw.expect_add,FiniteLaw.expect_indicator_eq_prob]]
    have HV : Q.expect (fun z => P.prob (V z)) ≤
        Q.expect (fun z => P.prob (bankCoverageBad K pred t q z))+Q.expect (fun z => P.prob (bankVertexBad level S z)) := by
      rw [← FiniteLaw.expect_add]
      exact Q.expect_mono (fun z => P.prob_or _ _)
    have HC := expected_bank_coverage_bad P K pred hpred t q a δ ha hcov
    have HT := bankTripleBad_prob β J level S
    have HB := expected_bankVertexBad β J level S
    dsimp only [P,Q] at HC HV ⊢
    nlinarith only [HV,HC,HT,HB,hE]
  obtain ⟨z,hz⟩ := Q.exists_le_expect f
  have hzE : f z≤E := hz.trans H
  have hnot : ¬bankTripleBad level S z := by
    intro hbad
    have H0 := P.prob_nonneg (V z)
    simp only [f,ite_eq_left hbad] at hzE
    linarith only [hzE,hE1,H0]
  refine ⟨z,hnot,?_⟩
  simpa only [f,ite_eq_right hnot,zero_add] using hzE

end SK.Analytic

end
end

end OAI