File size: 5,321 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
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 // i∈pred j}
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