File size: 5,811 Bytes
a2ee19a | 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 | import OAI.Probability.SATComputability.ClauseProcess
import OAI.Probability.SATComputability.PoissonMaskAggregation
namespace OAI
namespace FixedClauseThreshold.Computability
open DilutedSpinGlass _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
open scoped BigOperators NNReal Classical
abbrev SingleIncident (n : ℕ) := Fin 3 × SignedLiteral n × SignedLiteral n
abbrev BadIncident (n : ℕ) := (Fin 3 × SignedLiteral n) ⊕ Unit
def singleIncidentEquiv (n : ℕ) : SingleIncident n ≃ (Fin 2 → SignedLiteral n) × Fin 3 where
toFun p := (![p.2.1,p.2.2],p.1)
invFun p := (p.2,p.1 0,p.1 1)
left_inv := by rintro ⟨i,a,b⟩; rfl
right_inv := by
rintro ⟨f,i⟩
apply Prod.ext
· funext j; fin_cases j <;> rfl
· rfl
noncomputable def singleIncidentMask {n : ℕ} (p : SingleIncident n) :
Finset (DeletionCandidate n) := clauseMask ![p.2.1,p.2.2]
theorem singleIncident_law {n : ℕ} [NeZero n] (r : ℝ≥0)
(f : Finset (DeletionCandidate n) → ℝ) :
(∫ c, f (countsMask singleIncidentMask c) ∂poissonCountLaw (SingleIncident n) r) =
(candidateBlock (3*r*Fintype.card (Fin 2 → SignedLiteral n)) 2 Finset.univ).expect f := by
have he : singleIncidentMask (n := n) =
(fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1) ∘ singleIncidentEquiv n := rfl
rw [he]
simp_rw [countsMask_equiv]
rw [show (∫ c, f (countsMask (fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1)
(c ∘ (singleIncidentEquiv n).symm)) ∂poissonCountLaw (SingleIncident n) r) =
∫ c, f (countsMask (fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1) c)
∂poissonCountLaw ((Fin 2 → SignedLiteral n) × Fin 3) r from by
simpa only [Function.comp_def] using poissonCountLaw_equiv (singleIncidentEquiv n) r
(fun c => f (countsMask (fun p : (Fin 2 → SignedLiteral n) × Fin 3 => clauseMask p.1) c)),
poissonCountLaw_redundant_mask]
rw [candidateBlock_counts]
congr 2
simp only [Fintype.card_fin, mul_div_cancel_right₀ _ (show
(Fintype.card (Fin 2 → SignedLiteral n) : ℝ≥0) ≠ 0 by
exact_mod_cast Fintype.card_ne_zero)]
norm_num
theorem incident_killing_pointwise {n : ℕ} (U : Finset (DeletionCandidate n))
(c : IncidentClass n → ℕ) :
(if U ∩ countsMask incidentMask c = ∅ then (1 : ℝ) else 0) ≤
(if U ∩ countsMask singleIncidentMask (fun a => c (.inl a)) = ∅ then 1 else 0) +
(∑ b : BadIncident n, c (.inr b) : ℕ) := by
by_cases hz : ∑ b : BadIncident n, c (.inr b) = 0
· have hb (b : BadIncident n) : c (.inr b) = 0 :=
(Finset.sum_eq_zero_iff_of_nonneg (fun j _ => Nat.zero_le (c (.inr j)))).mp hz b
(Finset.mem_univ b)
have hm : countsMask incidentMask c =
countsMask singleIncidentMask (fun a => c (.inl a)) := by
ext x
simp [countsMask, incidentMask, singleIncidentMask, Sum.forall, hb]
rw [hm,hz,Nat.cast_zero,add_zero]
· have hpos : (1 : ℝ) ≤ (∑ b : BadIncident n, c (.inr b) : ℕ) := by
exact_mod_cast Nat.one_le_iff_ne_zero.mpr hz
split_ifs <;> linarith
theorem incident_killing_bound {n : ℕ} [NeZero n] (r : ℝ≥0)
(U : Finset (DeletionCandidate n)) :
(∫ c, if U ∩ countsMask incidentMask c = ∅ then (1 : ℝ) else 0
∂poissonCountLaw (IncidentClass n) r) ≤
poissonKillProbability U 2 (3*r*Fintype.card (Fin 2 → SignedLiteral n)) +
Fintype.card (BadIncident n)*(r : ℝ) := by
let μ := poissonCountLaw (IncidentClass n) r
let g := fun c : IncidentClass n → ℕ =>
if U ∩ countsMask singleIncidentMask (fun a => c (.inl a)) = ∅ then (1 : ℝ) else 0
let b := fun c : IncidentClass n → ℕ => ((∑ a : BadIncident n, c (.inr a) : ℕ) : ℝ)
have hg : Integrable g μ := by
apply Integrable.of_bound (measurable_of_countable _).aestronglyMeasurable 1
filter_upwards [] with c
dsimp only [g]
split_ifs <;> norm_num
have hres : HasLaw (fun c : IncidentClass n → ℕ => fun a : BadIncident n => c (.inr a))
(poissonCountLaw (BadIncident n) r) μ :=
⟨(measurable_of_countable _).aemeasurable,
poissonCountLaw_embedding Sum.inr Sum.inr_injective r⟩
have hsum := (poissonCountLaw_hasLaw_sum (fun _ : BadIncident n => r)).comp hres
have hb : Integrable b μ :=
hsum.integrable_comp (poisson_integrable_count _)
have hi : Integrable (fun c : IncidentClass n → ℕ =>
if U ∩ countsMask incidentMask c = ∅ then (1 : ℝ) else 0) μ := by
apply Integrable.of_bound (measurable_of_countable _).aestronglyMeasurable 1
filter_upwards [] with c
split_ifs <;> norm_num
have h := integral_mono hi (hg.add hb) (incident_killing_pointwise U)
simp only [Pi.add_apply] at h
rw [integral_add hg hb] at h
have hbg : (∫ c, b c ∂μ) = Fintype.card (BadIncident n)*(r : ℝ) := by
have he := hsum.integral_comp (f := fun k : ℕ => (k : ℝ))
(measurable_of_countable _).aestronglyMeasurable
rw [poisson_mean] at he
simpa only [Function.comp_def, Finset.sum_const, Finset.card_univ, nsmul_eq_mul,
NNReal.coe_mul, NNReal.coe_natCast] using he
have hgg : (∫ c, g c ∂μ) =
poissonKillProbability U 2 (3*r*Fintype.card (Fin 2 → SignedLiteral n)) := by
have he := poissonCountLaw_embedding_integral (A := IncidentClass n) (B := SingleIncident n)
Sum.inl Sum.inl_injective r
(fun c => if U ∩ countsMask singleIncidentMask c = ∅ then (1 : ℝ) else 0)
change (∫ c, g c ∂μ) = _ at he
rw [he, singleIncident_law r (fun I => if U ∩ I = ∅ then (1 : ℝ) else 0)]
rw [candidateBlock_mask _ _ U (fun V => if V = ∅ then (1 : ℝ) else 0), candidateBlock_kill]
rwa [hbg,hgg] at h
end FixedClauseThreshold.Computability
end OAI
|