The symmetric model: the state, the placements and the swap symmetry #
This is the base file of the port of the vendored low-individual-degree test
(MIPRE/Background/LIDT/MIPStarRE/LDT/) from finite-dimensional matrices to a vector state on a
Hilbert space (planning/c6b-plan.md, milestone M0, and its section "Port conventions"). It is
the counterpart of MIPRE/Background/LIDT/MIPStarRE/LDT/Basic/QuantumState.lean.
The vendored development works with a density matrix ψ on ι × ι, places a local operator
A : Op ι on the two tensor factors as leftTensor A = A ⊗ 1 and rightTensor A = 1 ⊗ A, and
assumes, for its symmetric strategies, that ψ is fixed by the swap of the two factors. Here a
symmetric model SymModel 𝔓 K is
- a C*-algebra
𝔓of local operators (the vendoredOp ι), with its order; - a Hilbert space
Kand a unit vectorΨ ∈ K(the state); - a ⋆-homomorphism
L : 𝔓 →⋆ₐ[ℂ] (K →L[ℂ] K), the first player's placement (leftTensor); - a self-inverse isometry
JofKfixingΨ, whose conjugationflipcarriesLto the second player's placementR := flip ∘ L(rightTensor), and such that the two placements commute.
Joint operators (the vendored Op (ι × ι)) are elements of K →L[ℂ] K, and the expectation is
ev X = Re ⟪Ψ, X Ψ⟫ = Op.qform Ψ X (MIPRE/Foundations/OpCalculus.lean), so the linearity,
monotonicity and positivity of the vendored ev are those of Op.qform.
The vendored swap symmetry (PermInvState, swapDensity, the *_of_density_fixed lemmas of
LDT/Test/StrategyCore.lean) is a hypothesis on a strategy there; here it is three theorems of
the structure (reports/c6b-paper-proofs.md, §4.1 and Theorem B):
ev_flip : ev (flip X) = ev X, sinceJfixesΨ;ev_L_eq_ev_R : ev (L x) = ev (R x), the vendoredPermInvState.swap_ev;ev_L_mul_R_comm : ev (L x * R y) = ev (L y * R x), the vendoredev_opTensor_swap_of_density_fixed.
The state alone is a vector state VecState K (the fields Ψ, Ψ_norm), the parent
structure of SymModel. Everything that uses only the state, and not the placements or the flip,
is a VecState declaration: ev and its linear and positivity lemmas here, and downstream the
same-space defects and relations (qSDD, sddError, SDDRel, …, Co/Test/Defs.lean). They
apply to a state with no swap symmetry (the vendored QuantumState ι on one space, the reduced
or tensored states of MakingMeasurementsProjective), and are reached from S : SymModel 𝔓 K by
the same dot notation, S.ev X being S.toVecState.ev X; an explicit argument
(V : VecState K) accepts S through a coercion.
The vector state is a state model of the repository (VecState.toStateModel, with H := K,
π := id), and the symmetric model a bipartite model (toBipartite, with in addition
πA := L, πB := R), so the state calculus of MIPRE/Foundations/ applies to both unchanged.
Every positivity lemma on the joint operators K →L[ℂ] K is proved here, in a file that imports
only Foundations and the Mathlib they import, and is applied downstream: positivity on
K →L[ℂ] K is the expensive part of elaboration, and it roughly doubles under the wholesale
import Mathlib of the vendored classical layer (planning/c6b-plan.md, §5). Positivity in the
local algebra 𝔓, or in a generic ordered ⋆-ring, stays with its vendored file.
Translation #
QuantumState (ι × ι) ψ ↦ S : SymModel 𝔓 K; ev ψ X ↦ S.ev X; leftTensor A ↦ S.L A;
rightTensor A ↦ S.R A; opTensor A B ↦ S.opTensor A B = S.L A * S.R B; ᴴ ↦ star;
swapDensity ↦ S.flip; a state on one space ↦ V : VecState K. Lemmas keep their vendored
names, as SymModel lemmas (S.leftTensor_mul_leftTensor, stated with S.L) or, when they use
only the state, VecState lemmas (S.ev_add, V.ev_add).
New here #
VecState,VecState.toStateModel(withtoStateModel_qform,toStateModel_snorm), the coercion of aSymModelto itsVecState;- the flip and its lemmas (
flip,R_apply,J_symm,flip_apply,flip_flip,flip_L,flip_R,L_comm_R), the swap symmetry (ev_flip,ev_L_eq_ev_R,ev_L_mul_R_comm); toBipartiteand itssimplemmas;leftTensor_real_smul,rightTensor_real_smul: placement of a real scalar multiple;opTensor_le_one: a product placement of two effects is an effect.
Ported here from other vendored files #
So that every positivity proof sits in this file, the following are ported here rather than in
the counterparts of their vendored files: from LDT/Basic/OperatorExpectations.lean, ev_add,
ev_sub, ev_scale, ev_real_smul, ev_zero, ev_opTensor, ev_one_of_isNormalized,
ev_adjoint_self_nonneg, ev_finset_sum, ev_sum, ev_nonneg_of_psd, ev_mono,
ev_conjTranspose, ev_mul_comm_of_hermitian, ev_mul_comm_of_psd,
ev_conjTranspose_mul_comm; from LDT/Basic/TensorPlacement.lean, leftTensor_finset_sum,
rightTensor_finset_sum, leftTensor_nonneg, rightTensor_nonneg, leftTensor_le_one,
rightTensor_le_one; from LDT/Test/StrategyCore.lean, swapDensity_opTensor,
ev_swapDensity_of_density_fixed, ev_opTensor_swap_of_density_fixed; from
Quantum/FiniteMatrix/Order.lean, sq_le_self (for any C*-algebra).
Not ported #
Matrix-only or density-only declarations of the vendored file, each replaced by the model:
QuantumState: replaced byVecState(a state on one space) andSymModel(a symmetric state on two); the state is the vectorΨ, not a density matrix.QuantumState.IsNormalized.nonempty: suppliesNonempty ιto the normalized trace, which the model does not have;Kcontains the unit vectorΨ.pureDensity: the scaled rank-one density of a vector; the state is a vector here.swapVector: replaced by the fieldJ.swapVector_swapVector: replaced by the fieldJ_J.PureState: the state is a unit vector already (Ψ,Ψ_norm).PureState.basis_unit: a coordinate vector ofι → ℂ; no coordinates here.PureState.basis: a coordinate vector ofι → ℂ; no coordinates here.PureState.density: density of a vector; no density here.PureState.density_psd: density of a vector; no density here.PureState.toQuantumState: the coercion of a vector to a density; no density here.PureState.coe_density: the coercion of a vector to a density; no density here.PureState.normalizedTrace_density: normalized trace; replaced byΨ_normandev_one_of_isNormalized.PureState.toQuantumState_isNormalized: replaced byisNormalized.PureState.normalizedTrace_density_mul: normalized trace ofρ X; replaced byev_eq_re_inner, which holds by definition.PureState.IsSwapInvariant: replaced by the fieldJ_Ψ.leftTensor: replaced by the fieldL.rightTensor: replaced byR.normalizedTrace_opTensor: the model has no trace.QuantumState.tensor: the tensor product of two states; the model has one state and no tensor product of Hilbert spaces.QuantumState.tensor_density: asQuantumState.tensor.QuantumState.tensor_isNormalized: asQuantumState.tensor.
A vector state: a unit vector Ψ in a Hilbert space K, acting on the operators of K
by X ↦ Re ⟪Ψ, X Ψ⟫. It is the vendored QuantumState ι of a state on one space, as a vector
state; it is the parent of SymModel, and the same-space quantities of the port (ev, qSDD,
SDDRel, …) are VecState declarations, reached from S : SymModel 𝔓 K by the same dot
notation (S.ev X is S.toVecState.ev X).
- Ψ : K
The state.
The state is a unit vector (the vendored
QuantumState.IsNormalized).
Instances For
A symmetric model: a vector state Ψ in a Hilbert space K, a ⋆-homomorphism L from a
C*-algebra 𝔓 of local operators into the operators on K (the first player's placement), and
a self-inverse isometry J of K fixing Ψ whose conjugation carries L to an operator family
commuting with L (the second player's placement R).
- Ψ : K
The first player's placement (the vendored
leftTensor).The flip of the two players (the vendored
swapVector).The flip is an involution.
The state is symmetric (the vendored
PureState.IsSwapInvariant).- commute (x y : 𝔓) : Commute (self.L x) (self.J.conjStarAlgEquiv (self.L y))
The two placements commute.
Instances For
An operator between 0 and 1 dominates its square: X (1 - X) is a product of commuting
positive elements.
The expectation #
The expectation Re ⟪Ψ, X Ψ⟫ of a joint operator (the vendored ev ψ X = Re τ(ρ X)).
Equations
- V.ev X = MIPRE.Op.qform V.Ψ X
Instances For
The expectation is the real part of the inner product (the vendored
PureState.ev_eq_re_inner).
ev distributes over addition.
ev distributes over subtraction.
ev commutes with complex scalar multiplication by a real number.
ev commutes with the real scalar action on operators.
ev of the zero operator is zero.
ev distributes over finite sums.
ev distributes over univ sums.
The state has unit expectation on the identity (the vendored QuantumState.IsNormalized,
τ(ρ) = 1).
Equations
- V.IsNormalized = (V.ev 1 = 1)
Instances For
A normalized state has unit expectation on the identity operator.
A vector state is normalized.
ev of a positive operator is nonnegative.
ev is monotone.
ev (M* M) = ‖M Ψ‖².
For any operator M, ev (M* M) ≥ 0.
The vector state as a state model of the repository (MIPRE/Foundations/StateModel.lean):
H := K, ψ := Ψ, π := id. Its quadratic form is ev and its state norm ‖X Ψ‖, both by
rfl.
Equations
- V.toStateModel = { H := K, normedAddCommGroup := inst✝², innerProductSpace := inst✝¹, completeSpace := inst✝, ψ := V.Ψ, π := StarAlgHom.id ℂ (K →L[ℂ] K) }
Instances For
The quadratic form of the state model is ev.
The state norm of the state model is ‖X Ψ‖.
Taking the adjoint does not change ev.
ev commutes on positive operators.
A symmetric model is a vector state: an explicit argument (V : VecState K) accepts
S : SymModel 𝔓 K.
Equations
The flip and the second placement #
The flip of the joint operators, X ↦ J X J (the vendored swapDensity).
Equations
- S.flip = S.J.conjStarAlgEquiv
Instances For
The second player's placement R x = J (L x) J (the vendored rightTensor).
Instances For
The second placement is the flip of the first.
The flip is its own inverse.
The flip of an operator, applied to a vector: (J X J) v.
The flip of the joint operators is an involution.
The flip carries the first placement to the second.
The flip carries the second placement to the first.
The two placements commute.
The model as a bipartite model #
The symmetric model as a bipartite model of the repository: H := K, π := id,
πA := L, πB := R.
Equations
- S.toBipartite = { toStateModel := S.toStateModel, πA := S.L, πB := S.R, commute := ⋯ }
Instances For
The state of the bipartite model is Ψ.
The state of the bipartite model is a unit vector.
The representation of the bipartite model is the identity.
The bipartite model's first placement is L.
The bipartite model's second placement is R.
The quadratic form of the bipartite model is ev.
The state norm of the bipartite model is ‖X Ψ‖.
The swap symmetry #
The two placements have the same expectations (the vendored PermInvState.swap_ev).
The expectation of a product placement is symmetric (the vendored
ev_opTensor_swap_of_density_fixed).
The flip preserves ev (the vendored ev_swapDensity_of_density_fixed, where the fixed
density was a hypothesis).
Tensor placement #
The product placement A ⊗ B = L A * R B (the vendored Kronecker product).
Instances For
Expectation of a tensor product can be written using left/right placements.
The flip exchanges the factors of a product placement.
The expectation of a product placement is symmetric in its factors.
Left placement of the identity is the identity.
Right placement of the identity is the identity.
Local placements multiply to the product placement.
Multiplying a left placement into a product placement only affects the left factor.
Multiplying a product placement by a left placement only affects the left factor.
Multiplying a right placement into a product placement only affects the right factor.
Product placements multiply factorwise.
Scalar multiplication commutes with left placement.
Left placement commutes with real scalar multiplication. Mathlib's map_smul does not apply
to a real scalar on a ℂ-algebra homomorphism, so a simp call meeting S.L (c • A) with
c : ℝ needs this lemma.
Right placement commutes with real scalar multiplication (as leftTensor_real_smul).
Powers commute with left placement.
The adjoint distributes over a product placement.
The adjoint commutes with left placement. (The vendored @[simp] is dropped: it would loop
with map_star.)
The adjoint commutes with right placement.
opTensor is linear in the left factor: subtraction.
Left placement commutes with subtraction.
Right placement commutes with subtraction.
opTensor is linear in the left factor: real scalar multiplication.
opTensor is linear in the right factor: real scalar multiplication.
opTensor is additive in the left factor.
opTensor is additive in the right factor.
Left placement commutes with finite sums.
Right placement commutes with finite sums.
Pull a finite sum out of the left factor of opTensor.
Pull a finite sum out of the right factor of opTensor.
Pull an unindexed finite-type sum out of the left factor of opTensor.
Pull an unindexed finite-type sum out of the right factor of opTensor.
Positivity of the placements #
Left placement preserves positivity.
Right placement preserves positivity.
Left placement is monotone.
Right placement is monotone.
Left placement preserves the bound ≤ 1.
Right placement preserves the bound ≤ 1.
Positivity is preserved by opTensor: a product of commuting positive operators.
opTensor is monotone in the left factor against a positive right factor.
opTensor is monotone in the right factor against a positive left factor.
If 0 ≤ A and B ≤ 1, then A ⊗ B ≤ A ⊗ 1 = L A.
A product placement of two effects is an effect: A ⊗ B ≤ L A ≤ 1.