Download data/lean/OAI/Probability/SATVariance/LifetimePotential.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATVariance/LifetimePotential.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/SATVariance/LifetimePotential.lean
-
curl -L -o LifetimePotential.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATVariance/LifetimePotential.lean
19.4 kB
| import OAI.Probability.SATVariance.OccupationBounds | |
| namespace OAI | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory | |
| namespace RandomKSAT | |
| open scoped Classical ENNReal | |
| lemma favg_tsum.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] (f : Ξ± β β β β) | |
| (hf : β a, Summable (f a)) : | |
| favg (fun a => β' m, f a m) = β' m, favg (fun a => f a m) := by | |
| unfold favg | |
| rw [β Summable.tsum_finsetSum (fun a _ => hf a), tsum_div_const] | |
| lemma lifetime_mono {u s : β} (hsu : s β€ u) {S T : Finset (Assignment u)} (hST : S β T) : | |
| lifetime u s S β€ lifetime u s T := by | |
| exact Summable.tsum_le_tsum (survival_mono hST) (survival_summable hsu S) | |
| (survival_summable hsu T) | |
| lemma lifetime_bellman {u s : β} (hsu : s β€ u) (S : Finset (Assignment u)) : | |
| lifetime u s S = alive u S + clauseStep u s (lifetime u s) S := by | |
| unfold clauseStep | |
| simp_rw [lifetime] | |
| rw [favg_tsum _ (fun _ => survival_summable hsu _)] | |
| have hs := survival_summable hsu S | |
| rw [tsum_eq_zero_add' (hs.comp_injective (fun _ _ h => Nat.add_right_cancel h))] | |
| congr 1 | |
| congr 1 | |
| funext m | |
| change (clauseStep u s)^[m+1] (alive u) S = _ | |
| rw [Function.iterate_succ_apply'] | |
| rfl | |
| lemma alive_le_lifetime {u s : β} (hsu : s β€ u) (S : Finset (Assignment u)) : | |
| alive u S β€ lifetime u s S := by | |
| rw [lifetime_bellman hsu] | |
| exact le_add_of_nonneg_right (favg_nonneg fun _ => lifetime_nonneg _ _ _) | |
| def markovSum.{u_1} {X : Type u_1} (P : β β (X β β) β X β β) (f : X β β) : β β X β β | |
| | 0 => fun _ => 0 | |
| | m+1 => fun x => f x + P 0 (markovSum (fun i => P (i+1)) f m) x | |
| lemma markovSum_mono.{u_1} {X : Type u_1} (P : β β (X β β) β X β β) | |
| (hP : β i, Monotone (P i)) {f g : X β β} (hfg : f β€ g) (m : β) : | |
| markovSum P f m β€ markovSum P g m := by | |
| induction m generalizing P with | |
| | zero => exact le_rfl | |
| | succ m ih => | |
| intro x | |
| exact add_le_add (hfg x) (hP 0 (ih _ (fun i => hP (i+1))) x) | |
| lemma markovSum_potential.{u_1} {X : Type u_1} (P : β β (X β β) β X β β) | |
| (hP : β i, Monotone (P i)) | |
| (hPc : β i f c, P i (fun x => f x+c) = fun x => P i f x+c) | |
| (f Ο : X β β) (hΟ : β x, 0 β€ Ο x) (z : β β β) | |
| (hdrift : β i x, f x + P i Ο x β€ Ο x + z i) (m : β) (x : X) : | |
| markovSum P f m x β€ Ο x + β i β Finset.range m, z i := by | |
| induction m generalizing P z x with | |
| | zero => simpa [markovSum] using hΟ x | |
| | succ m ih => | |
| have hi := hP 0 (fun y => ih (fun i => P (i+1)) (fun i => hP (i+1)) | |
| (fun i => hPc (i+1)) (fun i => z (i+1)) (fun i => hdrift (i+1)) y) | |
| rw [hPc] at hi | |
| calc | |
| markovSum P f (m+1) x β€ f x + | |
| (P 0 Ο x + β i β Finset.range m, z (i+1)) := by | |
| change f x + P 0 (markovSum (fun i => P (i+1)) f m) x β€ _ | |
| linarith [hi x] | |
| _ β€ Ο x + z 0 + β i β Finset.range m, z (i+1) := by linarith [hdrift 0 x] | |
| _ = _ := by rw [Finset.sum_range_succ']; ring | |
| lemma markovSum_level.{u_1} {X : Type u_1} (P : β β (X β β) β X β β) | |
| (hP : β i, Monotone (P i)) | |
| (hPc : β i f c, P i (fun x => f x+c) = fun x => P i f x+c) | |
| (hPconst : β i c, P i (fun _ => c) = fun _ => c) | |
| (f Ο : X β β) (hΟ : β x, 0 β€ Ο x) (z : β β β) (hz : β i, 0 β€ z i) | |
| (hdrift : β i x, f x + P i Ο x β€ Ο x + z i) | |
| (e : X β β) (hef : e β€ f) {C : β} (hC : 0 β€ C) | |
| (hlevel : β x, e x β 0 β Ο x β€ C) (m : β) (x : X) : | |
| markovSum P e m x β€ C + β i β Finset.range m, z i := by | |
| induction m generalizing P z x with | |
| | zero => simpa [markovSum] using hC | |
| | succ m ih => | |
| by_cases he : e x = 0 | |
| Β· have hi := hP 0 (fun y => ih (fun i => P (i+1)) (fun i => hP (i+1)) | |
| (fun i => hPc (i+1)) (fun i => hPconst (i+1)) (fun i => z (i+1)) | |
| (fun i => hz (i+1)) (fun i => hdrift (i+1)) y) | |
| rw [hPconst] at hi | |
| change e x + _ β€ _ | |
| rw [he, zero_add, Finset.sum_range_succ'] | |
| linarith [hi x, hz 0] | |
| Β· exact (markovSum_mono P hP hef (m+1) x).trans | |
| ((markovSum_potential P hP hPc f Ο hΟ z hdrift (m+1) x).trans | |
| (by linarith [hlevel x he])) | |
| def scheduledStep (u k : β) (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) | |
| (f : Finset (Assignment u) β β) (S : Finset (Assignment u)) : β := | |
| if ordinary i then clauseStep u k f S else f (S β© mask i) | |
| lemma scheduledStep_mono (u k : β) (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) : | |
| Monotone (scheduledStep u k ordinary mask i) := by | |
| intro f g h S | |
| unfold scheduledStep | |
| split | |
| Β· exact clauseStep_mono u k h S | |
| Β· exact h _ | |
| lemma scheduledStep_const {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) (c : β) : | |
| scheduledStep u k ordinary mask i (fun _ => c) = fun _ => c := by | |
| funext S | |
| unfold scheduledStep | |
| split | |
| Β· exact congrFun (clauseStep_const hku c) S | |
| Β· rfl | |
| lemma scheduledStep_add_const {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) | |
| (f : Finset (Assignment u) β β) (c : β) : | |
| scheduledStep u k ordinary mask i (fun S => f S+c) = | |
| fun S => scheduledStep u k ordinary mask i f S+c := by | |
| funext S | |
| unfold scheduledStep | |
| split | |
| Β· exact congrFun (clauseStep_add_const hku f c) S | |
| Β· rfl | |
| lemma scheduledStep_drift {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) (S : Finset (Assignment u)) : | |
| alive u S + scheduledStep u k ordinary mask i (lifetime u k) S β€ | |
| lifetime u k S + if ordinary i then 0 else 1 := by | |
| unfold scheduledStep | |
| split | |
| Β· simpa using (lifetime_bellman hku S).ge | |
| Β· have ht := lifetime_mono hku (Finset.inter_subset_left : S β© mask i β S) | |
| have hf := alive_le_one u S | |
| linarith | |
| lemma scheduled_occupation {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (L : β) (S : Finset (Assignment u)) | |
| {a : β} (ha : 0 < a) : | |
| markovSum (scheduledStep u (r+1) ordinary mask) | |
| (fun T => if T.Nonempty β§ a β€ blockKill u r T d then 1 else 0) L S β€ | |
| lifetimeC (r+1) * (d : β)^(lifetimeBeta (r+1)) * a^(-lifetimeBeta (r+1)) + | |
| β i β Finset.range L, if ordinary i then (0 : β) else 1 := by | |
| apply markovSum_level _ (scheduledStep_mono u (r+1) ordinary mask) | |
| (scheduledStep_add_const hru ordinary mask) (scheduledStep_const hru ordinary mask) | |
| (alive u) (lifetime u (r+1)) (lifetime_nonneg _ _) _ | |
| (fun _ => by split <;> norm_num) (scheduledStep_drift hru ordinary mask) | |
| Β· intro T | |
| by_cases hT : T.Nonempty | |
| Β· simp only [alive, ite_eq_left hT] | |
| split <;> norm_num | |
| Β· simp [alive, hT] | |
| Β· exact mul_nonneg (mul_nonneg (lifetimeC_pos (by omega : 1 β€ r)).le | |
| (Real.rpow_nonneg (by positivity) _)) (Real.rpow_nonneg ha.le _) | |
| Β· intro T hT | |
| have hTa : a β€ blockKill u r T d := by | |
| split_ifs at hT with h | |
| Β· exact h.2 | |
| Β· exact (hT rfl).elim | |
| exact lifetime_level hr hru hd T ha hTa | |
| lemma markovSum_const.{u_1} {X : Type u_1} (P : β β (X β β) β X β β) | |
| (hPc : β i c, P i (fun _ => c) = fun _ => c) (c : β) (m : β) : | |
| markovSum P (fun _ => c) m = fun _ => m*c := by | |
| induction m generalizing P with | |
| | zero => funext x; simp [markovSum] | |
| | succ m ih => | |
| funext x | |
| simp only [markovSum, ih _ (fun i => hPc (i+1)), hPc] | |
| push_cast | |
| ring | |
| lemma scheduled_occupation_le_length {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (e : Finset (Assignment u) β β) | |
| (he : β S, e S β€ 1) (L : β) (S : Finset (Assignment u)) : | |
| markovSum (scheduledStep u k ordinary mask) e L S β€ L := by | |
| have hm := markovSum_mono _ (scheduledStep_mono u k ordinary mask) he L S | |
| rw [markovSum_const _ (scheduledStep_const hku ordinary mask) 1] at hm | |
| simpa using hm | |
| lemma tailIndicator_antitone (x : β) : | |
| Antitone (fun a : β => if a β€ x then (1 : β) else 0) := by | |
| intro a b hab | |
| dsimp only | |
| by_cases hb : b β€ x | |
| Β· simp [hb, hab.trans hb] | |
| Β· simp only [ite_eq_right hb] | |
| split <;> norm_num | |
| lemma integral_tailIndicator {x : β} (hx : 0 β€ x) (hx1 : x β€ 1) : | |
| (β« a in (0 : β)..1, if a β€ x then (1 : β) else 0) = x := by | |
| have h := intervalIntegral.integral_indicator (ΞΌ := volume) | |
| (f := fun _ : β => (1 : β)) (show x β Set.Icc 0 1 from β¨hx, hx1β©) | |
| simpa [Set.indicator, intervalIntegral.integral_const] using h | |
| lemma favg_integral.{u_1} {Ξ± : Type u_1} [Fintype Ξ±] (f : Ξ± β β β β) {a b : β} | |
| (hf : β x, IntervalIntegrable (f x) volume a b) : | |
| favg (fun x => β« t in a..b, f x t) = β« t in a..b, favg (fun x => f x t) := by | |
| unfold favg | |
| rw [intervalIntegral.integral_div, intervalIntegral.integral_finsetSum (fun x _ => hf x)] | |
| lemma scheduledStep_antitone {u k : β} | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) | |
| (f : β β Finset (Assignment u) β β) (hf : β S, Antitone (fun a => f a S)) | |
| (S : Finset (Assignment u)) : | |
| Antitone (fun a => scheduledStep u k ordinary mask i (f a) S) := by | |
| intro a b hab | |
| exact scheduledStep_mono u k ordinary mask i (fun T => hf T hab) S | |
| lemma scheduledStep_integral {u k : β} | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) | |
| (f : β β Finset (Assignment u) β β) (hf : β S, Antitone (fun a => f a S)) | |
| (S : Finset (Assignment u)) (a b : β) : | |
| scheduledStep u k ordinary mask i (fun T => β« t in a..b, f t T) S = | |
| β« t in a..b, scheduledStep u k ordinary mask i (f t) S := by | |
| unfold scheduledStep | |
| split | |
| Β· simpa only [clauseStep] using favg_integral | |
| (fun c : Clause u k => fun t => f t (S.filter (Satisfies c))) | |
| (fun c => (hf _).intervalIntegrable) | |
| Β· rfl | |
| lemma scheduledSum_antitone {u k : β} | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) | |
| (f : β β Finset (Assignment u) β β) (hf : β S, Antitone (fun a => f a S)) | |
| (L : β) (S : Finset (Assignment u)) : | |
| Antitone (fun a => markovSum (scheduledStep u k ordinary mask) (f a) L S) := by | |
| intro a b hab | |
| exact markovSum_mono _ (scheduledStep_mono u k ordinary mask) (fun T => hf T hab) L S | |
| lemma scheduledSum_integral {u k : β} | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) | |
| (f : β β Finset (Assignment u) β β) (hf : β S, Antitone (fun a => f a S)) | |
| (L : β) (S : Finset (Assignment u)) (a b : β) : | |
| markovSum (scheduledStep u k ordinary mask) (fun T => β« t in a..b, f t T) L S = | |
| β« t in a..b, markovSum (scheduledStep u k ordinary mask) (f t) L S := by | |
| induction L generalizing ordinary mask S with | |
| | zero => simp [markovSum] | |
| | succ L ih => | |
| change (β« t in a..b, f t S) + scheduledStep u k ordinary mask 0 | |
| (markovSum (scheduledStep u k (fun i => ordinary (i+1)) (fun i => mask (i+1))) | |
| (fun T => β« t in a..b, f t T) L) S = _ | |
| have he : markovSum (scheduledStep u k (fun i => ordinary (i+1)) (fun i => mask (i+1))) | |
| (fun T => β« t in a..b, f t T) L = | |
| fun T => β« t in a..b, markovSum | |
| (scheduledStep u k (fun i => ordinary (i+1)) (fun i => mask (i+1))) (f t) L T := by | |
| funext T | |
| exact ih _ _ T | |
| rw [he, scheduledStep_integral _ _ _ _ | |
| (fun T => scheduledSum_antitone _ _ f hf L T)] | |
| exact (intervalIntegral.integral_add (hf S).intervalIntegrable | |
| (scheduledStep_antitone _ _ _ _ | |
| (fun T => scheduledSum_antitone _ _ f hf L T) S).intervalIntegrable).symm | |
| lemma scheduled_layercake {u k : β} | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (f : Finset (Assignment u) β β) | |
| (hf : β S, 0 β€ f S) (hf1 : β S, f S β€ 1) | |
| (L : β) (S : Finset (Assignment u)) : | |
| markovSum (scheduledStep u k ordinary mask) f L S = | |
| β« a in (0 : β)..1, markovSum (scheduledStep u k ordinary mask) | |
| (fun T => if a β€ f T then 1 else 0) L S := by | |
| have he : f = fun T => β« a in (0 : β)..1, if a β€ f T then (1 : β) else 0 := by | |
| funext T | |
| exact (integral_tailIndicator (hf T) (hf1 T)).symm | |
| conv_lhs => rw [he] | |
| exact scheduledSum_integral _ _ _ (fun T => tailIndicator_antitone (f T)) L S 0 1 | |
| lemma scheduled_reward_tail {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (f : Finset (Assignment u) β β) | |
| (hfempty : f β = 0) {ΞΈ Q : β} | |
| (hΞΈ : 0 β€ ΞΈ) (hQ : 0 β€ Q) | |
| (hprod : β S, lifetime u k S * (f S)^ΞΈ β€ Q) (L : β) | |
| (S : Finset (Assignment u)) {a : β} (ha : 0 < a) : | |
| markovSum (scheduledStep u k ordinary mask) | |
| (fun T => if a β€ f T then 1 else 0) L S β€ Q*a^(-ΞΈ) + | |
| β i β Finset.range L, if ordinary i then (0 : β) else 1 := by | |
| apply markovSum_level _ (scheduledStep_mono u k ordinary mask) | |
| (scheduledStep_add_const hku ordinary mask) (scheduledStep_const hku ordinary mask) | |
| (alive u) (lifetime u k) (lifetime_nonneg _ _) _ | |
| (fun _ => by split <;> norm_num) (scheduledStep_drift hku ordinary mask) | |
| Β· intro T | |
| dsimp only | |
| by_cases hT : T.Nonempty | |
| Β· simp only [alive, ite_eq_left hT] | |
| split <;> norm_num | |
| Β· have he : T = β := Finset.not_nonempty_iff_eq_empty.mp hT | |
| subst T | |
| simp [alive, hfempty, not_le.mpr ha] | |
| Β· exact mul_nonneg hQ (Real.rpow_nonneg ha.le _) | |
| Β· intro T hT | |
| have hTa : a β€ f T := by | |
| split_ifs at hT with h | |
| Β· exact h | |
| Β· exact (hT rfl).elim | |
| have hp := mul_le_mul_of_nonneg_left (Real.rpow_le_rpow ha.le hTa hΞΈ) | |
| (lifetime_nonneg u k T) | |
| rw [Real.rpow_neg ha.le, β div_eq_mul_inv] | |
| exact (le_div_iffβ (Real.rpow_pos_of_pos ha _)).2 (hp.trans (hprod T)) | |
| lemma scheduled_reward_tail_bound {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (f : Finset (Assignment u) β β) | |
| (hfempty : f β = 0) {ΞΈ Q Z : β} (hΞΈ : 0 β€ ΞΈ) (hQ : 0 β€ Q) (hZ : 0 β€ Z) | |
| (hprod : β S, lifetime u k S * (f S)^ΞΈ β€ Q) (L : β) | |
| (hcount : (β i β Finset.range L, if ordinary i then (0 : β) else 1) β€ Z) | |
| (S : Finset (Assignment u)) {a : β} (ha : a β Set.Ioo (0 : β) 1) : | |
| markovSum (scheduledStep u k ordinary mask) | |
| (fun T => if a β€ f T then 1 else 0) L S β€ (Q+Z+1)*a^(-ΞΈ) := by | |
| have hp : 1 β€ a^(-ΞΈ) := Real.one_le_rpow_of_pos_of_le_one_of_nonpos | |
| ha.1 ha.2.le (neg_nonpos.mpr hΞΈ) | |
| have ht := scheduled_reward_tail hku ordinary mask f hfempty hΞΈ hQ hprod L S ha.1 | |
| nlinarith [mul_nonneg hZ (sub_nonneg.mpr hp)] | |
| lemma scheduled_reward_integrated_subcritical {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (f : Finset (Assignment u) β β) | |
| (hfempty : f β = 0) (hf : β S, 0 β€ f S) (hf1 : β S, f S β€ 1) | |
| {ΞΈ Q Z : β} (hΞΈ : 0 β€ ΞΈ) (hΞΈ1 : ΞΈ < 1) (hQ : 0 β€ Q) (hZ : 0 β€ Z) | |
| (hprod : β S, lifetime u k S * (f S)^ΞΈ β€ Q) (L : β) | |
| (hcount : (β i β Finset.range L, if ordinary i then (0 : β) else 1) β€ Z) | |
| (S : Finset (Assignment u)) : | |
| markovSum (scheduledStep u k ordinary mask) f L S β€ (Q+Z+1)/(1-ΞΈ) := by | |
| rw [scheduled_layercake ordinary mask f hf hf1 L S] | |
| apply integrated_tail_subcritical | |
| (scheduledSum_antitone ordinary mask _ (fun T => tailIndicator_antitone (f T)) L S) hΞΈ1 | |
| intro a ha | |
| exact scheduled_reward_tail_bound hku ordinary mask f hfempty hΞΈ hQ hZ hprod L hcount S ha | |
| lemma scheduled_reward_integrated_critical {u k : β} (hku : k β€ u) | |
| (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (f : Finset (Assignment u) β β) | |
| (hfempty : f β = 0) (hf : β S, 0 β€ f S) (hf1 : β S, f S β€ 1) | |
| {Q Z : β} (hQ : 0 β€ Q) (hZ : 0 β€ Z) | |
| (hprod : β S, lifetime u k S * f S β€ Q) {L : β} (hL : 1 β€ L) | |
| (hcount : (β i β Finset.range L, if ordinary i then (0 : β) else 1) β€ Z) | |
| (S : Finset (Assignment u)) : | |
| markovSum (scheduledStep u k ordinary mask) f L S β€ (Q+Z+1)*(1+Real.log L) := by | |
| rw [scheduled_layercake ordinary mask f hf hf1 L S] | |
| apply integrated_tail_critical | |
| (scheduledSum_antitone ordinary mask _ (fun T => tailIndicator_antitone (f T)) L S) | |
| (by linarith) (by exact_mod_cast hL) | |
| Β· intro a | |
| exact scheduled_occupation_le_length hku ordinary mask _ | |
| (fun T => by split <;> norm_num) L S | |
| Β· intro a ha | |
| have ht := scheduled_reward_tail_bound hku ordinary mask f hfempty | |
| (by norm_num : (0 : β) β€ 1) hQ hZ (by simpa using hprod) L hcount S ha | |
| simpa [Real.rpow_neg_one, div_eq_mul_inv] using ht | |
| def occupationGamma (k : β) : β := (k : β)-lifetimeBeta k | |
| lemma occupationGamma_succ {r : β} (hr : 2 β€ r) : | |
| occupationGamma (r+1) = lifetimeBeta (r+1) * ((r-1 : β) : β) := by | |
| rw [occupationGamma, lifetimeBeta_succ (by omega), Nat.cast_add, Nat.cast_one, | |
| Nat.cast_sub (by omega : 1 β€ r), Nat.cast_one] | |
| have hrβ : (r : β) β 0 := by exact_mod_cast (by omega : r β 0) | |
| field_simp | |
| lemma occupationGamma_pos {r : β} (hr : 2 β€ r) : 0 < occupationGamma (r+1) := by | |
| rw [occupationGamma_succ hr, lifetimeBeta_succ (by omega)] | |
| have h : (0 : β) < ((r-1 : β) : β) := by exact_mod_cast (by omega : 0 < r-1) | |
| positivity | |
| def occupationReward (u r d : β) (S : Finset (Assignment u)) : β := | |
| if S.Nonempty then (blockKill u r S d)^(occupationGamma (r+1)) else 0 | |
| lemma occupationReward_nonneg (u r d : β) (S : Finset (Assignment u)) : | |
| 0 β€ occupationReward u r d S := by | |
| unfold occupationReward | |
| split | |
| Β· exact Real.rpow_nonneg (blockKill_nonneg _ _ _ _) _ | |
| Β· rfl | |
| lemma occupationReward_le_one {u r : β} (hr : 2 β€ r) (hru : r+1 β€ u) | |
| (d : β) (S : Finset (Assignment u)) : occupationReward u r d S β€ 1 := by | |
| unfold occupationReward | |
| split | |
| Β· exact Real.rpow_le_one (blockKill_nonneg _ _ _ _) (blockKill_le_one (by omega) _ _) | |
| (occupationGamma_pos hr).le | |
| Β· norm_num | |
| lemma occupationReward_product {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| (S : Finset (Assignment u)) : | |
| lifetime u (r+1) S * (occupationReward u r d S)^(((r-1 : β) : β)β»ΒΉ) β€ | |
| lifetimeC (r+1) * (d : β)^(lifetimeBeta (r+1)) := by | |
| have hΞΈ : (0 : β) < (((r-1 : β) : β)β»ΒΉ) := by | |
| exact inv_pos.mpr (by exact_mod_cast (by omega : 0 < r-1)) | |
| unfold occupationReward | |
| split | |
| Β· rw [β Real.rpow_mul (blockKill_nonneg _ _ _ _), occupationGamma_succ hr, | |
| mul_inv_cancel_rightβ (by exact_mod_cast (by omega : r-1 β 0) : ((r-1 : β) : β) β 0)] | |
| exact lifetime_product hr hru hd S | |
| Β· rw [Real.zero_rpow hΞΈ.ne', mul_zero] | |
| exact mul_nonneg (lifetimeC_pos (by omega : 1 β€ r)).le (Real.rpow_nonneg (by positivity) _) | |
| end RandomKSAT | |
| end | |
| end OAI | |