InformationTheory

InformationTheory.Shannon.ParallelGaussian.PerCoord

source

Parallel Gaussian capacity equals the water-filling sum #

The per-coordinate water-filling reduction: the parallel Gaussian information capacity parallelGaussianCapacity P N equals the per-coordinate water-filling sum, evaluated as a sup-sandwich mirroring the single-coordinate AWGN.awgnCapacity_eq.

Main definitions #

  • miImage P N — the mutual-information image whose sSup is the capacity.
  • gaussianProductInput Q — the independent-Gaussian product input with per-coordinate power Q i, used as the achiever.
  • IsParallelGaussianPerCoordRegularity P N Q — the analytic regularity bundle the sup-sandwich consumes (boundedness, achiever MI value, correlated-input max-entropy bound), mirroring the residual hypotheses of the 1-D awgnCapacity_eq.

Main statements #

Implementation notes #

The capacity is an information capacity (a sSup of mutual information), so it is evaluated directly by le_antisymm: the achiever lower bound uses le_csSup, the upper bound uses csSup_le. The achiever MI decomposition rests on the compProd-of-Measure.pi factorization gaussianProductInput_compProd_parallelGaussianChannel_eq_pi, self-built via Measure.pi_eq and the multivariate Tonelli lemma lintegral_fin_nat_prod_eq_prod.

noncomputable def

InformationTheory.Shannon.ParallelGaussian.miImage

source
{n : } (P : ) (N : Fin nNNReal) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) :

