import OAI.Computability.DepthThree.Hash
import Mathlib.Data.Finset.Max
import Mathlib.Data.Fintype.EquivFin

namespace OAI

namespace DepthThreeLowerBound.BinaryHash

open scoped BigOperators

theorem exists_last_nonzero {d : ℕ} (w : Data d) (hw : w ≠ 0) :
    ∃ s : Fin d, w s ≠ 0 ∧ ∀ a : Fin d, s.val < a.val → w a = 0 := by
  classical
  have hex : ∃ a : Fin d, w a ≠ 0 := by
    by_contra h
    apply hw
    funext a
    by_contra ha
    exact h ⟨a, ha⟩
  obtain ⟨a, ha⟩ := hex
  obtain ⟨s, hs, hmax⟩ := Finset.exists_max_image
    (Finset.univ.filter fun a : Fin d => w a ≠ 0) Fin.val
      ⟨a, by simp [ha]⟩
  refine ⟨s, (Finset.mem_filter.mp hs).2, ?_⟩
  intro b hsb
  by_contra hb
  have hle := hmax b (by simp [hb])
  omega

noncomputable def lastIndex {d : ℕ} (w : Data d) (hw : w ≠ 0) : Fin d :=
  (exists_last_nonzero w hw).choose

theorem lastIndex_nonzero {d : ℕ} (w : Data d) (hw : w ≠ 0) :
    w (lastIndex w hw) ≠ 0 :=
  (exists_last_nonzero w hw).choose_spec.1

theorem zero_after_lastIndex {d : ℕ} (w : Data d) (hw : w ≠ 0)
    (a : Fin d) (ha : (lastIndex w hw).val < a.val) : w a = 0 :=
  (exists_last_nonzero w hw).choose_spec.2 a ha

theorem data_dim_pos {d : ℕ} (w : Data d) (hw : w ≠ 0) : 0 < d :=
  Nat.zero_le (lastIndex w hw).val |>.trans_lt (lastIndex w hw).isLt

