lean/OAI/Computability/BinPacking/PCP/SourceAmplification.lean

import OAI.Computability.BinPacking.Games.Holenstein
import OAI.Computability.BinPacking.Games.RepetitionUpper
import OAI.Computability.BinPacking.PCP.NormalizationEmitMachine

namespace OAI

namespace BinPackingGames.Integration.SourceParameters

def rate (gap : ℚ) : ℚ := 1 - gap ^ 3 / 100000

theorem rate_bounds {gap : ℚ} (hgap : 0 < gap) (hgap1 : gap ≤ 1) :
    0 < rate gap ∧ rate gap < 1 := by
  have hcube : gap ^ 3 ≤ 1 := pow_le_one₀ hgap.le hgap1
  have hcubePos : 0 < gap ^ 3 := pow_pos hgap _
  constructor <;> unfold rate <;> linarith

theorem fourth_power_comparison {gap : ℚ} (hgap : 0 ≤ gap) (hgap1 : gap ≤ 1) :
    1 - (gap : ℝ) ^ 3 / 6000 ≤ (rate gap : ℝ) ^ 4 := by
  have hg : (0 : ℝ) ≤ gap := by exact_mod_cast hgap
  have hg1 : (gap : ℝ) ≤ 1 := by exact_mod_cast hgap1
  have hc : (gap : ℝ) ^ 3 ≤ 1 := pow_le_one₀ hg hg1
  have hc0 : 0 ≤ (gap : ℝ) ^ 3 := pow_nonneg hg _
  have hb := one_add_mul_le_pow (a := -(gap : ℝ) ^ 3 / 100000)
    (by linarith : (-2 : ℝ) ≤ -(gap : ℝ) ^ 3 / 100000) 4
  have hr : (rate gap : ℝ) = 1 - (gap : ℝ) ^ 3 / 100000 := by
    simp only [rate, Rat.cast_sub, Rat.cast_one, Rat.cast_div,
      Rat.cast_pow, Rat.cast_ofNat]
  rw [hr]
  calc
    _ ≤ 1 + 4 * (-(gap : ℝ) ^ 3 / 100000) := by linarith
    _ ≤ _ := by simpa only [Nat.cast_ofNat, sub_eq_add_neg, neg_div] using hb

theorem four_bit_rate_comparison {gap : ℚ}
    (hgap : 0 < gap) (hgap1 : gap ≤ 1) (n : Nat) :
    (1 - (gap : ℝ) ^ 3 / 6000) ^ ((n : ℝ) / 4) ≤ (rate gap : ℝ) ^ n := by
  have hg : (0 : ℝ) ≤ gap := by exact_mod_cast hgap.le
  have hg1 : (gap : ℝ) ≤ 1 := by exact_mod_cast hgap1
  have hc : (gap : ℝ) ^ 3 ≤ 1 := pow_le_one₀ hg hg1
  have hr : (0 : ℝ) ≤ rate gap := by exact_mod_cast (rate_bounds hgap hgap1).1.le
  calc
    _ ≤ ((rate gap : ℝ) ^ 4) ^ ((n : ℝ) / 4) :=
      Real.rpow_le_rpow (by linarith) (fourth_power_comparison hgap.le hgap1) (by positivity)
    _ = (rate gap : ℝ) ^ ((4 : ℝ) * ((n : ℝ) / 4)) :=
      (Real.rpow_natCast_mul hr 4 ((n : ℝ) / 4)).symm
    _ = (rate gap : ℝ) ^ (n : ℝ) := by congr 1; ring
    _ = _ := Real.rpow_natCast _ _

theorem logTwo_sixteen : BinPackingGames.Foundations.Repetition.logTwo 16 = 4 := by
  unfold BinPackingGames.Foundations.Repetition.logTwo
  rw [show (16 : ℝ) = 2 ^ 4 by norm_num, Real.log_pow]
  have hlog : Real.log 2 ≠ 0 := ne_of_gt (Real.log_pos (by norm_num : (1 : ℝ) < 2))
  simp [hlog]

