import Mathlib.Combinatorics.Additive.AP.Three.Behrend
import Mathlib.Data.ZMod.Basic
import Mathlib.Tactic.Linarith

namespace OAI

/-! Joint tensor extraction, compatibility and entropy estimates. -/

noncomputable section

namespace MatrixMultiplication.JointAPFree

def natSet (N : ℕ) : Finset ℕ := (rothNumberNat_spec N).choose

theorem natSet_subset (N : ℕ) : natSet N ⊆ Finset.range N :=
  (rothNumberNat_spec N).choose_spec.1

theorem natSet_card (N : ℕ) : (natSet N).card = rothNumberNat N :=
  (rothNumberNat_spec N).choose_spec.2.1

theorem natSet_threeAPFree (N : ℕ) : ThreeAPFree (natSet N : Set ℕ) :=
  (rothNumberNat_spec N).choose_spec.2.2

theorem mem_natSet_lt {N a : ℕ} (ha : a ∈ natSet N) : a < N :=
  Finset.mem_range.mp (natSet_subset N ha)

theorem natCast_injective_below {M a b : ℕ} (ha : a < M) (hb : b < M)
    (hab : (a : ZMod M) = (b : ZMod M)) : a = b := by
  have h := congrArg ZMod.val hab
  simpa only [ZMod.val_natCast_of_lt ha, ZMod.val_natCast_of_lt hb] using h

theorem add_lt_modulus {M a b : ℕ} (ha : a < M / 2) (hb : b < M / 2) :
    a + b < M := by
  have h := Nat.div_mul_le_self M 2
  omega

def modularSet (M : ℕ) : Finset (ZMod M) :=
  (natSet (M / 2)).image (fun a : ℕ => (a : ZMod M))

theorem modularSet_card (M : ℕ) :
    (modularSet M).card = rothNumberNat (M / 2) := by
  rw [modularSet, Finset.card_image_iff.mpr, natSet_card]
  intro a ha b hb hab
  exact natCast_injective_below
    ((mem_natSet_lt ha).trans_le (Nat.div_le_self M 2))
    ((mem_natSet_lt hb).trans_le (Nat.div_le_self M 2)) hab

