Documentation

LeanPool.BlockSpectralSensitivity.LLL.Asymmetric

The asymmetric Lovász local lemma #

Mathlib does not contain the Lovász local lemma, so we prove the version we need from scratch, for the finite counting probability space of BSLambda.LLL.Prob.

Events are given by a family Ev : I → Finset (Cfg β), each Ev i being determined by the coordinate set supp i. Two events are dependent when their supports meet. nbr supp i collects the indices of the events other than i that are dependent with Ev i.

The main results are pr_avoid_pos (the general asymmetric local lemma of Section 10 of bs_lambda.txt) and pr_avoid_pos_two_type (the two-type statement of Section 10.2).

The last section is independent of the local lemma: pr_le_prod_of_pinned and its constant-alphabet form pr_le_pow_of_pinned bound the probability of an event that pins a set of coordinates to targets read off a disjoint set of coordinates. They supply the hypothesis hcond above at the places where the local lemma is applied.

Adapted for Lean Pool from Timeroot/BS_Lam at commit 7bd39a8d41ee7910d3296d0477ad18f8fff9d870; ported to Lean Pool with proof and dependency cleanup.

Dependency neighbourhoods and avoidance events #

def BSLambda.LLL.nbr {A : Type u_1} [DecidableEq A] {I : Type u_3} [Fintype I] [DecidableEq I] (supp : I → Finset A) (i : I) :

The dependency neighbourhood: other events whose supports meet ours.

