File size: 8,740 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 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | import OAI.Probability.SATComputability.IncidentRates
import OAI.Probability.SATComputability.GridBlockLaw
namespace OAI
namespace FixedClauseThreshold.Computability
open DilutedSpinGlass _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
open scoped BigOperators Classical NNReal
noncomputable def activeMask {n : ℕ} (a : ActiveClause n) : Finset (DeletionCandidate (n+1)) :=
clauseMask (classClause (activeClass a))
noncomputable def baseMask {n : ℕ} (a : Triple (SignedLiteral n)) : Finset (DeletionCandidate n) :=
clauseMask ((tripleVectorEquiv _).symm a)
theorem active_base_counts {n : ℕ} (c : ActiveClause n → ℕ) :
countsMask (fun a => classBaseMask (activeClass a)) c =
countsMask baseMask (fun a => c (.inl a)) := by
ext x
simp [countsMask, classBaseMask, activeClass, baseMask, Sum.forall, Prod.forall]
theorem active_mask_counts {n : ℕ} (c : ActiveClause n → ℕ) :
countsMask activeMask c = restoredMask
(countsMask baseMask (fun a => c (.inl a)))
(countsMask (fun a => classIncidentMask false (activeClass a)) c)
(countsMask (fun a => classIncidentMask true (activeClass a)) c) := by
rw [← active_base_counts, ← countsMask_restored]
congr 1
funext a
exact classClause_restored (activeClass a)
theorem active_free_lifetime {n M r : ℕ} (c : ActiveClause n × Fin M → ℕ) :
maskLifetime M (freeDeletionBudgetMask (n+1) r 0) (maskGrid activeMask c) =
maskLifetime M (deletionBudgetMask n r) (maskGrid baseMask (fun p => c (.inl p.1,p.2))) := by
have he : maskGrid activeMask c = fun j => restoredMask
(countsMask baseMask (fun a => c (.inl a,j)))
(countsMask (fun a => classIncidentMask false (activeClass a)) (fun a => c (a,j)))
(countsMask (fun a => classIncidentMask true (activeClass a)) (fun a => c (a,j))) := by
funext j
exact active_mask_counts _
rw [he, free_restored_lifetime]
rfl
theorem active_stronger_counts {n : ℕ} (c : ActiveClause n → ℕ) :
countsMask strongerClassMask c = restoredMask
(countsMask baseMask (fun a => c (.inl a)))
(countsMask incidentMask (fun a => c (.inr (true,a))))
(countsMask incidentMask (fun a => c (.inr (false,a)))) :=
countsMask_stronger c
theorem active_gap_domination {n M r : ℕ} (c : ActiveClause n × Fin M → ℕ) :
(maskLifetime M (freeDeletionBudgetMask (n+1) r 0) (maskGrid activeMask c) -
maskLifetime M (deletionBudgetMask (n+1) r) (maskGrid activeMask c))^(6/5 : ℝ) ≤
(maskLifetime M (deletionBudgetMask n r) (maskGrid baseMask (fun p => c (.inl p.1,p.2))) -
maskLifetime M (deletionBudgetMask (n+1) r) (fun j => restoredMask
(countsMask baseMask (fun a => c (.inl a,j)))
(countsMask incidentMask (fun a => c (.inr (true,a),j)))
(countsMask incidentMask (fun a => c (.inr (false,a),j)))))^(6/5 : ℝ) := by
have hnon : 0 ≤ maskLifetime M (freeDeletionBudgetMask (n+1) r 0) (maskGrid activeMask c) -
maskLifetime M (deletionBudgetMask (n+1) r) (maskGrid activeMask c) :=
sub_nonneg.mpr (maskLifetime_mono (deletionBudgetMask_subset_free (n+1) r 0) _)
rw [active_free_lifetime] at hnon ⊢
apply Real.rpow_le_rpow hnon _ (by norm_num : (0 : ℝ) ≤ 6/5)
apply sub_le_sub_left
apply maskLifetime_map_le id _ _ _ _ (fun _ h => h)
intro j x hx
have he := active_stronger_counts (fun a => c (a,j))
rw [← he] at hx
exact countsMask_mono (fun a => strongerClassMask_subset a) _ hx
theorem poissonCountLaw_three {A B C : Type*} [Fintype A] [Fintype B] [Fintype C]
(r : ℝ≥0) (f : (A → ℕ) → (B → ℕ) → (C → ℕ) → ℝ)
(D : ℝ) (hD : ∀ a b c, |f a b c| ≤ D) :
(∫ s : A ⊕ (B ⊕ C) → ℕ,
f (fun a => s (.inl a)) (fun b => s (.inr (.inl b))) (fun c => s (.inr (.inr c)))
∂poissonCountLaw (A ⊕ (B ⊕ C)) r) =
∫ a, ∫ b, ∫ c, f a b c ∂poissonCountLaw C r
∂poissonCountLaw B r ∂poissonCountLaw A r := by
rw [poissonCountLaw_sum r _ D (fun s => hD _ _ _)]
apply integral_congr_ae
filter_upwards [] with a
exact poissonCountLaw_sum r _ D (fun _ => hD _ _ _)
theorem active_streams_expect {n M : ℕ} (r : ℝ≥0)
(ψ : (Fin M → Finset (DeletionCandidate n)) →
(Fin M → Finset (DeletionCandidate n)) → (Fin M → Finset (DeletionCandidate n)) → ℝ) :
(∫ c : ActiveClause n × Fin M → ℕ,
ψ (maskGrid baseMask (fun p => c (.inl p.1,p.2)))
(maskGrid incidentMask (fun p => c (.inr (true,p.1),p.2)))
(maskGrid incidentMask (fun p => c (.inr (false,p.1),p.2)))
∂poissonCountLaw (ActiveClause n × Fin M) r) =
(gridMaskLaw M r baseMask).expect (fun b =>
(gridMaskLaw M r incidentMask).expect (fun f =>
(gridMaskLaw M r incidentMask).expect (fun t => ψ b f t))) := by
let X := Fin M → Finset (DeletionCandidate n)
let D := ∑ p : X × X × X, |ψ p.1 p.2.1 p.2.2|
have hD (b f t : X) : |ψ b f t| ≤ D :=
Finset.single_le_sum (fun p _ => abs_nonneg (ψ p.1 p.2.1 p.2.2))
(Finset.mem_univ (b,f,t))
have he := poissonCountLaw_equiv (splitActiveGrid n M) r
(fun s => ψ (maskGrid baseMask (fun p => s (.inl p)))
(maskGrid incidentMask (fun p => s (.inr (.inr p))))
(maskGrid incidentMask (fun p => s (.inr (.inl p)))))
change (∫ c : ActiveClause n × Fin M → ℕ,
ψ (maskGrid baseMask (fun p => c (.inl p.1,p.2)))
(maskGrid incidentMask (fun p => c (.inr (true,p.1),p.2)))
(maskGrid incidentMask (fun p => c (.inr (false,p.1),p.2)))
∂poissonCountLaw (ActiveClause n × Fin M) r) = _ at he
rw [he, poissonCountLaw_three r
(fun (b : Triple (SignedLiteral n) × Fin M → ℕ)
(f t : IncidentClass n × Fin M → ℕ) =>
ψ (maskGrid baseMask b) (maskGrid incidentMask t) (maskGrid incidentMask f))
D (fun a b c => hD _ _ _)]
have hi (b : Triple (SignedLiteral n) × Fin M → ℕ)
(f : IncidentClass n × Fin M → ℕ) :
(∫ t, ψ (maskGrid baseMask b) (maskGrid incidentMask t) (maskGrid incidentMask f)
∂poissonCountLaw (IncidentClass n × Fin M) r) =
(gridMaskLaw M r incidentMask).expect
(fun t => ψ (maskGrid baseMask b) t (maskGrid incidentMask f)) :=
(gridMaskLaw_expect r incidentMask
(fun t => ψ (maskGrid baseMask b) t (maskGrid incidentMask f))).symm
simp_rw [hi]
have hm (b : Triple (SignedLiteral n) × Fin M → ℕ) :
(∫ f, (gridMaskLaw M r incidentMask).expect
(fun t => ψ (maskGrid baseMask b) t (maskGrid incidentMask f))
∂poissonCountLaw (IncidentClass n × Fin M) r) =
(gridMaskLaw M r incidentMask).expect (fun f =>
(gridMaskLaw M r incidentMask).expect (fun t => ψ (maskGrid baseMask b) t f)) :=
(gridMaskLaw_expect r incidentMask (fun f =>
(gridMaskLaw M r incidentMask).expect (fun t => ψ (maskGrid baseMask b) t f))).symm
simp_rw [hm]
rw [← gridMaskLaw_expect r baseMask (fun b =>
(gridMaskLaw M r incidentMask).expect (fun f =>
(gridMaskLaw M r incidentMask).expect (fun t => ψ b t f)))]
apply FiniteLaw.expect_congr
intro b
exact finite_expect_comm _ _ _
theorem active_original_expect {n M : ℕ} (r : ℝ≥0)
(ψ : (Fin M → Finset (DeletionCandidate (n+1))) → ℝ) :
(∫ c : TripleClasses (SignedLiteral n) × Fin M → ℕ,
ψ (maskGrid (fun a => clauseMask (classClause a)) c)
∂poissonCountLaw (TripleClasses (SignedLiteral n) × Fin M) r) =
∫ c : ActiveClause n × Fin M → ℕ, ψ (maskGrid activeMask c)
∂poissonCountLaw (ActiveClause n × Fin M) r := by
let e : ActiveClause n × Fin M → TripleClasses (SignedLiteral n) × Fin M :=
fun p => (activeClass p.1,p.2)
have he : Function.Injective e := by
intro p q h
change (activeClass p.1,p.2) = (activeClass q.1,q.2) at h
exact Prod.ext (activeClass_injective n (Prod.mk.inj h).1) (Prod.mk.inj h).2
rw [← poissonCountLaw_embedding_integral e he r]
apply integral_congr_ae
filter_upwards [] with c
congr 1
funext j
exact (countsMask_active (fun a => c (a,j))).symm
theorem base_grid_law {n : ℕ} [NeZero n] (M : ℕ) (r : ℝ≥0) :
gridMaskLaw M r (baseMask (n := n)) = FiniteLaw.pi (fun _ : Fin M =>
candidateBlock (r*Fintype.card (Triple (SignedLiteral n))) 3 Finset.univ) := by
rw [← gridMaskLaw_equiv (tripleVectorEquiv (SignedLiteral n)) r baseMask]
have hm : baseMask ∘ tripleVectorEquiv (SignedLiteral n) = clauseMask := by
funext a
simp only [baseMask, Function.comp_apply, Equiv.symm_apply_apply]
rw [hm, gridMaskLaw_clauses]
rw [Fintype.card_congr (tripleVectorEquiv (SignedLiteral n))]
end FixedClauseThreshold.Computability
end OAI
|