theorem game_repetition_rate {Q₁ Q₂ A₁ A₂ : Type*}
    [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂]
    [Nonempty A₁] [Nonempty A₂] [DecidableEq Q₁] [DecidableEq Q₂]
    (G : BinPackingGames.Foundations.Games.Game Q₁ Q₂ A₁ A₂)
    {gap : ℚ} (hgap : 0 < gap) (hgap1 : gap ≤ 1)
    (hcards : Fintype.card A₁ * Fintype.card A₂ = 16)
    (hvalue : G.value ≤ 1 - (gap : ℝ)) (n : Nat) :
    (G.repetition n).value ≤ (rate gap : ℝ) ^ n := by
  have hg : (0 : ℝ) < gap := by exact_mod_cast hgap
  have halphabet : BinPackingGames.Foundations.Repetition.logTwo
      ((Fintype.card A₁ : ℝ) * (Fintype.card A₂ : ℝ)) ≤ 4 := by
    rw [← Nat.cast_mul, hcards]
    exact logTwo_sixteen.le
  have h := BinPackingGames.Foundations.Repetition.holenstein_repetition_value
    G n hvalue (by linarith) (by norm_num : (1 : ℝ) ≤ 4) halphabet
  simp only [sub_sub_cancel] at h
  exact h.trans (four_bit_rate_comparison hgap hgap1 n)

def sourceThreshold (D : Nat) (δ : ℚ) : ℚ := 4 * (D : ℚ)⁻¹ * δ ^ 2

theorem sourceThreshold_pos {D : Nat} (hD : 0 < D) {δ : ℚ} (hδ : 0 < δ) :
    0 < sourceThreshold D δ := by
  unfold sourceThreshold
  positivity

theorem exists_repetition_length {gap δ : ℚ} (hgap : 0 < gap) (hgap1 : gap ≤ 1)
    (hδ : 0 < δ) {D : Nat} (hD : 0 < D) :
    ∃ u : Nat, 0 < u ∧ (rate gap) ^ u < sourceThreshold D δ :=
  BinPackingGames.Soundness.RepetitionUpper.exists_power_lt (rate gap) (sourceThreshold D δ)
    (rate_bounds hgap hgap1).1.le (rate_bounds hgap hgap1).2 (sourceThreshold_pos hD hδ)

def repetitionLength (gap δ : ℚ) (hgap : 0 < gap) (hgap1 : gap ≤ 1)
    (hδ : 0 < δ) (D : Nat) (hD : 0 < D) : Nat :=
  Nat.find (exists_repetition_length hgap hgap1 hδ hD)

theorem repetitionLength_spec (gap δ : ℚ) (hgap : 0 < gap) (hgap1 : gap ≤ 1)
    (hδ : 0 < δ) (D : Nat) (hD : 0 < D) :
    0 < repetitionLength gap δ hgap hgap1 hδ D hD ∧
      rate gap ^ repetitionLength gap δ hgap hgap1 hδ D hD < sourceThreshold D δ :=
  Nat.find_spec (exists_repetition_length hgap hgap1 hδ hD)

theorem repetitionLength_real_bound (gap δ : ℚ) (hgap : 0 < gap) (hgap1 : gap ≤ 1)
    (hδ : 0 < δ) (D : Nat) (hD : 0 < D) :
    (rate gap : ℝ) ^ repetitionLength gap δ hgap hgap1 hδ D hD ≤
      4 * (D : ℝ)⁻¹ * (δ : ℝ) ^ 2 := by
  have h := (repetitionLength_spec gap δ hgap hgap1 hδ D hD).2.le
  unfold sourceThreshold at h
  have hr := (Rat.cast_le (K := ℝ)).mpr h
  push_cast at hr
  exact hr

end BinPackingGames.Integration.SourceParameters

namespace BinPackingCompleteness.SourceAmplification

