Definitions for Exponents of quantum fixed-length pure state source coding
DefinitionQAlgorithms_Papers_Independent_Intakenext100_P20The objects the formalized statements of Exponents of quantum fixed-length pure state source coding (arXiv:quant-ph/0202002) are stated in. Each was checked against the paper by a blind read-back and a moderator.
DiscretePureSource: PDF pp.1-2: a discrete pure ensemble; its label set need not be finite. Summability and total mass one express a discrete probability distribution. The frozen Renew46.P43.PureSource is finite and injectively labelled, so it cannot represent this source domain; purity itself is imported from P08.DiscretePureSource.average: PDF p.2: the average is computed from the ensemble, never supplied freely.DiscretePureSource.wordWeight: PDF p.2: independent product probabilities at block length n.DiscretePureSource.wordState: PDF p.2: the tensor product of the actual word states.VisibleCode: PDF pp.1-2: finite nonzero memory, an arbitrary visible state map, and a CPTP decoder.BlindCode: PDF pp.1-2: a single quantum encoder fixed independently of the label.averageLoss: PDF pp.1-3: overlap loss, or exactly the square-root-overlap loss of Remark 2. The latter has no factor of two or outer square root.VisibleSequence: PDF p.2: visible code sequences, indexed by all positive block lengths.BlindSequence: PDF p.2: blind code sequences, with no oracle/label dependent encoder choice.sequenceRate: PDF p.2: limsup of log memory dimension divided by positive block length, in nats.logRate: PDF pp.2-3: -log 0 is +infinity, before taking any limit.exponentObjective: PDF pp.2-3: every exponent objective is a liminf.visibleExponent: PDF pp.2-3: visible error exponents are suprema; success exponents are infima. The feasible set uses limsup memory rate <= R.blindExponent: PDF pp.2-3: the blind analogue, optimizing over fixed CPTP encoders.sourceLossAdmissible: Section II, PDF p.2: ordinary admissibility requires error tending to zero; converse admissibility requires liminf error strictly below one. The latter is not convergence of the error and is not a limsup condition.visibleMinimumRate: Section II, PDF p.2: the infimum of limsup memory rates among actual visible code sequences satisfying the selected error criterion. Logarithms are natural; positive block lengths and memory dimensions come from VisibleSequence.blindMinimumRate: Section II, PDF p.2: the corresponding blind rate, with one CPTP encoder at each block length, fixed independently of the source word.thresholdProjection: PDF p.5: strict lower and inclusive upper threshold spectral projectors.logPowerTrace: PDF pp.3,5: psi(s) = log Tr rho^s, in natural logarithms.visibleEncoders: PDF p.5: the real convex set of all visible encoders.extremeEncoders: PDF p.5: the standard real extreme points of the visible-encoder set.decoders: PDF p.5: decoders are all CPTP maps between the full matrix algebras.dilatedDecoders: PDF p.5, (29): a finite nonzero ancillary space and a vector isometry, chosen before the input density. Its induced action is V rho V dagger.IsPositiveTracePreserving: PDF p.6 and Appendix D p.11: positive, trace-preserving complex-linear map.quantumDValues: Appendix A p.8: quantum relative entropies attained under an entropy constraint.classicalDValues: Appendix A p.8: the classical entropy-constrained value set.expNegD: Appendix B p.10: e^(-nD), with the extended boundary e^(-infinity) = 0.blockMass: Appendix B p.10: mass of the actual full isotypic block, not a highest-weight ray.eventTypes: Appendix B p.10: arbitrary simplex event, restricted to its empirical Young types.eventD: Appendix B p.10: finite event minimum, as an extended infimum; empty = +infinity.lowerPrefactor: Appendix B pp.9-10: the lower-bound polynomial, with real exponent -d(d+1)/2.
import Mathlib
import Definitions.Def_QAlgorithms_Defs_Channel
import Definitions.Def_QAlgorithms_Defs_Measurement
import Definitions.Def_QAlgorithms_Defs_ExtendedQuantumEntropy
import Definitions.Def_QAlgorithms_Defs_SchurWeylDecomposition
import Definitions.Def_QAlgorithms_Defs_GradientMethods
import Definitions.Def_QAlgorithms_Papers_Independent_Information100_P08
import Definitions.Def_QAlgorithms_Papers_Independent_Information100_P47
import Definitions.Def_QAlgorithms_Papers_Independent_Information100_P56
import Definitions.Def_QAlgorithms_Papers_Independent_Information100_P53
import Definitions.Def_QAlgorithms_Papers_Independent_Gap48_P19
import Definitions.Def_QAlgorithms_Papers_Independent_Dependency50_P28
noncomputable section
open scoped Matrix ENNReal ComplexOrder Topology
namespace QAlgorithms.Papers.Independent.Intakenext100.P20
open QAlgorithms.Papers.Independent.Information100.P08 (IsPure)
open QAlgorithms.Papers.Independent.Information100.P47 (IsProbability)
open QAlgorithms.Papers.Independent.Information100.P53 (SpectralData)
open QAlgorithms.Papers.Independent.Gap48.P19 (shannonNats)
open QAlgorithms.Papers.Independent.Dependency50.P28 (classicalD)
attribute [local instance] Classical.propDecidable
/-- PDF pp.1-2: a discrete pure ensemble; its label set need not be finite.
Summability and total mass one express a discrete probability distribution.
The frozen Renew46.P43.PureSource is finite and injectively labelled, so it
cannot represent this source domain; purity itself is imported from P08. -/
structure DiscretePureSource (L : Type*) (d : ℕ) where
dimension_pos : 0 < d
weight : L → ℝ
weight_nonneg : ∀ i, 0 ≤ weight i
weight_summable : Summable weight
weight_total : ∑' i, weight i = 1
state : L → Matrix (Fin d) (Fin d) ℂ
state_density : ∀ i, IsDensityMatrix (state i)
state_pure : ∀ i, IsPure (state i)
/-- PDF p.2: the average is computed from the ensemble, never supplied freely. -/
def DiscretePureSource.average {L : Type*} {d : ℕ} (S : DiscretePureSource L d) :
Matrix (Fin d) (Fin d) ℂ :=
∑' i, (S.weight i : ℂ) • S.state i
/-- PDF p.2: independent product probabilities at block length n. -/
def DiscretePureSource.wordWeight {L : Type*} {d : ℕ} (S : DiscretePureSource L d)
(n : ℕ) (w : Fin n → L) : ℝ :=
∏ j, S.weight (w j)
/-- PDF p.2: the tensor product of the actual word states. -/
def DiscretePureSource.wordState {L : Type*} {d : ℕ} (S : DiscretePureSource L d)
(n : ℕ) (w : Fin n → L) : Matrix (Fin n → Fin d) (Fin n → Fin d) ℂ :=
Matrix.of fun x y => ∏ j, S.state (w j) (x j) (y j)
/-- PDF pp.1-2: finite nonzero memory, an arbitrary visible state map, and a CPTP decoder. -/
structure VisibleCode (L I : Type*) [Fintype I] [DecidableEq I] where
memory : ℕ
memory_pos : 0 < memory
encode : L → Matrix (Fin memory) (Fin memory) ℂ
encode_density : ∀ i, IsDensityMatrix (encode i)
decode : Superop (Fin memory) I
decode_channel : IsChannel decode
/-- PDF pp.1-2: a single quantum encoder fixed independently of the label. -/
structure BlindCode (I : Type*) [Fintype I] [DecidableEq I] where
memory : ℕ
memory_pos : 0 < memory
encode : Superop I (Fin memory)
encode_channel : IsChannel encode
decode : Superop (Fin memory) I
decode_channel : IsChannel decode
/-- PDF pp.1-3: overlap loss, or exactly the square-root-overlap loss of Remark 2.
The latter has no factor of two or outer square root. -/
def averageLoss {L I : Type*} [Fintype I] (p : L → ℝ)
(rho output : L → Matrix I I ℂ) (bures : Bool) : ℝ :=
∑' i, p i * (if bures then 1 - Real.sqrt ((output i * rho i).trace.re)
else 1 - (output i * rho i).trace.re)
/-- PDF p.2: visible code sequences, indexed by all positive block lengths. -/
abbrev VisibleSequence (L : Type*) (d : ℕ) :=
(t : ℕ) → VisibleCode (Fin (t + 1) → L) (Fin (t + 1) → Fin d)
/-- PDF p.2: blind code sequences, with no oracle/label dependent encoder choice. -/
abbrev BlindSequence (d : ℕ) :=
(t : ℕ) → BlindCode (Fin (t + 1) → Fin d)
/-- PDF p.2: limsup of log memory dimension divided by positive block length, in nats. -/
def sequenceRate (memory : ℕ → ℕ) : EReal :=
Filter.limsup (fun t : ℕ =>
((Real.log (memory t : ℝ) / (t + 1 : ℕ) : ℝ) : EReal)) Filter.atTop
/-- PDF pp.2-3: -log 0 is +infinity, before taking any limit. -/
def logRate (q : ℝ) (n : ℕ) : EReal :=
if q = 0 then ⊤ else ((-Real.log q / (n : ℝ) : ℝ) : EReal)
/-- PDF pp.2-3: every exponent objective is a liminf. -/
def exponentObjective (loss : ℕ → ℝ) (success : Bool) : EReal :=
Filter.liminf (fun t : ℕ => logRate (if success then 1 - loss t else loss t) (t + 1))
Filter.atTop
/-- PDF pp.2-3: visible error exponents are suprema; success exponents are infima.
The feasible set uses limsup memory rate <= R. -/
def visibleExponent {L : Type*} {d : ℕ} (S : DiscretePureSource L d)
(R : ℝ) (bures success : Bool) : EReal :=
let values : Set EReal := {e | ∃ C : VisibleSequence L d,
sequenceRate (fun t => (C t).memory) ≤ (R : EReal) ∧
e = exponentObjective (fun t => averageLoss (S.wordWeight (t + 1))
(S.wordState (t + 1)) (fun w => (C t).decode ((C t).encode w)) bures) success}
if success then sInf values else sSup values
/-- PDF pp.2-3: the blind analogue, optimizing over fixed CPTP encoders. -/
def blindExponent {L : Type*} {d : ℕ} (S : DiscretePureSource L d)
(R : ℝ) (bures success : Bool) : EReal :=
let values : Set EReal := {e | ∃ C : BlindSequence d,
sequenceRate (fun t => (C t).memory) ≤ (R : EReal) ∧
e = exponentObjective (fun t => averageLoss (S.wordWeight (t + 1))
(S.wordState (t + 1))
(fun w => (C t).decode ((C t).encode (S.wordState (t + 1) w))) bures) success}
if success then sInf values else sSup values
/-- Section II, PDF p.2: ordinary admissibility requires error tending to zero;
converse admissibility requires liminf error strictly below one. The latter
is not convergence of the error and is not a limsup condition. -/
def sourceLossAdmissible (loss : ℕ → ℝ) (converse : Bool) : Prop :=
if converse then
Filter.liminf (fun t => (loss t : EReal)) Filter.atTop < (1 : EReal)
else Filter.Tendsto loss Filter.atTop (𝓝 (0 : ℝ))
/-- Section II, PDF p.2: the infimum of limsup memory rates among actual visible
code sequences satisfying the selected error criterion. Logarithms are natural;
positive block lengths and memory dimensions come from VisibleSequence. -/
def visibleMinimumRate {L : Type*} {d : ℕ} (S : DiscretePureSource L d)
(converse : Bool) : EReal :=
sInf {r | ∃ C : VisibleSequence L d,
sourceLossAdmissible (fun t => averageLoss (S.wordWeight (t + 1))
(S.wordState (t + 1)) (fun w => (C t).decode ((C t).encode w)) false) converse ∧
r = sequenceRate (fun t => (C t).memory)}
/-- Section II, PDF p.2: the corresponding blind rate, with one CPTP encoder
at each block length, fixed independently of the source word. -/
def blindMinimumRate {L : Type*} {d : ℕ} (S : DiscretePureSource L d)
(converse : Bool) : EReal :=
sInf {r | ∃ C : BlindSequence d,
sourceLossAdmissible (fun t => averageLoss (S.wordWeight (t + 1))
(S.wordState (t + 1))
(fun w => (C t).decode ((C t).encode (S.wordState (t + 1) w))) false) converse ∧
r = sequenceRate (fun t => (C t).memory)}
/-- PDF p.5: strict lower and inclusive upper threshold spectral projectors. -/
def thresholdProjection {d : ℕ} (rho : Matrix (Fin d) (Fin d) ℂ)
(lambda : ℝ) (upper : Bool) : Matrix (Fin d) (Fin d) ℂ :=
cfc (fun x : ℝ => if upper then (if Real.exp lambda ≤ x then 1 else 0)
else (if x < Real.exp lambda then 1 else 0)) rho
/-- PDF pp.3,5: psi(s) = log Tr rho^s, in natural logarithms. -/
def logPowerTrace {d : ℕ} (rho : Matrix (Fin d) (Fin d) ℂ) (s : ℝ) : ℝ :=
Real.log ((cfc (fun x : ℝ => Real.rpow x s) rho).trace.re)
/-- PDF p.5: the real convex set of all visible encoders. -/
def visibleEncoders (L : Type*) (m : ℕ) : Set (L → Matrix (Fin m) (Fin m) ℂ) :=
{F | ∀ i, IsDensityMatrix (F i)}
/-- PDF p.5: the standard real extreme points of the visible-encoder set. -/
def extremeEncoders (L : Type*) (m : ℕ) : Set (L → Matrix (Fin m) (Fin m) ℂ) :=
(visibleEncoders L m).extremePoints ℝ
/-- PDF p.5: decoders are all CPTP maps between the full matrix algebras. -/
def decoders (m d : ℕ) : Set (Superop (Fin m) (Fin d)) :=
{D | IsChannel D}
/-- PDF p.5, (29): a finite nonzero ancillary space and a vector isometry,
chosen before the input density. Its induced action is V rho V dagger. -/
def dilatedDecoders (m d : ℕ) : Set (Superop (Fin m) (Fin d)) :=
{D | D ∈ decoders m d ∧ ∃ k : ℕ, 0 < k ∧
∃ V : Matrix (Fin d × Fin k) (Fin m) ℂ,
Vᴴ * V = 1 ∧ ∀ rho, D rho = traceRight (V * rho * Vᴴ)}
/-- PDF p.6 and Appendix D p.11: positive, trace-preserving complex-linear map. -/
def IsPositiveTracePreserving {m d : ℕ}
(D : Matrix (Fin m) (Fin m) ℂ →ₗ[ℂ] Matrix (Fin d) (Fin d) ℂ) : Prop :=
(∀ A, A.PosSemidef → (D A).PosSemidef) ∧ ∀ A, (D A).trace = A.trace
/-- Appendix A p.8: quantum relative entropies attained under an entropy constraint. -/
def quantumDValues {d : ℕ} (rho : {M : Matrix (Fin d) (Fin d) ℂ // IsDensityMatrix M})
(condition : ℝ → Prop) : Set ℝ≥0∞ :=
{v | ∃ sigma : {M : Matrix (Fin d) (Fin d) ℂ // IsDensityMatrix M},
condition (QAlgorithms.Papers.Independent.Information100.P56.entropy sigma.val) ∧
v = QuantumLoss.umegakiEntropy sigma.val rho.val sigma.property rho.property}
/-- Appendix A p.8: the classical entropy-constrained value set. -/
def classicalDValues {d : ℕ} (a : Fin d → ℝ) (condition : ℝ → Prop) : Set ℝ≥0∞ :=
{v | ∃ b : Fin d → ℝ, IsProbability b ∧ condition (shannonNats b) ∧ v = (classicalD (.finite 1 (by norm_num)) b a).toENNReal}
/-- Appendix B p.10: e^(-nD), with the extended boundary e^(-infinity) = 0. -/
def expNegD (n : ℕ) (D : ℝ≥0∞) : ℝ :=
if D = ⊤ then 0 else Real.exp (-(n : ℝ) * D.toReal)
/-- Appendix B p.10: mass of the actual full isotypic block, not a highest-weight ray. -/
def blockMass {d n : ℕ} (rho : Matrix (Fin d) (Fin d) ℂ)
(shape : Schur.Partition d n) : ℝ :=
(Schur.isotypicProjector shape * piKron n rho).trace.re
/-- Appendix B p.10: arbitrary simplex event, restricted to its empirical Young types. -/
def eventTypes {d n : ℕ} (hd : 0 < d) (hn : 0 < n)
(A : Set (Fin d → ℝ)) : Finset (Schur.Partition d n) :=
Finset.univ.filter fun shape => Schur.normalizedRows hd hn shape ∈ A
/-- Appendix B p.10: finite event minimum, as an extended infimum; empty = +infinity. -/
def eventD {d n : ℕ} (hd : 0 < d) (hn : 0 < n)
(a : Fin d → ℝ) (A : Set (Fin d → ℝ)) : ℝ≥0∞ :=
⨅ shape : {shape : Schur.Partition d n // shape ∈ eventTypes hd hn A},
(classicalD (.finite 1 (by norm_num)) (Schur.normalizedRows hd hn shape.val) a).toENNReal
/-- Appendix B pp.9-10: the lower-bound polynomial, with real exponent -d(d+1)/2. -/
def lowerPrefactor (d n : ℕ) : ℝ :=
Real.rpow (n + d : ℝ) (-((d : ℝ) * (d + 1)) / 2)
-- Small definitional sanity checks: the zero-copy extension is never used as a code.
example {L : Type*} {d : ℕ} (S : DiscretePureSource L d) (w : Fin 0 → L) :
S.wordWeight 0 w = 1 := by simp [DiscretePureSource.wordWeight]
example (n : ℕ) : logRate 0 n = ⊤ := by simp [logRate]
example : shannonNats (fun _ : Fin 1 => (1 : ℝ)) = 0 := by simp [shannonNats]
example {d : ℕ} : (classicalD (.finite 1 (by norm_num)) (fun _ : Fin d => 0) (fun _ => 0)).toENNReal = 0 := by
simp [classicalD, EReal.toENNReal]
example (n : ℕ) : expNegD n ⊤ = 0 := by simp [expNegD]
example {d n : ℕ} (hd : 0 < d) (hn : 0 < n) :
eventTypes hd hn (∅ : Set (Fin d → ℝ)) = ∅ := by simp [eventTypes]
example {d n : ℕ} (hd : 0 < d) (hn : 0 < n) (a : Fin d → ℝ) :
eventD hd hn a ∅ = ⊤ := by simp [eventD, eventTypes]
example (m : ℕ) : visibleEncoders Empty m = Set.univ := by
ext F
simp [visibleEncoders]
-- Further sanity checks for the local source, code, loss, and shannonNats interfaces.
example {I : Type} [Fintype I] (v : EuclideanSpace ℂ I) (hv : ‖v‖ = 1) :
IsPure (pureDensity v) := ⟨v, hv, rfl⟩
example {d : ℕ} (S : DiscretePureSource (Fin 1) d) :
S.average = (S.weight 0 : ℂ) • S.state 0 := by simp [DiscretePureSource.average]
example {L : Type*} {d : ℕ} (S : DiscretePureSource L d) (w : Fin 1 → L)
(x y : Fin 1 → Fin d) : S.wordState 1 w x y = S.state (w 0) (x 0) (y 0) := by
simp [DiscretePureSource.wordState]
example {L I : Type*} [Fintype I] [DecidableEq I] (C : VisibleCode L I) (i : L) :
IsDensityMatrix (C.encode i) := C.encode_density i
example {I : Type*} [Fintype I] [DecidableEq I] (C : BlindCode I) :
IsChannel C.encode := C.encode_channel
example {L I : Type*} [Fintype I] (p : L → ℝ) (rho : L → Matrix I I ℂ) :
averageLoss p rho (fun _ => 0) false = ∑' i, p i := by simp [averageLoss]
example : sequenceRate (fun _ => 1) = 0 := by simp [sequenceRate]
example (n : ℕ) : logRate 1 n = 0 := by simp [logRate]
example : exponentObjective (fun _ => 0) false = ⊤ := by
simp [exponentObjective, logRate]
example {d : ℕ} (rho : Matrix (Fin d) (Fin d) ℂ) :
thresholdProjection rho 0 true = cfc (fun x : ℝ => if 1 ≤ x then 1 else 0) rho := by
simp [thresholdProjection]
example (s : ℝ) : logPowerTrace (1 : Matrix (Fin 1) (Fin 1) ℂ) s = 0 := by
simp [logPowerTrace, cfc_one]
example (L : Type*) (m : ℕ) :
extremeEncoders L m = (visibleEncoders L m).extremePoints ℝ := rfl
example (m d : ℕ) : dilatedDecoders m d ⊆ decoders m d := fun _ h => h.1
example (d : ℕ) : IsPositiveTracePreserving
(LinearMap.id : Matrix (Fin d) (Fin d) ℂ →ₗ[ℂ] Matrix (Fin d) (Fin d) ℂ) :=
⟨fun _ h => h, fun _ => rfl⟩
example : IsProbability (fun _ : Fin 1 => (1 : ℝ)) := ⟨by simp, by simp⟩
example : QAlgorithms.Papers.Independent.Information100.P56.entropy (1 : Matrix (Fin 1) (Fin 1) ℂ) = 0 := by
simp [QAlgorithms.Papers.Independent.Information100.P56.entropy, cfc_one]
example : (classicalD (.finite 1 (by norm_num)) (fun _ : Fin 1 => 1) (fun _ => 0)).toENNReal = ⊤ := by
simp [classicalD, EReal.toENNReal]
example (n : ℕ) : expNegD n 0 = 1 := by simp [expNegD]
example : lowerPrefactor 1 1 = (1 / 2 : ℝ) := by
norm_num [lowerPrefactor, Real.rpow_neg_one]
-- The new rate criteria accept exact coding and reject perpetual unit error.
example : sourceLossAdmissible (fun _ => 0) false := by
simp [sourceLossAdmissible]
example : sourceLossAdmissible (fun _ => 0) true := by
simp [sourceLossAdmissible]
example : ¬ sourceLossAdmissible (fun _ => 1) true := by
simp [sourceLossAdmissible]
end QAlgorithms.Papers.Independent.Intakenext100.P20
Read-back
What the Lean code literally says, in plain math · gpt-6.1-sol
QAlgorithms.Papers.Independent.Intakenext100.P20.BlindCode
For any finite type equipped with decidable equality, a blind code consists of a natural number , an encoding function from complex matrices indexed by to complex matrices, and a decoding function in the reverse direction. Both functions must have finite Kraus representations: there exist natural numbers , matrices , and matrices , such that
for all input matrices . An empty is allowed as a parameter, but then no such decoder exists because .
QAlgorithms.Papers.Independent.Intakenext100.P20.BlindSequence
For any natural number , a blind sequence assigns to every natural number a blind code on matrices indexed by words of length over . Each code has a positive memory dimension , an encoder to matrices, and a decoder back to the word-indexed matrices; each map has a finite Kraus representation with equal to the identity on that map’s input space. No relation between codes at different is imposed. Only positive word lengths occur, and makes the required decoders impossible.
QAlgorithms.Papers.Independent.Intakenext100.P20.DiscretePureSource.average
For any label type , natural number , and source with , nonnegative summable weights totaling , and positive semidefinite trace-one matrices for unit vectors , its average is the complex matrix
Here the weights act by scalar multiplication, and the sum is the unconditional matrix-valued sum over all labels; the total-sum operation returns zero if its summand family is not summable.
QAlgorithms.Papers.Independent.Intakenext100.P20.DiscretePureSource
For an arbitrary type of labels and a natural number , a discrete pure source consists of a proof that , weights for every satisfying , summability of the family , and , together with complex matrices for every label. Each is positive semidefinite with trace , and for each there exists a vector with such that . These state conditions apply even to labels of weight zero. No finiteness or countability assumption is imposed on ; an empty cannot satisfy the weight-total condition.
QAlgorithms.Papers.Independent.Intakenext100.P20.DiscretePureSource.wordState
For any label type , natural number , and source having , nonnegative summable weights totaling , and positive semidefinite trace-one matrices with , the state assigned to a word , for any natural number , is the matrix indexed by functions whose entries are
Thus this definition is the entrywise formula for the ordered tensor product of the selected matrices. For , its index set is a singleton and its sole entry is .
QAlgorithms.Papers.Independent.Intakenext100.P20.DiscretePureSource.wordWeight
For any label type , natural number , and source having , nonnegative summable weights totaling , and a pure density matrix at every label, the weight of a word , for any natural number , is
A pure density matrix here is a matrix for a unit vector , and is required to be positive semidefinite with trace . The definition includes : there is one empty word, and its weight is the empty product .
QAlgorithms.Papers.Independent.Intakenext100.P20.IsPositiveTracePreserving
For arbitrary natural numbers and a complex-linear map , this predicate means that is positive semidefinite whenever is positive semidefinite, and that for every complex matrix . The trace equality is equality of complex numbers and applies to all matrices. Zero dimensions are permitted; no complete-positivity condition is included.
QAlgorithms.Papers.Independent.Intakenext100.P20.VisibleCode
For arbitrary types and , with finite and equipped with decidable equality, a visible code consists of a natural number , an encoding assignment from to complex matrices, and a decoding function from complex matrices to complex matrices indexed by . Every must be positive semidefinite with trace . The decoder must admit a finite Kraus representation: there exist a natural number and matrices , for , such that
No finiteness assumption is imposed on . Although the parameters allow to be empty, the decoder condition cannot then hold because .
QAlgorithms.Papers.Independent.Intakenext100.P20.VisibleSequence
For an arbitrary label type and natural number , a visible sequence assigns to every natural number a visible code whose labels are words of length over and whose output matrices are indexed by words of length over . Explicitly, each code has a positive memory dimension , assigns a positive semidefinite trace-one matrix to every label word, and has a decoder of the form , where is a natural number and . No relation between different values of is required. The sequence begins with length-one words, and if , its required decoders cannot exist.
QAlgorithms.Papers.Independent.Intakenext100.P20.averageLoss
For arbitrary types and finite , any real-valued function , any two families of complex matrices indexed by , and any Boolean , define . The average loss is
There are no assumptions that the weights are nonnegative or normalized, that either matrix family consists of density matrices, or that the summand family is summable. The real square root is zero on nonpositive inputs, and the unconditional sum is defined to be zero when its summand family is not summable.
QAlgorithms.Papers.Independent.Intakenext100.P20.blindExponent
For any label type , natural number , source , real number , and Boolean flags and , this defines an extended real number using sequences of blind codes. The source includes , nonnegative summable weights with , and positive semidefinite trace-one matrices for unit vectors ; need not be finite or countable. At each index , put . A code chooses a positive memory dimension , an encoding map from matrices indexed by to matrices, and a decoding map in the opposite direction. Both maps must have finite Kraus representations with on their respective input spaces. For a word , define , , and . The loss is
Consider precisely those code sequences for which . Each contributes , where if , and otherwise; , while for , using natural logarithms. The definition takes the infimum of the contributed exponents when , and their supremum otherwise. An empty collection therefore yields or , respectively. Only positive block lengths occur.
QAlgorithms.Papers.Independent.Intakenext100.P20.blindMinimumRate
Let be any type, , and a source consisting of , nonnegative summable weights with , and positive semidefinite trace-one matrices , each of the form for a unit vector . For a Boolean parameter , this definition is the extended-real infimum over rates of blind code sequences. At each , with , such a code has a positive integer memory dimension , an encoding channel from matrices on to memory matrices, and a decoding channel in the opposite direction. Each channel is required to have a finite Kraus representation with . For , set
The rate is in the extended reals, with the natural logarithm. The infimum ranges over sequences with if , and with extended-real if . The loss contains no square root, every block length is positive, and the infimum of an empty set of admissible rates is .
QAlgorithms.Papers.Independent.Intakenext100.P20.blockMass
For any natural numbers , any complex matrix , and any finite Young diagram with cells and at most rows, this defines the real number
Here the tensor coordinates are words , with , and when , and otherwise. To define the remaining quantities, use the fixed chosen bijection between the cells of and ; let consist respectively of permutations preserving the row and the column of every numbered cell. Define the matrix on permutation coordinates by
let be its range, and let be the orthogonal projection onto that range. Then , where . There is no positivity or trace assumption on . Zero values of are permitted whenever such a diagram exists; for , the tensor products are empty products and the defined number is .
QAlgorithms.Papers.Independent.Intakenext100.P20.classicalDValues
For any natural number , arbitrary real vector , and predicate on real numbers, this defines a set of extended nonnegative real numbers. Choose a vector with , , and , using natural logarithms and the total convention . If every index with also has , the contributed value is
otherwise the contributed value is . The maximum with zero comes from converting the extended real divergence to an extended nonnegative real number. No nonnegativity or normalization condition is imposed on , and indices with contribute zero regardless of . If , or if no admissible satisfies , the set is empty.
QAlgorithms.Papers.Independent.Intakenext100.P20.decoders
For arbitrary natural numbers , this defines the set of functions admitting a finite Kraus representation: there must exist a natural number and complex matrices , indexed by , such that
The representation is required on all matrices, rather than only density matrices. Zero dimensions and are permitted; the completeness equation then determines whether such a representation exists.
QAlgorithms.Papers.Independent.Intakenext100.P20.dilatedDecoders
For arbitrary natural numbers , this defines the set of functions satisfying both of the following requirements: has a finite Kraus representation , with complex matrices and ; and there exist a positive natural number and a complex matrix , whose rows are indexed by pairs , such that and
Thus the second requirement explicitly traces out the -dimensional factor. No positivity assumption on is imposed. The dimensions may be zero, while must be strictly positive.
QAlgorithms.Papers.Independent.Intakenext100.P20.eventD
For any positive natural numbers , with the supplied proofs of positivity, any real vector , and any set , this defines an element of by taking the infimum over all Young diagrams with cells and at most rows whose normalized row vector belongs to . The quantity assigned to each such diagram is
The logarithm is natural, and coordinates with contribute . No nonnegativity or normalization assumption is imposed on ; the maximum with records the conversion from extended real values to extended nonnegative real values. If there are no qualifying diagrams, the infimum is .
QAlgorithms.Papers.Independent.Intakenext100.P20.eventTypes
For any positive natural numbers , with the supplied proofs of their positivity, and any set , this defines the finite set of all Young diagrams having exactly cells and at most rows for which
where is the length of row , taken as for rows beyond the diagram. The set is arbitrary, including the empty set, and the resulting finite set may be empty.
QAlgorithms.Papers.Independent.Intakenext100.P20.expNegD
For every natural number , including zero, and every extended nonnegative real number , this defines a real number equal to when , and equal to when is finite, using its real value in the latter expression. Consequently, gives for every finite but gives for ; gives for every .
QAlgorithms.Papers.Independent.Intakenext100.P20.exponentObjective
For any real-valued sequence and Boolean , put when , and when . The exponent objective is
taken in the extended reals, with each finite branch computed in . No bounds on the loss sequence are assumed, so may be negative or exceed ; for negative , the real logarithm equals . All denominators are positive.
QAlgorithms.Papers.Independent.Intakenext100.P20.extremeEncoders
For any type and natural number , this defines the real extreme points of the set of functions whose values are positive semidefinite matrices of trace . Explicitly, belongs to this set exactly when all its values satisfy those density conditions and, whenever also satisfy them and for a real , one has , with the combination taken pointwise. No finiteness assumption on is imposed. For empty , the unique function is an extreme point; for nonempty and , there are none.
QAlgorithms.Papers.Independent.Intakenext100.P20.logPowerTrace
For every natural number , arbitrary complex matrix , and real exponent , this defines
where uses the total real functional calculus and is the total real power function. No density, positivity, Hermitian, or nonzero-trace condition is assumed. For Hermitian , this applies that scalar power function to its eigenvalues; outside the self-adjoint domain the functional calculus returns zero. The logarithm is the total real natural logarithm, so a zero argument gives , and a negative argument is evaluated as the logarithm of its absolute value. In particular, is allowed and gives .
QAlgorithms.Papers.Independent.Intakenext100.P20.logRate
For any real number and natural number , the logarithmic rate is the extended real number
with the second branch evaluated in before embedding in the extended reals. No positivity or probability bound is imposed on , and is included. The real logarithm satisfies for negative , and division by zero in returns zero; consequently, at the value is zero for , while it remains for .
QAlgorithms.Papers.Independent.Intakenext100.P20.lowerPrefactor
For any natural numbers , this defines the real number
using real exponentiation after interpreting as a real number. No positivity assumptions are required. In particular, gives for every , including , where the expression uses the convention .
QAlgorithms.Papers.Independent.Intakenext100.P20.quantumDValues
For a natural number , a complex matrix supplied with the requirements that it be positive semidefinite and have trace , and any predicate on real numbers, this defines the set of extended nonnegative real numbers obtained as follows. Choose any positive semidefinite trace-one matrix such that
where the logarithm is natural and is evaluated by real functional calculus. If , the corresponding value is
regarded as an extended nonnegative real number; otherwise it is . Here also uses real functional calculus, including its total scalar convention . The order of the arguments is relative to the fixed . The set is empty if no satisfies ; for , the required input density matrix cannot exist.
QAlgorithms.Papers.Independent.Intakenext100.P20.sequenceRate
For any function , its sequence rate is the extended real number
where each quotient is first evaluated in and then embedded in the extended reals. The logarithm is the natural logarithm, and no positivity assumption on is required: the real logarithm used here has , so an index with contributes zero. The denominator is always positive.
QAlgorithms.Papers.Independent.Intakenext100.P20.sourceLossAdmissible
For any real sequence and Boolean parameter , this predicate means
The lower limit in the first branch is taken in the extended real numbers, after embedding each into them. No nonnegativity, upper bound, or convergence assumption is imposed on ; in particular, the first branch permits a lower limit of .
QAlgorithms.Papers.Independent.Intakenext100.P20.thresholdProjection
For every natural number , arbitrary complex matrix , real threshold parameter , and Boolean , this defines the real functional calculus of with the scalar function
Thus, for Hermitian , it is the spectral projection onto eigenvalues at least when is true, and onto eigenvalues strictly below otherwise; equality belongs to the upper branch. No positivity, trace, or Hermitian hypothesis is required: the total real functional calculus returns zero outside its self-adjoint domain. The definition also permits , giving the empty matrix.
QAlgorithms.Papers.Independent.Intakenext100.P20.visibleEncoders
For any type and natural number , this defines the set of all functions such that, for every , is positive semidefinite and . There is no finiteness assumption on , nor any further condition on the assignment . If is empty the condition is vacuous; if and is nonempty, the set is empty because an empty matrix has trace zero.
QAlgorithms.Papers.Independent.Intakenext100.P20.visibleExponent
For any type of labels , natural number , source , real number , and Boolean flags and , this defines an extended real number as follows. The source supplies , nonnegative summable weights on with , and matrices that are positive semidefinite, have trace , and each equal for some unit vector ; no finiteness or countability assumption on is imposed. For every positive block length , a visible code chooses a positive integer memory dimension , an arbitrary assignment of a density matrix on that memory to each word , and a decoding map . Each decoder has a finite Kraus representation , with , and outputs matrices indexed by . Write , let , and put . The loss at index is
Only code sequences satisfying are considered. Their exponent is , where if , and otherwise, and where and for . All logarithms here are natural logarithms. The defined value is the infimum of these exponents when , and their supremum otherwise. These are extended real infima and suprema, so an empty collection gives in the first case and in the second; zero-length blocks are never used.
QAlgorithms.Papers.Independent.Intakenext100.P20.visibleMinimumRate
Let be any type, , and a source consisting of , nonnegative summable weights with , and matrices that are positive semidefinite, have trace , and each equal for some unit vector . For a Boolean parameter , this definition takes the extended-real infimum of the rates of the following visible code sequences. At every , put ; the code has a positive integer memory dimension , assigns a memory density matrix to every label word , and has a decoding channel from memory matrices to matrices on . Here a density matrix means a positive semidefinite matrix of trace , and a channel means a map admitting a finite representation with . Define
The code's rate is , using the natural logarithm and taking the upper limit in the extended reals. The infimum includes precisely those code sequences for which when , or in the extended reals when . The loss uses the displayed trace overlap without a square root. All code block lengths are positive, since they are ; if the set of admissible rates is empty, its extended-real infimum is .
Confirmed by the mission captain (proposal self-audit).
Confirmed by the moderator at approval.