AFTD Auto-Formalizing Theoretical Domains

is_bipartite_locally_encodable_norm_one

theoremverifiedformalization

For nonempty finite types m and n, every locally encodable state ψ in EuclideanSpace ℂ (m × n) satisfies ‖ψ‖ = 1.

Statement

theorem is_bipartite_locally_encodable_norm_one {m n : Type*} [Fintype m] [DecidableEq m]
    [Fintype n] [DecidableEq n] [Nonempty m] [Nonempty n]
    {ψ : EuclideanSpace ℂ (m × n)} (h : is_bipartite_locally_encodable ψ) :
    ‖ψ‖ = 1
Formalizes
arXiv:2611.16921 Sec. II.1
Verified
14 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 1
  • is_bipartite_locally_encodableA bipartite quantum state ψ in EuclideanSpace ℂ (m × n) is locally encodable if there exists an orthonormal basis B of EuclideanSpace ℂ (m…

Read back from the Lean

For any finite, nonempty types $m$ and $n$ with decidable equality, and any vector $\psi \in \mathrm{EuclideanSpace}\ \mathbb{C}\ (m \times n)$, if $\psi$ is bipartite locally encodable, then the Euclidean norm of $\psi$ is equal to 1 ($\|\psi\| = 1$).

Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.

The proof, explained

By definition of local encodability, there is an orthonormal basis B such that every basis element is the image of ψ under some local unitary operator uA ⊗ uB. Since the index sets m and n are nonempty, we choose an index j, giving a basis vector B(j) = (uA ⊗ uB) ψ. The Kronecker product of unitary matrices is unitary, and the matrix-to-operator representation preserves the star-algebra structure, making the induced operator unitary and therefore isometric. Because B is orthonormal, ‖B(j)‖ = 1, which implies ‖ψ‖ = ‖(uA ⊗ uB) ψ‖ = ‖B(j)‖ = 1.

  1. Obtain an orthonormal basis B, an index j, and local unitaries uA and uB expressing B(j) in terms of ψ.

    By definition of local encodability, there is an orthonormal basis B whose elements are all local unitary transforms of ψ. Because m and n are nonempty, the product type m × n is nonempty, so we choose an index j. Specializing the local encodability hypothesis at j yields unitary matrices uA on ℂᵐ and uB on ℂⁿ such that B(j) = (uA ⊗ uB) ψ.

    lines 6–8

      obtain ⟨B, hB⟩ := h
      obtain ⟨j⟩ := (inferInstance : Nonempty (m × n))
      obtain ⟨uA, uB, hBj⟩ := hB j
  2. The Kronecker product M = uA ⊗ uB is unitary.

    We define M as the Kronecker product of uA and uB. Since both uA and uB are unitary matrices, their Kronecker product is unitary by Matrix.kronecker_mem_unitary.

    lines 10–12

    uses Matrix.kronecker_mem_unitary

      set M : Matrix (m × n) (m × n) ℂ := Matrix.kronecker (uA : Matrix m m ℂ) (uB : Matrix n n ℂ)
        with hM
      have hmem : M ∈ Matrix.unitaryGroup (m × n) ℂ := Matrix.kronecker_mem_unitary uA.2 uB.2
  3. The matrix-to-operator representation preserves adjoints, products, and identity.

    The mapping Matrix.toEuclideanCLM from matrices to continuous linear operators on Euclidean space is an equivalence of star-algebras. Consequently, it commutes with taking adjoints (hstar), preserves multiplication (hmul), and sends the identity matrix to the identity operator (hone).

    lines 13–23

      have hstar : star (Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M)
          = Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) (star M) :=
        ((Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ)).map_star' M).symm
      have hmul : ∀ A B : Matrix (m × n) (m × n) ℂ,
          Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) A *
              Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) B
            = Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) (A * B) :=
        fun A B => ((Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ)).map_mul A B).symm
      have hone : Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) (1 : Matrix (m × n) (m × n) ℂ)
          = 1 :=
        (Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ)).map_one
  4. The continuous linear map induced by M is unitary.

    By Unitary.mem_iff, an operator is unitary if its product with its adjoint on either side is the identity. Rewriting using the preservation of adjoints and products reduces this to the fact that M is a unitary matrix (M* M = 1 and M M* = 1), so the induced operator is unitary.

    lines 25–30

    uses Unitary.mem_iff

      have hU : Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M ∈
          unitary (EuclideanSpace ℂ (m × n) →L[ℂ] EuclideanSpace ℂ (m × n)) := by
        rw [Unitary.mem_iff]
        constructor
        · rw [hstar, hmul, hmem.1, hone]
        · rw [hstar, hmul, hmem.2, hone]
  5. The induced operator preserves vector norms and maps ψ to B(j).

    Since the operator induced by M is unitary, it preserves norms by ContinuousLinearMap.norm_map_of_mem_unitary, giving ‖M ψ‖ = ‖ψ‖. Furthermore, Matrix.coe_toEuclideanCLM_eq_toEuclideanLin equates the continuous linear map with the linear map, so evaluating it on ψ yields B(j) via congrArg.

    lines 31–35

    uses ContinuousLinearMap.norm_map_of_mem_unitary, Matrix.coe_toEuclideanCLM_eq_toEuclideanLin, congrArg

      have hnorm : ‖(Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M) ψ‖ = ‖ψ‖ :=
        ContinuousLinearMap.norm_map_of_mem_unitary hU ψ
      have happ : (Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M) ψ = B j := by
        rw [hBj]
        exact congrArg (fun f => f ψ) (Matrix.coe_toEuclideanCLM_eq_toEuclideanLin M)
  6. The norm of ψ is 1.

    Rewriting with ‖ψ‖ = ‖M ψ‖ and M ψ = B(j) reduces the goal to showing ‖B(j)‖ = 1. Since B is an orthonormal basis, every basis vector has norm 1, which closes the goal.

    lines 36–37

      rw [← hnorm, happ]
      exact B.orthonormal.1 j
