lean/OAI/Computability/RationalHitting/Generator.lean

import OAI.Computability.RationalHitting.Certificates

namespace OAI

namespace RationalHitting.Generator
open Matrix MvPolynomial
open scoped BigOperators
noncomputable section

def D (e : ℕ) : ℕ := CyclotomicRing.dimension e * CyclotomicRing.degree e

/-- Entrywise regular representation, flattening and fixed row-major reindexing. -/
def regular (e : ℕ) : Matrix (ZMod (CyclotomicRing.dimension e)) (ZMod (CyclotomicRing.dimension e))
    (CyclotomicRing.R e) →+* Mat (D e) :=
  (Matrix.reindexRingEquiv ℚ ((Equiv.prodCongr (ZMod.finEquiv (CyclotomicRing.dimension e)).symm.toEquiv
    (Equiv.refl (Fin (CyclotomicRing.degree e)))).trans finProdFinEquiv)).toRingHom.comp
    ((Matrix.compRingEquiv _ _ ℚ).toRingHom.comp (CyclotomicRing.rho e).toRingHom.mapMatrix)

/-- The fixed lexicographic three-dimensional integer grid, encoded by Fin H. -/
def grid (H : ℕ) : List (Fin 3 → Fin H) :=
  (List.finRange H).flatMap fun t => (List.finRange H).flatMap fun p =>
    (List.finRange H).map fun r => ![t,p,r]

lemma mem_grid (H : ℕ) (x : Fin 3 → Fin H) : x ∈ grid H := by
  simp only [grid,List.mem_flatMap,List.mem_map]
  refine ⟨x 0,by simp, x 1,by simp,x 2,by simp,?_⟩
  funext i
  fin_cases i <;> rfl

lemma grid_length (H : ℕ) : (grid H).length = H^3 := by
  simp [grid,List.length_flatMap,pow_succ,Nat.mul_assoc]

/-- The polynomial lift is evaluated over the exact rational quotient. -/
def Zring (n N e : ℕ) (x : Fin 3 → ℕ) (i : Fin (n+1)) :
    Matrix (ZMod (CyclotomicRing.dimension e)) (ZMod (CyclotomicRing.dimension e)) (CyclotomicRing.R e) :=
  (eval₂Hom (RingHom.id _) (fun j => (x j : CyclotomicRing.R e))).mapMatrix
    (PencilCertificates.lifts (CyclotomicRing.character e) N n i)

def Z (n N e : ℕ) (x : Fin 3 → ℕ) (i : Fin (n+1)) : Mat (D e) := regular e (Zring n N e x i)

def tupleAt (n N e : ℕ) (x : Fin 3 → ℕ) : Tuple n (D e) :=
  fun i => (Z n N e x 0)⁻¹ * Z n N e x i.succ

/-- The filtering step tests only Z_0, and receives no formula. -/
def atPoint (n N e : ℕ) (x : Fin 3 → ℕ) : Option (Tuple n (D e)) :=
  if (Z n N e x 0).det = 0 then none else some (tupleAt n N e x)

def output (n N e H : ℕ) : Output n where
  dimension := D e
  dimension_pos := Nat.mul_pos (CyclotomicRing.dimension_pos e) (CyclotomicRing.degree_pos e)
  tuples := (grid H).filterMap (fun x => atPoint n N e (fun i => (x i).val+1))

lemma length_output_le (n N e H : ℕ) : (output n N e H).tuples.length ≤ H^3 :=
  (List.length_filterMap_le _ _).trans_eq (grid_length H)

