| import Mathlib |
| import OAI.Probability.SKBarriers.SpinGlass.FiniteLaw |
| import OAI.Probability.SKBarriers.SpinGlass.FiniteSampling |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators |
| open Classical |
| namespace SK.Analytic |
| namespace FiniteLaw |
| variable {X I A : Type*} [Fintype X] [Fintype I] [Fintype A] [DecidableEq I] [DecidableEq A] |
|
|
| theorem iid_random_cell_miss (P : FiniteLaw X) (K : ℕ) (u : A → I) (v : Fin K → I) |
| (he : Function.Injective (Sum.elim u v)) |
| (C : (A → X) → X → Prop) (R : X → X → Prop) {a δ : ℝ} (ha : 0≤a) |
| (hcov : ∀ w, P.prob (fun x => C w x ∧ P.prob (fun y => C w y ∧ R x y)<a) ≤ δ) : |
| (P.iid I).expect (fun z => P.prob (fun x => C (z ∘ u) x ∧ |
| ∀ k, ¬(C (z ∘ u) (z (v k)) ∧ R x (z (v k))))) ≤ δ+Real.exp (-a*K) := by |
| classical |
| let F (w : A ⊕ Fin K → X) : ℝ := P.prob (fun x => C (w ∘ Sum.inl) x ∧ |
| ∀ k, ¬(C (w ∘ Sum.inl) (w (Sum.inr k)) ∧ R x (w (Sum.inr k)))) |
| have H := P.iid_expect_injective (Sum.elim u v) he F |
| change (P.iid I).expect (fun z => F (z ∘ Sum.elim u v)) ≤ _ |
| rw [H,P.iid_expect_sum F] |
| calc |
| _ ≤ (P.iid A).expect (fun _ => δ+Real.exp (-a*K)) := by |
| apply expect_mono |
| intro w |
| exact P.iid_cell_miss_bound (C w) R K ha (hcov w) |
| _ = _ := expect_const _ _ |
| end FiniteLaw |
|
|
| abbrev BankIndex {p : ℕ} (K : Fin p → ℕ) := (j : Fin p) × Fin (K j) |
| abbrev BankPrior {p : ℕ} (pred : Fin p → Finset (Fin p)) (j : Fin p) := {i : Fin p |
| abbrev BankTuple {p : ℕ} (K : Fin p → ℕ) (pred : Fin p → Finset (Fin p)) (j : Fin p) := |
| (i : BankPrior pred j) → Fin (K i.val) |
|
|
| def bankJointIndex {p : ℕ} (K : Fin p → ℕ) (pred : Fin p → Finset (Fin p)) (j : Fin p) |
| (T : BankTuple K pred j) : BankPrior pred j ⊕ Fin (K j) → BankIndex K := |
| Sum.elim (fun i => ⟨i.val,T i⟩) (fun a => ⟨j,a⟩) |
|
|
| theorem bankJointIndex_injective {p : ℕ} (K : Fin p → ℕ) (pred : Fin p → Finset (Fin p)) |
| (j : Fin p) (hj : j∉pred j) (T : BankTuple K pred j) : |
| Function.Injective (bankJointIndex K pred j T) := by |
| intro a b H |
| cases a with |
| | inl i => |
| cases b with |
| | inl k => |
| have he : i.val=k.val := congrArg Sigma.fst H |
| exact congrArg Sum.inl (Subtype.ext he) |
| | inr k => |
| have he : i.val=j := congrArg Sigma.fst H |
| apply False.elim; apply hj; simpa only [he] using i.property |
| | inr i => |
| cases b with |
| | inl k => |
| have he : j=k.val := congrArg Sigma.fst H |
| apply False.elim; apply hj; simpa only [← he] using k.property |
| | inr k => |
| have he : HEq i k := (Sigma.mk.inj_iff.mp H).2 |
| exact congrArg Sum.inr (eq_of_heq he) |
|
|
| def bankCell {n p : ℕ} (K : Fin p → ℕ) (pred : Fin p → Finset (Fin p)) (t : ℝ) |
| (z : BankIndex K → Config n) (j : Fin p) (T : BankTuple K pred j) (x : Config n) : Prop := |
| ∀ i : BankPrior pred j, |overlap (z ⟨i.val,T i⟩) x|≤3*t |
|
|
| def bankCoverageBad {n p : ℕ} (K : Fin p → ℕ) (pred : Fin p → Finset (Fin p)) (t q : ℝ) |
| (z : BankIndex K → Config n) (x : Config n) : Prop := |
| ∃ j : Fin p, ∃ T : BankTuple K pred j, bankCell K pred t z j T x ∧ |
| ∀ a : Fin (K j), ¬(bankCell K pred t z j T (z ⟨j,a⟩) ∧ q≤|overlap x (z ⟨j,a⟩)|) |
|
|
| theorem expected_bank_coverage_bad {n p : ℕ} (P : FiniteLaw (Config n)) (K : Fin p → ℕ) |
| (pred : Fin p → Finset (Fin p)) (hpred : ∀ j, j∉pred j) (t q : ℝ) (a δ : Fin p → ℝ) |
| (ha : ∀ j,0≤a j) |
| (hcov : ∀ j, ∀ w : BankPrior pred j → Config n, |
| P.prob (fun x => (∀i,|overlap (w i) x|≤3*t) ∧ |
| P.prob (fun y => (∀i,|overlap (w i) y|≤3*t) ∧ q≤|overlap x y|)<a j)≤δ j) : |
| (P.iid (BankIndex K)).expect (fun z => P.prob (bankCoverageBad K pred t q z)) ≤ |
| ∑ j, Fintype.card (BankTuple K pred j)*(δ j+Real.exp (-(a j)*(K j))) := by |
| classical |
| calc |
| _ ≤ (P.iid (BankIndex K)).expect (fun z => ∑ j : Fin p, ∑ T : BankTuple K pred j, |
| P.prob (fun x => bankCell K pred t z j T x ∧ |
| ∀ a : Fin (K j), ¬(bankCell K pred t z j T (z ⟨j,a⟩) ∧ q≤|overlap x (z ⟨j,a⟩)|))) := by |
| apply FiniteLaw.expect_mono |
| intro z |
| refine (P.prob_exists _).trans ?_ |
| apply Finset.sum_le_sum |
| intro j _ |
| exact P.prob_exists _ |
| _ = ∑ j : Fin p, ∑ T : BankTuple K pred j, (P.iid (BankIndex K)).expect (fun z => |
| P.prob (fun x => bankCell K pred t z j T x ∧ |
| ∀ a : Fin (K j), ¬(bankCell K pred t z j T (z ⟨j,a⟩) ∧ q≤|overlap x (z ⟨j,a⟩)|))) := by |
| rw [FiniteLaw.expect_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| exact FiniteLaw.expect_sum _ _ |
| _ ≤ ∑ j : Fin p, ∑ _T : BankTuple K pred j, (δ j+Real.exp (-(a j)*(K j))) := by |
| apply Finset.sum_le_sum |
| intro j _ |
| apply Finset.sum_le_sum |
| intro T _ |
| exact P.iid_random_cell_miss (I := BankIndex K) (A := BankPrior pred j) (K j) (fun i : BankPrior pred j => (⟨i.val,T i⟩ : BankIndex K)) (fun b => (⟨j,b⟩ : BankIndex K)) |
| (bankJointIndex_injective K pred j (hpred j) T) (fun w x => ∀i,|overlap (w i) x|≤3*t) |
| (fun x y => q≤|overlap x y|) (ha j) (hcov j) |
| _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] |
|
|
| end SK.Analytic |
|
|
| end |
| end |
|
|
| end OAI |
|
|