open SourceClause BinPackingGames.Foundations Games
open BinPackingGames.Integration

theorem logTwo_le_four {x : ℝ} (hx : 0 < x) (hbound : x ≤ 16) :
    Repetition.logTwo x ≤ 4 := by
  calc
    Repetition.logTwo x ≤ Repetition.logTwo 16 := by
      unfold Repetition.logTwo
      exact div_le_div_of_nonneg_right (Real.log_le_log hx hbound)
        (Real.log_pos (by norm_num : (1 : ℝ) < 2)).le
    _ = 4 := SourceParameters.logTwo_sixteen

theorem game_repetition_rate_le_sixteen {Q₁ Q₂ A₁ A₂ : Type*}
    [Fintype Q₁] [Fintype Q₂] [Fintype A₁] [Fintype A₂]
    [Nonempty A₁] [Nonempty A₂] [DecidableEq Q₁] [DecidableEq Q₂]
    (G : Game Q₁ Q₂ A₁ A₂) {gap : ℚ} (hgap : 0 < gap) (hgap1 : gap ≤ 1)
    (hcards : Fintype.card A₁ * Fintype.card A₂ ≤ 16)
    (hvalue : G.value ≤ 1 - (gap : ℝ)) (k : Nat) :
    (G.repetition k).value ≤ (SourceParameters.rate gap : ℝ) ^ k := by
  have hg : (0 : ℝ) < gap := by exact_mod_cast hgap
  have ha : (0 : ℝ) < Fintype.card A₁ := by exact_mod_cast Fintype.card_pos (α := A₁)
  have hb : (0 : ℝ) < Fintype.card A₂ := by exact_mod_cast Fintype.card_pos (α := A₂)
  have hbound : (Fintype.card A₁ : ℝ) * (Fintype.card A₂ : ℝ) ≤ 16 := by
    exact_mod_cast hcards
  have halphabet := logTwo_le_four (mul_pos ha hb) hbound
  have h := Repetition.holenstein_repetition_value G k hvalue
    (by linarith) (by norm_num : (1 : ℝ) ≤ 4) halphabet
  simp only [sub_sub_cancel] at h
  exact h.trans (SourceParameters.four_bit_rate_comparison hgap hgap1 k)

def ClauseGap {n m : Nat} (clauses : Fin m → NormalizedClause n) (γ : ℚ) : Prop :=
  ∀ assignment : Fin n → Bool,
    γ * (m : ℚ) ≤ (SourceGame.violatedCount clauses assignment : ℚ)

theorem source_value_le {n m : Nat} [NeZero m]
    (clauses : Fin m → NormalizedClause n) {γ : ℚ} (gap : ClauseGap clauses γ) :
    (SourceGame.game clauses).value ≤ 1 - ((γ / 3 : ℚ) : ℝ) := by
  apply ((SourceGame.game clauses).value_le_iff _).mpr
  intro strategy
  have hm : (0 : ℝ) < m := by exact_mod_cast Nat.pos_of_neZero m
  have hcount : (γ : ℝ) * (m : ℝ) ≤
      (SourceGame.violatedCount clauses strategy.2 : ℝ) := by
    exact_mod_cast gap strategy.2
  have hfrac := (le_div_iff₀ hm).mpr hcount
  have h := SourceGame.success_le_one_sub_third_violations clauses strategy
  push_cast
  linarith

theorem source_repetition_rate {n m : Nat} [NeZero m]
    (clauses : Fin m → NormalizedClause n) {γ : ℚ}
    (hγ : 0 < γ) (hγ1 : γ ≤ 1) (gap : ClauseGap clauses γ) (k : Nat) :
    ((SourceGame.game clauses).repetition k).value ≤
      (SourceParameters.rate (γ / 3) : ℝ) ^ k := by
  have hthird : (0 : ℚ) < γ / 3 := div_pos hγ (by norm_num)
  have hthird1 : γ / 3 ≤ (1 : ℚ) := by linarith
  have hv : (SourceGame.questionGame clauses).value ≤ 1 - ((γ / 3 : ℚ) : ℝ) := by
    simpa only [SourceGame.questionGame, OccurrenceGame.toGame_value] using
      source_value_le clauses gap
  have h := game_repetition_rate_le_sixteen (SourceGame.questionGame clauses)
    hthird hthird1 (by decide) hv k
  simpa only [SourceGame.questionGame, OccurrenceGame.toGame_repetition_value] using h

