File size: 5,672 Bytes
135052a | 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 146 147 148 149 150 | import OAI.Probability.SATVariance.Model
namespace OAI
noncomputable section
open MeasureTheory ProbabilityTheory
namespace RandomKSAT
open scoped Classical ENNReal
lemma support_card (n k : ℕ) :
Fintype.card {s : Finset (Fin n) // s.card = k} = n.choose k := by
classical
rw [Fintype.card_of_subtype ((Finset.univ : Finset (Fin n)).powersetCard k)
(by intro s; simp)]
simp
lemma clause_card (n k : ℕ) : Fintype.card (Clause n k) = n.choose k * 2 ^ k := by
classical
change Fintype.card ((s : {s : Finset (Fin n) // s.card = k}) × (s.1 → Bool)) = _
rw [Fintype.card_sigma]
simp only [Fintype.card_fun, Fintype.card_bool, Fintype.card_coe]
trans ∑ _ : {s : Finset (Fin n) // s.card = k}, 2 ^ k
· apply Finset.sum_congr rfl
intro s _
rw [s.property]
· rw [Finset.sum_const, Finset.card_univ, support_card, smul_eq_mul]
lemma clause_nonempty (n k : ℕ) (hkn : k ≤ n) : Nonempty (Clause n k) := by
rw [← Fintype.card_pos_iff, clause_card]
exact Nat.mul_pos (Nat.choose_pos hkn) (pow_pos (by decide) _)
lemma clauseLaw_probability (n k : ℕ) (hkn : k ≤ n) :
IsProbabilityMeasure (clauseLaw n k) := by
let := clause_nonempty n k hkn
unfold clauseLaw
infer_instance
lemma streamLaw_probability (n k : ℕ) (hkn : k ≤ n) :
IsProbabilityMeasure (streamLaw n k) := by
let := clauseLaw_probability n k hkn
unfold streamLaw
infer_instance
def frozen {n : ℕ} (S : Finset (Assignment n)) : Finset (Fin n) :=
Finset.univ.filter fun v => ∀ a ∈ S, ∀ b ∈ S, a v = b v
def Kills {n k : ℕ} (S : Finset (Assignment n)) (c : Clause n k) : Prop :=
∀ a ∈ S, ¬ Satisfies c a
lemma bool_ne_iff (x y : Bool) : x ≠ y ↔ y = !x := by
cases x <;> cases y <;> decide
lemma kills_iff {n k : ℕ} {S : Finset (Assignment n)} {a₀ : Assignment n}
(ha₀ : a₀ ∈ S) (c : Clause n k) :
Kills S c ↔ c.1.1 ⊆ frozen S ∧ ∀ v : c.1.1, c.2 v = !(a₀ v) := by
classical
constructor
· intro h
have hn : ∀ a ∈ S, ∀ v : c.1.1, a v ≠ c.2 v := by
intro a ha v he
exact h a ha ⟨v, he⟩
refine ⟨?_, fun v => (bool_ne_iff _ _).mp (hn a₀ ha₀ v)⟩
intro v hv
simp only [frozen, Finset.mem_filter, Finset.mem_univ, true_and]
intro a ha b hb
have h₁ := (bool_ne_iff _ _).mp (hn a ha ⟨v, hv⟩)
have h₂ := (bool_ne_iff _ _).mp (hn b hb ⟨v, hv⟩)
exact Bool.not_injective (h₁.symm.trans h₂)
· rintro ⟨hs, ht⟩ a ha ⟨v, hv⟩
have hf := (Finset.mem_filter.mp (hs v.property)).2 a ha a₀ ha₀
have hne := (bool_ne_iff (a₀ v) (c.2 v)).mpr (ht v)
exact hne (hf.symm.trans hv)
def killingEquiv {n k : ℕ} {S : Finset (Assignment n)} {a₀ : Assignment n}
(ha₀ : a₀ ∈ S) :
{c : Clause n k // Kills S c} ≃
{s : Finset (Fin n) // s ⊆ frozen S ∧ s.card = k} where
toFun c := ⟨c.1.1.1, (kills_iff ha₀ c.1).mp c.2 |>.1, c.1.1.2⟩
invFun s := ⟨⟨⟨s.1, s.2.2⟩, fun v => !(a₀ v)⟩,
(kills_iff ha₀ _).mpr ⟨s.2.1, fun _ => rfl⟩⟩
left_inv c := by
apply Subtype.ext
rcases c with ⟨⟨s, f⟩, hc⟩
have hf := (kills_iff ha₀ ⟨s, f⟩).mp hc |>.2
dsimp
congr 1
exact funext fun v => (hf v).symm
right_inv s := by
apply Subtype.ext
rfl
lemma killing_card {n k : ℕ} {S : Finset (Assignment n)} (hS : S.Nonempty) :
Fintype.card {c : Clause n k // Kills S c} = (frozen S).card.choose k := by
classical
obtain ⟨a₀, ha₀⟩ := hS
rw [Fintype.card_congr (killingEquiv ha₀)]
rw [Fintype.card_of_subtype ((frozen S).powersetCard k) (by intro s; simp)]
exact Finset.card_powersetCard _ _
lemma count_set_fintype.{u_1} {α : Type u_1} [MeasurableSpace α] [MeasurableSingletonClass α]
[Fintype α] (s : Set α) :
Measure.count s = (Fintype.card s : ℝ≥0∞) := by
rw [Measure.count_apply (Set.toFinite s).measurableSet,
Set.encard_eq_coe_toFinset_card]
simp
lemma clauseLaw_kills {n k : ℕ} {S : Finset (Assignment n)} (hS : S.Nonempty) :
clauseLaw n k {c | Kills S c} =
((frozen S).card.choose k : ℝ≥0∞) / ((n.choose k : ℝ≥0∞) * 2 ^ k) := by
rw [clauseLaw, uniformOn_univ, count_set_fintype]
have hc : Fintype.card ↑{c : Clause n k | Kills S c} = (frozen S).card.choose k := by
simpa only [Fintype.card_subtype, Set.mem_ofPred_eq] using (killing_card hS)
rw [hc, clause_card]
simp only [Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat]
lemma frozen_singleton {n : ℕ} (a : Assignment n) : frozen {a} = Finset.univ := by
ext v
simp [frozen]
lemma clauseLaw_not_satisfies {n k : ℕ} (hkn : k ≤ n) (a : Assignment n) :
clauseLaw n k {c | ¬ Satisfies c a} = ((2 : ℝ≥0∞) ^ k)⁻¹ := by
have he : {c : Clause n k | ¬ Satisfies c a} = {c | Kills {a} c} := by
ext c
simp [Kills]
rw [he, clauseLaw_kills (Finset.singleton_nonempty a), frozen_singleton,
Finset.card_univ, Fintype.card_fin]
have hc : (n.choose k : ℝ≥0∞) ≠ 0 := by
exact_mod_cast (Nat.choose_pos hkn).ne'
rw [div_eq_mul_inv, ENNReal.mul_inv (Or.inl hc)
(Or.inl (ENNReal.natCast_ne_top _)), ← mul_assoc,
ENNReal.mul_inv_cancel hc (ENNReal.natCast_ne_top _), one_mul]
lemma clauseLaw_satisfies {n k : ℕ} (hkn : k ≤ n) (a : Assignment n) :
clauseLaw n k {c | Satisfies c a} = 1 - ((2 : ℝ≥0∞) ^ k)⁻¹ := by
let := clauseLaw_probability n k hkn
have he : {c : Clause n k | Satisfies c a} = {c | ¬ Satisfies c a}ᶜ := by
ext c
simp
rw [he, measure_compl (Set.toFinite _).measurableSet (measure_ne_top _ _),
measure_univ, clauseLaw_not_satisfies hkn]
end RandomKSAT
end
end OAI
|