| import OAI.NumberTheory.SingleFold.Pell |
|
|
| namespace OAI |
|
|
| namespace SingleFold.PowerEstimate |
| lemma choose_ell (hδ : 0 < δ) : ∃ ell : ℕ, 1 ≤ ell ∧ 3 < δ*(ell:ℝ)*Real.log 2 := by |
| have hlog : 0 < Real.log (2:ℝ) := Real.log_pos (by norm_num) |
| obtain ⟨ell,hell⟩ := exists_nat_gt (3/(δ*Real.log 2)) |
| refine ⟨ell,?_,?_⟩ |
| · have : (0:ℝ) < ell := lt_trans (div_pos (by norm_num) (mul_pos hδ hlog)) hell |
| have hp : 0<ell := by exact_mod_cast this |
| omega |
| · have hh := (div_lt_iff₀ (mul_pos hδ hlog)).mp hell |
| nlinarith |
|
|
| def input (ell u₀ b n c : ℕ) := (c+1)^ell*(n+1)*(b+1)+u₀ |
| lemma input_bounds (hell : 1≤ell) (h₀ : 4≤u₀) : |
| u₀ ≤ input ell u₀ b n c ∧ (c+1)*(n+1)+4 ≤ input ell u₀ b n c ∧ |
| b < input ell u₀ b n c ∧ n+1 < input ell u₀ b n c-1 := by |
| have hp : c+1≤(c+1)^ell := Nat.le_pow hell |
| have h1 : 1≤(c+1)^ell*(n+1) := by |
| have : 0<(c+1)^ell*(n+1) := by positivity |
| omega |
| have hn : n+1≤(c+1)^ell*(n+1) := by nlinarith |
| have hm := Nat.mul_le_mul_right (n+1) hp |
| dsimp [input] |
| constructor; omega |
| constructor; nlinarith |
| constructor |
| · nlinarith |
| · have hnn : n+1+4≤(c+1)^ell*(n+1)*(b+1)+u₀ := by nlinarith |
| omega |
|
|
| lemma growth_nat (hδ : 0 < δ) (hu : 4≤u) |
| (hg : δ*(Real.log (u:ℝ))^2 < Real.log (g u:ℝ) ∧ Real.log (g u:ℝ)<(u:ℝ)*Real.log (u:ℝ)) : |
| 0<g u ∧ g u<u^u := by |
| have hu' : (1:ℝ)<u := by exact_mod_cast (show 1<u by omega) |
| have hlog : 0<Real.log (u:ℝ) := Real.log_pos hu' |
| have hglog : 0<Real.log (g u:ℝ) := lt_trans (mul_pos hδ (sq_pos_of_pos hlog)) hg.1 |
| have hgp : 0<g u := by |
| by_contra h |
| have he : g u=0 := by omega |
| simp [he] at hglog |
| refine ⟨hgp,?_⟩ |
| have hup : (0:ℝ)<(u:ℝ)^u := pow_pos (by linarith) _ |
| have hlg : Real.log (g u:ℝ)<Real.log ((u:ℝ)^u) := by simpa only [Real.log_pow] using hg.2 |
| have hh := (Real.log_lt_log_iff (by exact_mod_cast hgp) hup).mp hlg |
| exact_mod_cast hh |
|
|
| lemma cutoff (hδ : 0<δ) (hell : 1≤ell) |
| (hell' : 3<δ*(ell:ℝ)*Real.log 2) (h₀ : 4≤u₀) (hb : 2≤b) : |
| let u := input ell u₀ b n (b^n) |
| Real.log (((2*(b*u))^n:ℕ):ℝ) < δ*(Real.log (u:ℝ))^2 := by |
| dsimp only |
| let u := input ell u₀ b n (b^n) |
| have hbounds := input_bounds (c:=b^n) (b:=b) (n:=n) hell h₀ |
| have hu : 4≤u := h₀.trans hbounds.1 |
| have hbu : b<u := hbounds.2.2.1 |
| have hb' : (2:ℝ)≤b := by exact_mod_cast hb |
| have hu' : (2:ℝ)<u := by exact_mod_cast (show 2<u by omega) |
| have hbp : (0:ℝ)<b := by linarith |
| have hup : (0:ℝ)<u := by linarith |
| have hlog : 0<Real.log (u:ℝ) := Real.log_pos (by linarith) |
| have hl2 : 0<Real.log (2:ℝ) := Real.log_pos (by norm_num) |
| have hlb : Real.log (2:ℝ)≤Real.log (b:ℝ) := Real.log_le_log (by norm_num) hb' |
| have hpu : (b^n)^ell≤u := by |
| have hp : (b^n)^ell≤(b^n+1)^ell := Nat.pow_le_pow_left (by omega) _ |
| dsimp [u,input] |
| have hpn : (b^n+1)^ell≤(b^n+1)^ell*(n+1) := Nat.le_mul_of_pos_right _ (by omega) |
| exact hp.trans (hpn.trans ((Nat.le_mul_of_pos_right _ (by omega : 0<b+1)).trans (Nat.le_add_right _ _))) |
| have hlogu : (ell:ℝ)*(n:ℝ)*Real.log (b:ℝ)≤Real.log (u:ℝ) := by |
| have hp : (0:ℝ)<((b:ℝ)^n)^ell := pow_pos (pow_pos hbp _) _ |
| have hh : ((b:ℝ)^n)^ell≤(u:ℝ) := by exact_mod_cast hpu |
| have hh' := Real.log_le_log hp hh |
| simpa only [Real.log_pow,mul_assoc] using hh' |
| have hnu : (ell:ℝ)*(n:ℝ)*Real.log 2≤Real.log (u:ℝ) := by |
| exact (mul_le_mul_of_nonneg_left hlb (by positivity : 0≤(ell:ℝ)*(n:ℝ))).trans hlogu |
| have htriple : Real.log (2*(b:ℝ)*u) ≤ 3*Real.log (u:ℝ) := by |
| rw [Real.log_mul (mul_pos (by norm_num) hbp).ne' hup.ne', Real.log_mul (by norm_num) hbp.ne'] |
| have hh1 := Real.log_le_log (by norm_num : (0:ℝ)<2) hu'.le |
| have hh2 := Real.log_le_log hbp (show (b:ℝ)≤u by exact_mod_cast hbu.le) |
| linarith |
| have hsmall : 3*(n:ℝ) < δ*Real.log (u:ℝ) := by |
| have hh := mul_le_mul_of_nonneg_left hnu hδ.le |
| by_cases hn : n=0 |
| · subst n; simpa using mul_pos hδ hlog |
| · have hn' : (0:ℝ)<n := by exact_mod_cast Nat.pos_of_ne_zero hn |
| have ht := mul_lt_mul_of_pos_right hell' hn' |
| nlinarith |
| have hl : Real.log (((2*(b*u))^n:ℕ):ℝ)=(n:ℝ)*Real.log (2*(b:ℝ)*u) := by |
| push_cast; rw [Real.log_pow]; congr 2; ring |
| rw [hl] |
| have hh := mul_le_mul_of_nonneg_left htriple (Nat.cast_nonneg n : (0:ℝ)≤n) |
| have hh' := mul_lt_mul_of_pos_right hsmall hlog |
| nlinarith |
| end SingleFold.PowerEstimate |
|
|
| namespace SingleFold.PowerSystem |
| open PowerEstimate |
|
|
| def System (g : ℕ → ℕ) (ell u₀ b n c : ℕ) (w : Fin 9 → ℕ) : Prop := |
| 2≤b ∧ w 0=input ell u₀ b n c ∧ w 1=g (w 0) ∧ |
| (w 2)^2+(w 3)^2=1+(b*w 0)^2*(w 3)^2 ∧ |
| (w 4)^2+(w 5)^2=1+(w 0)^2*(w 5)^2 ∧ |
| 0<w 3 ∧ w 3<w 1 ∧ 0<w 5 ∧ w 5<w 1 ∧ |
| w 3=n+1+(b*w 0-1)*w 6 ∧ w 5=n+1+(w 0-1)*w 7 ∧ |
| w 3=c*w 5+w 8 ∧ w 8<w 5 |
| lemma pell_eq (ha : 1<a) : |
| X^2+F^2=1+a^2*F^2 ↔ X^2=1+(a^2-1)*F^2 := by |
| have hh : a^2-1+1=a^2 := Nat.sub_add_cancel (by nlinarith) |
| constructor <;> intro h <;> nlinarith |
|
|
| noncomputable def px (a n : ℕ) : ℕ := if ha : 1<a then Pell.xn ha n else 0 |
| noncomputable def py (a n : ℕ) : ℕ := if ha : 1<a then Pell.yn ha n else 0 |
| lemma coords_eq (ha : 1<a) (n : ℕ) : |
| (Pell.xn ha n)^2+(Pell.yn ha n)^2=1+a^2*(Pell.yn ha n)^2 := by |
| have hh := Pell.pell_eq ha n |
| change Pell.xn ha n*Pell.xn ha n-(a*a-1)*Pell.yn ha n*Pell.yn ha n=1 at hh |
| have hh' : Pell.xn ha n*Pell.xn ha n=1+(a*a-1)*Pell.yn ha n*Pell.yn ha n := by omega |
| apply (pell_eq ha).mpr |
| simpa only [pow_two,Nat.mul_assoc] using hh' |
| variable |
| variable (hδ : 0<δ) (hell : 1≤ell) (h₀ : 4≤u₀) |
| variable (hg : ∀ u, u₀≤u → δ*(Real.log (u:ℝ))^2<Real.log (g u:ℝ) ∧ Real.log (g u:ℝ)<(u:ℝ)*Real.log (u:ℝ)) |
| include hδ hell h₀ hg |
| lemma pinned (hw : System g ell u₀ b n c w) : |
| w 2=px (b*w 0) (n+1) ∧ w 3=py (b*w 0) (n+1) ∧ |
| w 4=px (w 0) (n+1) ∧ w 5=py (w 0) (n+1) := by |
| rcases hw with ⟨hb,hu,hv,hX,hY,hF,hFv,hH,hHv,hq,hq',hdiv,hr⟩ |
| have hbds := input_bounds (c:=c) (n:=n) (b:=b) hell h₀ |
| rw [←hu] at hbds |
| have hu4 : 4≤w 0 := h₀.trans hbds.1 |
| have hgu := growth_nat hδ hu4 (hg _ hbds.1) |
| have hla : w 0≤b*w 0 := by nlinarith |
| have hba : 1<b*w 0 := by nlinarith |
| have hua : 1<w 0 := by omega |
| have ha := PellSystem.pell_pinned hu4 hla hbds.2.2.2 ((pell_eq hba).mp hX) (by omega) hq |
| have hh := PellSystem.pell_pinned hu4 (le_refl (w 0)) hbds.2.2.2 ((pell_eq hua).mp hY) (by omega) hq' |
| simpa only [px,py,dite_eq_left hba,dite_eq_left hua] using And.intro ha.1 (And.intro ha.2 hh) |
| lemma sound (hw : System g ell u₀ b n c w) : 2≤b ∧ c=b^n := by |
| have hp := pinned hδ hell h₀ hg hw |
| have hbds := input_bounds (c:=c) (n:=n) (b:=b) hell h₀ |
| rcases hw with ⟨hb,hu,hv,hX,hY,hF,hFv,hH,hHv,hq,hq',hdiv,hr⟩ |
| rw [←hu] at hbds |
| rw [hp.2.1,hp.2.2.2] at hdiv |
| rw [hp.2.2.2] at hr |
| have hua : 1<w 0 := by omega |
| have hba : 1<b*w 0 := by nlinarith |
| simp only [py,dite_eq_left hua,dite_eq_left hba] at hdiv hr |
| exact ⟨hb,PellSystem.quotient_sound hb hbds.2.1 hdiv hr⟩ |
| lemma unique {b n c : ℕ} {w w' : Fin 9 → ℕ} (hw : System g ell u₀ b n c w) (hw' : System g ell u₀ b n c w') : w=w' := by |
| have hp := pinned hδ hell h₀ hg hw |
| have hp' := pinned hδ hell h₀ hg hw' |
| rcases hw with ⟨hb,hu,hv,hX,hY,hF,hFv,hH,hHv,hq,hq',hdiv,hr⟩ |
| rcases hw' with ⟨_,hu',hv',hX',hY',hF',hFv',hH',hHv',hqq,hqq',hdiv',hr'⟩ |
| have h0 : w 0=w' 0 := hu.trans hu'.symm |
| have h1 : w 1=w' 1 := by rw [hv,hv',h0] |
| have h2 : w 2=w' 2 := by rw [hp.1,hp'.1,h0] |
| have h3 : w 3=w' 3 := by rw [hp.2.1,hp'.2.1,h0] |
| have h4 : w 4=w' 4 := by rw [hp.2.2.1,hp'.2.2.1,h0] |
| have h5 : w 5=w' 5 := by rw [hp.2.2.2,hp'.2.2.2,h0] |
| have hu4 : 4≤w' 0 := by rw [hu']; exact h₀.trans (input_bounds (c:=c) (n:=n) (b:=b) hell h₀).1 |
| have h6 : w 6=w' 6 := by |
| rw [h0,h3] at hq |
| have hh : 2≤b*w' 0 := by nlinarith only [hb,hu4] |
| apply Nat.eq_of_mul_eq_mul_left (show 0<b*w' 0-1 by omega) |
| omega |
| have h7 : w 7=w' 7 := by |
| rw [h0,h5] at hq' |
| apply Nat.eq_of_mul_eq_mul_left (show 0<w' 0-1 by omega) |
| omega |
| have h8 : w 8=w' 8 := by rw [h3,h5] at hdiv; omega |
| funext j; fin_cases j <;> assumption |
| lemma complete (hell' : 3<δ*(ell:ℝ)*Real.log 2) (hb : 2≤b) : |
| ∃ w, System g ell u₀ b n (b^n) w := by |
| let c := b^n |
| let u := input ell u₀ b n c |
| have hbds := input_bounds (c:=c) (n:=n) (b:=b) hell h₀ |
| have hu4 : 4≤u := h₀.trans hbds.1 |
| have hua : 1<u := by omega |
| have hba : 1<b*u := by nlinarith |
| let F := Pell.yn hba (n+1) |
| let H := Pell.yn hua (n+1) |
| have hF : 0<F := PellPower.y_positive hba (by omega) |
| have hH : 0<H := PellPower.y_positive hua (by omega) |
| have hH' : (0:ℝ)<H := by exact_mod_cast hH |
| have hrati := PellPower.ratio_bounds (show 1<b by omega) hua n |
| change (b:ℝ)^n≤(F:ℝ)/H ∧ (F:ℝ)/H≤(b:ℝ)^n*(1+1/(2*(u:ℝ)-1))^n at hrati |
| have herr := PellAnalytics.quotient_error (c:=c) hbds.2.1 (le_refl c) hH' hrati.1 hrati.2 |
| have hle : c*H≤F := by |
| have hh := (le_div_iff₀ hH').mp hrati.1 |
| exact_mod_cast hh |
| have hc : (c:ℝ)=(b:ℝ)^n := by simp only [c,Nat.cast_pow] |
| have hlt : F<(c+1)*H := by |
| have hh : (F:ℝ)/H < (c:ℝ)+1 := by linarith [herr.2] |
| have hh' := (div_lt_iff₀ hH').mp hh |
| exact_mod_cast hh' |
| let r := F-c*H |
| have hr : r<H := by |
| dsimp [r] |
| have hh : F<c*H+H := by nlinarith only [hlt] |
| omega |
| have hd : F=c*H+r := by dsimp [r]; omega |
| obtain ⟨q,hq,_⟩ := PellSystem.residue_exists hba n |
| obtain ⟨q',hq',_⟩ := PellSystem.residue_exists hua n |
| have hgrowth := hg u hbds.1 |
| have hgp := (growth_nat hδ hu4 hgrowth).1 |
| have hcut := PowerEstimate.cutoff (n:=n) hδ hell hell' h₀ hb |
| change Real.log (((2*(b*u))^n:ℕ):ℝ)<_ at hcut |
| have hbig : (2*(b*u))^n<g u := by |
| have hh := lt_trans hcut hgrowth.1 |
| have hp : (0:ℝ)<((2*(b*u))^n:ℕ) := by exact_mod_cast (show 0<(2*(b*u))^n by positivity) |
| exact_mod_cast (Real.log_lt_log_iff hp (by exact_mod_cast hgp)).mp hh |
| have hFv : F<g u := lt_of_le_of_lt (PellPower.power_bounds hba n).2 hbig |
| have hHv : H<g u := by |
| apply lt_of_le_of_lt (PellPower.power_bounds hua n).2 |
| exact lt_of_le_of_lt (Nat.pow_le_pow_left (by nlinarith only [hb] : 2*u≤2*(b*u)) n) hbig |
| refine ⟨![u,g u,Pell.xn hba (n+1),F,Pell.xn hua (n+1),H,q,q',r],?_⟩ |
| change 2≤b ∧ u=input ell u₀ b n (b^n) ∧ g u=g u ∧ |
| (Pell.xn hba (n+1))^2+F^2=1+(b*u)^2*F^2 ∧ |
| (Pell.xn hua (n+1))^2+H^2=1+u^2*H^2 ∧ |
| 0<F ∧ F<g u ∧ 0<H ∧ H<g u ∧ F=n+1+(b*u-1)*q ∧ H=n+1+(u-1)*q' ∧ F=(b^n)*H+r ∧ r<H |
| exact ⟨hb,rfl,rfl,coords_eq hba _,coords_eq hua _,hF,hFv,hH,hHv,hq,hq',hd,hr⟩ |
| end SingleFold.PowerSystem |
|
|
| namespace SingleFold.Compiler.ScalarSF |
| variable |
| lemma reindex (hf : ScalarSF f) (i : α → β) : ScalarSF (fun z => f (z ∘ i)) := |
| MapSF.reindex hf i |
| lemma sub (hf : ScalarSF f) (hg : ScalarSF g) : ScalarSF (fun z => f z-g z) := by |
| have h := ((proj (Sum.inr ())).add (hg.reindex Sum.inl)).eq |
| ((hf.reindex Sum.inl).max (hg.reindex Sum.inl)) |
| refine SF.congr h ?_ |
| intro z |
|
|
| constructor |
| · intro hh |
| funext j; cases j |
| change z (.inr ())=f (z ∘ Sum.inl)-g (z ∘ Sum.inl) |
| omega |
| · intro hh |
| have he := congrFun hh () |
| change z (.inr ())=f (z ∘ Sum.inl)-g (z ∘ Sum.inl) at he |
| omega |
| end SingleFold.Compiler.ScalarSF |
|
|
| namespace SingleFold.PowerCompilation |
| open Compiler |
| lemma system_sf (g : ℕ → ℕ) (ell u₀ : ℕ) |
| (hg : SF (fun z : Fin 2 → ℕ => z 1=g (z 0))) : |
| SF (fun z : Fin 3⊕Fin 9 → ℕ => PowerSystem.System g ell u₀ (z (.inl 0)) (z (.inl 1)) (z (.inl 2)) (z ∘ Sum.inr)) := by |
| let α := Fin 3⊕Fin 9 |
| let a (i : α) : ScalarSF (fun z : α → ℕ => z i) := ScalarSF.proj i |
| let b := a (.inl 0) |
| let n := a (.inl 1) |
| let c := a (.inl 2) |
| let u := a (.inr 0) |
| let v := a (.inr 1) |
| let X := a (.inr 2) |
| let F := a (.inr 3) |
| let Y := a (.inr 4) |
| let H := a (.inr 5) |
| let q := a (.inr 6) |
| let q' := a (.inr 7) |
| let r := a (.inr 8) |
| let k (j : ℕ) : ScalarSF (fun _ : α → ℕ => j) := ScalarSF.const j |
| have hinput := u.eq (((((c.add (k 1)).pow ell).mul (n.add (k 1))).mul (b.add (k 1))).add (k u₀)) |
| have hgraph : SF (fun z : α → ℕ => z (.inr 1)=g (z (.inr 0))) := |
| by |
| simpa using hg.reindex (fun j => if j=0 then (Sum.inr 0 : α) else Sum.inr 1) |
| have heq1 := ((X.pow 2).add (F.pow 2)).eq ((k 1).add (((b.mul u).pow 2).mul (F.pow 2))) |
| have heq2 := ((Y.pow 2).add (H.pow 2)).eq ((k 1).add ((u.pow 2).mul (H.pow 2))) |
| have hres1 := F.eq ((n.add (k 1)).add (((b.mul u).sub (k 1)).mul q)) |
| have hres2 := H.eq ((n.add (k 1)).add ((u.sub (k 1)).mul q')) |
| exact ((k 2).le b).and (hinput.and (hgraph.and (heq1.and (heq2.and |
| (((k 0).lt F).and ((F.lt v).and (((k 0).lt H).and ((H.lt v).and |
| (hres1.and (hres2.and ((F.eq ((c.mul H).add r)).and (r.lt H)))))))))))) |
|
|
| lemma power_of_growth (g : ℕ → ℕ) (δ : ℝ) (u₀ : ℕ) (hδ : 0<δ) (h₀ : 4≤u₀) |
| (hgraph : SF (fun z : Fin 2 → ℕ => z 1=g (z 0))) |
| (hg : ∀ u, u₀≤u → δ*(Real.log (u:ℝ))^2<Real.log (g u:ℝ) ∧ Real.log (g u:ℝ)<(u:ℝ)*Real.log (u:ℝ)) : |
| SF (fun z : Fin 3 → ℕ => 2≤z 0 ∧ z 2=z 0^z 1) := by |
| obtain ⟨ell,hell,hell'⟩ := PowerEstimate.choose_ell hδ |
| have h := (system_sf g ell u₀ hgraph).ex (by |
| intro z w w' hw hw' |
| exact PowerSystem.unique hδ hell h₀ hg hw hw') |
| refine h.congr ?_ |
| intro z |
| constructor |
| · rintro ⟨w,hw⟩ |
| exact PowerSystem.sound hδ hell h₀ hg hw |
| · rintro ⟨hb,hc⟩ |
| obtain ⟨w,hw⟩ := PowerSystem.complete hδ hell h₀ hg hell' (n:=z 1) hb |
| refine ⟨w, ?_⟩ |
| change PowerSystem.System g ell u₀ (z 0) (z 1) (z 2) w |
| rw [hc] |
| exact hw |
| |
| theorem power : SF (fun z : Fin 3 → ℕ => 2≤z 0 ∧ z 2=z 0^z 1) := by |
| obtain ⟨g,δ,u₀,hδ,h₀,hgraph,hg⟩ := GrowthCompilation.growth |
| exact power_of_growth g δ u₀ hδ h₀ hgraph hg |
| end SingleFold.PowerCompilation |
| |
| end OAI |
| |
