InformationTheory

InformationTheory.Shannon.MultipleAccess.TimeSharingConverse.Bridge

source

Multiple access channel — time-sharing converse, geometric gateway and measure bridge #

The convex-geometry gateway mac_avgPentagon_mem_convexHull (an achievable pair bounded coordinate-wise by time averages of per-letter pentagons lies in the convex hull of their union), together with the measure-theoretic bridge feeding it: pentagon well-formedness for the product input, the code → ambient reduction, rate extraction, and the per-letter information transport under coordinate maps.

The model-independent half of that bridge — the Markov, memorylessness and pushforward-invariance lemmas, which mention no MAC structure — lives in ChannelCoding/CodeToAmbient.lean; what remains here is the MAC instantiation.

theorem

InformationTheory.Shannon.MAC.mac_avgPentagon_mem_convexHull

source
{n : } (hn : 0 < n) (a b c : Fin n) (h0a : ∀ (i : Fin n), 0 a i) (h0b : ∀ (i : Fin n), 0 b i) (hac : ∀ (i : Fin n), a i c i) (hbc : ∀ (i : Fin n), b i c i) (hsub : ∀ (i : Fin n), c i a i + b i) {R₁ R₂ : } (hR₁ : 0 R₁) (hR₂ : 0 R₂) (h1 : R₁ (∑ i : Fin n, a i) / n) (h2 : R₂ (∑ i : Fin n, b i) / n) (hs : R₁ + R₂ (∑ i : Fin n, c i) / n) :
(R₁, R₂) (convexHull ) (⋃ (i : Fin n), {p : × | 0 p.1 0 p.2 p.1 a i p.2 b i p.1 + p.2 c i})

Convex-geometry gateway for the MAC time-sharing converse. If a rate pair (R₁, R₂) is bounded coordinate-wise by the time averages (∑ a)/n, (∑ b)/n and, jointly, (∑ c)/n of a family of per-letter pentagons Pᵢ = {(x,y) | 0 ≤ x ≤ aᵢ, 0 ≤ y ≤ bᵢ, x + y ≤ cᵢ}, then (R₁, R₂) lies in the convex hull of ⋃ i, Pᵢ. Requires both single-user bounds a i ≤ c i and b i ≤ c i (see the module note).

