fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
add [Add α] (a b : Thunk α) : Thunk α := Thunk.mk fun _ => a.get + b.get | def | Lean | [
"Mathlib.Init"
] | Mathlib/Lean/Thunk.lean | add | The sum of two thunks. |
@[simp] add_get [Add α] {a b : Thunk α} : (a + b).get = a.get + b.get := rfl | theorem | Lean | [
"Mathlib.Init"
] | Mathlib/Lean/Thunk.lean | add_get | null |
noncomputable annIdeal (a : A) : Ideal R[X] :=
RingHom.ker ((aeval a).toRingHom : R[X] →+* A) | def | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | annIdeal | `annIdeal R a` is the *annihilating ideal* of all `p : R[X]` such that `p(a) = 0`.
The informal notation `p(a)` stand for `Polynomial.aeval a p`.
Again informally, the annihilating ideal of `a` is
`{ p ∈ R[X] | p(a) = 0 }`. This is an ideal in `R[X]`.
The formal definition uses the kernel of the aeval map. |
mem_annIdeal_iff_aeval_eq_zero {a : A} {p : R[X]} : p ∈ annIdeal R a ↔ aeval a p = 0 :=
Iff.rfl | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | mem_annIdeal_iff_aeval_eq_zero | It is useful to refer to ideal membership sometimes
and the annihilation condition other times. |
noncomputable annIdealGenerator (a : A) : 𝕜[X] :=
let g := IsPrincipal.generator <| annIdeal 𝕜 a
g * C g.leadingCoeff⁻¹ | def | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | annIdealGenerator | `annIdealGenerator 𝕜 a` is the monic generator of `annIdeal 𝕜 a`
if one exists, otherwise `0`.
Since `𝕜[X]` is a principal ideal domain there is a polynomial `g` such that
`span 𝕜 {g} = annIdeal a`. This picks some generator.
We prefer the monic generator of the ideal. |
@[simp]
annIdealGenerator_eq_zero_iff {a : A} : annIdealGenerator 𝕜 a = 0 ↔ annIdeal 𝕜 a = ⊥ := by
simp only [annIdealGenerator, mul_eq_zero, IsPrincipal.eq_bot_iff_generator_eq_zero,
Polynomial.C_eq_zero, inv_eq_zero, Polynomial.leadingCoeff_eq_zero, or_self_iff] | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | annIdealGenerator_eq_zero_iff | null |
@[simp]
span_singleton_annIdealGenerator (a : A) :
Ideal.span {annIdealGenerator 𝕜 a} = annIdeal 𝕜 a := by
by_cases h : annIdealGenerator 𝕜 a = 0
· rw [h, annIdealGenerator_eq_zero_iff.mp h, Set.singleton_zero, Ideal.span_zero]
· rw [annIdealGenerator, Ideal.span_singleton_mul_right_unit, Ideal.span_singleton_generator]
apply Polynomial.isUnit_C.mpr
apply IsUnit.mk0
apply inv_eq_zero.not.mpr
apply Polynomial.leadingCoeff_eq_zero.not.mpr
apply (mul_ne_zero_iff.mp h).1 | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | span_singleton_annIdealGenerator | `annIdealGenerator 𝕜 a` is indeed a generator. |
annIdealGenerator_mem (a : A) : annIdealGenerator 𝕜 a ∈ annIdeal 𝕜 a :=
Ideal.mul_mem_right _ _ (Submodule.IsPrincipal.generator_mem _) | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | annIdealGenerator_mem | The annihilating ideal generator is a member of the annihilating ideal. |
mem_iff_eq_smul_annIdealGenerator {p : 𝕜[X]} (a : A) :
p ∈ annIdeal 𝕜 a ↔ ∃ s : 𝕜[X], p = s • annIdealGenerator 𝕜 a := by
simp_rw [@eq_comm _ p, ← mem_span_singleton, ← span_singleton_annIdealGenerator 𝕜 a, Ideal.span] | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | mem_iff_eq_smul_annIdealGenerator | null |
monic_annIdealGenerator (a : A) (hg : annIdealGenerator 𝕜 a ≠ 0) :
Monic (annIdealGenerator 𝕜 a) :=
monic_mul_leadingCoeff_inv (mul_ne_zero_iff.mp hg).1
/-! We are working toward showing the generator of the annihilating ideal
in the field case is the minimal polynomial. We are going to use a uniqueness | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | monic_annIdealGenerator | The generator we chose for the annihilating ideal is monic when the ideal is non-zero. |
of the minimal polynomial.
This is the first condition: it must annihilate the original element `a : A`. -/ | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | of | null |
annIdealGenerator_aeval_eq_zero (a : A) : aeval a (annIdealGenerator 𝕜 a) = 0 :=
mem_annIdeal_iff_aeval_eq_zero.mp (annIdealGenerator_mem 𝕜 a)
variable {𝕜} | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | annIdealGenerator_aeval_eq_zero | null |
mem_iff_annIdealGenerator_dvd {p : 𝕜[X]} {a : A} :
p ∈ annIdeal 𝕜 a ↔ annIdealGenerator 𝕜 a ∣ p := by
rw [← Ideal.mem_span_singleton, span_singleton_annIdealGenerator] | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | mem_iff_annIdealGenerator_dvd | null |
degree_annIdealGenerator_le_of_mem (a : A) (p : 𝕜[X]) (hp : p ∈ annIdeal 𝕜 a)
(hpn0 : p ≠ 0) : degree (annIdealGenerator 𝕜 a) ≤ degree p :=
degree_le_of_dvd (mem_iff_annIdealGenerator_dvd.1 hp) hpn0
variable (𝕜) | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | degree_annIdealGenerator_le_of_mem | The generator of the annihilating ideal has minimal degree among
the non-zero members of the annihilating ideal |
annIdealGenerator_eq_minpoly (a : A) : annIdealGenerator 𝕜 a = minpoly 𝕜 a := by
by_cases h : annIdealGenerator 𝕜 a = 0
· rw [h, minpoly.eq_zero]
rintro ⟨p, p_monic, hp : aeval a p = 0⟩
refine p_monic.ne_zero (Ideal.mem_bot.mp ?_)
simpa only [annIdealGenerator_eq_zero_iff.mp h] using mem_annIdeal_iff_aeval_eq_zero.mpr hp
· exact minpoly.unique _ _ (monic_annIdealGenerator _ _ h) (annIdealGenerator_aeval_eq_zero _ _)
fun q q_monic hq =>
degree_annIdealGenerator_le_of_mem a q (mem_annIdeal_iff_aeval_eq_zero.mpr hq)
q_monic.ne_zero | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | annIdealGenerator_eq_minpoly | The generator of the annihilating ideal is the minimal polynomial. |
monic_generator_eq_minpoly (a : A) (p : 𝕜[X]) (p_monic : p.Monic)
(p_gen : Ideal.span {p} = annIdeal 𝕜 a) : annIdealGenerator 𝕜 a = p := by
by_cases h : p = 0
· rwa [h, annIdealGenerator_eq_zero_iff, ← p_gen, Ideal.span_singleton_eq_bot.mpr]
· rw [← span_singleton_annIdealGenerator, Ideal.span_singleton_eq_span_singleton] at p_gen
rw [eq_comm]
apply eq_of_monic_of_associated p_monic _ p_gen
apply monic_annIdealGenerator _ _ ((Associated.ne_zero_iff p_gen).mp h) | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | monic_generator_eq_minpoly | If a monic generates the annihilating ideal, it must match our choice
of the annihilating ideal generator. |
span_minpoly_eq_annihilator {M} [AddCommGroup M] [Module 𝕜 M] (f : Module.End 𝕜 M) :
Ideal.span {minpoly 𝕜 f} = Module.annihilator 𝕜[X] (Module.AEval' f) := by
rw [← annIdealGenerator_eq_minpoly, span_singleton_annIdealGenerator]; ext
rw [mem_annIdeal_iff_aeval_eq_zero, DFunLike.ext_iff, Module.mem_annihilator]; rfl | theorem | LinearAlgebra | [
"Mathlib.FieldTheory.Minpoly.Field",
"Mathlib.RingTheory.PrincipalIdealDomain",
"Mathlib.Algebra.Polynomial.Module.AEval"
] | Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean | span_minpoly_eq_annihilator | null |
mk₂'ₛₗ (f : M → N → P) (H1 : ∀ m₁ m₂ n, f (m₁ + m₂) n = f m₁ n + f m₂ n)
(H2 : ∀ (c : R) (m n), f (c • m) n = ρ₁₂ c • f m n)
(H3 : ∀ m n₁ n₂, f m (n₁ + n₂) = f m n₁ + f m n₂)
(H4 : ∀ (c : S) (m n), f m (c • n) = σ₁₂ c • f m n) : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P where
toFun m :=
{ toFun := f m
map_add' := H3 m
map_smul' := fun c => H4 c m }
map_add' m₁ m₂ := LinearMap.ext <| H1 m₁ m₂
map_smul' c m := LinearMap.ext <| H2 c m
variable {ρ₁₂ σ₁₂}
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | mk₂'ₛₗ | Create a bilinear map from a function that is semilinear in each component.
See `mk₂'` and `mk₂` for the linear case. |
mk₂'ₛₗ_apply (f : M → N → P) {H1 H2 H3 H4} (m : M) (n : N) :
(mk₂'ₛₗ ρ₁₂ σ₁₂ f H1 H2 H3 H4 : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) m n = f m n := rfl
variable (R S) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | mk₂'ₛₗ_apply | null |
mk₂' (f : M → N → Pₗ) (H1 : ∀ m₁ m₂ n, f (m₁ + m₂) n = f m₁ n + f m₂ n)
(H2 : ∀ (c : R) (m n), f (c • m) n = c • f m n)
(H3 : ∀ m n₁ n₂, f m (n₁ + n₂) = f m n₁ + f m n₂)
(H4 : ∀ (c : S) (m n), f m (c • n) = c • f m n) : M →ₗ[R] N →ₗ[S] Pₗ :=
mk₂'ₛₗ (RingHom.id R) (RingHom.id S) f H1 H2 H3 H4
variable {R S}
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | mk₂' | Create a bilinear map from a function that is linear in each component.
See `mk₂` for the special case where both arguments come from modules over the same ring. |
mk₂'_apply (f : M → N → Pₗ) {H1 H2 H3 H4} (m : M) (n : N) :
(mk₂' R S f H1 H2 H3 H4 : M →ₗ[R] N →ₗ[S] Pₗ) m n = f m n := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | mk₂'_apply | null |
ext₂ {f g : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P} (H : ∀ m n, f m n = g m n) : f = g :=
LinearMap.ext fun m => LinearMap.ext fun n => H m n | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | ext₂ | null |
congr_fun₂ {f g : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P} (h : f = g) (x y) : f x y = g x y :=
LinearMap.congr_fun (LinearMap.congr_fun h x) y | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | congr_fun₂ | null |
ext_iff₂ {f g : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P} : f = g ↔ ∀ m n, f m n = g m n :=
⟨congr_fun₂, ext₂⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | ext_iff₂ | null |
flip (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) : N →ₛₗ[σ₁₂] M →ₛₗ[ρ₁₂] P :=
mk₂'ₛₗ σ₁₂ ρ₁₂ (fun n m => f m n) (fun _ _ m => (f m).map_add _ _)
(fun _ _ m => (f m).map_smulₛₗ _ _)
(fun n m₁ m₂ => by simp only [map_add, add_apply])
(fun c n m => by simp only [map_smulₛₗ _, smul_apply])
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | flip | Given a linear map from `M` to linear maps from `N` to `P`, i.e., a bilinear map from `M × N` to
`P`, change the order of variables and get a linear map from `N` to linear maps from `M` to `P`. |
flip_apply (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (m : M) (n : N) : flip f n m = f m n := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | flip_apply | null |
lcompₛₗ (f : M →ₛₗ[σ₁₂] N) : (N →ₛₗ[σ₂₃] P) →ₗ[R₅] M →ₛₗ[σ₁₃] P :=
letI := SMulCommClass.symm
flip <| LinearMap.comp (flip id) f
variable {P σ₂₃ R₅}
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lcompₛₗ | Composing a semilinear map `M → N` and a semilinear map `N → P` to form a semilinear map
`M → P` is itself a linear map. |
lcompₛₗ_apply (f : M →ₛₗ[σ₁₂] N) (g : N →ₛₗ[σ₂₃] P) (x : M) :
lcompₛₗ R₅ P σ₂₃ f g x = g (f x) := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lcompₛₗ_apply | null |
compl₂ (h : M →ₛₗ[σ₁₅] N →ₛₗ[σ₂₃] P) (g : Q →ₛₗ[σ₄₂] N) : M →ₛₗ[σ₁₅] Q →ₛₗ[σ₄₃] P where
toFun a := (lcompₛₗ R₅ P σ₂₃ g) (h a)
map_add' _ _ := by
simp [map_add]
map_smul' _ _ := by
simp [LinearMap.map_smulₛₗ, lcompₛₗ]
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compl₂ | Composing a linear map `Q → N` and a bilinear map `M → N → P` to
form a bilinear map `M → Q → P`. |
compl₂_apply (h : M →ₛₗ[σ₁₅] N →ₛₗ[σ₂₃] P) (g : Q →ₛₗ[σ₄₂] N) (m : M) (q : Q) :
h.compl₂ g m q = h m (g q) := rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compl₂_apply | null |
compl₂_id (h : M →ₛₗ[σ₁₅] N →ₛₗ[σ₂₃] P) : h.compl₂ LinearMap.id = h := by
ext
rw [compl₂_apply, id_coe, _root_.id] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compl₂_id | null |
lcomp (f : M →ₗ[R] M₂) : (M₂ →ₗ[R] N) →ₗ[S] M →ₗ[R] N :=
lcompₛₗ _ _ _ f
variable {S N}
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lcomp | Composing a given linear map `M → N` with a linear map `N → P` as a linear map from
`Nₗ →ₗ[R] Pₗ` to `M →ₗ[R] Pₗ`. |
lcomp_apply (f : M →ₗ[R] M₂) (g : M₂ →ₗ[R] N) (x : M) : lcomp S N f g x = g (f x) := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lcomp_apply | null |
lcomp_apply' (f : M →ₗ[R] M₂) (g : M₂ →ₗ[R] N) : lcomp S N f g = g ∘ₗ f := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lcomp_apply' | null |
@[simp]
flip_flip (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) : f.flip.flip = f :=
LinearMap.ext₂ fun _x _y => (f.flip.flip_apply _ _).trans (f.flip_apply _ _) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | flip_flip | null |
flip_inj {f g : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P} (H : flip f = flip g) : f = g :=
ext₂ fun m n => show flip f n m = flip g n m by rw [H] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | flip_inj | null |
map_zero₂ (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (y) : f 0 y = 0 :=
(flip f y).map_zero | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | map_zero₂ | null |
map_neg₂ (f : M' →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P') (x y) : f (-x) y = -f x y :=
(flip f y).map_neg _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | map_neg₂ | null |
map_sub₂ (f : M' →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P') (x y z) : f (x - y) z = f x z - f y z :=
(flip f z).map_sub _ _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | map_sub₂ | null |
map_add₂ (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (x₁ x₂ y) : f (x₁ + x₂) y = f x₁ y + f x₂ y :=
(flip f y).map_add _ _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | map_add₂ | null |
map_smul₂ (f : M₂ →ₗ[R] N₂ →ₛₗ[σ₁₂] P₂) (r : R) (x y) : f (r • x) y = r • f x y :=
(flip f y).map_smul _ _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | map_smul₂ | null |
map_smulₛₗ₂ (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (r : R) (x y) : f (r • x) y = ρ₁₂ r • f x y :=
(flip f y).map_smulₛₗ _ _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | map_smulₛₗ₂ | null |
map_sum₂ {ι : Type*} (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (t : Finset ι) (x : ι → M) (y) :
f (∑ i ∈ t, x i) y = ∑ i ∈ t, f (x i) y :=
_root_.map_sum (flip f y) _ _ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | map_sum₂ | null |
domRestrict₂ (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (q : Submodule S N) : M →ₛₗ[ρ₁₂] q →ₛₗ[σ₁₂] P where
toFun m := (f m).domRestrict q
map_add' m₁ m₂ := LinearMap.ext fun _ => by simp only [map_add, domRestrict_apply, add_apply]
map_smul' c m :=
LinearMap.ext fun _ => by simp only [f.map_smulₛₗ, domRestrict_apply, smul_apply] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | domRestrict₂ | Restricting a bilinear map in the second entry |
domRestrict₂_apply (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (q : Submodule S N) (x : M) (y : q) :
f.domRestrict₂ q x y = f x y := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | domRestrict₂_apply | null |
domRestrict₁₂ (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (p : Submodule R M) (q : Submodule S N) :
p →ₛₗ[ρ₁₂] q →ₛₗ[σ₁₂] P :=
(f.domRestrict p).domRestrict₂ q | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | domRestrict₁₂ | Restricting a bilinear map in both components |
domRestrict₁₂_apply (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (p : Submodule R M) (q : Submodule S N)
(x : p) (y : q) : f.domRestrict₁₂ p q x y = f x y := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | domRestrict₁₂_apply | null |
@[simps!]
restrictScalars₁₂ (B : M →ₗ[R] N →ₗ[S] Pₗ) : M →ₗ[R'] N →ₗ[S'] Pₗ :=
LinearMap.mk₂' R' S'
(B · ·)
B.map_add₂
(fun r' m _ ↦ by
dsimp only
rw [← smul_one_smul R r' m, map_smul₂, smul_one_smul])
(fun _ ↦ map_add _)
(fun _ x ↦ (B x).map_smul_of_tower _) | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalars₁₂ | If `B : M → N → Pₗ` is `R`-`S` bilinear and `R'` and `S'` are compatible scalar multiplications,
then the restriction of scalars is a `R'`-`S'` bilinear map. |
restrictScalars₁₂_injective : Function.Injective
(LinearMap.restrictScalars₁₂ R' S' : (M →ₗ[R] N →ₗ[S] Pₗ) → (M →ₗ[R'] N →ₗ[S'] Pₗ)) :=
fun _ _ h ↦ ext₂ (congr_fun₂ h :)
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalars₁₂_injective | null |
restrictScalars₁₂_inj {B B' : M →ₗ[R] N →ₗ[S] Pₗ} :
B.restrictScalars₁₂ R' S' = B'.restrictScalars₁₂ R' S' ↔ B = B' :=
(restrictScalars₁₂_injective R' S').eq_iff | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalars₁₂_inj | null |
lflip {R₀ : Type*} [Semiring R₀] [Module R₀ P] [SMulCommClass S₂ R₀ P] [SMulCommClass R₂ R₀ P] :
(M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) ≃ₗ[R₀] (N →ₛₗ[σ₁₂] M →ₛₗ[ρ₁₂] P) where
toFun := flip
invFun := flip
map_add' _ _ := rfl
map_smul' _ _ := rfl
left_inv _ := rfl
right_inv _ := rfl
@[simp] theorem lflip_symm
{R₀ : Type*} [Semiring R₀] [Module R₀ P] [SMulCommClass S₂ R₀ P] [SMulCommClass R₂ R₀ P] :
(lflip : (M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) ≃ₗ[R₀] (N →ₛₗ[σ₁₂] M →ₛₗ[ρ₁₂] P)).symm = lflip :=
rfl
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lflip | `LinearMap.flip` as an isomorphism of modules. |
lflip_apply {R₀ : Type*} [Semiring R₀] [Module R₀ P] [SMulCommClass S₂ R₀ P]
[SMulCommClass R₂ R₀ P] (f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) :
lflip (R₀ := R₀) f = f.flip := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lflip_apply | null |
mk₂ (f : M → Nₗ → Pₗ) (H1 : ∀ m₁ m₂ n, f (m₁ + m₂) n = f m₁ n + f m₂ n)
(H2 : ∀ (c : R) (m n), f (c • m) n = c • f m n)
(H3 : ∀ m n₁ n₂, f m (n₁ + n₂) = f m n₁ + f m n₂)
(H4 : ∀ (c : R) (m n), f m (c • n) = c • f m n) : M →ₗ[R] Nₗ →ₗ[R] Pₗ :=
mk₂' R R f H1 H2 H3 H4
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | mk₂ | Create a bilinear map from a function that is linear in each component.
This is a shorthand for `mk₂'` for the common case when `R = S`. |
mk₂_apply (f : M → Nₗ → Pₗ) {H1 H2 H3 H4} (m : M) (n : Nₗ) :
(mk₂ R f H1 H2 H3 H4 : M →ₗ[R] Nₗ →ₗ[R] Pₗ) m n = f m n := rfl
variable [Module A Pₗ] [SMulCommClass R A Pₗ] {R} | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | mk₂_apply | null |
compl₁₂ [SMulCommClass R₂ R₁ Pₗ]
(f : Mₗ →ₗ[R₁] N →ₗ[R₂] Pₗ) (g : Qₗ →ₗ[R₁] Mₗ) (g' : Qₗ' →ₗ[R₂] N) :
Qₗ →ₗ[R₁] Qₗ' →ₗ[R₂] Pₗ :=
(f.comp g).compl₂ g'
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compl₁₂ | Composing linear maps `Q → M` and `Q' → N` with a bilinear map `M → N → P` to
form a bilinear map `Q → Q' → P`. |
compl₁₂_apply [SMulCommClass R₂ R₁ Pₗ]
(f : Mₗ →ₗ[R₁] N →ₗ[R₂] Pₗ) (g : Qₗ →ₗ[R₁] Mₗ) (g' : Qₗ' →ₗ[R₂] N) (x : Qₗ)
(y : Qₗ') : f.compl₁₂ g g' x y = f (g x) (g' y) := rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compl₁₂_apply | null |
compl₁₂_id_id [SMulCommClass R₂ R₁ Pₗ] (f : Mₗ →ₗ[R₁] N →ₗ[R₂] Pₗ) :
f.compl₁₂ LinearMap.id LinearMap.id = f := by
ext
simp_rw [compl₁₂_apply, id_coe, _root_.id] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compl₁₂_id_id | null |
compl₁₂_inj [SMulCommClass R₂ R₁ Pₗ]
{f₁ f₂ : Mₗ →ₗ[R₁] N →ₗ[R₂] Pₗ} {g : Qₗ →ₗ[R₁] Mₗ} {g' : Qₗ' →ₗ[R₂] N}
(hₗ : Function.Surjective g) (hᵣ : Function.Surjective g') :
f₁.compl₁₂ g g' = f₂.compl₁₂ g g' ↔ f₁ = f₂ := by
constructor <;> intro h
· -- B₁.comp l r = B₂.comp l r → B₁ = B₂
ext x y
obtain ⟨x', hx⟩ := hₗ x
subst hx
obtain ⟨y', hy⟩ := hᵣ y
subst hy
convert LinearMap.congr_fun₂ h x' y' using 0
· -- B₁ = B₂ → B₁.comp l r = B₂.comp l r
subst h; rfl
omit [Module R M] in | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compl₁₂_inj | null |
compr₂ [Module R A] [Module A M] [Module A Qₗ]
[SMulCommClass R A Qₗ] [IsScalarTower R A Qₗ] [IsScalarTower R A Pₗ]
(f : M →ₗ[A] Nₗ →ₗ[R] Pₗ) (g : Pₗ →ₗ[A] Qₗ) : M →ₗ[A] Nₗ →ₗ[R] Qₗ where
toFun x := g.restrictScalars R ∘ₗ (f x)
map_add' _ _ := by ext; simp
map_smul' _ _ := by ext; simp
omit [Module R M] in
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compr₂ | Composing a linear map `P → Q` and a bilinear map `M → N → P` to
form a bilinear map `M → N → Q`.
See `LinearMap.compr₂ₛₗ` for a version of this which does not support towers of scalars but which
does support semi-linear maps. |
compr₂_apply [Module R A] [Module A M] [Module A Qₗ]
[SMulCommClass R A Qₗ] [IsScalarTower R A Qₗ] [IsScalarTower R A Pₗ]
(f : M →ₗ[A] Nₗ →ₗ[R] Pₗ) (g : Pₗ →ₗ[A] Qₗ) (m : M) (n : Nₗ) :
f.compr₂ g m n = g (f m n) := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compr₂_apply | null |
injective_compr₂_of_injective (f : M →ₗ[R] Nₗ →ₗ[R] Pₗ) (g : Pₗ →ₗ[R] Qₗ) (hf : Injective f)
(hg : Injective g) : Injective (f.compr₂ g) :=
hg.injective_linearMapComp_left.comp hf | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | injective_compr₂_of_injective | A version of `Function.Injective.comp` for composition of a bilinear map with a linear map. |
surjective_compr₂_of_exists_rightInverse (f : M →ₗ[R] Nₗ →ₗ[R] Pₗ) (g : Pₗ →ₗ[R] Qₗ)
(hf : Surjective f) (hg : ∃ g' : Qₗ →ₗ[R] Pₗ, g.comp g' = LinearMap.id) :
Surjective (f.compr₂ g) := (surjective_comp_left_of_exists_rightInverse hg).comp hf | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | surjective_compr₂_of_exists_rightInverse | A version of `Function.Surjective.comp` for composition of a bilinear map with a linear map. |
surjective_compr₂_of_equiv (f : M →ₗ[R] Nₗ →ₗ[R] Pₗ) (g : Pₗ ≃ₗ[R] Qₗ) (hf : Surjective f) :
Surjective (f.compr₂ g.toLinearMap) :=
surjective_compr₂_of_exists_rightInverse f g.toLinearMap hf ⟨g.symm, by simp⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | surjective_compr₂_of_equiv | A version of `Function.Surjective.comp` for composition of a bilinear map with a linear map. |
bijective_compr₂_of_equiv (f : M →ₗ[R] Nₗ →ₗ[R] Pₗ) (g : Pₗ ≃ₗ[R] Qₗ) (hf : Bijective f) :
Bijective (f.compr₂ g.toLinearMap) :=
⟨injective_compr₂_of_injective f g.toLinearMap hf.1 g.bijective.1,
surjective_compr₂_of_equiv f g hf.2⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | bijective_compr₂_of_equiv | A version of `Function.Bijective.comp` for composition of a bilinear map with a linear map. |
llcomp : (N →ₛₗ[σ₂₃] P) →ₗ[R₃] (M →ₛₗ[σ₁₂] N) →ₛₗ[σ₂₃] M →ₛₗ[σ₁₃] P :=
flip
{ toFun := lcompₛₗ _ P σ₂₃
map_add' := fun _f _f' => ext₂ fun g _x => g.map_add _ _
map_smul' := fun (_c : R₂) _f => ext₂ fun g _x => g.map_smulₛₗ _ _ }
variable {M N P}
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | llcomp | Composing linear maps as a bilinear map from `(M →ₛₗ[σ₁₂] N) × (N →ₛₗ[σ₂₃] P)`
to `M →ₛₗ[σ₁₃] P`. |
llcomp_apply (f : N →ₛₗ[σ₂₃] P) (g : M →ₛₗ[σ₁₂] N) (x : M) :
llcomp _ M N P f g x = f (g x) := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | llcomp_apply | null |
llcomp_apply' (f : N →ₛₗ[σ₂₃] P) (g : M →ₛₗ[σ₁₂] N) : llcomp _ M N P f g = f ∘ₛₗ g := rfl
omit [Module R M] in | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | llcomp_apply' | null |
compr₂ₛₗ (f : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P) (g : P →ₛₗ[σ₃₄] Q) : M →ₛₗ[σ₁₄] N →ₛₗ[σ₂₄] Q :=
llcomp _ N P Q g ∘ₛₗ f
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compr₂ₛₗ | Composing a linear map `P →ₛₗ[σ₃₄] Q` and a bilinear map `M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P` to
form a bilinear map `M →ₛₗ[σ₁₄] N →ₛₗ[σ₂₄] Q`.
See `LinearMap.compr₂` for a version of this definition, which does not support semi-linear maps but
which does support towers of scalars. |
compr₂ₛₗ_apply (f : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P) (g : P →ₛₗ[σ₃₄] Q) (m : M) (n : N) :
f.compr₂ₛₗ g m n = g (f m n) := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | compr₂ₛₗ_apply | null |
injective_compr₂ₛₗ_of_injective (f : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P) (g : P →ₛₗ[σ₃₄] Q)
(hf : Injective f) (hg : Injective g) : Injective (f.compr₂ₛₗ g) :=
hg.injective_linearMapComp_left.comp hf | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | injective_compr₂ₛₗ_of_injective | A version of `Function.Injective.comp` for composition of a bilinear map with a linear map. |
surjective_compr₂ₛₗ_of_exists_rightInverse [RingHomInvPair σ₃₄ σ₄₃]
(f : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P) (g : P →ₛₗ[σ₃₄] Q)
(hf : Surjective f) (hg : ∃ g' : Q →ₛₗ[σ₄₃] P, g.comp g' = LinearMap.id) :
Surjective (f.compr₂ₛₗ g) := (surjective_comp_left_of_exists_rightInverse hg).comp hf | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | surjective_compr₂ₛₗ_of_exists_rightInverse | A version of `Function.Surjective.comp` for composition of a bilinear map with a linear map. |
surjective_compr₂ₛₗ_of_equiv [RingHomInvPair σ₃₄ σ₄₃] [RingHomInvPair σ₄₃ σ₃₄]
(f : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P) (g : P ≃ₛₗ[σ₃₄] Q) (hf : Surjective f) :
Surjective (f.compr₂ₛₗ g.toLinearMap) :=
surjective_compr₂ₛₗ_of_exists_rightInverse f g.toLinearMap hf ⟨g.symm, by simp⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | surjective_compr₂ₛₗ_of_equiv | A version of `Function.Surjective.comp` for composition of a bilinear map with a linear map. |
bijective_compr₂ₛₗ_of_equiv [RingHomInvPair σ₃₄ σ₄₃] [RingHomInvPair σ₄₃ σ₃₄]
(f : M →ₛₗ[σ₁₃] N →ₛₗ[σ₂₃] P) (g : P ≃ₛₗ[σ₃₄] Q) (hf : Bijective f) :
Bijective (f.compr₂ₛₗ g.toLinearMap) :=
⟨injective_compr₂ₛₗ_of_injective f g.toLinearMap hf.1 g.bijective.1,
surjective_compr₂ₛₗ_of_equiv f g hf.2⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | bijective_compr₂ₛₗ_of_equiv | A version of `Function.Bijective.comp` for composition of a bilinear map with a linear map. |
lsmul : R →ₗ[R] M →ₗ[R] M :=
mk₂ R (· • ·) add_smul (fun _ _ _ => mul_smul _ _ _) smul_add fun r s m => by
simp only [smul_smul, mul_comm]
variable {R} | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lsmul | Scalar multiplication as a bilinear map `R → M → M`. |
lsmul_eq_DistribMulAction_toLinearMap (r : R) :
lsmul R M r = DistribMulAction.toLinearMap R M r := rfl
variable {M}
@[simp] | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lsmul_eq_DistribMulAction_toLinearMap | null |
lsmul_apply (r : R) (m : M) : lsmul R M r m = r • m := rfl
variable (R M Nₗ) in | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lsmul_apply | null |
protected BilinMap : Type _ := M →ₗ[R] M →ₗ[R] Nₗ
variable (R M) in | abbrev | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | BilinMap | A shorthand for the type of `R`-bilinear `Nₗ`-valued maps on `M`. |
protected BilinForm : Type _ := LinearMap.BilinMap R M R | abbrev | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | BilinForm | For convenience, a shorthand for the type of bilinear forms from `M` to `R`. |
lsmul_injective [NoZeroSMulDivisors R M] {x : R} (hx : x ≠ 0) :
Function.Injective (lsmul R M x) :=
smul_right_injective _ hx | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | lsmul_injective | null |
ker_lsmul [NoZeroSMulDivisors R M] {a : R} (ha : a ≠ 0) :
LinearMap.ker (LinearMap.lsmul R M a) = ⊥ :=
LinearMap.ker_eq_bot_of_injective (LinearMap.lsmul_injective ha) | theorem | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | ker_lsmul | null |
noncomputable restrictScalarsRange :
M' →ₗ[S] P' :=
((f.restrictScalars S).comp i).codLift k hk hf
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalarsRange | Restrict the scalars and range of a linear map. |
restrictScalarsRange_apply (m : M') :
k (restrictScalarsRange i k hk f hf m) = f (i m) := by
have : k (restrictScalarsRange i k hk f hf m) =
(k ∘ₗ ((f.restrictScalars S).comp i).codLift k hk hf) m :=
rfl
rw [this, comp_codLift, comp_apply, restrictScalars_apply]
@[simp] | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalarsRange_apply | null |
eq_restrictScalarsRange_iff (m : M') (p : P') :
p = restrictScalarsRange i k hk f hf m ↔ k p = f (i m) := by
rw [← restrictScalarsRange_apply i k hk f hf m, hk.eq_iff]
@[simp] | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | eq_restrictScalarsRange_iff | null |
restrictScalarsRange_apply_eq_zero_iff (m : M') :
restrictScalarsRange i k hk f hf m = 0 ↔ f (i m) = 0 := by
rw [← hk.eq_iff, restrictScalarsRange_apply, map_zero] | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalarsRange_apply_eq_zero_iff | null |
noncomputable restrictScalarsRange₂ :
M' →ₗ[S] N' →ₗ[S] P' :=
(((LinearMap.restrictScalarsₗ S R _ _ _).comp
(B.restrictScalars S)).compl₁₂ i j).codRestrict₂ k hk hB
@[simp] lemma restrictScalarsRange₂_apply (m : M') (n : N') :
k (restrictScalarsRange₂ i j k hk B hB m n) = B (i m) (j n) := by
simp [restrictScalarsRange₂]
@[simp] | def | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalarsRange₂ | Restrict the scalars, domains, and range of a bilinear map. |
eq_restrictScalarsRange₂_iff (m : M') (n : N') (p : P') :
p = restrictScalarsRange₂ i j k hk B hB m n ↔ k p = B (i m) (j n) := by
rw [← restrictScalarsRange₂_apply i j k hk B hB m n, hk.eq_iff]
@[simp] | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | eq_restrictScalarsRange₂_iff | null |
restrictScalarsRange₂_apply_eq_zero_iff (m : M') (n : N') :
restrictScalarsRange₂ i j k hk B hB m n = 0 ↔ B (i m) (j n) = 0 := by
rw [← hk.eq_iff, restrictScalarsRange₂_apply, map_zero] | lemma | LinearAlgebra | [
"Mathlib.Algebra.Module.Submodule.Equiv",
"Mathlib.Algebra.NoZeroSMulDivisors.Basic"
] | Mathlib/LinearAlgebra/BilinearMap.lean | restrictScalarsRange₂_apply_eq_zero_iff | null |
coevaluation : K →ₗ[K] V ⊗[K] Module.Dual K V :=
let bV := Basis.ofVectorSpace K V
(Basis.singleton Unit K).constr K fun _ =>
∑ i : Basis.ofVectorSpaceIndex K V, bV i ⊗ₜ[K] bV.coord i | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Contraction"
] | Mathlib/LinearAlgebra/Coevaluation.lean | coevaluation | The coevaluation map is a linear map from a field `K` to a finite-dimensional
vector space `V`. |
coevaluation_apply_one :
(coevaluation K V) (1 : K) =
let bV := Basis.ofVectorSpace K V
∑ i : Basis.ofVectorSpaceIndex K V, bV i ⊗ₜ[K] bV.coord i := by
simp only [coevaluation]
rw [(Basis.singleton Unit K).constr_apply_fintype K]
simp only [Fintype.univ_punit, Finset.sum_const, one_smul, Basis.singleton_repr,
Basis.equivFun_apply, Basis.coe_ofVectorSpace, Finset.card_singleton]
open TensorProduct | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Contraction"
] | Mathlib/LinearAlgebra/Coevaluation.lean | coevaluation_apply_one | null |
contractLeft_assoc_coevaluation :
(contractLeft K V).rTensor _ ∘ₗ
(TensorProduct.assoc K _ _ _).symm.toLinearMap ∘ₗ
(coevaluation K V).lTensor (Module.Dual K V) =
(TensorProduct.lid K _).symm.toLinearMap ∘ₗ (TensorProduct.rid K _).toLinearMap := by
letI := Classical.decEq (Basis.ofVectorSpaceIndex K V)
apply TensorProduct.ext
apply (Basis.ofVectorSpace K V).dualBasis.ext; intro j; apply LinearMap.ext_ring
rw [LinearMap.compr₂_apply, LinearMap.compr₂_apply, TensorProduct.mk_apply]
simp only [LinearMap.coe_comp, Function.comp_apply, LinearEquiv.coe_toLinearMap]
rw [rid_tmul, one_smul, lid_symm_apply]
simp only [LinearMap.lTensor_tmul, coevaluation_apply_one]
rw [TensorProduct.tmul_sum, map_sum]; simp only [assoc_symm_tmul]
rw [map_sum]; simp only [LinearMap.rTensor_tmul, contractLeft_apply]
simp only [Basis.coe_dualBasis, Basis.coord_apply, Basis.repr_self_apply, TensorProduct.ite_tmul]
rw [Finset.sum_ite_eq']; simp only [Finset.mem_univ, if_true] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Contraction"
] | Mathlib/LinearAlgebra/Coevaluation.lean | contractLeft_assoc_coevaluation | This lemma corresponds to one of the coherence laws for duals in rigid categories, see
`CategoryTheory.Monoidal.Rigid`. |
contractLeft_assoc_coevaluation' :
(contractLeft K V).lTensor _ ∘ₗ
(TensorProduct.assoc K _ _ _).toLinearMap ∘ₗ (coevaluation K V).rTensor V =
(TensorProduct.rid K _).symm.toLinearMap ∘ₗ (TensorProduct.lid K _).toLinearMap := by
letI := Classical.decEq (Basis.ofVectorSpaceIndex K V)
apply TensorProduct.ext
apply LinearMap.ext_ring; apply (Basis.ofVectorSpace K V).ext; intro j
rw [LinearMap.compr₂_apply, LinearMap.compr₂_apply, TensorProduct.mk_apply]
simp only [LinearMap.coe_comp, Function.comp_apply, LinearEquiv.coe_toLinearMap]
rw [lid_tmul, one_smul, rid_symm_apply]
simp only [LinearMap.rTensor_tmul, coevaluation_apply_one]
rw [TensorProduct.sum_tmul, map_sum]; simp only [assoc_tmul]
rw [map_sum]; simp only [LinearMap.lTensor_tmul, contractLeft_apply]
simp only [Basis.coord_apply, Basis.repr_self_apply, TensorProduct.tmul_ite]
rw [Finset.sum_ite_eq]; simp only [Finset.mem_univ, if_true] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Contraction"
] | Mathlib/LinearAlgebra/Coevaluation.lean | contractLeft_assoc_coevaluation' | This lemma corresponds to one of the coherence laws for duals in rigid categories, see
`CategoryTheory.Monoidal.Rigid`. |
contractLeft : Module.Dual R M ⊗[R] M →ₗ[R] R :=
(uncurry _ _ _ _).toFun LinearMap.id | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | contractLeft | The natural left-handed pairing between a module and its dual. |
contractRight : M ⊗[R] Module.Dual R M →ₗ[R] R :=
(uncurry _ _ _ _).toFun (LinearMap.flip LinearMap.id) | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | contractRight | The natural right-handed pairing between a module and its dual. |
dualTensorHom : Module.Dual R M ⊗[R] N →ₗ[R] M →ₗ[R] N :=
let M' := Module.Dual R M
(uncurry R M' N (M →ₗ[R] N) : _ → M' ⊗ N →ₗ[R] M →ₗ[R] N) LinearMap.smulRightₗ
variable {R M N P Q}
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | dualTensorHom | The natural map associating a linear map to the tensor product of two modules. |
contractLeft_apply (f : Module.Dual R M) (m : M) : contractLeft R M (f ⊗ₜ m) = f m :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | contractLeft_apply | null |
contractRight_apply (f : Module.Dual R M) (m : M) : contractRight R M (m ⊗ₜ f) = f m :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | contractRight_apply | null |
dualTensorHom_apply (f : Module.Dual R M) (m : M) (n : N) :
dualTensorHom R M N (f ⊗ₜ n) m = f m • n :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | dualTensorHom_apply | null |
transpose_dualTensorHom (f : Module.Dual R M) (m : M) :
Dual.transpose (R := R) (dualTensorHom R M M (f ⊗ₜ m)) =
dualTensorHom R _ _ (Dual.eval R M m ⊗ₜ f) := by
ext f' m'
simp only [Dual.transpose_apply, coe_comp, Function.comp_apply, dualTensorHom_apply,
LinearMap.map_smulₛₗ, RingHom.id_apply, Algebra.id.smul_eq_mul, Dual.eval_apply,
LinearMap.smul_apply]
exact mul_comm _ _
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | transpose_dualTensorHom | null |
dualTensorHom_prodMap_zero (f : Module.Dual R M) (p : P) :
((dualTensorHom R M P) (f ⊗ₜ[R] p)).prodMap (0 : N →ₗ[R] Q) =
dualTensorHom R (M × N) (P × Q) ((f ∘ₗ fst R M N) ⊗ₜ inl R P Q p) := by
ext <;>
simp only [coe_comp, coe_inl, Function.comp_apply, prodMap_apply, dualTensorHom_apply,
fst_apply, Prod.smul_mk, LinearMap.zero_apply, smul_zero]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | dualTensorHom_prodMap_zero | null |
zero_prodMap_dualTensorHom (g : Module.Dual R N) (q : Q) :
(0 : M →ₗ[R] P).prodMap ((dualTensorHom R N Q) (g ⊗ₜ[R] q)) =
dualTensorHom R (M × N) (P × Q) ((g ∘ₗ snd R M N) ⊗ₜ inr R P Q q) := by
ext <;>
simp only [coe_comp, coe_inr, Function.comp_apply, prodMap_apply, dualTensorHom_apply,
snd_apply, Prod.smul_mk, LinearMap.zero_apply, smul_zero] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Dual.Lemmas",
"Mathlib.LinearAlgebra.Matrix.ToLin"
] | Mathlib/LinearAlgebra/Contraction.lean | zero_prodMap_dualTensorHom | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.