AFTD Auto-Formalizing Theoretical Domains

qutrit_block_four_products_to_bipartite

theoremverified

The four spectral block sums combine into a four-product bipartite matrix.

Statement

theorem qutrit_block_four_products_to_bipartite
    (B C : Matrix (Fin 3) (Fin 3) ℂ)
    (v : Fin 4 → Fin 3 → ℂ) (a b : Fin 4 → ℂ)
    (hv : ∀ t i, star (v t i) = v t i)
    (h0 : (1 : Matrix (Fin 3) (Fin 3) ℂ) =
      ∑ t, (a t * star (a t)) • vecMulVec (v t) (star (v t)))
    (hB : B = ∑ t, (a t * star (b t)) • vecMulVec (v t) (star (v t)))
    (hC : C = ∑ t, (b t * star (b t)) • vecMulVec (v t) (star (v t))) :
    ∀ (i j : Fin 3) (p q : Fin 2),
      (if p = 0 then if q = 0 then (1 : Matrix (Fin 3) (Fin 3) ℂ) i j else B i j
       else if q = 0 then Bᴴ i j else C i j) =
      ∑ t, (v t i * ![a t, b t] p) * star (v t j * ![a t, b t] q)
Source
Product-decomposition helper for OP-693.
Verified
12 Nov 2026
Axioms
Classical.choiceQuot.soundpropext

The proof, explained

The theorem establishes that the four block sums for I, B, Bᴴ, and C assemble into a single sum of outer products of bipartite vectors (v t ⊗ [a t, b t]ᵀ). The proof proceeds entrywise by fixing the matrix indices (i, j) and the block indices (p, q), then performing an exhaustive case split on (p, q) ∈ {0, 1}². In each of the four block cases, expanding the matrix operations and using the reality of the spatial vectors v t reduces the goal to the corresponding spectral hypothesis.

  1. Fix indices i, j ∈ Fin 3 and block indices p, q ∈ Fin 2, and extract the entrywise scalar equations for I, B, and C.

    We introduce the index variables. Applying entry evaluation at (i, j) to the given matrix equations gives scalar identities for the (i, j) entries of I, B, and C. We also evaluate the equation for B at transposed indices (j, i) to prepare for the conjugate transpose block Bᴴ.

    lines 18–22

    uses congrArg

      intro i j p q
      have h0' := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M i j) h0
      have hB' := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M i j) hB
      have hC' := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M i j) hC
      have hBt := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M j i) hB
  2. Split into four cases according to the block coordinates (p, q) ∈ {0, 1}².

    Since Fin 2 has only two elements, an exhaustive case analysis on p and q reduces the verification to checking the four blocks (0, 0), (0, 1), (1, 0), and (1, 1) of the 2 × 2 block matrix individually.

    line 23

      fin_cases p <;> fin_cases q
  3. The (0, 0) block identity holds: I i j = ∑ t, v t i * a t * star (v t j * a t).

    When p = 0 and q = 0, the block indexing yields the entry of the identity matrix I i j, and the 2-vector ![a t, b t] evaluates to a t at both factors. Because v t has real entries, star (v t j) = v t j, so the summand simplifies to (a t * star (a t)) * (v t i * v t j), matching the (i, j) entry of the given expansion for I.

    lines 24–25

    uses Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, smul_eq_mul, mul_comm, mul_left_comm, mul_assoc

      · simpa [Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, hv,
          smul_eq_mul, mul_comm, mul_left_comm, mul_assoc] using h0'
  4. The (0, 1) block identity holds: B i j = ∑ t, v t i * a t * star (v t j * b t).

    When p = 0 and q = 1, the block expression simplifies to B i j. The vector ![a t, b t] evaluates to a t at index 0 and b t at index 1. Using the reality of v t and the commutativity and associativity of multiplication, the summand rearranges to (a t * star (b t)) * (v t i * v t j), which equals the (i, j) entry of the expansion for B.

    lines 26–27

    uses Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, smul_eq_mul, mul_comm, mul_left_comm, mul_assoc

      · simpa [Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, hv,
          smul_eq_mul, mul_comm, mul_left_comm, mul_assoc] using hB'
  5. The (1, 0) block identity holds: Bᴴ i j = ∑ t, v t i * b t * star (v t j * a t).

    When p = 1 and q = 0, the block expression yields Bᴴ i j = star (B j i). Taking the complex conjugate of the (j, i) entry of B, distributing the conjugation over the sum and product, and using the reality of v t, the summand becomes star (a t * star (b t) * (v t j * v t i)) = (b t * star (a t)) * (v t i * v t j), which matches the right-hand side.

    lines 28–31

    uses congrArg, Matrix.conjTranspose_apply, Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, star_sum, smul_eq_mul, mul_comm, mul_left_comm, mul_assoc

      · have hBt' := congrArg star hBt
        simpa [Matrix.conjTranspose_apply, Matrix.sum_apply, Matrix.smul_apply,
          Matrix.vecMulVec_apply, star_sum, hv, smul_eq_mul,
          mul_comm, mul_left_comm, mul_assoc] using hBt'
  6. The (1, 1) block identity holds: C i j = ∑ t, v t i * b t * star (v t j * b t).

    When p = 1 and q = 1, the block expression simplifies to C i j, and the vector ![a t, b t] evaluates to b t at both factors. Using the reality of v t and ring arithmetic in ℂ, the summand simplifies to (b t * star (b t)) * (v t i * v t j), which matches the (i, j) entry of the expansion for C.

    lines 32–33

    uses Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, smul_eq_mul, mul_comm, mul_left_comm, mul_assoc

      · simpa [Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, hv,
          smul_eq_mul, mul_comm, mul_left_comm, mul_assoc] using hC'