theorem modularSet_threeAPFree (M : ℕ) :
    ThreeAPFree (modularSet M : Set (ZMod M)) := by
  intro a ha b hb c hc habc
  change a ∈ (natSet (M / 2)).image (fun n : ℕ => (n : ZMod M)) at ha
  change b ∈ (natSet (M / 2)).image (fun n : ℕ => (n : ZMod M)) at hb
  change c ∈ (natSet (M / 2)).image (fun n : ℕ => (n : ZMod M)) at hc
  obtain ⟨a', ha', rfl⟩ := Finset.mem_image.mp ha
  obtain ⟨b', hb', rfl⟩ := Finset.mem_image.mp hb
  obtain ⟨c', hc', rfl⟩ := Finset.mem_image.mp hc
  have hac := add_lt_modulus (mem_natSet_lt ha') (mem_natSet_lt hc')
  have hbb := add_lt_modulus (mem_natSet_lt hb') (mem_natSet_lt hb')
  have hnat : a' + c' = b' + b' := natCast_injective_below hac hbb (by
    simpa only [Nat.cast_add] using habc)
  exact congrArg (fun n : ℕ => (n : ZMod M)) (natSet_threeAPFree (M / 2) ha' hb' hc' hnat)

theorem modularSet_hashAP (M : ℕ) :
    ∀ x ∈ modularSet M, ∀ y ∈ modularSet M, ∀ z ∈ modularSet M,
      x + y = 2 * z → x = z ∧ y = z := by
  intro x hx y hy z hz h
  have h' : x + y = z + z := by simpa only [two_mul] using h
  exact ⟨modularSet_threeAPFree M hx hz hy h',
    ((modularSet_threeAPFree M).eq_right hx hz hy h').symm⟩

theorem modularSet_card_lower (M : ℕ) :
    ((M / 2 : ℕ) : ℝ) * Real.exp (-4 * Real.sqrt (Real.log ((M / 2 : ℕ) : ℝ))) ≤
      ((modularSet M).card : ℝ) := by
  rw [modularSet_card]
  exact Behrend.roth_lower_bound

theorem modularSet_card_le_half (M : ℕ) : (modularSet M).card ≤ M / 2 := by
  rw [modularSet_card]
  exact rothNumberNat_le _

theorem modularSet_card_pos {M : ℕ} (hM : 2 ≤ M) : 0 < (modularSet M).card := by
  have hhalf : 0 < M / 2 := Nat.div_pos hM (by decide)
  have hpos : (0 : ℝ) < ((M / 2 : ℕ) : ℝ) *
      Real.exp (-4 * Real.sqrt (Real.log ((M / 2 : ℕ) : ℝ))) := by
    exact mul_pos (by exact_mod_cast hhalf) (Real.exp_pos _)
  exact_mod_cast hpos.trans_le (modularSet_card_lower M)

theorem modularSet_nonempty {M : ℕ} (hM : 2 ≤ M) : (modularSet M).Nonempty :=
  Finset.card_pos.mp (modularSet_card_pos hM)

theorem modularSet_log_card_lower {M : ℕ} (hM : 2 ≤ M) :
    Real.log ((M / 2 : ℕ) : ℝ) - 4 * Real.sqrt (Real.log ((M / 2 : ℕ) : ℝ)) ≤
      Real.log ((modularSet M).card : ℝ) := by
  have hhalf : (0 : ℝ) < ((M / 2 : ℕ) : ℝ) := by
    exact_mod_cast (Nat.div_pos hM (by decide) : 0 < M / 2)
  have h := Real.log_le_log (mul_pos hhalf (Real.exp_pos _)) (modularSet_card_lower M)
  rw [Real.log_mul hhalf.ne' (Real.exp_pos _).ne', Real.log_exp] at h
  linarith

theorem modularSet_log_card_le_half {M : ℕ} (hM : 2 ≤ M) :
    Real.log ((modularSet M).card : ℝ) ≤ Real.log ((M / 2 : ℕ) : ℝ) := by
  apply Real.log_le_log
  · exact_mod_cast modularSet_card_pos hM
  · exact_mod_cast modularSet_card_le_half M

theorem modularSet_log_card_lower_modulus {M : ℕ} (hM : 2 ≤ M) :
    Real.log (M : ℝ) - Real.log 3 - 4 * Real.sqrt (Real.log (M : ℝ)) ≤
      Real.log ((modularSet M).card : ℝ) := by
  have hMr : (0 : ℝ) < M := by exact_mod_cast (by omega : 0 < M)
  have hhalf : (0 : ℝ) < ((M / 2 : ℕ) : ℝ) := by
    exact_mod_cast (Nat.div_pos hM (by decide) : 0 < M / 2)
  have hround : (M : ℝ) / 3 ≤ ((M / 2 : ℕ) : ℝ) := by
    have hn : M ≤ 3 * (M / 2) := by omega
    have hr : (M : ℝ) ≤ 3 * ((M / 2 : ℕ) : ℝ) := by exact_mod_cast hn
    linarith
  have hlog := Real.log_le_log (div_pos hMr (by norm_num)) hround
  rw [Real.log_div hMr.ne' (by norm_num)] at hlog
  have hlogUpper : Real.log ((M / 2 : ℕ) : ℝ) ≤ Real.log (M : ℝ) := by
    apply Real.log_le_log hhalf
    exact_mod_cast Nat.div_le_self M 2
  have hsqrt := Real.sqrt_le_sqrt hlogUpper
  have hcard := modularSet_log_card_lower hM
  linarith

theorem modularSet_log_card_le_modulus {M : ℕ} (hM : 2 ≤ M) :
    Real.log ((modularSet M).card : ℝ) ≤ Real.log (M : ℝ) := by
  apply Real.log_le_log
  · exact_mod_cast modularSet_card_pos hM
  · exact_mod_cast (modularSet_card_le_half M).trans (Nat.div_le_self M 2)

end MatrixMultiplication.JointAPFree

end

end OAI