InformationTheory

InformationTheory.Shannon.MultipleAccess.Achievability.Codebook

source

Multiple access channel — codebook, decoder, and Bonferroni decomposition #

The two-user codebook plumbing for MAC achievability (Cover–Thomas): the codebook type, the joint-typical pair decoder, the MACCode bundle, the four-event Bonferroni decomposition of the per-pair error probability, the corner-point information quantities, and the block-law / channel-fold helpers feeding the two-codebook random-coding average.

Codebook + joint-typical pair decoder #

abbrev

InformationTheory.Shannon.MAC.MACCodebook

source
@[reducible, inline]
(M n : ) (α : Type u_5) :
Type u_5

A length-n codebook for one MAC user: a function from message indices to length-n words. Two codebooks (one per user) make up a MACCode.

Equations
Instances For
    Used by
      noncomputable def

      InformationTheory.Shannon.MAC.macJointTypicalDecoder

      source
      {Ω : Type u_1} [MeasurableSpace Ω] {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [MeasurableSpace α₁] [Fintype α₂] [MeasurableSpace α₂] [Fintype β] [MeasurableSpace β] (μ : MeasureTheory.Measure Ω) (X1s : Ωα₁) (X2s : Ωα₂) (Ys : Ωβ) {M₁ M₂ n : } (hM₁ : 0 < M₁) (hM₂ : 0 < M₂) (ε : ) (c₁ : MACCodebook M₁ n α₁) (c₂ : MACCodebook M₂ n α₂) :
      (Fin nβ)Fin M₁ × Fin M₂

      Joint-typical pair decoder. Given a received word y, returns the unique message pair (m₁, m₂) such that (c₁ m₁, c₂ m₂, y) ∈ macJointlyTypicalSet …, falling back to (⟨0, hM₁⟩, ⟨0, hM₂⟩) if either no such pair exists or it is not unique.

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

          InformationTheory.Shannon.MAC.macCodebookToCode

          source
          {Ω : Type u_1} [MeasurableSpace Ω] {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [MeasurableSpace α₁] [Fintype α₂] [MeasurableSpace α₂] [Fintype β] [MeasurableSpace β] (μ : MeasureTheory.Measure Ω) (X1s : Ωα₁) (X2s : Ωα₂) (Ys : Ωβ) {M₁ M₂ n : } (hM₁ : 0 < M₁) (hM₂ : 0 < M₂) (ε : ) (c₁ : MACCodebook M₁ n α₁) (c₂ : MACCodebook M₂ n α₂) :
          MACCode M₁ M₂ n α₁ α₂ β

          Bundle two codebooks + the joint-typical pair decoder into a MACCode.

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

              Four-event Bonferroni decomposition #

              theorem

              InformationTheory.Shannon.MAC.mac_errorProbAt_le_bonferroni4

              source
              {Ω : Type u_1} [MeasurableSpace Ω] {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [MeasurableSpace α₁] [Fintype α₂] [MeasurableSpace α₂] [Fintype β] [MeasurableSpace β] (μ : MeasureTheory.Measure Ω) (X1s : Ωα₁) (X2s : Ωα₂) (Ys : Ωβ) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] {M₁ M₂ n : } (hM₁ : 0 < M₁) (hM₂ : 0 < M₂) {ε : } (c₁ : MACCodebook M₁ n α₁) (c₂ : MACCodebook M₂ n α₂) (m₁ : Fin M₁) (m₂ : Fin M₂) :
              ((macCodebookToCode μ X1s X2s Ys hM₁ hM₂ ε c₁ c₂).errorProbAt W (m₁, m₂)).toReal (MeasureTheory.Measure.pi fun (i : Fin n) => W (c₁ m₁ i, c₂ m₂ i)).real {y : Fin nβ | (c₁ m₁, c₂ m₂, y)macJointlyTypicalSet μ X1s X2s Ys n ε} + m₁'Finset.univ.erase m₁, (MeasureTheory.Measure.pi fun (i : Fin n) => W (c₁ m₁ i, c₂ m₂ i)).real {y : Fin nβ | (c₁ m₁', c₂ m₂, y) macJointlyTypicalSet μ X1s X2s Ys n ε} + m₂'Finset.univ.erase m₂, (MeasureTheory.Measure.pi fun (i : Fin n) => W (c₁ m₁ i, c₂ m₂ i)).real {y : Fin nβ | (c₁ m₁, c₂ m₂', y) macJointlyTypicalSet μ X1s X2s Ys n ε} + pFinset.univ.erase m₁ ×ˢ Finset.univ.erase m₂, (MeasureTheory.Measure.pi fun (i : Fin n) => W (c₁ m₁ i, c₂ m₂ i)).real {y : Fin nβ | (c₁ p.1, c₂ p.2, y) macJointlyTypicalSet μ X1s X2s Ys n ε}

              Four-event Bonferroni bound for the joint-typical pair decoder: when the pair (m₁, m₂) is sent, the per-pair error probability is bounded by the four error events:

              • E0 — the correct codeword triple (c₁ m₁, c₂ m₂, y) is not jointly typical;
              • E1 — some user-1 alias m₁' ≠ m₁ (with user 2 correct) is jointly typical;
              • E2 — some user-2 alias m₂' ≠ m₂ (with user 1 correct) is jointly typical;
              • E3 — some pair (m₁', m₂') with both indices wrong is jointly typical.

              The block output law is ν = Measure.pi (i ↦ W (c₁ m₁ i, c₂ m₂ i)). This is the two-codebook / four-event generalization of the single-user errorProbAt_le_E1_plus_E2; the two-codebook averaging consumes the four terms term by term.

              Used by

                Corner-point information quantities #

                The three rate corners returned in the entropy-exponent form handed back by the independent-pair bounds macJTS_indep_prob_le_X1/_X2/_both: macInfo₁ = I(X₁; (X₂, Y)), macInfo₂ = I(X₂; (X₁, Y)), macInfoBoth = I((X₁, X₂); Y), each expressed as a difference of entropies of marginals of the per-coordinate joint law macJointDistribution p₁ p₂ W. Under the independent product input p₁ ⊗ p₂ these equal the textbook conditional informations I(X₁; Y | X₂) / I(X₂; Y | X₁) / I(X₁, X₂; Y).

                noncomputable def

                InformationTheory.Shannon.MAC.macInfo₁

                source
                {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [MeasurableSpace α₁] [Fintype α₂] [MeasurableSpace α₂] [Fintype β] [MeasurableSpace β] (p₁ : MeasureTheory.Measure α₁) (p₂ : MeasureTheory.Measure α₂) (W : MACChannel α₁ α₂ β) :

                I(X₁; (X₂, Y)) = H(X₁) + H(X₂, Y) − H(X₁, X₂, Y) for the per-coordinate joint.

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

                    InformationTheory.Shannon.MAC.macInfo₂

                    source
                    {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [MeasurableSpace α₁] [Fintype α₂] [MeasurableSpace α₂] [Fintype β] [MeasurableSpace β] (p₁ : MeasureTheory.Measure α₁) (p₂ : MeasureTheory.Measure α₂) (W : MACChannel α₁ α₂ β) :

                    I(X₂; (X₁, Y)) = H(X₂) + H(X₁, Y) − H(X₁, X₂, Y).

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

                        InformationTheory.Shannon.MAC.macInfoBoth

                        source
                        {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [MeasurableSpace α₁] [Fintype α₂] [MeasurableSpace α₂] [Fintype β] [MeasurableSpace β] (p₁ : MeasureTheory.Measure α₁) (p₂ : MeasureTheory.Measure α₂) (W : MACChannel α₁ α₂ β) :

                        I((X₁, X₂); Y) = H(X₁, X₂) + H(Y) − H(X₁, X₂, Y).

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

                            Two-codebook averaging: block-law / channel-fold helpers #

                            theorem

                            InformationTheory.Shannon.MAC.mac_prodReal_eq_slice_sum

                            source

                            Product-measure slice expansion over the first factor (finite alphabets).

                            Used by
                              theorem

                              InformationTheory.Shannon.MAC.measureReal_eq_sum_ite

                              source
                              {γ : Type u_5} [Fintype γ] [MeasurableSpace γ] [MeasurableSingletonClass γ] (μ : MeasureTheory.Measure γ) [MeasureTheory.IsProbabilityMeasure μ] (S : Set γ) :
                              μ.real S = z : γ, if z S then μ.real {z} else 0

                              A finite-alphabet measure of a set equals the indicator sum over singletons.

                              Used by
                                theorem

                                InformationTheory.Shannon.MAC.macJointDistribution_map_fst

                                source

                                The first-input marginal of the per-coordinate MAC joint law is p₁.

                                Used by
                                  theorem

                                  InformationTheory.Shannon.MAC.macJointDistribution_triple_singleton

                                  source
                                  {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (a₁ : α₁) (a₂ : α₂) (b : β) :
                                  (macJointDistribution p₁ p₂ W).real {(a₁, a₂, b)} = p₁.real {a₁} * p₂.real {a₂} * (W (a₁, a₂)).real {b}

                                  The per-coordinate MAC joint law singleton mass: ν{(a₁, a₂, b)} = p₁{a₁} · p₂{a₂} · W(a₁, a₂){b}.

                                  Used by
                                    theorem

                                    InformationTheory.Shannon.MAC.macJointDistribution_X2Y_singleton

                                    source
                                    {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (a₂ : α₂) (b : β) :
                                    (MeasureTheory.Measure.map (fun (q : α₁ × α₂ × β) => (q.2.1, q.2.2)) (macJointDistribution p₁ p₂ W)).real {(a₂, b)} = p₂.real {a₂} * a₁ : α₁, p₁.real {a₁} * (W (a₁, a₂)).real {b}

                                    The per-coordinate (X₂, Y) marginal singleton mass: ν_{X₂Y}{(a₂, b)} = p₂{a₂} · ∑_{a₁} p₁{a₁} W(a₁, a₂){b}.

                                    Used by
                                      theorem

                                      InformationTheory.Shannon.MAC.mac_block_law_X1

                                      source

                                      The X₁-block law under the MAC ambient measure equals Measure.pi p₁.

                                      Used by
                                        theorem

                                        InformationTheory.Shannon.MAC.mac_block_law_X2Y_singleton

                                        source
                                        {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (x₂ : Fin nα₂) (y : Fin nβ) :
                                        (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX2s n ω, jointRV macYs n ω)) (macAmbientMeasure p₁ p₂ W)).real {(x₂, y)} = i : Fin n, (MeasureTheory.Measure.map (fun (q : α₁ × α₂ × β) => (q.2.1, q.2.2)) (macJointDistribution p₁ p₂ W)).real {(x₂ i, y i)}

                                        The (X₂, Y)-joint-block law singleton mass factorizes over coordinates as a product of the per-coordinate (X₂, Y) marginal masses.

                                        Used by
                                          theorem

                                          InformationTheory.Shannon.MAC.mac_chan_fold_one

                                          source
                                          {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (x₂ : Fin nα₂) (y : Fin nβ) :
                                          (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX2s n ω, jointRV macYs n ω)) (macAmbientMeasure p₁ p₂ W)).real {(x₂, y)} = x₁ : Fin nα₁, (MeasureTheory.Measure.pi fun (x : Fin n) => p₁).real {x₁} * (MeasureTheory.Measure.pi fun (x : Fin n) => p₂).real {x₂} * (MeasureTheory.Measure.pi fun (i : Fin n) => W (x₁ i, x₂ i)).real {y}

                                          Pair-channel conditional-output fold-in, in singleton form: the (X₂, Y)-joint block-law mass at (x₂, y) equals the average over the true user-1 codeword x₁ ~ p₁ⁿ of the paired-channel output mass at y, weighted by the user-2 codeword mass. This is where the two-codebook averaging does its work: the true user-1 input is marginalized out of the pair channel W(·, x₂ i) to recover the conditional (X₂, Y) output law.

                                          Used by
                                            theorem

                                            InformationTheory.Shannon.MAC.mac_chan_fold_set

                                            source
                                            {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (T : Set ((Fin nα₂) × (Fin nβ))) :
                                            (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX2s n ω, jointRV macYs n ω)) (macAmbientMeasure p₁ p₂ W)).real T = x₂ : Fin nα₂, x₁ : Fin nα₁, (MeasureTheory.Measure.pi fun (x : Fin n) => p₂).real {x₂} * (MeasureTheory.Measure.pi fun (x : Fin n) => p₁).real {x₁} * (MeasureTheory.Measure.pi fun (i : Fin n) => W (x₁ i, x₂ i)).real {y : Fin nβ | (x₂, y) T}

                                            Set-level version of the conditional-output fold-in: the (X₂, Y)-joint block law of a finite set T equals the user-2-weighted average over the true user-1 codeword of the paired-channel mass of the x₂-slice of T.

                                            Used by
                                              theorem

                                              InformationTheory.Shannon.MAC.macJointDistribution_map_X2

                                              source
                                              {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] :
                                              MeasureTheory.Measure.map (fun (q : α₁ × α₂ × β) => q.2.1) (macJointDistribution p₁ p₂ W) = p₂

                                              The second-input marginal of the per-coordinate MAC joint law is p₂.

                                              Used by
                                                theorem

                                                InformationTheory.Shannon.MAC.mac_block_law_X2

                                                source

                                                The X₂-block law under the MAC ambient measure equals Measure.pi p₂.

                                                Used by
                                                  theorem

                                                  InformationTheory.Shannon.MAC.mac_block_law_triple_singleton

                                                  source
                                                  {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (x₁ : Fin nα₁) (x₂ : Fin nα₂) (y : Fin nβ) :
                                                  (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX1s n ω, jointRV macX2s n ω, jointRV macYs n ω)) (macAmbientMeasure p₁ p₂ W)).real {(x₁, x₂, y)} = i : Fin n, (macJointDistribution p₁ p₂ W).real {(x₁ i, x₂ i, y i)}

                                                  Full-triple split block-law singleton mass factorizes over coordinates as a product of the per-coordinate MAC joint masses.

                                                  Used by
                                                    theorem

                                                    InformationTheory.Shannon.MAC.mac_chan_fold_triple_set

                                                    source
                                                    {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (T : Set ((Fin nα₁) × (Fin nα₂) × (Fin nβ))) :
                                                    (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX1s n ω, jointRV macX2s n ω, jointRV macYs n ω)) (macAmbientMeasure p₁ p₂ W)).real T = x₁ : Fin nα₁, x₂ : Fin nα₂, (MeasureTheory.Measure.pi fun (x : Fin n) => p₁).real {x₁} * (MeasureTheory.Measure.pi fun (x : Fin n) => p₂).real {x₂} * (MeasureTheory.Measure.pi fun (i : Fin n) => W (x₁ i, x₂ i)).real {y : Fin nβ | (x₁, x₂, y) T}

                                                    Master pair-channel fold on the full triple: the full-triple split block law of a finite set T equals the average over the true codeword pair (x₁, x₂) ~ p₁ⁿ ⊗ p₂ⁿ of the paired-channel mass of the corresponding slice of T.

                                                    Used by
                                                      theorem

                                                      InformationTheory.Shannon.MAC.mac_chan_fold_X1Y_set

                                                      source
                                                      {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (T : Set ((Fin nα₁) × (Fin nβ))) :
                                                      (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX1s n ω, jointRV macYs n ω)) (macAmbientMeasure p₁ p₂ W)).real T = x₁ : Fin nα₁, x₂ : Fin nα₂, (MeasureTheory.Measure.pi fun (x : Fin n) => p₁).real {x₁} * (MeasureTheory.Measure.pi fun (x : Fin n) => p₂).real {x₂} * (MeasureTheory.Measure.pi fun (i : Fin n) => W (x₁ i, x₂ i)).real {y : Fin nβ | (x₁, y) T}

                                                      The (X₁, Y)-split joint block-law fold, derived from the master triple fold by projecting out X₂.

                                                      Used by
                                                        theorem

                                                        InformationTheory.Shannon.MAC.mac_chan_fold_Y_set

                                                        source
                                                        {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (T : Set (Fin nβ)) :
                                                        (MeasureTheory.Measure.map (jointRV macYs n) (macAmbientMeasure p₁ p₂ W)).real T = x₁ : Fin nα₁, x₂ : Fin nα₂, (MeasureTheory.Measure.pi fun (x : Fin n) => p₁).real {x₁} * (MeasureTheory.Measure.pi fun (x : Fin n) => p₂).real {x₂} * (MeasureTheory.Measure.pi fun (i : Fin n) => W (x₁ i, x₂ i)).real {y : Fin nβ | y T}

                                                        The Y-block-law fold, derived from the master triple fold by projecting out both inputs.

                                                        Used by
                                                          theorem

                                                          InformationTheory.Shannon.MAC.mac_block_law_X1X2_singleton

                                                          source
                                                          {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (n : ) (xa : Fin nα₁) (xb : Fin nα₂) :
                                                          (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX1s n ω, jointRV macX2s n ω)) (macAmbientMeasure p₁ p₂ W)).real {(xa, xb)} = (MeasureTheory.Measure.pi fun (x : Fin n) => p₁).real {xa} * (MeasureTheory.Measure.pi fun (x : Fin n) => p₂).real {xb}

                                                          The (X₁, X₂)-split joint block-law singleton mass equals p₁ⁿ{x₁} · p₂ⁿ{x₂}, derived from the master triple fold by projecting out the output.

                                                          Used by
                                                            theorem

                                                            InformationTheory.Shannon.MAC.macJTS_indep_prob_le_X2_split

                                                            source
                                                            {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (hp₁ : ∀ (a : α₁), 0 < p₁.real {a}) (hp₂ : ∀ (a : α₂), 0 < p₂.real {a}) (hW : ∀ (a : α₁ × α₂) (b : β), 0 < (W a).real {b}) (n : ) {ε : } ( : 0 < ε) :
                                                            ((MeasureTheory.Measure.map (jointRV macX2s n) (macAmbientMeasure p₁ p₂ W)).prod (MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX1s n ω, jointRV macYs n ω)) (macAmbientMeasure p₁ p₂ W))).real {q : (Fin nα₂) × (Fin nα₁) × (Fin nβ) | (q.2.1, q.1, q.2.2) macJointlyTypicalSet (macAmbientMeasure p₁ p₂ W) macX1s macX2s macYs n ε} Real.exp (n * (entropy (macAmbientMeasure p₁ p₂ W) (macJointSequence macX1s macX2s macYs 0) - entropy (macAmbientMeasure p₁ p₂ W) (macX2s 0) - entropy (macAmbientMeasure p₁ p₂ W) (ChannelCoding.jointSequence macX1s macYs 0) + 3 * ε))

                                                            The user-2 independent-pair bound macJTS_indep_prob_le_X2, restated over the split product X₂-block ⊗ (X₁, Y)-joint-block: the jointly typical set is described as a preimage under the reshaping (x₂, (x₁, y)) ↦ (x₁, x₂, y) instead of a reshaped product.

                                                            Used by
                                                              theorem

                                                              InformationTheory.Shannon.MAC.macJTS_indep_prob_le_both_split

                                                              source
                                                              {α₁ : Type u_2} {α₂ : Type u_3} {β : Type u_4} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] (p₁ : MeasureTheory.Measure α₁) [MeasureTheory.IsProbabilityMeasure p₁] (p₂ : MeasureTheory.Measure α₂) [MeasureTheory.IsProbabilityMeasure p₂] (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (hp₁ : ∀ (a : α₁), 0 < p₁.real {a}) (hp₂ : ∀ (a : α₂), 0 < p₂.real {a}) (hW : ∀ (a : α₁ × α₂) (b : β), 0 < (W a).real {b}) (n : ) {ε : } ( : 0 < ε) :
                                                              ((MeasureTheory.Measure.map (fun (ω : α₁ × α₂ × β) => (jointRV macX1s n ω, jointRV macX2s n ω)) (macAmbientMeasure p₁ p₂ W)).prod (MeasureTheory.Measure.map (jointRV macYs n) (macAmbientMeasure p₁ p₂ W))).real {q : ((Fin nα₁) × (Fin nα₂)) × (Fin nβ) | (q.1.1, q.1.2, q.2) macJointlyTypicalSet (macAmbientMeasure p₁ p₂ W) macX1s macX2s macYs n ε} Real.exp (n * (entropy (macAmbientMeasure p₁ p₂ W) (macJointSequence macX1s macX2s macYs 0) - entropy (macAmbientMeasure p₁ p₂ W) (ChannelCoding.jointSequence macX1s macX2s 0) - entropy (macAmbientMeasure p₁ p₂ W) (macYs 0) + 3 * ε))

                                                              The both-users independent-pair bound macJTS_indep_prob_le_both, restated over the split product (X₁, X₂)-joint-block ⊗ Y-block: the jointly typical set is described as a preimage under the reshaping ((x₁, x₂), y) ↦ (x₁, x₂, y) instead of a reshaped product.

                                                              Used by