lean/OAI/Combinatorics/FiniteCircle/RandomCodes.lean

import OAI.Combinatorics.FiniteCircle.BitCounting

namespace OAI

namespace FiniteCircle

open scoped BigOperators List
open scoped ComplexConjugate
open RCLike Module

open Classical

abbrev SmallHoles (w : ℕ) := {S : Finset (Fin w) // (S.card : ℝ) ≤ (w : ℝ)/1048576}
abbrev DenseParameters (w : ℕ) := Fin w × Fin w × SmallHoles w

noncomputable instance (w : ℕ) : Fintype (SmallHoles w) := Fintype.ofFinite _

def denseList {w : ℕ} (P : DenseParameters w) : List (Fin w) :=
  (Finset.Icc P.1 P.2.1 \ P.2.2.val).sort (· ≤ ·)

theorem denseList_sorted {w : ℕ} (P : DenseParameters w) :
    (denseList P).Pairwise (fun i j => i.val < j.val) :=
  (Finset.sortedLT_sort (Finset.Icc P.1 P.2.1 \ P.2.2.val)).pairwise

theorem exists_denseParameters {w : ℕ} (is : List (Fin w))
    (hs : is.Pairwise (fun i j => i.val < j.val)) (hn : 0 < is.length)
    (hloss : (indexSpan is - is.length : ℕ) ≤ (w : ℝ)/1048576) :
    ∃ P : DenseParameters w, denseList P = is := by
  classical
  let lo := is.get ⟨0, hn⟩
  let hi := is.get ⟨is.length-1, by omega⟩
  let S := is.toFinset
  have hm : StrictMono is.get := List.pairwise_iff_get.mp hs
  have hsub : S ⊆ Finset.Icc lo hi := by
    intro i hiS
    obtain ⟨k, hk⟩ := List.mem_iff_get.mp (List.mem_toFinset.mp hiS)
    subst i
    exact Finset.mem_Icc.mpr ⟨hm.monotone (by exact Nat.zero_le _), hm.monotone (by
      change k.val ≤ is.length-1; omega)⟩
  have hcard : S.card = is.length := List.toFinset_card_of_nodup hs.nodup
  have hspan : (Finset.Icc lo hi).card = indexSpan is := by
    rw [Fin.card_Icc]
    have hh := indexSpan_ofFn is.get hn
    simpa only [List.ofFn_get] using hh.symm
  let H := Finset.Icc lo hi \ S
  have hH : (H.card : ℝ) ≤ (w : ℝ)/1048576 := by
    simpa only [H, Finset.card_sdiff_of_subset hsub, hcard, hspan] using hloss
  refine ⟨(lo, hi, ⟨H, hH⟩), ?_⟩
  dsimp only [denseList]
  rw [show Finset.Icc lo hi \ H = S from Finset.sdiff_sdiff_eq_self hsub]
  exact (List.toFinset_sort (· ≤ ·) hs.nodup).mpr (hs.imp (fun h => h.le))

def StrongLocal {α : Type*} {w : ℕ} (c : α → Fin w → Bool) : Prop :=
  ∀ a b : α, ∀ is js : List (Fin w),
    is.Pairwise (fun i j => i.val < j.val) →
    js.Pairwise (fun i j => i.val < j.val) →
    is.length = js.length → w ≤ 16*is.length →
    (indexSpan is - is.length : ℕ) ≤ (w : ℝ)/1048576 →
    (indexSpan js - js.length : ℕ) ≤ (w : ℝ)/1048576 →
    (∀ ij ∈ is.zip js, c a ij.1 = c b ij.2) →
    a = b ∧ ∃ i : Fin w, (i, i) ∈ is.zip js

abbrev DenseWitness (α : Type*) (w : ℕ) := (α × DenseParameters w) × (α × DenseParameters w)

def badDenseWitness {α : Type*} {w : ℕ} (W : DenseWitness α w) (ω : α × Fin w → Bool) : Prop :=
  let is := denseList W.1.2
  let js := denseList W.2.2
  is.length = js.length ∧ w ≤ 16*is.length ∧
  (W.1.1 ≠ W.2.1 ∨ ∀ i : Fin w, (i,i) ∉ is.zip js) ∧
  ∀ ij ∈ is.zip js, ω (W.1.1, ij.1) = ω (W.2.1, ij.2)

theorem card_badDenseWitness_le {α : Type*} [Fintype α] {w : ℕ}
    (W : DenseWitness α w) :
    (Finset.univ.filter (badDenseWitness W)).card ≤
      2^(Fintype.card α*w-w/64) := by
  classical
  let is := denseList W.1.2
  let js := denseList W.2.2
  by_cases hc : is.length = js.length ∧ w ≤ 16*is.length ∧
      (W.1.1 ≠ W.2.1 ∨ ∀ i : Fin w, (i,i) ∉ is.zip js)
  · obtain ⟨hlen, hw, hne⟩ := hc
    let f : Fin is.length → α × Fin w := fun k => (W.1.1, is.get k)
    let g : Fin is.length → α × Fin w := fun k => (W.2.1, js.get (Fin.cast hlen k))
    have his : StrictMono is.get := List.pairwise_iff_get.mp (denseList_sorted _)
    have hjs : StrictMono js.get := List.pairwise_iff_get.mp (denseList_sorted _)
    have hf : Function.Injective f := fun i j h => his.injective (congrArg Prod.snd h)
    have hg : Function.Injective g := by
      intro i j h
      have hh := hjs.injective (congrArg Prod.snd h)
      exact Fin.ext (show i.val = j.val from congrArg (fun k : Fin js.length => k.val) hh)
    have hpair (i : Fin is.length) : (is.get i, js.get (Fin.cast hlen i)) ∈ is.zip js := by
      apply List.mem_iff_get.mpr
      refine ⟨⟨i.val, by simp only [List.length_zip]; omega⟩, ?_⟩
      simp only [List.get_eq_getElem, List.getElem_zip, Fin.val_cast]
    have hn : ∀ i ∈ (Finset.univ : Finset (Fin is.length)), f i ≠ g i := by
      intro i _ he
      rcases hne with hne | hne
      · exact hne (show W.1.1 = W.2.1 from congrArg (fun x : α × Fin w => x.1) he)
      · have hh : is.get i = js.get (Fin.cast hlen i) := congrArg (fun x : α × Fin w => x.2) he
        exact hne (is.get i) (hh.symm ▸ hpair i)
    have hsub : Finset.univ.filter (badDenseWitness W) ⊆
        Finset.univ.filter (fun ω : α × Fin w → Bool => ∀ i ∈ (Finset.univ : Finset (Fin is.length)), ω (f i) = ω (g i)) := by
      intro ω hω
      have hω := (Finset.mem_filter.mp hω).2
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, fun i _ => hω.2.2.2 _ (hpair i)⟩
    have hh := card_matching_equalities_le (Finset.univ : Finset (Fin is.length)) f g hf hg hn w (by simpa using hw)
    exact (Finset.card_le_card hsub).trans (by simpa [Fintype.card_prod, Fintype.card_fin] using hh)
  · have he : Finset.univ.filter (badDenseWitness W) = ∅ := by
      apply Finset.eq_empty_iff_forall_notMem.mpr
      intro ω hω
      have hω := (Finset.mem_filter.mp hω).2
      exact hc ⟨hω.1, hω.2.1, hω.2.2.1⟩
    rw [he, Finset.card_empty]
    exact Nat.zero_le _

theorem card_denseWitness_le {α : Type*} [Fintype α] (w : ℕ) :
    (Fintype.card (DenseWitness α w) : ℝ) ≤
      (Fintype.card α : ℝ)^2 * (w : ℝ)^4 * Real.exp ((w : ℝ)/256) := by
  classical
  have hk : (Fintype.card (SmallHoles w) : ℝ) ≤ Real.exp ((w : ℝ)/512) := by
    simpa only [SmallHoles, Fintype.card_subtype] using card_small_subsets_le w
  have he : Real.exp ((w : ℝ)/256) = Real.exp ((w : ℝ)/512)^2 := by
    rw [← Real.exp_nat_mul]
    congr 1
    ring
  have hc : (Fintype.card (DenseWitness α w) : ℝ) =
      (Fintype.card α : ℝ)^2 * (w : ℝ)^4 * (Fintype.card (SmallHoles w) : ℝ)^2 := by
    simp only [DenseWitness, DenseParameters, Fintype.card_prod, Fintype.card_fin, Nat.cast_mul]
    ring
  rw [hc, he]
  exact mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (by positivity) hk 2) (by positivity)

