import OAI.Probability.SATComputability.IncidentRates
import OAI.Probability.SATComputability.GridBlockLaw

namespace OAI

namespace FixedClauseThreshold.Computability

open DilutedSpinGlass _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
open scoped BigOperators Classical NNReal

noncomputable def activeMask {n : ℕ} (a : ActiveClause n) : Finset (DeletionCandidate (n+1)) :=
  clauseMask (classClause (activeClass a))

noncomputable def baseMask {n : ℕ} (a : Triple (SignedLiteral n)) : Finset (DeletionCandidate n) :=
  clauseMask ((tripleVectorEquiv _).symm a)

theorem active_base_counts {n : ℕ} (c : ActiveClause n → ℕ) :
    countsMask (fun a => classBaseMask (activeClass a)) c =
      countsMask baseMask (fun a => c (.inl a)) := by
  ext x
  simp [countsMask, classBaseMask, activeClass, baseMask, Sum.forall, Prod.forall]

theorem active_mask_counts {n : ℕ} (c : ActiveClause n → ℕ) :
    countsMask activeMask c = restoredMask
      (countsMask baseMask (fun a => c (.inl a)))
      (countsMask (fun a => classIncidentMask false (activeClass a)) c)
      (countsMask (fun a => classIncidentMask true (activeClass a)) c) := by
  rw [← active_base_counts, ← countsMask_restored]
  congr 1
  funext a
  exact classClause_restored (activeClass a)

theorem active_free_lifetime {n M r : ℕ} (c : ActiveClause n × Fin M → ℕ) :
    maskLifetime M (freeDeletionBudgetMask (n+1) r 0) (maskGrid activeMask c) =
      maskLifetime M (deletionBudgetMask n r) (maskGrid baseMask (fun p => c (.inl p.1,p.2))) := by
  have he : maskGrid activeMask c = fun j => restoredMask
      (countsMask baseMask (fun a => c (.inl a,j)))
      (countsMask (fun a => classIncidentMask false (activeClass a)) (fun a => c (a,j)))
      (countsMask (fun a => classIncidentMask true (activeClass a)) (fun a => c (a,j))) := by
    funext j
    exact active_mask_counts _
  rw [he, free_restored_lifetime]
  rfl

theorem active_stronger_counts {n : ℕ} (c : ActiveClause n → ℕ) :
    countsMask strongerClassMask c = restoredMask
      (countsMask baseMask (fun a => c (.inl a)))
      (countsMask incidentMask (fun a => c (.inr (true,a))))
      (countsMask incidentMask (fun a => c (.inr (false,a)))) :=
  countsMask_stronger c

theorem active_gap_domination {n M r : ℕ} (c : ActiveClause n × Fin M → ℕ) :
    (maskLifetime M (freeDeletionBudgetMask (n+1) r 0) (maskGrid activeMask c) -
      maskLifetime M (deletionBudgetMask (n+1) r) (maskGrid activeMask c))^(6/5 : ℝ) ≤
    (maskLifetime M (deletionBudgetMask n r) (maskGrid baseMask (fun p => c (.inl p.1,p.2))) -
      maskLifetime M (deletionBudgetMask (n+1) r) (fun j => restoredMask
        (countsMask baseMask (fun a => c (.inl a,j)))
        (countsMask incidentMask (fun a => c (.inr (true,a),j)))
        (countsMask incidentMask (fun a => c (.inr (false,a),j)))))^(6/5 : ℝ) := by
  have hnon : 0 ≤ maskLifetime M (freeDeletionBudgetMask (n+1) r 0) (maskGrid activeMask c) -
      maskLifetime M (deletionBudgetMask (n+1) r) (maskGrid activeMask c) :=
    sub_nonneg.mpr (maskLifetime_mono (deletionBudgetMask_subset_free (n+1) r 0) _)
  rw [active_free_lifetime] at hnon ⊢
  apply Real.rpow_le_rpow hnon _ (by norm_num : (0 : ℝ) ≤ 6/5)
  apply sub_le_sub_left
  apply maskLifetime_map_le id _ _ _ _ (fun _ h => h)
  intro j x hx
  have he := active_stronger_counts (fun a => c (a,j))
  rw [← he] at hx
  exact countsMask_mono (fun a => strongerClassMask_subset a) _ hx

theorem poissonCountLaw_three {A B C : Type*} [Fintype A] [Fintype B] [Fintype C]
    (r : ℝ≥0) (f : (A → ℕ) → (B → ℕ) → (C → ℕ) → ℝ)
    (D : ℝ) (hD : ∀ a b c, |f a b c| ≤ D) :
    (∫ s : A ⊕ (B ⊕ C) → ℕ,
      f (fun a => s (.inl a)) (fun b => s (.inr (.inl b))) (fun c => s (.inr (.inr c)))
      ∂poissonCountLaw (A ⊕ (B ⊕ C)) r) =
      ∫ a, ∫ b, ∫ c, f a b c ∂poissonCountLaw C r
        ∂poissonCountLaw B r ∂poissonCountLaw A r := by
  rw [poissonCountLaw_sum r _ D (fun s => hD _ _ _)]
  apply integral_congr_ae
  filter_upwards [] with a
  exact poissonCountLaw_sum r _ D (fun _ => hD _ _ _)

