| import OAI.Probability.SATVariance.CountMoments | |
| namespace OAI | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory | |
| namespace RandomKSAT | |
| open scoped Classical ENNReal | |
| def renameClause {n m k : ℕ} (e : Fin n ≃ Fin m) (c : Clause n k) : Clause m k := | |
| ⟨⟨c.1.1.map e.toEmbedding, by simpa using c.1.2⟩, | |
| fun v => c.2 ⟨e.symm v, by simpa using v.property⟩⟩ | |
| lemma mem_renameClause {n m k : ℕ} (e : Fin n ≃ Fin m) (c : Clause n k) (v : Fin m) : | |
| v ∈ (renameClause e c).1.1 ↔ e.symm v ∈ c.1.1 := by simp [renameClause] | |
| lemma read_renameClause {n m k : ℕ} (e : Fin n ≃ Fin m) (c : Clause n k) (v : Fin m) : | |
| clauseRead (renameClause e c) v = clauseRead c (e.symm v) := by | |
| by_cases h : e.symm v ∈ c.1.1 <;> simp [clauseRead, renameClause, h] | |
| def renameClauseEquiv {n m k : ℕ} (e : Fin n ≃ Fin m) : Clause n k ≃ Clause m k where | |
| toFun := renameClause e | |
| invFun := renameClause e.symm | |
| left_inv c := by apply clause_ext; intro v; simp only [read_renameClause, Equiv.symm_symm, Equiv.symm_apply_apply] | |
| right_inv c := by apply clause_ext; intro v; simp only [read_renameClause, Equiv.symm_symm, Equiv.apply_symm_apply] | |
| lemma renameClauseEquiv_apply {n m k : ℕ} (e : Fin n ≃ Fin m) (c : Clause n k) : | |
| renameClauseEquiv e c = renameClause e c := rfl | |
| lemma support_probability_uniform {n k : ℕ} (v w : Fin n) : | |
| favg (fun c : Clause n k => if v ∈ c.1.1 then (1 : ℝ) else 0) = | |
| favg (fun c : Clause n k => if w ∈ c.1.1 then (1 : ℝ) else 0) := by | |
| have hh := favg_equiv (renameClauseEquiv (k := k) (Equiv.swap v w)) | |
| (fun c : Clause n k => if w ∈ c.1.1 then (1 : ℝ) else 0) | |
| simpa only [renameClauseEquiv_apply, mem_renameClause, Equiv.symm_swap, Equiv.swap_apply_right] using hh | |
| lemma support_probability_scaled {n k : ℕ} (hkn : k ≤ n) (v : Fin n) : | |
| (n : ℝ)*favg (fun c : Clause n k => if v ∈ c.1.1 then (1 : ℝ) else 0) = k := by | |
| let := clause_nonempty n k hkn | |
| have he (c : Clause n k) : (∑ w : Fin n, if w ∈ c.1.1 then (1 : ℝ) else 0) = k := by | |
| simp only [Finset.sum_boole] | |
| have hh : Finset.univ.filter (fun w => w ∈ c.1.1) = c.1.1 := by ext w; simp | |
| rw [hh, c.1.2] | |
| have hh : favg (fun c : Clause n k => ∑ w : Fin n, if w ∈ c.1.1 then (1 : ℝ) else 0) = k := by | |
| simp only [he, favg_const] | |
| rw [favg_sum] at hh | |
| have hew (w : Fin n) := support_probability_uniform (k := k) w v | |
| simp only [hew, Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] at hh | |
| exact hh | |
| lemma support_pair_probability_uniform {n k : ℕ} (v w z : Fin n) (hw : w ≠ v) (hz : z ≠ v) : | |
| favg (fun c : Clause n k => if v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) = | |
| favg (fun c : Clause n k => if v ∈ c.1.1 ∧ z ∈ c.1.1 then (1 : ℝ) else 0) := by | |
| have hh := favg_equiv (renameClauseEquiv (k := k) (Equiv.swap w z)) | |
| (fun c : Clause n k => if v ∈ c.1.1 ∧ z ∈ c.1.1 then (1 : ℝ) else 0) | |
| simpa only [renameClauseEquiv_apply, mem_renameClause, Equiv.symm_swap, Equiv.swap_apply_right, | |
| Equiv.swap_apply_of_ne_of_ne (Ne.symm hw) (Ne.symm hz)] using hh | |
| lemma support_pair_probability_scaled {n k : ℕ} (hk : 1 ≤ k) (hkn : k ≤ n) | |
| (v w : Fin n) (hw : w ≠ v) : | |
| ((n : ℝ)-1)*favg (fun c : Clause n k => if v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) = | |
| ((k : ℝ)-1)*favg (fun c : Clause n k => if v ∈ c.1.1 then (1 : ℝ) else 0) := by | |
| have he (c : Clause n k) : | |
| (∑ z ∈ (Finset.univ.erase v), if v ∈ c.1.1 ∧ z ∈ c.1.1 then (1 : ℝ) else 0) = | |
| ((k : ℝ)-1)*(if v ∈ c.1.1 then 1 else 0) := by | |
| by_cases hv : v ∈ c.1.1 | |
| · simp only [hv, true_and, ite_true, mul_one, Finset.sum_boole] | |
| have hh : (Finset.univ.erase v).filter (fun z => z ∈ c.1.1) = c.1.1.erase v := by ext z; simp | |
| rw [hh, Finset.card_erase_of_mem hv, c.1.2, Nat.cast_sub hk, Nat.cast_one] | |
| · simp [hv] | |
| have hh := congrArg (fun f : Clause n k → ℝ => favg f) (funext he) | |
| rw [favg_sum, favg_mul] at hh | |
| have hs : (∑ z ∈ (Finset.univ.erase v), | |
| favg (fun c : Clause n k => if v ∈ c.1.1 ∧ z ∈ c.1.1 then (1 : ℝ) else 0)) = | |
| ((n : ℝ)-1)*favg (fun c : Clause n k => if v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) := by | |
| trans ∑ _z ∈ (Finset.univ.erase v), favg (fun c : Clause n k => if v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) | |
| · apply Finset.sum_congr rfl | |
| intro z hz | |
| exact support_pair_probability_uniform v z w (Finset.mem_erase.mp hz).1 hw | |
| · simp only [Finset.sum_const, Finset.card_erase_of_mem (Finset.mem_univ v), Finset.card_univ, | |
| Fintype.card_fin, nsmul_eq_mul, Nat.cast_sub (show 1 ≤ n by omega), Nat.cast_one] | |
| rwa [hs] at hh | |
| lemma support_pair_probability_bound {n k : ℕ} (hn : 2 ≤ n) (hk : 1 ≤ k) (hkn : k ≤ n) | |
| (v w : Fin n) (hw : w ≠ v) : | |
| (n : ℝ)^2*favg (fun c : Clause n k => if v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) ≤ | |
| 2*(k : ℝ)^2 := by | |
| let P := favg (fun c : Clause n k => if v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) | |
| let p := favg (fun c : Clause n k => if v ∈ c.1.1 then (1 : ℝ) else 0) | |
| have hP : 0 ≤ P := favg_nonneg fun _ => by split <;> norm_num | |
| have hh := support_pair_probability_scaled hk hkn v w hw | |
| have hp := support_probability_scaled hkn v | |
| change ((n : ℝ)-1)*P = ((k : ℝ)-1)*p at hh | |
| change (n : ℝ)*p = k at hp | |
| have hn2 : (2 : ℝ) ≤ n := by exact_mod_cast hn | |
| have hm : (n : ℝ)*((n : ℝ)-1)*P = ((k : ℝ)-1)*k := by | |
| calc | |
| _ = (n : ℝ)*(((n : ℝ)-1)*P) := by ring | |
| _ = (n : ℝ)*(((k : ℝ)-1)*p) := by rw [hh] | |
| _ = ((k : ℝ)-1)*((n : ℝ)*p) := by ring | |
| _ = _ := by rw [hp] | |
| have hmul := mul_nonneg (show 0 ≤ (n : ℝ)-2 by linarith) (mul_nonneg (Nat.cast_nonneg n) hP) | |
| change (n : ℝ)^2*P ≤ _ | |
| nlinarith [Nat.cast_nonneg (α := ℝ) k] | |
| def clauseOverlap {n k : ℕ} (R : Finset (Fin n)) (c : Clause n k) : ℕ := | |
| (R ∩ c.1.1).card | |
| lemma incidence_indicator_le {n k : ℕ} (R : Finset (Fin n)) (c : Clause n k) : | |
| (if clauseOverlap R c ≠ 0 then (1 : ℝ) else 0) ≤ | |
| ∑ v ∈ R, if v ∈ c.1.1 then (1 : ℝ) else 0 := by | |
| split_ifs with h | |
| · obtain ⟨v,hv⟩ := Finset.card_pos.mp (Nat.pos_of_ne_zero h) | |
| have hRv := (Finset.mem_inter.mp hv).1 | |
| have hcv := (Finset.mem_inter.mp hv).2 | |
| have hh := Finset.single_le_sum (f := fun v => if v ∈ c.1.1 then (1 : ℝ) else 0) | |
| (fun w _ => by split <;> norm_num) hRv | |
| simpa only [ite_eq_left hcv] using hh | |
| · exact Finset.sum_nonneg fun _ _ => by split <;> norm_num | |
| lemma collision_indicator_le {n k : ℕ} (R : Finset (Fin n)) (c : Clause n k) : | |
| (if 2 ≤ clauseOverlap R c then (1 : ℝ) else 0) ≤ | |
| ∑ v ∈ R, ∑ w ∈ R, if v ≠ w ∧ v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0 := by | |
| have hnn (v : Fin n) : 0 ≤ ∑ w ∈ R, | |
| if v ≠ w ∧ v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0 := | |
| Finset.sum_nonneg fun _ _ => by split <;> norm_num | |
| split_ifs with h | |
| · obtain ⟨v,hv,w,hw,hvw⟩ := Finset.one_lt_card.mp (by change 2 ≤ (R ∩ c.1.1).card at h; omega : 1 < (R ∩ c.1.1).card) | |
| have hh := Finset.single_le_sum | |
| (f := fun w => if v ≠ w ∧ v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) | |
| (fun w _ => by split <;> norm_num) (Finset.mem_inter.mp hw).1 | |
| have hh' := Finset.single_le_sum (fun v _ => hnn v) (Finset.mem_inter.mp hv).1 | |
| apply le_trans _ hh' | |
| have hp : v ≠ w ∧ v ∈ c.1.1 ∧ w ∈ c.1.1 := | |
| ⟨hvw,(Finset.mem_inter.mp hv).2,(Finset.mem_inter.mp hw).2⟩ | |
| simpa only [ite_eq_left hp] using hh | |
| · exact Finset.sum_nonneg fun v _ => hnn v | |
| lemma incidence_probability_scaled {n k : ℕ} (hkn : k ≤ n) (R : Finset (Fin n)) : | |
| (n : ℝ)*favg (fun c : Clause n k => if clauseOverlap R c ≠ 0 then (1 : ℝ) else 0) ≤ | |
| (R.card : ℝ)*k := by | |
| have hh := favg_mono (fun c : Clause n k => incidence_indicator_le R c) | |
| rw [favg_sum] at hh | |
| have hm := mul_le_mul_of_nonneg_left hh (Nat.cast_nonneg (α := ℝ) n) | |
| rw [Finset.mul_sum] at hm | |
| simp only [support_probability_scaled hkn, Finset.sum_const, nsmul_eq_mul] at hm | |
| exact hm | |
| lemma collision_probability_scaled {n k : ℕ} (hn : 2 ≤ n) (hk : 1 ≤ k) (hkn : k ≤ n) | |
| (R : Finset (Fin n)) : | |
| (n : ℝ)^2*favg (fun c : Clause n k => if 2 ≤ clauseOverlap R c then (1 : ℝ) else 0) ≤ | |
| 2*(R.card : ℝ)^2*(k : ℝ)^2 := by | |
| let := clause_nonempty n k hkn | |
| have hh := favg_mono (fun c : Clause n k => collision_indicator_le R c) | |
| simp_rw [favg_sum] at hh | |
| calc | |
| _ ≤ (n : ℝ)^2*∑ v ∈ R, ∑ w ∈ R, | |
| favg (fun c : Clause n k => if v ≠ w ∧ v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) := | |
| mul_le_mul_of_nonneg_left hh (sq_nonneg _) | |
| _ = ∑ v ∈ R, ∑ w ∈ R, (n : ℝ)^2* | |
| favg (fun c : Clause n k => if v ≠ w ∧ v ∈ c.1.1 ∧ w ∈ c.1.1 then (1 : ℝ) else 0) := by | |
| simp_rw [Finset.mul_sum] | |
| _ ≤ ∑ _v ∈ R, ∑ _w ∈ R, 2*(k : ℝ)^2 := by | |
| apply Finset.sum_le_sum | |
| intro v _ | |
| apply Finset.sum_le_sum | |
| intro w _ | |
| by_cases hvw : v = w | |
| · simp only [hvw, ne_eq, not_true_eq_false, false_and, ite_false, favg_const, mul_zero] | |
| positivity | |
| · simp only [ne_eq, hvw, not_false_eq_true, true_and] | |
| exact support_pair_probability_bound hn hk hkn v w (Ne.symm hvw) | |
| _ = _ := by simp only [Finset.sum_const, nsmul_eq_mul]; ring | |
| def rootVariables {n k u : ℕ} (e : Fin k ⊕ Fin u ≃ Fin n) : Finset (Fin n) := | |
| Finset.univ.image (fun j => e (Sum.inl j)) | |
| lemma rootVariables_card {n k u : ℕ} (e : Fin k ⊕ Fin u ≃ Fin n) : | |
| (rootVariables e).card = k := by | |
| rw [rootVariables, Finset.card_image_of_injective _ (fun _ _ h => Sum.inl.inj (e.injective h))] | |
| simp | |
| lemma clauseOverlap_merge {n k u : ℕ} (e : Fin k ⊕ Fin u ≃ Fin n) | |
| (p : RootData u k) : clauseOverlap (rootVariables e) (mergeClause e p.1 p.2) = rootSize p.1 := by | |
| have he : rootVariables e ∩ (mergeClause e p.1 p.2).1.1 = | |
| (rootSupport p.1).image (fun j => e (Sum.inl j)) := by | |
| ext v | |
| obtain ⟨z,rfl⟩ := e.surjective v | |
| cases z <;> simp [rootVariables, mergeClause, rootSupport] | |
| simp only [clauseOverlap, he, Finset.card_image_of_injective _ (fun _ _ h => Sum.inl.inj (e.injective h)), rootSize] | |
| lemma rootIncident_scaled {n k u : ℕ} (hkn : k ≤ n) (e : Fin k ⊕ Fin u ≃ Fin n) : | |
| (n : ℝ)*hitProbability (rootIncident (u := u) (k := k)) ≤ (k : ℝ)^2 := by | |
| have he := favg_equiv (splitClauseEquiv e) | |
| (fun c : Clause n k => if clauseOverlap (rootVariables e) c ≠ 0 then (1 : ℝ) else 0) | |
| have hh := incidence_probability_scaled hkn (rootVariables e) | |
| change favg (fun p : RootData u k => if clauseOverlap (rootVariables e) (mergeClause e p.1 p.2) ≠ 0 then (1 : ℝ) else 0) = _ at he | |
| simp only [clauseOverlap_merge] at he | |
| rw [← he, rootVariables_card] at hh | |
| convert hh using 1 | |
| · unfold hitProbability | |
| congr 2 | |
| funext p | |
| unfold rootIncident | |
| split_ifs <;> rfl | |
| · ring | |
| lemma rootCollision_scaled {n k u : ℕ} (hn : 2 ≤ n) (hk : 1 ≤ k) | |
| (hkn : k ≤ n) (e : Fin k ⊕ Fin u ≃ Fin n) : | |
| (n : ℝ)^2*hitProbability (rootCollision (u := u) (k := k)) ≤ 2*(k : ℝ)^4 := by | |
| have he := favg_equiv (splitClauseEquiv e) | |
| (fun c : Clause n k => if 2 ≤ clauseOverlap (rootVariables e) c then (1 : ℝ) else 0) | |
| have hh := collision_probability_scaled hn hk hkn (rootVariables e) | |
| change favg (fun p : RootData u k => if 2 ≤ clauseOverlap (rootVariables e) (mergeClause e p.1 p.2) then (1 : ℝ) else 0) = _ at he | |
| simp only [clauseOverlap_merge] at he | |
| rw [← he, rootVariables_card] at hh | |
| change _ ≤ 2*(k : ℝ)^2*(k : ℝ)^2 at hh | |
| convert hh using 1 | |
| · unfold hitProbability | |
| congr 2 | |
| funext p | |
| unfold rootCollision | |
| split_ifs <;> rfl | |
| · ring | |
| lemma rootRewards_square_density {n u r M : ℕ} (hr : 2 ≤ r) (hru : r+1 ≤ u) | |
| (e : Fin (r+1) ⊕ Fin u ≃ Fin n) (a : Assignment (r+1)) | |
| {B : ℝ} (hB : 0 ≤ B) (hM : (M : ℝ) ≤ B*n) : | |
| favg (fun ps : Fin M → RootData u (r+1) => (dataRewards (forcedReward a) Finset.univ ps)^2) ≤ | |
| deletionMomentC (r+1) (B*(r+1 : ℕ)^2) (2*B^2*(r+1 : ℕ)^4)*durationLog (r+1) M := by | |
| have hn : r+1+u = n := by | |
| have hh := Fintype.card_congr e | |
| simpa only [Fintype.card_sum, Fintype.card_fin] using hh | |
| apply rootRewards_square_avg hr hru a | |
| · have hp := rootIncident_scaled (by omega : r+1 ≤ n) e | |
| have hm := mul_le_mul_of_nonneg_right hM (hitProbability_nonneg (rootIncident (u := u) (k := r+1))) | |
| have hb := mul_le_mul_of_nonneg_left hp hB | |
| nlinarith | |
| · have hq := rootCollision_scaled (by omega : 2 ≤ n) (by omega : 1 ≤ r+1) (by omega) e | |
| have hm := pow_le_pow_left₀ (Nat.cast_nonneg (α := ℝ) M) hM 2 | |
| have hm' := mul_le_mul_of_nonneg_right hm (hitProbability_nonneg (rootCollision (u := u) (k := r+1))) | |
| have hb := mul_le_mul_of_nonneg_left hq (sq_nonneg B) | |
| nlinarith | |
| end RandomKSAT | |
| end | |
| end OAI | |