theorem dense_union_numerics {A w : ℕ} (hA : 2 ≤ A) (hw : 67108864 ≤ w)
    (hlog : 2048*Real.log (A : ℝ) ≤ w) (hd : 64 ∣ w) :
    (A : ℝ)^2 * (w : ℝ)^4 * Real.exp ((w : ℝ)/256) < (2 : ℝ)^(w/64) := by
  have hAp : (0 : ℝ) < A := by positivity
  have hwp : (0 : ℝ) < w := by exact_mod_cast (by omega : 0 < w)
  have hsqrt : 8192 ≤ Real.sqrt (w : ℝ) := by
    apply (Real.le_sqrt (by norm_num) (by positivity)).mpr
    exact_mod_cast hw
  have hlogw : Real.log (w : ℝ) ≤ 2*Real.sqrt (w : ℝ) := by
    have hh := Real.log_le_sub_one_of_pos (Real.sqrt_pos.2 hwp)
    rw [Real.log_sqrt hwp.le] at hh
    linarith
  have hsquare : (Real.sqrt (w : ℝ))^2 = w := Real.sq_sqrt hwp.le
  have hlogw' : 4096 * Real.log (w : ℝ) ≤ w := by
    nlinarith
  have hdiv : ((w/64 : ℕ) : ℝ)*64 = w := by
    exact_mod_cast Nat.div_mul_cancel hd
  have hlog2 : (1 : ℝ)/2 < Real.log 2 := by linarith [Real.log_two_gt_d9]
  have hexpl : (A : ℝ)^2 * (w : ℝ)^4 * Real.exp ((w : ℝ)/256) =
      Real.exp (2*Real.log (A : ℝ) + 4*Real.log (w : ℝ) + (w : ℝ)/256) := by
    rw [Real.exp_add, Real.exp_add]
    have h2 := Real.exp_nat_mul (Real.log (A : ℝ)) 2
    have h4 := Real.exp_nat_mul (Real.log (w : ℝ)) 4
    norm_num only [Nat.cast_ofNat, Real.exp_log hAp, Real.exp_log hwp] at h2 h4
    rw [h2, h4]
  have hexpr : (2 : ℝ)^(w/64) = Real.exp (((w/64 : ℕ) : ℝ)*Real.log 2) := by
    rw [Real.exp_nat_mul, Real.exp_log (by norm_num : (0 : ℝ) < 2)]
  rw [hexpl, hexpr]
  apply Real.exp_lt_exp.mpr
  have hpos : (0 : ℝ) < (w/64 : ℕ) := by nlinarith
  have hm := mul_lt_mul_of_pos_left hlog2 hpos
  linarith

