import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.Guard

namespace OAI

namespace MatchingFPRAS.FiniteTrial
open Finset Switching Transport Enlargement Adaptive Variation
open scoped Classical

variable {G : GraphInput} [Nontrivial (Fin G.n)]
attribute [local instance] NumberedHierarchy.labelOrder sym2Order bagEdgeOrder bagEdgeFintype
attribute [local instance] UnitRefresh.Computable.allowedDec prodOrder sumOrder
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    DecidableEq (SourceLabel (fun x y=>(w x y:ℝ)) K) := Classical.decEq _
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    Fintype (BagEdge (sourceBags (fun x y=>(w x y:ℝ)) K)) := Fintype.ofFinite _
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    Fintype (SourceMarked (fun x y=>(w x y:ℝ)) K) := Fintype.ofFinite _

def ScaleState.certificateActivity {j : ℕ} (s : ScaleState G j) : Fin G.n → Fin G.n → ℚ :=
  fun a b => (if (min a b,max a b) ∈ G.edges then 1 else 0) * s.scale a * s.scale b
omit [Nontrivial (Fin G.n)] in
lemma ScaleState.certificateActivity_cast [Nontrivial (Fin G.n)] {j : ℕ} (s : ScaleState G j) :
    (fun a b => (s.certificateActivity a b : ℝ)) = s.toReal.certificateActivity := by
  funext a b
  unfold ScaleState.certificateActivity Trial.ScaleState.certificateActivity GraphBridge.rawActivity
  split_ifs <;> simp [ScaleState.toReal]

noncomputable def ScaleState.certificate {j : ℕ} (s : ScaleState G j) (K : ℕ)
    (a : SourceMarked (fun x y => (s.activity x y : ℝ)) K) : ℚ :=
  RationalSource.observableD s.activity s.certificateActivity K (RationalSource.sourceMarkedEquiv s.activity K a)

lemma ScaleState.certificate_cast {j : ℕ} (s : ScaleState G j) (K : ℕ)
    (a : SourceMarked (fun x y => (s.activity x y : ℝ)) K) :
    (s.certificate K a : ℝ) = observableD (fun x y => (s.activity x y : ℝ))
      (fun x y => (s.certificateActivity x y : ℝ)) K a :=
  RationalSource.observableD_cast _ _ _ _

lemma ScaleState.certificate_range {j : ℕ} (s : ScaleState G j) (K : ℕ)
    (a : SourceMarked (fun x y => (s.activity x y : ℝ)) K) :
    0 ≤ s.certificate K a ∧ s.certificate K a ≤ 1 := by
  have h : 0 ≤ (s.certificate K a : ℝ) ∧ (s.certificate K a : ℝ) ≤ 1 := by
    rw [s.certificate_cast]
    apply observableD_range _ _ (fun x y => by exact_mod_cast s.activity_pos x y)
    · intro x y
      have hc := s.toReal.certificateActivity_nonneg x y
      rw [←s.certificateActivity_cast] at hc
      exact hc
    · intro x y
      have hc := s.toReal.certificateActivity_le x y
      rw [←s.certificateActivity_cast, ←s.activity_cast] at hc
      exact hc
  exact_mod_cast h

theorem ScaleState.drawOne_certificate_zero (p : Trial.Parameters G) {j : ℕ}
    (hj : j ≤ p.K) (s : ScaleState G j) (hZ : Z G = 0) (b : Fin (oneBits p) → Bool) :
    s.certificate p.K (s.drawOne p hj b) = 0 := by
  have hs : 0 < sourceLaw (fun x y => (s.activity x y : ℝ)) p.K p.D (s.drawOne p hj b) :=
    RationalSource.fixedSampler_support _ _ _ _ _ _ _ _ _ _ _ _
  have hc := s.toReal.certificate_zero (K:=p.K) p.even hZ p.D
  rw [←s.activity_cast, ←s.certificateActivity_cast] at hc
  have hh := hc (s.drawOne p hj b) hs
  rw [←s.certificate_cast] at hh
  exact_mod_cast hh

lemma ScaleState.certificate_mean_lower (p : Trial.Parameters G) (s : ScaleState G p.K)
    (hs : s.Balanced p.hn) (hZ : 0 < Z G) :
    (1:ℝ)/4 ≤ ∑ a : SourceMarked (fun x y => (s.activity x y : ℝ)) p.K,
      sourceLaw (fun x y => (s.activity x y : ℝ)) p.K p.D a * (s.certificate p.K a : ℝ) := by
  have h := s.toReal.certificate_mean_lower p hs hZ
  rw [←s.activity_cast, ←s.certificateActivity_cast] at h
  simp_rw [←s.certificate_cast] at h
  convert h using 1
  exact Variation.sum_instances _ _ _

