InformationTheory

InformationTheory.Shannon.BroadcastChannel.Marton.MutualCovering

source

Second-moment core of the mutual covering lemma #

Marton's mutual covering lemma asserts that among the M₁ * M₂ pairs formed from two independently drawn codebooks, at least one pair is jointly typical. The standard proof is a second moment argument, and its analytic core does not mention typicality at all: it only needs a measurable set S in the product alphabet and the fact that indicator variables attached to two pairs sharing no index are independent.

This file develops that core for an abstract S, in two strengths. The crude estimate uses no information about S beyond p, and its conclusion needs both M₁ p and M₂ p to be large. The sharpened estimate additionally assumes that every conditional slice of S has mass at most qbar, and its conclusion splits into a term needing only the product M₁ M₂ p to be large plus two terms carrying the ratio qbar / p.

Main definitions #

  • codebookFamily X Y — the two codebooks interleaved into one family indexed by Fin M₁ ⊕ Fin M₂, so that mutual independence of all M₁ + M₂ codewords is a single iIndepFun hypothesis.
  • pairIndicator X Y S p — indicator of "the codeword pair indexed by p lands in S".
  • pairCount X Y S — number of codeword pairs landing in S.
  • pairProb μX μY S — probability that one independently drawn pair lands in S.
  • sharedFstSet S / sharedSndSet S — the triples of codewords realizing two pairs that share one index.

Main statements #

noncomputable def

InformationTheory.Shannon.BroadcastChannel.Marton.codebookFamily

source
{Ω : Type u_1} {α : Type u_2} {β : Type u_3} [Nonempty α] [Nonempty β] {M₁ M₂ : } (X : Fin M₁Ωα) (Y : Fin M₂Ωβ) :
Fin M₁ Fin M₂Ωα × β

