AFTD Auto-Formalizing Theoretical Domains

qutrit_ppt_rank_four_bordered_normal_if_phase

theoremverified

The phase equation turns a symmetric qutrit block with a real rank-one Schur update into a normal complex symmetric bordered matrix.

Statement

theorem qutrit_ppt_rank_four_bordered_normal_if_phase
    (B : Matrix (Fin 3) (Fin 3) ℂ) (u : Fin 3 → ℂ) (c s a b : ℝ)
    (hB : B.transpose = B)
    (hC : ∀ i j, star ((Bᴴ * B + vecMulVec u (star u)) i j) =
      (Bᴴ * B + vecMulVec u (star u)) i j)
    (hunit : c*c + s*s = 1)
    (hphase : let R : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).re
      let S : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).im
      let x0 : Fin 3 → ℝ := fun i => (star (u i)).re
      let y0 : Fin 3 → ℝ := fun i => (star (u i)).im
      ∀ i, (R.mulVec (fun j => s*x0 j + c*y0 j)) i -
        (S.mulVec (fun j => c*x0 j - s*y0 j)) i +
          b*(c*x0 i - s*y0 i) - a*(s*x0 i + c*y0 i) = 0) :
    let ξ : ℂ := (c : ℂ) + Complex.I * (s : ℂ)
    let W : Matrix (Fin 3) (Fin 1) ℂ := fun i _ => ξ * star (u i)
    let Z : Matrix (Fin 1) (Fin 1) ℂ := fun _ _ => (a : ℂ) + Complex.I * (b : ℂ)
    let N := Matrix.fromBlocks B W W.transpose Z
    Nᴴ * N = N * Nᴴ
Source
Helper for OP-693, based on the rank-four PPT source and the normal completion route in https://arxiv.org/abs/0903.0090.
Verified
12 Nov 2026
Axioms
Classical.choiceQuot.soundpropext

The proof, explained

