/-- Let `x : (K →+* ℂ) → ℂ` such that `x_φ = conj x_(conj φ)` for all `φ : K →+* ℂ`, then the
representation of `commMap K x` on `stdBasis` is given (up to reindexing) by the product of
`matrixToStdBasis` by `x`. -/
theorem stdBasis_repr_eq_matrixToStdBasis_mul (x : (K →+* ℂ) → ℂ)
    (hx : ∀ φ, conj (x φ) = x (ComplexEmbedding.conjugate φ)) (c : index K) :
    ((stdBasis K).repr (commMap K x) c : ℂ) =
      (mulVec (matrixToStdBasis K) (x ∘ (indexEquiv K))) c := by
  simp_rw [commMap, matrixToStdBasis, LinearMap.coe_mk, AddHom.coe_mk,
    mulVec, dotProduct, Function.comp_apply, index, Fintype.sum_sum_type,
    diagonal_one, reindex_apply, ← Finset.univ_product_univ, Finset.sum_product,
    indexEquiv_apply_ofIsReal, Fin.sum_univ_two, indexEquiv_apply_ofIsComplex_fst,
    indexEquiv_apply_ofIsComplex_snd, smul_of, smul_cons, smul_eq_mul,
    mul_one, smul_empty, Equiv.prodComm_symm, Equiv.coe_prodComm]
  cases c with
  | inl w =>
      simp_rw [stdBasis_apply_ofIsReal, fromBlocks_apply₁₁, fromBlocks_apply₁₂,
        one_apply, Matrix.zero_apply, ite_mul, one_mul, zero_mul, Finset.sum_ite_eq,
        Finset.mem_univ, ite_true, add_zero, Finset.sum_const_zero, add_zero,
        ← conj_eq_iff_re, hx (embedding w.val), conjugate_embedding_eq_of_isReal w.prop]
  | inr c =>
    rcases c with ⟨w, j⟩
    fin_cases j
    · simp_rw [Fin.mk_zero, stdBasis_apply_ofIsComplex_fst, fromBlocks_apply₂₁,
        fromBlocks_apply₂₂, Matrix.zero_apply, submatrix_apply,
        blockDiagonal_apply, Prod.swap_prod_mk, ite_mul, zero_mul, Finset.sum_const_zero,
        zero_add, Finset.sum_add_distrib, Finset.sum_ite_eq, Finset.mem_univ, ite_true,
        of_apply, cons_val', cons_val_zero, cons_val_one,
        head_cons, ← hx (embedding w), re_eq_add_conj]
      field_simp
    · 

Proof state:
case inr.mk.tail.head
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (K →+* ℂ) → ℂ
hx : ∀ (φ : K →+* ℂ), (starRingEnd ℂ) (x φ) = x (ComplexEmbedding.conjugate φ)
w : { w // IsComplex w }
⊢ ↑(((stdBasis K).repr (fun w => (x (embedding ↑w)).re, fun w => x (embedding ↑w)))
        (Sum.inr (w, { val := 1, isLt := (_ : (fun a => a < 2) 1) }))) =
    ∑ x_1 : { w // IsReal w },
        fromBlocks 1 0 0
            (submatrix (blockDiagonal fun x => of ![![2⁻¹, 2⁻¹], ![2⁻¹ * -I, 2⁻¹ * I]]) Prod.swap Prod.swap)
            (Sum.inr (w, { val := 1, isLt := (_ : (fun a => a < 2) 1) })) (Sum.inl x_1) *
          x (embedding ↑x_1) +
      ∑ x_1 : { w // IsComplex w },
        (fromBlocks 1 0 0
              (submatrix (blockDiagonal fun x => of ![![2⁻¹, 2⁻¹], ![2⁻¹ * -I, 2⁻¹ * I]]) Prod.swap Prod.swap)
              (Sum.inr (w, { val := 1, isLt := (_ : (fun a => a < 2) 1) })) (Sum.inr (x_1, 0)) *
            x (embedding ↑x_1) +
          fromBlocks 1 0 0
              (submatrix (blockDiagonal fun x => of ![![2⁻¹, 2⁻¹], ![2⁻¹ * -I, 2⁻¹ * I]]) Prod.swap Prod.swap)
              (Sum.inr (w, { val := 1, isLt := (_ : (fun a => a < 2) 1) })) (Sum.inr (x_1, 1)) *
            x (ComplexEmbedding.conjugate (embedding ↑x_1)))

Next tactic:
simp_rw [Fin.mk_one, stdBasis_apply_ofIsComplex_snd, fromBlocks_apply₂₁,
        fromBlocks_apply₂₂, Matrix.zero_apply, submatrix_apply,
        blockDiagonal_apply, Prod.swap_prod_mk, ite_mul, zero_mul, Finset.sum_const_zero,
        zero_add, Finset.sum_add_distrib, Finset.sum_ite_eq, Finset.mem_univ, ite_true,
        of_apply, cons_val', cons_val_zero, cons_val_one,
        head_cons, ← hx (embedding w), im_eq_sub_conj]