File size: 3,579 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 | import OAI.Probability.SATComputability.ActiveMaskCounts
import OAI.Probability.SATComputability.PoissonGrid
import OAI.Probability.SATComputability.FiniteProductPushforward
namespace OAI
namespace FixedClauseThreshold.Computability
open DilutedSpinGlass _root_.MeasureTheory _root_.OAI.MeasureTheory ProbabilityTheory
open scoped BigOperators Classical NNReal
theorem countsMask_restored {A : Type*} [Fintype A] {n : ℕ}
(B F T : A → Finset (DeletionCandidate n)) (c : A → ℕ) :
countsMask (fun a => restoredMask (B a) (F a) (T a)) c =
restoredMask (countsMask B c) (countsMask F c) (countsMask T c) := by
ext x
simp only [countsMask, restoredMask, Finset.mem_filter, Finset.mem_univ, true_and]
rcases x 0 with _ | (_ | _)
all_goals simp only [and_true, or_and_left, forall_and]
def splitActiveGrid (n M : ℕ) : ActiveClause n × Fin M ≃
(Triple (SignedLiteral n) × Fin M) ⊕
((IncidentClass n × Fin M) ⊕ (IncidentClass n × Fin M)) where
toFun p := match p.1 with
| .inl a => .inl (a,p.2)
| .inr (false,a) => .inr (.inl (a,p.2))
| .inr (true,a) => .inr (.inr (a,p.2))
invFun p := match p with
| .inl (a,j) => (.inl a,j)
| .inr (.inl (a,j)) => (.inr (false,a),j)
| .inr (.inr (a,j)) => (.inr (true,a),j)
left_inv := by rintro ⟨a,j⟩; rcases a with a | ⟨(_ | _),a⟩ <;> rfl
right_inv := by rintro (⟨a,j⟩ | (⟨a,j⟩ | ⟨a,j⟩)) <;> rfl
noncomputable def maskGrid {A : Type*} [Fintype A] {n M : ℕ}
(mask : A → Finset (DeletionCandidate n)) (c : A × Fin M → ℕ) :
Fin M → Finset (DeletionCandidate n) := fun j => countsMask mask (fun a => c (a,j))
local instance clauseProcessCandidateMeasurable (n : ℕ) :
MeasurableSpace (DeletionCandidate n) := ⊤
local instance clauseProcessCandidateSingleton (n : ℕ) :
MeasurableSingletonClass (DeletionCandidate n) := ⟨fun _ => trivial⟩
noncomputable def gridMaskLaw {A : Type*} [Fintype A] {n : ℕ}
(M : ℕ) (r : ℝ≥0) (mask : A → Finset (DeletionCandidate n)) :
FiniteLaw (Fin M → Finset (DeletionCandidate n)) :=
finitePushforward (poissonCountLaw (A × Fin M) r) (maskGrid mask)
(measurable_of_countable _)
theorem gridMaskLaw_expect {A : Type*} [Fintype A] {n M : ℕ}
(r : ℝ≥0) (mask : A → Finset (DeletionCandidate n))
(f : (Fin M → Finset (DeletionCandidate n)) → ℝ) :
(gridMaskLaw M r mask).expect f =
∫ c, f (maskGrid mask c) ∂poissonCountLaw (A × Fin M) r :=
finitePushforward_expect _ _ _ _
theorem gridMaskLaw_frontload {A : Type*} [Fintype A] {n M : ℕ}
(r : ℝ≥0) (mask : A → Finset (DeletionCandidate n))
(f : Finset (DeletionCandidate n) → ℝ) :
(gridMaskLaw M r mask).expect (fun xs => f (frontloadMask xs)) =
∫ c, f (countsMask mask c) ∂poissonCountLaw A (M*r) := by
rw [gridMaskLaw_expect]
have hfront (c : A × Fin M → ℕ) : frontloadMask (maskGrid mask c) =
countsMask mask (fun a => ∑ j, c (a,j)) :=
frontload_countsMask mask (fun j a => c (a,j))
simp only [hfront]
rw [← poissonCountLaw_uncurry_integral]
have hh := poissonCountLaw_row_sums (A := A) (B := Fin M) r
have h := integral_map (φ := fun c : A → Fin M → ℕ => fun a => ∑ j, c a j)
(μ := Measure.pi (fun _ : A => poissonCountLaw (Fin M) r))
(f := fun c => f (countsMask mask c))
(measurable_of_countable _).aemeasurable
(measurable_of_countable _).aestronglyMeasurable
rw [hh] at h
simpa only [Fintype.card_fin] using h.symm
end FixedClauseThreshold.Computability
end OAI
|