File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

full_name: LinearMap.BilinForm.IsRefl
code: /-- The proposition that a bilinear form is reflexive -/
def IsRefl (B : BilinForm R M) : Prop 
goal: Prop

full_name: LinearMap.BilinForm.IsRefl.eq_zero
code: theorem eq_zero : ∀ {x y : M}, B x y = 0 → B y x = 0 
goal: (B x) y = 0 → (B y) x = 0

full_name: LinearMap.BilinForm.IsRefl.neg
code: protected theorem neg {B : BilinForm R₁ M₁} (hB : B.IsRefl) : (-B).IsRefl 
goal: (-B).IsRefl

full_name: LinearMap.BilinForm.IsRefl.smul
code: protected theorem smul {α} [CommSemiring α] [Module α R] [SMulCommClass R α R]
    [NoZeroSMulDivisors α R] (a : α) {B : BilinForm R M} (hB : B.IsRefl) :
    (a • B).IsRefl 
goal: (a • B).IsRefl

full_name: LinearMap.BilinForm.IsRefl.groupSMul
code: protected theorem groupSMul {α} [Group α] [DistribMulAction α R] [SMulCommClass R α R] (a : α)
    {B : BilinForm R M} (hB : B.IsRefl) : (a • B).IsRefl 
goal: (a • B).IsRefl

full_name: LinearMap.BilinForm.isRefl_zero
code: @[simp]
theorem isRefl_zero : (0 : BilinForm R M).IsRefl 
goal: LinearMap.BilinForm.IsRefl 0

full_name: LinearMap.BilinForm.isRefl_neg
code: @[simp]
theorem isRefl_neg {B : BilinForm R₁ M₁} : (-B).IsRefl ↔ B.IsRefl 
goal: (-B).IsRefl ↔ B.IsRefl

full_name: LinearMap.BilinForm.IsSymm
code: /-- The proposition that a bilinear form is symmetric -/
def IsSymm (B : BilinForm R M) : Prop 
goal: Prop

full_name: LinearMap.BilinForm.IsSymm.eq
code: protected theorem eq (x y : M) : B x y = B y x 
goal: (B x) y = (B y) x

full_name: LinearMap.BilinForm.IsSymm.isRefl
code: theorem isRefl : B.IsRefl 
goal: B.IsRefl

full_name: LinearMap.BilinForm.IsSymm.add
code: protected theorem add {B₁ B₂ : BilinForm R M} (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) :
    (B₁ + B₂).IsSymm 
goal: (B₁ + B₂).IsSymm

full_name: LinearMap.BilinForm.IsSymm.sub
code: protected theorem sub {B₁ B₂ : BilinForm R₁ M₁} (hB₁ : B₁.IsSymm) (hB₂ : B₂.IsSymm) :
    (B₁ - B₂).IsSymm 
goal: (B₁ - B₂).IsSymm

full_name: LinearMap.BilinForm.IsSymm.neg
code: protected theorem neg {B : BilinForm R₁ M₁} (hB : B.IsSymm) : (-B).IsSymm 
goal: (-B).IsSymm

full_name: LinearMap.BilinForm.IsSymm.smul
code: protected theorem smul {α} [Monoid α] [DistribMulAction α R] [SMulCommClass R α R] (a : α)
    {B : BilinForm R M} (hB : B.IsSymm) : (a • B).IsSymm 
goal: (a • B).IsSymm

full_name: LinearMap.BilinForm.IsSymm.restrict
code: /-- The restriction of a symmetric bilinear form on a submodule is also symmetric. -/
theorem restrict {B : BilinForm R M} (b : B.IsSymm) (W : Submodule R M) :
    (B.restrict W).IsSymm 
goal: (B.restrict W).IsSymm

full_name: LinearMap.BilinForm.isSymm_zero
code: @[simp]
theorem isSymm_zero : (0 : BilinForm R M).IsSymm 
goal: LinearMap.BilinForm.IsSymm 0

full_name: LinearMap.BilinForm.isSymm_neg
code: @[simp]
theorem isSymm_neg {B : BilinForm R₁ M₁} : (-B).IsSymm ↔ B.IsSymm 
goal: (-B).IsSymm ↔ B.IsSymm

full_name: LinearMap.BilinForm.isSymm_iff_flip
code: theorem isSymm_iff_flip : B.IsSymm ↔ flipHom B = B 
goal: B.IsSymm ↔ LinearMap.BilinForm.flipHom B = B