To prove that the bordered matrix N = fromBlocks B W Wᵀ Z is normal, the proof reduces normality to four block matrix equations, showing that the (2,1) block is the conjugate transpose of the (1,2) block and that the (2,2) scalar block holds automatically by commutativity. The (1,1) block equation holds because B is complex symmetric and the rank-one Schur complement Bᴴ * B + u uᴴ has real entries. The (1,2) block equation is satisfied when the phase factor ξ = c + i s rotates u* into real components x and y solving the real phase equation. Finally, the theorem verifies these hypotheses from c² + s² = 1 and applies the completion lemma to conclude Nᴴ * N = N * Nᴴ.

  1. Normality of the bordered block matrix N = fromBlocks B W Wᵀ Z reduces to four block identities, where the (2,1) block identity is the conjugate transpose of the (1,2) block identity.

    Multiplying out Nᴴ * N and N * Nᴴ using block multiplication formulas Matrix.fromBlocks_conjTranspose and Matrix.fromBlocks_multiply produces 2x2 block matrices. Conjugate transposing the assumed (1,2) block identity h12 yields the (2,1) block identity h21 because (Bᴴ * W + Wᵀᴴ * Z)ᴴ = Wᴴ * B + Zᴴ * Wᵀ and similarly for the right-hand side.

    lines 15–20

    uses Matrix.fromBlocks_conjTranspose, Matrix.fromBlocks_multiply, congrArg, Matrix.conjTranspose_add, Matrix.conjTranspose_mul

      dsimp only
      rw [Matrix.fromBlocks_conjTranspose, Matrix.fromBlocks_multiply,
        Matrix.fromBlocks_multiply]
      have h21 : Wᴴ * B + Zᴴ * W.transpose = W.transpose * Bᴴ + Z * Wᴴ := by
        have h := congrArg Matrix.conjTranspose h12
        simpa [Matrix.conjTranspose_add, Matrix.conjTranspose_mul] using h
  2. The (2,2) scalar block identity holds by commutativity of complex multiplication, establishing normality of N from the (1,1) and (1,2) block conditions. automation

    Since Z is a 1x1 matrix and W has a single column, the (2,2) block is a 1x1 matrix whose single entry is a sum of products of complex numbers and their conjugates. By commutativity of multiplication in ℂ, star(z) * z = z * star(z), so the sums match term by term. Substituting the block identities h11, h12, h21, and h22 completes the proof of Nᴴ * N = N * Nᴴ.

    lines 21–30

    uses Fin.sum_univ_one, Fin.sum_univ_three, Fin.eq_zero

      have h22 : Wᴴ * W + Zᴴ * Z = W.transpose * W.transposeᴴ + Z * Zᴴ := by
        ext i j
        fin_cases i
        fin_cases j
        simp only [Matrix.add_apply, Matrix.mul_apply, Fin.sum_univ_one,
          Matrix.conjTranspose_apply, Matrix.transpose_apply]
        simp only [Fin.sum_univ_three]
        simp only [Fin.eq_zero]
        ring
      rw [h11, h12, h21, h22]
  3. If B is symmetric and Bᴴ * B + u uᴴ has real entries, then the (1,1) block equation Bᴴ * B + Wᵀᴴ * Wᵀ = B * Bᴴ + W * Wᴴ holds for W = ξ * star(u) with |ξ|² = 1. automation

    Evaluating each entry (i, j), (Wᵀᴴ * Wᵀ) i j simplifies to u i * star(u j) and (W * Wᴴ) i j simplifies to star(u i) * u j because ξ * star(ξ) = 1. Symmetry of B implies B i k = B k i. The condition that Bᴴ * B + u uᴴ has real entries asserts that each entry equals its complex conjugate; combining this equality with ξ * star(ξ) = 1 via linear_combination cancels all remaining terms.

    lines 40–60

    uses congrArg, Matrix.transpose_apply, star_mul, star_star, Finset.sum_congr

      dsimp only
      ext i j
      have hs (a b : Fin 3) : B a b = B b a := by
        have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M b a) hB
        simpa only [Matrix.transpose_apply] using h
      have hh := hC i j
      simp only [Matrix.add_apply, Matrix.mul_apply, Matrix.conjTranspose_apply,
        Matrix.vecMulVec_apply, Pi.star_apply, star_add, star_sum, star_mul, star_star] at hh
      simp only [Matrix.add_apply, Matrix.mul_apply, Matrix.conjTranspose_apply, Matrix.transpose_apply, Fin.sum_univ_one]
      dsimp [Matrix.transpose_apply, Matrix.conjTranspose_apply, Matrix.mul_apply]
      change (∑ k, star (B k i) * B k j) + star (ξ * star (u i)) * (ξ * star (u j)) =
        (∑ k, B i k * star (B j k)) + (ξ * star (u i)) * star (ξ * star (u j))
      simp only [hs i, hs j]
      simp only [star_mul, star_star]
      have hsum : (∑ k, star (B k j) * B k i) =
          ∑ k, B k i * star (B k j) := by
        apply Finset.sum_congr rfl
        intro k hk
        ring
      rw [hsum] at hh
      linear_combination -hh + (u i * star (u j) - star (u i) * u j) * hξ
  4. For real symmetric R and S, the phase equation implies the (1,2) block equation Bᴴ * W + Wᵀᴴ * Z = B * Wᵀᴴ + W * Zᴴ. automation

    Writing B = R + i S, W = x + i y, and Z = a + i b, the difference between the two sides of the (1,2) block equation is split into real and imaginary parts using Complex.ext. By symmetry of R and S (R k i = R i k and S k i = S i k), each coordinate simplifies to a scalar multiple of the phase relation (R *ᵥ y) i - (S *ᵥ x) i + b * x i - a * y i = 0, which is closed by linarith.

    lines 70–85

    uses congrArg, Matrix.transpose_apply, Matrix.mulVec, Fin.sum_univ_three, Complex.ext

      dsimp only
      ext i j
      fin_cases j
      have hr (k : Fin 3) : R k i = R i k := by
        have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℝ => M i k) hR
        simpa only [Matrix.transpose_apply] using h
      have hs (k : Fin 3) : S k i = S i k := by
        have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℝ => M i k) hS
        simpa only [Matrix.transpose_apply] using h
      have hh := hxy i
      simp only [Matrix.mulVec, dotProduct, Fin.sum_univ_three] at hh
      apply Complex.ext <;>
        simp [Matrix.add_apply, Matrix.mul_apply, Matrix.transpose_apply,
          Matrix.conjTranspose_apply, Fin.sum_univ_three, Fin.sum_univ_one,
          Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,
          hr, hs] <;> linarith
  5. The bordered matrix N is normal whenever the hypotheses of lemmas in767_bordered_h11 and in767_bordered_h12 are met.

    Normality reduces via in767_bordered_normality to checking the (1,1) and (1,2) block identities. The (1,1) block identity is supplied by in767_bordered_h11. For the (1,2) identity, identifying B with R + i S and W with x + i y allows in767_bordered_h12 to close the goal.

    lines 102–113

    uses in767_bordered_normality, in767_bordered_h11, in767_bordered_h12

      dsimp only
      apply in767_bordered_normality
      · exact in767_bordered_h11 B u ξ hB hC hξ
      · have h := in767_bordered_h12 R S x y a b hR hS hxy
        have hb : B = fun i j => (R i j : ℂ) + Complex.I * (S i j : ℂ) := by
          ext i j
          exact hRS i j
        have hw : (fun (i : Fin 3) (_ : Fin 1) => ξ * star (u i)) =
            (fun (i : Fin 3) (_ : Fin 1) => (x i : ℂ) + Complex.I * (y i : ℂ)) := by
          funext i j
          exact huw i
        simpa only [hb, hw] using h
  6. The real and imaginary parts R and S of B are symmetric matrices.

    From the symmetry assumption Bᵀ = B, we have B i j = B j i. Taking real and imaginary parts via Complex.re and Complex.im shows R j i = R i j and S j i = S i j, which means Rᵀ = R and Sᵀ = S.

    lines 133–146

    uses congrArg, Matrix.transpose_apply, Complex.re, Complex.im

      dsimp only
      let R : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).re
      let S : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).im
      let x : Fin 3 → ℝ := fun i => c * (star (u i)).re - s * (star (u i)).im
      let y : Fin 3 → ℝ := fun i => s * (star (u i)).re + c * (star (u i)).im
      have hsym (i j : Fin 3) : B i j = B j i := by
        have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M j i) hB
        simpa only [Matrix.transpose_apply] using h
      have hR : R.transpose = R := by
        ext i j
        exact congrArg Complex.re (hsym j i)
      have hS : S.transpose = S := by
        ext i j
        exact congrArg Complex.im (hsym j i)
  7. B decomposes as R + i S and the phase factor ξ = c + i s is unimodular (|ξ|² = 1). automation

    Decomposing each entry of B into real and imaginary parts follows from Complex.re_add_im. The unimodularity condition (c + i s) * star(c + i s) = 1 expands to c * c + s * s = 1 in the real part and 0 in the imaginary part, which is discharged by linarith using the hypothesis hunit.

    lines 147–152

    uses Complex.re_add_im, mul_comm, Complex.ext, Complex.mul_re, Complex.mul_im

      have hRS : ∀ i j, B i j = (R i j : ℂ) + Complex.I * (S i j : ℂ) := by
        intro i j
        dsimp [R, S]
        simpa only [mul_comm] using (Complex.re_add_im (B i j)).symm
      have hξ : ((c : ℂ) + Complex.I * (s : ℂ)) * star ((c : ℂ) + Complex.I * (s : ℂ)) = 1 := by
        apply Complex.ext <;> simp [Complex.mul_re, Complex.mul_im] <;> linarith
  8. The vector W = ξ * star(u) decomposes into real components x + i y that satisfy the phase condition, proving that N is normal.

    Expanding ξ * star(u i) = (c + i s) * ((star(u i)).re + i * (star(u i)).im) matches the definitions x i = c * (star(u i)).re - s * (star(u i)).im and y i = s * (star(u i)).re + c * (star(u i)).im. All conditions of the completion lemma in767_bordered_completion are thus verified, concluding Nᴴ * N = N * Nᴴ.

    lines 153–157

    uses Complex.ext, Complex.mul_re, Complex.mul_im, in767_bordered_completion

      have huw : ∀ i, ((c : ℂ) + Complex.I * (s : ℂ)) * star (u i) =
          (x i : ℂ) + Complex.I * (y i : ℂ) := by
        intro i
        apply Complex.ext <;> simp [x, y, Complex.mul_re, Complex.mul_im] <;> ring
      exact in767_bordered_completion B u _ R S x y a b hB hRS hR hS hC hξ huw hphase
