| import OAI.Computability.SpaceSimulation.OneTape.Sizes |
|
|
| namespace OAI |
|
|
| namespace Fifths.Cost |
|
|
| noncomputable def Log (T : ℕ) := Real.log (T+2 : ℝ) / Real.log 2 |
| noncomputable def exponent := (2:ℝ)/5 |
|
|
| private theorem logpos : 0 < Real.log 2 := Real.log_pos (by norm_num) |
| theorem one_le (T : ℕ) : 1 ≤ Log T := by |
| unfold Log |
| apply (le_div_iff₀ logpos).mpr |
| rw [one_mul] |
| apply Real.log_le_log (by norm_num) |
| have : (0:ℝ) ≤ T := by positivity |
| linarith |
|
|
| private theorem smallPow {T : ℕ} (h : T ≥ 2) : |
| 2^(T.size-1) ≤ T ∧ 1 ≤ T.size := by |
| have b := Nat.size_pos.mpr (show 0<T by omega) |
| exact ⟨Nat.lt_size.mp (by omega), b⟩ |
|
|
| theorem lg_real {T : ℕ} (h : T ≥ 2) : (lg T:ℝ) ≤ 3 * Log T := by |
| obtain ⟨p,l⟩ := smallPow h |
| have q : ((T.size-1:ℕ) : ℝ) ≤ Log T := by |
| unfold Log |
| apply (le_div_iff₀ logpos).mpr |
| rw [← Real.log_pow] |
| apply Real.log_le_log (by positivity) |
| exact le_trans (by exact_mod_cast p) (show (T:ℝ) ≤ T+2 by linarith) |
| have k := one_le T |
| rw [Nat.cast_sub l,Nat.cast_one] at q |
| unfold lg; push_cast |
| linarith |
| |
| theorem log_integer (T : ℕ) : Log T ≤ lg T := by |
| have p : T+2 ≤ 2^lg T := by |
| have h := Nat.lt_size_self T |
| unfold lg; rw [pow_succ]; omega |
| unfold Log |
| apply (div_le_iff₀ logpos).mpr |
| rw [← Real.log_pow] |
| exact Real.log_le_log (by positivity) (by exact_mod_cast p) |
|
|
| theorem log_shift (T : ℕ) : Log (T+2) ≤ 2 * Log T := by |
| unfold Log |
| rw [← mul_div_assoc] |
| apply div_le_div_of_nonneg_right _ logpos.le |
| have w : (↑(T+2:ℕ):ℝ)+2 ≤ ((T:ℝ)+2)^2 := by |
| push_cast |
| have : (0:ℝ) ≤ T := by positivity |
| nlinarith |
| have g := Real.log_le_log (by positivity) w |
| simpa only [Real.log_pow,Nat.cast_ofNat] using g |
| |
| theorem k_fifth {T : ℕ} (h : T ≥ 2) : K T ^ 5 ≤ 32*T := by |
| obtain ⟨p,l⟩ := smallPow h |
| unfold K; rw [← pow_mul] |
| calc |
| _ ≤ 2^(T.size+4) := Nat.pow_le_pow_right (by omega) (by unfold power; omega) |
| _ = 32*2^(T.size-1) := by |
| nth_rw 1 [show T.size+4 = 5+(T.size-1) by omega] |
| rw [pow_add]; norm_num |
| _ ≤ 32*T := Nat.mul_le_mul_left 32 p |
| |
| theorem k_real {T : ℕ} (h : T ≥ 2) : (K T:ℝ)*(K T:ℝ) ≤ 32*(T:ℝ)^exponent := by |
| have p : (K T:ℝ)^5 ≤ 32*(T:ℝ) := by exact_mod_cast k_fifth h |
| have a : (0:ℝ) ≤ T := by positivity |
| have g : ((T:ℝ)^exponent)^(5:ℕ) = (T:ℝ)^(2:ℕ) := by |
| rw [← Real.rpow_mul_natCast a] |
| rw [show exponent * (↑(5:ℕ):ℝ) = ((2:ℕ):ℝ) by unfold exponent; norm_num, |
| Real.rpow_natCast] |
| apply (pow_le_pow_iff_left₀ (by positivity) (by positivity) |
| (show (5:ℕ)≠0 by decide)).mp |
| rw [mul_pow,mul_pow,g] |
| calc |
| _ ≤ (32*(T:ℝ))*(32*(T:ℝ)) := mul_le_mul p p (by positivity) (by positivity) |
| _ ≤ _ := by nlinarith |
|
|
| noncomputable def factor (d : ℕ) : ℝ := 32 * 3^(d+2) |
| theorem fpos (d : ℕ) : 0 < factor d := by unfold factor; positivity |
| theorem realBound (d : ℕ) {T : ℕ} (h : T≥2) : |
| (bound d T:ℝ) ≤ factor d * (T:ℝ)^exponent * (Log T)^(d+2) := by |
| have p := k_real h |
| have q := lg_real h |
| have b := one_le T |
| unfold bound |
| push_cast |
| calc |
| _ ≤ (32 * (T:ℝ)^exponent) * (3*Log T)^(d+2) := |
| mul_le_mul p (pow_le_pow_left₀ (by positivity) q _) (by positivity) (by positivity) |
| _ = _ := by rw [mul_pow]; unfold factor; ring |
| |
| -- The `+1` in a scaled natural bound. State concrete |
| -- constants. These formulas will be used pointwise. |
| theorem scaledReal (d u : ℕ) {T : ℕ} (h : T≥2) : |
| ((u*(bound d T+1):ℕ) : ℝ) ≤ |
| (((u:ℝ)+1)*2*factor d) * (T:ℝ)^exponent * (Log T)^(d+2) := by |
| have g := realBound d h |
| have f : (1:ℝ) ≤ bound d T := by exact_mod_cast bound_pos d T |
| have p := one_le T |
| push_cast |
| calc |
| _ ≤ ((u:ℝ)+1)*(2*(bound d T:ℝ)) := |
| mul_le_mul (by linarith) (by linarith) (by positivity) (by positivity) |
| _ ≤ ((u:ℝ)+1)*(2*(factor d * (T:ℝ)^exponent * (Log T)^(d+2))) := by gcongr |
| _ = _ := by ring |
| |
| theorem scaledShift (d u T : ℕ) : |
| ((u*(bound d (T+2)+1):ℕ) : ℝ) ≤ |
| (((u:ℝ)+1)*2*factor d*2^(d+2)) * ((T:ℝ)+2)^exponent * (Log T)^(d+2) := by |
| have g := scaledReal d u (show T+2 ≥ 2 by omega) |
| apply g.trans |
| have p := fpos d |
| have h := one_le (T+2) |
| push_cast |
| calc |
| _ ≤ ((u+1 : ℝ)*2*factor d) * ((T:ℝ)+2)^exponent * (2*Log T)^(d+2) := by |
| gcongr |
| · exact log_shift T |
| _ = _ := by rw [mul_pow]; ring |
| |
| /-- Absorb a prescribed polylog with real leading constant and |
| real exponent. -/ |
| theorem absorbs (p q : ℝ) (_h : 1 ≤ p) : |
| ∃ d c : ℕ, ∀ T : ℕ, |
| p * Log T ^ q ≤ ((c*(bound d T + 1):ℕ):ℝ) := by |
| obtain ⟨d,v⟩ := exists_nat_gt q |
| obtain ⟨c,u⟩ := exists_nat_gt p |
| refine ⟨d,c,?_⟩ |
| intro T |
| have j := one_le T |
| have l : Log T ^ q ≤ ((bound d T:ℕ) : ℝ) := calc |
| _ ≤ Log T ^ (d:ℝ) := Real.rpow_le_rpow_of_exponent_le j v.le |
| _ = Log T ^ d := Real.rpow_natCast .. |
| _ ≤ (lg T:ℝ)^d := pow_le_pow_left₀ (by linarith) (log_integer T) _ |
| _ ≤ (bound d T:ℝ) := by exact_mod_cast lg_pow_le d T |
| push_cast |
| exact mul_le_mul u.le (by linarith) (Real.rpow_nonneg (by linarith) _) (by positivity) |
| |
| end Fifths.Cost |
| |
| end OAI |
| |