full_name: LinearMap.BilinForm.IsAlt
code: /-- The proposition that a bilinear form is alternating -/
def IsAlt (B : BilinForm R M) : Prop 
goal: Prop

full_name: LinearMap.BilinForm.IsAlt.self_eq_zero
code: theorem self_eq_zero (H : B.IsAlt) (x : M) : B x x = 0 
goal: (B x) x = 0

full_name: LinearMap.BilinForm.IsAlt.neg_eq
code: theorem neg_eq (H : B₁.IsAlt) (x y : M₁) : -B₁ x y = B₁ y x 
goal: -(B₁ x) y = (B₁ y) x

full_name: LinearMap.BilinForm.IsAlt.isRefl
code: theorem isRefl (H : B₁.IsAlt) : B₁.IsRefl 
goal: B₁.IsRefl

full_name: LinearMap.BilinForm.IsAlt.eq_of_add_add_eq_zero
code: theorem eq_of_add_add_eq_zero [IsCancelAdd R] {a b c : M} (H : B.IsAlt) (hAdd : a + b + c = 0) :
    B a b = B b c 
goal: (B a) b = (B b) c

full_name: LinearMap.BilinForm.IsAlt.add
code: protected theorem add {B₁ B₂ : BilinForm R M} (hB₁ : B₁.IsAlt) (hB₂ : B₂.IsAlt) : (B₁ + B₂).IsAlt 
goal: (B₁ + B₂).IsAlt

full_name: LinearMap.BilinForm.IsAlt.sub
code: protected theorem sub {B₁ B₂ : BilinForm R₁ M₁} (hB₁ : B₁.IsAlt) (hB₂ : B₂.IsAlt) :
    (B₁ - B₂).IsAlt 
goal: (B₁ - B₂).IsAlt

full_name: LinearMap.BilinForm.IsAlt.neg
code: protected theorem neg {B : BilinForm R₁ M₁} (hB : B.IsAlt) : (-B).IsAlt 
goal: (-B).IsAlt

full_name: LinearMap.BilinForm.IsAlt.smul
code: protected theorem smul {α} [Monoid α] [DistribMulAction α R] [SMulCommClass R α R] (a : α)
    {B : BilinForm R M} (hB : B.IsAlt) : (a • B).IsAlt 
goal: (a • B).IsAlt

full_name: LinearMap.BilinForm.isAlt_zero
code: @[simp]
theorem isAlt_zero : (0 : BilinForm R M).IsAlt 
goal: LinearMap.BilinForm.IsAlt 0

full_name: LinearMap.BilinForm.isAlt_neg
code: @[simp]
theorem isAlt_neg {B : BilinForm R₁ M₁} : (-B).IsAlt ↔ B.IsAlt 
goal: (-B).IsAlt ↔ B.IsAlt

full_name: LinearMap.BilinForm.IsAdjointPair
code: /-- Given a pair of modules equipped with bilinear forms, this is the condition for a pair of
maps between them to be mutually adjoint. -/
def IsAdjointPair 
goal: Prop