/-- The actual emitted rational normalization is the homomorphic image of the
quotient normalization. Consequently every original inverse occurrence is kept. -/
lemma transfer {n N e : ℕ} (x : Fin 3 → ℕ) (f : Formula n)
    (z : (Matrix (ZMod (CyclotomicRing.dimension e)) (ZMod (CyclotomicRing.dimension e))
      (CyclotomicRing.R e))ˣ)
    (hz : (z : Matrix _ _ _) = Zring n N e x 0)
    (v : Matrix (ZMod (CyclotomicRing.dimension e)) (ZMod (CyclotomicRing.dimension e)) (CyclotomicRing.R e))
    (hf : f.Eval (algebraMap ℚ _) (fun i => (↑z⁻¹ : Matrix _ _ _) * Zring n N e x i.succ) v)
    (hu : IsUnit v) :
    ∃ a, Evaluates f (tupleAt n N e x) a ∧ IsUnit a := by
  have hzinv : regular e (↑z⁻¹ : Matrix _ _ _) = (Z n N e x 0)⁻¹ := by
    symm
    apply Matrix.inv_eq_left_inv
    change regular e (↑z⁻¹ : Matrix _ _ _) * regular e (Zring n N e x 0) = 1
    simp only [← map_mul,← hz,Units.inv_mul,map_one]
  refine ⟨regular e v,?_,hu.map (regular e)⟩
  have hh := hf.map (regular e)
  rw [RingHom.ext_rat ((regular e).comp (algebraMap ℚ _)) (algebraMap ℚ _)] at hh
  change f.Eval (algebraMap ℚ _) (tupleAt n N e x) (regular e v)
  change f.Eval (algebraMap ℚ _) (fun i => (regular e (Zring n N e x 0))⁻¹ * regular e (Zring n N e x i.succ)) (regular e v)
  simpa only [map_mul,hzinv,Z] using hh

lemma emitted {n N e H : ℕ} (x : Fin 3 → Fin H)
    (hz : IsUnit (Zring n N e (fun i => (x i).val+1) 0)) :
    tupleAt n N e (fun i => (x i).val+1) ∈ (output n N e H).tuples := by
  apply List.mem_filterMap.mpr
  refine ⟨x,mem_grid H x,?_⟩
  have hq := (Matrix.isUnit_iff_isUnit_det _).mp (hz.map (regular e))
  have hne : (Z n N e (fun i => (x i).val+1) 0).det ≠ 0 := hq.ne_zero
  simp [atPoint,hne]

end
end RationalHitting.Generator

namespace RationalHitting.Generator
open Matrix MvPolynomial
open scoped BigOperators
noncomputable section

abbrev WitnessField := HahnSeries QuantumLift.Exponents ℂ
instance witnessCharZero : CharZero WitnessField :=
  CharZero.of_addMonoidHom (HahnSeries.C : ℂ →+* WitnessField).toAddMonoidHom
    (map_one (HahnSeries.C : ℂ →+* WitnessField)) HahnSeries.C_injective

def witnessEmbedding (e : ℕ) : CyclotomicRing.R e →+* WitnessField :=
  (HahnSeries.C : ℂ →+* WitnessField).comp (CyclotomicRing.intoComplex e).toRingHom

def finPencil {n : ℕ} (f : Formula n) :
    Matrix (Fin (Fintype.card f.Index)) (Fin (Fintype.card f.Index)) (Affine.Form n) :=
  (Formula.pencil f).reindex (Fintype.equivFin f.Index) (Fintype.equivFin f.Index)

lemma finPencil_unit {n : ℕ} {R : Type*} [Ring R] (c : ℚ →+* R)
    (X : Fin n → R) (f : Formula n) :
    IsUnit ((finPencil f).map (Affine.eval c X)) ↔ IsUnit (Formula.realized c X f) := by
  let E := Matrix.reindexRingEquiv R (Fintype.equivFin f.Index)
  change IsUnit (E (Formula.realized c X f)) ↔ IsUnit (Formula.realized c X f)
  constructor
  · intro h; simpa using h.map E.symm
  · exact fun h => h.map E

def onePencil (n : ℕ) : Matrix (Fin 1) (Fin 1) (Affine.Form n) := fun _ _ => Affine.constant 1

def conditions {n : ℕ} (N e : ℕ) (f : Formula n) : List (MvPolynomial (Fin 3) (CyclotomicRing.R e)) :=
  PencilCertificates.determinant (CyclotomicRing.character e) N (onePencil n) ::
    f.certificates.map (fun h => PencilCertificates.determinant (CyclotomicRing.character e) N (finPencil h))

