File size: 14,875 Bytes
760f90e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 | import OAI.Computability.RationalHitting.IntegralLift
namespace OAI
namespace RationalHitting.EncodingBounds
open Matrix
open scoped BigOperators
lemma encodeNat_length (a : ℕ) : (encodeNat a).length = 2*(Nat.digits 2 a).length+1 := by
simp [encodeNat]
omega
lemma encodeNat_le (a L : ℕ) (ha : a < 2^L) : (encodeNat a).length ≤ 2*L+1 := by
rw [encodeNat_length]
exact Nat.add_le_add_right (Nat.mul_le_mul_left 2 ((Nat.digits_length_le_iff (by omega) a).mpr ha)) 1
lemma ratio_num_le (a b : ℤ) (hb : b ≠ 0) : (Rat.divInt a b).num.natAbs ≤ a.natAbs := by
by_cases ha : a = 0
· simp [ha]
· exact Int.natAbs_le_of_dvd_ne_zero (Rat.num_dvd a hb) ha
lemma ratio_den_le (a b : ℤ) (hb : b ≠ 0) : (Rat.divInt a b).den ≤ b.natAbs := by
simpa only [Int.natAbs_natCast] using Int.natAbs_le_of_dvd_ne_zero (Rat.den_dvd a b) hb
lemma encodeRat_ratio_le (a b : ℤ) (hb : b ≠ 0) (L : ℕ)
(ha : a.natAbs < 2^L) (hb' : b.natAbs < 2^L) :
(encodeRat (Rat.divInt a b)).length ≤ 4*L+3 := by
have hn := encodeNat_le _ L (lt_of_le_of_lt (ratio_num_le a b hb) ha)
have hd := encodeNat_le _ L (lt_of_le_of_lt (ratio_den_le a b hb) hb')
simp only [encodeRat,List.length_append,List.length_singleton]
omega
lemma determinant_bound {d : ℕ} (A : Matrix (Fin d) (Fin d) ℤ) (B : ℕ)
(hA : ∀ i j, |A i j| ≤ B) : |A.det| ≤ (d.factorial : ℤ)*(B : ℤ)^d := by
rw [Matrix.det_apply]
apply (Finset.abs_sum_le_sum_abs _ _).trans
calc ∑ σ : Equiv.Perm (Fin d), |Equiv.Perm.sign σ • ∏ i, A (σ i) i| ≤
∑ _σ : Equiv.Perm (Fin d), (B : ℤ)^d := by
apply Finset.sum_le_sum
intro σ _
rw [Units.smul_def, zsmul_eq_mul, abs_mul]
have hsign : |((Equiv.Perm.sign σ : ℤˣ) : ℤ)| = 1 := by
rcases Int.units_eq_one_or (Equiv.Perm.sign σ) with h | h <;> rw [h] <;> norm_num
change |((Equiv.Perm.sign σ : ℤˣ) : ℤ)| * |∏ i, A (σ i) i| ≤ (B : ℤ)^d
rw [hsign]
rw [one_mul,Finset.abs_prod]
calc ∏ i, |A (σ i) i| ≤ ∏ _i : Fin d, (B : ℤ) :=
Finset.prod_le_prod₀ (fun _ _ => abs_nonneg _) (fun _ _ => hA _ _)
_ = _ := by simp
_ = _ := by simp [Fintype.card_perm]
/-- Cramer's rule used by the generator, without any assumption on arithmetic algorithms. -/
lemma normalized_entry_ratio {d : ℕ} (A B : Matrix (Fin d) (Fin d) ℤ) (hA : A.det ≠ 0)
(i j : Fin d) :
((A.map (Int.castRingHom ℚ))⁻¹ * B.map (Int.castRingHom ℚ)) i j =
Rat.divInt ((A.updateCol i (fun k => B k j)).det) A.det := by
let AQ := A.map (Int.castRingHom ℚ)
have hdet : AQ.det ≠ 0 := by
change (A.map (fun z : ℤ => (z : ℚ))).det ≠ 0
rw [← Int.cast_det]
exact_mod_cast hA
have h := Matrix.det_smul_inv_mulVec_eq_cramer AQ ((B.map (Int.castRingHom ℚ)).col j)
(isUnit_iff_ne_zero.mpr hdet)
have hi := congrFun h i
simp only [Pi.smul_apply,smul_eq_mul,Matrix.cramer_apply] at hi
have hcol : AQ.updateCol i ((B.map (Int.castRingHom ℚ)).col j) =
(A.updateCol i (fun k => B k j)).map (Int.castRingHom ℚ) := by
ext a b
simp [AQ,Matrix.updateCol_apply,Matrix.col,Matrix.map_apply]
rw [hcol] at hi
change AQ.det * (AQ⁻¹ *ᵥ (B.map (Int.castRingHom ℚ)).col j) i =
((A.updateCol i (fun k => B k j)).map (fun z : ℤ => (z : ℚ))).det at hi
rw [← Int.cast_det] at hi
change AQ.det * (AQ⁻¹ * B.map (Int.castRingHom ℚ)) i j = _ at hi
rw [Rat.divInt_eq_div]
apply (eq_div_iff (show (A.det : ℚ) ≠ 0 from by exact_mod_cast hA)).mpr
rw [mul_comm]
have he : AQ.det = (A.det : ℚ) := (Int.cast_det A).symm
rw [he] at hi
exact hi
lemma nat_le_two_pow (n : ℕ) : n ≤ 2^n := by
induction n with
| zero => norm_num
| succ n ih =>
rw [pow_succ]
have : 0 < 2^n := by positivity
omega
lemma determinant_pow_bound {d b : ℕ} (A : Matrix (Fin d) (Fin d) ℤ)
(hA : ∀ i j, |A i j| ≤ (2 : ℤ)^b) : |A.det| < (2 : ℤ)^(d*d+d*b+1) := by
have hb := determinant_bound A (2^b) (by simpa using hA)
have hf : d.factorial ≤ (2^d)^d :=
(Nat.factorial_le_pow d).trans (Nat.pow_le_pow_left ((nat_le_two_pow d)) d)
have hfc : (d.factorial : ℤ) ≤ ((2 : ℤ)^d)^d := by exact_mod_cast hf
have hn : |A.det| ≤ (2 : ℤ)^(d*d+d*b) := by
calc |A.det| ≤ (d.factorial : ℤ)*((2 : ℤ)^b)^d := by simpa using hb
_ ≤ ((2 : ℤ)^d)^d*((2 : ℤ)^b)^d := mul_le_mul_of_nonneg_right hfc (by positivity)
_ = _ := by rw [← pow_mul,← pow_mul,← pow_add]; congr 1; ring
apply hn.trans_lt
rw [pow_succ]
have : (0 : ℤ) < 2^(d*d+d*b) := by positivity
omega
lemma normalization_bit_bound {d b : ℕ} (A B : Matrix (Fin d) (Fin d) ℤ) (hA : A.det ≠ 0)
(hAb : ∀ i j, |A i j| ≤ (2 : ℤ)^b) (hBb : ∀ i j, |B i j| ≤ (2 : ℤ)^b) (i j : Fin d) :
(encodeRat (((A.map (Int.castRingHom ℚ))⁻¹ * B.map (Int.castRingHom ℚ)) i j)).length ≤
4*(d*d+d*b+1)+3 := by
rw [normalized_entry_ratio A B hA i j]
apply encodeRat_ratio_le _ _ hA
· have h := determinant_pow_bound (A.updateCol i (fun k => B k j)) (b := b) (by
intro a c
by_cases hc : c = i
· simpa [Matrix.updateCol_apply,hc] using hBb a j
· simpa [Matrix.updateCol_apply,hc] using hAb a c)
rw [← Int.natCast_natAbs] at h
exact_mod_cast h
· have h := determinant_pow_bound A hAb
rw [← Int.natCast_natAbs] at h
exact_mod_cast h
end RationalHitting.EncodingBounds
namespace RationalHitting.EncodingBounds
lemma flatMap_length_le {α β : Type*} (l : List α) (f : α → List β) (B : ℕ)
(h : ∀ a ∈ l, (f a).length ≤ B) : (l.flatMap f).length ≤ l.length*B := by
induction l with
| nil => simp
| cons a l ih =>
simp only [List.flatMap_cons,List.length_append,List.length_cons]
have ha := h a (by simp)
have hl := ih (fun b hb => h b (by simp [hb]))
simp only [Nat.add_mul,Nat.one_mul]
omega
lemma tuple_length_le {n d B : ℕ} (X : Tuple n d)
(h : ∀ a i j, (encodeRat (X a i j)).length ≤ B) :
(encodeTuple X).length ≤ n*d*d*B := by
unfold encodeTuple
calc _ ≤ (List.finRange n).length*(d*(d*B)) := by
apply flatMap_length_le
intro a _
calc _ ≤ (List.finRange d).length*(d*B) := by
apply flatMap_length_le
intro i _
calc _ ≤ (List.finRange d).length*B := flatMap_length_le _ _ B (fun j _ => h a i j)
_ = _ := by simp
_ = _ := by simp
_ = _ := by simp [Nat.mul_assoc]
lemma encodeNat_linear (a : ℕ) : (encodeNat a).length ≤ 2*(a+1)+1 := by
apply encodeNat_le
have h := nat_le_two_pow a
have hp : 0 < 2^a := by positivity
rw [pow_succ]
omega
lemma output_length_le {n B : ℕ} (H : Output n)
(hb : ∀ X ∈ H.tuples, ∀ a i j, (encodeRat (X a i j)).length ≤ B) :
(encodeOutput H).length ≤ 2*(H.dimension+1)+1 + 2*(H.tuples.length+1)+1 +
H.tuples.length*n*H.dimension*H.dimension*B := by
have hd := encodeNat_linear H.dimension
have hc := encodeNat_linear H.tuples.length
have ht := flatMap_length_le H.tuples encodeTuple (n*H.dimension*H.dimension*B)
(fun X hX => tuple_length_le X (hb X hX))
simp only [encodeOutput,List.length_append] at *
rw [← Nat.mul_assoc,← Nat.mul_assoc,← Nat.mul_assoc] at ht
omega
end RationalHitting.EncodingBounds
namespace RationalHitting.PolynomialBounds
/-- Coefficient/exponent bookkeeping, with no symbolic expansion of large powers. -/
lemma mul_monomials (a b m i j : ℕ) : (a*m^i)*(b*m^j) = (a*b)*m^(i+j) := by
rw [pow_add]
ac_rfl
lemma lift_power (c m i j : ℕ) (hm : 1 ≤ m) (hij : i ≤ j) : c*m^i ≤ c*m^j :=
Nat.mul_le_mul_left c (Nat.pow_le_pow_right hm hij)
lemma one_le_pow (m k : ℕ) (hm : 1 ≤ m) : 1 ≤ m^k :=
Nat.one_le_pow k m hm
/-- Exponent bounding all denominator-cleared matrix entries by a power of 2. -/
def logarithmic (n s : ℕ) : ℕ :=
4*Parameters.M n s + 4*Parameters.M n s*(n+1) + 3*Parameters.M n s*Parameters.H n s
def logConstant : ℕ := 64+64+3*16*24577
theorem logarithmic_bound (n s : ℕ) (hn : 1 ≤ n) :
logarithmic n s ≤ logConstant*(n+s+1)^22 := by
let m := n+s+1
have hm : 1 ≤ m := by dsimp [m]; omega
have hM := Parameters.polynomial_M n s
have hH := Parameters.polynomial_H n s hn
have h₁ : 4*Parameters.M n s ≤ 64*m^22 := by
calc _ ≤ 4*(16*m^5) := Nat.mul_le_mul_left 4 hM
_ = 64*m^5 := by rw [← Nat.mul_assoc]
_ ≤ _ := lift_power _ _ _ _ hm (by omega)
have h₂ : 4*Parameters.M n s*(n+1) ≤ 64*m^22 := by
calc _ ≤ (64*m^5)*m := by
apply Nat.mul_le_mul
· calc _ ≤ 4*(16*m^5) := Nat.mul_le_mul_left 4 hM
_ = _ := by rw [← Nat.mul_assoc]
· dsimp [m]; omega
_ = 64*m^6 := by rw [show m^6 = m^5*m from pow_succ m 5,Nat.mul_assoc]
_ ≤ _ := lift_power _ _ _ _ hm (by omega)
have h₃ : 3*Parameters.M n s*Parameters.H n s ≤ (3*16*24577)*m^22 := by
calc _ ≤ (3*(16*m^5))*(24577*m^17) := Nat.mul_le_mul (Nat.mul_le_mul_left 3 hM) hH
_ = (48*m^5)*(24577*m^17) := by rw [← Nat.mul_assoc 3 16]
_ = _ := mul_monomials 48 24577 m 5 17
unfold logarithmic logConstant
change _ ≤ (64+64+3*16*24577)*m^22
rw [Nat.add_mul,Nat.add_mul]
exact Nat.add_le_add (Nat.add_le_add h₁ h₂) h₃
def bitConstant : ℕ := 4*(256*256+256*logConstant+1)+3
theorem normalized_bits_bound (m D b : ℕ) (hm : 1 ≤ m)
(hD : D ≤ 256*m^10) (hb : b ≤ logConstant*m^22) :
4*(D*D+D*b+1)+3 ≤ bitConstant*m^32 := by
have h₁ : D*D ≤ (256*256)*m^32 := by
calc _ ≤ (256*m^10)*(256*m^10) := Nat.mul_le_mul hD hD
_ = (256*256)*m^20 := mul_monomials ..
_ ≤ _ := lift_power _ _ _ _ hm (by omega)
have h₂ : D*b ≤ (256*logConstant)*m^32 := by
calc _ ≤ (256*m^10)*(logConstant*m^22) := Nat.mul_le_mul hD hb
_ = _ := mul_monomials ..
have hp := one_le_pow m 32 hm
unfold bitConstant
rw [Nat.add_mul,Nat.mul_assoc,Nat.add_mul,Nat.add_mul,one_mul]
omega
def outputConstant : ℕ := (2*256+3) + (2*24577^3+3) + 24577^3*256*256*bitConstant
theorem output_bits_bound (n m D L B : ℕ) (hm : 1 ≤ m) (hn : n ≤ m)
(hD : D ≤ 256*m^10) (hL : L ≤ 24577^3*m^51) (hB : B ≤ bitConstant*m^32) :
2*(D+1)+1 + 2*(L+1)+1 + L*n*D*D*B ≤ outputConstant*m^104 := by
have hp := one_le_pow m 104 hm
have hd : D ≤ 256*m^104 := hD.trans (lift_power _ _ _ _ hm (by omega))
have hl : L ≤ 24577^3*m^104 := hL.trans (lift_power _ _ _ _ hm (by omega))
have hproduct : L*n*D*D*B ≤ (24577^3*256*256*bitConstant)*m^104 := by
calc _ ≤ (24577^3*m^51)*m*(256*m^10)*(256*m^10)*(bitConstant*m^32) := by
gcongr
_ = _ := by
have hh := mul_monomials (24577^3*256*256) bitConstant m 72 32
calc _ = ((24577^3*256*256)*m^72)*(bitConstant*m^32) := by
congr 1
calc _ = ((24577^3*256)*m^62)*(256*m^10) := by
congr 1
calc _ = (24577^3*m^52)*(256*m^10) := by
congr 1
rw [show m^52=m^51*m from pow_succ m 51,Nat.mul_assoc]
_ = _ := mul_monomials _ _ _ _ _
_ = _ := mul_monomials _ _ _ _ _
_ = _ := hh
unfold outputConstant
rw [Nat.add_mul,Nat.add_mul,Nat.add_mul,Nat.add_mul]
omega
end RationalHitting.PolynomialBounds
namespace RationalHitting.Generator
open Matrix EncodingBounds
open scoped BigOperators
noncomputable section
lemma U_power_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| ≤ (2 : ℤ)^(4*CyclotomicRing.dimension e +
4*CyclotomicRing.dimension e*(n+1)+3*CyclotomicRing.dimension e*H) := by
let M := CyclotomicRing.dimension e
have hM : (M : ℤ) ≤ 2^M := by exact_mod_cast nat_le_two_pow M
have hn : (2*(n+1) : ℤ) ≤ 2^(2*(n+1)) := by exact_mod_cast nat_le_two_pow (2*(n+1))
have hh : (H : ℤ) ≤ 2^H := by exact_mod_cast nat_le_two_pow H
calc _ ≤ (M : ℤ)^4*(2*(n+1) : ℤ)^(2*M)*(H : ℤ)^(3*M) := U_bound n N e H x hH hx a i j
_ ≤ ((2 : ℤ)^M)^4*((2 : ℤ)^(2*(n+1)))^(2*M)*((2 : ℤ)^H)^(3*M) := by
gcongr
_ = _ := by
simp only [← pow_mul,← pow_add]
congr 1
dsimp [M]
ring
lemma tupleAt_bit_bound (n N e H : ℕ) (x : Fin 3 → ℕ) (hH : 1 ≤ H) (hx : ∀ l, x l ≤ H)
(hz : (Z n N e x 0).det ≠ 0) (a : Fin n) (i j : Fin (D e)) :
(encodeRat (tupleAt n N e x a i j)).length ≤
4*(D e*D e+D e*(4*CyclotomicRing.dimension e +
4*CyclotomicRing.dimension e*(n+1)+3*CyclotomicRing.dimension e*H)+1)+3 := by
rw [tupleAt_integer n N e x hz a]
exact normalization_bit_bound _ _ (U_det_ne_zero n N e x hz)
(U_power_bound n N e H x hH hx 0) (U_power_bound n N e H x hH hx a.succ) i j
lemma output_entry_bit_bound (n N e H : ℕ) (hH : 1 ≤ H)
(X : Tuple n (D e)) (hX : X ∈ (output n N e H).tuples)
(a : Fin n) (i j : Fin (D e)) :
(encodeRat (X a i j)).length ≤
4*(D e*D e+D e*(4*CyclotomicRing.dimension e +
4*CyclotomicRing.dimension e*(n+1)+3*CyclotomicRing.dimension e*H)+1)+3 := by
obtain ⟨x,hx,he⟩ := List.mem_filterMap.mp hX
by_cases hz : (Z n N e (fun l => (x l).val+1) 0).det = 0
· simp [atPoint,hz] at he
· simp only [atPoint,ite_eq_right hz,Option.some.injEq] at he
rw [← he]
exact tupleAt_bit_bound n N e H _ hH (fun l => by omega) hz a i j
lemma list_output_bound (n s : ℕ) (hn : 1 ≤ n) :
(encodeOutput (list n s)).length ≤ PolynomialBounds.outputConstant*(n+s+1)^104 := by
have hH : 1 ≤ Parameters.H n s := by unfold Parameters.H; omega
have hb : ∀ X ∈ (list n s).tuples, ∀ a i j,
(encodeRat (X a i j)).length ≤ PolynomialBounds.bitConstant*(n+s+1)^32 := by
intro X hX a i j
apply (output_entry_bit_bound n (Parameters.N n s) (Parameters.exponent n s)
(Parameters.H n s) hH X hX a i j).trans
apply PolynomialBounds.normalized_bits_bound (hm := by omega)
· exact list_dimension_bound n s
· exact PolynomialBounds.logarithmic_bound n s hn
apply (output_length_le (list n s) hb).trans
apply PolynomialBounds.output_bits_bound (hm := by omega) (hn := by omega)
· exact list_dimension_bound n s
· exact list_length_bound n s hn
· exact Nat.le_refl _
end
end RationalHitting.Generator
/-! A staged division-free determinant computation for integer matrices.
Explicit dense tables prevent recursive matrix-entry recomputation. -/
end OAI
|