File: Mathlib/LinearAlgebra/BilinearForm/Hom.lean

full_name: LinearMap.BilinForm.toLinHomAux₁
code: /-- Auxiliary definition to define `toLinHom`; see below. -/
def toLinHomAux₁ (A : BilinForm R M) (x : M) : M →ₗ[R] R 
goal: M →ₗ[R] R

full_name: LinearMap.BilinForm.toLinHomAux₂
code: /-- Auxiliary definition to define `toLinHom`; see below. -/
@[deprecated (since := "2024-04-26")]
def toLinHomAux₂ (A : BilinForm R M) : M →ₗ[R] M →ₗ[R] R 
goal: M →ₗ[R] M →ₗ[R] R

full_name: LinearMap.BilinForm.toLinHom
code: /-- The linear map obtained from a `BilinForm` by fixing the left co-ordinate and evaluating in
the right. -/
@[deprecated (since := "2024-04-26")]
def toLinHom : BilinForm R M →ₗ[R] M →ₗ[R] M →ₗ[R] R 
goal: LinearMap.BilinForm R M →ₗ[R] M →ₗ[R] M →ₗ[R] R

full_name: LinearMap.BilinForm.toLin'_apply
code: @[deprecated (since := "2024-04-26")]
theorem toLin'_apply (A : BilinForm R M) (x : M) : toLinHom (M := M) A x = A x 
goal: (LinearMap.BilinForm.toLinHom A) x = A x

full_name: LinearMap.BilinForm.sum_left
code: theorem sum_left {α} (t : Finset α) (g : α → M) (w : M) :
    B (∑ i ∈ t, g i) w = ∑ i ∈ t, B (g i) w 
goal: (B (∑ i ∈ t, g i)) w = ∑ i ∈ t, (B (g i)) w

full_name: LinearMap.BilinForm.sum_right
code: theorem sum_right {α} (t : Finset α) (w : M) (g : α → M) :
    B w (∑ i ∈ t, g i) = ∑ i ∈ t, B w (g i) 
goal: (B w) (∑ i ∈ t, g i) = ∑ i ∈ t, (B w) (g i)

full_name: LinearMap.BilinForm.sum_apply
code: theorem sum_apply {α} (t : Finset α) (B : α → BilinForm R M) (v w : M) :
    (∑ i ∈ t, B i) v w = ∑ i ∈ t, B i v w 
goal: ((∑ i ∈ t, B i) v) w = ∑ i ∈ t, ((B i) v) w

full_name: LinearMap.BilinForm.toLinHomFlip
code: /-- The linear map obtained from a `BilinForm` by fixing the right co-ordinate and evaluating in
the left. -/
def toLinHomFlip : BilinForm R M →ₗ[R] M →ₗ[R] M →ₗ[R] R 
goal: LinearMap.BilinForm R M →ₗ[R] M →ₗ[R] M →ₗ[R] R

full_name: LinearMap.BilinForm.toLin'Flip_apply
code: theorem toLin'Flip_apply (A : BilinForm R M) (x : M) : toLinHomFlip (M := M) A x = fun y => A y x 
goal: ⇑((LinearMap.BilinForm.toLinHomFlip A) x) = fun y => (A y) x

full_name: LinearMap.toBilinAux
code: /-- A map with two arguments that is linear in both is a bilinear form.

This is an auxiliary definition for the full linear equivalence `LinearMap.toBilin`.
-/
def LinearMap.toBilinAux (f : M →ₗ[R] M →ₗ[R] R) : BilinForm R M 
goal: LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.toLin
code: /-- Bilinear forms are linearly equivalent to maps with two arguments that are linear in both. -/
@[deprecated (since := "2024-04-26")]
def LinearMap.BilinForm.toLin : BilinForm R M ≃ₗ[R] M →ₗ[R] M →ₗ[R] R 
goal: LinearMap.BilinForm R M ≃ₗ[R] M →ₗ[R] M →ₗ[R] R

