introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
17.1 kB
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