theorem exists_coding_width (A : ℕ) (hA : 2 ≤ A) :
    ∃ w : ℕ, 67108864 ≤ w ∧ 64 ∣ w ∧
      2048*Real.log (A : ℝ) ≤ w ∧
      (w : ℝ) ≤ 67108928 * Real.log (2*A) := by
  let t := Real.log (2*(A : ℝ))
  have hAp : (0 : ℝ) < A := by positivity
  have ht : 1 ≤ t := by
    have hh : (4 : ℝ) ≤ 2*A := by exact_mod_cast (by omega : 4 ≤ 2*A)
    have hm := Real.log_le_log (by norm_num : (0 : ℝ) < 4) hh
    have h4 : Real.log (4 : ℝ) = 2*Real.log 2 := by
      rw [show (4 : ℝ) = 2^2 by norm_num, Real.log_pow]; norm_num
    dsimp only [t]
    linarith [Real.log_two_gt_d9]
  have hAt : Real.log (A : ℝ) ≤ t := Real.log_le_log hAp (by nlinarith)
  let n := ⌈1048576*t⌉₊
  have hn : 1048576*t ≤ (n : ℝ) := Nat.le_ceil _
  have hn' : (n : ℝ) < 1048576*t+1 := Nat.ceil_lt_add_one (by positivity)
  refine ⟨64*n, ?_, dvd_mul_right _ _, ?_, ?_⟩
  · have hh : (67108864 : ℝ) ≤ 64*n := by nlinarith
    exact_mod_cast hh
  · push_cast
    nlinarith
  · push_cast
    change 64*(n : ℝ) ≤ 67108928*t
    nlinarith

