File: Mathlib/LinearAlgebra/BilinearForm/Basic.lean

full_name: LinearMap.BilinForm.coeFn_congr
code: @[deprecated (since := "2024-04-14")]
theorem coeFn_congr : ∀ {x x' y y' : M}, x = x' → y = y' → B x y = B x' y'
  
goal: x = x' → y = y' → (B x) y = (B x') y'

full_name: LinearMap.BilinForm.add_left
code: theorem add_left (x y z : M) : B (x + y) z = B x z + B y z 
goal: (B (x + y)) z = (B x) z + (B y) z

full_name: LinearMap.BilinForm.smul_left
code: theorem smul_left (a : R) (x y : M) : B (a • x) y = a * B x y 
goal: (B (a • x)) y = a * (B x) y

full_name: LinearMap.BilinForm.add_right
code: theorem add_right (x y z : M) : B x (y + z) = B x y + B x z 
goal: (B x) (y + z) = (B x) y + (B x) z

full_name: LinearMap.BilinForm.smul_right
code: theorem smul_right (a : R) (x y : M) : B x (a • y) = a * B x y 
goal: (B x) (a • y) = a * (B x) y

full_name: LinearMap.BilinForm.zero_left
code: theorem zero_left (x : M) : B 0 x = 0 
goal: (B 0) x = 0

full_name: LinearMap.BilinForm.zero_right
code: theorem zero_right (x : M) : B x 0 = 0 
goal: (B x) 0 = 0

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

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

full_name: LinearMap.BilinForm.sub_left
code: theorem sub_left (x y z : M₁) : B₁ (x - y) z = B₁ x z - B₁ y z 
goal: (B₁ (x - y)) z = (B₁ x) z - (B₁ y) z

full_name: LinearMap.BilinForm.sub_right
code: theorem sub_right (x y z : M₁) : B₁ x (y - z) = B₁ x y - B₁ x z 
goal: (B₁ x) (y - z) = (B₁ x) y - (B₁ x) z

full_name: LinearMap.BilinForm.smul_left_of_tower
code: lemma smul_left_of_tower (r : S) (x y : M) : B (r • x) y = r • B x y 
goal: (B (r • x)) y = r • (B x) y

full_name: LinearMap.BilinForm.smul_right_of_tower
code: lemma smul_right_of_tower (r : S) (x y : M) : B x (r • y) = r • B x y 
goal: (B x) (r • y) = r • (B x) y

full_name: LinearMap.BilinForm.coe_injective
code: theorem coe_injective : Function.Injective ((fun B x y => B x y) : BilinForm R M → M → M → R) 
goal: Function.Injective fun B x y => (B x) y

full_name: LinearMap.BilinForm.ext
code: @[ext]
theorem ext (H : ∀ x y : M, B x y = D x y) : B = D 
goal: B = D

full_name: LinearMap.BilinForm.congr_fun
code: theorem congr_fun (h : B = D) (x y : M) : B x y = D x y 
goal: (B x) y = (D x) y

full_name: LinearMap.BilinForm.ext_iff
code: theorem ext_iff : B = D ↔ ∀ x y, B x y = D x y 
goal: B = D ↔ ∀ (x y : M), (B x) y = (D x) y

full_name: LinearMap.BilinForm.coe_zero
code: @[deprecated (since := "2024-04-14")]
theorem coe_zero : ⇑(0 : BilinForm R M) = 0 
goal: ⇑0 = 0

full_name: LinearMap.BilinForm.zero_apply
code: @[simp]
theorem zero_apply (x y : M) : (0 : BilinForm R M) x y = 0 
goal: (0 x) y = 0

full_name: LinearMap.BilinForm.coe_add
code: @[deprecated (since := "2024-04-14")]
theorem coe_add : ⇑(B + D) = B + D 
goal: ⇑(B + D) = ⇑B + ⇑D

full_name: LinearMap.BilinForm.add_apply
code: @[simp]
theorem add_apply (x y : M) : (B + D) x y = B x y + D x y 
goal: ((B + D) x) y = (B x) y + (D x) y

full_name: LinearMap.BilinForm.coe_neg
code: @[deprecated (since := "2024-04-14")]
theorem coe_neg : ⇑(-B₁) = -B₁ 
goal: ⇑(-B₁) = -⇑B₁

full_name: LinearMap.BilinForm.neg_apply
code: @[simp]
theorem neg_apply (x y : M₁) : (-B₁) x y = -B₁ x y 
goal: ((-B₁) x) y = -(B₁ x) y

full_name: LinearMap.BilinForm.coe_sub
code: @[deprecated (since := "2024-04-14")]
theorem coe_sub : ⇑(B₁ - D₁) = B₁ - D₁ 
goal: ⇑(B₁ - D₁) = ⇑B₁ - ⇑D₁

full_name: LinearMap.BilinForm.sub_apply
code: @[simp]
theorem sub_apply (x y : M₁) : (B₁ - D₁) x y = B₁ x y - D₁ x y 
goal: ((B₁ - D₁) x) y = (B₁ x) y - (D₁ x) y

full_name: LinearMap.BilinForm.coeFnAddMonoidHom
code: /-- `coeFn` as an `AddMonoidHom` -/
def coeFnAddMonoidHom : BilinForm R M →+ M → M → R 
goal: LinearMap.BilinForm R M →+ M → M → R

full_name: LinearMap.BilinForm.flipHomAux
code: /-- Auxiliary construction for the flip of a bilinear form, obtained by exchanging the left and
right arguments. This version is a `LinearMap`; it is later upgraded to a `LinearEquiv`
in `flipHom`. -/
def flipHomAux : (BilinForm R M) →ₗ[R] (BilinForm R M) 
goal: LinearMap.BilinForm R M →ₗ[R] LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.flip_flip_aux
code: theorem flip_flip_aux (A : BilinForm R M) :
    flipHomAux (M := M) (flipHomAux (M := M) A) = A 
goal: LinearMap.BilinForm.flipHomAux (LinearMap.BilinForm.flipHomAux A) = A

full_name: LinearMap.BilinForm.flipHom
code: /-- The flip of a bilinear form, obtained by exchanging the left and right arguments. -/
def flipHom : BilinForm R M ≃ₗ[R] BilinForm R M 
goal: LinearMap.BilinForm R M ≃ₗ[R] LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.flip_apply
code: @[simp]
theorem flip_apply (A : BilinForm R M) (x y : M) : flipHom A x y = A y x 
goal: ((LinearMap.BilinForm.flipHom A) x) y = (A y) x

full_name: LinearMap.BilinForm.flip_flip
code: theorem flip_flip :
    flipHom.trans flipHom = LinearEquiv.refl R (BilinForm R M) 
goal: LinearMap.BilinForm.flipHom ≪≫ₗ LinearMap.BilinForm.flipHom = LinearEquiv.refl R (LinearMap.BilinForm R M)

full_name: LinearMap.BilinForm.flip
code: /-- The `flip` of a bilinear form over a commutative ring, obtained by exchanging the left and
right arguments. -/
abbrev flip (B : BilinForm R M) 
goal: LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.restrict
code: /-- The restriction of a bilinear form on a submodule. -/
@[simps! apply]
def restrict (B : BilinForm R M) (W : Submodule R M) : BilinForm R W 
goal: LinearMap.BilinForm R ↥W

full_name: LinearMap.BilinForm.restrict_apply
code: /-- The restriction of a bilinear form on a submodule. -/
@[simps! apply]
def restrict (B : BilinForm R M) (W : Submodule R M) : BilinForm R W 
goal: (B.restrict W) m = (B ↑m).domRestrict W