def Nonpivot {d r : ℕ} (w : Data d) (hw : w ≠ 0) :=
  {j : Fin (d + r - 1) // ¬ ∃ i : Fin r, sumIndex i (lastIndex w hw) = j}

noncomputable instance {d r : ℕ} (w : Data d) (hw : w ≠ 0) :
    Fintype (Nonpivot (r := r) w hw) := by
  classical
  unfold Nonpivot
  infer_instance

theorem card_nonpivot {d r : ℕ} (w : Data d) (hw : w ≠ 0) :
    Fintype.card (Nonpivot (r := r) w hw) = d - 1 := by
  classical
  have hp : Fintype.card
      {j : Fin (d + r - 1) // ∃ i : Fin r, sumIndex i (lastIndex w hw) = j} = r := by
    let e : Fin r ≃
        {j : Fin (d + r - 1) // ∃ i : Fin r, sumIndex i (lastIndex w hw) = j} :=
      Equiv.ofInjective (fun i : Fin r => sumIndex i (lastIndex w hw))
        (sumIndex_left_injective (lastIndex w hw))
    simpa only [Fintype.card_fin] using (Fintype.card_congr e).symm
  calc
    Fintype.card (Nonpivot (r := r) w hw) = Fintype.card
        {j : Fin (d + r - 1) // ¬ ∃ i : Fin r, sumIndex i (lastIndex w hw) = j} :=
      Fintype.card_congr (Equiv.refl _)
    _ = (d + r - 1) - r := by
      rw [Fintype.card_subtype_compl, hp, Fintype.card_fin]
    _ = d - 1 := by
      have hd := data_dim_pos w hw
      omega

def triangularMap {d r : ℕ} (w : Data d) (hw : w ≠ 0) (u : Seed d r) :
    Output r × (Nonpivot (r := r) w hw → F2) :=
  (hashF2 u w, fun j => u j.val)

theorem triangularMap_injective {d r : ℕ} (w : Data d) (hw : w ≠ 0) :
    Function.Injective (triangularMap (r := r) w hw) := by
  classical
  intro u v huv
  have hhash : hashF2 u w = hashF2 v w := congrArg Prod.fst huv
  have hfree : (fun j : Nonpivot (r := r) w hw => u j.val) =
      (fun j : Nonpivot (r := r) w hw => v j.val) := congrArg Prod.snd huv
  have heq : ∀ n : ℕ, ∀ j : Fin (d + r - 1), j.val = n → u j = v j := by
    intro n
    induction n using Nat.strong_induction_on with
    | h n ih =>
      intro j hj
      by_cases hp : ∃ i : Fin r, sumIndex i (lastIndex w hw) = j
      · obtain ⟨i, rfl⟩ := hp
        have hrow : (∑ a : Fin d,
            (u (sumIndex i a) - v (sumIndex i a)) * w a) = 0 := by
          calc
            (∑ a : Fin d, (u (sumIndex i a) - v (sumIndex i a)) * w a) =
                hashF2 u w i - hashF2 v w i := by
                  simp only [hashF2, sub_mul, Finset.sum_sub_distrib]
            _ = 0 := sub_eq_zero.mpr (congrFun hhash i)
        have hsingle : (∑ a : Fin d,
            (u (sumIndex i a) - v (sumIndex i a)) * w a) =
            (u (sumIndex i (lastIndex w hw)) -
              v (sumIndex i (lastIndex w hw))) * w (lastIndex w hw) := by
          apply Finset.sum_eq_single_of_mem (lastIndex w hw) (Finset.mem_univ _)
          intro a _ ha
          by_cases hlt : a.val < (lastIndex w hw).val
          · have hidx : (sumIndex i a).val < n := by
              simp only [sumIndex_val] at hj ⊢
              omega
            rw [ih (sumIndex i a).val hidx (sumIndex i a) rfl, sub_self, zero_mul]
          · have hne : a.val ≠ (lastIndex w hw).val := by
              intro he
              exact ha (Fin.ext he)
            have hgt : (lastIndex w hw).val < a.val := by omega
            rw [zero_after_lastIndex w hw a hgt, mul_zero]
        rw [hsingle] at hrow
        exact sub_eq_zero.mp ((mul_eq_zero.mp hrow).resolve_right (lastIndex_nonzero w hw))
      · exact congrFun hfree ⟨j, hp⟩
  exact funext fun j => heq j.val j rfl

theorem triangularMap_bijective {d r : ℕ} (w : Data d) (hw : w ≠ 0) :
    Function.Bijective (triangularMap (r := r) w hw) := by
  classical
  apply (Fintype.bijective_iff_injective_and_card _).2
  refine ⟨triangularMap_injective w hw, ?_⟩
  have hd := data_dim_pos w hw
  simp only [Seed, Output, Fintype.card_prod, Fintype.card_fun,
    F2, BinaryAlgebra.F2, ZMod.card, Fintype.card_fin, card_nonpivot]
  rw [← pow_add]
  congr 1
  omega

noncomputable def triangularEquiv {d r : ℕ} (w : Data d) (hw : w ≠ 0) :
    Seed d r ≃ Output r × (Nonpivot (r := r) w hw → F2) :=
  Equiv.ofBijective (triangularMap w hw) (triangularMap_bijective w hw)

@[simp] theorem triangularEquiv_fst {d r : ℕ} (w : Data d) (hw : w ≠ 0)
    (u : Seed d r) : (triangularEquiv w hw u).1 = hashF2 u w := rfl

@[simp] theorem triangularEquiv_snd {d r : ℕ} (w : Data d) (hw : w ≠ 0)
    (u : Seed d r) (j : Nonpivot (r := r) w hw) :
    (triangularEquiv w hw u).2 j = u j.val := rfl

end DepthThreeLowerBound.BinaryHash

end OAI