Definitions for On the quantum, classical and total amount of correlations in a quantum state
DefinitionQAlgorithms_Papers_Independent_Intakenext100_P47The objects the formalized statements of On the quantum, classical and total amount of correlations in a quantum state (arXiv:quant-ph/0410091) are stated in. Each was checked against the paper by a blind read-back and a moderator.
sourcePower: PDF p.2: rho tensor n in party order A^n:B^n.LocalNoise: PDF p.2: a finite probability ensemble; zero-weight entries are permitted.COLUR: PDF p.2, (2): one shared random index, with actual product unitaries.COLUR.operation: PDF p.2, (2): the channel implemented by the chosen ensemble.NoiseClass: PDF p.2: the four noise restrictions distinguished by the source.COLUR.allowed: PDF p.2: LUR independence is imposed on the implementing ensemble, not just its channel.NoiseCost: PDF pp.2--3, (4): the three ensemble noise costs.COLUR.cost: PDF pp.2--3: size and Shannon cost belong to an ensemble; exchange belongs to its channel.Decorrelates: PDF p.2, (3): approximation by a normalized product, full trace norm.Disentangles: PDF p.6, (14): closeness to an actual normalized separable state.erasureEta: PDF p.3, (5): the capped entropy correction, including the continuous value at zero.logDimension: PDF pp.3,6: fixed one-copy dimension d=d_A*d_B, independent of blocklength.totalCosts: PDF p.4: feasible noise costs at a finite block.totalBlockRate: PDF p.4: optimal finite noise per copy; n=k+1 excludes division by zero.rateLimit: PDF pp.4,7: choose liminf (optimistic) or limsup (pessimistic), before vanishing error.totalErasure: PDF p.4, Theorem II.3: operational erasure rate, independently computed from ensembles.disentanglingSizes: PDF p.7: admissible finite ensemble sizes for entanglement erasure.minimumDisentanglingSize: PDF p.7: N(n,eps), the smallest size, defined by the actual feasible channels.entanglementBlockRate: PDF p.7: normalized finite-block cost; only positive lengths enter the limit.entanglementErasure: PDF pp.7--8: optimistic/pessimistic erasure, without assuming the conjectured entropy formula.separableEntropyCosts: PDF p.6, Proposition III.1: all COLUR maps and nearby separable targets are optimized.withAncilla: PDF p.5: combine rho and an arbitrary ancillary bipartite state in party order.discountedCosts: PDF p.5: finite ancillary dimensions are varied explicitly, with their cost discounted.blockIndex: PDF pp.6--7: concatenate n successive k-copy blocks, retaining the party order.regroupedChannelPower: PDF p.7: transport the accepted tensor-power channel from copy order (AB)^n into party order A^n:B^n, on every matrix coefficient including reference blocks.schmidtKet: PDF p.8: normalized Schmidt ket in arbitrary orthonormal local frames.schmidtDiagonal: PDF p.8: the dephased Schmidt state; the output is constructed, not assumed.schmidtPhase: PDF p.8: positive phase exp(2piikj/D), identity on the unused orthogonal complement.PublicProtocol: PDF pp.5--6, Remark II.6: a finite adaptive public-instrument tree. Every outcome is public; subsequent local instruments may depend on the full transcript. All finite local dimensions, outcomes, Kraus counts, and finite numbers of rounds occur.PublicProtocol.average: PDF pp.5--6, (12)--(13): actual expected final mutual information conditional on all public messages. Zero-probability branches contribute zero, without normalization.MultiCopies: PDF p.10: party i's n-copy register.multiSourcePower: PDF p.10: independent copies of the multipartite source, regrouped by party.MultiNoise: PDF p.10: multipartite COLUR, with actual product unitaries and one shared index.MultiNoise.productUnitary: PDF p.10: the tensor-product unitary for one ensemble member.MultiNoise.operation: PDF p.10: the actual randomizing operation on every joint operator.MultiNoise.independent: PDF p.10: independent LUR choices imposed on the ensemble itself.MultiNoise.cost: PDF p.10: the same three costs, counted on a multipartite ensemble.MultiDecorrelates: PDF p.10: a fully product target, normalized at every party.reducedOn: PDF p.10: an actual partial trace onto a specified set of parties.multiInformation: PDF p.10, (16): the entropy expression, distinct from the operational erasure rate.tailInformation: PDF p.10: I(A_j : A_{j+1}...A_p), on the original tail marginal.multiCosts: PDF p.10: finite-block multipartite feasible costs.multiBlockRate: PDF p.10: normalized finite cost, with strictly positive copy count.multiErasure: PDF p.10: operational multipartite total erasure, without an entropy definition.successiveBlockOutput: PDF p.10: the same execution at arbitrary positive blocklength.
import Mathlib
import Definitions.Def_QAlgorithms_Defs_Ensemble
import Definitions.Def_QAlgorithms_Defs_Channel
import Definitions.Def_QAlgorithms_Defs_MatrixDistances
import Definitions.Def_QAlgorithms_Defs_BipartiteSeparability
import Definitions.Def_QAlgorithms_Defs_Measurement
import Definitions.Def_QAlgorithms_Papers_Independent_Gap48_P20
import Definitions.Def_QAlgorithms_Papers_Independent_Dependency50_P19
import Definitions.Def_QAlgorithms_Papers_Independent_Dependency50_P45
import Definitions.Def_QAlgorithms_Papers_Independent_Information100_P27
import Definitions.Def_QAlgorithms_Papers_Independent_Information100_P71
import Definitions.Def_QAlgorithms_Papers_Independent_Advance50_P05
/-!
Groisman--Popescu--Winter, arXiv:quant-ph/0410091v2.
All entropies are in bits; traceNorm is the full Schatten 1-norm.
Accepted frozen interfaces are imported; new operational definitions are confined to
this paper. The operational costs below contain no mutual-information formula. Finite nonzero local spaces may have unequal dimensions.
The source's conjectures, erroneous formulas, and cited background are inventoried
in HARD.md. Compilation is pending the separate mechanical handoff.
-/
noncomputable section
namespace QAlgorithms.Papers.Independent.Intakenext100.P47
open QAlgorithms Filter
open QAlgorithms.Papers.Independent.Gap48.P20 (Copies localProduct)
open QAlgorithms.Papers.Independent.Dependency50.P19 (mutualInformation first)
open QAlgorithms.Papers.Independent.Dependency50.P45 (entropyExchange)
open QAlgorithms.Papers.Independent.Information100.P27 (shannon Config)
open QAlgorithms.Papers.Independent.Information100.P71 (channelPower)
open QAlgorithms.Papers.Independent.Advance50.P05 (RectangularInstrument)
open scoped Matrix ComplexConjugate
attribute [local instance] Classical.propDecidable Classical.decEq
/-- PDF p.2: rho tensor n in party order A^n:B^n. -/
def sourcePower {A B : Type} (rho : Matrix (A × B) (A × B) ℂ) (n : ℕ) :
Matrix (Copies A n × Copies B n) (Copies A n × Copies B n) ℂ :=
fun x y => ∏ t, rho (x.1 t, x.2 t) (y.1 t, y.2 t)
/-- PDF p.2: a finite probability ensemble; zero-weight entries are permitted. -/
structure LocalNoise (A : Type) [Fintype A] where
count : ℕ
count_pos : 0 < count
weight : Fin count → ℝ
weight_nonneg : ∀ i, 0 ≤ weight i
weight_sum : ∑ i, weight i = 1
unitary : Fin count → Matrix.unitaryGroup A ℂ
/-- PDF p.2, (2): one shared random index, with actual product unitaries. -/
structure COLUR (A B : Type) [Fintype A] [Fintype B] where
count : ℕ
count_pos : 0 < count
weight : Fin count → ℝ
weight_nonneg : ∀ i, 0 ≤ weight i
weight_sum : ∑ i, weight i = 1
alice : Fin count → Matrix.unitaryGroup A ℂ
bob : Fin count → Matrix.unitaryGroup B ℂ
/-- PDF p.2, (2): the channel implemented by the chosen ensemble. -/
def COLUR.operation {A B : Type} [Fintype A] [Fintype B] (R : COLUR A B) :
Superop (A × B) (A × B) :=
fun rho => ∑ i, (R.weight i : ℂ) •
(Matrix.kronecker (R.alice i : Matrix A A ℂ) (R.bob i : Matrix B B ℂ) * rho *
(Matrix.kronecker (R.alice i : Matrix A A ℂ) (R.bob i : Matrix B B ℂ))ᴴ)
/-- PDF p.2: the four noise restrictions distinguished by the source. -/
inductive NoiseClass where
| coordinated | alice | bob | independent
deriving DecidableEq
/-- PDF p.2: LUR independence is imposed on the implementing ensemble, not just its channel. -/
def COLUR.allowed {A B : Type} [Fintype A] [Fintype B]
(R : COLUR A B) : NoiseClass → Prop
| .coordinated => True
| .alice => ∀ i, R.bob i = 1
| .bob => ∀ i, R.alice i = 1
| .independent => ∃ L : LocalNoise A, ∃ M : LocalNoise B,
∃ e : Fin R.count ≃ (Fin L.count × Fin M.count),
(∀ i, R.weight i = L.weight (e i).1 * M.weight (e i).2) ∧
(∀ i, R.alice i = L.unitary (e i).1) ∧
(∀ i, R.bob i = M.unitary (e i).2)
/-- PDF pp.2--3, (4): the three ensemble noise costs. -/
inductive NoiseCost where
| size | entropy | exchange
deriving DecidableEq
/-- PDF pp.2--3: size and Shannon cost belong to an ensemble; exchange belongs to its channel. -/
def COLUR.cost {A B : Type} [Fintype A] [Fintype B] (R : COLUR A B)
(rho : Matrix (A × B) (A × B) ℂ) : NoiseCost → ℝ
| .size => Real.logb 2 R.count
| .entropy => shannon R.weight
| .exchange => entropyExchange R.operation rho
/-- PDF p.2, (3): approximation by a normalized product, full trace norm. -/
def Decorrelates {A B : Type} [Fintype A] [Fintype B]
(out : Matrix (A × B) (A × B) ℂ) (eps : ℝ) : Prop :=
∃ a : Matrix A A ℂ, ∃ b : Matrix B B ℂ,
IsDensityMatrix a ∧ IsDensityMatrix b ∧ traceNorm (out - Matrix.kronecker a b) ≤ eps
/-- PDF p.6, (14): closeness to an actual normalized separable state. -/
def Disentangles {A B : Type} [Fintype A] [Fintype B] [Nonempty A] [Nonempty B]
(out : Matrix (A × B) (A × B) ℂ) (eps : ℝ) : Prop :=
∃ sigma : Matrix (A × B) (A × B) ℂ,
Entanglement.IsSeparableDensity sigma ∧ traceNorm (out - sigma) ≤ eps
/-- PDF p.3, (5): the capped entropy correction, including the continuous value at zero. -/
def erasureEta (x : ℝ) : ℝ :=
if x ≤ (Real.exp 1)⁻¹ then -x * Real.logb 2 x
else (Real.exp 1)⁻¹ * Real.logb 2 (Real.exp 1)
/-- PDF pp.3,6: fixed one-copy dimension d=d_A*d_B, independent of blocklength. -/
def logDimension (A B : Type) [Fintype A] [Fintype B] : ℝ :=
Real.logb 2 (Fintype.card A * Fintype.card B : ℕ)
/-- PDF p.4: feasible noise costs at a finite block. -/
def totalCosts {A B : Type} [Fintype A] [Fintype B]
(rho : Matrix (A × B) (A × B) ℂ) (n : ℕ) (eps : ℝ)
(mode : NoiseClass) (cost : NoiseCost) : Set ℝ :=
{v | ∃ R : COLUR (Copies A n) (Copies B n), R.allowed mode ∧
Decorrelates (R.operation (sourcePower rho n)) eps ∧
v = R.cost (sourcePower rho n) cost}
/-- PDF p.4: optimal finite noise per copy; n=k+1 excludes division by zero. -/
def totalBlockRate {A B : Type} [Fintype A] [Fintype B]
(rho : Matrix (A × B) (A × B) ℂ) (eps : ℝ) (mode : NoiseClass)
(cost : NoiseCost) (k : ℕ) : ℝ :=
sInf (totalCosts rho (k+1) eps mode cost) / (k+1 : ℕ)
/-- PDF pp.4,7: choose liminf (optimistic) or limsup (pessimistic), before vanishing error. -/
def rateLimit (pessimistic : Bool) (f : ℕ → ℝ) : ℝ :=
if pessimistic then limsup f atTop else liminf f atTop
/-- PDF p.4, Theorem II.3: operational erasure rate, independently computed from ensembles. -/
def totalErasure {A B : Type} [Fintype A] [Fintype B]
(rho : Matrix (A × B) (A × B) ℂ) (mode : NoiseClass)
(cost : NoiseCost) (pessimistic : Bool) : ℝ :=
sSup {v | ∃ eps > (0 : ℝ), v = rateLimit pessimistic (totalBlockRate rho eps mode cost)}
/-- PDF p.7: admissible finite ensemble sizes for entanglement erasure. -/
def disentanglingSizes {A B : Type} [Fintype A] [Fintype B] [Nonempty A] [Nonempty B]
(rho : Matrix (A × B) (A × B) ℂ) (n : ℕ) (eps : ℝ) : Set ℕ :=
{N | ∃ R : COLUR (Copies A n) (Copies B n), R.count = N ∧
Disentangles (R.operation (sourcePower rho n)) eps}
/-- PDF p.7: N(n,eps), the smallest size, defined by the actual feasible channels. -/
def minimumDisentanglingSize {A B : Type} [Fintype A] [Fintype B]
[Nonempty A] [Nonempty B] (rho : Matrix (A × B) (A × B) ℂ) (n : ℕ) (eps : ℝ) : ℕ :=
sInf (disentanglingSizes rho n eps)
/-- PDF p.7: normalized finite-block cost; only positive lengths enter the limit. -/
def entanglementBlockRate {A B : Type} [Fintype A] [Fintype B]
[Nonempty A] [Nonempty B] (rho : Matrix (A × B) (A × B) ℂ) (eps : ℝ) (k : ℕ) : ℝ :=
Real.logb 2 (minimumDisentanglingSize rho (k+1) eps) / (k+1 : ℕ)
/-- PDF pp.7--8: optimistic/pessimistic erasure, without assuming the conjectured entropy formula. -/
def entanglementErasure {A B : Type} [Fintype A] [Fintype B]
[Nonempty A] [Nonempty B] (rho : Matrix (A × B) (A × B) ℂ)
(pessimistic : Bool) : ℝ :=
sSup {v | ∃ eps > (0 : ℝ), v = rateLimit pessimistic (entanglementBlockRate rho eps)}
/-- PDF p.6, Proposition III.1: all COLUR maps and nearby separable targets are optimized. -/
def separableEntropyCosts {A B : Type} [Fintype A] [Fintype B]
[Nonempty A] [Nonempty B] (rho : Matrix (A × B) (A × B) ℂ)
(n : ℕ) (eps : ℝ) : Set ℝ :=
{v | ∃ R : COLUR (Copies A n) (Copies B n),
∃ sigma : Matrix (Copies A n × Copies B n) (Copies A n × Copies B n) ℂ,
Entanglement.IsSeparableDensity sigma ∧
traceNorm (sigma - R.operation (sourcePower rho n)) ≤ eps ∧
v = vnEntropy sigma - n * vnEntropy rho - n * eps * logDimension A B - erasureEta eps}
/-- Sanity: no-copy tensors are the scalar unit, not the zero state. -/
example {A B : Type} (rho : Matrix (A × B) (A × B) ℂ)
(x y : Copies A 0 × Copies B 0) : sourcePower rho 0 x y = 1 := by
simp [sourcePower]
/-- Sanity: the one-copy matrix preserves every entry and its party order. -/
example {A B : Type} (rho : Matrix (A × B) (A × B) ℂ)
(x y : Copies A 1 × Copies B 1) :
sourcePower rho 1 x y = rho (x.1 0, x.2 0) (y.1 0, y.2 0) := by
simp [sourcePower]
/-- Sanity: the zero probability and erasureEta boundary are continuous entropy contributions. -/
example : shannon (fun _ : Fin 1 => (1 : ℝ)) = 0 ∧ erasureEta 0 = 0 := by
simp [shannon, erasureEta, le_of_lt (inv_pos.mpr (Real.exp_pos 1))]
/-- Sanity: every chosen randomizing ensemble sends the zero operator to zero. -/
example {A B : Type} [Fintype A] [Fintype B] (R : COLUR A B) :
R.operation 0 = 0 := by
simp [COLUR.operation]
/-- Sanity: the one-copy zero source retains zero. -/
example {A B : Type}
(x y : Copies A 1 × Copies B 1) :
sourcePower (0 : Matrix (A × B) (A × B) ℂ) 1 x y = 0 := by
simp [sourcePower]
/-- PDF p.5: combine rho and an arbitrary ancillary bipartite state in party order. -/
def withAncilla {A B C D : Type} (rho : Matrix (A × B) (A × B) ℂ)
(gamma : Matrix (C × D) (C × D) ℂ) :
Matrix ((A × C) × (B × D)) ((A × C) × (B × D)) ℂ :=
fun x y => rho (x.1.1,x.2.1) (y.1.1,y.2.1) * gamma (x.1.2,x.2.2) (y.1.2,y.2.2)
/-- PDF p.5: finite ancillary dimensions are varied explicitly, with their cost discounted. -/
def discountedCosts {A B : Type} [Fintype A] [Fintype B]
(rho : Matrix (A × B) (A × B) ℂ) : Set ℝ :=
{v | ∃ c d : ℕ, ∃ hc : 0 < c, ∃ hd : 0 < d,
∃ gamma : Matrix (Fin c × Fin d) (Fin c × Fin d) ℂ, IsDensityMatrix gamma ∧
v = totalErasure (withAncilla rho gamma) .coordinated .size true -
totalErasure gamma .coordinated .size true}
/-- PDF pp.6--7: concatenate n successive k-copy blocks, retaining the party order. -/
def blockIndex {k n : ℕ} (t : Fin n) (s : Fin k) : Fin (k*n) :=
Fin.cast (Nat.mul_comm n k) (finProdFinEquiv (t,s))
/-- PDF p.7: transport the accepted tensor-power channel from copy order (AB)^n
into party order A^n:B^n, on every matrix coefficient including reference blocks. -/
def regroupedChannelPower {A B : Type} [Fintype A] [Fintype B]
(T : Superop (A × B) (A × B)) (n : ℕ) :
Superop (Copies A n × Copies B n) (Copies A n × Copies B n) :=
fun rho x y => channelPower T n
(fun u v => rho ((fun t => (u t).1), (fun t => (u t).2))
((fun t => (v t).1), (fun t => (v t).2)))
(fun t => (x.1 t, x.2 t)) (fun t => (y.1 t, y.2 t))
/-- PDF p.8: normalized Schmidt ket in arbitrary orthonormal local frames. -/
def schmidtKet {A B : Type} {D : ℕ} (f : Fin D → ℝ)
(a : Matrix A (Fin D) ℂ) (b : Matrix B (Fin D) ℂ) : EuclideanSpace ℂ (A × B) :=
WithLp.toLp 2 fun x => ∑ j, (Real.sqrt (f j) : ℂ) * a x.1 j * b x.2 j
/-- PDF p.8: the dephased Schmidt state; the output is constructed, not assumed. -/
def schmidtDiagonal {A B : Type} {D : ℕ} (f : Fin D → ℝ)
(a : Matrix A (Fin D) ℂ) (b : Matrix B (Fin D) ℂ) : Matrix (A × B) (A × B) ℂ :=
fun x y => ∑ j, (f j : ℂ) * a x.1 j * b x.2 j * conj (a y.1 j * b y.2 j)
/-- PDF p.8: positive phase exp(2*pi*i*k*j/D), identity on the unused orthogonal complement. -/
def schmidtPhase {A : Type} [Fintype A] {D : ℕ}
(a : Matrix A (Fin D) ℂ) (k : Fin D) : Matrix A A ℂ :=
(1 : Matrix A A ℂ) + (Matrix.of fun (x y : A) => ∑ j,
(Complex.exp (2 * Real.pi * Complex.I *
(k.val : ℂ) * (j.val : ℂ) / (D : ℂ)) - 1) * a x j * conj (a y j))
/-- PDF pp.5--6, Remark II.6: a finite adaptive public-instrument tree.
Every outcome is public; subsequent local instruments may depend on the full transcript.
All finite local dimensions, outcomes, Kraus counts, and finite numbers of rounds occur. -/
inductive PublicProtocol : ℕ → ℕ → Type
| stop {a b : ℕ} : PublicProtocol a b
| alice {a b c : ℕ} (hc : 0 < c) (outcomeCount : ℕ)
(I : RectangularInstrument (Fin a) (Fin c) (Fin (outcomeCount+1)))
(next : Fin (outcomeCount+1) → PublicProtocol c b) : PublicProtocol a b
| bob {a b d : ℕ} (hd : 0 < d) (outcomeCount : ℕ)
(I : RectangularInstrument (Fin b) (Fin d) (Fin (outcomeCount+1)))
(next : Fin (outcomeCount+1) → PublicProtocol a d) : PublicProtocol a b
/-- PDF pp.5--6, (12)--(13): actual expected final mutual information conditional on
all public messages. Zero-probability branches contribute zero, without normalization. -/
def PublicProtocol.average : {a b : ℕ} → PublicProtocol a b →
Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ → ℝ
| _, _, .stop, rho => mutualInformation rho
| _, _, .alice _ _ I next, rho => ∑ x,
let omega := first (I.branch x) rho
let p := omega.trace.re
if 0 < p then p * (next x).average ((p : ℂ)⁻¹ • omega) else 0
| _, _, .bob _ _ I next, rho => ∑ x,
let omega := idTensorSuperop (I.branch x) rho
let p := omega.trace.re
if 0 < p then p * (next x).average ((p : ℂ)⁻¹ • omega) else 0
/-- Sanity: no instrument leaves the original total correlation. -/
example {a b : ℕ} (rho : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) :
PublicProtocol.average .stop rho = mutualInformation rho := rfl
/-- PDF p.10: party i's n-copy register. -/
abbrev MultiCopies {p : ℕ} (d : Fin p → ℕ) (n : ℕ) (i : Fin p) := Copies (Fin (d i)) n
/-- PDF p.10: independent copies of the multipartite source, regrouped by party. -/
def multiSourcePower {p : ℕ} {d : Fin p → ℕ}
(rho : Matrix (Config d) (Config d) ℂ) (n : ℕ) :
Matrix ((i : Fin p) → MultiCopies d n i) ((i : Fin p) → MultiCopies d n i) ℂ :=
fun x y => ∏ t, rho (fun i => x i t) (fun i => y i t)
/-- PDF p.10: multipartite COLUR, with actual product unitaries and one shared index. -/
structure MultiNoise {p : ℕ} (D : Fin p → Type) [∀ i, Fintype (D i)] where
count : ℕ
count_pos : 0 < count
weight : Fin count → ℝ
weight_nonneg : ∀ j, 0 ≤ weight j
weight_sum : ∑ j, weight j = 1
unitary : Fin count → (i : Fin p) → Matrix.unitaryGroup (D i) ℂ
/-- PDF p.10: the tensor-product unitary for one ensemble member. -/
def MultiNoise.productUnitary {p : ℕ} {D : Fin p → Type} [∀ i, Fintype (D i)]
(R : MultiNoise D) (j : Fin R.count) : Matrix ((i : Fin p) → D i) ((i : Fin p) → D i) ℂ :=
fun x y => ∏ i, (R.unitary j i : Matrix (D i) (D i) ℂ) (x i) (y i)
/-- PDF p.10: the actual randomizing operation on every joint operator. -/
def MultiNoise.operation {p : ℕ} {D : Fin p → Type} [∀ i, Fintype (D i)]
(R : MultiNoise D) : Superop ((i : Fin p) → D i) ((i : Fin p) → D i) :=
fun rho => ∑ j, (R.weight j : ℂ) •
(R.productUnitary j * rho * (R.productUnitary j)ᴴ)
/-- PDF p.10: independent LUR choices imposed on the ensemble itself. -/
def MultiNoise.independent {p : ℕ} {D : Fin p → Type} [∀ i, Fintype (D i)]
(R : MultiNoise D) : Prop :=
∃ L : (i : Fin p) → LocalNoise (D i),
∃ e : Fin R.count ≃ ((i : Fin p) → Fin (L i).count),
(∀ j, R.weight j = ∏ i, (L i).weight (e j i)) ∧
(∀ j i, R.unitary j i = (L i).unitary (e j i))
/-- PDF p.10: the same three costs, counted on a multipartite ensemble. -/
def MultiNoise.cost {p : ℕ} {D : Fin p → Type} [∀ i, Fintype (D i)]
(R : MultiNoise D) (rho : Matrix ((i : Fin p) → D i) ((i : Fin p) → D i) ℂ) : NoiseCost → ℝ
| .size => Real.logb 2 R.count
| .entropy => shannon R.weight
| .exchange => entropyExchange R.operation rho
/-- PDF p.10: a fully product target, normalized at every party. -/
def MultiDecorrelates {p : ℕ} {D : Fin p → Type} [∀ i, Fintype (D i)]
(out : Matrix ((i : Fin p) → D i) ((i : Fin p) → D i) ℂ) (eps : ℝ) : Prop :=
∃ sigma : (i : Fin p) → Matrix (D i) (D i) ℂ,
(∀ i, IsDensityMatrix (sigma i)) ∧
traceNorm (out - (Matrix.of fun (x y : (i : Fin p) → D i) =>
∏ i, sigma i (x i) (y i))) ≤ eps
/-- PDF p.10: an actual partial trace onto a specified set of parties. -/
def reducedOn {p : ℕ} {d : Fin p → ℕ}
(rho : Matrix (Config d) (Config d) ℂ)
(S : Finset (Fin p)) :
Matrix ((i : {i // i ∈ S}) → Fin (d i.val))
((i : {i // i ∈ S}) → Fin (d i.val)) ℂ :=
fun u v => ∑ x, ∑ y,
if (∀ i : {i // i ∈ S}, x i.val = u i) ∧
(∀ i : {i // i ∈ S}, y i.val = v i) ∧
(∀ i, i ∉ S → x i = y i) then rho x y else 0
/-- PDF p.10, (16): the entropy expression, distinct from the operational erasure rate. -/
def multiInformation {p : ℕ} {d : Fin p → ℕ}
(rho : Matrix (Config d) (Config d) ℂ) : ℝ :=
(∑ i, vnEntropy (reducedOn rho {i})) - vnEntropy rho
/-- PDF p.10: I(A_j : A_{j+1}...A_p), on the original tail marginal. -/
def tailInformation {p : ℕ} {d : Fin p → ℕ}
(rho : Matrix (Config d) (Config d) ℂ)
(j : Fin (p-1)) : ℝ :=
vnEntropy (reducedOn rho (Finset.univ.filter fun i => i.val = j.val)) +
vnEntropy (reducedOn rho (Finset.univ.filter fun i => j.val < i.val)) -
vnEntropy (reducedOn rho (Finset.univ.filter fun i => j.val ≤ i.val))
/-- PDF p.10: finite-block multipartite feasible costs. -/
def multiCosts {p : ℕ} {d : Fin p → ℕ}
(rho : Matrix (Config d) (Config d) ℂ)
(n : ℕ) (eps : ℝ) (independent : Bool) (cost : NoiseCost) : Set ℝ :=
{v | ∃ R : MultiNoise (MultiCopies d n),
(independent = true → R.independent) ∧
MultiDecorrelates (R.operation (multiSourcePower rho n)) eps ∧
v = R.cost (multiSourcePower rho n) cost}
/-- PDF p.10: normalized finite cost, with strictly positive copy count. -/
def multiBlockRate {p : ℕ} {d : Fin p → ℕ}
(rho : Matrix (Config d) (Config d) ℂ)
(eps : ℝ) (independent : Bool) (cost : NoiseCost) (k : ℕ) : ℝ :=
sInf (multiCosts rho (k+1) eps independent cost) / (k+1 : ℕ)
/-- PDF p.10: operational multipartite total erasure, without an entropy definition. -/
def multiErasure {p : ℕ} {d : Fin p → ℕ}
(rho : Matrix (Config d) (Config d) ℂ)
(independent : Bool) (cost : NoiseCost) (pessimistic : Bool) : ℝ :=
sSup {v | ∃ eps > (0 : ℝ), v = rateLimit pessimistic (multiBlockRate rho eps independent cost)}
/-- PDF p.10: the same execution at arbitrary positive blocklength. -/
def successiveBlockOutput {p : ℕ} {d : Fin p → ℕ} {n : ℕ}
(R : Fin (p-1) → MultiNoise (MultiCopies d n))
(rho : Matrix ((i : Fin p) → MultiCopies d n i) ((i : Fin p) → MultiCopies d n i) ℂ) :=
(List.finRange (p-1)).foldl (fun state j => (R j).operation state) rho
/-- Sanity: a single party requires no successive stage. -/
example {d : Fin 1 → ℕ} {n : ℕ}
(R : Fin (1-1) → MultiNoise (MultiCopies d n))
(rho : Matrix ((i : Fin 1) → MultiCopies d n i) ((i : Fin 1) → MultiCopies d n i) ℂ) :
successiveBlockOutput R rho = rho := by
simp [successiveBlockOutput]
end QAlgorithms.Papers.Independent.Intakenext100.P47
Read-back
What the Lean code literally says, in plain math · gpt-6.1-sol
QAlgorithms.Papers.Independent.Intakenext100.P47.COLUR.allowed
For finite enumerated types , let consist of , nonnegative weights summing to , and unitary matrices on and on . This defines a predicate depending on one of four class labels: is always allowed; is allowed exactly when every is the identity; is allowed exactly when every is the identity; and is allowed exactly when there exist positive natural numbers , nonnegative normalized weight families , , unitary families on , on , and a bijection such that, whenever ,
These conditions apply to every index, including indices of zero weight; may be empty.
QAlgorithms.Papers.Independent.Intakenext100.P47.COLUR.cost
For finite enumerated types , let have , nonnegative normalized weights , and unitary families , and let be any complex matrix on . Set . This defines three real costs: the cost is ; the cost is ; and the cost is , constructed as follows. Write , choose the finite-enumeration bijection , and put . Define
where and is continuous functional calculus. Zero weights contribute zero under the total logarithm convention. No density-matrix assumption is made on , and may be empty.
QAlgorithms.Papers.Independent.Intakenext100.P47.COLUR
For types , each equipped with a finite enumeration, a value of this structure consists of a natural number , real weights for with , and two families of complex unitary matrices: indexed by , and indexed by . Both families use the same index and weights. Zero weights and repeated matrices are permitted, and neither nor is required to be nonempty.
QAlgorithms.Papers.Independent.Intakenext100.P47.COLUR.operation
For finite enumerated types and a structure consisting of , weights summing to , and unitary matrices on and on , this defines the function on all complex matrices indexed by given by
Here denotes conjugate transpose. No positivity or normalization condition is imposed on the argument , and the finite types may be empty.
QAlgorithms.Papers.Independent.Intakenext100.P47.Decorrelates
For finite enumerated types , any complex matrix indexed by , and any real , this predicate means that there exist matrices on and on , both positive semidefinite with trace exactly , such that
No density-matrix condition is imposed on , and the product factors need not equal its marginals. Negative cannot satisfy the predicate; if either finite type is empty, the required trace-one factor does not exist.
QAlgorithms.Papers.Independent.Intakenext100.P47.Disentangles
For nonempty finite enumerated types , any complex matrix indexed by , and any real , this predicate means that there exist a natural number , real weights summing to , and positive semidefinite trace-one matrices on and on , such that
The weight normalization excludes , but individual weights may be zero. No density-matrix condition is imposed on , and negative cannot satisfy the predicate.
QAlgorithms.Papers.Independent.Intakenext100.P47.LocalNoise
For any type equipped with a finite enumeration, a value of this structure consists of a natural number , real weights for satisfying , and an -indexed complex unitary matrix for each . Zero weights and repeated unitary matrices are permitted. The type is not required to be nonempty.
QAlgorithms.Papers.Independent.Intakenext100.P47.MultiCopies
For any natural number , dimension function , natural number , and party index , this is an abbreviation for the type of functions
that is, length- strings of basis labels for party . No positivity assumption is imposed on or . For this type has exactly one element, even if ; if and , it is empty. When , there is no party index .
QAlgorithms.Papers.Independent.Intakenext100.P47.MultiDecorrelates
For any natural number , finite types for , arbitrary complex matrix on , and real number , this predicate means that there exist matrices on the respective , each positive semidefinite with complex trace exactly , such that
No density-matrix assumption is imposed on . A negative cannot satisfy this inequality. If any is empty, its required trace-one matrix cannot exist. When , there are no local matrices to choose, the configuration space is a singleton, and is its identity matrix.
QAlgorithms.Papers.Independent.Intakenext100.P47.MultiNoise.cost
For any natural number , finite types indexed by , and matrix on the configuration space , let consist of a positive integer , nonnegative real weights summing to , and a unitary matrix on each , for . Set and . The cost is the following function of the selected cost kind:
Here , using the formal functional calculus. To define literally, take the finite enumeration , put , and set . No positivity or normalization of is required. Empty and are allowed; when , the configuration space has one element and each product defining is .
QAlgorithms.Papers.Independent.Intakenext100.P47.MultiNoise.independent
For any natural number , family of finite types , and noise data with positive count , nonnegative weights summing to one, and local unitaries , this property means that there exist, for every party , local noise data with a positive natural count , nonnegative real weights summing to one, and unitaries on , together with a bijection
such that, for every and every ,
These are equalities of the listed weights and unitary matrices under the bijection, including entries of weight zero; distinct indices need not specify distinct unitaries. The local types may be empty. When , the product index set is a singleton, so the property requires and its sole weight to equal .
QAlgorithms.Papers.Independent.Intakenext100.P47.MultiNoise
For any natural number and family of finite types , , this structure consists of a natural count , real weights for satisfying , and, for every and , a unitary complex matrix indexed by . The finite local types need not be nonempty. Zero weights and repeated choices of unitaries are allowed. The case is included: it retains the positive count and probability weights, while requiring no local-unitary data.
QAlgorithms.Papers.Independent.Intakenext100.P47.MultiNoise.operation
For any natural number , family of finite types , and noise data with positive count , weights summing to one, and local unitaries on , this defines a map from complex matrices on to matrices on the same type by
The input is arbitrary; no density-matrix hypothesis is imposed. Zero weights, repeated unitary choices, and empty local types are allowed. When , the configuration space is a singleton, every has sole entry , and this operation is the identity on its scalar matrices.
QAlgorithms.Papers.Independent.Intakenext100.P47.MultiNoise.productUnitary
For any natural number , family of finite types , and noise data consisting of a positive count , nonnegative weights summing to one, and local unitaries on , this defines, for every , a matrix on configurations by
The weights are part of the supplied data but do not enter this definition. Local types may be empty. For , the configuration type is a singleton and the matrix’s sole entry is the empty product .
QAlgorithms.Papers.Independent.Intakenext100.P47.NoiseClass
This defines a type with exactly four distinct values, named , , , and , together with decidable equality. The declaration itself imposes no mathematical conditions associated with these names.
QAlgorithms.Papers.Independent.Intakenext100.P47.NoiseCost
This defines a type with exactly three distinct values, named , , and , together with decidable equality. No numerical cost is assigned by this declaration itself.
QAlgorithms.Papers.Independent.Intakenext100.P47.PublicProtocol.average
For all natural dimensions , every protocol tree of dimensions , and every complex matrix on , this defines a real number recursively. At a stop node its value is
where uses continuous functional calculus. At an Alice instrument node, whose finite rectangular Kraus matrices satisfy , form
Its value is , with each summand defined instead to be zero whenever . At a Bob node the same rule uses . Each node has a positive output dimension and one continuation per outcome. No positivity, Hermiticity, or trace normalization is required of the input matrix, and zero initial dimensions are included; in particular, branches of zero or negative real trace contribute zero without evaluating a normalized continuation.
QAlgorithms.Papers.Independent.Intakenext100.P47.PublicProtocol
This defines a family of inductively generated protocol trees indexed by natural numbers , representing local matrix dimensions. A protocol of dimensions is either a stop node, an Alice node, or a Bob node. An Alice node specifies a positive output dimension , a natural number , an instrument with outcomes , and a continuation of dimensions for every outcome. The instrument specifies a natural Kraus count and matrices , , satisfying . A Bob node analogously specifies a positive output dimension , a natural number , matrices satisfying the same completeness equation with , and a continuation of dimensions for each outcome. The trees are finite, with no prescribed common depth bound. Every instrument node has at least one outcome, although its Kraus count may be zero if the completeness equation permits it. Initial dimensions or may be zero; a stop node is available for every pair of dimensions.
QAlgorithms.Papers.Independent.Intakenext100.P47.blockIndex
For natural numbers , an index , and an index , this defines the index in with numerical value
If or , there is no pair of input indices.
QAlgorithms.Papers.Independent.Intakenext100.P47.discountedCosts
For any finite types , possibly empty, and any complex matrix on , this defines the set of real numbers
where is regrouped across the two parties, with entry . For a bipartite matrix , the real-valued expression means
Here has entries , and consists of for positive finite integers and operations , with nonnegative weights summing to and local unitaries , whose output on is within trace norm of some product of density matrices. No independence restriction is placed on the paired local choices. The trace norm is . These are the total real infimum and supremum operations, which return for empty sets or, respectively, sets unbounded below or above; this definition assumes no density-matrix condition on and asserts no attainment.
QAlgorithms.Papers.Independent.Intakenext100.P47.disentanglingSizes
For any finite nonempty types , any complex matrix on , any natural number , and any real , this defines the set of natural numbers for which there exist pairs of local unitaries on and on , with nonnegative weights summing to , such that , where , , and . The matrix must have a finite representation , with , , and every positive semidefinite with trace . There is no restriction on the noise list beyond those stated, no assumption that is a density matrix, and zero weights are allowed. The set never contains , is empty for , and includes the case , when is the scalar matrix .
QAlgorithms.Papers.Independent.Intakenext100.P47.entanglementBlockRate
For any finite nonempty types , any complex matrix on , any real , and any natural number , put . This defines , where is the least positive integer for which there are local unitaries and nonnegative weights summing to such that , with , , and a finite convex combination of products of positive semidefinite, trace-one matrices on and . The trace norm is , and zero noise weights are allowed. If no such list exists, the natural-number infimum defining is , and the real logarithm convention makes the defined rate ; this includes negative . No density assumption on is imposed, and the block length is always positive, including at .
QAlgorithms.Papers.Independent.Intakenext100.P47.entanglementErasure
For any finite nonempty types , any complex matrix on , and any Boolean , this defines
Here is the least positive length of a probability-weighted list of pairs of local unitaries producing , with and , for which is within trace norm of a finite convex combination of products of positive semidefinite, trace-one matrices on and . The entries of are , and . If no admissible list exists, is defined to be , and . Zero weights are permitted, and is not required to be positive or normalized. The supremum and sequence limits are totalized real-valued operations, with no boundedness or convergence hypotheses, and the supremum ranges over every positive tolerance.
QAlgorithms.Papers.Independent.Intakenext100.P47.erasureEta
For every real number , this defines
The boundary uses the first branch. There is no nonnegativity assumption on : the real logarithm is total, with and for negative , so in particular .
QAlgorithms.Papers.Independent.Intakenext100.P47.logDimension
For any types , each equipped with a finite enumeration, this defines the real number
Neither type is required to be nonempty. If either is empty, the product of cardinalities is zero and the total real logarithm convention makes the value .
QAlgorithms.Papers.Independent.Intakenext100.P47.minimumDisentanglingSize
For any finite nonempty types , any complex matrix on , any natural number , and any real , this defines the infimum in of all positive list lengths for which a map , with local unitaries and nonnegative weights summing to , sends the matrix , whose entries are , within trace norm of some finite convex combination of products of positive semidefinite, trace-one matrices. Here the trace norm is . Thus it is the least admissible positive list length when such a length exists, and is when no such length exists, including whenever . No normalization or positivity of is assumed, zero weights in the noise list are permitted, and uses the empty-product matrix .
QAlgorithms.Papers.Independent.Intakenext100.P47.multiBlockRate
For any natural number , natural dimensions , arbitrary complex matrix on , real , Boolean independence flag , cost kind , and natural number , this definition gives
To define , put and . Its elements are costs of maps , where , , , and with local unitaries on , such that for some positive semidefinite trace-one . If , the choices must be indexed, through a bijection, by a product of positive-sized local choice sets, with weights equal to products of local probability weights and each depending only on the corresponding local choice; if , no such restriction applies. The cost is respectively , , or for size, entropy, or exchange, where , uses the transposed entries of in the finite enumeration used by the definition, and . The infimum is taken in the real numbers with the total formal convention, so an empty or unbounded-below cost set has infimum ; attainment is not required here. The divisor is always positive, including . No density assumption on , positivity of the , or positivity of is imposed.
QAlgorithms.Papers.Independent.Intakenext100.P47.multiCosts
For any natural number , natural dimensions , arbitrary complex matrix on , natural block length , real tolerance , Boolean flag , and cost kind , this definition is the set of real costs obtainable as follows. Give party the block configuration space , and define the block input by . Choose a positive integer , nonnegative weights summing to , and local unitaries on ; these determine and . If , additionally require local choices with positive counts , probability weights , and unitaries , together with a bijection , such that and ; when , this requirement imposes no condition. Require positive semidefinite trace-one matrices on satisfying
The included value is for size, for entropy, or for exchange. Here , , and is formed from the transposed entries of after the finite enumeration used in the definition. No density assumption on is required. The definition permits , zero dimensions, and ; at , every local block space is a singleton and every product defining the block input is . For , the cost set is empty.
QAlgorithms.Papers.Independent.Intakenext100.P47.multiErasure
For any natural number , natural dimensions , arbitrary complex matrix on , Boolean independence flag , cost kind , and Boolean flag , this definition is
Here contains the selected costs of finite random products of local unitaries on the spaces : a choice has , weights summing to , local unitaries , and map . Its block input has entries , and its output must lie within trace norm of for some positive semidefinite trace-one matrices . When , the choice set must be bijective to a product of positive-sized local choice sets, with product probability weights and each party’s unitary determined by its own choice; adds no restriction. Size cost is , entropy cost is , and exchange cost is , where and uses the transposed entries of in the finite enumeration used by the definition. The trace norm is . All infima, suprema, and order limits here are real-valued formal operations; no boundedness or existence of limits is assumed, and an empty or unbounded-below cost set has infimum . The outer operation ranges over every positive tolerance, rather than asserting a limit as the tolerance decreases to zero. Zero dimensions and are permitted, and need not be a density matrix.
QAlgorithms.Papers.Independent.Intakenext100.P47.multiInformation
For any natural number , natural dimensions , and arbitrary complex matrix on , this definition assigns the real number
For any subset , the matrix has entries , where the sum runs over full configurations restricting to on and agreeing at every coordinate outside . The functional calculus in is the total formal operation used in the definition; no density-matrix assumption is made on . Dimensions may be zero, and is included: then the sum over parties is empty and the value is for a matrix on a singleton configuration space.
QAlgorithms.Papers.Independent.Intakenext100.P47.multiSourcePower
For any natural number , dimension function , complex matrix indexed by configurations with , and natural number , this defines a matrix whose basis labels assign a length- string of labels below to every party. Its entries are
No density-matrix or positivity hypothesis is required, and the local dimensions may be zero. When , the matrix has a single basis label and its sole entry is the empty product . When , the configuration type is a singleton, and the displayed entry is the -th power of the sole entry of .
QAlgorithms.Papers.Independent.Intakenext100.P47.rateLimit
For any Boolean choice and any sequence , this defines when is true, and when is false, using the order-theoretic limits along the filter of sufficiently large natural numbers. No convergence or boundedness assumption is imposed; these are totalized real-valued operations, rather than operations taking values in the extended real numbers.
QAlgorithms.Papers.Independent.Intakenext100.P47.reducedOn
For any natural number , natural dimensions indexed by , arbitrary complex matrix on , and subset of the party indices, this definition gives a matrix on whose entries are
Thus coordinates outside are summed over with equal row and column values, while coordinates in are fixed by and . No positivity or trace condition is assumed. Zero dimensions are permitted and can make the configuration space empty, in which case the sums are zero. For , the output is the scalar matrix with entry ; for , the full configuration space itself is a singleton.
QAlgorithms.Papers.Independent.Intakenext100.P47.regroupedChannelPower
For finite types , possibly empty, an arbitrary map from complex matrices on to complex matrices on , and any natural number , this defines a map on matrices indexed by . For tuples , , its entries are
where is the matrix with its sole nonzero entry in row , column . No linearity, positivity, or channel assumption is imposed on . When , the tuple spaces are singletons and the empty product is , so this map is the identity on the resulting one-dimensional matrix space.
QAlgorithms.Papers.Independent.Intakenext100.P47.schmidtDiagonal
For arbitrary types , a natural number , any function , and complex matrices with respective row sets and columns, this defines a complex matrix on by
No finiteness or nonemptiness assumptions are imposed on , and neither normalization nor orthogonality is assumed for the columns. The coefficients may be negative, and no positivity or trace-one condition is required of the resulting matrix; when , it is the zero matrix.
QAlgorithms.Papers.Independent.Intakenext100.P47.schmidtKet
For arbitrary types , a natural number , any real-valued function on , and complex matrices with rows indexed by and with rows indexed by , both having columns, this defines the vector with coefficients
There are no nonnegativity or normalization assumptions on , no orthogonality assumptions on the columns, and no finiteness assumptions on . The real square root is on negative inputs, so nonpositive contribute ; when , the vector is .
QAlgorithms.Papers.Independent.Intakenext100.P47.schmidtPhase
For any finite type , natural number , complex matrix with rows indexed by and columns indexed by , and index , this defines the matrix on by
There is no assumption that the columns of are orthonormal, or that this matrix is unitary. The type may be empty. When , there is no admissible index , so the definition has no instance with such a .
QAlgorithms.Papers.Independent.Intakenext100.P47.separableEntropyCosts
For any finite nonempty types , any complex matrix on , any natural number , and any real , this defines the set of real numbers
obtained by choosing a positive-length list of pairs of local unitaries on , with nonnegative weights summing to , setting , and choosing , where , , and every is positive semidefinite with trace , such that . Here , , , and matrix functions use continuous functional calculus. The correction is if , and otherwise. There is no noise-class restriction and no density assumption on ; zero noise weights are permitted. Negative makes the set empty, while uses .
QAlgorithms.Papers.Independent.Intakenext100.P47.sourcePower
For arbitrary types , any complex matrix indexed by , and any natural number , this defines a matrix indexed by , where means the functions . Its entries are
There are no finiteness, positivity, or normalization assumptions on . When , each function space has one element and the empty product is , so the resulting matrix is the matrix with entry .
QAlgorithms.Papers.Independent.Intakenext100.P47.successiveBlockOutput
For any natural numbers , natural dimensions , and arbitrary complex matrix on , suppose that for every a noise choice is given. Each consists of a positive count , nonnegative weights summing to , and local unitaries on the party block spaces, determining
The output is obtained by starting with , setting in increasing order , and returning . No restriction requires to act only on party , have independent local choices, or have uniform weights. No density assumption on is imposed, and and zero dimensions are allowed. When or , natural subtraction makes the list of steps empty and the output is exactly .
QAlgorithms.Papers.Independent.Intakenext100.P47.tailInformation
For any natural number , natural dimensions , arbitrary complex matrix on , and index , this definition gives
Here , and is the sum of over full configurations with , , and for every . No positivity or normalization is assumed, and zero dimensions are allowed. The index type has elements with natural-number subtraction truncated at zero, so there is no possible argument when or .
QAlgorithms.Papers.Independent.Intakenext100.P47.totalBlockRate
For any finite types , any complex matrix on , any real , any noise class and cost, and any natural number , put . This defines , where consists of the following real costs. Form with entries , and choose a positive-length list of pairs of local unitaries , with nonnegative weights summing to , giving . The output must satisfy for some positive semidefinite, trace-one matrices , where . Coordinated noise imposes no further restriction; Alice noise requires ; Bob noise requires ; independent noise requires the list and weights to be, up to a bijection, a Cartesian product of two local probability-weighted unitary lists. For a list of length , its cost is respectively , , or , according to the cost choice, where , , and matrix functions use continuous functional calculus. The infimum is taken in , whose totalized infimum is for an empty set or a set unbounded below. The denominator is always positive, including at . Neither normalization of nor nonemptiness of is assumed; in particular, a negative makes empty and the defined rate .
QAlgorithms.Papers.Independent.Intakenext100.P47.totalCosts
For any finite types , any complex matrix indexed by , any natural number , any real , and choices of noise class and cost, this defines the set of real numbers obtainable as follows. Write , similarly for , and define by . Choose a positive integer , nonnegative weights summing to , and unitary matrices on and on , and put . For coordinated noise there is no additional restriction; for Alice noise every is the identity; for Bob noise every is the identity; for independent noise the indexed list must, up to a bijection, be the Cartesian product of two positive-length lists of local unitaries with probability weights, with equal to the product of the corresponding local weights. Require density matrices on and on such that , where a density matrix is positive semidefinite with trace , and , with the square root given by continuous functional calculus. The resulting number is for size cost, for entropy cost, or for exchange cost, where and . There is no density assumption on , no nonemptiness assumption on , and zero weights are permitted. When , the product defining is ; when , the defined set is empty.
QAlgorithms.Papers.Independent.Intakenext100.P47.totalErasure
For any finite types , any complex matrix on , any noise class and cost, and any Boolean , this defines
Here is the matrix on with entries , and consists of costs of maps , where , the are nonnegative and sum to , and are local unitaries, such that for some positive semidefinite, trace-one matrices . The trace norm is . Coordinated noise adds no restriction; Alice noise requires every ; Bob noise requires every ; independent noise requires a bijective identification with a Cartesian product of two local probability-weighted unitary lists, including factorization of the weights. The selected cost is , , or , where and ; matrix functions use continuous functional calculus. All infima, suprema and sequence limits here are real-valued and totalized; in particular, an empty inner cost set has infimum . The definition assumes neither that is a density matrix nor that are nonempty, and it takes a supremum over all positive tolerances.
QAlgorithms.Papers.Independent.Intakenext100.P47.withAncilla
For arbitrary types , any complex matrix indexed by , and any complex matrix indexed by , this defines a complex matrix on by
There are no finiteness, nonemptiness, positivity, trace, or normalization assumptions on these types or matrices.
Confirmed by the mission captain (proposal self-audit).
Confirmed by the moderator at approval.