File size: 6,506 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 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 | import OAI.Probability.SATComputability.PoissonSemigroup
import OAI.Probability.SATComputability.MarkovOccupation
namespace OAI
namespace FixedClauseThreshold.Computability
open DilutedSpinGlass MeasureTheory ProbabilityTheory Filter
open scoped BigOperators NNReal
theorem candidateResidual_subset {n k d : ℕ} (U : Finset (DeletionCandidate n))
(cs : Fin d → Fin k → SignedLiteral n) : candidateResidual U cs ⊆ U := by
classical
exact Finset.filter_subset _ _
theorem candidateResidual_mono {n k d : ℕ} {U V : Finset (DeletionCandidate n)}
(h : U ⊆ V) (cs : Fin d → Fin k → SignedLiteral n) :
candidateResidual U cs ⊆ candidateResidual V cs := by
classical
exact Finset.filter_subset_filter _ h
theorem candidateAlive_mono {n : ℕ} :
Monotone (candidateAlive (n := n)) := by
intro U V h
unfold candidateAlive
split_ifs with hU hV
· rfl
· exact (hV (hU.mono h)).elim
· norm_num
· rfl
theorem candidateBlock_expect_mono_state {n : ℕ} [NeZero n]
(r : ℝ≥0) (k : ℕ) {f : Finset (DeletionCandidate n) → ℝ}
(hf : Monotone f) : Monotone (fun U => (candidateBlock r k U).expect f) := by
intro U V hUV
simp only [candidateBlock, poissonMixture_expect]
apply integral_mono (poissonMixture_integrable_expect r
(fun d => candidateFixedBlock k d U) f)
(poissonMixture_integrable_expect r (fun d => candidateFixedBlock k d V) f)
intro d
simp only [candidateFixedBlock_expect, candidateStep_iterate]
exact FiniteLaw.expect_mono _ (fun cs => hf (candidateResidual_mono hUV cs))
theorem candidateBlock_expect_le_of_subset {n : ℕ} [NeZero n]
(r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n))
(f g : Finset (DeletionCandidate n) → ℝ)
(h : ∀ V ⊆ U, f V ≤ g V) :
(candidateBlock r k U).expect f ≤ (candidateBlock r k U).expect g := by
simp only [candidateBlock, poissonMixture_expect]
apply integral_mono (poissonMixture_integrable_expect r _ f)
(poissonMixture_integrable_expect r _ g)
intro d
simp only [candidateFixedBlock_expect, candidateStep_iterate]
exact FiniteLaw.expect_mono _ (fun cs => h _ (candidateResidual_subset U cs))
theorem candidateBlock_expect_alive {n : ℕ} [NeZero n]
(r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n)) :
(candidateBlock r k U).expect candidateAlive = 1 - poissonKillProbability U k r := by
have he : candidateAlive (n := n) = fun V => 1 - (if V = ∅ then 1 else 0) := by
classical
funext V
by_cases h : V = ∅ <;> simp [candidateAlive, h, Finset.nonempty_iff_ne_empty]
rw [he, FiniteLaw.expect_sub, FiniteLaw.expect_const, candidateBlock_kill]
theorem candidateBlock_empty {n : ℕ} [NeZero n]
(r : ℝ≥0) (k : ℕ) (f : Finset (DeletionCandidate n) → ℝ) :
(candidateBlock r k ∅).expect f = f ∅ := by
simp only [candidateBlock_expect, candidateStep_iterate, candidateResidual,
Finset.filter_empty, FiniteLaw.expect_const, integral_const, probReal_univ, one_smul]
theorem candidateBlock_survival_le {n : ℕ} [NeZero n]
(r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n)) :
(candidateBlock r k U).expect candidateAlive ≤ candidateAlive U := by
apply (candidateBlock_expect_le_of_subset r k U candidateAlive
(fun _ => candidateAlive U) (fun _ h => candidateAlive_mono h)).trans_eq
exact FiniteLaw.expect_const _ _
theorem candidateBlock_survival_submultiplicative {n : ℕ} [NeZero n]
(r s : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n)) :
(candidateBlock (r+s) k U).expect candidateAlive ≤
(candidateBlock r k U).expect candidateAlive *
(candidateBlock s k U).expect candidateAlive := by
rw [candidateBlock_comp]
calc
_ ≤ (candidateBlock r k U).expect (fun V =>
candidateAlive V * (candidateBlock s k U).expect candidateAlive) := by
apply candidateBlock_expect_le_of_subset
intro V hV
by_cases h : V.Nonempty
· simpa only [candidateAlive, ite_eq_left h, one_mul] using
candidateBlock_expect_mono_state s k candidateAlive_mono hV
· have he : V = ∅ := Finset.not_nonempty_iff_eq_empty.mp h
subst V
simp [candidateBlock_empty, candidateAlive]
_ = _ := FiniteLaw.expect_mul_right _ _ _
theorem candidateBlock_survival_geometric {n : ℕ} [NeZero n]
(r : ℝ≥0) (k : ℕ) (U : Finset (DeletionCandidate n))
{δ : ℝ} (hδ : δ ≤ poissonKillProbability U k r) (m : ℕ) :
(candidateBlock (r*m) k U).expect candidateAlive ≤ (1-δ)^m := by
have hs := FiniteLaw.expect_nonneg (candidateBlock r k U) candidateAlive_nonneg
have hb : (candidateBlock r k U).expect candidateAlive ≤ 1-δ := by
rw [candidateBlock_expect_alive]
linarith
have hd : 0 ≤ 1-δ := hs.trans hb
induction m with
| zero => simp [candidateBlock_expect, integral_poissonMeasure, zero_pow_eq, ite_div, ite_mul,
candidateAlive_le_one]
| succ m ih =>
have he : r * ((m+1 : ℕ) : ℝ≥0) = r*m+r := by push_cast; ring
rw [he, pow_succ]
exact (candidateBlock_survival_submultiplicative (r*m) r k U).trans
(mul_le_mul ih hb hs (pow_nonneg hd m))
theorem candidateBlock_occupation {n : ℕ} [NeZero n]
(r : ℝ≥0) (k L M : ℕ) (bin : Finset (DeletionCandidate n) → Prop)
[DecidablePred bin] {δ : ℝ} (hδ : 0 < δ)
(hbin : ∀ U, bin U → U.Nonempty ∧ δ ≤ poissonKillProbability U k (r*L))
(U : Finset (DeletionCandidate n)) :
(∑ t ∈ Finset.range M,
(candidateBlock (r*t) k U).expect (fun V => if bin V then 1 else 0)) ≤
(L : ℝ)/δ := by
have hi (m : ℕ) (f : Finset (DeletionCandidate n) → ℝ) :
(finiteKernelStep (candidateBlock r k))^[m] f U =
(candidateBlock (r*m) k U).expect f := poissonCandidateStep_iterate r k m U f
have h := finiteKernel_occupation (candidateBlock r k) candidateAlive
(fun V => if bin V then 1 else 0) candidateAlive_nonneg candidateAlive_le_one hδ L
(fun V => ?_) M U
· simpa only [hi] using h
· change δ * (if bin V then 1 else 0) ≤ candidateAlive V -
(poissonCandidateStep r k)^[L] candidateAlive V
rw [poissonCandidateStep_iterate]
by_cases hb : bin V
· obtain ⟨hne, hk⟩ := hbin V hb
rw [ite_eq_left hb, mul_one, candidateAlive, ite_eq_left hne,
candidateBlock_expect_alive]
linarith
· rw [ite_eq_right hb, mul_zero]
exact sub_nonneg.mpr (candidateBlock_survival_le _ _ _)
end FixedClauseThreshold.Computability
end OAI
|