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 ⌀ |
|---|---|---|---|---|---|---|
@[simps]
LinearMap.vecCons₂ {n} (f : M →ₗ[R] M₂ →ₗ[R] M₃) (g : M →ₗ[R] M₂ →ₗ[R] Fin n → M₃) :
M →ₗ[R] M₂ →ₗ[R] Fin n.succ → M₃ where
toFun m := LinearMap.vecCons (f m) (g m)
map_add' x y :=
LinearMap.ext fun z => by
simp only [f.map_add, g.map_add, LinearMap.add_apply, LinearMap.vecCons_apply,
Matrix.cons_add_cons (f x z)]
map_smul' r x := LinearMap.ext fun z => by simp [Matrix.smul_cons r (f x z)] | def | LinearAlgebra | [
"Mathlib.Algebra.Group.Fin.Tuple",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.BigOperators.Pi",
"Mathlib.Algebra.Module.Prod",
"Mathlib.Algebra.Module.Submodule.Ker",
"Mathlib.Algebra.Module.Submodule.Range",
"Mathlib.Algebra.Module.Equiv.Basic",
"Mathlib.Logic.Equiv.Fin.Bas... | Mathlib/LinearAlgebra/Pi.lean | LinearMap.vecCons₂ | A bilinear map into `Fin n.succ → M₃` can be built out of a map into `M₃` and a map into
`Fin n → M₃` |
@[elab_as_elim]
Module.pi_induction' {ι : Type v} [Finite ι] (R : Type*) [Ring R]
(motive : ∀ (N : Type u) [AddCommGroup N] [Module R N], Prop)
(motive' : ∀ (N : Type (max u v)) [AddCommGroup N] [Module R N], Prop)
(equiv : ∀ {N : Type u} {N' : Type (max u v)} [AddCommGroup N] [AddCommGroup N']
[Module R N] [Module R N'], (N ≃ₗ[R] N') → motive N → motive' N')
(equiv' : ∀ {N N' : Type (max u v)} [AddCommGroup N] [AddCommGroup N']
[Module R N] [Module R N'], (N ≃ₗ[R] N') → motive' N → motive' N')
(unit : motive PUnit) (prod : ∀ {N : Type u} {N' : Type (max u v)} [AddCommGroup N]
[AddCommGroup N'] [Module R N] [Module R N'], motive N → motive' N' → motive' (N × N'))
(M : ι → Type u) [∀ i, AddCommGroup (M i)] [∀ i, Module R (M i)]
(h : ∀ i, motive (M i)) : motive' (∀ i, M i) := by
classical
cases nonempty_fintype ι
revert M
refine Fintype.induction_empty_option
(fun α β _ e h M _ _ hM ↦ equiv' (LinearEquiv.piCongrLeft R M e) <| h _ fun i ↦ hM _)
(fun M _ _ _ ↦ equiv default unit) (fun α _ h M _ _ hn ↦ ?_) ι
exact equiv' (LinearEquiv.piOptionEquivProd R).symm <| prod (hn _) (h _ fun i ↦ hn i) | lemma | LinearAlgebra | [
"Mathlib.Algebra.Group.Fin.Tuple",
"Mathlib.Algebra.BigOperators.GroupWithZero.Action",
"Mathlib.Algebra.BigOperators.Pi",
"Mathlib.Algebra.Module.Prod",
"Mathlib.Algebra.Module.Submodule.Ker",
"Mathlib.Algebra.Module.Submodule.Range",
"Mathlib.Algebra.Module.Equiv.Basic",
"Mathlib.Logic.Equiv.Fin.Bas... | Mathlib/LinearAlgebra/Pi.lean | Module.pi_induction' | A variant of `Module.pi_induction` that assumes `AddCommGroup` instead of `AddCommMonoid`. |
trace_restrict_eq_of_forall_mem [IsDomain R] [IsPrincipalIdealRing R]
(p : Submodule R M) (f : M →ₗ[R] M)
(hf : ∀ x, f x ∈ p) (hf' : ∀ x ∈ p, f x ∈ p := fun x _ ↦ hf x) :
trace R p (f.restrict hf') = trace R M f := by
let ι := Module.Free.ChooseBasisIndex R M
obtain ⟨n, snf⟩ := p.smithNormalForm (Module.Free.chooseBasis R M)
rw [trace_eq_matrix_trace R snf.bM, trace_eq_matrix_trace R snf.bN]
set A : Matrix (Fin n) (Fin n) R := toMatrix snf.bN snf.bN (f.restrict hf')
set B : Matrix ι ι R := toMatrix snf.bM snf.bM f
have aux : ∀ i, B i i ≠ 0 → i ∈ Set.range snf.f := fun i hi ↦ by
contrapose! hi; exact snf.repr_eq_zero_of_notMem_range ⟨_, (hf _)⟩ hi
change ∑ i, A i i = ∑ i, B i i
rw [← Finset.sum_filter_of_ne (p := fun j ↦ j ∈ Set.range snf.f) (by simpa using aux)]
simp [A, B, hf] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Trace",
"Mathlib.LinearAlgebra.FreeModule.PID",
"Mathlib.LinearAlgebra.FreeModule.Finite.Basic"
] | Mathlib/LinearAlgebra/PID.lean | trace_restrict_eq_of_forall_mem | If a linear endomorphism of a (finite, free) module `M` takes values in a submodule `p ⊆ M`,
then the trace of its restriction to `p` is equal to its trace on `M`. |
Eqv : FreeAddMonoid (R × Π i, s i) → FreeAddMonoid (R × Π i, s i) → Prop
| of_zero : ∀ (r : R) (f : Π i, s i) (i : ι) (_ : f i = 0), Eqv (FreeAddMonoid.of (r, f)) 0
| of_zero_scalar : ∀ f : Π i, s i, Eqv (FreeAddMonoid.of (0, f)) 0
| of_add : ∀ (_ : DecidableEq ι) (r : R) (f : Π i, s i) (i : ι) (m₁ m₂ : s i),
Eqv (FreeAddMonoid.of (r, update f i m₁) + FreeAddMonoid.of (r, update f i m₂))
(FreeAddMonoid.of (r, update f i (m₁ + m₂)))
| of_add_scalar : ∀ (r r' : R) (f : Π i, s i),
Eqv (FreeAddMonoid.of (r, f) + FreeAddMonoid.of (r', f)) (FreeAddMonoid.of (r + r', f))
| of_smul : ∀ (_ : DecidableEq ι) (r : R) (f : Π i, s i) (i : ι) (r' : R),
Eqv (FreeAddMonoid.of (r, update f i (r' • f i))) (FreeAddMonoid.of (r' * r, f))
| add_comm : ∀ x y, Eqv (x + y) (y + x) | inductive | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | Eqv | The relation on `FreeAddMonoid (R × Π i, s i)` that generates a congruence whose quotient is
the tensor product. |
PiTensorProduct : Type _ :=
(addConGen (PiTensorProduct.Eqv R s)).Quotient
variable {R} | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | PiTensorProduct | `PiTensorProduct R s` with `R` a commutative semiring and `s : ι → Type*` is the tensor
product of all the `s i`'s. This is denoted by `⨂[R] i, s i`. |
tprodCoeff (r : R) (f : Π i, s i) : ⨂[R] i, s i :=
AddCon.mk' _ <| FreeAddMonoid.of (r, f)
variable {R} | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tprodCoeff | This enables the notation `⨂[R] i : ι, s i` for the pi tensor product `PiTensorProduct`,
given an indexed family of types `s : ι → Type*`. -/
scoped[TensorProduct] notation3:100"⨂["R"] "(...)", "r:(scoped f => PiTensorProduct R f) => r
open TensorProduct
namespace PiTensorProduct
section Module
instance : AddCommMonoid (⨂[R] i, s i) :=
{ (addConGen (PiTensorProduct.Eqv R s)).addMonoid with
add_comm := fun x y ↦
AddCon.induction_on₂ x y fun _ _ ↦
Quotient.sound' <| AddConGen.Rel.of _ _ <| Eqv.add_comm _ _ }
instance : Inhabited (⨂[R] i, s i) := ⟨0⟩
variable (R) {s}
/-- `tprodCoeff R r f` with `r : R` and `f : Π i, s i` is the tensor product of the vectors `f i`
over all `i : ι`, multiplied by the coefficient `r`. Note that this is meant as an auxiliary
definition for this file alone, and that one should use `tprod` defined below for most purposes. |
zero_tprodCoeff (f : Π i, s i) : tprodCoeff R 0 f = 0 :=
Quotient.sound' <| AddConGen.Rel.of _ _ <| Eqv.of_zero_scalar _ | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | zero_tprodCoeff | null |
zero_tprodCoeff' (z : R) (f : Π i, s i) (i : ι) (hf : f i = 0) : tprodCoeff R z f = 0 :=
Quotient.sound' <| AddConGen.Rel.of _ _ <| Eqv.of_zero _ _ i hf | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | zero_tprodCoeff' | null |
add_tprodCoeff [DecidableEq ι] (z : R) (f : Π i, s i) (i : ι) (m₁ m₂ : s i) :
tprodCoeff R z (update f i m₁) + tprodCoeff R z (update f i m₂) =
tprodCoeff R z (update f i (m₁ + m₂)) :=
Quotient.sound' <| AddConGen.Rel.of _ _ (Eqv.of_add _ z f i m₁ m₂) | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | add_tprodCoeff | null |
add_tprodCoeff' (z₁ z₂ : R) (f : Π i, s i) :
tprodCoeff R z₁ f + tprodCoeff R z₂ f = tprodCoeff R (z₁ + z₂) f :=
Quotient.sound' <| AddConGen.Rel.of _ _ (Eqv.of_add_scalar z₁ z₂ f) | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | add_tprodCoeff' | null |
smul_tprodCoeff_aux [DecidableEq ι] (z : R) (f : Π i, s i) (i : ι) (r : R) :
tprodCoeff R z (update f i (r • f i)) = tprodCoeff R (r * z) f :=
Quotient.sound' <| AddConGen.Rel.of _ _ <| Eqv.of_smul _ _ _ _ _ | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | smul_tprodCoeff_aux | null |
smul_tprodCoeff [DecidableEq ι] (z : R) (f : Π i, s i) (i : ι) (r : R₁) [SMul R₁ R]
[IsScalarTower R₁ R R] [SMul R₁ (s i)] [IsScalarTower R₁ R (s i)] :
tprodCoeff R z (update f i (r • f i)) = tprodCoeff R (r • z) f := by
have h₁ : r • z = r • (1 : R) * z := by rw [smul_mul_assoc, one_mul]
have h₂ : r • f i = (r • (1 : R)) • f i := (smul_one_smul _ _ _).symm
rw [h₁, h₂]
exact smul_tprodCoeff_aux z f i _ | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | smul_tprodCoeff | null |
liftAddHom (φ : (R × Π i, s i) → F)
(C0 : ∀ (r : R) (f : Π i, s i) (i : ι) (_ : f i = 0), φ (r, f) = 0)
(C0' : ∀ f : Π i, s i, φ (0, f) = 0)
(C_add : ∀ [DecidableEq ι] (r : R) (f : Π i, s i) (i : ι) (m₁ m₂ : s i),
φ (r, update f i m₁) + φ (r, update f i m₂) = φ (r, update f i (m₁ + m₂)))
(C_add_scalar : ∀ (r r' : R) (f : Π i, s i), φ (r, f) + φ (r', f) = φ (r + r', f))
(C_smul : ∀ [DecidableEq ι] (r : R) (f : Π i, s i) (i : ι) (r' : R),
φ (r, update f i (r' • f i)) = φ (r' * r, f)) :
(⨂[R] i, s i) →+ F :=
(addConGen (PiTensorProduct.Eqv R s)).lift (FreeAddMonoid.lift φ) <|
AddCon.addConGen_le fun x y hxy ↦
match hxy with
| Eqv.of_zero r' f i hf =>
(AddCon.ker_rel _).2 <| by simp [FreeAddMonoid.lift_eval_of, C0 r' f i hf]
| Eqv.of_zero_scalar f =>
(AddCon.ker_rel _).2 <| by simp [FreeAddMonoid.lift_eval_of, C0']
| Eqv.of_add inst z f i m₁ m₂ =>
(AddCon.ker_rel _).2 <| by simp [FreeAddMonoid.lift_eval_of, @C_add inst]
| Eqv.of_add_scalar z₁ z₂ f =>
(AddCon.ker_rel _).2 <| by simp [FreeAddMonoid.lift_eval_of, C_add_scalar]
| Eqv.of_smul inst z f i r' =>
(AddCon.ker_rel _).2 <| by simp [FreeAddMonoid.lift_eval_of, @C_smul inst]
| Eqv.add_comm x y =>
(AddCon.ker_rel _).2 <| by simp_rw [AddMonoidHom.map_add, add_comm] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | liftAddHom | Construct an `AddMonoidHom` from `(⨂[R] i, s i)` to some space `F` from a function
`φ : (R × Π i, s i) → F` with the appropriate properties. |
@[elab_as_elim]
protected induction_on' {motive : (⨂[R] i, s i) → Prop} (z : ⨂[R] i, s i)
(tprodCoeff : ∀ (r : R) (f : Π i, s i), motive (tprodCoeff R r f))
(add : ∀ x y, motive x → motive y → motive (x + y)) :
motive z := by
have C0 : motive 0 := by
have h₁ := tprodCoeff 0 0
rwa [zero_tprodCoeff] at h₁
refine AddCon.induction_on z fun x ↦ FreeAddMonoid.recOn x C0 ?_
simp_rw [AddCon.coe_add]
refine fun f y ih ↦ add _ _ ?_ ih
convert tprodCoeff f.1 f.2 | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | induction_on' | Induct using `tprodCoeff` |
hasSMul' : SMul R₁ (⨂[R] i, s i) :=
⟨fun r ↦
liftAddHom (fun f : R × Π i, s i ↦ tprodCoeff R (r • f.1) f.2)
(fun r' f i hf ↦ by simp_rw [zero_tprodCoeff' _ f i hf])
(fun f ↦ by simp [zero_tprodCoeff]) (fun r' f i m₁ m₂ ↦ by simp [add_tprodCoeff])
(fun r' r'' f ↦ by simp [add_tprodCoeff']) fun z f i r' ↦ by
simp [smul_tprodCoeff, mul_smul_comm]⟩ | instance | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | hasSMul' | null |
smul_tprodCoeff' (r : R₁) (z : R) (f : Π i, s i) :
r • tprodCoeff R z f = tprodCoeff R (r • z) f := rfl | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | smul_tprodCoeff' | null |
protected smul_add (r : R₁) (x y : ⨂[R] i, s i) : r • (x + y) = r • x + r • y :=
AddMonoidHom.map_add _ _ _ | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | smul_add | null |
distribMulAction' : DistribMulAction R₁ (⨂[R] i, s i) where
smul := (· • ·)
smul_add _ _ _ := AddMonoidHom.map_add _ _ _
mul_smul r r' x :=
PiTensorProduct.induction_on' x (fun {r'' f} ↦ by simp [smul_tprodCoeff', smul_smul])
fun {x y} ihx ihy ↦ by simp_rw [PiTensorProduct.smul_add, ihx, ihy]
one_smul x :=
PiTensorProduct.induction_on' x (fun {r f} ↦ by rw [smul_tprodCoeff', one_smul])
fun {z y} ihz ihy ↦ by simp_rw [PiTensorProduct.smul_add, ihz, ihy]
smul_zero _ := AddMonoidHom.map_zero _ | instance | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | distribMulAction' | null |
smulCommClass' [SMulCommClass R₁ R₂ R] : SMulCommClass R₁ R₂ (⨂[R] i, s i) :=
⟨fun {r' r''} x ↦
PiTensorProduct.induction_on' x (fun {xr xf} ↦ by simp only [smul_tprodCoeff', smul_comm])
fun {z y} ihz ihy ↦ by simp_rw [PiTensorProduct.smul_add, ihz, ihy]⟩ | instance | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | smulCommClass' | null |
isScalarTower' [SMul R₁ R₂] [IsScalarTower R₁ R₂ R] :
IsScalarTower R₁ R₂ (⨂[R] i, s i) :=
⟨fun {r' r''} x ↦
PiTensorProduct.induction_on' x (fun {xr xf} ↦ by simp only [smul_tprodCoeff', smul_assoc])
fun {z y} ihz ihy ↦ by simp_rw [PiTensorProduct.smul_add, ihz, ihy]⟩ | instance | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | isScalarTower' | null |
module' [Semiring R₁] [Module R₁ R] [SMulCommClass R₁ R R] : Module R₁ (⨂[R] i, s i) :=
{ PiTensorProduct.distribMulAction' with
add_smul := fun r r' x ↦
PiTensorProduct.induction_on' x
(fun {r f} ↦ by simp_rw [smul_tprodCoeff', add_smul, add_tprodCoeff'])
fun {x y} ihx ihy ↦ by simp_rw [PiTensorProduct.smul_add, ihx, ihy, add_add_add_comm]
zero_smul := fun x ↦
PiTensorProduct.induction_on' x
(fun {r f} ↦ by simp_rw [smul_tprodCoeff', zero_smul, zero_tprodCoeff])
fun {x y} ihx ihy ↦ by simp_rw [PiTensorProduct.smul_add, ihx, ihy, add_zero] } | instance | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | module' | null |
tprod : MultilinearMap R s (⨂[R] i, s i) where
toFun := tprodCoeff R 1
map_update_add' {_ f} i x y := (add_tprodCoeff (1 : R) f i x y).symm
map_update_smul' {_ f} i r x := by
rw [smul_tprodCoeff', ← smul_tprodCoeff (1 : R) _ i, update_idem, update_self]
@[inherit_doc tprod]
notation3:100 "⨂ₜ["R"] "(...)", "r:(scoped f => tprod R f) => r | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tprod | The canonical `MultilinearMap R s (⨂[R] i, s i)`.
`tprod R fun i => f i` has notation `⨂ₜ[R] i, f i`. |
tprod_eq_tprodCoeff_one :
⇑(tprod R : MultilinearMap R s (⨂[R] i, s i)) = tprodCoeff R 1 := rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tprod_eq_tprodCoeff_one | null |
tprodCoeff_eq_smul_tprod (z : R) (f : Π i, s i) : tprodCoeff R z f = z • tprod R f := by
have : z = z • (1 : R) := by simp only [mul_one, Algebra.id.smul_eq_mul]
conv_lhs => rw [this]
rfl | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tprodCoeff_eq_smul_tprod | null |
_root_.FreeAddMonoid.toPiTensorProduct (p : FreeAddMonoid (R × Π i, s i)) :
AddCon.toQuotient (c := addConGen (PiTensorProduct.Eqv R s)) p =
List.sum (List.map (fun x ↦ x.1 • ⨂ₜ[R] i, x.2 i) p.toList) := by
match p with
| [] => rw [FreeAddMonoid.toList_nil, List.map_nil, List.sum_nil]; rfl
| x :: ps =>
rw [FreeAddMonoid.toList_cons, List.map_cons, List.sum_cons, ← List.singleton_append,
← toPiTensorProduct ps, ← tprodCoeff_eq_smul_tprod]
rfl | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | _root_.FreeAddMonoid.toPiTensorProduct | The image of an element `p` of `FreeAddMonoid (R × Π i, s i)` in the `PiTensorProduct` is
equal to the sum of `a • ⨂ₜ[R] i, m i` over all the entries `(a, m)` of `p`. |
lifts (x : ⨂[R] i, s i) : Set (FreeAddMonoid (R × Π i, s i)) :=
{p | AddCon.toQuotient (c := addConGen (PiTensorProduct.Eqv R s)) p = x} | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lifts | The set of lifts of an element `x` of `⨂[R] i, s i` in `FreeAddMonoid (R × Π i, s i)`. |
mem_lifts_iff (x : ⨂[R] i, s i) (p : FreeAddMonoid (R × Π i, s i)) :
p ∈ lifts x ↔ List.sum (List.map (fun x ↦ x.1 • ⨂ₜ[R] i, x.2 i) p.toList) = x := by
simp only [lifts, Set.mem_setOf_eq, FreeAddMonoid.toPiTensorProduct] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | mem_lifts_iff | An element `p` of `FreeAddMonoid (R × Π i, s i)` lifts an element `x` of `⨂[R] i, s i`
if and only if `x` is equal to the sum of `a • ⨂ₜ[R] i, m i` over all the entries
`(a, m)` of `p`. |
nonempty_lifts (x : ⨂[R] i, s i) : Set.Nonempty (lifts x) := by
existsi @Quotient.out _ (addConGen (PiTensorProduct.Eqv R s)).toSetoid x
simp only [lifts, Set.mem_setOf_eq]
rw [← AddCon.quot_mk_eq_coe]
erw [Quot.out_eq] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | nonempty_lifts | Every element of `⨂[R] i, s i` has a lift in `FreeAddMonoid (R × Π i, s i)`. |
lifts_zero : 0 ∈ lifts (0 : ⨂[R] i, s i) := by
rw [mem_lifts_iff, FreeAddMonoid.toList_zero, List.map_nil, List.sum_nil] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lifts_zero | The empty list lifts the element `0` of `⨂[R] i, s i`. |
lifts_add {x y : ⨂[R] i, s i} {p q : FreeAddMonoid (R × Π i, s i)}
(hp : p ∈ lifts x) (hq : q ∈ lifts y) : p + q ∈ lifts (x + y) := by
simp only [lifts, Set.mem_setOf_eq, AddCon.coe_add]
rw [hp, hq] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lifts_add | If elements `p,q` of `FreeAddMonoid (R × Π i, s i)` lift elements `x,y` of `⨂[R] i, s i`
respectively, then `p + q` lifts `x + y`. |
lifts_smul {x : ⨂[R] i, s i} {p : FreeAddMonoid (R × Π i, s i)} (h : p ∈ lifts x) (a : R) :
p.map (fun (y : R × Π i, s i) ↦ (a * y.1, y.2)) ∈ lifts (a • x) := by
rw [mem_lifts_iff] at h ⊢
rw [← h]
simp [Function.comp_def, mul_smul, List.smul_sum] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lifts_smul | If an element `p` of `FreeAddMonoid (R × Π i, s i)` lifts an element `x` of `⨂[R] i, s i`,
and if `a` is an element of `R`, then the list obtained by multiplying the first entry of each
element of `p` by `a` lifts `a • x`. |
@[elab_as_elim]
protected induction_on {motive : (⨂[R] i, s i) → Prop} (z : ⨂[R] i, s i)
(smul_tprod : ∀ (r : R) (f : Π i, s i), motive (r • tprod R f))
(add : ∀ x y, motive x → motive y → motive (x + y)) :
motive z := by
simp_rw [← tprodCoeff_eq_smul_tprod] at smul_tprod
exact PiTensorProduct.induction_on' z smul_tprod add
@[ext] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | induction_on | Induct using scaled versions of `PiTensorProduct.tprod`. |
ext {φ₁ φ₂ : (⨂[R] i, s i) →ₗ[R] E}
(H : φ₁.compMultilinearMap (tprod R) = φ₂.compMultilinearMap (tprod R)) : φ₁ = φ₂ := by
refine LinearMap.ext ?_
refine fun z ↦
PiTensorProduct.induction_on' z ?_ fun {x y} hx hy ↦ by rw [φ₁.map_add, φ₂.map_add, hx, hy]
· intro r f
rw [tprodCoeff_eq_smul_tprod, φ₁.map_smul, φ₂.map_smul]
apply congr_arg
exact MultilinearMap.congr_fun H f | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | ext | null |
span_tprod_eq_top :
Submodule.span R (Set.range (tprod R)) = (⊤ : Submodule R (⨂[R] i, s i)) :=
Submodule.eq_top_iff'.mpr fun t ↦ t.induction_on
(fun _ _ ↦ Submodule.smul_mem _ _
(Submodule.subset_span (by simp only [Set.mem_range, exists_apply_eq_apply])))
(fun _ _ hx hy ↦ Submodule.add_mem _ hx hy) | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | span_tprod_eq_top | The pure tensors (i.e. the elements of the image of `PiTensorProduct.tprod`) span
the tensor product. |
liftAux (φ : MultilinearMap R s E) : (⨂[R] i, s i) →+ E :=
liftAddHom (fun p : R × Π i, s i ↦ p.1 • φ p.2)
(fun z f i hf ↦ by simp_rw [map_coord_zero φ i hf, smul_zero])
(fun f ↦ by simp_rw [zero_smul])
(fun z f i m₁ m₂ ↦ by simp_rw [← smul_add, φ.map_update_add])
(fun z₁ z₂ f ↦ by rw [← add_smul])
fun z f i r ↦ by simp [φ.map_update_smul, smul_smul, mul_comm] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | liftAux | Auxiliary function to constructing a linear map `(⨂[R] i, s i) → E` given a
`MultilinearMap R s E` with the property that its composition with the canonical
`MultilinearMap R s (⨂[R] i, s i)` is the given multilinear map. |
liftAux_tprod (φ : MultilinearMap R s E) (f : Π i, s i) : liftAux φ (tprod R f) = φ f := by
simp only [liftAux, liftAddHom, tprod_eq_tprodCoeff_one, tprodCoeff, AddCon.coe_mk']
erw [AddCon.lift_coe]
simp | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | liftAux_tprod | null |
liftAux_tprodCoeff (φ : MultilinearMap R s E) (z : R) (f : Π i, s i) :
liftAux φ (tprodCoeff R z f) = z • φ f := rfl | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | liftAux_tprodCoeff | null |
liftAux.smul {φ : MultilinearMap R s E} (r : R) (x : ⨂[R] i, s i) :
liftAux φ (r • x) = r • liftAux φ x := by
refine PiTensorProduct.induction_on' x ?_ ?_
· intro z f
rw [smul_tprodCoeff' r z f, liftAux_tprodCoeff, liftAux_tprodCoeff, smul_assoc]
· intro z y ihz ihy
rw [smul_add, (liftAux φ).map_add, ihz, ihy, (liftAux φ).map_add, smul_add] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | liftAux.smul | null |
lift : MultilinearMap R s E ≃ₗ[R] (⨂[R] i, s i) →ₗ[R] E where
toFun φ := { liftAux φ with map_smul' := liftAux.smul }
invFun φ' := φ'.compMultilinearMap (tprod R)
left_inv φ := by
ext
simp [liftAux_tprod, LinearMap.compMultilinearMap]
right_inv φ := by
ext
simp [liftAux_tprod]
map_add' φ₁ φ₂ := by
ext
simp [liftAux_tprod]
map_smul' r φ₂ := by
ext
simp [liftAux_tprod]
variable {φ : MultilinearMap R s E}
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift | Constructing a linear map `(⨂[R] i, s i) → E` given a `MultilinearMap R s E` with the
property that its composition with the canonical `MultilinearMap R s E` is
the given multilinear map `φ`. |
lift.tprod (f : Π i, s i) : lift φ (tprod R f) = φ f :=
liftAux_tprod φ f | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift.tprod | null |
lift.unique' {φ' : (⨂[R] i, s i) →ₗ[R] E}
(H : φ'.compMultilinearMap (PiTensorProduct.tprod R) = φ) : φ' = lift φ :=
ext <| H.symm ▸ (lift.symm_apply_apply φ).symm | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift.unique' | null |
lift.unique {φ' : (⨂[R] i, s i) →ₗ[R] E} (H : ∀ f, φ' (PiTensorProduct.tprod R f) = φ f) :
φ' = lift φ :=
lift.unique' (MultilinearMap.ext H)
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift.unique | null |
lift_symm (φ' : (⨂[R] i, s i) →ₗ[R] E) : lift.symm φ' = φ'.compMultilinearMap (tprod R) :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift_symm | null |
lift_tprod : lift (tprod R : MultilinearMap R s _) = LinearMap.id :=
Eq.symm <| lift.unique' rfl | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift_tprod | null |
map : (⨂[R] i, s i) →ₗ[R] ⨂[R] i, t i :=
lift <| (tprod R).compLinearMap f
@[simp] lemma map_tprod (x : Π i, s i) :
map f (tprod R x) = tprod R fun i ↦ f i (x i) :=
lift.tprod _ | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map | Let `sᵢ` and `tᵢ` be two families of `R`-modules.
Let `f` be a family of `R`-linear maps between `sᵢ` and `tᵢ`, i.e. `f : Πᵢ sᵢ → tᵢ`,
then there is an induced map `⨂ᵢ sᵢ → ⨂ᵢ tᵢ` by `⨂ aᵢ ↦ ⨂ fᵢ aᵢ`.
This is `TensorProduct.map` for an arbitrary family of modules. |
map_range_eq_span_tprod :
LinearMap.range (map f) =
Submodule.span R {t | ∃ (m : Π i, s i), tprod R (fun i ↦ f i (m i)) = t} := by
rw [← Submodule.map_top, ← span_tprod_eq_top, Submodule.map_span, ← Set.range_comp]
apply congrArg; ext x
simp only [Set.mem_range, comp_apply, map_tprod, Set.mem_setOf_eq] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_range_eq_span_tprod | null |
@[simp]
mapIncl (p : Π i, Submodule R (s i)) : (⨂[R] i, p i) →ₗ[R] ⨂[R] i, s i :=
map fun (i : ι) ↦ (p i).subtype | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | mapIncl | Given submodules `p i ⊆ s i`, this is the natural map: `⨂[R] i, p i → ⨂[R] i, s i`.
This is `TensorProduct.mapIncl` for an arbitrary family of modules. |
map_comp : map (fun (i : ι) ↦ g i ∘ₗ f i) = map g ∘ₗ map f := by
ext
simp only [LinearMap.compMultilinearMap_apply, map_tprod, LinearMap.coe_comp, Function.comp_apply] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_comp | null |
lift_comp_map (h : MultilinearMap R t E) :
lift h ∘ₗ map f = lift (h.compLinearMap f) := by
ext
simp only [LinearMap.compMultilinearMap_apply, LinearMap.coe_comp, Function.comp_apply,
map_tprod, lift.tprod, MultilinearMap.compLinearMap_apply]
attribute [local ext high] ext
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift_comp_map | null |
map_id : map (fun i ↦ (LinearMap.id : s i →ₗ[R] s i)) = .id := by
ext
simp only [LinearMap.compMultilinearMap_apply, map_tprod, LinearMap.id_coe, id_eq]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_id | null |
protected map_one : map (fun (i : ι) ↦ (1 : s i →ₗ[R] s i)) = 1 :=
map_id | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_one | null |
protected map_mul (f₁ f₂ : Π i, s i →ₗ[R] s i) :
map (fun i ↦ f₁ i * f₂ i) = map f₁ * map f₂ :=
map_comp f₁ f₂ | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_mul | null |
@[simps]
mapMonoidHom : (Π i, s i →ₗ[R] s i) →* ((⨂[R] i, s i) →ₗ[R] ⨂[R] i, s i) where
toFun := map
map_one' := PiTensorProduct.map_one
map_mul' := PiTensorProduct.map_mul
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | mapMonoidHom | Upgrading `PiTensorProduct.map` to a `MonoidHom` when `s = t`. |
protected map_pow (f : Π i, s i →ₗ[R] s i) (n : ℕ) :
map (f ^ n) = map f ^ n := MonoidHom.map_pow mapMonoidHom _ _
open Function in | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_pow | null |
private map_add_smul_aux [DecidableEq ι] (i : ι) (x : Π i, s i) (u : s i →ₗ[R] t i) :
(fun j ↦ update f i u j (x j)) = update (fun j ↦ (f j) (x j)) i (u (x i)) := by
ext j
exact apply_update (fun i F => F (x i)) f i u j
open Function in | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_add_smul_aux | null |
protected map_update_add [DecidableEq ι] (i : ι) (u v : s i →ₗ[R] t i) :
map (update f i (u + v)) = map (update f i u) + map (update f i v) := by
ext x
simp only [LinearMap.compMultilinearMap_apply, map_tprod, map_add_smul_aux, LinearMap.add_apply,
MultilinearMap.map_update_add]
open Function in | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_update_add | null |
protected map_update_smul [DecidableEq ι] (i : ι) (c : R) (u : s i →ₗ[R] t i) :
map (update f i (c • u)) = c • map (update f i u) := by
ext x
simp only [LinearMap.compMultilinearMap_apply, map_tprod, map_add_smul_aux, LinearMap.smul_apply,
MultilinearMap.map_update_smul]
variable (R s t) | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_update_smul | null |
@[simps]
noncomputable mapMultilinear :
MultilinearMap R (fun (i : ι) ↦ s i →ₗ[R] t i) ((⨂[R] i, s i) →ₗ[R] ⨂[R] i, t i) where
toFun := map
map_update_smul' _ _ _ _ := PiTensorProduct.map_update_smul _ _ _ _
map_update_add' _ _ _ _ := PiTensorProduct.map_update_add _ _ _ _
variable {R s t} | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | mapMultilinear | The tensor of a family of linear maps from `sᵢ` to `tᵢ`, as a multilinear map of
the family. |
piTensorHomMap : (⨂[R] i, s i →ₗ[R] t i) →ₗ[R] (⨂[R] i, s i) →ₗ[R] ⨂[R] i, t i :=
lift.toLinearMap ∘ₗ lift (MultilinearMap.piLinearMap <| tprod R)
@[simp] lemma piTensorHomMap_tprod_tprod (f : Π i, s i →ₗ[R] t i) (x : Π i, s i) :
piTensorHomMap (tprod R f) (tprod R x) = tprod R fun i ↦ f i (x i) := by
simp [piTensorHomMap] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | piTensorHomMap | Let `sᵢ` and `tᵢ` be families of `R`-modules.
Then there is an `R`-linear map between `⨂ᵢ Hom(sᵢ, tᵢ)` and `Hom(⨂ᵢ sᵢ, ⨂ tᵢ)` defined by
`⨂ᵢ fᵢ ↦ ⨂ᵢ aᵢ ↦ ⨂ᵢ fᵢ aᵢ`.
This is `TensorProduct.homTensorHomMap` for an arbitrary family of modules.
Note that `PiTensorProduct.piTensorHomMap (tprod R f)` is equal to `PiTensorProduct.map f`. |
piTensorHomMap_tprod_eq_map (f : Π i, s i →ₗ[R] t i) :
piTensorHomMap (tprod R f) = map f := by
ext; simp | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | piTensorHomMap_tprod_eq_map | null |
noncomputable congr (f : Π i, s i ≃ₗ[R] t i) :
(⨂[R] i, s i) ≃ₗ[R] ⨂[R] i, t i :=
.ofLinear
(map (fun i ↦ f i))
(map (fun i ↦ (f i).symm))
(by ext; simp)
(by ext; simp)
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | congr | If `s i` and `t i` are linearly equivalent for every `i` in `ι`, then `⨂[R] i, s i` and
`⨂[R] i, t i` are linearly equivalent.
This is the n-ary version of `TensorProduct.congr` |
congr_tprod (f : Π i, s i ≃ₗ[R] t i) (m : Π i, s i) :
congr f (tprod R m) = tprod R (fun (i : ι) ↦ (f i) (m i)) := by
simp only [congr, LinearEquiv.ofLinear_apply, map_tprod, LinearEquiv.coe_coe]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | congr_tprod | null |
congr_symm_tprod (f : Π i, s i ≃ₗ[R] t i) (p : Π i, t i) :
(congr f).symm (tprod R p) = tprod R (fun (i : ι) ↦ (f i).symm (p i)) := by
simp only [congr, LinearEquiv.ofLinear_symm_apply, map_tprod, LinearEquiv.coe_coe] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | congr_symm_tprod | null |
map₂ (f : Π i, s i →ₗ[R] t i →ₗ[R] t' i) :
(⨂[R] i, s i) →ₗ[R] (⨂[R] i, t i) →ₗ[R] ⨂[R] i, t' i :=
lift <| LinearMap.compMultilinearMap piTensorHomMap <| (tprod R).compLinearMap f | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map₂ | Let `sᵢ`, `tᵢ` and `t'ᵢ` be families of `R`-modules, then `f : Πᵢ sᵢ → tᵢ → t'ᵢ` induces an
element of `Hom(⨂ᵢ sᵢ, Hom(⨂ tᵢ, ⨂ᵢ t'ᵢ))` defined by `⨂ᵢ aᵢ ↦ ⨂ᵢ bᵢ ↦ ⨂ᵢ fᵢ aᵢ bᵢ`.
This is `PiTensorProduct.map` for two arbitrary families of modules.
This is `TensorProduct.map₂` for families of modules. |
map₂_tprod_tprod (f : Π i, s i →ₗ[R] t i →ₗ[R] t' i) (x : Π i, s i) (y : Π i, t i) :
map₂ f (tprod R x) (tprod R y) = tprod R fun i ↦ f i (x i) (y i) := by
simp [map₂] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map₂_tprod_tprod | null |
piTensorHomMapFun₂ : (⨂[R] i, s i →ₗ[R] t i →ₗ[R] t' i) →
(⨂[R] i, s i) →ₗ[R] (⨂[R] i, t i) →ₗ[R] (⨂[R] i, t' i) :=
fun φ => lift <| LinearMap.compMultilinearMap piTensorHomMap <|
(lift <| MultilinearMap.piLinearMap <| tprod R) φ | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | piTensorHomMapFun₂ | Let `sᵢ`, `tᵢ` and `t'ᵢ` be families of `R`-modules.
Then there is a function from `⨂ᵢ Hom(sᵢ, Hom(tᵢ, t'ᵢ))` to `Hom(⨂ᵢ sᵢ, Hom(⨂ tᵢ, ⨂ᵢ t'ᵢ))`
defined by `⨂ᵢ fᵢ ↦ ⨂ᵢ aᵢ ↦ ⨂ᵢ bᵢ ↦ ⨂ᵢ fᵢ aᵢ bᵢ`. |
piTensorHomMapFun₂_add (φ ψ : ⨂[R] i, s i →ₗ[R] t i →ₗ[R] t' i) :
piTensorHomMapFun₂ (φ + ψ) = piTensorHomMapFun₂ φ + piTensorHomMapFun₂ ψ := by
dsimp [piTensorHomMapFun₂]; ext; simp only [map_add, LinearMap.compMultilinearMap_apply,
lift.tprod, add_apply, LinearMap.add_apply] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | piTensorHomMapFun₂_add | null |
piTensorHomMapFun₂_smul (r : R) (φ : ⨂[R] i, s i →ₗ[R] t i →ₗ[R] t' i) :
piTensorHomMapFun₂ (r • φ) = r • piTensorHomMapFun₂ φ := by
dsimp [piTensorHomMapFun₂]; ext; simp only [map_smul, LinearMap.compMultilinearMap_apply,
lift.tprod, smul_apply, LinearMap.smul_apply] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | piTensorHomMapFun₂_smul | null |
piTensorHomMap₂ : (⨂[R] i, s i →ₗ[R] t i →ₗ[R] t' i) →ₗ[R]
(⨂[R] i, s i) →ₗ[R] (⨂[R] i, t i) →ₗ[R] (⨂[R] i, t' i) where
toFun := piTensorHomMapFun₂
map_add' x y := piTensorHomMapFun₂_add x y
map_smul' x y := piTensorHomMapFun₂_smul x y
@[simp] lemma piTensorHomMap₂_tprod_tprod_tprod
(f : ∀ i, s i →ₗ[R] t i →ₗ[R] t' i) (a : ∀ i, s i) (b : ∀ i, t i) :
piTensorHomMap₂ (tprod R f) (tprod R a) (tprod R b) = tprod R (fun i ↦ f i (a i) (b i)) := by
simp [piTensorHomMapFun₂, piTensorHomMap₂] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | piTensorHomMap₂ | Let `sᵢ`, `tᵢ` and `t'ᵢ` be families of `R`-modules.
Then there is an linear map from `⨂ᵢ Hom(sᵢ, Hom(tᵢ, t'ᵢ))` to `Hom(⨂ᵢ sᵢ, Hom(⨂ tᵢ, ⨂ᵢ t'ᵢ))`
defined by `⨂ᵢ fᵢ ↦ ⨂ᵢ aᵢ ↦ ⨂ᵢ bᵢ ↦ ⨂ᵢ fᵢ aᵢ bᵢ`.
This is `TensorProduct.homTensorHomMap` for two arbitrary families of modules. |
reindex (e : ι ≃ ι₂) : (⨂[R] i : ι, s i) ≃ₗ[R] ⨂[R] i : ι₂, s (e.symm i) :=
let f := domDomCongrLinearEquiv' R R s (⨂[R] (i : ι₂), s (e.symm i)) e
let g := domDomCongrLinearEquiv' R R s (⨂[R] (i : ι), s i) e
LinearEquiv.ofLinear (lift <| f.symm <| tprod R) (lift <| g <| tprod R) (by aesop) (by aesop) | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | reindex | Re-index the components of the tensor power by `e`. |
@[simp]
reindex_tprod (e : ι ≃ ι₂) (f : Π i, s i) :
reindex R s e (tprod R f) = tprod R fun i ↦ f (e.symm i) := by
dsimp [reindex]
exact liftAux_tprod _ f
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | reindex_tprod | null |
reindex_comp_tprod (e : ι ≃ ι₂) :
(reindex R s e).compMultilinearMap (tprod R) =
(domDomCongrLinearEquiv' R R s _ e).symm (tprod R) :=
MultilinearMap.ext <| reindex_tprod e | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | reindex_comp_tprod | null |
lift_comp_reindex (e : ι ≃ ι₂) (φ : MultilinearMap R (fun i ↦ s (e.symm i)) E) :
lift φ ∘ₗ (reindex R s e) = lift ((domDomCongrLinearEquiv' R R s _ e).symm φ) := by
ext; simp [reindex]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift_comp_reindex | null |
lift_comp_reindex_symm (e : ι ≃ ι₂) (φ : MultilinearMap R s E) :
lift φ ∘ₗ (reindex R s e).symm = lift (domDomCongrLinearEquiv' R R s _ e φ) := by
ext; simp [reindex] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift_comp_reindex_symm | null |
lift_reindex
(e : ι ≃ ι₂) (φ : MultilinearMap R (fun i ↦ s (e.symm i)) E) (x : ⨂[R] i, s i) :
lift φ (reindex R s e x) = lift ((domDomCongrLinearEquiv' R R s _ e).symm φ) x :=
LinearMap.congr_fun (lift_comp_reindex e φ) x
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift_reindex | null |
lift_reindex_symm
(e : ι ≃ ι₂) (φ : MultilinearMap R s E) (x : ⨂[R] i, s (e.symm i)) :
lift φ (reindex R s e |>.symm x) = lift (domDomCongrLinearEquiv' R R s _ e φ) x :=
LinearMap.congr_fun (lift_comp_reindex_symm e φ) x
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | lift_reindex_symm | null |
reindex_trans (e : ι ≃ ι₂) (e' : ι₂ ≃ ι₃) :
(reindex R s e).trans (reindex R _ e') = reindex R s (e.trans e') := by
apply LinearEquiv.toLinearMap_injective
ext f
simp only [LinearEquiv.trans_apply, LinearEquiv.coe_coe, reindex_tprod,
LinearMap.coe_compMultilinearMap, Function.comp_apply,
reindex_comp_tprod]
congr | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | reindex_trans | null |
reindex_reindex (e : ι ≃ ι₂) (e' : ι₂ ≃ ι₃) (x : ⨂[R] i, s i) :
reindex R _ e' (reindex R s e x) = reindex R s (e.trans e') x :=
LinearEquiv.congr_fun (reindex_trans e e' : _ = reindex R s (e.trans e')) x | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | reindex_reindex | null |
@[simp]
reindex_symm (e : ι ≃ ι₂) :
(reindex R (fun _ ↦ M) e).symm = reindex R (fun _ ↦ M) e.symm := by
ext x
simp [reindex]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | reindex_symm | This lemma is impractical to state in the dependent case. |
reindex_refl : reindex R s (Equiv.refl ι) = LinearEquiv.refl R _ := by
apply LinearEquiv.toLinearMap_injective
ext
simp only [Equiv.refl_symm, Equiv.refl_apply, reindex, domDomCongrLinearEquiv',
LinearEquiv.coe_symm_mk, LinearMap.compMultilinearMap_apply, LinearEquiv.coe_coe,
LinearEquiv.refl_toLinearMap, LinearMap.id_coe, id_eq]
simp
variable {t : ι → Type*}
variable [∀ i, AddCommMonoid (t i)] [∀ i, Module R (t i)] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | reindex_refl | null |
map_comp_reindex_eq (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) :
map (fun i ↦ f (e.symm i)) ∘ₗ reindex R s e = reindex R t e ∘ₗ map f := by
ext m
simp only [LinearMap.compMultilinearMap_apply, LinearEquiv.coe_coe,
LinearMap.comp_apply, reindex_tprod, map_tprod] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_comp_reindex_eq | Re-indexing the components of the tensor product by an equivalence `e` is compatible
with `PiTensorProduct.map`. |
map_reindex (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) (x : ⨂[R] i, s i) :
map (fun i ↦ f (e.symm i)) (reindex R s e x) = reindex R t e (map f x) :=
DFunLike.congr_fun (map_comp_reindex_eq _ _) _ | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_reindex | null |
map_comp_reindex_symm (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) :
map f ∘ₗ (reindex R s e).symm = (reindex R t e).symm ∘ₗ map (fun i => f (e.symm i)) := by
ext m
apply LinearEquiv.injective (reindex R t e)
simp only [LinearMap.compMultilinearMap_apply, LinearMap.coe_comp, LinearEquiv.coe_coe,
comp_apply, ← map_reindex, LinearEquiv.apply_symm_apply, map_tprod] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_comp_reindex_symm | null |
map_reindex_symm (f : Π i, s i →ₗ[R] t i) (e : ι ≃ ι₂) (x : ⨂[R] i, s (e.symm i)) :
map f ((reindex R s e).symm x) = (reindex R t e).symm (map (fun i ↦ f (e.symm i)) x) :=
DFunLike.congr_fun (map_comp_reindex_symm _ _) _
variable (ι)
attribute [local simp] eq_iff_true_of_subsingleton in | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | map_reindex_symm | null |
@[simps symm_apply]
isEmptyEquiv [IsEmpty ι] : (⨂[R] i : ι, s i) ≃ₗ[R] R where
toFun := lift (constOfIsEmpty R _ 1)
invFun r := r • tprod R (@isEmptyElim _ _ _)
left_inv x := by
refine x.induction_on ?_ ?_
· intro x y
simp only [map_smulₛₗ, RingHom.id_apply, lift.tprod, constOfIsEmpty_apply, const_apply,
smul_eq_mul, mul_one]
congr
aesop
· simp only
intro x y hx hy
rw [map_add, add_smul, hx, hy]
right_inv t := by simp
map_add' := LinearMap.map_add _
map_smul' := fun r x => by
exact LinearMap.map_smul _ r x
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | isEmptyEquiv | The tensor product over an empty index type `ι` is isomorphic to the base ring. |
isEmptyEquiv_apply_tprod [IsEmpty ι] (f : Π i, s i) :
isEmptyEquiv ι (tprod R f) = 1 :=
lift.tprod _
variable {ι} | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | isEmptyEquiv_apply_tprod | null |
@[simps symm_apply]
subsingletonEquiv [Subsingleton ι] (i₀ : ι) : (⨂[R] _ : ι, M) ≃ₗ[R] M where
toFun := lift (MultilinearMap.ofSubsingleton R M M i₀ .id)
invFun m := tprod R fun _ ↦ m
left_inv x := by
dsimp only
have : ∀ (f : ι → M) (z : M), (fun _ : ι ↦ z) = update f i₀ z := fun f z ↦ by
ext i
rw [Subsingleton.elim i i₀, Function.update_self]
refine x.induction_on ?_ ?_
· intro r f
simp only [LinearMap.map_smul, LinearMap.id_apply, lift.tprod, ofSubsingleton_apply_apply,
this f, MultilinearMap.map_update_smul, update_eq_self]
· intro x y hx hy
rw [LinearMap.map_add, this 0 (_ + _), MultilinearMap.map_update_add, ← this 0 (lift _ _), hx,
← this 0 (lift _ _), hy]
right_inv t := by simp only [ofSubsingleton_apply_apply, LinearMap.id_apply, lift.tprod]
map_add' := LinearMap.map_add _
map_smul' := fun r x => by
exact LinearMap.map_smul _ r x
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | subsingletonEquiv | Tensor product of `M` over a singleton set is equivalent to `M` |
subsingletonEquiv_apply_tprod [Subsingleton ι] (i : ι) (f : ι → M) :
subsingletonEquiv i (tprod R f) = f i :=
lift.tprod _
variable (R M) | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | subsingletonEquiv_apply_tprod | null |
tmulEquivDep :
(⨂[R] i₁, N (.inl i₁)) ⊗[R] (⨂[R] i₂, N (.inr i₂)) ≃ₗ[R] ⨂[R] i, N i :=
LinearEquiv.ofLinear
(TensorProduct.lift
{ toFun a := PiTensorProduct.lift (PiTensorProduct.lift
(MultilinearMap.currySumEquiv (tprod R)) a)
map_add' := by simp
map_smul' := by simp })
(PiTensorProduct.lift (MultilinearMap.domCoprodDep (tprod R) (tprod R))) (by
ext
dsimp
simp only [lift.tprod, domCoprodDep_apply, lift.tmul, LinearMap.coe_mk, AddHom.coe_mk,
currySum_apply]
congr
ext (_ | _) <;> simp)
(TensorProduct.ext (by aesop))
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tmulEquivDep | Equivalence between a `TensorProduct` of `PiTensorProduct`s and a single
`PiTensorProduct` indexed by a `Sum` type. If `N` is a constant family of
modules, use the non-dependent version `PiTensorProduct.tmulEquiv` instead. |
tmulEquivDep_apply (a : (i₁ : ι) → N (.inl i₁))
(b : (i₂ : ι₂) → N (.inr i₂)) :
tmulEquivDep R N ((⨂ₜ[R] i₁, a i₁) ⊗ₜ (⨂ₜ[R] i₂, b i₂)) =
(⨂ₜ[R] i, Sum.rec a b i) := by
simp [tmulEquivDep]
@[simp] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tmulEquivDep_apply | null |
tmulEquivDep_symm_apply (f : (i : ι ⊕ ι₂) → N i) :
(tmulEquivDep R N).symm (⨂ₜ[R] i, f i) =
((⨂ₜ[R] i₁, f (.inl i₁)) ⊗ₜ (⨂ₜ[R] i₂, f (.inr i₂))) := by
simp [tmulEquivDep] | lemma | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tmulEquivDep_symm_apply | null |
tmulEquiv :
(⨂[R] (_ : ι), M) ⊗[R] (⨂[R] (_ : ι₂), M) ≃ₗ[R] ⨂[R] (_ : ι ⊕ ι₂), M :=
tmulEquivDep R (fun _ ↦ M)
@[simp] | def | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tmulEquiv | Equivalence between a `TensorProduct` of `PiTensorProduct`s and a single
`PiTensorProduct` indexed by a `Sum` type.
See `PiTensorProduct.tmulEquivDep` for the dependent version. |
tmulEquiv_apply (a : ι → M) (b : ι₂ → M) :
tmulEquiv R M ((⨂ₜ[R] i, a i) ⊗ₜ[R] (⨂ₜ[R] i, b i)) = ⨂ₜ[R] i, Sum.elim a b i := by
simp [tmulEquiv, Sum.elim]
@[simp] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tmulEquiv_apply | null |
tmulEquiv_symm_apply (a : ι ⊕ ι₂ → M) :
(tmulEquiv R M).symm (⨂ₜ[R] i, a i) =
(⨂ₜ[R] i, a (Sum.inl i)) ⊗ₜ[R] (⨂ₜ[R] i, a (Sum.inr i)) := by
simp [tmulEquiv] | theorem | LinearAlgebra | [
"Mathlib.LinearAlgebra.Multilinear.TensorProduct",
"Mathlib.Tactic.AdaptationNote",
"Mathlib.LinearAlgebra.Multilinear.Curry"
] | Mathlib/LinearAlgebra/PiTensorProduct.lean | tmulEquiv_symm_apply | null |
fst : M × M₂ →ₗ[R] M where
toFun := Prod.fst
map_add' _x _y := rfl
map_smul' _x _y := rfl | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst | The first projection of a product is a linear map. |
snd : M × M₂ →ₗ[R] M₂ where
toFun := Prod.snd
map_add' _x _y := rfl
map_smul' _x _y := rfl | def | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd | The second projection of a product is a linear map. |
@[simp]
fst_apply (x : M × M₂) : fst R M M₂ x = x.1 :=
rfl
@[simp] | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_apply | null |
snd_apply (x : M × M₂) : snd R M M₂ x = x.2 :=
rfl
@[simp, norm_cast] lemma coe_fst : ⇑(fst R M M₂) = Prod.fst := rfl
@[simp, norm_cast] lemma coe_snd : ⇑(snd R M M₂) = Prod.snd := rfl | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_apply | null |
fst_surjective : Function.Surjective (fst R M M₂) := fun x => ⟨(x, 0), rfl⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | fst_surjective | null |
snd_surjective : Function.Surjective (snd R M M₂) := fun x => ⟨(0, x), rfl⟩ | theorem | LinearAlgebra | [
"Mathlib.Algebra.Algebra.Prod",
"Mathlib.Algebra.Group.Graph",
"Mathlib.LinearAlgebra.Span.Basic"
] | Mathlib/LinearAlgebra/Prod.lean | snd_surjective | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.