The two codebooks interleaved into a single family indexed by Fin M₁ ⊕ Fin M₂, each entry padded by a constant in the unused coordinate so that the whole family shares the codomain α × β. Padding by a constant leaves the generated σ-algebra unchanged, so iIndepFun (codebookFamily X Y) μ says exactly that the M₁ + M₂ codewords are mutually independent.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    Used by
      theorem

      InformationTheory.Shannon.BroadcastChannel.Marton.codebookFamily_inl

      source
      @[simp]
      {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [Nonempty α] [Nonempty β] {M₁ M₂ : } (X : Fin M₁Ωα) (Y : Fin M₂Ωβ) (i : Fin M₁) :
      codebookFamily X Y (Sum.inl i) = fun (ω : Ω) => (X i ω, Classical.arbitrary β)
      Used by
        theorem

        InformationTheory.Shannon.BroadcastChannel.Marton.codebookFamily_inr

        source
        @[simp]
        {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [Nonempty α] [Nonempty β] {M₁ M₂ : } (X : Fin M₁Ωα) (Y : Fin M₂Ωβ) (j : Fin M₂) :
        codebookFamily X Y (Sum.inr j) = fun (ω : Ω) => (Classical.arbitrary α, Y j ω)
        Used by
          noncomputable def

          InformationTheory.Shannon.BroadcastChannel.Marton.pairIndicator

          source
          {Ω : Type u_1} {α : Type u_2} {β : Type u_3} {M₁ M₂ : } (X : Fin M₁Ωα) (Y : Fin M₂Ωβ) (S : Set (α × β)) (p : Fin M₁ × Fin M₂) (ω : Ω) :

          Indicator of the event that the codeword pair indexed by p lands in S.

          Equations
          Instances For
            Used by
              noncomputable def

              InformationTheory.Shannon.BroadcastChannel.Marton.pairCount

              source
              {Ω : Type u_1} {α : Type u_2} {β : Type u_3} {M₁ M₂ : } (X : Fin M₁Ωα) (Y : Fin M₂Ωβ) (S : Set (α × β)) (ω : Ω) :

              Number of codeword pairs landing in S.

              Equations
              Instances For
                Used by
                  noncomputable def

                  InformationTheory.Shannon.BroadcastChannel.Marton.pairProb

                  source
                  {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] (μX : MeasureTheory.Measure α) (μY : MeasureTheory.Measure β) (S : Set (α × β)) :

                  Probability that one independently drawn codeword pair lands in S.

                  Equations
                  Instances For
                    Used by
                      theorem

                      InformationTheory.Shannon.BroadcastChannel.Marton.measurable_codebookFamily

                      source
                      {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (k : Fin M₁ Fin M₂) :
                      Used by
                        theorem

                        InformationTheory.Shannon.BroadcastChannel.Marton.measurable_pairIndicator

                        source
                        {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (p : Fin M₁ × Fin M₂) :
                        Used by
                          theorem

                          InformationTheory.Shannon.BroadcastChannel.Marton.pairIndicator_nonneg

                          source
                          {Ω : Type u_1} {α : Type u_2} {β : Type u_3} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (p : Fin M₁ × Fin M₂) (ω : Ω) :
                          0 pairIndicator X Y S p ω
                          Used by
                            theorem

                            InformationTheory.Shannon.BroadcastChannel.Marton.pairIndicator_le_one

                            source
                            {Ω : Type u_1} {α : Type u_2} {β : Type u_3} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (p : Fin M₁ × Fin M₂) (ω : Ω) :
                            pairIndicator X Y S p ω 1
                            Used by
                              theorem

                              InformationTheory.Shannon.BroadcastChannel.Marton.memLp_pairIndicator

                              source
                              {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] {μ : MeasureTheory.Measure Ω} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) [MeasureTheory.IsFiniteMeasure μ] (p : Fin M₁ × Fin M₂) :
                              Used by
                                theorem

                                InformationTheory.Shannon.BroadcastChannel.Marton.memLp_pairCount

                                source
                                {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] {μ : MeasureTheory.Measure Ω} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) [MeasureTheory.IsFiniteMeasure μ] :
                                Used by
                                  theorem

                                  InformationTheory.Shannon.BroadcastChannel.Marton.indepFun_codewordPair

                                  source
                                  {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) {i i' : Fin M₁} {j j' : Fin M₂} (hi : i i') (hj : j j') :
                                  ProbabilityTheory.IndepFun (fun (ω : Ω) => (X i ω, Y j ω)) (fun (ω : Ω) => (X i' ω, Y j' ω)) μ
                                  Used by
                                    theorem

                                    InformationTheory.Shannon.BroadcastChannel.Marton.indepFun_pairIndicator

                                    source
                                    {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) {p q : Fin M₁ × Fin M₂} (hi : p.1 q.1) (hj : p.2 q.2) :
                                    Used by
                                      theorem

                                      InformationTheory.Shannon.BroadcastChannel.Marton.covariance_pairIndicator_eq_zero

                                      source
                                      {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) [MeasureTheory.IsFiniteMeasure μ] {p q : Fin M₁ × Fin M₂} (hi : p.1 q.1) (hj : p.2 q.2) :
                                      Used by
                                        theorem

                                        InformationTheory.Shannon.BroadcastChannel.Marton.indepFun_codeword

                                        source
                                        {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (i : Fin M₁) (j : Fin M₂) :
                                        Used by
                                          theorem

                                          InformationTheory.Shannon.BroadcastChannel.Marton.map_codewordPair

                                          source
                                          {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsFiniteMeasure μ] (i : Fin M₁) (j : Fin M₂) :
                                          MeasureTheory.Measure.map (fun (ω : Ω) => (X i ω, Y j ω)) μ = μX.prod μY
                                          Used by
                                            theorem

                                            InformationTheory.Shannon.BroadcastChannel.Marton.integral_pairIndicator

                                            source
                                            {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (p : Fin M₁ × Fin M₂) :
                                            (x : Ω), pairIndicator X Y S p x μ = pairProb μX μY S
                                            Used by
                                              theorem

                                              InformationTheory.Shannon.BroadcastChannel.Marton.integral_pairCount

                                              source
                                              {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] :
                                              (x : Ω), pairCount X Y S x μ = M₁ * M₂ * pairProb μX μY S
                                              Used by
                                                theorem

                                                InformationTheory.Shannon.BroadcastChannel.Marton.covariance_pairIndicator_le

                                                source
                                                {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (p q : Fin M₁ × Fin M₂) :
                                                Used by
                                                  theorem

                                                  InformationTheory.Shannon.BroadcastChannel.Marton.variance_pairCount_le

                                                  source
                                                  {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] :
                                                  ProbabilityTheory.variance (pairCount X Y S) μ M₁ * M₂ * (M₁ + M₂) * pairProb μX μY S
                                                  Used by
                                                    theorem

                                                    InformationTheory.Shannon.BroadcastChannel.Marton.meas_pairCount_eq_zero_le

                                                    source
                                                    {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (hM₁ : M₁ 0) (hM₂ : M₂ 0) (hp : 0 < pairProb μX μY S) :
                                                    μ {ω : Ω | pairCount X Y S ω = 0} ENNReal.ofReal ((M₁ + M₂) / (M₁ * M₂ * pairProb μX μY S))

                                                    Second-moment estimate behind Marton's mutual covering lemma: the probability that no codeword pair lands in S is at most (M₁ + M₂) / (M₁ M₂ p), where p is the probability that one independently drawn pair lands in S.

                                                    Used by

                                                      Sharpened variance bound under a uniform slice bound #

                                                      variance_pairCount_le bounds the covariance of two pairs sharing one index by the crude pairProb μX μY S. If instead every conditional slice of S has mass at most qbar, that covariance is bounded by qbar * pairProb μX μY S, and the resulting Chebyshev estimate splits into a diagonal term 1 / (M₁ M₂ p) plus shared-index terms carrying a factor qbar.

                                                      Two slice bounds are needed, one in each coordinate: the α-slices control the pairs sharing their second index and the β-slices control the pairs sharing their first index. Neither bound implies the other.

                                                      def

                                                      InformationTheory.Shannon.BroadcastChannel.Marton.sharedFstSet

                                                      source
                                                      {α : Type u_2} {β : Type u_3} (S : Set (α × β)) :
                                                      Set (α × β × β)

                                                      Triples (x, y, y') whose two pairs (x, y) and (x, y') both lie in S.

                                                      Equations
                                                      Instances For
                                                        Used by
                                                          def

                                                          InformationTheory.Shannon.BroadcastChannel.Marton.sharedSndSet

                                                          source
                                                          {α : Type u_2} {β : Type u_3} (S : Set (α × β)) :
                                                          Set (β × α × α)

                                                          Triples (y, x, x') whose two pairs (x, y) and (x', y) both lie in S.

                                                          Equations
                                                          Instances For
                                                            Used by
                                                              theorem

                                                              InformationTheory.Shannon.BroadcastChannel.Marton.measurableSet_sharedFstSet

                                                              source
                                                              {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] {S : Set (α × β)} (hS : MeasurableSet S) :
                                                              Used by
                                                                theorem

                                                                InformationTheory.Shannon.BroadcastChannel.Marton.measurableSet_sharedSndSet

                                                                source
                                                                {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] {S : Set (α × β)} (hS : MeasurableSet S) :
                                                                Used by
                                                                  theorem

                                                                  InformationTheory.Shannon.BroadcastChannel.Marton.prod_sharedFstSet_le

                                                                  source
                                                                  {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {S : Set (α × β)} {qbar : } [MeasureTheory.SFinite μX] [MeasureTheory.IsFiniteMeasure μY] (hS : MeasurableSet S) (hsliceY : ∀ (x : α), (μY (Prod.mk x ⁻¹' S)).toReal qbar) :
                                                                  (μX.prod (μY.prod μY)) (sharedFstSet S) ENNReal.ofReal qbar * (μX.prod μY) S
                                                                  Used by
                                                                    theorem

                                                                    InformationTheory.Shannon.BroadcastChannel.Marton.prod_sharedSndSet_le

                                                                    source
                                                                    {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty β] {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {S : Set (α × β)} {qbar : } [MeasureTheory.IsFiniteMeasure μX] [MeasureTheory.SFinite μY] (hS : MeasurableSet S) (hsliceX : ∀ (y : β), (μX ((fun (x : α) => (x, y)) ⁻¹' S)).toReal qbar) :
                                                                    (μY.prod (μX.prod μX)) (sharedSndSet S) ENNReal.ofReal qbar * (μX.prod μY) S
                                                                    Used by
                                                                      theorem

                                                                      InformationTheory.Shannon.BroadcastChannel.Marton.map_codewordTripleFst

                                                                      source
                                                                      {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (i : Fin M₁) {j j' : Fin M₂} (hj : j j') :
                                                                      MeasureTheory.Measure.map (fun (ω : Ω) => (X i ω, Y j ω, Y j' ω)) μ = μX.prod (μY.prod μY)
                                                                      Used by
                                                                        theorem

                                                                        InformationTheory.Shannon.BroadcastChannel.Marton.map_codewordTripleSnd

                                                                        source
                                                                        {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] {i i' : Fin M₁} (hi : i i') (j : Fin M₂) :
                                                                        MeasureTheory.Measure.map (fun (ω : Ω) => (Y j ω, X i ω, X i' ω)) μ = μY.prod (μX.prod μX)
                                                                        Used by
                                                                          theorem

                                                                          InformationTheory.Shannon.BroadcastChannel.Marton.integral_pairIndicator_mul_sharedFst_le

                                                                          source
                                                                          {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} {qbar : } (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (hsliceY : ∀ (x : α), (μY (Prod.mk x ⁻¹' S)).toReal qbar) (i : Fin M₁) {j j' : Fin M₂} (hj : j j') :
                                                                          (x : Ω), (pairIndicator X Y S (i, j) * pairIndicator X Y S (i, j')) x μ qbar * pairProb μX μY S
                                                                          Used by
                                                                            theorem

                                                                            InformationTheory.Shannon.BroadcastChannel.Marton.integral_pairIndicator_mul_sharedSnd_le

                                                                            source
                                                                            {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} {qbar : } (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (hsliceX : ∀ (y : β), (μX ((fun (x : α) => (x, y)) ⁻¹' S)).toReal qbar) {i i' : Fin M₁} (hi : i i') (j : Fin M₂) :
                                                                            (x : Ω), (pairIndicator X Y S (i, j) * pairIndicator X Y S (i', j)) x μ qbar * pairProb μX μY S
                                                                            Used by
                                                                              theorem

                                                                              InformationTheory.Shannon.BroadcastChannel.Marton.covariance_pairIndicator_shared_le

                                                                              source
                                                                              {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} {qbar : } (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (hsliceY : ∀ (x : α), (μY (Prod.mk x ⁻¹' S)).toReal qbar) (hsliceX : ∀ (y : β), (μX ((fun (x : α) => (x, y)) ⁻¹' S)).toReal qbar) {p q : Fin M₁ × Fin M₂} (hpq : p.1 = q.1 p.2 q.2 p.1 q.1 p.2 = q.2) :

                                                                              Covariance of two codeword pairs sharing exactly one index, under the two uniform slice bounds. Each bound constrains one coordinate of S only, so both are needed: the pairs sharing their first index are governed by the β-slices and those sharing their second index by the α-slices.

                                                                              @audit:ok

                                                                              Used by
                                                                                theorem

                                                                                InformationTheory.Shannon.BroadcastChannel.Marton.variance_pairCount_le'

                                                                                source
                                                                                {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} {qbar : } (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (hsliceY : ∀ (x : α), (μY (Prod.mk x ⁻¹' S)).toReal qbar) (hsliceX : ∀ (y : β), (μX ((fun (x : α) => (x, y)) ⁻¹' S)).toReal qbar) :
                                                                                ProbabilityTheory.variance (pairCount X Y S) μ M₁ * M₂ * pairProb μX μY S + M₁ * M₂ * (M₁ + M₂) * (qbar * pairProb μX μY S)

                                                                                Sharpened variance bound: the diagonal terms contribute M₁ M₂ p, and the pairs sharing one index contribute at most qbar * p each.

                                                                                @audit:ok

                                                                                Used by
                                                                                  theorem

                                                                                  InformationTheory.Shannon.BroadcastChannel.Marton.meas_pairCount_eq_zero_le'

                                                                                  source
                                                                                  {Ω : Type u_1} {α : Type u_2} {β : Type u_3} [MeasurableSpace Ω] [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μ : MeasureTheory.Measure Ω} {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {X : Fin M₁Ωα} {Y : Fin M₂Ωβ} {S : Set (α × β)} {qbar : } (hX : ∀ (i : Fin M₁), Measurable (X i)) (hY : ∀ (j : Fin M₂), Measurable (Y j)) (hS : MeasurableSet S) (hIndep : ProbabilityTheory.iIndepFun (codebookFamily X Y) μ) (hXlaw : ∀ (i : Fin M₁), MeasureTheory.Measure.map (X i) μ = μX) (hYlaw : ∀ (j : Fin M₂), MeasureTheory.Measure.map (Y j) μ = μY) [MeasureTheory.IsProbabilityMeasure μ] (hsliceY : ∀ (x : α), (μY (Prod.mk x ⁻¹' S)).toReal qbar) (hsliceX : ∀ (y : β), (μX ((fun (x : α) => (x, y)) ⁻¹' S)).toReal qbar) (hM₁ : M₁ 0) (hM₂ : M₂ 0) (hp : 0 < pairProb μX μY S) :
                                                                                  μ {ω : Ω | pairCount X Y S ω = 0} ENNReal.ofReal (1 / (M₁ * M₂ * pairProb μX μY S) + qbar / (M₁ * pairProb μX μY S) + qbar / (M₂ * pairProb μX μY S))

                                                                                  Sharpened second-moment estimate behind Marton's mutual covering lemma. When every conditional slice of S has mass at most qbar, the probability that no codeword pair lands in S splits into a term governed by the product M₁ M₂ and two terms carrying qbar.

                                                                                  @audit:ok

                                                                                  Used by

                                                                                    A canonical ambient realizing the hypotheses #

                                                                                    meas_pairCount_eq_zero_le is stated over an abstract probability space. This section exhibits the i.i.d. codebook ambient on which its hypotheses hold, so that the abstract statement is known to be non-vacuous and downstream users have a template to instantiate.

                                                                                    noncomputable def

                                                                                    InformationTheory.Shannon.BroadcastChannel.Marton.ambientFactor

                                                                                    source
                                                                                    {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] (μX : MeasureTheory.Measure α) (μY : MeasureTheory.Measure β) (M₁ M₂ : ) :
                                                                                    Fin M₁ Fin M₂MeasureTheory.Measure (α × β)

                                                                                    Law of one entry of the interleaved codebook family on the canonical ambient: an α-codeword carries μX in its first coordinate and a point mass in the padded one.

                                                                                    Equations
                                                                                    Instances For
                                                                                      Used by
                                                                                        instance

                                                                                        InformationTheory.Shannon.BroadcastChannel.Marton.instIsProbabilityMeasureAmbientFactor

                                                                                        source
                                                                                        Used by
                                                                                          noncomputable def

                                                                                          InformationTheory.Shannon.BroadcastChannel.Marton.ambient

                                                                                          source
                                                                                          {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] (μX : MeasureTheory.Measure α) (μY : MeasureTheory.Measure β) (M₁ M₂ : ) :
                                                                                          MeasureTheory.Measure (Fin M₁ Fin M₂α × β)

                                                                                          Canonical ambient measure: the M₁ + M₂ codewords are drawn independently.

                                                                                          Equations
                                                                                          Instances For
                                                                                            Used by
                                                                                              instance

                                                                                              InformationTheory.Shannon.BroadcastChannel.Marton.instIsProbabilityMeasureAmbient

                                                                                              source
                                                                                              Used by
                                                                                                def

                                                                                                InformationTheory.Shannon.BroadcastChannel.Marton.ambientX

                                                                                                source
                                                                                                {α : Type u_2} {β : Type u_3} (M₁ M₂ : ) (i : Fin M₁) :
                                                                                                (Fin M₁ Fin M₂α × β)α

                                                                                                First codebook read off the canonical ambient.

                                                                                                Equations
                                                                                                Instances For
                                                                                                  Used by
                                                                                                    def

                                                                                                    InformationTheory.Shannon.BroadcastChannel.Marton.ambientY

                                                                                                    source
                                                                                                    {α : Type u_2} {β : Type u_3} (M₁ M₂ : ) (j : Fin M₂) :
                                                                                                    (Fin M₁ Fin M₂α × β)β

                                                                                                    Second codebook read off the canonical ambient.

                                                                                                    Equations
                                                                                                    Instances For
                                                                                                      Used by
                                                                                                        noncomputable def

                                                                                                        InformationTheory.Shannon.BroadcastChannel.Marton.ambientPad

                                                                                                        source
                                                                                                        {α : Type u_2} {β : Type u_3} [Nonempty α] [Nonempty β] (M₁ M₂ : ) :
                                                                                                        Fin M₁ Fin M₂α × βα × β

                                                                                                        The padding map attached to one index of the interleaved family.

                                                                                                        Equations
                                                                                                        Instances For
                                                                                                          Used by
                                                                                                            theorem

                                                                                                            InformationTheory.Shannon.BroadcastChannel.Marton.measurable_ambientX

                                                                                                            source
                                                                                                            {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] {M₁ M₂ : } (i : Fin M₁) :
                                                                                                            Measurable (ambientX M₁ M₂ i)
                                                                                                            Used by
                                                                                                              theorem

                                                                                                              InformationTheory.Shannon.BroadcastChannel.Marton.measurable_ambientY

                                                                                                              source
                                                                                                              {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] {M₁ M₂ : } (j : Fin M₂) :
                                                                                                              Measurable (ambientY M₁ M₂ j)
                                                                                                              Used by
                                                                                                                theorem

                                                                                                                InformationTheory.Shannon.BroadcastChannel.Marton.measurable_ambientPad

                                                                                                                source
                                                                                                                {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {M₁ M₂ : } (k : Fin M₁ Fin M₂) :
                                                                                                                Measurable (ambientPad M₁ M₂ k)
                                                                                                                Used by
                                                                                                                  theorem

                                                                                                                  InformationTheory.Shannon.BroadcastChannel.Marton.iIndepFun_codebookFamily_ambient

                                                                                                                  source
                                                                                                                  Used by
                                                                                                                    theorem

                                                                                                                    InformationTheory.Shannon.BroadcastChannel.Marton.map_ambientX

                                                                                                                    source
                                                                                                                    {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } [MeasureTheory.IsProbabilityMeasure μX] [MeasureTheory.IsProbabilityMeasure μY] (i : Fin M₁) :
                                                                                                                    MeasureTheory.Measure.map (ambientX M₁ M₂ i) (ambient μX μY M₁ M₂) = μX
                                                                                                                    Used by
                                                                                                                      theorem

                                                                                                                      InformationTheory.Shannon.BroadcastChannel.Marton.map_ambientY

                                                                                                                      source
                                                                                                                      {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } [MeasureTheory.IsProbabilityMeasure μX] [MeasureTheory.IsProbabilityMeasure μY] (j : Fin M₂) :
                                                                                                                      MeasureTheory.Measure.map (ambientY M₁ M₂ j) (ambient μX μY M₁ M₂) = μY
                                                                                                                      Used by
                                                                                                                        theorem

                                                                                                                        InformationTheory.Shannon.BroadcastChannel.Marton.meas_pairCount_ambient_eq_zero_le

                                                                                                                        source
                                                                                                                        {α : Type u_2} {β : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [Nonempty α] [Nonempty β] {μX : MeasureTheory.Measure α} {μY : MeasureTheory.Measure β} {M₁ M₂ : } {S : Set (α × β)} [MeasureTheory.IsProbabilityMeasure μX] [MeasureTheory.IsProbabilityMeasure μY] (hS : MeasurableSet S) (hM₁ : M₁ 0) (hM₂ : M₂ 0) (hp : 0 < pairProb μX μY S) :
                                                                                                                        (ambient μX μY M₁ M₂) {ω : Fin M₁ Fin M₂α × β | pairCount (ambientX M₁ M₂) (ambientY M₁ M₂) S ω = 0} ENNReal.ofReal ((M₁ + M₂) / (M₁ * M₂ * pairProb μX μY S))

                                                                                                                        The mutual covering estimate on the canonical i.i.d. codebook ambient.

                                                                                                                        Used by