InformationTheory

InformationTheory.Shannon.BroadcastChannel.Converse

source

Degraded broadcast channel — converse (outer bound) #

The converse to the degraded BC coding theorem (Cover–Thomas): for uniformly distributed, independent messages (W₁, W₂) sent over a degraded broadcast channel X → Y₁ → Y₂ and decoded by per-receiver decoders, the rate pair (log |M₁|, log |M₂|) lies in the auxiliary-variable capacity region with Uᵢ = (W₂, Y₂^{i-1}).

The structure mirrors the multiple-access converse mac_converse:

  • message level (bc_converse_message_level): each rate is bounded by the relevant n-letter message–output mutual information plus the Fano slack, obtained from the single-shot Fano converse shannon_converse_single_shot.
  • single letter (bc_degraded_converse): the message-level mutual informations are bridged to the per-letter channel quantities ∑ᵢ I(Uᵢ; Y_{2,i}) (receiver 2, the easy chain-rule half bc_singleletterize_bound₂) and ∑ᵢ I(Xᵢ; Y_{1,i} | Uᵢ) (receiver 1, the Csiszár-sum single-letterization bc_singleletterize_bound₁), combined via InBCCapacityRegion.mono.

The degradedness X → Y₁ → Y₂ and the memoryless block structure are taken as preconditions (regularity / structural hypotheses); they do not carry the proof core.

Receiver-2 single-letterization (the easy chain-rule half, bound (a)) #

theorem

InformationTheory.Shannon.BroadcastChannel.bc_singleletterize_bound₂

source
{Ω : Type u_1} [MeasurableSpace Ω] {β₂ : Type u_4} [Fintype β₂] [MeasurableSpace β₂] [MeasurableSingletonClass β₂] [StandardBorelSpace β₂] [Nonempty β₂] {M₂ n : } [NeZero M₂] (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ] (W₂ : ΩFin M₂) (Y₂s : Fin nΩβ₂) (hW₂ : Measurable W₂) (hY₂s : ∀ (i : Fin n), Measurable (Y₂s i)) :
(mutualInfo μ W₂ fun (ω : Ω) (j : Fin n) => Y₂s j ω) i : Fin n, mutualInfo μ (fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₂s j, ω)) (Y₂s i)

Receiver-2 single-letterization for the BC converse: with Uᵢ = (W₂, Y₂^{i-1}), the message–output mutual information obeys I(W₂; Y₂ⁿ) ≤ ∑ᵢ I(Uᵢ; Y_{2,i}). Pure chain-rule plumbing on a prefix conditioner — no Csiszár identity, no degradedness. Typed analogue of bc_converse_bound_a.