full_name: LinearMap.BilinForm.IsAdjointPair.eq
code: theorem IsAdjointPair.eq (h : IsAdjointPair B B' f g) : ∀ {x y}, B' (f x) y = B x (g y) 
goal: (B' (f x)) y = (B x) (g y)

full_name: LinearMap.BilinForm.isAdjointPair_iff_compLeft_eq_compRight
code: theorem isAdjointPair_iff_compLeft_eq_compRight (f g : Module.End R M) :
    IsAdjointPair B F f g ↔ F.compLeft f = B.compRight g 
goal: B.IsAdjointPair F f g ↔ F.compLeft f = B.compRight g

full_name: LinearMap.BilinForm.isAdjointPair_zero
code: theorem isAdjointPair_zero : IsAdjointPair B B' 0 0 
goal: B.IsAdjointPair B' 0 0

full_name: LinearMap.BilinForm.isAdjointPair_id
code: theorem isAdjointPair_id : IsAdjointPair B B 1 1 
goal: B.IsAdjointPair B 1 1

full_name: LinearMap.BilinForm.IsAdjointPair.add
code: theorem IsAdjointPair.add (h : IsAdjointPair B B' f g) (h' : IsAdjointPair B B' f' g') :
    IsAdjointPair B B' (f + f') (g + g') 
goal: B.IsAdjointPair B' (f + f') (g + g')

full_name: LinearMap.BilinForm.IsAdjointPair.sub
code: theorem IsAdjointPair.sub (h : IsAdjointPair B₁ B₁' f₁ g₁) (h' : IsAdjointPair B₁ B₁' f₁' g₁') :
    IsAdjointPair B₁ B₁' (f₁ - f₁') (g₁ - g₁') 
goal: B₁.IsAdjointPair B₁' (f₁ - f₁') (g₁ - g₁')

full_name: LinearMap.BilinForm.IsAdjointPair.smul
code: theorem IsAdjointPair.smul (c : R) (h : IsAdjointPair B B₂' f₂ g₂) :
    IsAdjointPair B B₂' (c • f₂) (c • g₂) 
goal: B.IsAdjointPair B₂' (c • f₂) (c • g₂)

full_name: LinearMap.BilinForm.IsAdjointPair.comp
code: theorem IsAdjointPair.comp {f' : M' →ₗ[R] M''} {g' : M'' →ₗ[R] M'} (h : IsAdjointPair B B' f g)
    (h' : IsAdjointPair B' B'' f' g') : IsAdjointPair B B'' (f'.comp f) (g.comp g') 
goal: B.IsAdjointPair B'' (f' ∘ₗ f) (g ∘ₗ g')

full_name: LinearMap.BilinForm.IsAdjointPair.mul
code: theorem IsAdjointPair.mul {f g f' g' : Module.End R M} (h : IsAdjointPair B B f g)
    (h' : IsAdjointPair B B f' g') : IsAdjointPair B B (f * f') (g' * g) 
goal: B.IsAdjointPair B (f * f') (g' * g)

full_name: LinearMap.BilinForm.IsPairSelfAdjoint
code: /-- The condition for an endomorphism to be "self-adjoint" with respect to a pair of bilinear forms
on the underlying module. In the case that these two forms are identical, this is the usual concept
of self adjointness. In the case that one of the forms is the negation of the other, this is the
usual concept of skew adjointness. -/
def IsPairSelfAdjoint (f : Module.End R M) 
goal: Prop

full_name: LinearMap.BilinForm.isPairSelfAdjointSubmodule
code: /-- The set of pair-self-adjoint endomorphisms are a submodule of the type of all endomorphisms. -/
def isPairSelfAdjointSubmodule : Submodule R (Module.End R M) 
goal: Submodule R (Module.End R M)

full_name: LinearMap.BilinForm.mem_isPairSelfAdjointSubmodule
code: @[simp]
theorem mem_isPairSelfAdjointSubmodule (f : Module.End R M) :
    f ∈ isPairSelfAdjointSubmodule B₂ F₂ ↔ IsPairSelfAdjoint B₂ F₂ f 
goal: f ∈ B₂.isPairSelfAdjointSubmodule F₂ ↔ B₂.IsPairSelfAdjoint F₂ f

full_name: LinearMap.BilinForm.isPairSelfAdjoint_equiv
code: theorem isPairSelfAdjoint_equiv (e : M' ≃ₗ[R] M) (f : Module.End R M) :
    IsPairSelfAdjoint B₂ F₂ f ↔
      IsPairSelfAdjoint (B₂.comp ↑e ↑e) (F₂.comp ↑e ↑e) (e.symm.conj f) 
goal: B₂.IsPairSelfAdjoint F₂ f ↔ (B₂.comp ↑e ↑e).IsPairSelfAdjoint (F₂.comp ↑e ↑e) (e.symm.conj f)

full_name: LinearMap.BilinForm.IsSelfAdjoint
code: /-- An endomorphism of a module is self-adjoint with respect to a bilinear form if it serves as an
adjoint for itself. -/
def IsSelfAdjoint (f : Module.End R M) 
goal: Prop

full_name: LinearMap.BilinForm.IsSkewAdjoint
code: /-- An endomorphism of a module is skew-adjoint with respect to a bilinear form if its negation
serves as an adjoint. -/
def IsSkewAdjoint (f : Module.End R₁ M₁) 
goal: Prop

full_name: LinearMap.BilinForm.isSkewAdjoint_iff_neg_self_adjoint
code: theorem isSkewAdjoint_iff_neg_self_adjoint (f : Module.End R₁ M₁) :
    B₁.IsSkewAdjoint f ↔ IsAdjointPair (-B₁) B₁ f f 
goal: B₁.IsSkewAdjoint f ↔ (-B₁).IsAdjointPair B₁ f f

full_name: LinearMap.BilinForm.selfAdjointSubmodule
code: /-- The set of self-adjoint endomorphisms of a module with bilinear form is a submodule. (In fact
it is a Jordan subalgebra.) -/
def selfAdjointSubmodule 
goal: Submodule R (Module.End R M)

full_name: LinearMap.BilinForm.mem_selfAdjointSubmodule
code: @[simp]
theorem mem_selfAdjointSubmodule (f : Module.End R M) :
    f ∈ B.selfAdjointSubmodule ↔ B.IsSelfAdjoint f 
goal: f ∈ B.selfAdjointSubmodule ↔ B.IsSelfAdjoint f

full_name: LinearMap.BilinForm.skewAdjointSubmodule
code: /-- The set of skew-adjoint endomorphisms of a module with bilinear form is a submodule. (In fact
it is a Lie subalgebra.) -/
def skewAdjointSubmodule 
goal: Submodule R₁ (Module.End R₁ M₁)

full_name: LinearMap.BilinForm.mem_skewAdjointSubmodule
code: @[simp]
theorem mem_skewAdjointSubmodule (f : Module.End R₁ M₁) :
    f ∈ B₁.skewAdjointSubmodule ↔ B₁.IsSkewAdjoint f 
goal: f ∈ B₁.skewAdjointSubmodule ↔ B₁.IsSkewAdjoint f

full_name: LinearMap.BilinForm.Nondegenerate
code: /-- A nondegenerate bilinear form is a bilinear form such that the only element that is orthogonal
to every other element is `0`; i.e., for all nonzero `m` in `M`, there exists `n` in `M` with
`B m n ≠ 0`.

Note that for general (neither symmetric nor antisymmetric) bilinear forms this definition has a
chirality; in addition to this "left" nondegeneracy condition one could define a "right"
nondegeneracy condition that in the situation described, `B n m ≠ 0`.  This variant definition is
not currently provided in mathlib. In finite dimension either definition implies the other. -/
def Nondegenerate (B : BilinForm R M) : Prop 
goal: Prop

full_name: LinearMap.BilinForm.not_nondegenerate_zero
code: /-- In a non-trivial module, zero is not non-degenerate. -/
theorem not_nondegenerate_zero [Nontrivial M] : ¬(0 : BilinForm R M).Nondegenerate 
goal: ¬LinearMap.BilinForm.Nondegenerate 0

full_name: LinearMap.BilinForm.Nondegenerate.ne_zero
code: theorem Nondegenerate.ne_zero [Nontrivial M] {B : BilinForm R M} (h : B.Nondegenerate) : B ≠ 0 
goal: B ≠ 0

full_name: LinearMap.BilinForm.Nondegenerate.congr
code: theorem Nondegenerate.congr {B : BilinForm R M} (e : M ≃ₗ[R] M') (h : B.Nondegenerate) :
    (congr e B).Nondegenerate 
goal: ((LinearMap.BilinForm.congr e) B).Nondegenerate

full_name: LinearMap.BilinForm.nondegenerate_congr_iff
code: @[simp]
theorem nondegenerate_congr_iff {B : BilinForm R M} (e : M ≃ₗ[R] M') :
    (congr e B).Nondegenerate ↔ B.Nondegenerate 
goal: ((LinearMap.BilinForm.congr e) B).Nondegenerate ↔ B.Nondegenerate

full_name: LinearMap.BilinForm.nondegenerate_iff_ker_eq_bot
code: /-- A bilinear form is nondegenerate if and only if it has a trivial kernel. -/
theorem nondegenerate_iff_ker_eq_bot {B : BilinForm R M} :
    B.Nondegenerate ↔ LinearMap.ker B = ⊥ 
goal: B.Nondegenerate ↔ LinearMap.ker B = ⊥

full_name: LinearMap.BilinForm.Nondegenerate.ker_eq_bot
code: theorem Nondegenerate.ker_eq_bot {B : BilinForm R M} (h : B.Nondegenerate) :
    LinearMap.ker B = ⊥ 
goal: LinearMap.ker B = ⊥

full_name: LinearMap.BilinForm.compLeft_injective
code: theorem compLeft_injective (B : BilinForm R₁ M₁) (b : B.Nondegenerate) :
    Function.Injective B.compLeft 
goal: Function.Injective B.compLeft

full_name: LinearMap.BilinForm.isAdjointPair_unique_of_nondegenerate
code: theorem isAdjointPair_unique_of_nondegenerate (B : BilinForm R₁ M₁) (b : B.Nondegenerate)
    (φ ψ₁ ψ₂ : M₁ →ₗ[R₁] M₁) (hψ₁ : IsAdjointPair B B ψ₁ φ) (hψ₂ : IsAdjointPair B B ψ₂ φ) :
    ψ₁ = ψ₂ 
goal: ψ₁ = ψ₂

full_name: LinearMap.BilinForm.toDual
code: /-- Given a nondegenerate bilinear form `B` on a finite-dimensional vector space, `B.toDual` is
the linear equivalence between a vector space and its dual. -/
noncomputable def toDual (B : BilinForm K V) (b : B.Nondegenerate) : V ≃ₗ[K] Module.Dual K V 
goal: V ≃ₗ[K] Module.Dual K V

full_name: LinearMap.BilinForm.toDual_def
code: theorem toDual_def {B : BilinForm K V} (b : B.SeparatingLeft) {m n : V} : B.toDual b m n = B m n 
goal: ((B.toDual b) m) n = (B m) n

full_name: LinearMap.BilinForm.apply_toDual_symm_apply
code: @[simp]
lemma apply_toDual_symm_apply {B : BilinForm K V} {hB : B.Nondegenerate}
    (f : Module.Dual K V) (v : V) :
    B ((B.toDual hB).symm f) v = f v 
goal: (B ((B.toDual hB).symm f)) v = f v

full_name: LinearMap.BilinForm.Nondegenerate.flip
code: lemma Nondegenerate.flip {B : BilinForm K V} (hB : B.Nondegenerate) :
    B.flip.Nondegenerate 
goal: B.flip.Nondegenerate

full_name: LinearMap.BilinForm.nonDegenerateFlip_iff
code: lemma nonDegenerateFlip_iff {B : BilinForm K V} :
    B.flip.Nondegenerate ↔ B.Nondegenerate 
goal: B.flip.Nondegenerate ↔ B.Nondegenerate

full_name: LinearMap.BilinForm.dualBasis
code: /-- The `B`-dual basis `B.dualBasis hB b` to a finite basis `b` satisfies
`B (B.dualBasis hB b i) (b j) = B (b i) (B.dualBasis hB b j) = if i = j then 1 else 0`,
where `B` is a nondegenerate (symmetric) bilinear form and `b` is a finite basis. -/
noncomputable def dualBasis (B : BilinForm K V) (hB : B.Nondegenerate) (b : Basis ι K V) :
    Basis ι K V 
goal: Basis ι K V

full_name: LinearMap.BilinForm.dualBasis_repr_apply
code: @[simp]
theorem dualBasis_repr_apply (B : BilinForm K V) (hB : B.Nondegenerate) (b : Basis ι K V) (x i) :
    (B.dualBasis hB b).repr x i = B x (b i) 
goal: ((B.dualBasis hB b).repr x) i = (B x) (b i)

full_name: LinearMap.BilinForm.apply_dualBasis_left
code: theorem apply_dualBasis_left (B : BilinForm K V) (hB : B.Nondegenerate) (b : Basis ι K V) (i j) :
    B (B.dualBasis hB b i) (b j) = if j = i then 1 else 0 
goal: (B ((B.dualBasis hB b) i)) (b j) = if j = i then 1 else 0

full_name: LinearMap.BilinForm.apply_dualBasis_right
code: theorem apply_dualBasis_right (B : BilinForm K V) (hB : B.Nondegenerate) (sym : B.IsSymm)
    (b : Basis ι K V) (i j) : B (b i) (B.dualBasis hB b j) = if i = j then 1 else 0 
goal: (B (b i)) ((B.dualBasis hB b) j) = if i = j then 1 else 0

full_name: LinearMap.BilinForm.dualBasis_dualBasis_flip
code: @[simp]
lemma dualBasis_dualBasis_flip (B : BilinForm K V) (hB : B.Nondegenerate) {ι}
    [Finite ι] [DecidableEq ι] (b : Basis ι K V) :
    B.dualBasis hB (B.flip.dualBasis hB.flip b) = b 
goal: B.dualBasis hB (B.flip.dualBasis ⋯ b) = b

full_name: LinearMap.BilinForm.dualBasis_flip_dualBasis
code: @[simp]
lemma dualBasis_flip_dualBasis (B : BilinForm K V) (hB : B.Nondegenerate) {ι}
    [Finite ι] [DecidableEq ι] [FiniteDimensional K V] (b : Basis ι K V) :
    B.flip.dualBasis hB.flip (B.dualBasis hB b) = b 
goal: B.flip.dualBasis ⋯ (B.dualBasis hB b) = b

full_name: LinearMap.BilinForm.dualBasis_dualBasis
code: @[simp]
lemma dualBasis_dualBasis (B : BilinForm K V) (hB : B.Nondegenerate) (hB' : B.IsSymm) {ι}
    [Finite ι] [DecidableEq ι] [FiniteDimensional K V] (b : Basis ι K V) :
    B.dualBasis hB (B.dualBasis hB b) = b 
goal: B.dualBasis hB (B.dualBasis hB b) = b

full_name: LinearMap.BilinForm.symmCompOfNondegenerate
code: /-- Given bilinear forms `B₁, B₂` where `B₂` is nondegenerate, `symmCompOfNondegenerate`
is the linear map `B₂ ∘ B₁`. -/
noncomputable def symmCompOfNondegenerate (B₁ B₂ : BilinForm K V) (b₂ : B₂.Nondegenerate) :
    V →ₗ[K] V 
goal: V →ₗ[K] V

full_name: LinearMap.BilinForm.comp_symmCompOfNondegenerate_apply
code: theorem comp_symmCompOfNondegenerate_apply (B₁ : BilinForm K V) {B₂ : BilinForm K V}
    (b₂ : B₂.Nondegenerate) (v : V) :
    B₂ (B₁.symmCompOfNondegenerate B₂ b₂ v) = B₁ v 
goal: B₂ ((B₁.symmCompOfNondegenerate B₂ b₂) v) = B₁ v

full_name: LinearMap.BilinForm.symmCompOfNondegenerate_left_apply
code: @[simp]
theorem symmCompOfNondegenerate_left_apply (B₁ : BilinForm K V) {B₂ : BilinForm K V}
    (b₂ : B₂.Nondegenerate) (v w : V) : B₂ (symmCompOfNondegenerate B₁ B₂ b₂ w) v = B₁ w v 
goal: (B₂ ((B₁.symmCompOfNondegenerate B₂ b₂) w)) v = (B₁ w) v

full_name: LinearMap.BilinForm.leftAdjointOfNondegenerate
code: /-- Given the nondegenerate bilinear form `B` and the linear map `φ`,
`leftAdjointOfNondegenerate` provides the left adjoint of `φ` with respect to `B`.
The lemma proving this property is `BilinForm.isAdjointPairLeftAdjointOfNondegenerate`. -/
noncomputable def leftAdjointOfNondegenerate (B : BilinForm K V) (b : B.Nondegenerate)
    (φ : V →ₗ[K] V) : V →ₗ[K] V 
goal: V →ₗ[K] V

full_name: LinearMap.BilinForm.isAdjointPairLeftAdjointOfNondegenerate
code: theorem isAdjointPairLeftAdjointOfNondegenerate (B : BilinForm K V) (b : B.Nondegenerate)
    (φ : V →ₗ[K] V) : IsAdjointPair B B (B.leftAdjointOfNondegenerate b φ) φ 
goal: B.IsAdjointPair B (B.leftAdjointOfNondegenerate b φ) φ

full_name: LinearMap.BilinForm.isAdjointPair_iff_eq_of_nondegenerate
code: /-- Given the nondegenerate bilinear form `B`, the linear map `φ` has a unique left adjoint given by
`BilinForm.leftAdjointOfNondegenerate`. -/
theorem isAdjointPair_iff_eq_of_nondegenerate (B : BilinForm K V) (b : B.Nondegenerate)
    (ψ φ : V →ₗ[K] V) : IsAdjointPair B B ψ φ ↔ ψ = B.leftAdjointOfNondegenerate b φ 
goal: B.IsAdjointPair B ψ φ ↔ ψ = B.leftAdjointOfNondegenerate b φ