full_name: LinearMap.toBilin
code: /-- A map with two arguments that is linear in both is linearly equivalent to bilinear form. -/
@[deprecated (since := "2024-04-26")]
def LinearMap.toBilin : (M →ₗ[R] M →ₗ[R] R) ≃ₗ[R] BilinForm R M 
goal: (M →ₗ[R] M →ₗ[R] R) ≃ₗ[R] LinearMap.BilinForm R M

full_name: LinearMap.toBilinAux_eq
code: @[deprecated (since := "2024-04-26")]
theorem LinearMap.toBilinAux_eq (f : M →ₗ[R] M →ₗ[R] R) :
    LinearMap.toBilinAux f = f 
goal: f.toBilinAux = f

full_name: LinearMap.toBilin_symm
code: @[deprecated (since := "2024-04-26")]
theorem LinearMap.toBilin_symm :
    (LinearMap.toBilin.symm : BilinForm R M ≃ₗ[R] _) = BilinForm.toLin 
goal: LinearMap.toBilin.symm = LinearMap.BilinForm.toLin

full_name: BilinForm.toLin_symm
code: @[deprecated (since := "2024-04-26")]
theorem BilinForm.toLin_symm :
    (BilinForm.toLin.symm : _ ≃ₗ[R] BilinForm R M) = LinearMap.toBilin 
goal: LinearMap.BilinForm.toLin.symm = LinearMap.toBilin

full_name: LinearMap.toBilin_apply
code: @[deprecated (since := "2024-04-26")]
theorem LinearMap.toBilin_apply (f : M →ₗ[R] M →ₗ[R] R) (x y : M) :
    toBilin f x y = f x y 
goal: ((LinearMap.toBilin f) x) y = (f x) y

full_name: BilinForm.toLin_apply
code: @[deprecated (since := "2024-04-26")]
theorem BilinForm.toLin_apply (x : M) : BilinForm.toLin B x = B x 
goal: (LinearMap.BilinForm.toLin B) x = B x

