File size: 5,220 Bytes
472a116 | 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 | 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
|