Download data/lean/OAI/Probability/SATVariance/WeightedRewards.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 21.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATVariance/WeightedRewards.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/SATVariance/WeightedRewards.lean
-
curl -L -o WeightedRewards.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/SATVariance/WeightedRewards.lean
21.6 kB
| import OAI.Probability.SATVariance.HiddenTests | |
| namespace OAI | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory | |
| namespace RandomKSAT | |
| open scoped Classical ENNReal | |
| lemma markovSum_projection.{u_1, u_2} {X : Type u_1} {Y : Type u_2} | |
| (P : β β (X β β) β X β β) (Q : β β (Y β β) β Y β β) | |
| (Ο : X β Y) (hΟ : β i f x, P i (fun y => f (Ο y)) x = Q i f (Ο x)) | |
| (f : Y β β) (M : β) (x : X) : | |
| markovSum P (fun y => f (Ο y)) M x = markovSum Q f M (Ο x) := by | |
| induction M generalizing P Q x with | |
| | zero => rfl | |
| | succ M ih => | |
| simp only [markovSum] | |
| have he : markovSum (fun i => P (i+1)) (fun y => f (Ο y)) M = | |
| fun y => markovSum (fun i => Q (i+1)) f M (Ο y) := by | |
| funext y | |
| exact ih _ _ (fun i => hΟ (i+1)) y | |
| rw [he, hΟ] | |
| lemma rootSum_projection {u k : β} (hku : k β€ u) (a : Assignment k) | |
| (env : β β RootData u k) (f : Finset (Assignment u) β β) (M : β) (S : PairState u k) : | |
| markovSum (uniformStep (pairEvolution a env)) (fun T => f (fibre a T)) M S = | |
| markovSum (scheduledStep u k (fun i => rootSize (env i).1 = 0) | |
| (fun i => dataMask (env i) a)) f M (fibre a S) := | |
| markovSum_projection _ _ _ (pairEvolution_fibre_operator hku a env) f M S | |
| lemma fibre_univ {u k : β} (a : Assignment k) : | |
| fibre (u := u) a Finset.univ = Finset.univ := by ext b; simp [fibre] | |
| lemma rootSum_test_bound {u k M d : β} (hku : k β€ u) (a : Assignment k) | |
| (env : β β RootData u k) (J : Finset (Fin k)) | |
| (hJ : β j β J, Available a (fun i : Fin M => env i) j) | |
| (hd : β m j, (testIndices a (fun i : Fin M => env i) m j).card β€ d) | |
| (w : Finset (Assignment u) β β) (hw : β S, 0 β€ w S) : | |
| markovSum (uniformStep (pairEvolution a env)) | |
| (fun T => forcedReward a T * w (fibre a T)) M Finset.univ β€ | |
| markovSum (scheduledStep u k (fun i => rootSize (env i).1 = 0) | |
| (fun i => dataMask (env i) a)) | |
| (fun S => w S * (alive u S * blockKill u (k-1) S d ^ J.card)) M Finset.univ := by | |
| let := clause_nonempty u k hku | |
| let := clause_nonempty u (k-1) (by omega) | |
| rw [β fibre_univ (u := u) a, β rootSum_projection hku] | |
| rw [β rootRewards_avg hku, β rootRewards_avg hku] | |
| rw [favg_noiseWord, favg_noiseWord] | |
| apply favg_mono | |
| intro o | |
| unfold dataRewards | |
| rw [favg_sum, favg_sum] | |
| apply Finset.sum_le_sum | |
| intro m _ | |
| simp only [fibre_pairPrefix_refresh] | |
| have he : favg (fun ys : Fin k β Fin M β Clause u (k-1) => | |
| forcedReward a (pairPrefix Finset.univ | |
| (fun i => refreshData a (env i) (o i,fun j => ys j i)) m.val) * | |
| w (fibrePrefix a (fun i : Fin M => env i) o m.val)) = | |
| w (fibrePrefix a (fun i : Fin M => env i) o m.val) * | |
| favg (fun ys : Fin k β Fin M β Clause u (k-1) => | |
| forcedReward a (pairPrefix Finset.univ | |
| (fun i => refreshData a (env i) (o i,fun j => ys j i)) m.val)) := by | |
| simp_rw [mul_comm _ (w _)] | |
| exact favg_mul _ _ | |
| rw [he, favg_const] | |
| exact mul_le_mul_of_nonneg_left (forcedPrefix_probability hku a _ o m.val J hJ (hd _)) (hw _) | |
| def incidentSet {u k M : β} (env : Fin M β RootData u k) : Finset (Fin M) := | |
| Finset.univ.filter fun i => rootSize (env i).1 β 0 | |
| def collisionSet {u k M : β} (env : Fin M β RootData u k) : Finset (Fin M) := | |
| Finset.univ.filter fun i => 2 β€ rootSize (env i).1 | |
| lemma testIndices_card_le {u k M : β} (a : Assignment k) (env : Fin M β RootData u k) | |
| (m : β) (j : Fin k) : (testIndices a env m j).card β€ (incidentSet env).card := by | |
| apply Finset.card_le_card | |
| intro i hi | |
| have hh := (Finset.mem_filter.mp hi).2.2.1 | |
| simp [incidentSet, hh] | |
| lemma incidentSet_sum {u k : β} (env : β β RootData u k) (M : β) : | |
| (β i β Finset.range M, if rootSize (env i).1 = 0 then (0 : β) else 1) = | |
| ((incidentSet (fun i : Fin M => env i)).card : β) := by | |
| rw [β Fin.sum_univ_eq_sum_range] | |
| simp only [incidentSet, Finset.card_filter] | |
| push_cast | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| split_ifs <;> simp_all | |
| lemma available_of_no_collision {u k M : β} (a : Assignment k) (env : Fin M β RootData u k) | |
| (hV : (collisionSet env).card = 0) (j : Fin k) : Available a env j := by | |
| intro i hi | |
| have hm : i β collisionSet env := by simp [collisionSet, hi] | |
| rw [Finset.card_eq_zero.mp hV] at hm | |
| exact (Finset.notMem_empty i hm).elim | |
| lemma uniqueTrue_injective {k : β} (t : RootType k) (a : Assignment k) {i j : Fin k} | |
| (hi : UniqueTrue t a i) (hj : UniqueTrue t a j) : i = j := by | |
| by_contra h | |
| exact hj.2 i h hi.1 | |
| lemma available_except_one {u k M : β} (hk : 1 β€ k) (a : Assignment k) | |
| (env : Fin M β RootData u k) (hV : (collisionSet env).card β€ 1) : | |
| β jβ : Fin k, β j, j β jβ β Available a env j := by | |
| by_cases hbad : β j : Fin k, Β¬ Available a env j | |
| Β· obtain β¨jβ,hjββ© := hbad | |
| refine β¨jβ,fun j hj i hi hij => ?_β© | |
| obtain β¨iβ,hiβ,hijββ© : β i, 2 β€ rootSize (env i).1 β§ UniqueTrue (env i).1 a jβ := by | |
| simp only [Available] at hjβ | |
| push Not at hjβ | |
| exact hjβ | |
| have he : i = iβ := Finset.card_le_one.mp hV i | |
| (by simp [collisionSet, hi]) iβ (by simp [collisionSet, hiβ]) | |
| subst iβ | |
| exact hj (uniqueTrue_injective _ _ hij hijβ) | |
| Β· refine β¨β¨0, by omegaβ©, fun j _ => ?_β© | |
| by_contra hj | |
| exact hbad β¨j,hjβ© | |
| lemma lifetimeBeta_bounds {r : β} (hr : 2 β€ r) : | |
| 1 β€ lifetimeBeta (r+1) β§ lifetimeBeta (r+1) β€ (r : β) β§ | |
| 2*lifetimeBeta (r+1) β€ 3 := by | |
| rw [lifetimeBeta_succ (by omega)] | |
| have hr2 : (2 : β) β€ r := by exact_mod_cast hr | |
| have hi : (0 : β) β€ (r : β)β»ΒΉ := inv_nonneg.mpr (by positivity) | |
| have hj : (r : β)β»ΒΉ β€ 1/2 := by | |
| apply (inv_le_iff_one_le_mulβ (by positivity)).2 | |
| linarith | |
| constructor | |
| Β· linarith | |
| constructor <;> linarith | |
| def deletionQ (k d : β) : β := (lifetimeC k+1)*(d : β)^(lifetimeBeta k) | |
| lemma deletionQ_nonneg {r d : β} (hr : 2 β€ r) : 0 β€ deletionQ (r+1) d := by | |
| unfold deletionQ | |
| exact mul_nonneg (by linarith [lifetimeC_pos (by omega : 1 β€ r)]) | |
| (Real.rpow_nonneg (by positivity) _) | |
| lemma lifetime_weight_product {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| {Z : β} (hZ : 0 β€ Z) (hZd : Z β€ d) (S : Finset (Assignment u)) : | |
| (lifetime u (r+1) S+Z) * (blockKill u r S d)^(lifetimeBeta (r+1)) β€ deletionQ (r+1) d := by | |
| have hb := lifetimeBeta_bounds hr | |
| have hd1 : (1 : β) β€ d := by exact_mod_cast hd | |
| have hdp : (d : β) β€ (d : β)^(lifetimeBeta (r+1)) := by | |
| simpa using Real.rpow_le_rpow_of_exponent_le hd1 hb.1 | |
| have hq := Real.rpow_le_one (blockKill_nonneg u r S d) (blockKill_le_one (by omega) S d) | |
| (by linarith : 0 β€ lifetimeBeta (r+1)) | |
| have ht := lifetime_product hr hru hd S | |
| unfold deletionQ | |
| nlinarith [mul_nonneg hZ (sub_nonneg.mpr hq)] | |
| lemma weighted_all_tests {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| {Z : β} (hZ : 0 β€ Z) (hZd : Z β€ d) (S : Finset (Assignment u)) : | |
| (lifetime u (r+1) S+Z) * (alive u S * blockKill u r S d ^ (r+1)) β€ | |
| deletionQ (r+1) d * occupationReward u r d S := by | |
| by_cases hS : S.Nonempty | |
| Β· simp only [alive, occupationReward, ite_eq_left hS, one_mul] | |
| by_cases hq : blockKill u r S d = 0 | |
| Β· simp only [hq, zero_pow (by omega : r+1 β 0), mul_zero] | |
| exact mul_nonneg (deletionQ_nonneg hr) (Real.rpow_nonneg (by norm_num) _) | |
| Β· have hqp : 0 < blockKill u r S d := lt_of_le_of_ne (blockKill_nonneg _ _ _ _) (Ne.symm hq) | |
| have he : (blockKill u r S d)^(r+1) = | |
| (blockKill u r S d)^(lifetimeBeta (r+1)) * (blockKill u r S d)^(occupationGamma (r+1)) := by | |
| rw [β Real.rpow_add hqp, occupationGamma] | |
| simp only [add_sub_cancel, Real.rpow_natCast] | |
| rw [he, β mul_assoc] | |
| exact mul_le_mul_of_nonneg_right (lifetime_weight_product hr hru hd hZ hZd S) | |
| (Real.rpow_nonneg hqp.le _) | |
| Β· simp [alive, occupationReward, hS] | |
| lemma weighted_all_but_one_test {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| {Z : β} (hZ : 0 β€ Z) (hZd : Z β€ d) (S : Finset (Assignment u)) : | |
| (lifetime u (r+1) S+Z) * (alive u S * blockKill u r S d ^ r) β€ deletionQ (r+1) d := by | |
| by_cases hS : S.Nonempty | |
| Β· simp only [alive, ite_eq_left hS, one_mul] | |
| by_cases hq : blockKill u r S d = 0 | |
| Β· simpa only [hq, zero_pow (by omega : r β 0), mul_zero] using deletionQ_nonneg (d := d) hr | |
| Β· have hqp : 0 < blockKill u r S d := lt_of_le_of_ne (blockKill_nonneg _ _ _ _) (Ne.symm hq) | |
| have hpow : (blockKill u r S d)^r β€ (blockKill u r S d)^(lifetimeBeta (r+1)) := by | |
| rw [β Real.rpow_natCast] | |
| exact Real.rpow_le_rpow_of_exponent_ge hqp (blockKill_le_one (by omega) S d) | |
| (lifetimeBeta_bounds hr).2.1 | |
| exact (mul_le_mul_of_nonneg_left hpow (add_nonneg (lifetime_nonneg _ _ _) hZ)).trans | |
| (lifetime_weight_product hr hru hd hZ hZd S) | |
| Β· simp only [alive, ite_eq_right hS, zero_mul, mul_zero] | |
| exact deletionQ_nonneg hr | |
| lemma scheduledStep_mul (u k : β) (ordinary : β β Prop) [DecidablePred ordinary] | |
| (mask : β β Finset (Assignment u)) (i : β) (c : β) (f : Finset (Assignment u) β β) : | |
| scheduledStep u k ordinary mask i (fun S => c*f S) = | |
| fun S => c*scheduledStep u k ordinary mask i f S := by | |
| funext S | |
| unfold scheduledStep | |
| split | |
| Β· exact favg_mul c _ | |
| Β· rfl | |
| lemma rootRewards_square_test_bound {u k M d : β} (hku : k β€ u) (a : Assignment k) | |
| (env : β β RootData u k) (J : Finset (Fin k)) | |
| (hJ : β j β J, Available a (fun i : Fin M => env i) j) | |
| (hd : β m j, (testIndices a (fun i : Fin M => env i) m j).card β€ d) | |
| {Z : β} (hZ : 0 β€ Z) | |
| (hcount : ((incidentSet (fun i : Fin M => env i)).card : β) β€ Z) : | |
| favg (fun z : Fin M β RefreshNoise u k => | |
| (dataRewards (forcedReward a) Finset.univ (fun i => refreshData a (env i) (z i)))^2) β€ | |
| 2*markovSum (scheduledStep u k (fun i => rootSize (env i).1 = 0) | |
| (fun i => dataMask (env i) a)) | |
| (fun S => (lifetime u k S+Z)*(alive u S * blockKill u (k-1) S d ^ J.card)) M Finset.univ := by | |
| have hh := rootPath_square hku a env M (Z := Z) (by rw [incidentSet_sum]; exact hcount) (Finset.univ : PairState u k) | |
| simp_rw [rootPath_eq_rewards] at hh | |
| exact hh.trans (mul_le_mul_of_nonneg_left | |
| (rootSum_test_bound hku a env J hJ hd (fun S : Finset (Assignment u) => lifetime u k S+Z) | |
| (fun S => add_nonneg (lifetime_nonneg _ _ _) hZ)) (by norm_num)) | |
| def durationLog (k M : β) : β := if k = 3 then 1+Real.log (M+1) else 1 | |
| lemma durationLog_one_le (k M : β) : 1 β€ durationLog k M := by | |
| unfold durationLog | |
| split | |
| Β· have h : (1 : β) β€ M+1 := by linarith [Nat.cast_nonneg (Ξ± := β) M] | |
| linarith [Real.log_nonneg h] | |
| Β· rfl | |
| lemma integrated_occupationReward {u r d : β} (hr : 2 β€ r) (hru : r+1 β€ u) (hd : 1 β€ d) | |
| (ordinary : β β Prop) [DecidablePred ordinary] (mask : β β Finset (Assignment u)) | |
| (M : β) {Z : β} (hZ : 0 β€ Z) (hZd : Z β€ d) | |
| (hcount : (β i β Finset.range M, if ordinary i then (0 : β) else 1) β€ Z) | |
| (S : Finset (Assignment u)) : | |
| markovSum (scheduledStep u (r+1) ordinary mask) (occupationReward u r d) M S β€ | |
| 4*deletionQ (r+1) d * durationLog (r+1) M := by | |
| let Q := lifetimeC (r+1)*(d : β)^(lifetimeBeta (r+1)) | |
| have hQ : 0 β€ Q := mul_nonneg (lifetimeC_pos (by omega : 1 β€ r)).le (Real.rpow_nonneg (by positivity) _) | |
| have hd1 : (1 : β) β€ d := by exact_mod_cast hd | |
| have hdp : (d : β) β€ (d : β)^(lifetimeBeta (r+1)) := by | |
| simpa using Real.rpow_le_rpow_of_exponent_le hd1 (lifetimeBeta_bounds hr).1 | |
| have hbound : Q+Z+1 β€ 2*deletionQ (r+1) d := by | |
| dsimp only [Q, deletionQ] | |
| have hc := lifetimeC_pos (by omega : 1 β€ r) | |
| nlinarith [Real.rpow_nonneg (x := (d : β)) (by positivity) (lifetimeBeta (r+1))] | |
| have he : occupationReward u r d β = 0 := by simp [occupationReward] | |
| by_cases hr2 : r = 2 | |
| Β· subst r | |
| by_cases hM : M = 0 | |
| Β· subst M | |
| simp only [markovSum] | |
| exact mul_nonneg (mul_nonneg (by norm_num) (deletionQ_nonneg (by omega))) | |
| (le_trans (by norm_num) (durationLog_one_le _ _)) | |
| Β· have hp (T : Finset (Assignment u)) : lifetime u 3 T * occupationReward u 2 d T β€ Q := by | |
| simpa using occupationReward_product (by omega : 2 β€ 2) hru hd T | |
| have hh := scheduled_reward_integrated_critical hru ordinary mask (occupationReward u 2 d) | |
| he (occupationReward_nonneg _ _ _) (occupationReward_le_one (by omega) hru d) | |
| hQ hZ hp (by omega : 1 β€ M) hcount S | |
| have hlog := Real.log_le_log (by exact_mod_cast (by omega : 0 < M)) (by norm_num : (M : β) β€ M+1) | |
| have hpos : 0 β€ 1+Real.log (M : β) := by | |
| have h := Real.log_nonneg (show (1 : β) β€ (M : β) by exact_mod_cast (by omega : 1 β€ M)) | |
| linarith | |
| simp only [durationLog, show 2+1=3 from rfl, βreduceIte] | |
| have hbprod := mul_le_mul_of_nonneg_right hbound hpos | |
| nlinarith [mul_nonneg (deletionQ_nonneg (d := d) (by omega : 2 β€ 2)) | |
| (sub_nonneg.mpr hlog), mul_nonneg (deletionQ_nonneg (d := d) (by omega : 2 β€ 2)) hpos] | |
| Β· have hr3 : 3 β€ r := by omega | |
| have hΞΈ : 0 β€ (((r-1 : β) : β)β»ΒΉ) := by positivity | |
| have hΞΈ2 : (((r-1 : β) : β)β»ΒΉ) β€ 1/2 := by | |
| apply (inv_le_iff_one_le_mulβ (by exact_mod_cast (by omega : 0 < r-1))).2 | |
| have h : (2 : β) β€ (r-1 : β) := by exact_mod_cast (by omega : 2 β€ r-1) | |
| linarith | |
| have hΞΈ1 : (((r-1 : β) : β)β»ΒΉ) < 1 := by linarith | |
| have hh := scheduled_reward_integrated_subcritical hru ordinary mask (occupationReward u r d) | |
| he (occupationReward_nonneg _ _ _) (occupationReward_le_one hr hru d) | |
| hΞΈ hΞΈ1 hQ hZ (occupationReward_product hr hru hd) M hcount S | |
| have hdiv : (Q+Z+1)/(1-(((r-1 : β) : β)β»ΒΉ)) β€ 2*(Q+Z+1) := by | |
| apply (div_le_iffβ (by linarith)).2 | |
| nlinarith | |
| simp only [durationLog, ite_eq_right (by omega : r+1 β 3), mul_one] | |
| exact hh.trans (hdiv.trans (by linarith)) | |
| lemma rootRewards_square_no_collision {u r M d : β} (hr : 2 β€ r) (hru : r+1 β€ u) | |
| (hd : 1 β€ d) (a : Assignment (r+1)) (env : β β RootData u (r+1)) | |
| (hV : (collisionSet (fun i : Fin M => env i)).card = 0) | |
| {Z : β} (hZ : 0 β€ Z) (hZd : Z β€ d) | |
| (hcount : ((incidentSet (fun i : Fin M => env i)).card : β) β€ Z) : | |
| favg (fun z : Fin M β RefreshNoise u (r+1) => | |
| (dataRewards (forcedReward a) Finset.univ (fun i => refreshData a (env i) (z i)))^2) β€ | |
| 8*(deletionQ (r+1) d)^2*durationLog (r+1) M := by | |
| have htests (m) (j : Fin (r+1)) : | |
| (testIndices a (fun i : Fin M => env i) m j).card β€ d := by | |
| have hh := testIndices_card_le a (fun i : Fin M => env i) m j | |
| have hh' : ((incidentSet (fun i : Fin M => env i)).card : β) β€ d := hcount.trans hZd | |
| exact hh.trans (by exact_mod_cast hh') | |
| have hh := rootRewards_square_test_bound hru a env Finset.univ | |
| (fun j _ => available_of_no_collision a _ hV j) htests hZ hcount | |
| simp only [Finset.card_univ, Fintype.card_fin, Nat.add_sub_cancel] at hh | |
| have hm := markovSum_mono _ | |
| (scheduledStep_mono u (r+1) (fun i => rootSize (env i).1 = 0) (fun i => dataMask (env i) a)) | |
| (weighted_all_tests hr hru hd hZ hZd) M (Finset.univ : Finset (Assignment u)) | |
| rw [markovSum_mul _ (scheduledStep_mul _ _ _ _)] at hm | |
| have ho := integrated_occupationReward hr hru hd (fun i => rootSize (env i).1 = 0) | |
| (fun i => dataMask (env i) a) M hZ hZd (by rw [incidentSet_sum]; exact hcount) Finset.univ | |
| have hp := mul_le_mul_of_nonneg_left ho (deletionQ_nonneg (d := d) hr) | |
| nlinarith | |
| lemma rootRewards_square_one_collision {u r M d : β} (hr : 2 β€ r) (hru : r+1 β€ u) | |
| (hd : 1 β€ d) (a : Assignment (r+1)) (env : β β RootData u (r+1)) | |
| (hV : (collisionSet (fun i : Fin M => env i)).card β€ 1) | |
| {Z : β} (hZ : 0 β€ Z) (hZd : Z β€ d) | |
| (hcount : ((incidentSet (fun i : Fin M => env i)).card : β) β€ Z) : | |
| favg (fun z : Fin M β RefreshNoise u (r+1) => | |
| (dataRewards (forcedReward a) Finset.univ (fun i => refreshData a (env i) (z i)))^2) β€ | |
| 2*M*deletionQ (r+1) d := by | |
| obtain β¨jβ,hjββ© := available_except_one (by omega : 1 β€ r+1) a _ hV | |
| have htests (m) (j : Fin (r+1)) : | |
| (testIndices a (fun i : Fin M => env i) m j).card β€ d := by | |
| have hh := testIndices_card_le a (fun i : Fin M => env i) m j | |
| have hh' : ((incidentSet (fun i : Fin M => env i)).card : β) β€ d := hcount.trans hZd | |
| exact hh.trans (by exact_mod_cast hh') | |
| have hh := rootRewards_square_test_bound hru a env (Finset.univ.erase jβ) | |
| (fun j hj => hjβ j (Finset.mem_erase.mp hj).1) htests hZ hcount | |
| have hc : (Finset.univ.erase jβ).card = r := by simp | |
| rw [hc] at hh | |
| simp only [Nat.add_sub_cancel] at hh | |
| have hm := markovSum_mono _ | |
| (scheduledStep_mono u (r+1) (fun i => rootSize (env i).1 = 0) (fun i => dataMask (env i) a)) | |
| (weighted_all_but_one_test hr hru hd hZ hZd) M (Finset.univ : Finset (Assignment u)) | |
| rw [markovSum_const _ (scheduledStep_const hru _ _)] at hm | |
| nlinarith | |
| lemma dataRewards_nonneg {u k M : β} (a : Assignment k) (S : PairState u k) | |
| (ps : Fin M β RootData u k) : 0 β€ dataRewards (forcedReward a) S ps := | |
| Finset.sum_nonneg fun _ _ => forcedReward_nonneg _ _ | |
| lemma dataRewards_le_length {u k M : β} (a : Assignment k) (S : PairState u k) | |
| (ps : Fin M β RootData u k) : dataRewards (forcedReward a) S ps β€ M := by | |
| have hh := Finset.sum_le_sum (s := (Finset.univ : Finset (Fin M))) (fun i _ => forcedReward_le_one a (pairPrefix S ps i.val)) | |
| simpa [dataRewards] using hh | |
| lemma rootRewards_square_conditioned {u r M : β} (hr : 2 β€ r) (hru : r+1 β€ u) | |
| (a : Assignment (r+1)) (env : β β RootData u (r+1)) : | |
| let Z := (incidentSet (fun i : Fin M => env i)).card | |
| let V : β := (collisionSet (fun i : Fin M => env i)).card | |
| let Q := deletionQ (r+1) (max 1 Z) | |
| favg (fun z : Fin M β RefreshNoise u (r+1) => | |
| (dataRewards (forcedReward a) Finset.univ (fun i => refreshData a (env i) (z i)))^2) β€ | |
| 8*Q^2*durationLog (r+1) M + 2*M*Q*V + (M : β)^2*V*(V-1) := by | |
| dsimp only | |
| let Z := (incidentSet (fun i : Fin M => env i)).card | |
| let V := (collisionSet (fun i : Fin M => env i)).card | |
| let Q := deletionQ (r+1) (max 1 Z) | |
| have hQ : 0 β€ Q := deletionQ_nonneg hr | |
| have hZF : (Z : β) β€ (max 1 Z : β) := by exact_mod_cast le_max_right 1 Z | |
| have hterm : 0 β€ 8*Q^2*durationLog (r+1) M := by | |
| exact mul_nonneg (mul_nonneg (by norm_num) (sq_nonneg _)) | |
| (le_trans (by norm_num) (durationLog_one_le _ _)) | |
| change _ β€ 8*Q^2*durationLog (r+1) M+2*M*Q*(V : β)+(M : β)^2*V*(V-1) | |
| by_cases hV : V = 0 | |
| Β· have hh := rootRewards_square_no_collision hr hru (le_max_left 1 Z) a env hV | |
| (Nat.cast_nonneg Z) hZF (le_refl (Z : β)) | |
| simpa only [hV, Nat.cast_zero, mul_zero, zero_mul, add_zero] using hh | |
| by_cases hV1 : V β€ 1 | |
| Β· have he : V = 1 := by omega | |
| have hh := rootRewards_square_one_collision hr hru (le_max_left 1 Z) a env hV1 | |
| (Nat.cast_nonneg Z) hZF (le_refl (Z : β)) | |
| simp only [he, Nat.cast_one, mul_one, sub_self, mul_zero, add_zero] | |
| exact hh.trans (le_add_of_nonneg_left hterm) | |
| Β· have hv : (2 : β) β€ V := by exact_mod_cast (by omega : 2 β€ V) | |
| have htriv : favg (fun z : Fin M β RefreshNoise u (r+1) => | |
| (dataRewards (forcedReward a) Finset.univ (fun i => refreshData a (env i) (z i)))^2) β€ (M : β)^2 := by | |
| let := clause_nonempty u (r+1) hru | |
| let := clause_nonempty u ((r+1)-1) (by omega) | |
| exact (favg_mono (fun z => pow_le_pow_leftβ (dataRewards_nonneg a _ _) (dataRewards_le_length a _ _) 2)).trans_eq (favg_const _) | |
| have hfac : 1 β€ (V : β)*(V-1) := by nlinarith | |
| have hmfac := mul_le_mul_of_nonneg_left hfac (sq_nonneg (M : β)) | |
| have hmQ : 0 β€ 2*M*Q*(V : β) := by positivity | |
| nlinarith | |
| lemma deletionQ_poly_bound {r Z : β} (hr : 2 β€ r) : | |
| deletionQ (r+1) (max 1 Z) β€ (lifetimeC (r+1)+1)*(1+(Z : β))^2 := by | |
| unfold deletionQ | |
| have hb := lifetimeBeta_bounds hr | |
| have hd : (1 : β) β€ (max 1 Z : β) := by exact_mod_cast le_max_left 1 Z | |
| have hd' : ((max 1 Z : β) : β) β€ 1+(Z : β) := by | |
| rw [Nat.cast_max, Nat.cast_one] | |
| exact max_le (by linarith [Nat.cast_nonneg (Ξ± := β) Z]) (by linarith) | |
| have hp := Real.rpow_le_rpow_of_exponent_le hd (show lifetimeBeta (r+1) β€ (2 : β) by linarith) | |
| change _ β€ ((max 1 Z : β) : β)^((2 : β) : β) at hp | |
| rw [Real.rpow_natCast] at hp | |
| apply mul_le_mul_of_nonneg_left (hp.trans (pow_le_pow_leftβ (by positivity) hd' 2)) | |
| linarith [lifetimeC_pos (by omega : 1 β€ r)] | |
| lemma deletionQ_sq_poly_bound {r Z : β} (hr : 2 β€ r) : | |
| (deletionQ (r+1) (max 1 Z))^2 β€ (lifetimeC (r+1)+1)^2*(1+(Z : β))^3 := by | |
| unfold deletionQ | |
| rw [mul_pow, β Real.rpow_mul_natCast (by positivity)] | |
| have hb := lifetimeBeta_bounds hr | |
| have hd : (1 : β) β€ (max 1 Z : β) := by exact_mod_cast le_max_left 1 Z | |
| have hd' : ((max 1 Z : β) : β) β€ 1+(Z : β) := by | |
| rw [Nat.cast_max, Nat.cast_one] | |
| exact max_le (by linarith [Nat.cast_nonneg (Ξ± := β) Z]) (by linarith) | |
| have hp := Real.rpow_le_rpow_of_exponent_le hd (show lifetimeBeta (r+1)* (2 : β) β€ (3 : β) by linarith) | |
| change _ β€ ((max 1 Z : β) : β)^((3 : β) : β) at hp | |
| rw [Real.rpow_natCast] at hp | |
| exact mul_le_mul_of_nonneg_left (hp.trans (pow_le_pow_leftβ (by positivity) hd' 3)) (sq_nonneg _) | |
| end RandomKSAT | |
| end | |
| end OAI | |