Matrix.kronecker_mem_unitary
The Kronecker product of two unitary matrices is itself a unitary matrix.
Unitary.mem_iff
An element U of a star monoid is unitary if and only if star U * U = 1 and U * star U = 1.
ContinuousLinearMap.norm_map_of_mem_unitary
A unitary continuous linear map on a Hilbert space preserves the norm of every vector.
Matrix.coe_toEuclideanCLM_eq_toEuclideanLin
The continuous linear map induced by a matrix coincides with the linear map induced by that matrix.
congrArg
Applying a function to equal inputs yields equal outputs (congruence of arguments).

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

/-- Any locally encodable bipartite state in a nonempty system has norm 1. -/theorem is_bipartite_locally_encodable_norm_one {m n : Type*} [Fintype m] [DecidableEq m]    [Fintype n] [DecidableEq n] [Nonempty m] [Nonempty n]    {ψ : EuclideanSpace ℂ (m × n)} (h : is_bipartite_locally_encodable ψ) :    ‖ψ‖ = 1 := by  obtain ⟨B, hB⟩ := h  obtain ⟨j⟩ := (inferInstance : Nonempty (m × n))  obtain ⟨uA, uB, hBj⟩ := hB j  -- the local unitary `uA ⊗ₖ uB` is unitary  set M : Matrix (m × n) (m × n) ℂ := Matrix.kronecker (uA : Matrix m m ℂ) (uB : Matrix n n ℂ)    with hM  have hmem : M ∈ Matrix.unitaryGroup (m × n) ℂ := Matrix.kronecker_mem_unitary uA.2 uB.2  have hstar : star (Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M)      = Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) (star M) :=    ((Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ)).map_star' M).symm  have hmul : ∀ A B : Matrix (m × n) (m × n) ℂ,      Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) A *          Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) B        = Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) (A * B) :=    fun A B => ((Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ)).map_mul A B).symm  have hone : Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) (1 : Matrix (m × n) (m × n) ℂ)      = 1 :=    (Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ)).map_one  -- hence the induced operator on `EuclideanSpace ℂ (m × n)` is unitary, so it is an isometry  have hU : Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M ∈      unitary (EuclideanSpace ℂ (m × n) →L[ℂ] EuclideanSpace ℂ (m × n)) := by    rw [Unitary.mem_iff]    constructor    · rw [hstar, hmul, hmem.1, hone]    · rw [hstar, hmul, hmem.2, hone]  have hnorm : ‖(Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M) ψ‖ = ‖ψ‖ :=    ContinuousLinearMap.norm_map_of_mem_unitary hU ψ  have happ : (Matrix.toEuclideanCLM (n := m × n) (𝕜 := ℂ) M) ψ = B j := by    rw [hBj]    exact congrArg (fun f => f ψ) (Matrix.coe_toEuclideanCLM_eq_toEuclideanLin M)  rw [← hnorm, happ]  exact B.orthonormal.1 j
See it in the graphDiscuss this resultChallenge it