lemma condition_nonzero {n s N e : ℕ} (hs : 1 ≤ s) (f : Formula n) (hf : f.size ≤ s)
    (hnz : Nonzero f)
    (hN : 1 ≤ N) (hMN : CyclotomicRing.dimension e = N+2*(n+1)^3*(2*s+1))
    (hM : (2*s+1)*(2*(n+1)^3*(2*s+1)) < CyclotomicRing.dimension e) :
    ∀ p ∈ conditions N e f, p ≠ 0 := by
  obtain ⟨d,hd,W,a,ha,ha0⟩ := hnz
  obtain ⟨X,v,hv,hvu⟩ := formula_invertible_witness hd f W a ha ha0
  let C : WitnessField →+* LaurentReduction.F WitnessField := HahnSeries.C
  let Y : Fin n → Matrix (Fin d) (Fin d) (LaurentReduction.F WitnessField) := fun i => C.mapMatrix (X i)
  have hv' : Formula.Eval (algebraMap ℚ (Matrix (Fin d) (Fin d) (LaurentReduction.F WitnessField)))
      Y f (C.mapMatrix v) := by
    convert hv.map C.mapMatrix using 1
    exact RingHom.ext_rat _ _
  have hcert : ∀ h ∈ f.certificates, IsUnit (Formula.realized (algebraMap ℚ _) Y h) :=
    (Formula.certificates_iff (algebraMap ℚ _) Y f).mpr ⟨_,hv',hvu.map C.mapMatrix⟩
  intro p hp
  rcases List.mem_cons.mp hp with rfl | hp
  · apply PencilCertificates.determinant_ne_zero (CyclotomicRing.character e)
      (CyclotomicRing.character_primitive e) (witnessEmbedding e) (onePencil n)
      (2*s+1) 1 (by omega) (by omega) hN hMN hM (by omega) (fun _ => 0)
    have heq : (onePencil n).map (Affine.eval (algebraMap ℚ (Matrix (Fin 1) (Fin 1)
        (LaurentReduction.F WitnessField))) (fun _ => 0)) = 1 := by
      ext i j
      simp [onePencil,Affine.eval_constant,Matrix.one_apply,Subsingleton.elim i j]
    rw [heq]
    exact isUnit_one
  · obtain ⟨h,hh,rfl⟩ := List.mem_map.mp hp
    have hb := (Formula.certificate_bounds f s hs hf).2 h hh
    apply PencilCertificates.determinant_ne_zero (CyclotomicRing.character e)
      (CyclotomicRing.character_primitive e) (witnessEmbedding e) (finPencil h)
      (2*s+1) d hb.1 hb.2 hN hMN hM hd Y
    exact (finPencil_unit _ _ h).mpr (hcert h hh)

lemma condition_degree {n s N e : ℕ} (hs : 1 ≤ s) (f : Formula n) (hf : f.size ≤ s) :
    (conditions N e f).length ≤ s+2 ∧
    ∀ p ∈ conditions N e f, p.totalDegree ≤ 3*(2*s+1)*(CyclotomicRing.dimension e)^2 := by
  refine ⟨?_,?_⟩
  · have hh := (Formula.certificate_bounds f s hs hf).1
    simpa only [conditions,List.length_cons,List.length_map] using Nat.succ_le_succ hh
  · intro p hp
    rcases List.mem_cons.mp hp with rfl | hp
    · exact (PencilCertificates.degree_le _ _).trans (by gcongr; omega)
    · obtain ⟨h,hh,rfl⟩ := List.mem_map.mp hp
      exact (PencilCertificates.degree_le _ _).trans (by gcongr; exact (Formula.certificate_bounds f s hs hf).2 h hh |>.2)

