import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.GuardProbability

namespace OAI

namespace MatchingFPRAS.FiniteTrial
open Transport Enlargement Variation Adaptive Amplification Finset
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 _

noncomputable def guardBits (p : Trial.Parameters G) : ℕ := 16*oneBits p
noncomputable def ScaleState.drawGuard (p : Trial.Parameters G) (s : ScaleState G p.K) :
    (Fin (guardBits p) → Bool) → GuardSamples p s :=
  (fun b i=>s.drawOne p le_rfl (b i)) ∘ matrixBitsEquiv 16 (oneBits p)
lemma ScaleState.drawGuard_law (p : Trial.Parameters G) (s : ScaleState G p.K) :
    imageLaw (s.drawGuard p)=(guardLaw p s).mass := by
  unfold ScaleState.drawGuard
  erw [imageLaw_comp_equiv,imageLaw_componentwise]
  rw [ScaleState.drawOne_law]
  rfl
lemma ScaleState.drawGuard_no_certificate (p : Trial.Parameters G) (s : ScaleState G p.K)
    (hZ : Z G = 0) (b : Fin (guardBits p) → Bool) : ¬guardPass p s (s.drawGuard p b) := by
  dsimp only [guardBits] at b
  dsimp only [guardPass, ScaleState.drawGuard, guardBits, Function.comp_apply]
  simp only [s.drawOne_certificate_zero p le_rfl hZ, lt_self_iff_false, exists_const, not_false_eq_true]

noncomputable def guardedBits (p : Trial.Parameters G) : ℕ := p.K*stageBits p+guardBits p
noncomputable def drawGuarded (p : Trial.Parameters G) :
    (Fin (guardedBits p) → Bool) → GuardedTrial p :=
  fun b =>
    let c := pairBitsEquiv (p.K*stageBits p) (guardBits p) b
    let x := drawLayer p p.K le_rfl c.1
    ⟨x,((layers p p.K le_rfl).state x).drawGuard p c.2⟩
lemma drawGuarded_law (p : Trial.Parameters G) : imageLaw (drawGuarded p)=(guardedLaw p).mass := by
  change imageLaw ((fun c : (Fin (p.K*stageBits p) → Bool) × (Fin (guardBits p) → Bool) =>
    (⟨drawLayer p p.K le_rfl c.1,
      ((layers p p.K le_rfl).state (drawLayer p p.K le_rfl c.1)).drawGuard p c.2⟩ : GuardedTrial p)) ∘
    pairBitsEquiv (p.K*stageBits p) (guardBits p)) = _
  erw [imageLaw_comp_equiv]
  change imageLaw _ = sigmaLift (layers p p.K le_rfl).law.mass (fun x=>(guardLaw p ((layers p p.K le_rfl).state x)).mass)
  rw [imageLaw_sigma_pair (drawLayer p p.K le_rfl) (fun x=>((layers p p.K le_rfl).state x).drawGuard p)]
  simp_rw [ScaleState.drawGuard_law]
  rw [drawLayer_law]
noncomputable def guardedBitOutput (p : Trial.Parameters G) : (Fin (guardedBits p) → Bool) → ℚ :=
  guardedOutput p ∘ drawGuarded p
lemma guardedBitOutput_nonneg (p : Trial.Parameters G) (b : Fin (guardedBits p) → Bool) :
    0≤guardedBitOutput p b := guardedOutput_nonneg p _
theorem guardedBitOutput_zero (p : Trial.Parameters G) (hZ : Z G=0) (b : Fin (guardedBits p) → Bool) :
    guardedBitOutput p b=0 := by
  unfold guardedBitOutput drawGuarded
  simp only [Function.comp_apply, guardedOutput]
  exact ite_eq_right (ScaleState.drawGuard_no_certificate p _ hZ _)

noncomputable def guardedAmplifiedBits (p : Trial.Parameters G) (δ : ℚ) : ℕ :=
  (2*halfRepetitions δ+1)*guardedBits p
noncomputable def drawGuardedTrials (p : Trial.Parameters G) (δ : ℚ) :
    (Fin (guardedAmplifiedBits p δ) → Bool) → Fin (2*halfRepetitions δ+1) → GuardedTrial p :=
  (fun bits i=>drawGuarded p (bits i)) ∘ matrixBitsEquiv (2*halfRepetitions δ+1) (guardedBits p)