congrArg
Applying a function to both sides of an equality yields an equality.
Matrix.conjTranspose_apply
The (i, j) entry of the conjugate transpose of a matrix M is the complex conjugate of M j i.
Matrix.smul_apply
The (i, j) entry of a scalar multiple r • A is r times A i j.
Matrix.sum_apply
The (i, j) entry of a sum of matrices is the sum of their (i, j) entries.
Matrix.vecMulVec_apply
The (i, j) entry of the outer product vecMulVec w v is w i * v j.
mul_assoc
Multiplication is associative: (a * b) * c = a * (b * c).
mul_comm
Multiplication is commutative: a * b = b * a.
mul_left_comm
Multiplication satisfies left-commutativity: a * (b * c) = b * (a * c).
smul_eq_mul
Scalar multiplication of elements in a ring agrees with standard multiplication.
star_sum
Complex conjugation distributes over finite sums.

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

open Matrixopen scoped BigOperators Matrix ComplexOrderset_option backward.isDefEq.respectTransparency falseset_option linter.unusedSimpArgs falsetheorem qutrit_block_four_products_to_bipartite    (B C : Matrix (Fin 3) (Fin 3) ℂ)    (v : Fin 4 → Fin 3 → ℂ) (a b : Fin 4 → ℂ)    (hv : ∀ t i, star (v t i) = v t i)    (h0 : (1 : Matrix (Fin 3) (Fin 3) ℂ) =      ∑ t, (a t * star (a t)) • vecMulVec (v t) (star (v t)))    (hB : B = ∑ t, (a t * star (b t)) • vecMulVec (v t) (star (v t)))    (hC : C = ∑ t, (b t * star (b t)) • vecMulVec (v t) (star (v t))) :    ∀ (i j : Fin 3) (p q : Fin 2),      (if p = 0 then if q = 0 then (1 : Matrix (Fin 3) (Fin 3) ℂ) i j else B i j       else if q = 0 then Bᴴ i j else C i j) =      ∑ t, (v t i * ![a t, b t] p) * star (v t j * ![a t, b t] q) := by  intro i j p q  have h0' := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M i j) h0  have hB' := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M i j) hB  have hC' := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M i j) hC  have hBt := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M j i) hB  fin_cases p <;> fin_cases q  · simpa [Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, hv,      smul_eq_mul, mul_comm, mul_left_comm, mul_assoc] using h0'  · simpa [Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, hv,      smul_eq_mul, mul_comm, mul_left_comm, mul_assoc] using hB'  · have hBt' := congrArg star hBt    simpa [Matrix.conjTranspose_apply, Matrix.sum_apply, Matrix.smul_apply,      Matrix.vecMulVec_apply, star_sum, hv, smul_eq_mul,      mul_comm, mul_left_comm, mul_assoc] using hBt'  · simpa [Matrix.sum_apply, Matrix.smul_apply, Matrix.vecMulVec_apply, hv,      smul_eq_mul, mul_comm, mul_left_comm, mul_assoc] using hC'
See it in the graphDiscuss this resultChallenge it