lean/OAI/Combinatorics/MatchingCount/Algorithm/AlgorithmLaw.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.Algorithm
import OAI.Combinatorics.MatchingCount.Complexity.OnlineHistoryCost

namespace OAI

namespace MatchingFPRAS.PhysicalStream
lemma qaverage_mono {A : Type} [Fintype A] (f g : A→ℚ) (h : ∀ a,f a≤g a) : qaverage f≤qaverage g := by
  unfold qaverage
  exact div_le_div_of_nonneg_right (Finset.sum_le_sum (fun a _=>h a)) (Nat.cast_nonneg _)
lemma qaverage_indicator {A : Type} [Fintype A] (P : A→Prop) [DecidablePred P] :
    qaverage (fun a=>if P a then 1 else 0)=((Finset.univ.filter P).card:ℚ)/Fintype.card A := by
  simp only [qaverage,Finset.sum_boole]
namespace Experiment
lemma mean_mono {A : Type} (p : Experiment A) (f g : A→ℚ) (h : p.All (fun a=>f a≤g a)) : p.mean f≤p.mean g := by
  induction p with
  | done a => exact h
  | delay n p ih => exact ih h
  | read p ih => exact div_le_div_of_nonneg_right (add_le_add (ih false h.1) (ih true h.2)) (by norm_num)
lemma mean_const {A : Type} (p : Experiment A) (q : ℚ) : p.mean (fun _=>q)=q := by
  induction p with
  | done a => rfl
  | delay n p ih => exact ih
  | read p ih => simp only [mean,ih];ring
lemma mean_indicator_eq_one {A : Type} (p : Experiment A) (P : A→Prop) [DecidablePred P]
    (h : p.All P) : p.mean (fun a=>if P a then 1 else 0)=1 := by
  induction p with
  | done value => exact ite_eq_left h
  | delay ticks experiment ih => exact ih h
  | read next ih => norm_num [mean,ih false h.1,ih true h.2]
end Experiment
end MatchingFPRAS.PhysicalStream

namespace MatchingFPRAS.LiteralAlgorithm
open scoped Classical
open TreeTyped TreeFraction PhysicalStream LiteralInput

lemma empty_source (G : GraphInput) (ε δ : ℚ) : empty (parseInput (encodeInput G ε δ))=decide (G.n=0) := by
  rw [parseInput_source];rfl
lemma invalid_source (G : GraphInput) (ε δ : ℚ) : invalid (parseInput (encodeInput G ε δ))=
    (!(decide (G.n%2=0)) || decide (2*G.edges.card<G.n)) := by
  rw [parseInput_source]
  simp only [invalid,ExecutableInput.tooSparse,edgeNumbers_length]