lemma drawGuardedTrials_law (p : Trial.Parameters G) (δ : ℚ) :
    imageLaw (drawGuardedTrials p δ)=((guardedLaw p).iid (2*halfRepetitions δ+1)).mass := by
  unfold drawGuardedTrials
  erw [imageLaw_comp_equiv,imageLaw_componentwise]
  rw [drawGuarded_law]
  rfl
noncomputable def guardedAmplifiedOutput (p : Trial.Parameters G) (δ : ℚ)
    (x : Fin (2*halfRepetitions δ+1) → GuardedTrial p) : ℚ := median (fun i=>guardedOutput p (x i))
noncomputable def guardedAmplifiedBitOutput (p : Trial.Parameters G) (δ : ℚ) :
    (Fin (guardedAmplifiedBits p δ) → Bool) → ℚ := guardedAmplifiedOutput p δ ∘ drawGuardedTrials p δ
lemma guardedAmplifiedBitOutput_nonneg (p : Trial.Parameters G) (δ : ℚ)
    (b : Fin (guardedAmplifiedBits p δ) → Bool) : 0≤guardedAmplifiedBitOutput p δ b :=
  median_nonneg _ (fun _=>guardedOutput_nonneg p _)

omit [Nontrivial (Fin G.n)] in
lemma median_eq_of_constant {k : ℕ} (x : Fin (2*k+1) → ℚ) (a : ℚ) (hx : ∀ i,x i=a) : median x=a := by
  unfold median sortedValue
  have hp := List.mergeSort_perm (List.ofFn x) (· ≤ ·)
  have hm : (sortedList x)[k]'(by rw [sortedList_length]; omega) ∈ List.ofFn x :=
    hp.mem_iff.mp (List.getElem_mem _)
  obtain ⟨i,hi⟩ := List.mem_ofFn.mp hm
  rw [←hi, hx]

theorem guardedAmplifiedBitOutput_zero (p : Trial.Parameters G) (hZ : Z G=0) (δ : ℚ)
    (b : Fin (guardedAmplifiedBits p δ) → Bool) : guardedAmplifiedBitOutput p δ b=0 := by
  apply median_eq_of_constant
  intro i
  exact guardedBitOutput_zero p hZ _

noncomputable def guardedAccurateBits (p : Trial.Parameters G) (δ : ℚ) : Finset (Fin (guardedAmplifiedBits p δ) → Bool) :=
  univ.filter fun b=>Accurate p (guardedAmplifiedBitOutput p δ b)
theorem guardedAmplifiedBitOutput_success (p : Trial.Parameters G) (hZ : 0<Z G) (δ : ℚ) (hδ : 0<δ) :
    ((guardedAccurateBits p δ).card:ℚ)/(2:ℚ)^(guardedAmplifiedBits p δ)≥1-δ := by
  have hf := median_delta (guardedLaw p) (guardedOutput p) ((1-p.epsilon)*(Z G:ℚ))
    ((1+p.epsilon)*(Z G:ℚ)) (guarded_trial_failure p hZ) δ hδ
  have hc:=event_complement ((guardedLaw p).iid (2*halfRepetitions δ+1)).mass
    (fun x=>Accurate p (guardedAmplifiedOutput p δ x))
  rw [Law.total] at hc
  have hh : 1-(δ:ℝ) ≤ event ((guardedLaw p).iid (2*halfRepetitions δ+1)).mass
      (fun x=>Accurate p (guardedAmplifiedOutput p δ x)) := by
    change event _ (fun x=>¬Accurate p (guardedAmplifiedOutput p δ x))≤(δ:ℝ) at hf
    linarith only [hc,hf]
  rw [←drawGuardedTrials_law,event_imageLaw] at hh
  have he : Fintype.card (Fin (guardedAmplifiedBits p δ) → Bool)=2^(guardedAmplifiedBits p δ) := by simp
  rw [he] at hh
  change 1-(δ:ℝ) ≤ ((guardedAccurateBits p δ).card:ℝ)/(2^(guardedAmplifiedBits p δ):ℕ) at hh
  have hr : ((1-δ:ℚ):ℝ) ≤ (((((guardedAccurateBits p δ).card:ℚ)/(2:ℚ)^(guardedAmplifiedBits p δ)):ℚ):ℝ) := by
    push_cast
    simpa only [Nat.cast_pow,Nat.cast_ofNat] using hh
  exact Rat.cast_le.mp hr

end MatchingFPRAS.FiniteTrial

end OAI