theorem active_streams_expect {n M : ℕ} (r : ℝ≥0)
    (ψ : (Fin M → Finset (DeletionCandidate n)) →
      (Fin M → Finset (DeletionCandidate n)) → (Fin M → Finset (DeletionCandidate n)) → ℝ) :
    (∫ c : ActiveClause n × Fin M → ℕ,
      ψ (maskGrid baseMask (fun p => c (.inl p.1,p.2)))
        (maskGrid incidentMask (fun p => c (.inr (true,p.1),p.2)))
        (maskGrid incidentMask (fun p => c (.inr (false,p.1),p.2)))
      ∂poissonCountLaw (ActiveClause n × Fin M) r) =
      (gridMaskLaw M r baseMask).expect (fun b =>
        (gridMaskLaw M r incidentMask).expect (fun f =>
          (gridMaskLaw M r incidentMask).expect (fun t => ψ b f t))) := by
  let X := Fin M → Finset (DeletionCandidate n)
  let D := ∑ p : X × X × X, |ψ p.1 p.2.1 p.2.2|
  have hD (b f t : X) : |ψ b f t| ≤ D :=
    Finset.single_le_sum (fun p _ => abs_nonneg (ψ p.1 p.2.1 p.2.2))
      (Finset.mem_univ (b,f,t))
  have he := poissonCountLaw_equiv (splitActiveGrid n M) r
    (fun s => ψ (maskGrid baseMask (fun p => s (.inl p)))
      (maskGrid incidentMask (fun p => s (.inr (.inr p))))
      (maskGrid incidentMask (fun p => s (.inr (.inl p)))))
  change (∫ c : ActiveClause n × Fin M → ℕ,
      ψ (maskGrid baseMask (fun p => c (.inl p.1,p.2)))
        (maskGrid incidentMask (fun p => c (.inr (true,p.1),p.2)))
        (maskGrid incidentMask (fun p => c (.inr (false,p.1),p.2)))
      ∂poissonCountLaw (ActiveClause n × Fin M) r) = _ at he
  rw [he, poissonCountLaw_three r
    (fun (b : Triple (SignedLiteral n) × Fin M → ℕ)
      (f t : IncidentClass n × Fin M → ℕ) =>
        ψ (maskGrid baseMask b) (maskGrid incidentMask t) (maskGrid incidentMask f))
    D (fun a b c => hD _ _ _)]
  have hi (b : Triple (SignedLiteral n) × Fin M → ℕ)
      (f : IncidentClass n × Fin M → ℕ) :
      (∫ t, ψ (maskGrid baseMask b) (maskGrid incidentMask t) (maskGrid incidentMask f)
        ∂poissonCountLaw (IncidentClass n × Fin M) r) =
        (gridMaskLaw M r incidentMask).expect
          (fun t => ψ (maskGrid baseMask b) t (maskGrid incidentMask f)) :=
    (gridMaskLaw_expect r incidentMask
      (fun t => ψ (maskGrid baseMask b) t (maskGrid incidentMask f))).symm
  simp_rw [hi]
  have hm (b : Triple (SignedLiteral n) × Fin M → ℕ) :
      (∫ f, (gridMaskLaw M r incidentMask).expect
        (fun t => ψ (maskGrid baseMask b) t (maskGrid incidentMask f))
        ∂poissonCountLaw (IncidentClass n × Fin M) r) =
      (gridMaskLaw M r incidentMask).expect (fun f =>
        (gridMaskLaw M r incidentMask).expect (fun t => ψ (maskGrid baseMask b) t f)) :=
    (gridMaskLaw_expect r incidentMask (fun f =>
      (gridMaskLaw M r incidentMask).expect (fun t => ψ (maskGrid baseMask b) t f))).symm
  simp_rw [hm]
  rw [← gridMaskLaw_expect r baseMask (fun b =>
    (gridMaskLaw M r incidentMask).expect (fun f =>
      (gridMaskLaw M r incidentMask).expect (fun t => ψ b t f)))]
  apply FiniteLaw.expect_congr
  intro b
  exact finite_expect_comm _ _ _

theorem active_original_expect {n M : ℕ} (r : ℝ≥0)
    (ψ : (Fin M → Finset (DeletionCandidate (n+1))) → ℝ) :
    (∫ c : TripleClasses (SignedLiteral n) × Fin M → ℕ,
      ψ (maskGrid (fun a => clauseMask (classClause a)) c)
      ∂poissonCountLaw (TripleClasses (SignedLiteral n) × Fin M) r) =
    ∫ c : ActiveClause n × Fin M → ℕ, ψ (maskGrid activeMask c)
      ∂poissonCountLaw (ActiveClause n × Fin M) r := by
  let e : ActiveClause n × Fin M → TripleClasses (SignedLiteral n) × Fin M :=
    fun p => (activeClass p.1,p.2)
  have he : Function.Injective e := by
    intro p q h
    change (activeClass p.1,p.2) = (activeClass q.1,q.2) at h
    exact Prod.ext (activeClass_injective n (Prod.mk.inj h).1) (Prod.mk.inj h).2
  rw [← poissonCountLaw_embedding_integral e he r]
  apply integral_congr_ae
  filter_upwards [] with c
  congr 1
  funext j
  exact (countsMask_active (fun a => c (a,j))).symm

theorem base_grid_law {n : ℕ} [NeZero n] (M : ℕ) (r : ℝ≥0) :
    gridMaskLaw M r (baseMask (n := n)) = FiniteLaw.pi (fun _ : Fin M =>
      candidateBlock (r*Fintype.card (Triple (SignedLiteral n))) 3 Finset.univ) := by
  rw [← gridMaskLaw_equiv (tripleVectorEquiv (SignedLiteral n)) r baseMask]
  have hm : baseMask ∘ tripleVectorEquiv (SignedLiteral n) = clauseMask := by
    funext a
    simp only [baseMask, Function.comp_apply, Equiv.symm_apply_apply]
  rw [hm, gridMaskLaw_clauses]
  rw [Fintype.card_congr (tripleVectorEquiv (SignedLiteral n))]

end FixedClauseThreshold.Computability

end OAI