lemma integer_grid {K : Type*} [Field K] [CharZero K] (P : List (MvPolynomial (Fin 3) K))
    (hP : ∀ p ∈ P, p ≠ 0) (d H : ℕ) (hd : ∀ p ∈ P, p.totalDegree ≤ d)
    (hH : P.length*d < H) :
    ∃ x : Fin 3 → Fin H, ∀ p ∈ P, eval (fun i => (((x i).val+1 : ℕ) : K)) p ≠ 0 := by
  classical
  let S : Finset K := (Finset.range H).image (fun i => ((i+1 : ℕ) : K))
  have hS : S.card = H := by
    rw [Finset.card_image_of_injective,Finset.card_range]
    intro i j h
    have hh : i+1=j+1 := Nat.cast_injective h
    omega
  obtain ⟨x,hx,hxp⟩ := FiniteGrid.simultaneous P hP d hd S (by rwa [hS])
  have hm (i : Fin 3) : ∃ k : Fin H, ((k.val+1 : ℕ) : K) = x i := by
    obtain ⟨k,hk,he⟩ := Finset.mem_image.mp (hx i)
    exact ⟨⟨k,Finset.mem_range.mp hk⟩,he⟩
  choose y hy using hm
  refine ⟨y,?_⟩
  intro p hp
  have heq : (fun i => (((y i).val+1 : ℕ) : K)) = x := funext hy
  simpa only [heq] using hxp p hp

lemma specialized_unit {K : Type*} [Field K] [CharZero K] {n q M N : ℕ} [NeZero M]
    (χ : AddChar (ZMod M) K) (L : Matrix (Fin q) (Fin q) (Affine.Form n)) (x : Fin 3 → K)
    (hx : eval x (PencilCertificates.determinant χ N L) ≠ 0) :
    IsUnit (L.map (Affine.homogeneous (algebraMap ℚ _) (fun i =>
      (eval₂Hom (RingHom.id K) x).mapMatrix (PencilCertificates.lifts χ N n i)))) := by
  have hd : IsUnit ((eval₂Hom (RingHom.id K) x).mapMatrix (PencilCertificates.polynomial χ N L)) := by
    apply (Matrix.isUnit_iff_isUnit_det _).mpr
    apply isUnit_iff_ne_zero.mpr
    rw [← RingHom.map_det]
    exact hx
  rw [PencilCertificates.specialized] at hd
  simpa using hd.map (Matrix.compRingEquiv (Fin q) (ZMod M) K).symm

lemma onePencil_unit {K : Type*} [Field K] [CharZero K] {n : ℕ}
    {ι : Type*} [Fintype ι] [DecidableEq ι] (Z : Fin (n+1) → Matrix ι ι K)
    (h : IsUnit ((onePencil n).map (Affine.homogeneous (algebraMap ℚ _) Z))) : IsUnit (Z 0) := by
  have hh := h.map (Matrix.uniqueRingEquiv (m := Fin 1) (A := Matrix ι ι K)).toRingHom
  have heq : (Matrix.uniqueRingEquiv (m := Fin 1) (A := Matrix ι ι K))
      ((onePencil n).map (Affine.homogeneous (algebraMap ℚ _) Z)) = Z 0 := by
    change Affine.homogeneous (algebraMap ℚ _) Z (Affine.constant 1) = Z 0
    simp [Affine.homogeneous,Affine.coeff,Affine.constant,Fin.sum_univ_succ]
  change IsUnit ((Matrix.uniqueRingEquiv (m := Fin 1) (A := Matrix ι ι K))
      ((onePencil n).map (Affine.homogeneous (algebraMap ℚ _) Z))) at hh
  rwa [heq] at hh

/-- The finite formula-independent list hits every admissible nonzero formula
at a defined and invertible original-tree value. -/