theorem exists_strongLocal (α : Type*) [Fintype α] (hA : 2 ≤ Fintype.card α) :
    ∃ (w : ℕ) (c : α → Fin w → Bool), 67108864 ≤ w ∧ 64 ∣ w ∧
      (w : ℝ) ≤ 67108928 * Real.log (2*Fintype.card α) ∧ StrongLocal c := by
  classical
  obtain ⟨w, hw, hd, hlog, hwidth⟩ := exists_coding_width (Fintype.card α) hA
  let Ω := α × Fin w → Bool
  let B : Finset Ω := Finset.univ.biUnion (fun W : DenseWitness α w =>
    Finset.univ.filter (badDenseWitness W))
  have hcard : B.card ≤ Fintype.card (DenseWitness α w) * 2^(Fintype.card α*w-w/64) := by
    apply Finset.card_biUnion_le.trans
    calc
      _ ≤ ∑ _W : DenseWitness α w, 2^(Fintype.card α*w-w/64) :=
        Finset.sum_le_sum (fun W _ => card_badDenseWitness_le W)
      _ = _ := by simp
  have hexp : (Fintype.card (DenseWitness α w) : ℝ) < (2 : ℝ)^(w/64) :=
    (card_denseWitness_le w).trans_lt (dense_union_numerics hA hw hlog hd)
  have hkn : w/64 ≤ Fintype.card α*w := by
    have hh : w ≤ Fintype.card α*w := by nlinarith
    exact (Nat.div_le_self _ _).trans hh
  have hstrict : (B.card : ℝ) < (2 : ℝ)^(Fintype.card α*w) := by
    have hc : (B.card : ℝ) ≤ (Fintype.card (DenseWitness α w) : ℝ) * (2 : ℝ)^(Fintype.card α*w-w/64) := by
      exact_mod_cast hcard
    calc
      _ ≤ _ := hc
      _ < (2 : ℝ)^(w/64) * (2 : ℝ)^(Fintype.card α*w-w/64) :=
        mul_lt_mul_of_pos_right hexp (by positivity)
      _ = _ := by rw [← pow_add, Nat.add_sub_of_le hkn]
  have hB : B.card < (Finset.univ : Finset Ω).card := by
    have he : (Finset.univ : Finset Ω).card = 2^(Fintype.card α*w) := by
      simp [Ω, Fintype.card_prod]
    rw [he]
    exact_mod_cast hstrict
  obtain ⟨ω, _, hω⟩ := Finset.exists_mem_notMem_of_card_lt_card hB
  have hω' (W : DenseWitness α w) : ¬badDenseWitness W ω := by
    intro hh
    apply hω
    exact Finset.mem_biUnion.mpr ⟨W, Finset.mem_univ _, Finset.mem_filter.mpr ⟨Finset.mem_univ _, hh⟩⟩
  refine ⟨w, fun a i => ω (a,i), hw, hd, hwidth, ?_⟩
  intro a b is js his hjs hlen hsize hli hlj hbits
  have hn : 0 < is.length := by omega
  obtain ⟨P, hP⟩ := exists_denseParameters is his hn hli
  obtain ⟨Q, hQ⟩ := exists_denseParameters js hjs (by omega) hlj
  by_contra hh
  apply hω' ((a,P),(b,Q))
  dsimp only [badDenseWitness]
  rw [hP, hQ]
  refine ⟨hlen, hsize, ?_, hbits⟩
  by_cases hab : a = b
  · exact Or.inr (fun i hi => hh ⟨hab, i, hi⟩)
  · exact Or.inl hab

end FiniteCircle

end OAI