File size: 5,553 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.ObstructionMoment
namespace OAI
namespace FixedClauseThreshold.Computability
open DilutedSpinGlass MeasureTheory ProbabilityTheory
open scoped BigOperators Classical NNReal
noncomputable def finiteMap {Ω Ξ : Type*} [Fintype Ω] [Fintype Ξ]
[DecidableEq Ξ] (P : FiniteLaw Ω) (f : Ω → Ξ) : FiniteLaw Ξ where
weight y := P.expect (fun x => if f x = y then 1 else 0)
nonneg y := P.expect_nonneg (fun x => by split_ifs <;> norm_num)
total := by
rw [← FiniteLaw.expect_fintype_sum]
simp
theorem finiteMap_expect {Ω Ξ : Type*} [Fintype Ω] [Fintype Ξ]
[DecidableEq Ξ] (P : FiniteLaw Ω) (f : Ω → Ξ) (g : Ξ → ℝ) :
(finiteMap P f).expect g = P.expect (fun x => g (f x)) := by
simp only [FiniteLaw.expect, finiteMap, Finset.sum_mul, mul_ite, mul_one, mul_zero]
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro x _
simp
noncomputable def unionMaskLaw {n : ℕ}
(P Q : FiniteLaw (Finset (DeletionCandidate n))) : FiniteLaw (Finset (DeletionCandidate n)) :=
finiteMap (P.bind (fun _ => Q)) (fun p => p.1 ∪ p.2)
theorem unionMaskLaw_killing {n : ℕ}
(P Q : FiniteLaw (Finset (DeletionCandidate n))) (U : Finset (DeletionCandidate n)) :
(unionMaskLaw P Q).expect (fun I => if U ∩ I = ∅ then 1 else 0) =
P.expect (fun I => if U ∩ I = ∅ then 1 else 0) *
Q.expect (fun I => if U ∩ I = ∅ then 1 else 0) := by
rw [unionMaskLaw, finiteMap_expect, FiniteLaw.expect_bind]
have he (I J : Finset (DeletionCandidate n)) :
(if U ∩ (I ∪ J) = ∅ then (1 : ℝ) else 0) =
(if U ∩ I = ∅ then 1 else 0) * (if U ∩ J = ∅ then 1 else 0) := by
simp only [Finset.inter_union_distrib_left, Finset.union_eq_empty]
split_ifs <;> simp_all
simp only [he, FiniteLaw.expect_mul_left, FiniteLaw.expect_mul_right]
noncomputable def catastropheLaw (n : ℕ) (ρ : ℝ≥0) : FiniteLaw (Finset (DeletionCandidate n)) :=
poissonMixture ρ (fun d => finiteMap (FiniteLaw.uniform : FiniteLaw Unit)
(fun _ => if d = 0 then Finset.univ else ∅))
theorem catastropheLaw_bound (n : ℕ) (ρ : ℝ≥0) :
(catastropheLaw n ρ).expect (fun I => if I = Finset.univ then 0 else 1) ≤ ρ := by
rw [catastropheLaw, poissonMixture_expect]
simp only [finiteMap_expect, FiniteLaw.expect_const]
have hi : Integrable (fun d : ℕ =>
if (if d = 0 then (Finset.univ : Finset (DeletionCandidate n)) else ∅) = Finset.univ
then (0 : ℝ) else 1) (poissonMeasure ρ) := by
apply Integrable.of_bound (measurable_of_countable _).aestronglyMeasurable 1
filter_upwards [] with d
split_ifs <;> norm_num
apply (integral_mono hi (poisson_integrable_count ρ) (fun d => ?_)).trans_eq (poisson_mean ρ)
by_cases hd : d = 0
· simp [hd]
· have hd' : (1 : ℝ) ≤ d := by exact_mod_cast (Nat.pos_of_ne_zero hd)
split_ifs <;> linarith
noncomputable def incidentSignLaw {n : ℕ} [NeZero n] (ρ : ℝ≥0) :
FiniteLaw (Finset (DeletionCandidate n)) :=
finiteMap ((candidateBlock 60 2 Finset.univ).bind (fun _ => catastropheLaw n ρ))
(fun p => p.1 ∩ p.2)
theorem incidentSignLaw_killing {n : ℕ} [NeZero n] (ρ : ℝ≥0)
(U : Finset (DeletionCandidate n)) :
(incidentSignLaw ρ).expect (fun I => if U ∩ I = ∅ then 1 else 0) ≤
poissonKillProbability U 2 60 + ρ := by
rw [incidentSignLaw, finiteMap_expect, FiniteLaw.expect_bind]
have hb (I J : Finset (DeletionCandidate n)) :
(if U ∩ (I ∩ J) = ∅ then (1 : ℝ) else 0) ≤
(if U ∩ I = ∅ then 1 else 0) + (if J = Finset.univ then 0 else 1) := by
by_cases hJ : J = Finset.univ
· simp [hJ]
· split_ifs <;> norm_num
have h := (candidateBlock (n := n) 60 2 Finset.univ).expect_mono (fun I =>
(catastropheLaw n ρ).expect_mono (hb I))
simp only [FiniteLaw.expect_add, FiniteLaw.expect_const] at h
have he : (candidateBlock 60 2 (Finset.univ : Finset (DeletionCandidate n))).expect
(fun I => if U ∩ I = ∅ then 1 else 0) = poissonKillProbability U 2 60 := by
rw [candidateBlock_mask 60 2 U (fun V => if V = ∅ then 1 else 0), candidateBlock_kill]
rw [he] at h
exact h.trans (add_le_add le_rfl (catastropheLaw_bound n ρ))
noncomputable def dominatingIncidentLaw {n : ℕ} [NeZero n] (ρ : ℝ≥0) :
FiniteLaw (Finset (DeletionCandidate n)) := unionMaskLaw (incidentSignLaw ρ) (incidentSignLaw ρ)
theorem dominatingIncidentLaw_killing {n : ℕ} [NeZero n] (ρ : ℝ≥0)
(U : Finset (DeletionCandidate n)) :
(dominatingIncidentLaw ρ).expect (fun I => if U.Nonempty ∧ U ∩ I = ∅ then 1 else 0) ≤
(poissonKillProbability U 2 60 + ρ)^2 := by
by_cases hU : U.Nonempty
· simp only [hU, true_and, dominatingIncidentLaw, unionMaskLaw_killing]
rw [← pow_two]
exact pow_le_pow_left₀ (FiniteLaw.expect_nonneg _ (fun I => by split_ifs <;> norm_num))
(incidentSignLaw_killing ρ U) 2
· simp only [hU, false_and, ite_false, FiniteLaw.expect_const]
exact sq_nonneg _
theorem dominatingIncidentLaw_delay {n : ℕ} [NeZero n]
(r : ℝ≥0) (hr : (1 : ℝ)/8 ≤ r) (M : ℕ) (ρ : ℝ≥0)
(U : Finset (DeletionCandidate n)) :
(dominatingIncidentLaw ρ).expect (fun I => maskDelayMoment r 3 M U I) ≤
(48/5 : ℝ) * (∑' j, dyadicMomentCoefficient j) +
(12/5 : ℝ)*(ρ : ℝ)^2*(M : ℝ)^(6/5 : ℝ) :=
maskDelayMoment_of_obstruction r hr M (dominatingIncidentLaw ρ) ρ
(dominatingIncidentLaw_killing ρ) U
end FixedClauseThreshold.Computability
end OAI
|