Download data/lean/OAI/Probability/RandomSAT/Forcing.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 24.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Forcing.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/RandomSAT/Forcing.lean
-
curl -L -o Forcing.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Forcing.lean
24.9 kB
| import OAI.Probability.RandomSAT.Binomial | |
| namespace OAI | |
| /-! | |
| Deletion and erasure of a coordinate, permutation symmetry, and the integrated | |
| forcing bound. | |
| -/ | |
| namespace FixedClauseThreshold | |
| open Finset | |
| noncomputable section | |
| attribute [local instance] Classical.propDecidable | |
| abbrev SplitClause (v k : β) := ProperClause v k β (ProperClause v (k - 1) Γ Bool) | |
| def DeletedSatisfied {v k : β} (Ο : Assignment v) : SplitClause v k β Prop | |
| | .inl C => SatisfiesClause Ο C | |
| | .inr _ => True | |
| def ErasedSatisfied {v k : β} (Ο : Assignment v) : SplitClause v k β Prop | |
| | .inl C => SatisfiesClause Ο C | |
| | .inr Q => SatisfiesClause Ο Q.1 | |
| def deletedSolutions {v k m : β} (S : Finset (Assignment v)) (F : Fin m β SplitClause v k) : | |
| Finset (Assignment v) := S.filter (fun Ο => β i, DeletedSatisfied Ο (F i)) | |
| def erasedSolutions {v k m : β} (S : Finset (Assignment v)) (F : Fin m β SplitClause v k) : | |
| Finset (Assignment v) := S.filter (fun Ο => β i, ErasedSatisfied Ο (F i)) | |
| @[simp] theorem mem_deletedSolutions {v k m : β} (S : Finset (Assignment v)) | |
| (F : Fin m β SplitClause v k) (Ο : Assignment v) : | |
| Ο β deletedSolutions S F β Ο β S β§ β i, DeletedSatisfied Ο (F i) := by | |
| simp [deletedSolutions] | |
| @[simp] theorem mem_erasedSolutions {v k m : β} (S : Finset (Assignment v)) | |
| (F : Fin m β SplitClause v k) (Ο : Assignment v) : | |
| Ο β erasedSolutions S F β Ο β S β§ β i, ErasedSatisfied Ο (F i) := by | |
| simp [erasedSolutions] | |
| theorem erasedSolutions_subset {v k m : β} (S : Finset (Assignment v)) | |
| (F : Fin m β SplitClause v k) : erasedSolutions S F β deletedSolutions S F := by | |
| intro Ο hΟ | |
| rw [mem_erasedSolutions] at hΟ | |
| rw [mem_deletedSolutions] | |
| refine β¨hΟ.1, fun i => ?_β© | |
| have hi := hΟ.2 i | |
| cases hFi : F i with | |
| | inl C => simpa [ErasedSatisfied, DeletedSatisfied, hFi] using hi | |
| | inr Q => trivial | |
| theorem satisfies_head_split {v k : β} (hk : 0 < k) (Ο : Assignment v) | |
| (b : Bool) (X : SplitClause v k) : | |
| SatisfiesClause (Fin.cons b Ο) ((clauseHeadEquiv hk).symm X) β | |
| match X with | |
| | .inl C => SatisfiesClause Ο C | |
| | .inr Q => Q.2 = b β¨ SatisfiesClause Ο Q.1 := by | |
| cases X with | |
| | inl C => exact satisfiesClause_prependAbsent Ο b C | |
| | inr Q => exact satisfiesClause_prependPresent hk Ο b Q.2 Q.1 | |
| theorem head_erasure_extension {v k m : β} (hk : 0 < k) | |
| (F : Fin m β SplitClause v k) {Ο : Assignment v} | |
| (hΟ : Ο β erasedSolutions Finset.univ F) (b : Bool) : | |
| Satisfies (Fin.cons b Ο) (fun i => (clauseHeadEquiv hk).symm (F i)) := by | |
| intro i | |
| rw [satisfies_head_split] | |
| have hi := ((mem_erasedSolutions _ _ _).mp hΟ).2 i | |
| cases hFi : F i with | |
| | inl C => simpa [ErasedSatisfied, hFi] using hi | |
| | inr Q => exact Or.inr (by simpa [ErasedSatisfied, hFi] using hi) | |
| theorem head_deletion_projection {v k m : β} (hk : 0 < k) | |
| (F : Fin m β SplitClause v k) {Ο : Assignment (v + 1)} | |
| (hΟ : Satisfies Ο (fun i => (clauseHeadEquiv hk).symm (F i))) : | |
| Fin.tail Ο β deletedSolutions Finset.univ F := by | |
| rw [mem_deletedSolutions] | |
| refine β¨Finset.mem_univ _, fun i => ?_β© | |
| have hi := hΟ i | |
| rw [β Fin.cons_self_tail Ο, satisfies_head_split] at hi | |
| cases hFi : F i with | |
| | inl C => simpa [DeletedSatisfied, hFi] using hi | |
| | inr Q => trivial | |
| theorem head_forced_reduction {v k m : β} (hk : 0 < k) (F : Fin m β SplitClause v k) | |
| (hf : (0 : Fin (v + 1)) β forcedVariables | |
| (restrictSolutions Finset.univ (fun i => (clauseHeadEquiv hk).symm (F i)))) : | |
| (deletedSolutions Finset.univ F).Nonempty β§ Β¬ (erasedSolutions Finset.univ F).Nonempty := by | |
| simp only [forcedVariables, Finset.mem_filter, Finset.mem_univ, true_and] at hf | |
| obtain β¨Ο, hΟβ© := hf.1 | |
| have hsat : Satisfies Ο (fun i => (clauseHeadEquiv hk).symm (F i)) := | |
| ((mem_restrictSolutions _ _ _).mp hΟ).2 | |
| refine β¨β¨Fin.tail Ο, head_deletion_projection hk F hsatβ©, ?_β© | |
| rintro β¨Ο, hΟβ© | |
| obtain β¨b, hbβ© := hf.2 | |
| have hext (t : Bool) : Fin.cons t Ο β | |
| restrictSolutions Finset.univ (fun i => (clauseHeadEquiv hk).symm (F i)) := by | |
| rw [mem_restrictSolutions] | |
| exact β¨Finset.mem_univ _, head_erasure_extension hk F hΟ tβ© | |
| have hfalse := hb _ (hext false) | |
| have htrue := hb _ (hext true) | |
| simp only [Fin.cons_zero] at hfalse htrue | |
| cases b <;> simp_all | |
| theorem head_forced_indicator_le {v k m : β} (hk : 0 < k) (F : Fin m β SplitClause v k) : | |
| (if (0 : Fin (v + 1)) β forcedVariables | |
| (restrictSolutions Finset.univ (fun i => (clauseHeadEquiv hk).symm (F i))) | |
| then (1 : β) else 0) β€ | |
| alive (deletedSolutions Finset.univ F) - alive (erasedSolutions Finset.univ F) := by | |
| split | |
| Β· rename_i h | |
| obtain β¨hd, heβ© := head_forced_reduction hk F h | |
| simp [alive, hd, he] | |
| Β· have h := alive_mono (erasedSolutions_subset Finset.univ F) | |
| linarith | |
| theorem deletedSolutions_cons_inl {v k m : β} (S : Finset (Assignment v)) | |
| (C : ProperClause v k) (F : Fin m β SplitClause v k) : | |
| deletedSolutions S (Fin.cons (.inl C) F) = deletedSolutions (addClause S C) F := by | |
| ext Ο | |
| simp only [mem_deletedSolutions, mem_addClause, Fin.forall_fin_succ, | |
| Fin.cons_zero, Fin.cons_succ, DeletedSatisfied] | |
| tauto | |
| theorem deletedSolutions_cons_inr {v k m : β} (S : Finset (Assignment v)) | |
| (Q : ProperClause v (k - 1)) (b : Bool) (F : Fin m β SplitClause v k) : | |
| deletedSolutions S (Fin.cons (.inr (Q, b)) F) = deletedSolutions S F := by | |
| ext Ο | |
| simp only [mem_deletedSolutions, Fin.forall_fin_succ, | |
| Fin.cons_zero, Fin.cons_succ, DeletedSatisfied, true_and] | |
| theorem erasedSolutions_cons_inl {v k m : β} (S : Finset (Assignment v)) | |
| (C : ProperClause v k) (F : Fin m β SplitClause v k) : | |
| erasedSolutions S (Fin.cons (.inl C) F) = erasedSolutions (addClause S C) F := by | |
| ext Ο | |
| simp only [mem_erasedSolutions, mem_addClause, Fin.forall_fin_succ, | |
| Fin.cons_zero, Fin.cons_succ, ErasedSatisfied] | |
| tauto | |
| theorem erasedSolutions_cons_inr {v k m : β} (S : Finset (Assignment v)) | |
| (Q : ProperClause v (k - 1)) (b : Bool) (F : Fin m β SplitClause v k) : | |
| erasedSolutions S (Fin.cons (.inr (Q, b)) F) = erasedSolutions (addClause S Q) F := by | |
| ext Ο | |
| simp only [mem_erasedSolutions, mem_addClause, Fin.forall_fin_succ, | |
| Fin.cons_zero, Fin.cons_succ, ErasedSatisfied] | |
| tauto | |
| def deletedMean {v k : β} (hk : 0 < k) (m : β) (S : Finset (Assignment v)) : β := | |
| uniformMean (fun F : Formula (v + 1) k m => | |
| alive (deletedSolutions S (fun i => clauseHeadSplit hk (F i)))) | |
| def erasedMean {v k : β} (hk : 0 < k) (m : β) (S : Finset (Assignment v)) : β := | |
| uniformMean (fun F : Formula (v + 1) k m => | |
| alive (erasedSolutions S (fun i => clauseHeadSplit hk (F i)))) | |
| @[simp] theorem deletedMean_zero {v k : β} (hk : 0 < k) (S : Finset (Assignment v)) : | |
| deletedMean hk 0 S = alive S := by | |
| have h (F : Formula (v + 1) k 0) : | |
| deletedSolutions S (fun i => clauseHeadSplit hk (F i)) = S := by | |
| ext Ο | |
| simp | |
| simp only [deletedMean, h, uniformMean_const] | |
| @[simp] theorem erasedMean_zero {v k : β} (hk : 0 < k) (S : Finset (Assignment v)) : | |
| erasedMean hk 0 S = alive S := by | |
| have h (F : Formula (v + 1) k 0) : | |
| erasedSolutions S (fun i => clauseHeadSplit hk (F i)) = S := by | |
| ext Ο | |
| simp | |
| simp only [erasedMean, h, uniformMean_const] | |
| theorem deletedMean_succ {v k m : β} (hk : 0 < k) (hkv : k β€ v) | |
| (S : Finset (Assignment v)) : | |
| deletedMean hk (m + 1) S = | |
| (1 - (k : β) / (v + 1)) * clauseAverage k (deletedMean hk m) S + | |
| ((k : β) / (v + 1)) * deletedMean hk m S := by | |
| let : Nonempty (ProperClause v (k - 1)) := nonempty_properClause (by omega) | |
| unfold deletedMean | |
| rw [uniformMean_fin_succ] | |
| have hcons (C : ProperClause (v + 1) k) (F : Formula (v + 1) k m) : | |
| (fun i : Fin (m + 1) => clauseHeadSplit hk ((Fin.cons C F : Formula (v + 1) k (m + 1)) i)) = | |
| Fin.cons (clauseHeadSplit hk C) (fun i => clauseHeadSplit hk (F i)) := by | |
| funext i | |
| refine Fin.cases ?_ (fun _ => ?_) i <;> rfl | |
| simp only [hcons] | |
| rw [clauseHead_mean hk hkv (fun X => uniformMean (fun F : Formula (v + 1) k m => | |
| alive (deletedSolutions S (Fin.cons X (fun i => clauseHeadSplit hk (F i))))))] | |
| simp only [deletedSolutions_cons_inl, deletedSolutions_cons_inr, | |
| uniformMean_const] | |
| rfl | |
| theorem erasedMean_succ {v k m : β} (hk : 0 < k) (hkv : k β€ v) | |
| (S : Finset (Assignment v)) : | |
| erasedMean hk (m + 1) S = | |
| (1 - (k : β) / (v + 1)) * clauseAverage k (erasedMean hk m) S + | |
| ((k : β) / (v + 1)) * clauseAverage (k - 1) (erasedMean hk m) S := by | |
| unfold erasedMean | |
| rw [uniformMean_fin_succ] | |
| have hcons (C : ProperClause (v + 1) k) (F : Formula (v + 1) k m) : | |
| (fun i : Fin (m + 1) => clauseHeadSplit hk ((Fin.cons C F : Formula (v + 1) k (m + 1)) i)) = | |
| Fin.cons (clauseHeadSplit hk C) (fun i => clauseHeadSplit hk (F i)) := by | |
| funext i | |
| refine Fin.cases ?_ (fun _ => ?_) i <;> rfl | |
| simp only [hcons] | |
| rw [clauseHead_mean hk hkv (fun X => uniformMean (fun F : Formula (v + 1) k m => | |
| alive (erasedSolutions S (Fin.cons X (fun i => clauseHeadSplit hk (F i))))))] | |
| simp only [erasedSolutions_cons_inl, erasedSolutions_cons_inr, | |
| uniformMean_const] | |
| rfl | |
| theorem clauseAverage_binomialMean {v k : β} (p : β) (m : β) | |
| (f : β β Finset (Assignment v) β β) (S : Finset (Assignment v)) : | |
| clauseAverage k (fun T => binomialMean p m (fun d => f d T)) S = | |
| binomialMean p m (fun d => clauseAverage k (f d) S) := | |
| uniformMean_binomialMean p m _ | |
| theorem clauseAverage_survival {v k t : β} (S : Finset (Assignment v)) : | |
| clauseAverage k (survival k t) S = survival k (t + 1) S := | |
| (survival_succ S).symm | |
| theorem clauseAverage_short_survival {n k t : β} (hk : 3 β€ k) (hn : k + 1 β€ n) | |
| (S : Finset (Assignment (n - 1))) : | |
| survival k (t + replacementBlock n k) S - replacementError n k β€ | |
| clauseAverage (k - 1) (survival k t) S := by | |
| have h := clauseAverage_iterate_mono (k := k) (m := t) | |
| (shorter_survival_replacement hk hn) S | |
| rw [clauseAverage_iterate_sub_const (by omega)] at h | |
| dsimp only at h | |
| rw [survival_add] at h | |
| have he : clauseAverage (k - 1) (survival k t) S = | |
| ((clauseAverage k)^[t] (survival (k - 1) 1)) S := | |
| survival_shift (m := 1) (d := t) S | |
| rw [he] | |
| simpa using h | |
| theorem deletedMean_eq_binomial {v k m : β} (hk : 0 < k) (hkv : k β€ v) | |
| (S : Finset (Assignment v)) : | |
| deletedMean hk m S = binomialMean ((k : β) / (v + 1)) m | |
| (fun d => survival k (m - d) S) := by | |
| induction m generalizing S with | |
| | zero => simp [binomialMean] | |
| | succ m ih => | |
| rw [deletedMean_succ hk hkv] | |
| have hfun : deletedMean hk m = | |
| (fun T : Finset (Assignment v) => binomialMean ((k : β) / (v + 1)) m | |
| (fun d => survival k (m - d) T)) := funext ih | |
| rw [hfun, clauseAverage_binomialMean] | |
| change _ = (1 - (k : β) / (v + 1)) * _ + ((k : β) / (v + 1)) * _ | |
| congr 1 | |
| Β· congr 1 | |
| apply binomialMean_congr | |
| intro d hd | |
| rw [clauseAverage_survival] | |
| congr 1 | |
| omega | |
| Β· congr 1 | |
| apply binomialMean_congr | |
| intro d _ | |
| congr 1 | |
| omega | |
| theorem erasedMean_replacement {n k m : β} (hk : 3 β€ k) (hn : k + 1 β€ n) | |
| (S : Finset (Assignment (n - 1))) : | |
| binomialMean ((k : β) / n) m (fun d => | |
| survival k (m - d + replacementBlock n k * d) S - | |
| (d : β) * replacementError n k) β€ erasedMean (by omega : 0 < k) m S := by | |
| have hkn : k β€ n - 1 := by omega | |
| have hshort : k - 1 β€ n - 1 := by omega | |
| have hn1 : n - 1 + 1 = n := by omega | |
| have hp0 : 0 β€ (k : β) / n := by positivity | |
| have hp1 : (k : β) / n β€ 1 := by | |
| apply (div_le_one (by exact_mod_cast (by omega : 0 < n))).mpr | |
| exact_mod_cast (by omega : k β€ n) | |
| induction m generalizing S with | |
| | zero => simp [binomialMean] | |
| | succ m ih => | |
| rw [erasedMean_succ (by omega) hkn] | |
| have hden : ((n - 1 : β) : β) + 1 = n := by exact_mod_cast hn1 | |
| rw [hden] | |
| have hlong := clauseAverage_mono (k := k) ih S | |
| have hshorter := clauseAverage_mono (k := k - 1) ih S | |
| rw [clauseAverage_binomialMean] at hlong hshorter | |
| have ha : binomialMean ((k : β) / n) m (fun d => | |
| survival k (m + 1 - d + replacementBlock n k * d) S - | |
| (d : β) * replacementError n k) β€ clauseAverage k (erasedMean (by omega : 0 < k) m) S := by | |
| calc | |
| _ = binomialMean ((k : β) / n) m (fun d => clauseAverage k | |
| (fun T => survival k (m - d + replacementBlock n k * d) T - | |
| (d : β) * replacementError n k) S) := by | |
| apply binomialMean_congr | |
| intro d hd | |
| rw [clauseAverage_sub_const hkn, clauseAverage_survival] | |
| congr 2 | |
| omega | |
| _ β€ _ := hlong | |
| have hb : binomialMean ((k : β) / n) m (fun d => | |
| survival k (m + 1 - (d + 1) + replacementBlock n k * (d + 1)) S - | |
| ((d + 1 : β) : β) * replacementError n k) β€ | |
| clauseAverage (k - 1) (erasedMean (by omega : 0 < k) m) S := by | |
| apply le_trans _ hshorter | |
| apply binomialMean_mono hp0 hp1 | |
| intro d _ | |
| rw [clauseAverage_sub_const hshort] | |
| have h := clauseAverage_short_survival (t := m - d + replacementBlock n k * d) hk hn S | |
| have he : m + 1 - (d + 1) + replacementBlock n k * (d + 1) = | |
| m - d + replacementBlock n k * d + replacementBlock n k := by | |
| rw [Nat.mul_add, Nat.mul_one] | |
| omega | |
| rw [he] | |
| push_cast | |
| linarith | |
| exact add_le_add (mul_le_mul_of_nonneg_left ha (sub_nonneg.mpr hp1)) | |
| (mul_le_mul_of_nonneg_left hb hp0) | |
| theorem replacementBlock_pos {n k : β} (hn : 0 < n) (hk : 0 < k) : | |
| 1 β€ replacementBlock n k := by | |
| have hp : 0 < 2 * (k : β) * replacementScale n k := | |
| mul_pos (mul_pos (by norm_num) (by exact_mod_cast hk)) (replacementScale_pos hn) | |
| exact Nat.ceil_pos.mpr hp | |
| theorem replacementError_nonneg (n k : β) : 0 β€ replacementError n k := by | |
| unfold replacementError replacementScale | |
| positivity | |
| def headForcedMean (v k m : β) : β := | |
| uniformMean (fun F : Formula (v + 1) k m => | |
| if (0 : Fin (v + 1)) β forcedVariables (restrictSolutions Finset.univ F) | |
| then (1 : β) else 0) | |
| theorem headForcedMean_le_difference {v k m : β} (hk : 0 < k) : | |
| headForcedMean v k m β€ deletedMean (v := v) hk m Finset.univ - erasedMean (v := v) hk m Finset.univ := by | |
| unfold headForcedMean deletedMean erasedMean | |
| rw [β uniformMean_sub] | |
| apply uniformMean_mono | |
| intro F | |
| have he : (fun i => (clauseHeadEquiv hk).symm (clauseHeadSplit hk (F i))) = F := by | |
| funext i | |
| exact (clauseHeadEquiv hk).symm_apply_apply (F i) | |
| have h := head_forced_indicator_le hk (fun i => clauseHeadSplit hk (F i)) | |
| simpa only [he] using h | |
| theorem headForcedMean_replacement {v k m : β} (hk : 3 β€ k) (hkv : k β€ v) : | |
| headForcedMean v k m β€ | |
| binomialMean ((k : β) / (v + 1)) m | |
| (replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) m) + | |
| ((m : β) * ((k : β) / (v + 1))) * replacementError (v + 1) k := by | |
| have hdel := deletedMean_eq_binomial (m := m) (by omega : 0 < k) hkv Finset.univ | |
| have her := erasedMean_replacement (n := v + 1) (m := m) hk (by omega) Finset.univ | |
| simp only [Nat.cast_add, Nat.cast_one] at her | |
| have hforced := headForcedMean_le_difference (v := v) (m := m) (by omega : 0 < k) | |
| rw [hdel] at hforced | |
| have hsub : (binomialMean ((k : β) / (v + 1)) m (fun d => survival k (m - d) | |
| (Finset.univ : Finset (Assignment v)))) - | |
| binomialMean ((k : β) / (v + 1)) m (fun d => | |
| survival k (m - d + replacementBlock (v + 1) k * d) | |
| (Finset.univ : Finset (Assignment v)) - | |
| (d : β) * replacementError (v + 1) k) = | |
| binomialMean ((k : β) / (v + 1)) m | |
| (replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) m) + | |
| ((m : β) * ((k : β) / (v + 1))) * replacementError (v + 1) k := by | |
| rw [β binomialMean_sub] | |
| have hg : 1 β€ replacementBlock (v + 1) k := replacementBlock_pos (by omega) (by omega) | |
| calc | |
| _ = binomialMean ((k : β) / (v + 1)) m (fun d => | |
| replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) m d + | |
| (d : β) * replacementError (v + 1) k) := by | |
| apply binomialMean_congr | |
| intro d hd | |
| unfold replacementDifference | |
| rw [properSATProbability_eq_survival, properSATProbability_eq_survival] | |
| have he : m - d + replacementBlock (v + 1) k * d = | |
| m + (replacementBlock (v + 1) k - 1) * d := by | |
| have hh := Nat.sub_add_cancel hg | |
| have := congrArg (fun a : β => a * d) hh | |
| simp only [Nat.add_mul, Nat.one_mul] at this | |
| omega | |
| rw [he] | |
| ring | |
| _ = _ := by rw [binomialMean_add, binomialMean_mul_const, binomialMean_id] | |
| rw [β hsub] | |
| linarith | |
| theorem integrated_head_forcing {v k : β} (hk : 3 β€ k) (hkv : k β€ v) (M : β) : | |
| β j β Finset.range (M + 1), headForcedMean v k j β€ | |
| (replacementBlock (v + 1) k : β) * M * ((k : β) / (v + 1)) + | |
| ((M + 1 : β) : β) * M * ((k : β) / (v + 1)) * replacementError (v + 1) k := by | |
| have hp0 : 0 β€ (k : β) / (v + 1) := by positivity | |
| have hp1 : (k : β) / (v + 1) β€ 1 := by | |
| apply (div_le_one (by positivity)).mpr | |
| exact_mod_cast (by omega : k β€ v + 1) | |
| calc | |
| _ β€ β j β Finset.range (M + 1), | |
| (binomialMean ((k : β) / (v + 1)) j | |
| (replacementDifference (properSATProbability v k) (replacementBlock (v + 1) k) j) + | |
| ((j : β) * ((k : β) / (v + 1))) * replacementError (v + 1) k) := | |
| Finset.sum_le_sum (fun _ _ => headForcedMean_replacement hk hkv) | |
| _ = _ := Finset.sum_add_distrib | |
| _ β€ _ := by | |
| apply add_le_add | |
| Β· exact binomial_replacement_sum_le hp0 hp1 (properSATProbability_antitone hkv) | |
| (fun j => properSATProbability_nonneg v k j) (fun j => properSATProbability_le_one v k j) | |
| (replacementBlock_pos (by omega) (by omega)) M | |
| Β· calc | |
| _ β€ β _j β Finset.range (M + 1), | |
| ((M : β) * ((k : β) / (v + 1))) * replacementError (v + 1) k := by | |
| apply Finset.sum_le_sum | |
| intro j hj | |
| have hjM : (j : β) β€ M := by | |
| exact_mod_cast (Nat.le_of_lt_succ (Finset.mem_range.mp hj)) | |
| exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hjM hp0) | |
| (replacementError_nonneg (v + 1) k) | |
| _ = _ := by simp; ring | |
| def renameClause {n k : β} (e : Fin n β Fin n) (C : ProperClause n k) : ProperClause n k := | |
| β¨fun i => C.val (e i), by | |
| have h := Fintype.card_congr | |
| (e.subtypeEquivOfSubtype (p := fun i => (C.val i).isSome)) | |
| simp only [Fintype.card_subtype] at h | |
| exact h.trans C.propertyβ© | |
| def renameClauseEquiv {n k : β} (e : Fin n β Fin n) : ProperClause n k β ProperClause n k where | |
| toFun := renameClause e | |
| invFun := renameClause e.symm | |
| left_inv C := by apply Subtype.ext; funext i; simp [renameClause] | |
| right_inv C := by apply Subtype.ext; funext i; simp [renameClause] | |
| def renameAssignment {n : β} (e : Fin n β Fin n) (Ο : Assignment n) : Assignment n := | |
| fun i => Ο (e i) | |
| def renameFormula {n k m : β} (e : Fin n β Fin n) (F : Formula n k m) : Formula n k m := | |
| fun i => renameClause e (F i) | |
| def renameFormulaEquiv {n k m : β} (e : Fin n β Fin n) : Formula n k m β Formula n k m := | |
| Equiv.piCongrRight (fun _ => renameClauseEquiv e) | |
| theorem renameFormulaEquiv_apply {n k m : β} (e : Fin n β Fin n) (F : Formula n k m) : | |
| renameFormulaEquiv e F = renameFormula e F := rfl | |
| theorem satisfiesClause_rename {n k : β} (e : Fin n β Fin n) (Ο : Assignment n) | |
| (C : ProperClause n k) : | |
| SatisfiesClause (renameAssignment e Ο) (renameClause e C) β SatisfiesClause Ο C := by | |
| change (β i, C.val (e i) = some (Ο (e i))) β β i, C.val i = some (Ο i) | |
| constructor | |
| Β· rintro β¨i, hiβ© | |
| exact β¨e i, hiβ© | |
| Β· rintro β¨i, hiβ© | |
| exact β¨e.symm i, by simpa using hiβ© | |
| theorem satisfies_rename {n k m : β} (e : Fin n β Fin n) (Ο : Assignment n) | |
| (F : Formula n k m) : | |
| Satisfies (renameAssignment e Ο) (renameFormula e F) β Satisfies Ο F := by | |
| simp only [Satisfies, renameFormula, satisfiesClause_rename] | |
| theorem satisfies_rename_inverse {n k m : β} (e : Fin n β Fin n) (Ο : Assignment n) | |
| (F : Formula n k m) : | |
| Satisfies Ο (renameFormula e F) β Satisfies (renameAssignment e.symm Ο) F := by | |
| have h := satisfies_rename e (renameAssignment e.symm Ο) F | |
| have he : renameAssignment e (renameAssignment e.symm Ο) = Ο := by | |
| funext i | |
| exact congrArg Ο (e.symm_apply_apply i) | |
| rw [he] at h | |
| exact h | |
| theorem satisfiable_rename {n k m : β} (e : Fin n β Fin n) (F : Formula n k m) : | |
| Satisfiable (renameFormula e F) β Satisfiable F := by | |
| constructor | |
| Β· rintro β¨Ο, hΟβ© | |
| exact β¨renameAssignment e.symm Ο, (satisfies_rename_inverse e Ο F).mp hΟβ© | |
| Β· rintro β¨Ο, hΟβ© | |
| exact β¨renameAssignment e Ο, (satisfies_rename e Ο F).mpr hΟβ© | |
| theorem mem_forced_formula {n k m : β} (F : Formula n k m) (i : Fin n) : | |
| i β forcedVariables (restrictSolutions Finset.univ F) β | |
| Satisfiable F β§ β b, β Ο, Satisfies Ο F β Ο i = b := by | |
| simp [forcedVariables, Finset.Nonempty, Satisfiable, Satisfies] | |
| theorem forcedVariables_rename {n k m : β} (e : Fin n β Fin n) (F : Formula n k m) (i : Fin n) : | |
| i β forcedVariables (restrictSolutions Finset.univ (renameFormula e F)) β | |
| e i β forcedVariables (restrictSolutions Finset.univ F) := by | |
| rw [mem_forced_formula, mem_forced_formula, satisfiable_rename] | |
| constructor | |
| Β· rintro β¨hS, b, hbβ© | |
| refine β¨hS, b, fun Ο hΟ => ?_β© | |
| exact hb (renameAssignment e Ο) ((satisfies_rename e Ο F).mpr hΟ) | |
| Β· rintro β¨hS, b, hbβ© | |
| refine β¨hS, b, fun Ο hΟ => ?_β© | |
| have h := hb (renameAssignment e.symm Ο) ((satisfies_rename_inverse e Ο F).mp hΟ) | |
| simpa only [renameAssignment, Equiv.symm_apply_apply] using h | |
| theorem forced_coordinate_mean {v k m : β} (i : Fin (v + 1)) : | |
| uniformMean (fun F : Formula (v + 1) k m => | |
| if i β forcedVariables (restrictSolutions Finset.univ F) then (1 : β) else 0) = | |
| headForcedMean v k m := by | |
| let e : Fin (v + 1) β Fin (v + 1) := Equiv.swap 0 i | |
| calc | |
| _ = uniformMean (fun F : Formula (v + 1) k m => | |
| if (0 : Fin (v + 1)) β forcedVariables | |
| (restrictSolutions Finset.univ (renameFormula e F)) then (1 : β) else 0) := by | |
| apply uniformMean_congr | |
| intro F | |
| simp only [forcedVariables_rename, e, Equiv.swap_apply_left] | |
| _ = _ := by | |
| have h := uniformMean_equiv (renameFormulaEquiv (n := v + 1) (k := k) (m := m) e) | |
| (fun F : Formula (v + 1) k m => if (0 : Fin (v + 1)) β forcedVariables | |
| (restrictSolutions Finset.univ F) then (1 : β) else 0) | |
| have heq : (fun F : Formula (v + 1) k m => if (0 : Fin (v + 1)) β forcedVariables | |
| (restrictSolutions Finset.univ (renameFormula e F)) then (1 : β) else 0) = | |
| (fun F : Formula (v + 1) k m => if (0 : Fin (v + 1)) β forcedVariables | |
| (restrictSolutions Finset.univ (renameFormulaEquiv e F)) then (1 : β) else 0) := by | |
| funext F | |
| apply ite_congr | |
| Β· rfl | |
| Β· intro _; rfl | |
| Β· intro _; rfl | |
| rw [heq] | |
| exact h | |
| def forcedFractionMean (n k m : β) : β := | |
| uniformMean (fun F : Formula n k m => | |
| ((forcedVariables (restrictSolutions Finset.univ F)).card : β) / n) | |
| theorem forcedFractionMean_eq_head (v k m : β) : | |
| forcedFractionMean (v + 1) k m = headForcedMean v k m := by | |
| have hc (F : Formula (v + 1) k m) : | |
| ((forcedVariables (restrictSolutions Finset.univ F)).card : β) = | |
| β i : Fin (v + 1), if i β forcedVariables (restrictSolutions Finset.univ F) | |
| then (1 : β) else 0 := by simp | |
| unfold forcedFractionMean | |
| simp_rw [hc, div_eq_mul_inv] | |
| rw [uniformMean_mul_const, uniformMean_sum] | |
| simp only [forced_coordinate_mean, Finset.sum_const, Finset.card_univ, | |
| Fintype.card_fin, nsmul_eq_mul] | |
| have hv : ((v + 1 : β) : β) β 0 := by positivity | |
| field_simp | |
| theorem integrated_forcing_finite {n k : β} (hk : 3 β€ k) (hn : k + 1 β€ n) (M : β) : | |
| β j β Finset.range (M + 1), forcedFractionMean n k j β€ | |
| (replacementBlock n k : β) * M * ((k : β) / n) + | |
| ((M + 1 : β) : β) * M * ((k : β) / n) * replacementError n k := by | |
| cases n with | |
| | zero => omega | |
| | succ v => | |
| simp only [forcedFractionMean_eq_head] | |
| simpa only [Nat.cast_add, Nat.cast_one] using integrated_head_forcing hk (by omega) M | |
| end | |
| end FixedClauseThreshold | |
| end OAI | |