lemma invalid_zero (G : GraphInput) (ε δ : ℚ) (h : invalid (parseInput (encodeInput G ε δ))=true) : Z G=0 := by
  rw [invalid_source] at h
  by_cases he : Even G.n
  · have he' : G.n%2=0 := Nat.even_iff.mp he
    simp only [he',decide_true,Bool.not_true,Bool.false_or] at h
    exact zero_of_vertex_bound (of_decide_eq_true h)
  · exact zero_of_not_even he
lemma valid_even (G : GraphInput) (ε δ : ℚ) (h : invalid (parseInput (encodeInput G ε δ))=false) : Even G.n := by
  rw [invalid_source] at h
  by_contra he
  have he' : ¬G.n%2=0 := fun hm=>he (Nat.even_iff.mpr hm)
  simp only [he',decide_false,Bool.not_false,Bool.true_or,Bool.true_eq_false] at h
lemma valid_size (G : GraphInput) (ε δ : ℚ) (h : invalid (parseInput (encodeInput G ε δ))=false) :
    G.n≤2*(encodeInput G ε δ).length := by
  rw [invalid_source] at h
  have hh : ¬2*G.edges.card<G.n := by
    intro hc
    simp only [hc,decide_true,Bool.or_true,Bool.true_eq_false] at h
  exact (show G.n≤2*G.edges.card by omega).trans (Nat.mul_le_mul_left 2 (edgeCard_le_input_length G ε δ))
lemma valid_two (G : GraphInput) (ε δ : ℚ) (he : empty (parseInput (encodeInput G ε δ))=false)
    (hi : invalid (parseInput (encodeInput G ε δ))=false) : 2≤G.n := by
  have h0 := of_decide_eq_false (show decide (G.n=0)=false by rwa [empty_source] at he)
  have hev:=Nat.even_iff.mp (valid_even G ε δ hi)
  omega

def Proper (G : GraphInput) (as : List Symbol) : Prop :=
  ∃ q : ℚ,0≤q ∧ as=encodeRat q ∧ (Z G=0→q=0)
def AccurateWord (G : GraphInput) (ε : ℚ) (as : List Symbol) : Prop :=
  ∃ q : ℚ,as=encodeRat q ∧ (1-ε)*(Z G:ℚ)≤q ∧ q≤(1+ε)*(Z G:ℚ)
lemma algorithm_proper (G : GraphInput) (ε δ : ℚ) (he : 0<ε) (he1 : ε<1) (hd : 0≤δ) :
    (algorithm (encodeInput G ε δ)).All (Proper G) := by
  unfold algorithm
  rw [Experiment.all_map]
  have hen : LiteralCodec.ratWord (1,1)=encodeRat 1 := LiteralCodec.ratWord_repr 1 (by norm_num)
  have hzero : LiteralCodec.ratWord (0,1)=encodeRat 0 := LiteralCodec.ratWord_repr 0 (by norm_num)
  cases hE:empty (parseInput (encodeInput G ε δ)) with
  | true =>
    have hn : G.n=0 := of_decide_eq_true (by rwa [empty_source] at hE)
    have hz:=count_empty_graph hn
    simp only [count,hE,ite_true,Experiment.All]
    exact ⟨1,by norm_num,hen,by intro h;omega⟩
  | false =>
    cases hI:invalid (parseInput (encodeInput G ε δ)) with
    | true =>
      simp only [count,hE,hI,Bool.false_eq_true,ite_false,ite_true,Experiment.All]
      exact ⟨0,by norm_num,hzero,fun _=>rfl⟩
    | false =>
      simp only [count,hE,hI,Bool.false_eq_true,ite_false]
      have hn:=valid_two G ε δ hE hI
      have hev:=valid_even G ε δ hI
      let : Nontrivial (Fin G.n):=Fin.nontrivial_iff_two_le.mpr hn
      apply Experiment.all_of_qaverage _ (fun b=>TreeFraction.repr
        (FiniteTrial.guardedAmplifiedBitOutput (FiniteTrial.parameters G hn hev ε he he1) δ b))
      · exact compute_mean hn hev ε δ he he1 hd
      · intro b
        let p:=FiniteTrial.parameters G hn hev ε he he1
        have hq:=FiniteTrial.guardedAmplifiedBitOutput_nonneg p δ b
        exact ⟨_,hq,LiteralCodec.ratWord_repr _ hq,fun hz=>FiniteTrial.guardedAmplifiedBitOutput_zero p hz δ b⟩

lemma accurate_zero (G : GraphInput) (ε : ℚ) (hz : Z G=0) : AccurateWord G ε (encodeRat 0) := by
  refine ⟨0,rfl,?_,?_⟩ <;> simp [hz]
lemma proper_accurate_zero (G : GraphInput) (ε : ℚ) (hz : Z G=0) (as : List Symbol) (ha : Proper G as) :
    AccurateWord G ε as := by
  obtain ⟨q,_,rfl,hq⟩:=ha
  rw [hq hz]
  exact accurate_zero G ε hz

lemma algorithm_success (G : GraphInput) (ε δ : ℚ) (he : 0<ε) (he1 : ε<1) (hd : 0<δ) :
    1-δ≤(algorithm (encodeInput G ε δ)).mean (fun as=>if AccurateWord G ε as then 1 else 0) := by
  classical
  by_cases hz:Z G=0
  · rw [Experiment.mean_indicator_eq_one _ _ ((algorithm_proper G ε δ he he1 hd.le).mono
      (proper_accurate_zero G ε hz))]
    linarith
  have hZ:0<Z G:=Nat.pos_of_ne_zero hz
  cases hE:empty (parseInput (encodeInput G ε δ)) with
  | true =>
    have hn : G.n=0 := of_decide_eq_true (by rwa [empty_source] at hE)
    have hz:=count_empty_graph hn
    have hq : AccurateWord G ε (LiteralCodec.ratWord (1,1)) := by
      refine ⟨1,LiteralCodec.ratWord_repr 1 (by norm_num),?_,?_⟩ <;> rw [hz] <;> norm_num <;> linarith
    simp only [algorithm,Experiment.mean_map,count,hE,ite_true,Experiment.mean,ite_eq_left hq]
    linarith
  | false =>
    have hI:invalid (parseInput (encodeInput G ε δ))=false := by
      cases hi:invalid (parseInput (encodeInput G ε δ)) with
      | false => rfl
      | true => exact False.elim (hz (invalid_zero G ε δ hi))
    have hn:=valid_two G ε δ hE hI
    have hev:=valid_even G ε δ hI
    let : Nontrivial (Fin G.n):=Fin.nontrivial_iff_two_le.mpr hn
    let p:=FiniteTrial.parameters G hn hev ε he he1
    have hs:=FiniteTrial.guardedAmplifiedBitOutput_success p hZ δ hd
    have hb : qaverage (fun b=>if FiniteTrial.Accurate p (FiniteTrial.guardedAmplifiedBitOutput p δ b) then 1 else 0)≥1-δ := by
      rw [qaverage_indicator]
      simpa only [FiniteTrial.guardedAccurateBits,Fintype.card_fun,Fintype.card_fin,Fintype.card_bool,Nat.cast_pow,Nat.cast_ofNat] using hs
    simp only [algorithm,Experiment.mean_map,count,hE,hI,Bool.false_eq_true,ite_false]
    rw [compute_mean hn hev ε δ he he1 hd.le]
    apply hb.trans (qaverage_mono _ _ (fun b=>?_))
    split_ifs with ha hword hword
    · rfl
    · exfalso
      apply hword
      exact ⟨_,LiteralCodec.ratWord_repr _ (FiniteTrial.guardedAmplifiedBitOutput_nonneg p δ b),ha⟩
    · norm_num
    · rfl
end MatchingFPRAS.LiteralAlgorithm

end OAI