Used by

    Pentagon well-formedness for the product input #

    The convex-geometry gateway mac_avgPentagon_mem_convexHull needs the two single-user bounds a i ≤ c i and b i ≤ c i. In the MAC application these are the two information inequalities macInfo₁ ≤ macInfoBoth and macInfo₂ ≤ macInfoBoth, i.e. I(X₁; (X₂, Y)) ≤ I((X₁, X₂); Y) and I(X₂; (X₁, Y)) ≤ I((X₁, X₂); Y). Both follow from the chain rule I((X₁, X₂); Y) = I(X_j; Y) + I(X_{3-j}; Y | X_j) and nonnegativity of mutual information (finite alphabets, so no independence hypothesis is needed here).

    theorem

    InformationTheory.Shannon.MAC.mac_macInfo₁_le_macInfoBoth

    source

    Pentagon well-formedness (user 1): macInfo₁ ≤ macInfoBoth, i.e. I(X₁; (X₂, Y)) ≤ I((X₁, X₂); Y). Supplies the a i ≤ c i hypothesis of mac_avgPentagon_mem_convexHull. Proved by the chain rule I((X₂, X₁); Y) = I(X₂; Y) + I(X₁; Y | X₂) (after prodComm) and condMutualInfo_nonneg.

    Used by
      theorem

      InformationTheory.Shannon.MAC.mac_macInfo₂_le_macInfoBoth

      source

      Pentagon well-formedness (user 2): macInfo₂ ≤ macInfoBoth, i.e. I(X₂; (X₁, Y)) ≤ I((X₁, X₂); Y). Supplies the b i ≤ c i hypothesis of mac_avgPentagon_mem_convexHull. Proved by the chain rule I((X₁, X₂); Y) = I(X₁; Y) + I(X₂; Y | X₁) and condMutualInfo_nonneg.

      Used by

        Code → ambient bridge #

        mac_converse is a floating message-level statement: it takes the ambient probability space μ, the message/output projections, and all the memoryless / Markov / independence / uniformity hypotheses as preconditions. This section constructs, from a bare MACCode c and a Markov channel W, the canonical ambient measure

        macConverseAmbient c W := (uniform on Fin M₁ × Fin M₂) ⊗ₘ (per-letter product channel)

        on Ω := (Fin M₁ × Fin M₂) × (Fin n → β), reads the messages and outputs off as coordinate projections, and discharges the mac_converse hypotheses. The resulting bridge mac_converse_from_code is the true operational starting point of the converse.

        noncomputable def

        InformationTheory.Shannon.MAC.macConverseInput

        source
        (M₁ M₂ : ) :

        Uniform input law on the message pair: the product of the two uniform message laws.

        Equations
        Instances For
          Used by
            instance

            InformationTheory.Shannon.MAC.macConverseInput_isProbabilityMeasure

            source
            {M₁ M₂ : } [NeZero M₁] [NeZero M₂] :
            Used by
              noncomputable def

              InformationTheory.Shannon.MAC.macConverseKernel

              source
              {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [MeasurableSpace α₁] [MeasurableSpace α₂] [MeasurableSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) :
              ProbabilityTheory.Kernel (Fin M₁ × Fin M₂) (Fin nβ)

              Per-letter product-channel kernel: given the message pair m, the output law is the product over the n letters of the channel W applied to the encoded pair (encoder₁ m₁ i, encoder₂ m₂ i). The channel input is deterministic in the messages (through the encoders).

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

                  InformationTheory.Shannon.MAC.macConverseKernel_isMarkovKernel

                  source
                  {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [MeasurableSpace α₁] [MeasurableSpace α₂] [MeasurableSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] :
                  Used by
                    noncomputable def

                    InformationTheory.Shannon.MAC.macConverseAmbient

                    source
                    {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [MeasurableSpace α₁] [MeasurableSpace α₂] [MeasurableSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) :
                    MeasureTheory.Measure ((Fin M₁ × Fin M₂) × (Fin nβ))

                    Canonical ambient measure for the MAC converse: a uniform message pair passed through the per-letter product channel.

                    Equations
                    Instances For
                      Used by
                        instance

                        InformationTheory.Shannon.MAC.macConverseAmbient_isProbabilityMeasure

                        source
                        {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [MeasurableSpace α₁] [MeasurableSpace α₂] [MeasurableSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                        Used by
                          def

                          InformationTheory.Shannon.MAC.macConverseMsg₁

                          source
                          {β : Type u_3} {M₁ M₂ n : } :
                          (Fin M₁ × Fin M₂) × (Fin nβ)Fin M₁

                          Message-1 projection ω ↦ ω.1.1.

                          Equations
                          Instances For
                            Used by
                              def

                              InformationTheory.Shannon.MAC.macConverseMsg₂

                              source
                              {β : Type u_3} {M₁ M₂ n : } :
                              (Fin M₁ × Fin M₂) × (Fin nβ)Fin M₂

                              Message-2 projection ω ↦ ω.1.2.

                              Equations
                              Instances For
                                Used by
                                  def

                                  InformationTheory.Shannon.MAC.macConverseYs

                                  source
                                  {β : Type u_3} {M₁ M₂ n : } :
                                  Fin n(Fin M₁ × Fin M₂) × (Fin nβ)β

                                  Output projection i ↦ ω ↦ ω.2 i.

                                  Equations
                                  Instances For
                                    Used by
                                      theorem

                                      InformationTheory.Shannon.MAC.measurable_macConverseMsg₁

                                      source
                                      {β : Type u_3} [MeasurableSpace β] {M₁ M₂ n : } :
                                      Used by
                                        theorem

                                        InformationTheory.Shannon.MAC.measurable_macConverseMsg₂

                                        source
                                        {β : Type u_3} [MeasurableSpace β] {M₁ M₂ n : } :
                                        Used by
                                          theorem

                                          InformationTheory.Shannon.MAC.measurable_macConverseYs

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

                                            InformationTheory.Shannon.MAC.macConverseInput_map_fst

                                            source
                                            Used by
                                              theorem

                                              InformationTheory.Shannon.MAC.macConverseInput_map_snd

                                              source
                                              Used by
                                                theorem

                                                InformationTheory.Shannon.MAC.macConverseInput_eq

                                                source
                                                {M₁ M₂ : } :
                                                Used by
                                                  theorem

                                                  InformationTheory.Shannon.MAC.macConverse_msgPair_eq_fst

                                                  source
                                                  {β : Type u_3} [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } :
                                                  (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) = Prod.fst

                                                  The map ω ↦ (Msg₁ ω, Msg₂ ω) is the outer first projection Prod.fst on the ambient.

                                                  Used by
                                                    theorem

                                                    InformationTheory.Shannon.MAC.macConverseMsg₁_uniform

                                                    source
                                                    {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                                                    Used by
                                                      theorem

                                                      InformationTheory.Shannon.MAC.macConverseMsg₂_uniform

                                                      source
                                                      {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                                                      Used by
                                                        theorem

                                                        InformationTheory.Shannon.MAC.macConverseMsg₁₂_uniform

                                                        source
                                                        {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                                                        Used by
                                                          noncomputable def

                                                          InformationTheory.Shannon.MAC.macConverseCodeKernel

                                                          source
                                                          {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [Fintype α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [MeasurableSpace β] {n : } (W : MACChannel α₁ α₂ β) :
                                                          ProbabilityTheory.Kernel ((Fin nα₁) × (Fin nα₂)) (Fin nβ)

                                                          Codeword → output block kernel: given an encoded input-pair codeword x = (x₁, x₂), the output law is the per-letter product ∏ᵢ W (x₁ i, x₂ i) of the MAC channel.

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

                                                              InformationTheory.Shannon.MAC.macConverseCodeKernel_isMarkovKernel

                                                              source
                                                              Used by
                                                                theorem

                                                                InformationTheory.Shannon.MAC.macConverse_memorylessChannel

                                                                source
                                                                {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :

                                                                Memoryless-channel property of the constructed ambient: the per-letter output is conditionally independent of the other letters given the current input pair. @audit:ok

                                                                Used by
                                                                  theorem

                                                                  InformationTheory.Shannon.MAC.macConverse_mutualInfo_eq_zero

                                                                  source
                                                                  {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :

                                                                  The two messages are independent under the constructed ambient (uniform product input law), hence their mutual information vanishes. @audit:ok

                                                                  Used by
                                                                    theorem

                                                                    InformationTheory.Shannon.MAC.macConverse_isMarkovChain

                                                                    source
                                                                    {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                                                                    IsMarkovChain (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (fun (j : Fin n) => c.encoder₁ (macConverseMsg₁ ω) j, fun (j : Fin n) => c.encoder₂ (macConverseMsg₂ ω) j)) fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (j : Fin n) => macConverseYs j ω

                                                                    Markov chain (messages) → (encoded inputs) → (outputs) for the constructed ambient. @audit:ok

                                                                    Used by
                                                                      theorem

                                                                      InformationTheory.Shannon.MAC.mac_converse_from_code

                                                                      source
                                                                      {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } [NeZero M₁] [NeZero M₂] (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (hcard₁ : 2 M₁) (hcard₂ : 2 M₂) :
                                                                      InMACCapacityRegion (Real.log M₁) (Real.log M₂) ((∑ i : Fin n, condMutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i) (macConverseYs i) fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i).toReal + Real.binEntropy (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₁ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₂ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₂ × (Fin nβ)) => (c.decoder p.2).1) + (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₁ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₂ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₂ × (Fin nβ)) => (c.decoder p.2).1) * Real.log (M₁ - 1)) ((∑ i : Fin n, condMutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i) (macConverseYs i) fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i).toReal + Real.binEntropy (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₂ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₁ × (Fin nβ)) => (c.decoder p.2).2) + (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₂ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₁ × (Fin nβ)) => (c.decoder p.2).2) * Real.log (M₂ - 1)) ((∑ i : Fin n, mutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (c.encoder₁ (macConverseMsg₁ ω) i, c.encoder₂ (macConverseMsg₂ ω) i)) (macConverseYs i)).toReal + Real.binEntropy (MeasureFano.errorProb (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (i : Fin n) => macConverseYs i ω) c.decoder) + MeasureFano.errorProb (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (i : Fin n) => macConverseYs i ω) c.decoder * Real.log (↑(M₁ * M₂) - 1))

                                                                      The MAC converse instantiated at a bare code: for any two-user MAC block code c and Markov channel W, the canonical ambient measure macConverseAmbient c W discharges every hypothesis of the floating converse mac_converse, so the rate pair (log M₁, log M₂) lies in the corner-point region determined by the per-letter conditional and joint mutual informations. The Fano slack is still carried here; it vanishes only in the n → ∞ limit. @audit:ok

                                                                      Used by
                                                                        theorem

                                                                        InformationTheory.Shannon.MAC.mac_converse_rate_extract

                                                                        source
                                                                        {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } [NeZero M₁] [NeZero M₂] (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] (hcard₁ : 2 M₁) (hcard₂ : 2 M₂) {R₁ R₂ : } (hM₁ : Real.exp (n * R₁)⌉₊ M₁) (hM₂ : Real.exp (n * R₂)⌉₊ M₂) :
                                                                        InMACCapacityRegion (n * R₁) (n * R₂) ((∑ i : Fin n, condMutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i) (macConverseYs i) fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i).toReal + Real.binEntropy (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₁ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₂ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₂ × (Fin nβ)) => (c.decoder p.2).1) + (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₁ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₂ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₂ × (Fin nβ)) => (c.decoder p.2).1) * Real.log (M₁ - 1)) ((∑ i : Fin n, condMutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i) (macConverseYs i) fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i).toReal + Real.binEntropy (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₂ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₁ × (Fin nβ)) => (c.decoder p.2).2) + (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₂ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₁ × (Fin nβ)) => (c.decoder p.2).2) * Real.log (M₂ - 1)) ((∑ i : Fin n, mutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (c.encoder₁ (macConverseMsg₁ ω) i, c.encoder₂ (macConverseMsg₂ ω) i)) (macConverseYs i)).toReal + Real.binEntropy (MeasureFano.errorProb (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (i : Fin n) => macConverseYs i ω) c.decoder) + MeasureFano.errorProb (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (i : Fin n) => macConverseYs i ω) c.decoder * Real.log (↑(M₁ * M₂) - 1))

                                                                        Finite-n rate extraction for the weak converse: for a fixed two-user block code whose message counts satisfy ⌈exp (n R₁)⌉ ≤ M₁, ⌈exp (n R₂)⌉ ≤ M₂, chaining the code→ambient converse mac_converse_from_code with n Rⱼ ≤ log Mⱼ moves the rate scaled by n inside the corner-point region determined by the per-letter conditional/joint mutual informations plus the Fano slack. The slack is still symbolic here; the Fano → 0 limit is taken in mac_timesharing_converse.

                                                                        Used by
                                                                          theorem

                                                                          InformationTheory.Shannon.MAC.mac_converse_ambient_errorProb_joint_eq

                                                                          source
                                                                          {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                                                                          MeasureFano.errorProb (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (i : Fin n) => macConverseYs i ω) c.decoder = (c.averageErrorProb W).toReal

                                                                          The ambient joint decode error under macConverseAmbient c W equals the code's average error probability: the ambient was built as uniform(messages) ⊗ per-letter product channel precisely to model uniform-message transmission, so its joint error event has probability averageErrorProb.

                                                                          Used by
                                                                            theorem

                                                                            InformationTheory.Shannon.MAC.mac_converse_ambient_errorProb_user1_le

                                                                            source
                                                                            {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                                                                            (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₁ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₂ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₂ × (Fin nβ)) => (c.decoder p.2).1) MeasureFano.errorProb (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (i : Fin n) => macConverseYs i ω) c.decoder

                                                                            The ambient user-1 marginal decode error is at most the joint decode error: the event {msg₁ mis-decoded} is contained in {message pair mis-decoded}.

                                                                            Used by
                                                                              theorem

                                                                              InformationTheory.Shannon.MAC.mac_converse_ambient_errorProb_user2_le

                                                                              source
                                                                              {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] :
                                                                              (MeasureFano.errorProb (macConverseAmbient c W) macConverseMsg₂ (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, fun (i : Fin n) => macConverseYs i ω)) fun (p : Fin M₁ × (Fin nβ)) => (c.decoder p.2).2) MeasureFano.errorProb (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (macConverseMsg₁ ω, macConverseMsg₂ ω)) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) (i : Fin n) => macConverseYs i ω) c.decoder

                                                                              The ambient user-2 marginal decode error is at most the joint decode error.

                                                                              Used by
                                                                                theorem

                                                                                InformationTheory.Shannon.MAC.macConverse_map_triple_eq

                                                                                source
                                                                                {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] (i : Fin n) :
                                                                                MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (c.encoder₁ (macConverseMsg₁ ω) i, c.encoder₂ (macConverseMsg₂ ω) i, macConverseYs i ω)) (macConverseAmbient c W) = macJointDistribution (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i) (macConverseAmbient c W)) (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i) (macConverseAmbient c W)) W

                                                                                Per-letter joint law identification: under the converse ambient macConverseAmbient c W, the joint law of the i-th per-letter triple (X₁ᵢ, X₂ᵢ, Yᵢ) equals the achievability per-coordinate joint macJointDistribution p₁ᵢ p₂ᵢ W of the product of the per-letter input marginals p₁ᵢ = μ.map X₁ᵢ, p₂ᵢ = μ.map X₂ᵢ. The two inputs are independent (functions of the independent uniform messages), and the output is conditionally W-distributed by the per-letter product-channel structure.

                                                                                Used by
                                                                                  theorem

                                                                                  InformationTheory.Shannon.MAC.mac_condMI_eq_macInfo₁_at

                                                                                  source
                                                                                  {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] (i : Fin n) :
                                                                                  (condMutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i) (macConverseYs i) fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i).toReal = macInfo₁ (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i) (macConverseAmbient c W)) (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i) (macConverseAmbient c W)) W

                                                                                  Per-letter identification of the user-1 corner information: the ambient per-letter conditional mutual information I(X₁ᵢ; Yᵢ | X₂ᵢ) equals the achievability corner information macInfo₁ of the per-letter product input. This rewrites the user-1 sum term of mac_converse_rate_extract into ∑ᵢ macInfo₁ p₁ᵢ p₂ᵢ W.

                                                                                  Used by
                                                                                    theorem

                                                                                    InformationTheory.Shannon.MAC.mac_condMI_eq_macInfo₂_at

                                                                                    source
                                                                                    {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] (i : Fin n) :
                                                                                    (condMutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i) (macConverseYs i) fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i).toReal = macInfo₂ (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i) (macConverseAmbient c W)) (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i) (macConverseAmbient c W)) W

                                                                                    Per-letter identification of the user-2 corner information: the ambient per-letter conditional mutual information I(X₂ᵢ; Yᵢ | X₁ᵢ) equals macInfo₂ of the per-letter product input.

                                                                                    Used by
                                                                                      theorem

                                                                                      InformationTheory.Shannon.MAC.mac_mutualInfo_eq_macInfoBoth_at

                                                                                      source
                                                                                      {α₁ : Type u_1} {α₂ : Type u_2} {β : Type u_3} [Fintype α₁] [DecidableEq α₁] [Nonempty α₁] [MeasurableSpace α₁] [MeasurableSingletonClass α₁] [StandardBorelSpace α₁] [Fintype α₂] [DecidableEq α₂] [Nonempty α₂] [MeasurableSpace α₂] [MeasurableSingletonClass α₂] [StandardBorelSpace α₂] [Fintype β] [DecidableEq β] [Nonempty β] [MeasurableSpace β] [MeasurableSingletonClass β] [StandardBorelSpace β] {M₁ M₂ n : } (c : MACCode M₁ M₂ n α₁ α₂ β) (W : MACChannel α₁ α₂ β) [ProbabilityTheory.IsMarkovKernel W] [NeZero M₁] [NeZero M₂] (i : Fin n) :
                                                                                      (mutualInfo (macConverseAmbient c W) (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => (c.encoder₁ (macConverseMsg₁ ω) i, c.encoder₂ (macConverseMsg₂ ω) i)) (macConverseYs i)).toReal = macInfoBoth (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₁ (macConverseMsg₁ ω) i) (macConverseAmbient c W)) (MeasureTheory.Measure.map (fun (ω : (Fin M₁ × Fin M₂) × (Fin nβ)) => c.encoder₂ (macConverseMsg₂ ω) i) (macConverseAmbient c W)) W

                                                                                      Per-letter identification of the sum-corner information: the ambient per-letter joint mutual information I((X₁ᵢ, X₂ᵢ); Yᵢ) equals macInfoBoth of the per-letter product input.

                                                                                      Used by