Matrix.fromBlocks_conjTranspose
The conjugate transpose of a 2x2 block matrix is the block matrix with transposed blocks and conjugate-transposed entries.
Matrix.fromBlocks_multiply
Multiplication of 2x2 block matrices follows standard block multiplication.
congrArg
If two inputs are equal, a function applied to them yields equal outputs.
Matrix.conjTranspose_add
The conjugate transpose distributes over matrix addition.
Matrix.conjTranspose_mul
The conjugate transpose reverses the order of matrix multiplication.
Fin.sum_univ_one
A sum indexed by the singleton type Fin 1 evaluates to its single term at index 0.
Fin.sum_univ_three
A sum indexed by Fin 3 evaluates to the sum of terms at indices 0, 1, and 2.
Fin.eq_zero
Every element of the singleton type Fin 1 is equal to 0.
Matrix.transpose_apply
The (i, j) entry of the transpose of a matrix M is M j i.
star_mul
Complex conjugation reverses the order of multiplication: (r * s)* = s* * r*.
star_star
Complex conjugation is an involution: (r*)* = r.
Finset.sum_congr
Two sums over identical finite sets with pointwise equal summands are equal.
Matrix.mulVec
Matrix-vector multiplication computes the dot product of each matrix row with the vector.
Complex.ext
Two complex numbers are equal if and only if their real and imaginary parts are equal.
in767_bordered_normality
A bordered matrix fromBlocks B W Wᵀ Z is normal if the (1,1) and (1,2) block normality conditions hold.
in767_bordered_h11
Under symmetry of B and unimodularity of ξ, reality of Bᴴ * B + u uᴴ implies the (1,1) block normality condition.
in767_bordered_h12
For real symmetric R and S, the phase equation implies the (1,2) block normality condition for B = R + i S, W = x + i y, and Z = a + i b.
Complex.re
The real part projection of a complex number.
Complex.im
The imaginary part projection of a complex number.
Complex.re_add_im
Every complex number equals its real part plus i times its imaginary part.
mul_comm
Multiplication in a commutative ring satisfies a * b = b * a.
Complex.mul_re
The real part of a product of complex numbers: Re(z * w) = Re(z) * Re(w) - Im(z) * Im(w).
Complex.mul_im
The imaginary part of a product of complex numbers: Im(z * w) = Re(z) * Im(w) + Im(z) * Re(w).
in767_bordered_completion
Combines the block normality lemmas to prove normality of the bordered matrix from its components.

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 falseset_option linter.unnecessarySeqFocus false-- The normality of a symmetric bordered block reduces to its first row.private lemma in767_bordered_normality    (B : Matrix (Fin 3) (Fin 3) ℂ)    (W : Matrix (Fin 3) (Fin 1) ℂ)    (Z : Matrix (Fin 1) (Fin 1) ℂ)    (h11 : Bᴴ * B + W.transposeᴴ * W.transpose = B * Bᴴ + W * Wᴴ)    (h12 : Bᴴ * W + W.transposeᴴ * Z = B * W.transposeᴴ + W * Zᴴ) :    let N := Matrix.fromBlocks B W W.transpose Z    Nᴴ * N = N * Nᴴ := by  dsimp only  rw [Matrix.fromBlocks_conjTranspose, Matrix.fromBlocks_multiply,    Matrix.fromBlocks_multiply]  have h21 : Wᴴ * B + Zᴴ * W.transpose = W.transpose * Bᴴ + Z * Wᴴ := by    have h := congrArg Matrix.conjTranspose h12    simpa [Matrix.conjTranspose_add, Matrix.conjTranspose_mul] using h  have h22 : Wᴴ * W + Zᴴ * Z = W.transpose * W.transposeᴴ + Z * Zᴴ := by    ext i j    fin_cases i    fin_cases j    simp only [Matrix.add_apply, Matrix.mul_apply, Fin.sum_univ_one,      Matrix.conjTranspose_apply, Matrix.transpose_apply]    simp only [Fin.sum_univ_three]    simp only [Fin.eq_zero]    ring  rw [h11, h12, h21, h22]private lemma in767_bordered_h11    (B : Matrix (Fin 3) (Fin 3) ℂ) (u : Fin 3 → ℂ) (ξ : ℂ)    (hB : B.transpose = B)    (hC : ∀ i j, star ((Bᴴ * B + vecMulVec u (star u)) i j) =      (Bᴴ * B + vecMulVec u (star u)) i j)    (hξ : ξ * star ξ = 1) :    let W : Matrix (Fin 3) (Fin 1) ℂ := fun i _ => ξ * star (u i)    Bᴴ * B + W.transposeᴴ * W.transpose = B * Bᴴ + W * Wᴴ := by  dsimp only  ext i j  have hs (a b : Fin 3) : B a b = B b a := by    have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M b a) hB    simpa only [Matrix.transpose_apply] using h  have hh := hC i j  simp only [Matrix.add_apply, Matrix.mul_apply, Matrix.conjTranspose_apply,    Matrix.vecMulVec_apply, Pi.star_apply, star_add, star_sum, star_mul, star_star] at hh  simp only [Matrix.add_apply, Matrix.mul_apply, Matrix.conjTranspose_apply, Matrix.transpose_apply, Fin.sum_univ_one]  dsimp [Matrix.transpose_apply, Matrix.conjTranspose_apply, Matrix.mul_apply]  change (∑ k, star (B k i) * B k j) + star (ξ * star (u i)) * (ξ * star (u j)) =    (∑ k, B i k * star (B j k)) + (ξ * star (u i)) * star (ξ * star (u j))  simp only [hs i, hs j]  simp only [star_mul, star_star]  have hsum : (∑ k, star (B k j) * B k i) =      ∑ k, B k i * star (B k j) := by    apply Finset.sum_congr rfl    intro k hk    ring  rw [hsum] at hh  linear_combination -hh + (u i * star (u j) - star (u i) * u j) * hξprivate lemma in767_bordered_h12    (R S : Matrix (Fin 3) (Fin 3) ℝ) (x y : Fin 3 → ℝ) (a b : ℝ)    (hR : R.transpose = R) (hS : S.transpose = S)    (hxy : ∀ i, (R.mulVec y) i - (S.mulVec x) i + b*x i - a*y i = 0) :    let B : Matrix (Fin 3) (Fin 3) ℂ := fun i j => (R i j : ℂ) + Complex.I * (S i j : ℂ)    let W : Matrix (Fin 3) (Fin 1) ℂ := fun i _ => (x i : ℂ) + Complex.I * (y i : ℂ)    let Z : Matrix (Fin 1) (Fin 1) ℂ := fun _ _ => (a : ℂ) + Complex.I * (b : ℂ)    Bᴴ * W + W.transposeᴴ * Z = B * W.transposeᴴ + W * Zᴴ := by  dsimp only  ext i j  fin_cases j  have hr (k : Fin 3) : R k i = R i k := by    have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℝ => M i k) hR    simpa only [Matrix.transpose_apply] using h  have hs (k : Fin 3) : S k i = S i k := by    have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℝ => M i k) hS    simpa only [Matrix.transpose_apply] using h  have hh := hxy i  simp only [Matrix.mulVec, dotProduct, Fin.sum_univ_three] at hh  apply Complex.ext <;>    simp [Matrix.add_apply, Matrix.mul_apply, Matrix.transpose_apply,      Matrix.conjTranspose_apply, Fin.sum_univ_three, Fin.sum_univ_one,      Complex.add_re, Complex.add_im, Complex.mul_re, Complex.mul_im,      hr, hs] <;> linarithprivate lemma in767_bordered_completion    (B : Matrix (Fin 3) (Fin 3) ℂ) (u : Fin 3 → ℂ) (ξ : ℂ)    (R S : Matrix (Fin 3) (Fin 3) ℝ) (x y : Fin 3 → ℝ) (a b : ℝ)    (hB : B.transpose = B)    (hRS : ∀ i j, B i j = (R i j : ℂ) + Complex.I * (S i j : ℂ))    (hR : R.transpose = R) (hS : S.transpose = S)    (hC : ∀ i j, star ((Bᴴ * B + vecMulVec u (star u)) i j) =      (Bᴴ * B + vecMulVec u (star u)) i j)    (hξ : ξ * star ξ = 1)    (huw : ∀ i, ξ * star (u i) = (x i : ℂ) + Complex.I * (y i : ℂ))    (hxy : ∀ i, (R.mulVec y) i - (S.mulVec x) i + b*x i - a*y i = 0) :    let W : Matrix (Fin 3) (Fin 1) ℂ := fun i _ => ξ * star (u i)    let Z : Matrix (Fin 1) (Fin 1) ℂ := fun _ _ => (a : ℂ) + Complex.I * (b : ℂ)    let N := Matrix.fromBlocks B W W.transpose Z    Nᴴ * N = N * Nᴴ := by  dsimp only  apply in767_bordered_normality  · exact in767_bordered_h11 B u ξ hB hC hξ  · have h := in767_bordered_h12 R S x y a b hR hS hxy    have hb : B = fun i j => (R i j : ℂ) + Complex.I * (S i j : ℂ) := by      ext i j      exact hRS i j    have hw : (fun (i : Fin 3) (_ : Fin 1) => ξ * star (u i)) =        (fun (i : Fin 3) (_ : Fin 1) => (x i : ℂ) + Complex.I * (y i : ℂ)) := by      funext i j      exact huw i    simpa only [hb, hw] using htheorem qutrit_ppt_rank_four_bordered_normal_if_phase    (B : Matrix (Fin 3) (Fin 3) ℂ) (u : Fin 3 → ℂ) (c s a b : ℝ)    (hB : B.transpose = B)    (hC : ∀ i j, star ((Bᴴ * B + vecMulVec u (star u)) i j) =      (Bᴴ * B + vecMulVec u (star u)) i j)    (hunit : c*c + s*s = 1)    (hphase : let R : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).re      let S : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).im      let x0 : Fin 3 → ℝ := fun i => (star (u i)).re      let y0 : Fin 3 → ℝ := fun i => (star (u i)).im      ∀ i, (R.mulVec (fun j => s*x0 j + c*y0 j)) i -        (S.mulVec (fun j => c*x0 j - s*y0 j)) i +          b*(c*x0 i - s*y0 i) - a*(s*x0 i + c*y0 i) = 0) :    let ξ : ℂ := (c : ℂ) + Complex.I * (s : ℂ)    let W : Matrix (Fin 3) (Fin 1) ℂ := fun i _ => ξ * star (u i)    let Z : Matrix (Fin 1) (Fin 1) ℂ := fun _ _ => (a : ℂ) + Complex.I * (b : ℂ)    let N := Matrix.fromBlocks B W W.transpose Z    Nᴴ * N = N * Nᴴ := by  dsimp only  let R : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).re  let S : Matrix (Fin 3) (Fin 3) ℝ := fun i j => (B i j).im  let x : Fin 3 → ℝ := fun i => c * (star (u i)).re - s * (star (u i)).im  let y : Fin 3 → ℝ := fun i => s * (star (u i)).re + c * (star (u i)).im  have hsym (i j : Fin 3) : B i j = B j i := by    have h := congrArg (fun M : Matrix (Fin 3) (Fin 3) ℂ => M j i) hB    simpa only [Matrix.transpose_apply] using h  have hR : R.transpose = R := by    ext i j    exact congrArg Complex.re (hsym j i)  have hS : S.transpose = S := by    ext i j    exact congrArg Complex.im (hsym j i)  have hRS : ∀ i j, B i j = (R i j : ℂ) + Complex.I * (S i j : ℂ) := by    intro i j    dsimp [R, S]    simpa only [mul_comm] using (Complex.re_add_im (B i j)).symm  have hξ : ((c : ℂ) + Complex.I * (s : ℂ)) * star ((c : ℂ) + Complex.I * (s : ℂ)) = 1 := by    apply Complex.ext <;> simp [Complex.mul_re, Complex.mul_im] <;> linarith  have huw : ∀ i, ((c : ℂ) + Complex.I * (s : ℂ)) * star (u i) =      (x i : ℂ) + Complex.I * (y i : ℂ) := by    intro i    apply Complex.ext <;> simp [x, y, Complex.mul_re, Complex.mul_im] <;> ring  exact in767_bordered_completion B u _ R S x y a b hB hRS hR hS hC hξ huw hphase
See it in the graphDiscuss this resultChallenge it