Used by

    Message-level Fano bounds #

    The message-level bounds are pure single-shot Fano plumbing on the output measurable spaces, so the finite-alphabet / standard-Borel structure of the variable context is unused here.

    theorem

    InformationTheory.Shannon.BroadcastChannel.bc_converse_bound₁

    source
    {Ω : Type u_1} [MeasurableSpace Ω] {α : Type u_2} [MeasurableSpace α] {β₁ : Type u_3} [Fintype β₁] [MeasurableSpace β₁] [MeasurableSingletonClass β₁] {β₂ : Type u_4} [MeasurableSpace β₂] {M₁ M₂ n : } (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ] (W₁ : ΩFin M₁) (W₂ : ΩFin M₂) (Y₁s : Fin nΩβ₁) (c : BroadcastCode M₁ M₂ n α β₁ β₂) (hW₁ : Measurable W₁) (hW₂ : Measurable W₂) (hY₁s : ∀ (i : Fin n), Measurable (Y₁s i)) (hW₁_uniform : MeasureTheory.Measure.map W₁ μ = (↑(Fintype.card (Fin M₁)))⁻¹ MeasureTheory.Measure.count) (hcard₁ : 2 M₁) :
    Real.log M₁ (mutualInfo μ W₁ fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)).toReal + Real.binEntropy (MeasureFano.errorProb μ W₁ (fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)) fun (p : Fin M₂ × (Fin nβ₁)) => c.decoder₁ p.2) + (MeasureFano.errorProb μ W₁ (fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)) fun (p : Fin M₂ × (Fin nβ₁)) => c.decoder₁ p.2) * Real.log (M₁ - 1)

    Receiver-1 corner bound of the BC converse at the message level: under a uniform W₁, log |M₁| ≤ I(W₁; (W₂, Y₁ⁿ)) + h(Pe₁) + Pe₁ · log(|M₁| − 1), with Pe₁ the receiver-1 error probability of the Y₁-only decoder.

    Used by
      theorem

      InformationTheory.Shannon.BroadcastChannel.bc_converse_bound₂

      source
      {Ω : Type u_1} [MeasurableSpace Ω] {α : Type u_2} [MeasurableSpace α] {β₁ : Type u_3} [MeasurableSpace β₁] {β₂ : Type u_4} [Fintype β₂] [MeasurableSpace β₂] [MeasurableSingletonClass β₂] {M₁ M₂ n : } (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ] (W₂ : ΩFin M₂) (Y₂s : Fin nΩβ₂) (c : BroadcastCode M₁ M₂ n α β₁ β₂) (hW₂ : Measurable W₂) (hY₂s : ∀ (i : Fin n), Measurable (Y₂s i)) (hW₂_uniform : MeasureTheory.Measure.map W₂ μ = (↑(Fintype.card (Fin M₂)))⁻¹ MeasureTheory.Measure.count) (hcard₂ : 2 M₂) :
      Real.log M₂ (mutualInfo μ W₂ fun (ω : Ω) (i : Fin n) => Y₂s i ω).toReal + Real.binEntropy (MeasureFano.errorProb μ W₂ (fun (ω : Ω) (i : Fin n) => Y₂s i ω) c.decoder₂) + MeasureFano.errorProb μ W₂ (fun (ω : Ω) (i : Fin n) => Y₂s i ω) c.decoder₂ * Real.log (M₂ - 1)

      Receiver-2 corner bound of the BC converse at the message level: under a uniform W₂, log |M₂| ≤ I(W₂; Y₂ⁿ) + h(Pe₂) + Pe₂ · log(|M₂| − 1), with Pe₂ the receiver-2 error probability.

      Used by
        theorem

        InformationTheory.Shannon.BroadcastChannel.bc_converse_message_level

        source
        {Ω : Type u_1} [MeasurableSpace Ω] {α : Type u_2} [MeasurableSpace α] {β₁ : Type u_3} [Fintype β₁] [MeasurableSpace β₁] [MeasurableSingletonClass β₁] {β₂ : Type u_4} [Fintype β₂] [MeasurableSpace β₂] [MeasurableSingletonClass β₂] {M₁ M₂ n : } (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ] (W₁ : ΩFin M₁) (W₂ : ΩFin M₂) (Y₁s : Fin nΩβ₁) (Y₂s : Fin nΩβ₂) (c : BroadcastCode M₁ M₂ n α β₁ β₂) (hW₁ : Measurable W₁) (hW₂ : Measurable W₂) (hY₁s : ∀ (i : Fin n), Measurable (Y₁s i)) (hY₂s : ∀ (i : Fin n), Measurable (Y₂s i)) (hW₁_uniform : MeasureTheory.Measure.map W₁ μ = (↑(Fintype.card (Fin M₁)))⁻¹ MeasureTheory.Measure.count) (hW₂_uniform : MeasureTheory.Measure.map W₂ μ = (↑(Fintype.card (Fin M₂)))⁻¹ MeasureTheory.Measure.count) (hcard₁ : 2 M₁) (hcard₂ : 2 M₂) :
        InBCCapacityRegion (Real.log M₁) (Real.log M₂) ((mutualInfo μ W₁ fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)).toReal + Real.binEntropy (MeasureFano.errorProb μ W₁ (fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)) fun (p : Fin M₂ × (Fin nβ₁)) => c.decoder₁ p.2) + (MeasureFano.errorProb μ W₁ (fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)) fun (p : Fin M₂ × (Fin nβ₁)) => c.decoder₁ p.2) * Real.log (M₁ - 1)) ((mutualInfo μ W₂ fun (ω : Ω) (i : Fin n) => Y₂s i ω).toReal + Real.binEntropy (MeasureFano.errorProb μ W₂ (fun (ω : Ω) (i : Fin n) => Y₂s i ω) c.decoder₂) + MeasureFano.errorProb μ W₂ (fun (ω : Ω) (i : Fin n) => Y₂s i ω) c.decoder₂ * Real.log (M₂ - 1))

        Message-level Fano outer bound for the broadcast channel: for uniform messages decoded by per-receiver decoders, the rate pair satisfies the two message-level Fano information bounds, packaged as InBCCapacityRegion. The single-letterization that turns this into the textbook degraded-BC converse is bc_degraded_converse.

        Used by

          Receiver-1 single-letterization (Csiszár-sum half, bound (b)) #

          theorem

          InformationTheory.Shannon.BroadcastChannel.bc_input_singleletterize

          source
          {Ω : Type u_1} [MeasurableSpace Ω] {α : Type u_2} [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α] [StandardBorelSpace α] [Nonempty α] {β₁ : Type u_3} [Fintype β₁] [MeasurableSpace β₁] [MeasurableSingletonClass β₁] [StandardBorelSpace β₁] [Nonempty β₁] {β₂ : Type u_4} [Fintype β₂] [MeasurableSpace β₂] [MeasurableSingletonClass β₂] [StandardBorelSpace β₂] [Nonempty β₂] {M₂ n : } [NeZero M₂] (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ] (W₂ : ΩFin M₂) (Xs : Fin nΩα) (Y₁s : Fin nΩβ₁) (Y₂s : Fin nΩβ₂) (hW₂ : Measurable W₂) (hXs : ∀ (i : Fin n), Measurable (Xs i)) (hY₁s : ∀ (i : Fin n), Measurable (Y₁s i)) (hY₂s : ∀ (i : Fin n), Measurable (Y₂s i)) (h_memo : ∀ (i : Fin n), IsMarkovChain μ (fun (ω : Ω) => (W₂ ω, fun (j : { j : Fin n // j i }) => Xs (↑j) ω, fun (j : { j : Fin n // j i }) => Y₁s (↑j) ω, fun (j : { j : Fin n // j i }) => Y₂s (↑j) ω)) (Xs i) (Y₁s i)) (h_deg_block : ∀ (i : Fin n), IsMarkovChain μ (Y₁s i) (fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₁s j, ω)) fun (ω : Ω) (j : Fin i) => Y₂s j, ω) :
          condMutualInfo μ (fun (ω : Ω) (j : Fin n) => Xs j ω) (fun (ω : Ω) (j : Fin n) => Y₁s j ω) W₂ i : Fin n, condMutualInfo μ (Xs i) (Y₁s i) fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₂s j, ω)

          Receiver-1 input-level single-letterization of the BC converse, via term-by-term degradedness: under a memoryless broadcast channel with the conditioning message W₂ upstream of the channel and physical degradedness X → Y₁ → Y₂, the conditional block input–output mutual information collapses to the per-letter auxiliary-variable sum I(Xⁿ; Y₁ⁿ | W₂) ≤ ∑ᵢ I(Xᵢ; Y_{1,i} | Uᵢ) with Uᵢ = (W₂, Y₂^{i-1}).

          Proof (entropy-difference route, mirroring the MAC single-letterization condMutualInfo_singleletter_le_of_memoryless): both sides reduce to conditional-entropy differences H(Y₁ | ·) − H(Y₁ | ·, X). The joint-output memoryless hypothesis h_memo collapses every "noise" term H(Y₁ᵢ | …, Xᵢ) to the common H(Y₁ᵢ | Xᵢ) on both sides, so those cancel; what remains is H(Y₁ⁿ | W₂) ≤ ∑ᵢ H(Y₁ᵢ | W₂, Y₂^{i-1}), which holds term-by-term via the LHS chain rule and the conditioner swap H(Y₁ᵢ | W₂, Y₁^{<i}) ≤ H(Y₁ᵢ | W₂, Y₂^{<i}) (block-prefix degradedness h_deg_block plus conditioning-reduces-entropy).

          The two structural preconditions encode the channel, not the conclusion:

          • h_memojoint-output memoryless: Y₁ᵢ ⫫ (W₂, X^{≠i}, Y₁^{≠i}, Y₂^{≠i}) | Xᵢ. It blocks the conditioning message W₂ and all other letters (including the degraded outputs Y₂^{≠i}) at Xᵢ. Blocking Y₂^{≠i} is needed by the entropy-difference route: it collapses the RHS noise term H(Y₁ᵢ | W₂, Y₂^{<i}, Xᵢ) to the common H(Y₁ᵢ | Xᵢ).
          • h_deg_blockblock-prefix degradedness: Y₁ᵢ ⫫ Y₂^{<i} | (W₂, Y₁^{<i}). This is the d-separation consequence of physical per-letter degradedness X → Y₁ → Y₂ together with memorylessness; per-letter degradedness Y₂ⱼ ⫫ Xⱼ | Y₁ⱼ alone is insufficient (it is satisfied by the documented n = 2 collider counterexample — an early degraded output leaking a later letter's input — which breaks the bound), and deriving the block form from the per-letter form needs graphoid / d-separation machinery absent from Mathlib, so it is taken as a structural precondition (parity with h_memo). This is the hypothesis that rules out the collider counterexample (it fails there: Y₁₁ ⫫ Y₂₀ | (·, Y₁₀) is false when Y₁₁ = Y₂₀), whereas the strengthened h_memo still holds in it.

          Both are regularity / structural preconditions (true in the operational degraded-memoryless setup where Xⁿ = encoder (W₁, W₂)), not load-bearing.

          @audit:ok

          Used by
            theorem

            InformationTheory.Shannon.BroadcastChannel.bc_singleletterize_bound₁

            source
            {Ω : Type u_1} [MeasurableSpace Ω] {α : Type u_2} [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α] [StandardBorelSpace α] [Nonempty α] {β₁ : Type u_3} [Fintype β₁] [MeasurableSpace β₁] [MeasurableSingletonClass β₁] [StandardBorelSpace β₁] [Nonempty β₁] {β₂ : Type u_4} [Fintype β₂] [MeasurableSpace β₂] [MeasurableSingletonClass β₂] [StandardBorelSpace β₂] [Nonempty β₂] {M₁ M₂ n : } [NeZero M₁] [NeZero M₂] (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ] (W₁ : ΩFin M₁) (W₂ : ΩFin M₂) (Y₁s : Fin nΩβ₁) (Y₂s : Fin nΩβ₂) (c : BroadcastCode M₁ M₂ n α β₁ β₂) (hW₁ : Measurable W₁) (hW₂ : Measurable W₂) (hY₁s : ∀ (i : Fin n), Measurable (Y₁s i)) (hY₂s : ∀ (i : Fin n), Measurable (Y₂s i)) (h_indep : mutualInfo μ W₁ W₂ = 0) (h_memo : ∀ (i : Fin n), IsMarkovChain μ (fun (ω : Ω) => (W₂ ω, fun (j : { j : Fin n // j i }) => c.encoder (W₁ ω, W₂ ω) j, fun (j : { j : Fin n // j i }) => Y₁s (↑j) ω, fun (j : { j : Fin n // j i }) => Y₂s (↑j) ω)) (fun (ω : Ω) => c.encoder (W₁ ω, W₂ ω) i) (Y₁s i)) (h_deg_block : ∀ (i : Fin n), IsMarkovChain μ (Y₁s i) (fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₁s j, ω)) fun (ω : Ω) (j : Fin i) => Y₂s j, ω) (hmarkov : IsMarkovChain μ (fun (ω : Ω) => (W₂ ω, W₁ ω)) (fun (ω : Ω) => (W₂ ω, fun (j : Fin n) => c.encoder (W₁ ω, W₂ ω) j)) fun (ω : Ω) (j : Fin n) => Y₁s j ω) :
            (mutualInfo μ W₁ fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)) i : Fin n, condMutualInfo μ (fun (ω : Ω) => c.encoder (W₁ ω, W₂ ω) i) (Y₁s i) fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₂s j, ω)

            Receiver-1 single-letterized corner bound of the BC converse: the message–output mutual information I(W₁; (W₂, Y₁ⁿ)) is bounded by the per-letter auxiliary-variable sum ∑ᵢ I(Xᵢ; Y_{1,i} | Uᵢ) with Uᵢ = (W₂, Y₂^{i-1}), Xᵢ = (encoder (W₁, W₂))ᵢ.

            Reduction: independence gives I(W₁; (W₂, Y₁ⁿ)) = I(W₁; Y₁ⁿ | W₂); data processing along W₁ → Xⁿ → Y₁ⁿ (conditioned on W₂) gives ≤ I(Xⁿ; Y₁ⁿ | W₂); then the input-level single-letterization bc_input_singleletterize closes the bound.

            @audit:ok

            Used by

              Single-letterized headline #

              theorem

              InformationTheory.Shannon.BroadcastChannel.bc_degraded_converse

              source
              {Ω : Type u_1} [MeasurableSpace Ω] {α : Type u_2} [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α] [StandardBorelSpace α] [Nonempty α] {β₁ : Type u_3} [Fintype β₁] [MeasurableSpace β₁] [MeasurableSingletonClass β₁] [StandardBorelSpace β₁] [Nonempty β₁] {β₂ : Type u_4} [Fintype β₂] [MeasurableSpace β₂] [MeasurableSingletonClass β₂] [StandardBorelSpace β₂] [Nonempty β₂] {M₁ M₂ n : } [NeZero M₁] [NeZero M₂] (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ] (W₁ : ΩFin M₁) (W₂ : ΩFin M₂) (Y₁s : Fin nΩβ₁) (Y₂s : Fin nΩβ₂) (c : BroadcastCode M₁ M₂ n α β₁ β₂) (hW₁ : Measurable W₁) (hW₂ : Measurable W₂) (hY₁s : ∀ (i : Fin n), Measurable (Y₁s i)) (hY₂s : ∀ (i : Fin n), Measurable (Y₂s i)) (hW₁_uniform : MeasureTheory.Measure.map W₁ μ = (↑(Fintype.card (Fin M₁)))⁻¹ MeasureTheory.Measure.count) (hW₂_uniform : MeasureTheory.Measure.map W₂ μ = (↑(Fintype.card (Fin M₂)))⁻¹ MeasureTheory.Measure.count) (h_indep : mutualInfo μ W₁ W₂ = 0) (h_memo : ∀ (i : Fin n), IsMarkovChain μ (fun (ω : Ω) => (W₂ ω, fun (j : { j : Fin n // j i }) => c.encoder (W₁ ω, W₂ ω) j, fun (j : { j : Fin n // j i }) => Y₁s (↑j) ω, fun (j : { j : Fin n // j i }) => Y₂s (↑j) ω)) (fun (ω : Ω) => c.encoder (W₁ ω, W₂ ω) i) (Y₁s i)) (h_deg_block : ∀ (i : Fin n), IsMarkovChain μ (Y₁s i) (fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₁s j, ω)) fun (ω : Ω) (j : Fin i) => Y₂s j, ω) (hmarkov : IsMarkovChain μ (fun (ω : Ω) => (W₂ ω, W₁ ω)) (fun (ω : Ω) => (W₂ ω, fun (j : Fin n) => c.encoder (W₁ ω, W₂ ω) j)) fun (ω : Ω) (j : Fin n) => Y₁s j ω) (hcard₁ : 2 M₁) (hcard₂ : 2 M₂) :
              InBCCapacityRegion (Real.log M₁) (Real.log M₂) ((∑ i : Fin n, condMutualInfo μ (fun (ω : Ω) => c.encoder (W₁ ω, W₂ ω) i) (Y₁s i) fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₂s j, ω)).toReal + Real.binEntropy (MeasureFano.errorProb μ W₁ (fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)) fun (p : Fin M₂ × (Fin nβ₁)) => c.decoder₁ p.2) + (MeasureFano.errorProb μ W₁ (fun (ω : Ω) => (W₂ ω, fun (i : Fin n) => Y₁s i ω)) fun (p : Fin M₂ × (Fin nβ₁)) => c.decoder₁ p.2) * Real.log (M₁ - 1)) ((∑ i : Fin n, mutualInfo μ (fun (ω : Ω) => (W₂ ω, fun (j : Fin i) => Y₂s j, ω)) (Y₂s i)).toReal + Real.binEntropy (MeasureFano.errorProb μ W₂ (fun (ω : Ω) (i : Fin n) => Y₂s i ω) c.decoder₂) + MeasureFano.errorProb μ W₂ (fun (ω : Ω) (i : Fin n) => Y₂s i ω) c.decoder₂ * Real.log (M₂ - 1))

              Single-letter outer bound for the degraded broadcast channel (Cover–Thomas): for uniform, independent messages sent over a degraded memoryless broadcast channel X → Y₁ → Y₂ and decoded per receiver, the rate pair (log |M₁|, log |M₂|) lies in the auxiliary-variable capacity region whose information bounds are the per-letter channel sums ∑ᵢ I(Xᵢ; Y_{1,i} | Uᵢ) (receiver 1) and ∑ᵢ I(Uᵢ; Y_{2,i}) (receiver 2), with Uᵢ = (W₂, Y₂^{i-1}), plus the Fano error slack.

              The degradedness and memoryless structure are preconditions (parity with the single-user channel_coding_converse_general_memoryless_pure and mac_converse). The operational instantiation — building μ from uniform messages through the encoder and the channel — is a separate wrapper, not part of this statement.

              @audit:ok

              Used by