Blame for lean/OAI/Computability/RationalHitting/IntegralLift.lean

import OAI.Computability.RationalHitting.Generator

namespace OAI

namespace RationalHitting.CyclotomicRing
open Polynomial Matrix Module
noncomputable section

lemma root_degree (e : ℕ) : AdjoinRoot.root (modulus e)^degree e = -1 := by
  have h := AdjoinRoot.eval₂_root (modulus e)
  change Polynomial.eval₂ (AdjoinRoot.of (modulus e)) (AdjoinRoot.root (modulus e))
    ((X : ℚ[X])^degree e+1) = 0 at h
  rw [Polynomial.eval₂_add,Polynomial.eval₂_pow,Polynomial.eval₂_X,Polynomial.eval₂_one] at h
  exact eq_neg_of_add_eq_zero_left h

lemma root_pow_reduce (e k : ℕ) :
    AdjoinRoot.root (modulus e)^k = (-1 : R e)^(k/degree e) *
      (basis e ⟨k % degree e,Nat.mod_lt _ (degree_pos e)⟩) := by
  rw [basis_apply,← root_degree,← pow_mul,← pow_add]
  congr 1
  change k = degree e*(k/degree e)+k%degree e
  exact (Nat.div_add_mod k (degree e)).symm

/-- Every regular-representation entry of a cyclotomic monomial is 0 or ±1.
This also gives an explicit integral computation with a division and remainder. -/
lemma rho_root_pow (e k : ℕ) (i j : Fin (degree e)) :
    rho e (AdjoinRoot.root (modulus e)^k) i j =
      if (k+j.val) % degree e = i.val then (-1 : ℚ)^((k+j.val)/degree e) else 0 := by
  rw [rho,Algebra.leftMulMatrix_eq_repr_mul,basis_apply,← pow_add,root_pow_reduce]
  rw [show (-1 : R e)^((k+j.val)/degree e) =
      algebraMap ℚ (R e) ((-1 : ℚ)^((k+j.val)/degree e)) by simp]
  rw [← Algebra.smul_def, map_smul, Basis.repr_self,Finsupp.smul_apply,Finsupp.single_apply]
  simp only [smul_eq_mul,mul_ite,mul_one,mul_zero]
  congr 1
  exact propext ⟨fun h => congrArg Fin.val h,fun h => Fin.ext h⟩

lemma rho_character (e : ℕ) (a : ZMod (dimension e)) (i j : Fin (degree e)) :
    rho e (character e a) i j =
      if (a.val+j.val) % degree e = i.val then (-1 : ℚ)^((a.val+j.val)/degree e) else 0 := by
  rw [character,AddChar.zmodChar_apply,rho_root_pow]

def signedEntry (e : ℕ) (a : ZMod (dimension e)) (i j : Fin (degree e)) : ℤ :=
  if (a.val+j.val) % degree e = i.val then (-1 : ℤ)^((a.val+j.val)/degree e) else 0

lemma rho_character_integral (e : ℕ) (a : ZMod (dimension e)) (i j : Fin (degree e)) :
    rho e (character e a) i j = (signedEntry e a i j : ℚ) := by
  simp only [rho_character,signedEntry,Int.cast_ite,Int.cast_pow,Int.cast_neg,Int.cast_one,Int.cast_zero]

lemma signedEntry_abs (e : ℕ) (a : ZMod (dimension e)) (i j : Fin (degree e)) :
    |signedEntry e a i j| ≤ 1 := by
  unfold signedEntry
  split_ifs <;> simp [abs_pow]

end
end RationalHitting.CyclotomicRing


namespace RationalHitting.IntegralTest
open Polynomial Matrix
open scoped BigOperators

/-- Integer computation of the exact expanded Taylor-reversal matrix at t. -/
def full (M : ℕ) (a t : ℤ) : Matrix (Fin M) (Fin M) ℤ := fun i j =>
  ∑ r : Fin M, ((-a)^(r.rev.val-i.val)*(r.rev.val.choose i.val : ℤ)) *
    (a^(j.val-r.val)*(j.val.choose r.val : ℤ)) * t^r.val