full_name: LinearMap.compBilinForm_apply_apply
code: /-- Apply a linear map on the output of a bilinear form. -/
@[simps!]
def compBilinForm (f : R →ₗ[R'] R') (B : BilinForm R M) : BilinForm R' M 
goal: ∀ (a m : M), ((f.compBilinForm B) a) m = f ((B a) m)

full_name: LinearMap.compBilinForm
code: /-- Apply a linear map on the output of a bilinear form. -/
@[simps!]
def compBilinForm (f : R →ₗ[R'] R') (B : BilinForm R M) : BilinForm R' M 
goal: LinearMap.BilinForm R' M

full_name: LinearMap.BilinForm.comp
code: /-- Apply a linear map on the left and right argument of a bilinear form. -/
def comp (B : BilinForm R M') (l r : M →ₗ[R] M') : BilinForm R M 
goal: LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.compLeft
code: /-- Apply a linear map to the left argument of a bilinear form. -/
def compLeft (B : BilinForm R M) (f : M →ₗ[R] M) : BilinForm R M 
goal: LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.compRight
code: /-- Apply a linear map to the right argument of a bilinear form. -/
def compRight (B : BilinForm R M) (f : M →ₗ[R] M) : BilinForm R M 
goal: LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.comp_comp
code: theorem comp_comp {M'' : Type*} [AddCommMonoid M''] [Module R M''] (B : BilinForm R M'')
    (l r : M →ₗ[R] M') (l' r' : M' →ₗ[R] M'') :
    (B.comp l' r').comp l r = B.comp (l'.comp l) (r'.comp r) 
goal: (B.comp l' r').comp l r = B.comp (l' ∘ₗ l) (r' ∘ₗ r)

full_name: LinearMap.BilinForm.compLeft_compRight
code: @[simp]
theorem compLeft_compRight (B : BilinForm R M) (l r : M →ₗ[R] M) :
    (B.compLeft l).compRight r = B.comp l r 
goal: (B.compLeft l).compRight r = B.comp l r

full_name: LinearMap.BilinForm.compRight_compLeft
code: @[simp]
theorem compRight_compLeft (B : BilinForm R M) (l r : M →ₗ[R] M) :
    (B.compRight r).compLeft l = B.comp l r 
goal: (B.compRight r).compLeft l = B.comp l r

full_name: LinearMap.BilinForm.comp_apply
code: @[simp]
theorem comp_apply (B : BilinForm R M') (l r : M →ₗ[R] M') (v w) : B.comp l r v w = B (l v) (r w) 
goal: ((B.comp l r) v) w = (B (l v)) (r w)

full_name: LinearMap.BilinForm.compLeft_apply
code: @[simp]
theorem compLeft_apply (B : BilinForm R M) (f : M →ₗ[R] M) (v w) : B.compLeft f v w = B (f v) w 
goal: ((B.compLeft f) v) w = (B (f v)) w

full_name: LinearMap.BilinForm.compRight_apply
code: @[simp]
theorem compRight_apply (B : BilinForm R M) (f : M →ₗ[R] M) (v w) : B.compRight f v w = B v (f w) 
goal: ((B.compRight f) v) w = (B v) (f w)

full_name: LinearMap.BilinForm.comp_id_left
code: @[simp]
theorem comp_id_left (B : BilinForm R M) (r : M →ₗ[R] M) :
    B.comp LinearMap.id r = B.compRight r 
goal: B.comp LinearMap.id r = B.compRight r

full_name: LinearMap.BilinForm.comp_id_right
code: @[simp]
theorem comp_id_right (B : BilinForm R M) (l : M →ₗ[R] M) :
    B.comp l LinearMap.id = B.compLeft l 
goal: B.comp l LinearMap.id = B.compLeft l

full_name: LinearMap.BilinForm.compLeft_id
code: @[simp]
theorem compLeft_id (B : BilinForm R M) : B.compLeft LinearMap.id = B 
goal: B.compLeft LinearMap.id = B

full_name: LinearMap.BilinForm.compRight_id
code: @[simp]
theorem compRight_id (B : BilinForm R M) : B.compRight LinearMap.id = B 
goal: B.compRight LinearMap.id = B

full_name: LinearMap.BilinForm.comp_id_id
code: @[simp high]
theorem comp_id_id (B : BilinForm R M) : B.comp LinearMap.id LinearMap.id = B 
goal: B.comp LinearMap.id LinearMap.id = B

full_name: LinearMap.BilinForm.comp_inj
code: theorem comp_inj (B₁ B₂ : BilinForm R M') {l r : M →ₗ[R] M'} (hₗ : Function.Surjective l)
    (hᵣ : Function.Surjective r) : B₁.comp l r = B₂.comp l r ↔ B₁ = B₂ 
goal: B₁.comp l r = B₂.comp l r ↔ B₁ = B₂

full_name: LinearMap.BilinForm.congr
code: /-- Apply a linear equivalence on the arguments of a bilinear form. -/
def congr (e : M ≃ₗ[R] M') : BilinForm R M ≃ₗ[R] BilinForm R M' 
goal: LinearMap.BilinForm R M ≃ₗ[R] LinearMap.BilinForm R M'

full_name: LinearMap.BilinForm.congr_apply
code: @[simp]
theorem congr_apply (e : M ≃ₗ[R] M') (B : BilinForm R M) (x y : M') :
    congr e B x y = B (e.symm x) (e.symm y) 
goal: (((LinearMap.BilinForm.congr e) B) x) y = (B (e.symm x)) (e.symm y)

full_name: LinearMap.BilinForm.congr_symm
code: @[simp]
theorem congr_symm (e : M ≃ₗ[R] M') : (congr e).symm = congr e.symm 
goal: (LinearMap.BilinForm.congr e).symm = LinearMap.BilinForm.congr e.symm

full_name: LinearMap.BilinForm.congr_refl
code: @[simp]
theorem congr_refl : congr (LinearEquiv.refl R M) = LinearEquiv.refl R _ 
goal: LinearMap.BilinForm.congr (LinearEquiv.refl R M) = LinearEquiv.refl R (LinearMap.BilinForm R M)

full_name: LinearMap.BilinForm.congr_trans
code: theorem congr_trans (e : M ≃ₗ[R] M') (f : M' ≃ₗ[R] M'') :
    (congr e).trans (congr f) = congr (e.trans f) 
goal: LinearMap.BilinForm.congr e ≪≫ₗ LinearMap.BilinForm.congr f = LinearMap.BilinForm.congr (e ≪≫ₗ f)

full_name: LinearMap.BilinForm.congr_congr
code: theorem congr_congr (e : M' ≃ₗ[R] M'') (f : M ≃ₗ[R] M') (B : BilinForm R M) :
    congr e (congr f B) = congr (f.trans e) B 
goal: (LinearMap.BilinForm.congr e) ((LinearMap.BilinForm.congr f) B) = (LinearMap.BilinForm.congr (f ≪≫ₗ e)) B

full_name: LinearMap.BilinForm.congr_comp
code: theorem congr_comp (e : M ≃ₗ[R] M') (B : BilinForm R M) (l r : M'' →ₗ[R] M') :
    (congr e B).comp l r =
      B.comp (LinearMap.comp (e.symm : M' →ₗ[R] M) l)
        (LinearMap.comp (e.symm : M' →ₗ[R] M) r) 
goal: ((LinearMap.BilinForm.congr e) B).comp l r = B.comp (↑e.symm ∘ₗ l) (↑e.symm ∘ₗ r)

full_name: LinearMap.BilinForm.comp_congr
code: theorem comp_congr (e : M' ≃ₗ[R] M'') (B : BilinForm R M) (l r : M' →ₗ[R] M) :
    congr e (B.comp l r) =
      B.comp (l.comp (e.symm : M'' →ₗ[R] M')) (r.comp (e.symm : M'' →ₗ[R] M')) 
goal: (LinearMap.BilinForm.congr e) (B.comp l r) = B.comp (l ∘ₗ ↑e.symm) (r ∘ₗ ↑e.symm)

full_name: LinearMap.BilinForm.linMulLin
code: /-- `linMulLin f g` is the bilinear form mapping `x` and `y` to `f x * g y` -/
def linMulLin (f g : M →ₗ[R] R) : BilinForm R M 
goal: LinearMap.BilinForm R M

full_name: LinearMap.BilinForm.linMulLin_apply
code: @[simp]
theorem linMulLin_apply (x y) : linMulLin f g x y = f x * g y 
goal: ((LinearMap.BilinForm.linMulLin f g) x) y = f x * g y

full_name: LinearMap.BilinForm.linMulLin_comp
code: @[simp]
theorem linMulLin_comp (l r : M' →ₗ[R] M) :
    (linMulLin f g).comp l r = linMulLin (f.comp l) (g.comp r) 
goal: (LinearMap.BilinForm.linMulLin f g).comp l r = LinearMap.BilinForm.linMulLin (f ∘ₗ l) (g ∘ₗ r)

full_name: LinearMap.BilinForm.linMulLin_compLeft
code: @[simp]
theorem linMulLin_compLeft (l : M →ₗ[R] M) :
    (linMulLin f g).compLeft l = linMulLin (f.comp l) g 
goal: (LinearMap.BilinForm.linMulLin f g).compLeft l = LinearMap.BilinForm.linMulLin (f ∘ₗ l) g

full_name: LinearMap.BilinForm.linMulLin_compRight
code: @[simp]
theorem linMulLin_compRight (r : M →ₗ[R] M) :
    (linMulLin f g).compRight r = linMulLin f (g.comp r) 
goal: (LinearMap.BilinForm.linMulLin f g).compRight r = LinearMap.BilinForm.linMulLin f (g ∘ₗ r)

full_name: LinearMap.BilinForm.ext_basis
code: /-- Two bilinear forms are equal when they are equal on all basis vectors. -/
theorem ext_basis (h : ∀ i j, B (b i) (b j) = F₂ (b i) (b j)) : B = F₂ 
goal: B = F₂

full_name: LinearMap.BilinForm.sum_repr_mul_repr_mul
code: /-- Write out `B x y` as a sum over `B (b i) (b j)` if `b` is a basis. -/
theorem sum_repr_mul_repr_mul (x y : M) :
    ((b.repr x).sum fun i xi => (b.repr y).sum fun j yj => xi • yj • B (b i) (b j)) = B x y 
goal: ((b.repr x).sum fun i xi => (b.repr y).sum fun j yj => xi • yj • (B (b i)) (b j)) = (B x) y