Documentation

Mathlib.LinearAlgebra.BilinearForm.Hom

Bilinear form and linear maps #

This file describes the relation between bilinear forms and linear maps.

Notations #

Given any term B of type BilinForm, due to a coercion, can use the notation B x y to refer to the function field, ie. B x y = B.bilin x y.

In this file we use the following type variables:

References #

Tags #

Bilinear form,

def BilinForm.toLinHomAux₁ {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (A : BilinForm R M) (x : M) :

Auxiliary definition to define toLinHom; see below.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    def BilinForm.toLinHomAux₂ {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {R₂ : Type u_5} [CommSemiring R₂] [Algebra R₂ R] [Module R₂ M] [IsScalarTower R₂ R M] (A : BilinForm R M) :
    M →ₗ[R₂] M →ₗ[R] R

    Auxiliary definition to define toLinHom; see below.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      def BilinForm.toLinHom {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (R₂ : Type u_5) [CommSemiring R₂] [Algebra R₂ R] [Module R₂ M] [IsScalarTower R₂ R M] :
      BilinForm R M →ₗ[R₂] M →ₗ[R₂] M →ₗ[R] R

      The linear map obtained from a BilinForm by fixing the left co-ordinate and evaluating in the right. This is the most general version of the construction; it is R₂-linear for some distinguished commutative subsemiring R₂ of the scalar ring. Over a semiring with no particular distinguished such subsemiring, use toLin', which is -linear. Over a commutative semiring, use toLin, which is linear.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        @[simp]
        theorem BilinForm.toLin'_apply {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {R₂ : Type u_5} [CommSemiring R₂] [Algebra R₂ R] [Module R₂ M] [IsScalarTower R₂ R M] (A : BilinForm R M) (x : M) :
        (((BilinForm.toLinHom R₂) A) x) = A.bilin x
        @[inline, reducible]
        abbrev BilinForm.toLin' {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] :

        The linear map obtained from a BilinForm by fixing the left co-ordinate and evaluating in the right. Over a commutative semiring, use toLin, which is linear rather than -linear.

        Equations
        Instances For
          @[simp]
          theorem BilinForm.sum_left {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) {α : Type u_11} (t : Finset α) (g : αM) (w : M) :
          B.bilin (Finset.sum t fun (i : α) => g i) w = Finset.sum t fun (i : α) => B.bilin (g i) w
          @[simp]
          theorem BilinForm.sum_right {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) {α : Type u_11} (t : Finset α) (w : M) (g : αM) :
          B.bilin w (Finset.sum t fun (i : α) => g i) = Finset.sum t fun (i : α) => B.bilin w (g i)
          @[simp]
          theorem BilinForm.sum_apply {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {α : Type u_11} (t : Finset α) (B : αBilinForm R M) (v : M) (w : M) :
          (Finset.sum t fun (i : α) => B i).bilin v w = Finset.sum t fun (i : α) => (B i).bilin v w
          def BilinForm.toLinHomFlip {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (R₂ : Type u_5) [CommSemiring R₂] [Algebra R₂ R] [Module R₂ M] [IsScalarTower R₂ R M] :
          BilinForm R M →ₗ[R₂] M →ₗ[R₂] M →ₗ[R] R

          The linear map obtained from a BilinForm by fixing the right co-ordinate and evaluating in the left. This is the most general version of the construction; it is R₂-linear for some distinguished commutative subsemiring R₂ of the scalar ring. Over semiring with no particular distinguished such subsemiring, use toLin'Flip, which is -linear. Over a commutative semiring, use toLinFlip, which is linear.

          Equations
          Instances For
            @[simp]
            theorem BilinForm.toLin'Flip_apply {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {R₂ : Type u_5} [CommSemiring R₂] [Algebra R₂ R] [Module R₂ M] [IsScalarTower R₂ R M] (A : BilinForm R M) (x : M) :
            (((BilinForm.toLinHomFlip R₂) A) x) = fun (y : M) => A.bilin y x
            @[inline, reducible]

            The linear map obtained from a BilinForm by fixing the right co-ordinate and evaluating in the left. Over a commutative semiring, use toLinFlip, which is linear rather than -linear.

            Equations
            Instances For
              def LinearMap.toBilinAux {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] (f : M₂ →ₗ[R₂] M₂ →ₗ[R₂] R₂) :
              BilinForm R₂ M₂

              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.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                def BilinForm.toLin {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] :
                BilinForm R₂ M₂ ≃ₗ[R₂] M₂ →ₗ[R₂] M₂ →ₗ[R₂] R₂

                Bilinear forms are linearly equivalent to maps with two arguments that are linear in both.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  def LinearMap.toBilin {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] :
                  (M₂ →ₗ[R₂] M₂ →ₗ[R₂] R₂) ≃ₗ[R₂] BilinForm R₂ M₂

                  A map with two arguments that is linear in both is linearly equivalent to bilinear form.

                  Equations
                  Instances For
                    @[simp]
                    theorem LinearMap.toBilinAux_eq {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] (f : M₂ →ₗ[R₂] M₂ →ₗ[R₂] R₂) :
                    LinearMap.toBilinAux f = LinearMap.toBilin f
                    @[simp]
                    theorem LinearMap.toBilin_symm {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] :
                    LinearEquiv.symm LinearMap.toBilin = BilinForm.toLin
                    @[simp]
                    theorem BilinForm.toLin_symm {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] :
                    LinearEquiv.symm BilinForm.toLin = LinearMap.toBilin
                    @[simp]
                    theorem LinearMap.toBilin_apply {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] (f : M₂ →ₗ[R₂] M₂ →ₗ[R₂] R₂) (x : M₂) (y : M₂) :
                    (LinearMap.toBilin f).bilin x y = (f x) y
                    @[simp]
                    theorem BilinForm.toLin_apply {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {B₂ : BilinForm R₂ M₂} (x : M₂) :
                    ((BilinForm.toLin B₂) x) = B₂.bilin x
                    @[simp]
                    theorem LinearMap.compBilinForm_apply {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {R' : Type u_11} [CommSemiring R'] [Algebra R' R] [Module R' M] [IsScalarTower R' R M] (f : R →ₗ[R'] R') (B : BilinForm R M) (x : M) (y : M) :
                    (LinearMap.compBilinForm f B).bilin x y = f (B.bilin x y)
                    def LinearMap.compBilinForm {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {R' : Type u_11} [CommSemiring R'] [Algebra R' R] [Module R' M] [IsScalarTower R' R M] (f : R →ₗ[R'] R') (B : BilinForm R M) :

                    Apply a linear map on the output of a bilinear form.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      def BilinForm.comp {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {M' : Type w} [AddCommMonoid M'] [Module R M'] (B : BilinForm R M') (l : M →ₗ[R] M') (r : M →ₗ[R] M') :

                      Apply a linear map on the left and right argument of a bilinear form.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        def BilinForm.compLeft {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (f : M →ₗ[R] M) :

                        Apply a linear map to the left argument of a bilinear form.

                        Equations
                        Instances For
                          def BilinForm.compRight {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (f : M →ₗ[R] M) :

                          Apply a linear map to the right argument of a bilinear form.

                          Equations
                          Instances For
                            theorem BilinForm.comp_comp {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {M' : Type w} [AddCommMonoid M'] [Module R M'] {M'' : Type u_11} [AddCommMonoid M''] [Module R M''] (B : BilinForm R M'') (l : M →ₗ[R] M') (r : M →ₗ[R] M') (l' : M' →ₗ[R] M'') (r' : M' →ₗ[R] M'') :
                            BilinForm.comp (BilinForm.comp B l' r') l r = BilinForm.comp B (l' ∘ₗ l) (r' ∘ₗ r)
                            @[simp]
                            theorem BilinForm.compLeft_compRight {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (l : M →ₗ[R] M) (r : M →ₗ[R] M) :
                            @[simp]
                            theorem BilinForm.compRight_compLeft {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (l : M →ₗ[R] M) (r : M →ₗ[R] M) :
                            @[simp]
                            theorem BilinForm.comp_apply {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {M' : Type w} [AddCommMonoid M'] [Module R M'] (B : BilinForm R M') (l : M →ₗ[R] M') (r : M →ₗ[R] M') (v : M) (w : M) :
                            (BilinForm.comp B l r).bilin v w = B.bilin (l v) (r w)
                            @[simp]
                            theorem BilinForm.compLeft_apply {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (f : M →ₗ[R] M) (v : M) (w : M) :
                            (BilinForm.compLeft B f).bilin v w = B.bilin (f v) w
                            @[simp]
                            theorem BilinForm.compRight_apply {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (f : M →ₗ[R] M) (v : M) (w : M) :
                            (BilinForm.compRight B f).bilin v w = B.bilin v (f w)
                            @[simp]
                            theorem BilinForm.comp_id_left {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (r : M →ₗ[R] M) :
                            BilinForm.comp B LinearMap.id r = BilinForm.compRight B r
                            @[simp]
                            theorem BilinForm.comp_id_right {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) (l : M →ₗ[R] M) :
                            BilinForm.comp B l LinearMap.id = BilinForm.compLeft B l
                            @[simp]
                            theorem BilinForm.compLeft_id {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) :
                            BilinForm.compLeft B LinearMap.id = B
                            @[simp]
                            theorem BilinForm.compRight_id {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) :
                            BilinForm.compRight B LinearMap.id = B
                            @[simp]
                            theorem BilinForm.comp_id_id {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] (B : BilinForm R M) :
                            BilinForm.comp B LinearMap.id LinearMap.id = B
                            theorem BilinForm.comp_inj {R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] {M' : Type w} [AddCommMonoid M'] [Module R M'] (B₁ : BilinForm R M') (B₂ : BilinForm R M') {l : M →ₗ[R] M'} {r : M →ₗ[R] M'} (hₗ : Function.Surjective l) (hᵣ : Function.Surjective r) :
                            BilinForm.comp B₁ l r = BilinForm.comp B₂ l r B₁ = B₂
                            def BilinForm.congr {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} [AddCommMonoid M₂'] [Module R₂ M₂'] (e : M₂ ≃ₗ[R₂] M₂') :
                            BilinForm R₂ M₂ ≃ₗ[R₂] BilinForm R₂ M₂'

                            Apply a linear equivalence on the arguments of a bilinear form.

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              @[simp]
                              theorem BilinForm.congr_apply {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} [AddCommMonoid M₂'] [Module R₂ M₂'] (e : M₂ ≃ₗ[R₂] M₂') (B : BilinForm R₂ M₂) (x : M₂') (y : M₂') :
                              ((BilinForm.congr e) B).bilin x y = B.bilin ((LinearEquiv.symm e) x) ((LinearEquiv.symm e) y)
                              @[simp]
                              theorem BilinForm.congr_symm {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} [AddCommMonoid M₂'] [Module R₂ M₂'] (e : M₂ ≃ₗ[R₂] M₂') :
                              @[simp]
                              theorem BilinForm.congr_refl {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] :
                              theorem BilinForm.congr_trans {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} {M₂'' : Type u_12} [AddCommMonoid M₂'] [AddCommMonoid M₂''] [Module R₂ M₂'] [Module R₂ M₂''] (e : M₂ ≃ₗ[R₂] M₂') (f : M₂' ≃ₗ[R₂] M₂'') :
                              BilinForm.congr e ≪≫ₗ BilinForm.congr f = BilinForm.congr (e ≪≫ₗ f)
                              theorem BilinForm.congr_congr {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} {M₂'' : Type u_12} [AddCommMonoid M₂'] [AddCommMonoid M₂''] [Module R₂ M₂'] [Module R₂ M₂''] (e : M₂' ≃ₗ[R₂] M₂'') (f : M₂ ≃ₗ[R₂] M₂') (B : BilinForm R₂ M₂) :
                              (BilinForm.congr e) ((BilinForm.congr f) B) = (BilinForm.congr (f ≪≫ₗ e)) B
                              theorem BilinForm.congr_comp {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} {M₂'' : Type u_12} [AddCommMonoid M₂'] [AddCommMonoid M₂''] [Module R₂ M₂'] [Module R₂ M₂''] (e : M₂ ≃ₗ[R₂] M₂') (B : BilinForm R₂ M₂) (l : M₂'' →ₗ[R₂] M₂') (r : M₂'' →ₗ[R₂] M₂') :
                              BilinForm.comp ((BilinForm.congr e) B) l r = BilinForm.comp B ((LinearEquiv.symm e) ∘ₗ l) ((LinearEquiv.symm e) ∘ₗ r)
                              theorem BilinForm.comp_congr {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} {M₂'' : Type u_12} [AddCommMonoid M₂'] [AddCommMonoid M₂''] [Module R₂ M₂'] [Module R₂ M₂''] (e : M₂' ≃ₗ[R₂] M₂'') (B : BilinForm R₂ M₂) (l : M₂' →ₗ[R₂] M₂) (r : M₂' →ₗ[R₂] M₂) :
                              (BilinForm.congr e) (BilinForm.comp B l r) = BilinForm.comp B (l ∘ₗ (LinearEquiv.symm e)) (r ∘ₗ (LinearEquiv.symm e))
                              def BilinForm.linMulLin {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] (f : M₂ →ₗ[R₂] R₂) (g : M₂ →ₗ[R₂] R₂) :
                              BilinForm R₂ M₂

                              linMulLin f g is the bilinear form mapping x and y to f x * g y

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                @[simp]
                                theorem BilinForm.linMulLin_apply {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {f : M₂ →ₗ[R₂] R₂} {g : M₂ →ₗ[R₂] R₂} (x : M₂) (y : M₂) :
                                (BilinForm.linMulLin f g).bilin x y = f x * g y
                                @[simp]
                                theorem BilinForm.linMulLin_comp {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {M₂' : Type u_11} [AddCommMonoid M₂'] [Module R₂ M₂'] {f : M₂ →ₗ[R₂] R₂} {g : M₂ →ₗ[R₂] R₂} (l : M₂' →ₗ[R₂] M₂) (r : M₂' →ₗ[R₂] M₂) :
                                BilinForm.comp (BilinForm.linMulLin f g) l r = BilinForm.linMulLin (f ∘ₗ l) (g ∘ₗ r)
                                @[simp]
                                theorem BilinForm.linMulLin_compLeft {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {f : M₂ →ₗ[R₂] R₂} {g : M₂ →ₗ[R₂] R₂} (l : M₂ →ₗ[R₂] M₂) :
                                @[simp]
                                theorem BilinForm.linMulLin_compRight {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {f : M₂ →ₗ[R₂] R₂} {g : M₂ →ₗ[R₂] R₂} (r : M₂ →ₗ[R₂] M₂) :
                                theorem BilinForm.ext_basis {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {B₂ : BilinForm R₂ M₂} {F₂ : BilinForm R₂ M₂} {ι : Type u_13} (b : Basis ι R₂ M₂) (h : ∀ (i j : ι), B₂.bilin (b i) (b j) = F₂.bilin (b i) (b j)) :
                                B₂ = F₂

                                Two bilinear forms are equal when they are equal on all basis vectors.

                                theorem BilinForm.sum_repr_mul_repr_mul {R₂ : Type u_5} {M₂ : Type u_6} [CommSemiring R₂] [AddCommMonoid M₂] [Module R₂ M₂] {B₂ : BilinForm R₂ M₂} {ι : Type u_13} (b : Basis ι R₂ M₂) (x : M₂) (y : M₂) :
                                (Finsupp.sum (b.repr x) fun (i : ι) (xi : R₂) => Finsupp.sum (b.repr y) fun (j : ι) (yj : R₂) => xi yj B₂.bilin (b i) (b j)) = B₂.bilin x y

                                Write out B x y as a sum over B (b i) (b j) if b is a basis.