lemma ScaleState.runLaw_tv (p : Trial.Parameters G) {j : ℕ} (hj : j ≤ p.K) (s : ScaleState G j) :
    tv (s.runLaw p hj).mass (sourceLaw (fun x y => (s.activity x y : ℝ)) p.K p.D) ≤
      3/(1000*p.K*p.S) := by
  have hN : 2 ≤ Fintype.card (SourceVertex (Fin G.n) p.K) := by
    have h := sourceVertex_card_ge (V:=Fin G.n) p.K
    simp only [Fintype.card_fin] at h
    have hn := p.hn
    omega
  have h := RationalSource.finiteSourceLaw_tv s.activity s.activity_pos p.K p.D
    (1000*p.K*p.S) (sourceD_one p.K) hN (RationalSource.sampling_denominator_gt _ _ p.K_pos p.S_pos)
    (s.cap hj) p.q_pos (RationalSource.startMatching _ _ p.even) (1/(1000*p.K*p.S)) (by have := p.K_pos; have := p.S_pos; positivity)
  rw [RationalSource.sampling_budget _ _ p.K_pos p.S_pos] at h
  convert h using 1
  exact tv_instances _ _ _ _

theorem ScaleState.guard_success (p : Trial.Parameters G) (s : ScaleState G p.K)
    (hs : s.Balanced p.hn) (hZ : 0 < Z G) :
    (1:ℝ)/5 ≤ (s.runLaw p le_rfl).event (fun a => 0 < s.certificate p.K a) := by
  let q := sourceLaw (fun x y => (s.activity x y : ℝ)) p.K p.D
  have hz : 0 < sourceBagZ (fun x y => (s.activity x y : ℝ)) p.K p.D := by
    rw [s.activity_cast]
    exact sourceBagZ_pos _ s.toReal.activity_pos (s.toReal.partition_pos p.even) _ _
  have hq0 : ∀ a, 0 ≤ q a := sourceLaw_nonneg _ (fun x y => by exact_mod_cast s.activity_pos x y) _ _ hz.le
  have hq1 : ∑ a, q a = 1 := by
    convert sourceLaw_sum (fun x y => (s.activity x y : ℝ)) p.K p.D hz.ne' using 1
    exact Variation.sum_instances _ _ _
  have hm := (s.certificate_mean_lower p hs hZ).trans
    (mean_le_positive_event q (fun a => (s.certificate p.K a : ℝ)) hq0
      (fun a => by exact_mod_cast s.certificate_range p.K a))
  have hev : event q (fun a => 0 < (s.certificate p.K a : ℝ)) =
      event q (fun a => 0 < s.certificate p.K a) := by
    congr 1
    ext a
    exact_mod_cast Iff.rfl
  rw [hev] at hm
  have hd := event_sub_le (s.runLaw p le_rfl).mass q ((s.runLaw p le_rfl).total.trans hq1.symm)
    (fun a => 0 < s.certificate p.K a)
  have ht := s.runLaw_tv p le_rfl
  have hk : (1:ℝ) ≤ p.K := by exact_mod_cast p.K_pos
  have hS : (1:ℝ) ≤ p.S := by exact_mod_cast p.S_pos
  have hc : 3/(1000*(p.K:ℝ)*p.S) ≤ (3:ℝ)/1000 := by
    apply (div_le_div_iff₀ (by positivity) (by norm_num)).mpr
    nlinarith [mul_le_mul hk hS (by norm_num) (by positivity)]
  have hh := (abs_sub_le_iff.mp hd).2
  change 1/5 ≤ event (s.runLaw p le_rfl).mass (fun a => 0 < s.certificate p.K a)
  dsimp only [q] at *
  linarith

end MatchingFPRAS.FiniteTrial

namespace MatchingFPRAS.Adaptive
open Finset
open scoped Classical

variable {Ω : Type*} [Fintype Ω]

lemma Law.iid_all (μ : Law Ω) (r : ℕ) (P : Ω → Prop) :
    (μ.iid r).event (fun x => ∀ i, P (x i)) = (μ.event P)^r := by
  unfold Law.event Law.iid Variation.iid
  calc
    _ = ∑ x : Fin r → Ω, ∏ i, if P (x i) then μ (x i) else 0 := by
      apply sum_congr rfl
      intro x _
      by_cases hx : ∀ i, P (x i)
      · simp [hx]
      · obtain ⟨i, hi⟩ := not_forall.mp hx
        simp only [hx, ite_false]
        symm
        apply prod_eq_zero (mem_univ i)
        simp [hi]
    _ = ∏ _ : Fin r, (∑ x, if P x then μ x else 0) := by
      convert (Fintype.prod_sum (fun (_ : Fin r) (x : Ω) => if P x then μ x else 0)).symm using 1
    _ = _ := by simp

