File: Mathlib/LinearAlgebra/SesquilinearForm.lean

full_name: LinearMap.IsOrtho
code: /-- The proposition that two elements of a sesquilinear map space are orthogonal -/
def IsOrtho (B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M) (x : M₁) (y : M₂) : Prop 
goal: Prop

full_name: LinearMap.isOrtho_def
code: theorem isOrtho_def {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} {x y} : B.IsOrtho x y ↔ B x y = 0 
goal: B.IsOrtho x y ↔ (B x) y = 0

full_name: LinearMap.isOrtho_zero_left
code: theorem isOrtho_zero_left (B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M) (x) : IsOrtho B (0 : M₁) x 
goal: B.IsOrtho 0 x

full_name: LinearMap.isOrtho_zero_right
code: theorem isOrtho_zero_right (B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M) (x) : IsOrtho B x (0 : M₂) 
goal: B.IsOrtho x 0

full_name: LinearMap.isOrtho_flip
code: theorem isOrtho_flip {B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₁'] M} {x y} : B.IsOrtho x y ↔ B.flip.IsOrtho y x 
goal: B.IsOrtho x y ↔ B.flip.IsOrtho y x

full_name: LinearMap.IsOrthoᵢ
code: /-- A set of vectors `v` is orthogonal with respect to some bilinear map `B` if and only
if for all `i ≠ j`, `B (v i) (v j) = 0`. For orthogonality between two elements, use
`BilinForm.isOrtho` -/
def IsOrthoᵢ (B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₁'] M) (v : n → M₁) : Prop 
goal: Prop

full_name: LinearMap.isOrthoᵢ_def
code: theorem isOrthoᵢ_def {B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₁'] M} {v : n → M₁} :
    B.IsOrthoᵢ v ↔ ∀ i j : n, i ≠ j → B (v i) (v j) = 0 
goal: B.IsOrthoᵢ v ↔ ∀ (i j : n), i ≠ j → (B (v i)) (v j) = 0

full_name: LinearMap.isOrthoᵢ_flip
code: theorem isOrthoᵢ_flip (B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₁'] M) {v : n → M₁} :
    B.IsOrthoᵢ v ↔ B.flip.IsOrthoᵢ v 
goal: B.IsOrthoᵢ v ↔ B.flip.IsOrthoᵢ v

full_name: LinearMap.ortho_smul_left
code: theorem ortho_smul_left {B : V₁ →ₛₗ[I₁] V₂ →ₛₗ[I₂] V} {x y} {a : K₁} (ha : a ≠ 0) :
    IsOrtho B x y ↔ IsOrtho B (a • x) y 
goal: B.IsOrtho x y ↔ B.IsOrtho (a • x) y

full_name: LinearMap.ortho_smul_right
code: theorem ortho_smul_right {B : V₁ →ₛₗ[I₁] V₂ →ₛₗ[I₂] V} {x y} {a : K₂} {ha : a ≠ 0} :
    IsOrtho B x y ↔ IsOrtho B x (a • y) 
goal: B.IsOrtho x y ↔ B.IsOrtho x (a • y)

full_name: LinearMap.linearIndependent_of_isOrthoᵢ
code: /-- A set of orthogonal vectors `v` with respect to some sesquilinear map `B` is linearly
  independent if for all `i`, `B (v i) (v i) ≠ 0`. -/
theorem linearIndependent_of_isOrthoᵢ {B : V₁ →ₛₗ[I₁] V₁ →ₛₗ[I₁'] V} {v : n → V₁}
    (hv₁ : B.IsOrthoᵢ v) (hv₂ : ∀ i, ¬B.IsOrtho (v i) (v i)) : LinearIndependent K₁ v 
goal: LinearIndependent K₁ v

full_name: LinearMap.IsRefl
code: /-- The proposition that a sesquilinear map is reflexive -/
def IsRefl (B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M) : Prop 
goal: Prop

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

full_name: LinearMap.IsRefl.ortho_comm
code: theorem ortho_comm {x y} : IsOrtho B x y ↔ IsOrtho B y x 
goal: B.IsOrtho x y ↔ B.IsOrtho y x

full_name: LinearMap.IsRefl.domRestrict
code: theorem domRestrict (H : B.IsRefl) (p : Submodule R₁ M₁) : (B.domRestrict₁₂ p p).IsRefl 
goal: (B.domRestrict₁₂ p p).IsRefl

full_name: LinearMap.IsRefl.flip_isRefl_iff
code: @[simp]
theorem flip_isRefl_iff : B.flip.IsRefl ↔ B.IsRefl 
goal: B.flip.IsRefl ↔ B.IsRefl

full_name: LinearMap.IsRefl.ker_flip_eq_bot
code: theorem ker_flip_eq_bot (H : B.IsRefl) (h : LinearMap.ker B = ⊥) : LinearMap.ker B.flip = ⊥ 
goal: LinearMap.ker B.flip = ⊥

full_name: LinearMap.IsRefl.ker_eq_bot_iff_ker_flip_eq_bot
code: theorem ker_eq_bot_iff_ker_flip_eq_bot (H : B.IsRefl) :
    LinearMap.ker B = ⊥ ↔ LinearMap.ker B.flip = ⊥ 
goal: LinearMap.ker B = ⊥ ↔ LinearMap.ker B.flip = ⊥

full_name: LinearMap.IsSymm
code: /-- The proposition that a sesquilinear form is symmetric -/
def IsSymm (B : M →ₛₗ[I] M →ₗ[R] R) : Prop 
goal: Prop

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

full_name: LinearMap.IsSymm.isRefl
code: theorem isRefl (H : B.IsSymm) : B.IsRefl 
goal: B.IsRefl

full_name: LinearMap.IsSymm.ortho_comm
code: theorem ortho_comm (H : B.IsSymm) {x y} : IsOrtho B x y ↔ IsOrtho B y x 
goal: B.IsOrtho x y ↔ B.IsOrtho y x

full_name: LinearMap.IsSymm.domRestrict
code: theorem domRestrict (H : B.IsSymm) (p : Submodule R M) : (B.domRestrict₁₂ p p).IsSymm 
goal: (B.domRestrict₁₂ p p).IsSymm

full_name: LinearMap.isSymm_zero
code: @[simp]
theorem isSymm_zero : (0 : M →ₛₗ[I] M →ₗ[R] R).IsSymm 
goal: LinearMap.IsSymm 0

full_name: LinearMap.isSymm_iff_eq_flip
code: theorem isSymm_iff_eq_flip {B : LinearMap.BilinForm R M} : B.IsSymm ↔ B = B.flip 
goal: LinearMap.IsSymm B ↔ B = LinearMap.flip B

full_name: LinearMap.IsAlt
code: /-- The proposition that a sesquilinear map is alternating -/
def IsAlt (B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M) : Prop 
goal: Prop

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

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

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

full_name: LinearMap.IsAlt.isRefl
code: theorem isRefl : B.IsRefl 
goal: B.IsRefl

full_name: LinearMap.IsAlt.ortho_comm
code: theorem ortho_comm {x y} : IsOrtho B x y ↔ IsOrtho B y x 
goal: B.IsOrtho x y ↔ B.IsOrtho y x

full_name: LinearMap.isAlt_iff_eq_neg_flip
code: theorem isAlt_iff_eq_neg_flip [NoZeroDivisors R] [CharZero R] {B : M₁ →ₛₗ[I] M₁ →ₛₗ[I] R} :
    B.IsAlt ↔ B = -B.flip 
goal: B.IsAlt ↔ B = -B.flip

full_name: Submodule.orthogonalBilin
code: /-- The orthogonal complement of a submodule `N` with respect to some bilinear map is the set of
elements `x` which are orthogonal to all elements of `N`; i.e., for all `y` in `N`, `B x y = 0`.

Note that for general (neither symmetric nor antisymmetric) bilinear maps this definition has a
chirality; in addition to this "left" orthogonal complement one could define a "right" orthogonal
complement for which, for all `y` in `N`, `B y x = 0`.  This variant definition is not currently
provided in mathlib. -/
def orthogonalBilin (N : Submodule R₁ M₁) (B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M) : Submodule R₁ M₁ 
goal: Submodule R₁ M₁

full_name: Submodule.mem_orthogonalBilin_iff
code: @[simp]
theorem mem_orthogonalBilin_iff {m : M₁} : m ∈ N.orthogonalBilin B ↔ ∀ n ∈ N, B.IsOrtho n m 
goal: m ∈ N.orthogonalBilin B ↔ ∀ n ∈ N, B.IsOrtho n m

full_name: Submodule.orthogonalBilin_le
code: theorem orthogonalBilin_le (h : N ≤ L) : L.orthogonalBilin B ≤ N.orthogonalBilin B 
goal: L.orthogonalBilin B ≤ N.orthogonalBilin B

full_name: Submodule.le_orthogonalBilin_orthogonalBilin
code: theorem le_orthogonalBilin_orthogonalBilin (b : B.IsRefl) :
    N ≤ (N.orthogonalBilin B).orthogonalBilin B 
goal: N ≤ (N.orthogonalBilin B).orthogonalBilin B

full_name: LinearMap.span_singleton_inf_orthogonal_eq_bot
code: theorem span_singleton_inf_orthogonal_eq_bot (B : V₁ →ₛₗ[J₁] V₁ →ₛₗ[J₁'] V₂) (x : V₁)
    (hx : ¬B.IsOrtho x x) : (K₁ ∙ x) ⊓ Submodule.orthogonalBilin (K₁ ∙ x) B = ⊥ 
goal: Submodule.span K₁ {x} ⊓ (Submodule.span K₁ {x}).orthogonalBilin B = ⊥

full_name: LinearMap.orthogonal_span_singleton_eq_to_lin_ker
code: theorem orthogonal_span_singleton_eq_to_lin_ker {B : V →ₗ[K] V →ₛₗ[J] V₂} (x : V) :
    Submodule.orthogonalBilin (K ∙ x) B = LinearMap.ker (B x) 
goal: (Submodule.span K {x}).orthogonalBilin B = LinearMap.ker (B x)

full_name: LinearMap.span_singleton_sup_orthogonal_eq_top
code: theorem span_singleton_sup_orthogonal_eq_top {B : V →ₗ[K] V →ₗ[K] K} {x : V} (hx : ¬B.IsOrtho x x) :
    (K ∙ x) ⊔ Submodule.orthogonalBilin (N := K ∙ x) (B := B) = ⊤ 
goal: Submodule.span K {x} ⊔ (Submodule.span K {x}).orthogonalBilin B = ⊤

full_name: LinearMap.isCompl_span_singleton_orthogonal
code: /-- Given a bilinear form `B` and some `x` such that `B x x ≠ 0`, the span of the singleton of `x`
  is complement to its orthogonal complement. -/
theorem isCompl_span_singleton_orthogonal {B : V →ₗ[K] V →ₗ[K] K} {x : V} (hx : ¬B.IsOrtho x x) :
    IsCompl (K ∙ x) (Submodule.orthogonalBilin (N := K ∙ x) (B := B)) 
goal: IsCompl (Submodule.span K {x}) ((Submodule.span K {x}).orthogonalBilin B)

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

full_name: LinearMap.isAdjointPair_iff_comp_eq_compl₂
code: theorem isAdjointPair_iff_comp_eq_compl₂ : IsAdjointPair B B' f g ↔ B'.comp f = B.compl₂ g 
goal: B.IsAdjointPair B' f g ↔ B' ∘ₗ f = B.compl₂ g

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

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

full_name: LinearMap.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.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.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.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.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.IsPairSelfAdjoint
code: /-- The condition for an endomorphism to be "self-adjoint" with respect to a pair of bilinear maps
on the underlying module. In the case that these two maps are identical, this is the usual concept
of self adjointness. In the case that one of the maps 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.IsSelfAdjoint
code: /-- An endomorphism of a module is self-adjoint with respect to a bilinear map if it serves as an
adjoint for itself. -/
protected def IsSelfAdjoint (f : Module.End R M) 
goal: Prop

full_name: LinearMap.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.IsSkewAdjoint
code: /-- An endomorphism of a module is skew-adjoint with respect to a bilinear map if its negation
serves as an adjoint. -/
def IsSkewAdjoint (f : Module.End R M) 
goal: Prop

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

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

full_name: LinearMap.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.isPairSelfAdjoint_equiv
code: theorem isPairSelfAdjoint_equiv (e : M₁ ≃ₗ[R] M) (f : Module.End R M) :
    IsPairSelfAdjoint B F f ↔
      IsPairSelfAdjoint (B.compl₁₂ ↑e ↑e) (F.compl₁₂ ↑e ↑e) (e.symm.conj f) 
goal: B.IsPairSelfAdjoint F f ↔ (B.compl₁₂ ↑e ↑e).IsPairSelfAdjoint (F.compl₁₂ ↑e ↑e) (e.symm.conj f)

full_name: LinearMap.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.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.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.SeparatingLeft
code: /-- A bilinear map is called left-separating if
the only element that is left-orthogonal to every other element is `0`; i.e.,
for every nonzero `x` in `M₁`, there exists `y` in `M₂` with `B x y ≠ 0`. -/
def SeparatingLeft (B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M) : Prop 
goal: Prop

full_name: LinearMap.not_separatingLeft_zero
code: /-- In a non-trivial module, zero is not non-degenerate. -/
theorem not_separatingLeft_zero [Nontrivial M₁] : ¬(0 : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M).SeparatingLeft 
goal: ¬LinearMap.SeparatingLeft 0

full_name: LinearMap.SeparatingLeft.ne_zero
code: theorem SeparatingLeft.ne_zero [Nontrivial M₁] {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M}
    (h : B.SeparatingLeft) : B ≠ 0 
goal: B ≠ 0

full_name: LinearMap.SeparatingLeft.congr
code: theorem SeparatingLeft.congr (h : B.SeparatingLeft) :
    (e₁.arrowCongr (e₂.arrowCongr (LinearEquiv.refl R M)) B).SeparatingLeft 
goal: ((e₁.arrowCongr (e₂.arrowCongr (LinearEquiv.refl R M))) B).SeparatingLeft

full_name: LinearMap.separatingLeft_congr_iff
code: @[simp]
theorem separatingLeft_congr_iff :
    (e₁.arrowCongr (e₂.arrowCongr (LinearEquiv.refl R M)) B).SeparatingLeft ↔ B.SeparatingLeft 
goal: ((e₁.arrowCongr (e₂.arrowCongr (LinearEquiv.refl R M))) B).SeparatingLeft ↔ B.SeparatingLeft

full_name: LinearMap.SeparatingRight
code: /-- A bilinear map is called right-separating if
the only element that is right-orthogonal to every other element is `0`; i.e.,
for every nonzero `y` in `M₂`, there exists `x` in `M₁` with `B x y ≠ 0`. -/
def SeparatingRight (B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M) : Prop 
goal: Prop

full_name: LinearMap.Nondegenerate
code: /-- A bilinear map is called non-degenerate if it is left-separating and right-separating. -/
def Nondegenerate (B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M) : Prop 
goal: Prop

full_name: LinearMap.flip_separatingRight
code: @[simp]
theorem flip_separatingRight {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.flip.SeparatingRight ↔ B.SeparatingLeft 
goal: B.flip.SeparatingRight ↔ B.SeparatingLeft

full_name: LinearMap.flip_separatingLeft
code: @[simp]
theorem flip_separatingLeft {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.flip.SeparatingLeft ↔ SeparatingRight B 
goal: B.flip.SeparatingLeft ↔ B.SeparatingRight

full_name: LinearMap.flip_nondegenerate
code: @[simp]
theorem flip_nondegenerate {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} : B.flip.Nondegenerate ↔ B.Nondegenerate 
goal: B.flip.Nondegenerate ↔ B.Nondegenerate

full_name: LinearMap.separatingLeft_iff_linear_nontrivial
code: theorem separatingLeft_iff_linear_nontrivial {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.SeparatingLeft ↔ ∀ x : M₁, B x = 0 → x = 0 
goal: B.SeparatingLeft ↔ ∀ (x : M₁), B x = 0 → x = 0

full_name: LinearMap.separatingRight_iff_linear_flip_nontrivial
code: theorem separatingRight_iff_linear_flip_nontrivial {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.SeparatingRight ↔ ∀ y : M₂, B.flip y = 0 → y = 0 
goal: B.SeparatingRight ↔ ∀ (y : M₂), B.flip y = 0 → y = 0

full_name: LinearMap.separatingLeft_iff_ker_eq_bot
code: /-- A bilinear map is left-separating if and only if it has a trivial kernel. -/
theorem separatingLeft_iff_ker_eq_bot {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.SeparatingLeft ↔ LinearMap.ker B = ⊥ 
goal: B.SeparatingLeft ↔ LinearMap.ker B = ⊥

full_name: LinearMap.separatingRight_iff_flip_ker_eq_bot
code: /-- A bilinear map is right-separating if and only if its flip has a trivial kernel. -/
theorem separatingRight_iff_flip_ker_eq_bot {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.SeparatingRight ↔ LinearMap.ker B.flip = ⊥ 
goal: B.SeparatingRight ↔ LinearMap.ker B.flip = ⊥

full_name: LinearMap.IsRefl.nondegenerate_of_separatingLeft
code: theorem IsRefl.nondegenerate_of_separatingLeft {B : M →ₗ[R] M →ₗ[R] M₁} (hB : B.IsRefl)
    (hB' : B.SeparatingLeft) : B.Nondegenerate 
goal: B.Nondegenerate

full_name: LinearMap.IsRefl.nondegenerate_of_separatingRight
code: theorem IsRefl.nondegenerate_of_separatingRight {B : M →ₗ[R] M →ₗ[R] M₁} (hB : B.IsRefl)
    (hB' : B.SeparatingRight) : B.Nondegenerate 
goal: B.Nondegenerate

full_name: LinearMap.nondegenerate_restrict_of_disjoint_orthogonal
code: /-- The restriction of a reflexive bilinear map `B` onto a submodule `W` is
nondegenerate if `W` has trivial intersection with its orthogonal complement,
that is `Disjoint W (W.orthogonalBilin B)`. -/
theorem nondegenerate_restrict_of_disjoint_orthogonal {B : M →ₗ[R] M →ₗ[R] M₁} (hB : B.IsRefl)
    {W : Submodule R M} (hW : Disjoint W (W.orthogonalBilin B)) :
    (B.domRestrict₁₂ W W).Nondegenerate 
goal: (B.domRestrict₁₂ W W).Nondegenerate

full_name: LinearMap.IsOrthoᵢ.not_isOrtho_basis_self_of_separatingLeft
code: /-- An orthogonal basis with respect to a left-separating bilinear map has no self-orthogonal
elements. -/
theorem IsOrthoᵢ.not_isOrtho_basis_self_of_separatingLeft [Nontrivial R]
    {B : M →ₛₗ[I] M →ₛₗ[I'] M₁} {v : Basis n R M} (h : B.IsOrthoᵢ v) (hB : B.SeparatingLeft)
    (i : n) : ¬B.IsOrtho (v i) (v i) 
goal: ¬B.IsOrtho (v i) (v i)

full_name: LinearMap.IsOrthoᵢ.not_isOrtho_basis_self_of_separatingRight
code: /-- An orthogonal basis with respect to a right-separating bilinear map has no self-orthogonal
elements. -/
theorem IsOrthoᵢ.not_isOrtho_basis_self_of_separatingRight [Nontrivial R]
    {B : M →ₛₗ[I] M →ₛₗ[I'] M₁} {v : Basis n R M} (h : B.IsOrthoᵢ v) (hB : B.SeparatingRight)
    (i : n) : ¬B.IsOrtho (v i) (v i) 
goal: ¬B.IsOrtho (v i) (v i)

full_name: LinearMap.IsOrthoᵢ.separatingLeft_of_not_isOrtho_basis_self
code: /-- Given an orthogonal basis with respect to a bilinear map, the bilinear map is left-separating if
the basis has no elements which are self-orthogonal. -/
theorem IsOrthoᵢ.separatingLeft_of_not_isOrtho_basis_self [NoZeroSMulDivisors R M₁]
    {B : M →ₗ[R] M →ₗ[R] M₁} (v : Basis n R M) (hO : B.IsOrthoᵢ v)
    (h : ∀ i, ¬B.IsOrtho (v i) (v i)) : B.SeparatingLeft 
goal: B.SeparatingLeft

full_name: LinearMap.IsOrthoᵢ.separatingRight_iff_not_isOrtho_basis_self
code: /-- Given an orthogonal basis with respect to a bilinear map, the bilinear map is right-separating
if the basis has no elements which are self-orthogonal. -/
theorem IsOrthoᵢ.separatingRight_iff_not_isOrtho_basis_self [NoZeroSMulDivisors R M₁]
    {B : M →ₗ[R] M →ₗ[R] M₁} (v : Basis n R M) (hO : B.IsOrthoᵢ v)
    (h : ∀ i, ¬B.IsOrtho (v i) (v i)) : B.SeparatingRight 
goal: B.SeparatingRight

full_name: LinearMap.IsOrthoᵢ.nondegenerate_of_not_isOrtho_basis_self
code: /-- Given an orthogonal basis with respect to a bilinear map, the bilinear map is nondegenerate
if the basis has no elements which are self-orthogonal. -/
theorem IsOrthoᵢ.nondegenerate_of_not_isOrtho_basis_self [NoZeroSMulDivisors R M₁]
    {B : M →ₗ[R] M →ₗ[R] M₁} (v : Basis n R M) (hO : B.IsOrthoᵢ v)
    (h : ∀ i, ¬B.IsOrtho (v i) (v i)) : B.Nondegenerate 
goal: B.Nondegenerate