theorem exists_repetition_length {γ σ : ℚ}
    (hγ : 0 < γ) (hγ1 : γ ≤ 1) (hσ : 0 < σ) :
    ∃ k : Nat, 0 < k ∧ SourceParameters.rate (γ / 3) ^ k < σ := by
  have hthird : (0 : ℚ) < γ / 3 := div_pos hγ (by norm_num)
  have hthird1 : γ / 3 ≤ (1 : ℚ) := by linarith
  have hr := SourceParameters.rate_bounds hthird hthird1
  exact BinPackingGames.Soundness.RepetitionUpper.exists_power_lt
    (SourceParameters.rate (γ / 3)) σ hr.1.le hr.2 hσ

def repetitionLength (γ σ : ℚ) (hγ : 0 < γ) (hγ1 : γ ≤ 1) (hσ : 0 < σ) : Nat :=
  Nat.find (exists_repetition_length hγ hγ1 hσ)

theorem repetitionLength_spec (γ σ : ℚ) (hγ : 0 < γ) (hγ1 : γ ≤ 1) (hσ : 0 < σ) :
    0 < repetitionLength γ σ hγ hγ1 hσ ∧
      SourceParameters.rate (γ / 3) ^ repetitionLength γ σ hγ hγ1 hσ < σ :=
  Nat.find_spec (exists_repetition_length hγ hγ1 hσ)

theorem repeated_source_value_lt {n m : Nat} [NeZero m]
    (clauses : Fin m → NormalizedClause n) (γ σ : ℚ)
    (hγ : 0 < γ) (hγ1 : γ ≤ 1) (hσ : 0 < σ) (gap : ClauseGap clauses γ) :
    ((SourceGame.game clauses).repetition (repetitionLength γ σ hγ hγ1 hσ)).value < (σ : ℝ) := by
  have hsmall : (SourceParameters.rate (γ / 3) : ℝ) ^
      repetitionLength γ σ hγ hγ1 hσ < (σ : ℝ) := by
    exact_mod_cast (repetitionLength_spec γ σ hγ hγ1 hσ).2
  exact (source_repetition_rate clauses hγ hγ1 gap _).trans_lt hsmall

theorem repeated_completeness_success {n m : Nat} [NeZero m]
    (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool)
    (satisfying : ∀ c, (clauses c).clause.eval assignment = true) (k : Nat) :
    ((SourceGame.game clauses).repetition k).success
      (Game.repeatStrategy (SourceGame.completenessStrategy clauses assignment satisfying) k) = 1 := by
  rw [← (SourceGame.game clauses).toGame_repetition_success (SourceGame.presentation clauses)]
  change ((SourceGame.questionGame clauses).repetition k).success
    (Game.repeatStrategy (SourceGame.completenessStrategy clauses assignment satisfying) k) = 1
  rw [Game.success_repeatStrategy, SourceGame.questionGame_success,
    SourceGame.completeness_success, one_pow]

theorem repeated_completeness_value {n m : Nat} [NeZero m]
    (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool)
    (satisfying : ∀ c, (clauses c).clause.eval assignment = true) (k : Nat) :
    ((SourceGame.game clauses).repetition k).value = 1 := by
  apply le_antisymm ((SourceGame.game clauses).repetition k).value_le_one
  rw [← repeated_completeness_success clauses assignment satisfying k]
  exact ((SourceGame.game clauses).repetition k).success_le_value _

end BinPackingCompleteness.SourceAmplification

end OAI