theorem output_hits {n s N e H : ℕ} (hs : 1 ≤ s)
    (hN : 1 ≤ N) (hMN : CyclotomicRing.dimension e = N+2*(n+1)^3*(2*s+1))
    (hM : (2*s+1)*(2*(n+1)^3*(2*s+1)) < CyclotomicRing.dimension e)
    (hH : (s+2)*(3*(2*s+1)*(CyclotomicRing.dimension e)^2) < H) :
    Hits s (output n N e H) := by
  intro f hf _ha hnz
  have hb := condition_degree hs f hf (N := N) (e := e)
  obtain ⟨x,hx⟩ := integer_grid (conditions N e f)
    (condition_nonzero hs f hf hnz hN hMN hM) _ H hb.2 (lt_of_le_of_lt (Nat.mul_le_mul_right _ hb.1) hH)
  let t : Fin 3 → ℕ := fun i => (x i).val+1
  let Zr := Zring n N e t
  have hz : IsUnit (Zr 0) := by
    apply onePencil_unit Zr
    exact specialized_unit _ _ _ (hx _ (List.mem_cons_self ..))
  obtain ⟨z,hz'⟩ := hz
  have hcert : ∀ h ∈ f.certificates,
      IsUnit (Formula.realized (algebraMap ℚ _) (fun i => (↑z⁻¹ : Matrix _ _ _)*Zr i.succ) h) := by
    intro h hh
    apply (finPencil_unit _ _ h).mp
    apply Affine.normalized_pencil_unit (finPencil h) Zr z hz'
    apply specialized_unit
    exact hx _ (List.mem_cons_of_mem _ (List.mem_map.mpr ⟨h,hh,rfl⟩))
  obtain ⟨v,hv,hu⟩ := (Formula.certificates_iff _ _ f).mp hcert
  obtain ⟨a,ha,hua⟩ := transfer t f z hz' v hv hu
  exact ⟨tupleAt n N e t,emitted x ⟨z,hz'⟩,a,ha,hua⟩

end
end RationalHitting.Generator

namespace RationalHitting.Parameters

/-- The parameters, with M the least power of two strictly above BΔ. -/
def w (n : ℕ) := n+1
def B (s : ℕ) := 2*s+1
def delta (n s : ℕ) := 2*(w n)^3*B s
def exponent (n s : ℕ) := Nat.log 2 (B s * delta n s)
def M (n s : ℕ) := 2^(exponent n s+1)
def N (n s : ℕ) := M n s-delta n s
def H (n s : ℕ) := 1+3*(s+2)*B s*(M n s)^3

theorem threshold_pos (n s : ℕ) : 0 < B s * delta n s := by
  simp only [B,delta,w]
  positivity

theorem threshold_lt (n s : ℕ) : B s * delta n s < M n s :=
  Nat.lt_pow_succ_log_self (by omega) _

theorem M_le (n s : ℕ) : M n s ≤ 2*(B s*delta n s) := by
  unfold M
  rw [pow_succ]
  have h := Nat.pow_log_le_self 2 (threshold_pos n s).ne'
  unfold exponent
  omega