The MI image whose sSup defines parallelGaussianCapacity.

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

      InformationTheory.Shannon.ParallelGaussian.parallelGaussianCapacity_eq_sSup_miImage

      source
      {n : } (P : ) (N : Fin nNNReal) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) :
      parallelGaussianCapacity P N h_meas h_parallel_meas = sSup (miImage P N h_meas h_parallel_meas)
      Used by

        Achiever: the independent Gaussian product input #

        noncomputable def

        InformationTheory.Shannon.ParallelGaussian.gaussianProductInput

        source
        {n : } (Q : Fin nNNReal) :

        The independent-Gaussian product input with per-coordinate power Q i.

        Equations
        Instances For
          Used by
            instance

            InformationTheory.Shannon.ParallelGaussian.gaussianProductInput.instIsProbabilityMeasure

            source
            Used by
              theorem

              InformationTheory.Shannon.ParallelGaussian.integral_sq_gaussianProductInput

              source
              {n : } (Q : Fin nNNReal) (i : Fin n) :
              (x : Fin n), x i ^ 2 gaussianProductInput Q = (Q i)

              The achiever's per-coordinate second moment: ∫ xᵢ² ∂(gaussianProductInput Q) = Q i.

              Used by
                theorem

                InformationTheory.Shannon.ParallelGaussian.gaussianProductInput_mem_constraintSet

                source
                {n : } (P : ) (Q : Fin nNNReal) (hQ : i : Fin n, (Q i) P) :

                Achiever feasibility: if ∑ᵢ Q i ≤ P then the product Gaussian input lies in parallelGaussianPowerConstraintSet P.

                @audit:ok

                Used by

                  Regularity bundle #

                  structure

                  InformationTheory.Shannon.ParallelGaussian.IsParallelGaussianPerCoordRegularity

                  source
                  {n : } (P : ) (N : Fin nNNReal) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) (Q : Fin nNNReal) :

                  The analytic regularity bundle the sup-sandwich consumes, parameterized by the achiever power split Q, mirroring the single-coordinate AWGN.awgnCapacity_eq residuals.

                  Instances For
                    Used by

                      Sup-sandwich #

                      theorem

                      InformationTheory.Shannon.ParallelGaussian.parallelGaussianCapacity_ge_sum

                      source
                      {n : } (P : ) (N : Fin nNNReal) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) (Q : Fin nNNReal) (hQ : i : Fin n, (Q i) P) (h_reg : IsParallelGaussianPerCoordRegularity P N h_meas h_parallel_meas Q) :
                      i : Fin n, 1 / 2 * Real.log (1 + (Q i) / (N i)) parallelGaussianCapacity P N h_meas h_parallel_meas

                      Lower bound (achiever). The independent Gaussian product input is feasible and achieves the per-coordinate sum, so the capacity is at least that sum.

                      Used by
                        theorem

                        InformationTheory.Shannon.ParallelGaussian.parallelGaussianCapacity_le_sum

                        source
                        {n : } (P : ) (N : Fin nNNReal) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) (Q : Fin nNNReal) (hQ : i : Fin n, (Q i) P) (ν : ) (h_opt : IsWaterFillingOptimal P N ν) (h_Q_eq : ∀ (i : Fin n), (Q i) = waterFillingPower ν N i) (h_reg : IsParallelGaussianPerCoordRegularity P N h_meas h_parallel_meas Q) :
                        parallelGaussianCapacity P N h_meas h_parallel_meas i : Fin n, 1 / 2 * Real.log (1 + (Q i) / (N i))

                        Upper bound (max-entropy and water-filling). Every constrained input has MI bounded by the water-filling sum.

                        Used by

                          max_ent via output-entropy subadditivity #

                          theorem

                          InformationTheory.Shannon.ParallelGaussian.parallelGaussian_max_ent_le_of_subadditivity

                          source
                          {n : } (μY : MeasureTheory.Measure (Fin n)) [MeasureTheory.IsProbabilityMeasure μY] [∀ (i : Fin n), MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.map (fun (z : Fin n) => z i) μY)] (miReal condTerm : ) (P' : Fin n) (N : Fin nNNReal) (h_decomp : miReal = jointDifferentialEntropyPi μY - condTerm) (h_marg_ac : ∀ (i : Fin n), (MeasureTheory.Measure.map (fun (z : Fin n) => z i) μY).AbsolutelyContinuous MeasureTheory.volume) (hμ_ac : μY.AbsolutelyContinuous MeasureTheory.volume) (h_joint_ac : μY.AbsolutelyContinuous (MeasureTheory.Measure.pi fun (i : Fin n) => MeasureTheory.Measure.map (fun (z : Fin n) => z i) μY)) (h_int_marg : ∀ (i : Fin n), MeasureTheory.Integrable (fun (z : Fin n) => Real.log ((MeasureTheory.Measure.map (fun (z : Fin n) => z i) μY).rnDeriv MeasureTheory.volume (z i)).toReal) μY) (h_int_joint : MeasureTheory.Integrable (fun (z : Fin n) => Real.log (μY.rnDeriv MeasureTheory.volume z).toReal) μY) (h_perCoord : i : Fin n, differentialEntropy (MeasureTheory.Measure.map (fun (z : Fin n) => z i) μY) - condTerm i : Fin n, 1 / 2 * Real.log (1 + P' i / (N i))) :
                          miReal i : Fin n, 1 / 2 * Real.log (1 + P' i / (N i))

                          max_ent from subadditivity. With the channel MI written as h(Yⁿ) - condTerm (h_decomp), output-entropy subadditivity h(Yⁿ) ≤ ∑ h(Yᵢ) and the per-coordinate water-filling allocation bound h_perCoord give I ≤ ∑ᵢ (1/2) log(1 + P'ᵢ/Nᵢ).

                          Used by

                            Per-coordinate reduction #

                            theorem

                            InformationTheory.Shannon.ParallelGaussian.isParallelGaussianPerCoordReduction_of_kkt

                            source
                            {n : } (P : ) (hP : 0 < P) (N : Fin (n + 1)NNReal) (hN : ∀ (i : Fin (n + 1)), (N i) 0) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) (ν : ) (h_kkt : IsWaterFillingKKT P N ν) (h_reg : IsParallelGaussianPerCoordRegularity P N h_meas h_parallel_meas fun (i : Fin (n + 1)) => (waterFillingPower ν N i).toNNReal) :
                            IsParallelGaussianPerCoordReduction P N h_meas h_parallel_meas ν

                            At a KKT water level ν (h_kkt) the capacity equals the per-coordinate water-filling sum, i.e. IsParallelGaussianPerCoordReduction P N h_meas h_parallel_meas ν holds. The analytic regularity hypotheses are bundled in IsParallelGaussianPerCoordRegularity.

                            Used by

                              Headline capacity formula #

                              theorem

                              InformationTheory.Shannon.ParallelGaussian.parallel_gaussian_capacity_formula

                              source
                              {n : } (P : ) (hP : 0 < P) (N : Fin (n + 1)NNReal) (hN : ∀ (i : Fin (n + 1)), (N i) 0) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) (ν : ) (h_kkt : IsWaterFillingKKT P N ν) (h_reg : IsParallelGaussianPerCoordRegularity P N h_meas h_parallel_meas fun (i : Fin (n + 1)) => (waterFillingPower ν N i).toNNReal) :
                              parallelGaussianCapacity P N h_meas h_parallel_meas = i : Fin (n + 1), 1 / 2 * Real.log (1 + waterFillingPower ν N i / (N i))

                              Parallel Gaussian channel capacity (water-filling). For parallel AWGN channels Y_i = X_i + Z_i, Z_i ∼ 𝒩(0, N_i) (i : Fin (n+1)) under the total power constraint ∑_i E[X_i²] ≤ P, the information capacity equals the water-filling sum

                              C = ∑_i (1/2) log(1 + max(0, ν - N_i) / N_i)

                              at the KKT water level ν. The hypotheses are the KKT budget condition h_kkt and the analytic regularity bundle h_reg; water-filling optimality is obtained internally from h_kkt rather than assumed.

                              Used by

                                Achiever mutual-information decomposition #

                                theorem

                                InformationTheory.Shannon.ParallelGaussian.lintegral_fin_nat_prod_eq_prod

                                source
                                {n : } {E : Fin nType u_1} {mE : (i : Fin n) → MeasurableSpace (E i)} (μ : (i : Fin n) → MeasureTheory.Measure (E i)) [∀ (i : Fin n), MeasureTheory.SigmaFinite (μ i)] (f : (i : Fin n) → E iENNReal) (hf : ∀ (i : Fin n), Measurable (f i)) :
                                ∫⁻ (x : (i : Fin n) → E i), i : Fin n, f i (x i) MeasureTheory.Measure.pi μ = i : Fin n, ∫⁻ (x : E i), f i x μ i

                                The ℝ≥0∞ analogue of n-variate Fubini: for a product measure Measure.pi μ over Fin n, the integral of a product of single-coordinate functions equals the product of the per-coordinate integrals (the ℝ≥0∞ form of MeasureTheory.integral_fin_nat_prod_eq_prod).

                                @audit:ok

                                Used by
                                  theorem

                                  InformationTheory.Shannon.ParallelGaussian.gaussianProductInput_compProd_parallelGaussianChannel_eq_pi

                                  source

                                  compProd-of-Measure.pi factorization. The channel joint gaussianProductInput Q ⊗ₘ parallelGaussianChannel N factors as the Measure.pi of the per-coordinate joints gaussianReal 0 (Qᵢ) ⊗ₘ awgnChannel Nᵢ, reshaped by arrowProdEquivProdArrow.

                                  @audit:ok

                                  Used by
                                    theorem

                                    InformationTheory.Shannon.ParallelGaussian.parallelGaussian_achiever_mi_eq_sum_perChannel_enn

                                    source

                                    Per-channel MI decomposition of the product achiever. The channel mutual information of the independent-Gaussian product input through the parallel Gaussian channel equals the sum of the per-coordinate single-channel mutual informations.

                                    @audit:ok

                                    Used by
                                      theorem

                                      InformationTheory.Shannon.ParallelGaussian.awgn_mutualInfoOfChannel_ne_top

                                      source

                                      AWGN single-channel mutual information is finite. The channel MI of the Gaussian input through a single AWGN channel is a finite ENNReal (≠ ⊤).

                                      The N ≠ 0 hypothesis is required: for N = 0 the channel is deterministic (W x = dirac x), the joint lives on the diagonal graph (p.prod q-null for a continuous input P ≠ 0), and klDiv = ⊤ — the claim is false there.

                                      Used by
                                        theorem

                                        InformationTheory.Shannon.ParallelGaussian.parallelGaussian_achiever_mi_eq_sum_perChannel

                                        source

                                        Per-channel MI decomposition of the product achiever, in .toReal form. The per-coordinate finiteness needed for the .toReal/ exchange requires N i ≠ 0.

                                        Used by
                                          theorem

                                          InformationTheory.Shannon.ParallelGaussian.awgn_perCoord_mi_closed_form

                                          source

                                          Per-coordinate AWGN MI closed form (all variances). For a single AWGN sub-channel, the Gaussian-input mutual information equals (1/2)·log(1 + Q/N), with no positivity hypothesis on the input variance Q. The Q = 0 branch (deterministic input gaussianReal 0 0 = dirac 0) gives MI = 0 = (1/2)·log 1 via klDiv_self.

                                          Used by
                                            theorem

                                            InformationTheory.Shannon.ParallelGaussian.parallelGaussianCapacity_achiever_mi

                                            source
                                            {n : } (Q N : Fin nNNReal) (hN : ∀ (i : Fin n), N i 0) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) :
                                            (ChannelCoding.mutualInfoOfChannel (gaussianProductInput Q) (parallelGaussianChannel N h_meas h_parallel_meas)).toReal = i : Fin n, 1 / 2 * Real.log (1 + (Q i) / (N i))

                                            The achiever MI value equals the per-coordinate water-filling sum. Inhabits the achiever_mi field of IsParallelGaussianPerCoordRegularity.

                                            Used by
                                              theorem

                                              InformationTheory.Shannon.ParallelGaussian.parallel_gaussian_capacity_formula_discharged

                                              source
                                              @[deprecated InformationTheory.Shannon.ParallelGaussian.parallel_gaussian_capacity_formula (since := "2026-05-21")]
                                              {n : } (P : ) (hP : 0 < P) (N : Fin (n + 1)NNReal) (hN : ∀ (i : Fin (n + 1)), (N i) 0) (h_meas : IsParallelAwgnChannelMeasurable N) (h_parallel_meas : IsParallelGaussianKernelMeasurable N) (ν : ) (h_kkt : IsWaterFillingKKT P N ν) (h_reg : IsParallelGaussianPerCoordRegularity P N h_meas h_parallel_meas fun (i : Fin (n + 1)) => (waterFillingPower ν N i).toNNReal) :
                                              parallelGaussianCapacity P N h_meas h_parallel_meas = i : Fin (n + 1), 1 / 2 * Real.log (1 + waterFillingPower ν N i / (N i))
                                              Used by