lemma Law.iid_no_certificate (μ : Law Ω) (P : Ω → Prop) (hP : (1:ℝ)/5 ≤ μ.event P) :
    (μ.iid 16).event (fun x => ¬∃ i, P (x i)) ≤ 1/16 := by
  have hc : μ.event (fun x => ¬P x) ≤ 4/5 := by
    have h := Variation.event_complement μ.mass P
    change μ.event P + μ.event (fun x => ¬P x) = ∑ x, μ.mass x at h
    rw [μ.total] at h
    linarith
  have he : (fun x : Fin 16 → Ω => ¬∃ i, P (x i)) = (fun x => ∀ i, ¬P (x i)) := by
    funext x
    simp
  rw [he]
  have hi := μ.iid_all 16 (fun x => ¬P x)
  change Variation.event _ _ = _ at hi
  have hie : (μ.iid 16).event (fun x => ∀ i, ¬P (x i)) = (μ.event (fun x => ¬P x))^16 := by
    convert hi using 1
    exact Variation.sum_instances _ _ _
  rw [hie]
  calc
    _ ≤ (4/5:ℝ)^16 := pow_le_pow_left₀ (μ.event_nonneg _) hc _
    _ ≤ 1/16 := by norm_num

end MatchingFPRAS.Adaptive

namespace MatchingFPRAS.FiniteTrial
open Finset Switching Transport Enlargement Adaptive Variation
open scoped Classical

variable {G : GraphInput} [Nontrivial (Fin G.n)]
attribute [local instance] NumberedHierarchy.labelOrder sym2Order bagEdgeOrder bagEdgeFintype
attribute [local instance] UnitRefresh.Computable.allowedDec prodOrder sumOrder
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    DecidableEq (SourceLabel (fun x y=>(w x y:ℝ)) K) := Classical.decEq _
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    Fintype (BagEdge (sourceBags (fun x y=>(w x y:ℝ)) K)) := Fintype.ofFinite _
noncomputable local instance (w : Fin G.n → Fin G.n → ℚ) (K : ℕ) :
    Fintype (SourceMarked (fun x y=>(w x y:ℝ)) K) := Fintype.ofFinite _

abbrev GuardSamples (p : Trial.Parameters G) (s : ScaleState G p.K) :=
  Fin 16 → SourceMarked (fun x y => (s.activity x y : ℝ)) p.K
noncomputable def guardPass (p : Trial.Parameters G) (s : ScaleState G p.K) (x : GuardSamples p s) : Prop :=
  ∃ i, 0 < s.certificate p.K (x i)
noncomputable def guardLaw (p : Trial.Parameters G) (s : ScaleState G p.K) : Law (GuardSamples p s) :=
  (s.runLaw p le_rfl).iid 16
lemma guard_failure (p : Trial.Parameters G) (s : ScaleState G p.K)
    (hs : s.Balanced p.hn) (hZ : 0 < Z G) :
    (guardLaw p s).event (fun x => ¬guardPass p s x) ≤ 1/16 := by
  have h := (s.runLaw p le_rfl).iid_no_certificate
    (fun x => 0 < s.certificate p.K x) (s.guard_success p hs hZ)
  exact h

abbrev GuardedTrial (p : Trial.Parameters G) :=
  Σ x : (layers p p.K le_rfl).Ω, GuardSamples p ((layers p p.K le_rfl).state x)
noncomputable def guardedLaw (p : Trial.Parameters G) : Law (GuardedTrial p) :=
  (layers p p.K le_rfl).law.sigma (fun x => guardLaw p ((layers p p.K le_rfl).state x))
noncomputable def guardedOutput (p : Trial.Parameters G) (x : GuardedTrial p) : ℚ :=
  if guardPass p ((layers p p.K le_rfl).state x.1) x.2 then output p x.1 else 0
lemma guardedOutput_nonneg (p : Trial.Parameters G) (x : GuardedTrial p) : 0 ≤ guardedOutput p x := by
  unfold guardedOutput
  split_ifs
  · exact output_nonneg _ _
  · rfl

theorem guarded_trial_failure (p : Trial.Parameters G) (hZ : 0 < Z G) :
    (guardedLaw p).event (fun x => ¬Accurate p (guardedOutput p x)) ≤ 1/10 := by
  have hf := first_failure_sigma (layers p p.K le_rfl).law
    (fun x => guardLaw p ((layers p p.K le_rfl).state x))
    ((layers p p.K le_rfl).good p) (fun x => Accurate p (guardedOutput p x)) (1/16) (by norm_num)
    (fun x hx => ((guardLaw p ((layers p p.K le_rfl).state x)).event_mono
      (fun y hy hp => by
        apply hy
        simp only [guardedOutput, hp, ite_true]
        exact good_output p hZ x hx)).trans (guard_failure p _ hx.1 hZ))
  have hb := layers_failure p p.K le_rfl
  have hk : (p.K:ℝ) ≠ 0 := by exact_mod_cast p.K_pos.ne'
  have he : (p.K:ℝ) * (13/(1000*p.K)) = 13/1000 := by field_simp
  rw [he] at hb
  change (guardedLaw p).event _ ≤ _ at hf
  linarith

end MatchingFPRAS.FiniteTrial

end OAI