theorem M_minimal (n s k : ℕ) (hk : B s*delta n s < 2^k) : M n s ≤ 2^k := by
  apply Nat.pow_le_pow_right (by omega)
  exact Nat.succ_le_of_lt (Nat.log_lt_of_lt_pow (threshold_pos n s).ne' hk)

theorem N_pos (n s : ℕ) : 1 ≤ N n s := by
  have hh := threshold_lt n s
  have hb : 1 ≤ B s := by unfold B; omega
  have hd : delta n s ≤ B s*delta n s := by nlinarith
  unfold N
  omega

theorem M_eq (n s : ℕ) : M n s = N n s+delta n s := by
  have hh := N_pos n s
  unfold N at *
  omega

theorem grid_large (n s : ℕ) : (s+2)*(3*B s*(M n s)^2) < H n s := by
  have hp : 1 ≤ M n s := Nat.one_le_iff_ne_zero.mpr (by unfold M; positivity)
  have hpow : (M n s)^2 ≤ (M n s)^3 := Nat.pow_le_pow_right hp (by omega)
  unfold H
  nlinarith [Nat.mul_le_mul_left (3*(s+2)*B s) hpow]

theorem w_bound (n s : ℕ) : w n ≤ n+s+1 := by unfold w; omega

theorem B_bound (n s : ℕ) : B s ≤ 2*(n+s+1) := by unfold B; omega

theorem delta_bound (n s : ℕ) : delta n s ≤ 4*(n+s+1)^4 := by
  calc delta n s ≤ 2*(n+s+1)^3*(2*(n+s+1)) := by
         unfold delta
         gcongr
         · exact w_bound n s
         · exact B_bound n s
       _ = _ := by ring

theorem polynomial_M (n s : ℕ) : M n s ≤ 16*(n+s+1)^5 := by
  calc M n s ≤ 2*(B s*delta n s) := M_le n s
       _ ≤ 2*((2*(n+s+1))*(4*(n+s+1)^4)) := by
          gcongr
          · exact B_bound n s
          · exact delta_bound n s
       _ = _ := by ring

theorem polynomial_H (n s : ℕ) (hn : 1 ≤ n) : H n s ≤ 24577*(n+s+1)^17 := by
  have hp : 1 ≤ (n+s+1)^17 := Nat.one_le_iff_ne_zero.mpr (by positivity)
  calc H n s ≤ 1+3*(n+s+1)*(2*(n+s+1))*(16*(n+s+1)^5)^3 := by
         unfold H
         apply Nat.add_le_add_left
         apply Nat.mul_le_mul
         · apply Nat.mul_le_mul
           · exact Nat.mul_le_mul_left 3 (by omega)
           · exact B_bound n s
         · exact Nat.pow_le_pow_left (polynomial_M n s) 3
       _ = 1+24576*(n+s+1)^17 := by ring
       _ ≤ _ := by omega

end RationalHitting.Parameters

namespace RationalHitting.Generator
noncomputable section

/-- The list with all parameters fixed by the unary inputs. -/
def list (n s : ℕ) : Output n :=
  output n (Parameters.N n s) (Parameters.exponent n s) (Parameters.H n s)

theorem list_hits (n s : ℕ) (hs : 1 ≤ s) : Hits s (list n s) := by
  apply output_hits hs
  · exact Parameters.N_pos n s
  · exact Parameters.M_eq n s
  · exact Parameters.threshold_lt n s
  · exact Parameters.grid_large n s

theorem list_dimension_bound (n s : ℕ) : (list n s).dimension ≤ 256*(n+s+1)^10 := by
  have hd : CyclotomicRing.degree (Parameters.exponent n s) ≤ Parameters.M n s := by
    unfold CyclotomicRing.degree Parameters.M
    exact Nat.pow_le_pow_right (by omega) (by omega)
  change Parameters.M n s * CyclotomicRing.degree (Parameters.exponent n s) ≤ _
  calc _ ≤ (16*(n+s+1)^5)*(16*(n+s+1)^5) :=
             Nat.mul_le_mul (Parameters.polynomial_M n s) (hd.trans (Parameters.polynomial_M n s))
       _ = _ := by ring

theorem list_length_bound (n s : ℕ) (hn : 1 ≤ n) :
    (list n s).tuples.length ≤ 24577^3*(n+s+1)^51 := by
  calc _ ≤ (Parameters.H n s)^3 := length_output_le ..
       _ ≤ (24577*(n+s+1)^17)^3 := Nat.pow_le_pow_left (Parameters.polynomial_H n s hn) 3
       _ = _ := by rw [mul_pow,← pow_mul]

/-- The algebraic hitting property and the polynomial list-cardinality bound. -/

theorem algebraic_generator : ∃ G : (n s : ℕ) → Output n,
    ∀ n s, 1 ≤ n → 1 ≤ s →
      (G n s).dimension ≤ 256*(n+s+1)^10 ∧
      (G n s).tuples.length ≤ 24577^3*(n+s+1)^51 ∧ Hits s (G n s) := by
  exact ⟨list,fun n s hn hs => ⟨list_dimension_bound n s,list_length_bound n s hn,list_hits n s hs⟩⟩

end
end RationalHitting.Generator

end OAI