def padded (M N : ℕ) (a t : ℤ) : Matrix (Fin M) (Fin M) ℤ :=
  fun i j => if j.val < N then full M a t i j else 0

lemma coeff_bound (a : ℤ) (w M k j : ℕ) (hw : 1 ≤ w) (ha : |a| ≤ w) (hk : k ≤ M) :
    |(((X+C a)^k : ℤ[X]).coeff j)| ≤ (2*w : ℤ)^M := by
  rw [coeff_X_add_C_pow,abs_mul,abs_pow,Int.abs_natCast]
  have hw' : (1 : ℤ) ≤ w := by exact_mod_cast hw
  have hc : (k.choose j : ℤ) ≤ (2 : ℤ)^M := by
    exact_mod_cast (Nat.choose_le_two_pow k j).trans (Nat.pow_le_pow_right (by omega) hk)
  calc |a|^(k-j)*(k.choose j : ℤ) ≤ (w : ℤ)^M * (2 : ℤ)^M := by
         apply mul_le_mul _ hc (by positivity) (by positivity)
         exact (pow_le_pow_left₀ (abs_nonneg a) ha (k-j)).trans (pow_le_pow_right₀ hw' (Nat.sub_le k j |>.trans hk))
       _ = _ := by rw [← mul_pow]; congr 1; ring

lemma full_bound (M : ℕ) (a t : ℤ) (w H : ℕ) (hw : 1 ≤ w) (hH : 1 ≤ H)
    (ha : |a| ≤ w) (ht : |t| ≤ H) (i j : Fin M) :
    |full M a t i j| ≤ (M : ℤ)*(2*w : ℤ)^(2*M)*(H : ℤ)^M := by
  unfold full
  simp_rw [← coeff_X_add_C_pow]
  calc |∑ r : Fin M, _| ≤ ∑ r : Fin M, |(((X+C (-a))^r.rev.val : ℤ[X]).coeff i.val) *
          (((X+C a)^j.val : ℤ[X]).coeff r.val) * t^r.val| := Finset.abs_sum_le_sum_abs _ _
       _ ≤ ∑ _r : Fin M, (2*w : ℤ)^(2*M)*(H : ℤ)^M := by
         apply Finset.sum_le_sum
         intro r _
         rw [abs_mul,abs_mul,abs_pow]
         have hh : (1 : ℤ) ≤ H := by exact_mod_cast hH
         calc _ ≤ ((2*w : ℤ)^M*(2*w : ℤ)^M)*(H : ℤ)^M := by
                apply mul_le_mul _ _ (by positivity) (by positivity)
                · apply mul_le_mul (coeff_bound (-a) w M _ _ hw (by simpa using ha) (Nat.le_of_lt r.rev.isLt))
                    (coeff_bound a w M _ _ hw ha (Nat.le_of_lt j.isLt)) (abs_nonneg _) (by positivity)
                · exact (pow_le_pow_left₀ (abs_nonneg t) ht r.val).trans (pow_le_pow_right₀ hh (Nat.le_of_lt r.isLt))
              _ = _ := by rw [← pow_add]; simp [two_mul]
       _ = _ := by simp [mul_assoc]

lemma padded_bound (M N : ℕ) (a t : ℤ) (w H : ℕ) (hw : 1 ≤ w) (hH : 1 ≤ H)
    (ha : |a| ≤ w) (ht : |t| ≤ H) (i j : Fin M) :
    |padded M N a t i j| ≤ (M : ℤ)*(2*w : ℤ)^(2*M)*(H : ℤ)^M := by
  by_cases h : j.val < N
  · simpa [padded,h] using full_bound M a t w H hw hH ha ht i j
  · simp only [padded,h,ite_false,abs_zero]; positivity

end RationalHitting.IntegralTest


namespace RationalHitting.IntegralTest
open Matrix Polynomial
open scoped BigOperators

lemma full_cast {K : Type*} [Field K] (M : ℕ) (a t : ℤ) (i j : Fin M) :
    Polynomial.eval (t : K) (TestPolynomial.full M (a : K) i j) =
      (full M a t i j : K) := by
  simp only [TestPolynomial.full,full,coeff_X_add_C_pow,Polynomial.eval_finsetSum,
    Polynomial.eval_mul,Polynomial.eval_C,Polynomial.eval_pow,Polynomial.eval_X]
  simp only [Int.cast_sum,Int.cast_mul,Int.cast_pow,Int.cast_neg,Int.cast_natCast]

lemma padded_cast {K : Type*} [Field K] (M N : ℕ) (a t : ℤ) (i j : Fin M) :
    Polynomial.eval (t : K) (TestPolynomial.padded M N (a : K) i j) =
      (padded M N a t i j : K) := by
  by_cases h : j.val < N
  · simpa [TestPolynomial.padded,padded,h] using full_cast M a t i j (K := K)
  · simp [TestPolynomial.padded,padded,h]

end RationalHitting.IntegralTest

namespace RationalHitting.ThreeLift
open Polynomial MvPolynomial Matrix
open scoped BigOperators
noncomputable section
variable {K : Type*} [Field K] {d : ℕ} [NeZero d]

lemma eval_uni (x : Fin 3 → K) (p : K[X]) : MvPolynomial.eval x (uni p) = Polynomial.eval (x 0) p := by
  have he : (MvPolynomial.eval x).comp uni = Polynomial.evalRingHom (x 0) := by
    apply Polynomial.ringHom_ext
    · intro a; simp [uni]
    · simp [uni]
  exact DFunLike.congr_fun he p

lemma eval_lift (χ : AddChar (ZMod d) K) (R : Matrix (ZMod d) (ZMod d) K[X])
    (x : Fin 3 → K) (i j : ZMod d) :
    MvPolynomial.eval x (lift χ R i j) =
      (d : K)⁻¹ * ∑ a : ZMod d, ∑ b : ZMod d, ∑ k : ZMod d,
        χ (-a*k)*Polynomial.eval (x 0) (R k (k-b)) * QuantumMatrices.weyl χ a b i j *
          (x 1)^a.val*(x 2)^b.val := by
  simp only [lift,map_sum,map_mul,map_pow,eval_uni,MvPolynomial.eval_C,MvPolynomial.eval_X,coeffP,
    Polynomial.eval_C]
  simp only [Finset.mul_sum,Finset.sum_mul]
  congr 1
  ext a
  congr 1
  ext b
  congr 1
  ext k
  ring

end
end RationalHitting.ThreeLift

namespace RationalHitting.IntegralLift
open _root_.OAI.RationalHitting.CyclotomicRing Matrix
open scoped BigOperators
noncomputable section

/-- The fixed signed-monomial integer formula for M times a regular lift entry. -/
def entry (e : ℕ) (T : Matrix (ZMod (dimension e)) (ZMod (dimension e)) ℤ)
    (p r : ℤ) (u v : ZMod (dimension e)) (i j : Fin (degree e)) : ℤ :=
  ∑ a : ZMod (dimension e), ∑ b : ZMod (dimension e), ∑ k : ZMod (dimension e),
    if u = v+b then T k (k-b)*signedEntry e (-a*k+a*u) i j*p^a.val*r^b.val else 0

lemma entry_bound (e : ℕ) (T : Matrix (ZMod (dimension e)) (ZMod (dimension e)) ℤ)
    (p r : ℤ) (A H : ℕ) (hT : ∀ i j, |T i j| ≤ A) (hH : 1 ≤ H)
    (hp : |p| ≤ H) (hr : |r| ≤ H) (u v : ZMod (dimension e)) (i j : Fin (degree e)) :
    |entry e T p r u v i j| ≤ (dimension e : ℤ)^3*A*(H : ℤ)^(2*dimension e) := by
  have hH' : (1 : ℤ) ≤ H := by exact_mod_cast hH
  have hterm (a b k : ZMod (dimension e)) :
      |(if u=v+b then T k (k-b)*signedEntry e (-a*k+a*u) i j*p^a.val*r^b.val else 0)| ≤
        (A : ℤ)*(H : ℤ)^(2*dimension e) := by
    split_ifs
    · simp only [abs_mul,abs_pow]
      calc _ ≤ ((A : ℤ)*1*(H : ℤ)^dimension e)*(H : ℤ)^dimension e := by
               apply mul_le_mul _ _ (by positivity) (by positivity)
               · apply mul_le_mul _ _ (by positivity) (by positivity)
                 · exact mul_le_mul (hT _ _) (signedEntry_abs ..) (abs_nonneg _) (by positivity)
                 · exact (pow_le_pow_left₀ (abs_nonneg p) hp a.val).trans
                     (pow_le_pow_right₀ hH' (Nat.le_of_lt a.val_lt))
               · exact (pow_le_pow_left₀ (abs_nonneg r) hr b.val).trans
                   (pow_le_pow_right₀ hH' (Nat.le_of_lt b.val_lt))
           _ = _ := by rw [mul_one,mul_assoc,← pow_add]; simp [two_mul]
    · simp only [abs_zero]; positivity
  unfold entry
  calc |∑ a : ZMod (dimension e), _| ≤ ∑ a : ZMod (dimension e), |∑ b : ZMod (dimension e), _| :=
          Finset.abs_sum_le_sum_abs _ _
       _ ≤ ∑ a : ZMod (dimension e), ∑ b : ZMod (dimension e), ∑ k : ZMod (dimension e),
          (A : ℤ)*(H : ℤ)^(2*dimension e) := by
         apply Finset.sum_le_sum
         intro a _
         apply (Finset.abs_sum_le_sum_abs _ _).trans
         apply Finset.sum_le_sum
         intro b _
         exact (Finset.abs_sum_le_sum_abs _ _).trans (Finset.sum_le_sum (fun k _ => hterm a b k))
       _ = _ := by simp only [Finset.sum_const,Finset.card_univ,ZMod.card,nsmul_eq_mul]; ring

end
end RationalHitting.IntegralLift

namespace RationalHitting.IntegralLift
open Matrix _root_.OAI.RationalHitting.CyclotomicRing Polynomial
open scoped BigOperators
noncomputable section

lemma rho_rat_mul (e : ℕ) (q : ℚ) (z : R e) (i j : Fin (degree e)) :
    rho e (algebraMap ℚ (R e) q * z) i j = q * rho e z i j := by
  rw [← Algebra.smul_def, map_smul, Matrix.smul_apply, smul_eq_mul]

lemma rho_div_nat (e : ℕ) (z : R e) (i j : Fin (degree e)) :
    (dimension e : ℚ) * rho e ((dimension e : R e)⁻¹*z) i j = rho e z i j := by
  have hc : (dimension e : R e)⁻¹ = algebraMap ℚ (R e) ((dimension e : ℚ)⁻¹) := by simp
  have hd : (dimension e : ℚ) ≠ 0 := by exact_mod_cast (dimension_pos e).ne'
  rw [hc,rho_rat_mul,← mul_assoc,mul_inv_cancel₀ hd,one_mul]

lemma entry_spec (e : ℕ)
    (P : Matrix (ZMod (dimension e)) (ZMod (dimension e)) (R e)[X])
    (T : Matrix (ZMod (dimension e)) (ZMod (dimension e)) ℤ) (t p r : ℤ)
    (hT : ∀ u v, Polynomial.eval (t : R e) (P u v) = (T u v : R e))
    (u v : ZMod (dimension e)) (i j : Fin (degree e)) :
    (entry e T p r u v i j : ℚ) = (dimension e : ℚ) *
      rho e (MvPolynomial.eval ![(t : R e),(p : R e),(r : R e)]
        (ThreeLift.lift (character e) P u v)) i j := by
  rw [ThreeLift.eval_lift,rho_div_nat]
  simp only [entry,Int.cast_sum,map_sum,Matrix.sum_apply]
  apply Finset.sum_congr rfl
  intro a _
  apply Finset.sum_congr rfl
  intro b _
  apply Finset.sum_congr rfl
  intro k _
  simp only [Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val_two,hT,
    QuantumMatrices.weyl]
  by_cases h : u = v+b
  · simp only [ite_eq_left h]
    have he : character e (-a*k)*(T k (k-b) : R e)*character e (a*u)*
        (p : R e)^a.val*(r : R e)^b.val =
        algebraMap ℚ (R e) ((T k (k-b)*p^a.val*r^b.val : ℤ) : ℚ) *
          character e (-a*k+a*u) := by
      rw [AddChar.map_add_eq_mul]
      simp only [map_mul,map_pow,map_intCast,Int.cast_mul,Int.cast_pow]
      ring
    change ((T k (k-b)*signedEntry e (-a*k+a*u) i j*p^a.val*r^b.val : ℤ) : ℚ) =
      rho e (character e (-a*k)*(T k (k-b) : R e)*character e (a*u)*
        (p : R e)^a.val*(r : R e)^b.val) i j
    rw [he,rho_rat_mul,rho_character_integral]
    simp only [Int.cast_mul,Int.cast_pow]
    ring
  · simp [h]

end
end RationalHitting.IntegralLift

namespace RationalHitting.Generator
open Matrix
open scoped BigOperators
noncomputable section

/-- Fixed row-major block coordinate. -/
def coordinate (e : ℕ) : ZMod (CyclotomicRing.dimension e) × Fin (CyclotomicRing.degree e) ≃ Fin (D e) :=
  (Equiv.prodCongr (ZMod.finEquiv (CyclotomicRing.dimension e)).symm.toEquiv
    (Equiv.refl (Fin (CyclotomicRing.degree e)))).trans finProdFinEquiv

lemma regular_apply (e : ℕ)
    (A : Matrix (ZMod (CyclotomicRing.dimension e)) (ZMod (CyclotomicRing.dimension e)) (CyclotomicRing.R e))
    (i j : Fin (D e)) : regular e A i j = CyclotomicRing.rho e
      (A ((coordinate e).symm i).1 ((coordinate e).symm j).1)
      ((coordinate e).symm i).2 ((coordinate e).symm j).2 := rfl

/-- Exact integer Taylor matrices, with the same fixed order of residues. -/
def integerTest (N e : ℕ) (a t : ℤ) :
    Matrix (ZMod (CyclotomicRing.dimension e)) (ZMod (CyclotomicRing.dimension e)) ℤ :=
  (IntegralTest.padded (CyclotomicRing.dimension e) N a t).reindex
    (ZMod.finEquiv (CyclotomicRing.dimension e)).toEquiv
    (ZMod.finEquiv (CyclotomicRing.dimension e)).toEquiv

/-- The common-denominator-cleared regular matrices used in exact arithmetic. -/
def U (n N e : ℕ) (x : Fin 3 → ℕ) (a : Fin (n+1)) : Matrix (Fin (D e)) (Fin (D e)) ℤ :=
  fun i j => IntegralLift.entry e (integerTest N e (a.val : ℤ) (x 0 : ℤ))
    (x 1 : ℤ) (x 2 : ℤ) ((coordinate e).symm i).1 ((coordinate e).symm j).1
      ((coordinate e).symm i).2 ((coordinate e).symm j).2

lemma U_cast (n N e : ℕ) (x : Fin 3 → ℕ) (a : Fin (n+1)) :
    (U n N e x a).map (Int.castRingHom ℚ) = (CyclotomicRing.dimension e : ℚ) • Z n N e x a := by
  ext i j
  change (U n N e x a i j : ℚ) = (CyclotomicRing.dimension e : ℚ) * regular e (Zring n N e x a) i j
  rw [regular_apply]
  unfold U
  have hh := IntegralLift.entry_spec e
    (PencilDeformation.test (CyclotomicRing.dimension e) N (a.val : CyclotomicRing.R e))
    (integerTest N e (a.val : ℤ) (x 0 : ℤ)) (x 0 : ℤ) (x 1 : ℤ) (x 2 : ℤ)
    (fun u v => by
      simp only [PencilDeformation.test,integerTest,Matrix.reindex_apply]
      simpa only [Int.cast_natCast,Matrix.submatrix_apply] using IntegralTest.padded_cast (K := CyclotomicRing.R e) (CyclotomicRing.dimension e)
        N (a.val : ℤ) (x 0 : ℤ) _ _)
    ((coordinate e).symm i).1 ((coordinate e).symm j).1
    ((coordinate e).symm i).2 ((coordinate e).symm j).2
  have hx : (fun j : Fin 3 => (x j : CyclotomicRing.R e)) =
      ![(x 0 : CyclotomicRing.R e),(x 1 : CyclotomicRing.R e),(x 2 : CyclotomicRing.R e)] := by
    funext j
    fin_cases j <;> rfl
  simpa only [Zring,PencilCertificates.lifts,RingHom.mapMatrix_apply,Matrix.map_apply,
    MvPolynomial.coe_eval₂Hom,MvPolynomial.eval₂_id,Int.cast_natCast,hx] using hh

lemma U_bound (n N e H : ℕ) (x : Fin 3 → ℕ) (hH : 1 ≤ H) (hx : ∀ l, x l ≤ H)
    (a : Fin (n+1)) (i j : Fin (D e)) :
    |U n N e x a i j| ≤ (CyclotomicRing.dimension e : ℤ)^4 *
      (2*(n+1) : ℤ)^(2*CyclotomicRing.dimension e) * (H : ℤ)^(3*CyclotomicRing.dimension e) := by
  have hT (u v) : |integerTest N e (a.val : ℤ) (x 0 : ℤ) u v| ≤
      (CyclotomicRing.dimension e : ℤ)*(2*(n+1) : ℤ)^(2*CyclotomicRing.dimension e)*(H : ℤ)^CyclotomicRing.dimension e := by
    apply IntegralTest.padded_bound _ _ _ _ (n+1) H (by omega) hH
    · rw [Int.abs_natCast]; exact_mod_cast (Nat.le_of_lt a.isLt)
    · rw [Int.abs_natCast]; exact_mod_cast hx 0
  have hh := IntegralLift.entry_bound e (integerTest N e (a.val : ℤ) (x 0 : ℤ))
    (x 1 : ℤ) (x 2 : ℤ)
    (CyclotomicRing.dimension e*(2*(n+1))^(2*CyclotomicRing.dimension e)*H^CyclotomicRing.dimension e)
    H (by simpa using hT) hH (by simpa using hx 1) (by simpa using hx 2)
    ((coordinate e).symm i).1 ((coordinate e).symm j).1
    ((coordinate e).symm i).2 ((coordinate e).symm j).2
  apply hh.trans_eq
  push_cast
  rw [show 3*CyclotomicRing.dimension e = CyclotomicRing.dimension e+2*CyclotomicRing.dimension e by omega,pow_add]
  ring

lemma scaled_normalization {d : ℕ} (A B : Mat d) (hA : A.det ≠ 0) (c : ℚ) (hc : c ≠ 0) :
    (c • A)⁻¹ * (c • B) = A⁻¹*B := by
  let : Invertible c := invertibleOfNonzero hc
  have hi : (c • A)⁻¹ = c⁻¹ • A⁻¹ := by
    simpa only [invOf_eq_inv] using (Matrix.inv_smul (A := A) c (isUnit_iff_ne_zero.mpr hA))
  rw [hi,Matrix.smul_mul,Matrix.mul_smul,smul_smul]
  simp [hc]

lemma tupleAt_integer (n N e : ℕ) (x : Fin 3 → ℕ) (hz : (Z n N e x 0).det ≠ 0)
    (a : Fin n) :
    tupleAt n N e x a = ((U n N e x 0).map (Int.castRingHom ℚ))⁻¹ *
      (U n N e x a.succ).map (Int.castRingHom ℚ) := by
  rw [U_cast,U_cast,scaled_normalization _ _ hz _ (by exact_mod_cast (CyclotomicRing.dimension_pos e).ne')]
  rfl

lemma U_det_ne_zero (n N e : ℕ) (x : Fin 3 → ℕ) (hz : (Z n N e x 0).det ≠ 0) :
    (U n N e x 0).det ≠ 0 := by
  have hu : ((U n N e x 0).map (Int.castRingHom ℚ)).det ≠ 0 := by
    rw [U_cast,Matrix.det_smul]
    exact mul_ne_zero (pow_ne_zero _ (by exact_mod_cast (CyclotomicRing.dimension_pos e).ne')) hz
  have he : ((U n N e x 0).map (Int.castRingHom ℚ)).det = ((U n N e x 0).det : ℚ) :=
    (Int.cast_det _).symm
  rw [he] at hu
  exact_mod_cast hu

end
end RationalHitting.Generator

end OAI