Equations
Instances For
    @[simp]
    theorem BSLambda.LLL.mem_nbr {A : Type u_1} [DecidableEq A] {I : Type u_3} [Fintype I] [DecidableEq I] {supp : I → Finset A} {i j : I} :
    j ∈ nbr supp i ↔ j ≠ i ∧ ¬Disjoint (supp i) (supp j)

    Membership in the dependency neighbourhood.

    theorem BSLambda.LLL.disjoint_supp_sup_sdiff_nbr {A : Type u_1} [DecidableEq A] {I : Type u_3} [Fintype I] [DecidableEq I] {supp : I → Finset A} {i : I} {S : Finset I} (hi : i ∉ S) :
    Disjoint (supp i) ((S \ nbr supp i).sup supp)

    The events indexed outside the dependency neighbourhood of i are supported away from supp i.

    def BSLambda.LLL.avoid {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] (Ev : I → Finset (Cfg β)) (S : Finset I) :
    Finset (Cfg β)

    The event that none of the bad events indexed by S occurs.

    Equations
    Instances For
      @[simp]
      theorem BSLambda.LLL.mem_avoid {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] {Ev : I → Finset (Cfg β)} {S : Finset I} {ω : Cfg β} :
      ω ∈ avoid Ev S ↔ ∀ i ∈ S, ω ∉ Ev i

      Membership in avoid.

      @[simp]
      theorem BSLambda.LLL.avoid_empty {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] (Ev : I → Finset (Cfg β)) :

      Avoiding no events is the sure event.

      theorem BSLambda.LLL.avoid_univ {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] (Ev : I → Finset (Cfg β)) :
      avoid Ev Finset.univ = {ω : Cfg β | ∀ (i : I), ω ∉ Ev i}

      Avoiding every event is avoiding all of them.

      theorem BSLambda.LLL.avoid_anti {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] {Ev : I → Finset (Cfg β)} {S T : Finset I} (h : S ⊆ T) :
      avoid Ev T ⊆ avoid Ev S

      Avoiding more events is a smaller event.

      theorem BSLambda.LLL.avoid_insert {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] (Ev : I → Finset (Cfg β)) (i : I) (S : Finset I) :
      avoid Ev (insert i S) = (Ev i)ᶜ ∩ avoid Ev S

      Peeling one event off avoid.

      theorem BSLambda.LLL.determined_avoid {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] {Ev : I → Finset (Cfg β)} {supp : I → Finset A} (hdet : ∀ (i : I), Determined (supp i) (Ev i)) (S : Finset I) :
      Determined (S.sup supp) (avoid Ev S)

      avoid Ev S is determined by the union of the supports of the events indexed by S.

      The local lemma #

      theorem BSLambda.LLL.pr_avoid_pos {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] [∀ (a : A), Nonempty (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] (Ev : I → Finset (Cfg β)) (supp : I → Finset A) (x : I → ℝ) (hdet : ∀ (i : I), Determined (supp i) (Ev i)) (hx0 : ∀ (i : I), 0 < x i) (hx1 : ∀ (i : I), x i < 1) (hcond : ∀ (i : I), pr (Ev i) ≤ x i * ∏ j ∈ nbr supp i, (1 - x j)) :
      0 < pr {ω : Cfg β | ∀ (i : I), ω ∉ Ev i}

      The asymmetric Lovász local lemma (Section 10.2 of bs_lambda.txt). If each bad event Ev i is determined by supp i and has probability at most x i * ∏ j ∈ nbr supp i, (1 - x j) for some weights x i ∈ (0, 1), then with positive probability no bad event occurs.

      The two-type form #

      theorem BSLambda.LLL.pr_avoid_pos_two_type {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] [∀ (a : A), Nonempty (β a)] {I : Type u_3} [Fintype I] [DecidableEq I] (Ev : I → Finset (Cfg β)) (supp : I → Finset A) (hdet : ∀ (i : I), Determined (supp i) (Ev i)) (ty : I → Bool) (p x : Bool → ℝ) (D : Bool → Bool → ℕ) (hp : ∀ (i : I), pr (Ev i) ≤ p (ty i)) (hD : ∀ (i : I) (t : Bool), {j ∈ nbr supp i | ty j = t}.card ≤ D (ty i) t) (hx0 : ∀ (t : Bool), 0 < x t) (hx1 : ∀ (t : Bool), x t < 1) (hcond : ∀ (t : Bool), p t ≤ x t * (1 - x false) ^ D t false * (1 - x true) ^ D t true) :
      0 < pr {ω : Cfg β | ∀ (i : I), ω ∉ Ev i}

      The two-type asymmetric local lemma of Section 10.2 of bs_lambda.txt. Each event has a type ty i : Bool, and events of type t have probability at most p t and at most D t s neighbours of type s.

      Pinning coordinates whose targets depend on other coordinates #

      def BSLambda.LLL.fibre {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] (G : Finset A) (c : (a : A) → a ∈ G → β a) :
      Finset (Cfg β)

      The event that a configuration agrees on G with the partial configuration c.

      Equations
      Instances For
        @[simp]
        theorem BSLambda.LLL.mem_fibre {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {G : Finset A} {c : (a : A) → a ∈ G → β a} {ω : Cfg β} :
        ω ∈ fibre G c ↔ ∀ (a : A) (ha : a ∈ G), ω a = c a ha

        Membership in a fibre.

        theorem BSLambda.LLL.mem_fibre_restrict {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {G : Finset A} (ω : Cfg β) :
        ω ∈ fibre G fun (a : A) (x : a ∈ G) => ω a

        Every configuration lies in the fibre over its own restriction to G.

        theorem BSLambda.LLL.determined_fibre {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {G : Finset A} (c : (a : A) → a ∈ G → β a) :

        A fibre over G is determined by G.

        theorem BSLambda.LLL.disjoint_fibre {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] {G : Finset A} {c c' : (a : A) → a ∈ G → β a} (h : c ≠ c') :
        Disjoint (fibre G c) (fibre G c')

        Distinct partial configurations have disjoint fibres.

        theorem BSLambda.LLL.sum_pr_fibre {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [(a : A) → DecidableEq (β a)] [∀ (a : A), Nonempty (β a)] (G : Finset A) :
        ∑ c ∈ G.pi fun (a : A) => Finset.univ, pr (fibre G c) = 1

        The fibres over G partition the configuration space, so their probabilities sum to 1.

        theorem BSLambda.LLL.pr_le_prod_of_pinned {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [∀ (a : A), Nonempty (β a)] {G T : Finset A} (hGT : Disjoint G T) (tgt : ((a : A) → a ∈ G → β a) → (a : A) → Finset (β a)) (m : ℕ) (hm : ∀ (c : (a : A) → a ∈ G → β a), ∀ a ∈ T, (tgt c a).card ≤ m) {E : Finset (Cfg β)} (hE : ∀ ω ∈ E, ∀ a ∈ T, ω a ∈ tgt (fun (b : A) (x : b ∈ G) => ω b) a) :
        pr E ≤ ∏ a ∈ T, ↑m / ↑(Fintype.card (β a))

        Pinning with targets read off other coordinates. If, on the event E, every coordinate of T lands in a target set of size at most m that depends only on the coordinates of a set G disjoint from T, then E has probability at most ∏ a ∈ T, m / |β a|. This is the counting form of "condition on G; the coordinates of T are still independent and uniform".

        theorem BSLambda.LLL.pr_le_pow_of_pinned {A : Type u_1} [Fintype A] [DecidableEq A] {β : A → Type u_2} [(a : A) → Fintype (β a)] [∀ (a : A), Nonempty (β a)] {G T : Finset A} (hGT : Disjoint G T) (N : ℕ) (hN : ∀ a ∈ T, Fintype.card (β a) = N) (tgt : ((a : A) → a ∈ G → β a) → (a : A) → Finset (β a)) (m : ℕ) (hm : ∀ (c : (a : A) → a ∈ G → β a), ∀ a ∈ T, (tgt c a).card ≤ m) {E : Finset (Cfg β)} (hE : ∀ ω ∈ E, ∀ a ∈ T, ω a ∈ tgt (fun (b : A) (x : b ∈ G) => ω b) a) :
        pr E ≤ (↑m / ↑N) ^ T.card

        The constant-alphabet form of pr_le_prod_of_pinned, as used in Sections 8.1 and 9.