Module docstring
{"# Continuous linear maps on products and Pi types ","### Properties that hold for non-necessarily commutative semirings. "}
{"# Continuous linear maps on products and Pi types ","### Properties that hold for non-necessarily commutative semirings. "}
ContinuousLinearMap.prod
definition
(f₁ : M₁ →L[R] M₂) (f₂ : M₁ →L[R] M₃) : M₁ →L[R] M₂ × M₃
/-- The cartesian product of two bounded linear maps, as a bounded linear map. -/
protected def prod (f₁ : M₁ →L[R] M₂) (f₂ : M₁ →L[R] M₃) :
M₁ →L[R] M₂ × M₃ :=
⟨(f₁ : M₁ →ₗ[R] M₂).prod f₂, f₁.2.prodMk f₂.2⟩
ContinuousLinearMap.coe_prod
theorem
(f₁ : M₁ →L[R] M₂) (f₂ : M₁ →L[R] M₃) : (f₁.prod f₂ : M₁ →ₗ[R] M₂ × M₃) = LinearMap.prod f₁ f₂
@[simp, norm_cast]
theorem coe_prod (f₁ : M₁ →L[R] M₂) (f₂ : M₁ →L[R] M₃) :
(f₁.prod f₂ : M₁ →ₗ[R] M₂ × M₃) = LinearMap.prod f₁ f₂ :=
rfl
ContinuousLinearMap.prod_apply
theorem
(f₁ : M₁ →L[R] M₂) (f₂ : M₁ →L[R] M₃) (x : M₁) : f₁.prod f₂ x = (f₁ x, f₂ x)
@[simp, norm_cast]
theorem prod_apply (f₁ : M₁ →L[R] M₂) (f₂ : M₁ →L[R] M₃) (x : M₁) :
f₁.prod f₂ x = (f₁ x, f₂ x) :=
rfl
ContinuousLinearMap.inl
definition
: M₁ →L[R] M₁ × M₂
/-- The left injection into a product is a continuous linear map. -/
def inl : M₁ →L[R] M₁ × M₂ :=
(id R M₁).prod 0
ContinuousLinearMap.inr
definition
: M₂ →L[R] M₁ × M₂
/-- The right injection into a product is a continuous linear map. -/
def inr : M₂ →L[R] M₁ × M₂ :=
(0 : M₂ →L[R] M₁).prod (id R M₂)
ContinuousLinearMap.inl_apply
theorem
(x : M₁) : inl R M₁ M₂ x = (x, 0)
ContinuousLinearMap.inr_apply
theorem
(x : M₂) : inr R M₁ M₂ x = (0, x)
ContinuousLinearMap.coe_inl
theorem
: (inl R M₁ M₂ : M₁ →ₗ[R] M₁ × M₂) = LinearMap.inl R M₁ M₂
@[simp, norm_cast]
theorem coe_inl : (inl R M₁ M₂ : M₁ →ₗ[R] M₁ × M₂) = LinearMap.inl R M₁ M₂ :=
rfl
ContinuousLinearMap.coe_inr
theorem
: (inr R M₁ M₂ : M₂ →ₗ[R] M₁ × M₂) = LinearMap.inr R M₁ M₂
@[simp, norm_cast]
theorem coe_inr : (inr R M₁ M₂ : M₂ →ₗ[R] M₁ × M₂) = LinearMap.inr R M₁ M₂ :=
rfl
ContinuousLinearMap.ker_prod
theorem
(f : M₁ →L[R] M₂) (g : M₁ →L[R] M₃) : ker (f.prod g) = ker f ⊓ ker g
@[simp]
theorem ker_prod (f : M₁ →L[R] M₂) (g : M₁ →L[R] M₃) :
ker (f.prod g) = kerker f ⊓ ker g :=
LinearMap.ker_prod (f : M₁ →ₗ[R] M₂) (g : M₁ →ₗ[R] M₃)
ContinuousLinearMap.fst
definition
: M₁ × M₂ →L[R] M₁
/-- `Prod.fst` as a `ContinuousLinearMap`. -/
def fst : M₁ × M₂M₁ × M₂ →L[R] M₁ where
cont := continuous_fst
toLinearMap := LinearMap.fst R M₁ M₂
ContinuousLinearMap.snd
definition
: M₁ × M₂ →L[R] M₂
/-- `Prod.snd` as a `ContinuousLinearMap`. -/
def snd : M₁ × M₂M₁ × M₂ →L[R] M₂ where
cont := continuous_snd
toLinearMap := LinearMap.snd R M₁ M₂
ContinuousLinearMap.coe_fst
theorem
: ↑(fst R M₁ M₂) = LinearMap.fst R M₁ M₂
@[simp, norm_cast]
theorem coe_fst : ↑(fst R M₁ M₂) = LinearMap.fst R M₁ M₂ :=
rfl
ContinuousLinearMap.coe_fst'
theorem
: ⇑(fst R M₁ M₂) = Prod.fst
ContinuousLinearMap.coe_snd
theorem
: ↑(snd R M₁ M₂) = LinearMap.snd R M₁ M₂
@[simp, norm_cast]
theorem coe_snd : ↑(snd R M₁ M₂) = LinearMap.snd R M₁ M₂ :=
rfl
ContinuousLinearMap.coe_snd'
theorem
: ⇑(snd R M₁ M₂) = Prod.snd
ContinuousLinearMap.fst_prod_snd
theorem
: (fst R M₁ M₂).prod (snd R M₁ M₂) = id R (M₁ × M₂)
ContinuousLinearMap.fst_comp_prod
theorem
(f : M₁ →L[R] M₂) (g : M₁ →L[R] M₃) : (fst R M₂ M₃).comp (f.prod g) = f
@[simp]
theorem fst_comp_prod (f : M₁ →L[R] M₂) (g : M₁ →L[R] M₃) :
(fst R M₂ M₃).comp (f.prod g) = f :=
ext fun _x => rfl
ContinuousLinearMap.snd_comp_prod
theorem
(f : M₁ →L[R] M₂) (g : M₁ →L[R] M₃) : (snd R M₂ M₃).comp (f.prod g) = g
@[simp]
theorem snd_comp_prod (f : M₁ →L[R] M₂) (g : M₁ →L[R] M₃) :
(snd R M₂ M₃).comp (f.prod g) = g :=
ext fun _x => rfl
ContinuousLinearMap.prodMap
definition
(f₁ : M₁ →L[R] M₂) (f₂ : M₃ →L[R] M₄) : M₁ × M₃ →L[R] M₂ × M₄
/-- `Prod.map` of two continuous linear maps. -/
def prodMap (f₁ : M₁ →L[R] M₂) (f₂ : M₃ →L[R] M₄) :
M₁ × M₃M₁ × M₃ →L[R] M₂ × M₄ :=
(f₁.comp (fst R M₁ M₃)).prod (f₂.comp (snd R M₁ M₃))
ContinuousLinearMap.coe_prodMap
theorem
(f₁ : M₁ →L[R] M₂) (f₂ : M₃ →L[R] M₄) : ↑(f₁.prodMap f₂) = (f₁ : M₁ →ₗ[R] M₂).prodMap (f₂ : M₃ →ₗ[R] M₄)
@[simp, norm_cast]
theorem coe_prodMap (f₁ : M₁ →L[R] M₂)
(f₂ : M₃ →L[R] M₄) : ↑(f₁.prodMap f₂) = (f₁ : M₁ →ₗ[R] M₂).prodMap (f₂ : M₃ →ₗ[R] M₄) :=
rfl
ContinuousLinearMap.coe_prodMap'
theorem
(f₁ : M₁ →L[R] M₂) (f₂ : M₃ →L[R] M₄) : ⇑(f₁.prodMap f₂) = Prod.map f₁ f₂
@[simp, norm_cast]
theorem coe_prodMap' (f₁ : M₁ →L[R] M₂)
(f₂ : M₃ →L[R] M₄) : ⇑(f₁.prodMap f₂) = Prod.map f₁ f₂ :=
rfl
ContinuousLinearMap.pi
definition
(f : ∀ i, M →L[R] φ i) : M →L[R] ∀ i, φ i
/-- `pi` construction for continuous linear functions. From a family of continuous linear functions
it produces a continuous linear function into a family of topological modules. -/
def pi (f : ∀ i, M →L[R] φ i) : M →L[R] ∀ i, φ i :=
⟨LinearMap.pi fun i => f i, continuous_pi fun i => (f i).continuous⟩
ContinuousLinearMap.coe_pi'
theorem
(f : ∀ i, M →L[R] φ i) : ⇑(pi f) = fun c i => f i c
@[simp]
theorem coe_pi' (f : ∀ i, M →L[R] φ i) : ⇑(pi f) = fun c i => f i c :=
rfl
ContinuousLinearMap.coe_pi
theorem
(f : ∀ i, M →L[R] φ i) : (pi f : M →ₗ[R] ∀ i, φ i) = LinearMap.pi fun i => f i
@[simp]
theorem coe_pi (f : ∀ i, M →L[R] φ i) : (pi f : M →ₗ[R] ∀ i, φ i) = LinearMap.pi fun i => f i :=
rfl
ContinuousLinearMap.pi_apply
theorem
(f : ∀ i, M →L[R] φ i) (c : M) (i : ι) : pi f c i = f i c
theorem pi_apply (f : ∀ i, M →L[R] φ i) (c : M) (i : ι) : pi f c i = f i c :=
rfl
ContinuousLinearMap.pi_eq_zero
theorem
(f : ∀ i, M →L[R] φ i) : pi f = 0 ↔ ∀ i, f i = 0
theorem pi_eq_zero (f : ∀ i, M →L[R] φ i) : pipi f = 0 ↔ ∀ i, f i = 0 := by
simp only [ContinuousLinearMap.ext_iff, pi_apply, funext_iff]
exact forall_swap
ContinuousLinearMap.pi_zero
theorem
: pi (fun _ => 0 : ∀ i, M →L[R] φ i) = 0
theorem pi_zero : pi (fun _ => 0 : ∀ i, M →L[R] φ i) = 0 :=
ext fun _ => rfl
ContinuousLinearMap.pi_comp
theorem
(f : ∀ i, M →L[R] φ i) (g : M₂ →L[R] M) : (pi f).comp g = pi fun i => (f i).comp g
theorem pi_comp (f : ∀ i, M →L[R] φ i) (g : M₂ →L[R] M) :
(pi f).comp g = pi fun i => (f i).comp g :=
rfl
ContinuousLinearMap.proj
definition
(i : ι) : (∀ i, φ i) →L[R] φ i
/-- The projections from a family of topological modules are continuous linear maps. -/
def proj (i : ι) : (∀ i, φ i) →L[R] φ i :=
⟨LinearMap.proj i, continuous_apply _⟩
ContinuousLinearMap.proj_apply
theorem
(i : ι) (b : ∀ i, φ i) : (proj i : (∀ i, φ i) →L[R] φ i) b = b i
@[simp]
theorem proj_apply (i : ι) (b : ∀ i, φ i) : (proj i : (∀ i, φ i) →L[R] φ i) b = b i :=
rfl
ContinuousLinearMap.proj_pi
theorem
(f : ∀ i, M₂ →L[R] φ i) (i : ι) : (proj i).comp (pi f) = f i
ContinuousLinearMap.coe_proj
theorem
(i : ι) : (proj i).toLinearMap = (LinearMap.proj i : ((i : ι) → φ i) →ₗ[R] _)
@[simp]
theorem coe_proj (i : ι) : (proj i).toLinearMap = (LinearMap.proj i : ((i : ι) → φ i) →ₗ[R] _) :=
rfl
ContinuousLinearMap.pi_proj
theorem
: pi proj = .id R (∀ i, φ i)
ContinuousLinearMap.pi_proj_comp
theorem
(f : M₂ →L[R] ∀ i, φ i) : pi (proj · ∘L f) = f
@[simp]
theorem pi_proj_comp (f : M₂ →L[R] ∀ i, φ i) : pi (projproj · ∘L f) = f := rfl
ContinuousLinearMap.iInf_ker_proj
theorem
: (⨅ i, ker (proj i : (∀ i, φ i) →L[R] φ i) : Submodule R (∀ i, φ i)) = ⊥
theorem iInf_ker_proj : (⨅ i, ker (proj i : (∀ i, φ i) →L[R] φ i) : Submodule R (∀ i, φ i)) = ⊥ :=
LinearMap.iInf_ker_proj
Pi.compRightL
definition
{α : Type*} (f : α → ι) : ((i : ι) → φ i) →L[R] ((i : α) → φ (f i))
/-- Given a function `f : α → ι`, it induces a continuous linear function by right composition on
product types. For `f = Subtype.val`, this corresponds to forgetting some set of variables. -/
def _root_.Pi.compRightL {α : Type*} (f : α → ι) : ((i : ι) → φ i) →L[R] ((i : α) → φ (f i)) where
toFun := fun v i ↦ v (f i)
map_add' := by intros; ext; simp
map_smul' := by intros; ext; simp
cont := by continuity
Pi.compRightL_apply
theorem
{α : Type*} (f : α → ι) (v : (i : ι) → φ i) (i : α) : Pi.compRightL R φ f v i = v (f i)
@[simp] lemma _root_.Pi.compRightL_apply {α : Type*} (f : α → ι) (v : (i : ι) → φ i) (i : α) :
Pi.compRightL R φ f v i = v (f i) := rfl
ContinuousLinearMap.single
definition
[DecidableEq ι] (i : ι) : φ i →L[R] (∀ i, φ i)
/-- `Pi.single` as a bundled continuous linear map. -/
@[simps! -fullyApplied]
def single [DecidableEq ι] (i : ι) : φ i →L[R] (∀ i, φ i) where
toLinearMap := .single R φ i
cont := continuous_single _
ContinuousLinearMap.range_prod_eq
theorem
{f : M →L[R] M₂} {g : M →L[R] M₃} (h : ker f ⊔ ker g = ⊤) : range (f.prod g) = (range f).prod (range g)
theorem range_prod_eq {f : M →L[R] M₂} {g : M →L[R] M₃} (h : kerker f ⊔ ker g = ⊤) :
range (f.prod g) = (range f).prod (range g) :=
LinearMap.range_prod_eq h
ContinuousLinearMap.ker_prod_ker_le_ker_coprod
theorem
(f : M →L[R] M₃) (g : M₂ →L[R] M₃) : (LinearMap.ker f).prod (LinearMap.ker g) ≤ LinearMap.ker (f.coprod g)
theorem ker_prod_ker_le_ker_coprod (f : M →L[R] M₃) (g : M₂ →L[R] M₃) :
(LinearMap.ker f).prod (LinearMap.ker g) ≤ LinearMap.ker (f.coprod g) :=
LinearMap.ker_prod_ker_le_ker_coprod f.toLinearMap g.toLinearMap
ContinuousLinearMap.prodEquiv
definition
: (M →L[R] M₂) × (M →L[R] M₃) ≃ (M →L[R] M₂ × M₃)
/-- `ContinuousLinearMap.prod` as an `Equiv`. -/
@[simps apply]
def prodEquiv : (M →L[R] M₂) × (M →L[R] M₃)(M →L[R] M₂) × (M →L[R] M₃) ≃ (M →L[R] M₂ × M₃) where
toFun f := f.1.prod f.2
invFun f := ⟨(fst _ _ _).comp f, (snd _ _ _).comp f⟩
left_inv f := by ext <;> rfl
right_inv f := by ext <;> rfl
ContinuousLinearMap.prod_ext_iff
theorem
{f g : M × M₂ →L[R] M₃} : f = g ↔ f.comp (inl _ _ _) = g.comp (inl _ _ _) ∧ f.comp (inr _ _ _) = g.comp (inr _ _ _)
theorem prod_ext_iff {f g : M × M₂M × M₂ →L[R] M₃} :
f = g ↔ f.comp (inl _ _ _) = g.comp (inl _ _ _) ∧ f.comp (inr _ _ _) = g.comp (inr _ _ _) := by
simp only [← coe_inj, LinearMap.prod_ext_iff]
rfl
ContinuousLinearMap.prod_ext
theorem
{f g : M × M₂ →L[R] M₃} (hl : f.comp (inl _ _ _) = g.comp (inl _ _ _)) (hr : f.comp (inr _ _ _) = g.comp (inr _ _ _)) :
f = g
ContinuousLinearMap.prodₗ
definition
: ((M →L[R] M₂) × (M →L[R] M₃)) ≃ₗ[S] M →L[R] M₂ × M₃
ContinuousLinearMap.coprod
definition
(f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) : M₁ × M₂ →L[R] M
/-- The continuous linear map given by `(x, y) ↦ f₁ x + f₂ y`. -/
@[simps! coe apply]
def coprod (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) : M₁ × M₂M₁ × M₂ →L[R] M :=
⟨.coprod f₁ f₂, (f₁.cont.comp continuous_fst).add (f₂.cont.comp continuous_snd)⟩
ContinuousLinearMap.coprod_add
theorem
(f₁ g₁ : M₁ →L[R] M) (f₂ g₂ : M₂ →L[R] M) : (f₁ + g₁).coprod (f₂ + g₂) = f₁.coprod f₂ + g₁.coprod g₂
@[simp] lemma coprod_add (f₁ g₁ : M₁ →L[R] M) (f₂ g₂ : M₂ →L[R] M) :
(f₁ + g₁).coprod (f₂ + g₂) = f₁.coprod f₂ + g₁.coprod g₂ := by ext <;> simp
ContinuousLinearMap.range_coprod
theorem
(f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) : range (f₁.coprod f₂) = range f₁ ⊔ range f₂
lemma range_coprod (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
range (f₁.coprod f₂) = rangerange f₁ ⊔ range f₂ := LinearMap.range_coprod ..
ContinuousLinearMap.comp_fst_add_comp_snd
theorem
(f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) : f₁.comp (.fst _ _ _) + f₂.comp (.snd _ _ _) = f₁.coprod f₂
lemma comp_fst_add_comp_snd (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
f₁.comp (.fst _ _ _) + f₂.comp (.snd _ _ _) = f₁.coprod f₂ := rfl
ContinuousLinearMap.comp_coprod
theorem
(f : M →L[R] N) (g₁ : M₁ →L[R] M) (g₂ : M₂ →L[R] M) : f.comp (g₁.coprod g₂) = (f.comp g₁).coprod (f.comp g₂)
lemma comp_coprod (f : M →L[R] N) (g₁ : M₁ →L[R] M) (g₂ : M₂ →L[R] M) :
f.comp (g₁.coprod g₂) = (f.comp g₁).coprod (f.comp g₂) :=
coe_injective <| LinearMap.comp_coprod ..
ContinuousLinearMap.coprod_comp_inl
theorem
(f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) : (f₁.coprod f₂).comp (.inl _ _ _) = f₁
@[simp] lemma coprod_comp_inl (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
(f₁.coprod f₂).comp (.inl _ _ _) = f₁ := coe_injective <| LinearMap.coprod_inl ..
ContinuousLinearMap.coprod_comp_inr
theorem
(f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) : (f₁.coprod f₂).comp (.inr _ _ _) = f₂
@[simp] lemma coprod_comp_inr (f₁ : M₁ →L[R] M) (f₂ : M₂ →L[R] M) :
(f₁.coprod f₂).comp (.inr _ _ _) = f₂ := coe_injective <| LinearMap.coprod_inr ..
ContinuousLinearMap.coprod_inl_inr
theorem
: ContinuousLinearMap.coprod (.inl R M N) (.inr R M N) = .id R (M × N)
@[simp]
lemma coprod_inl_inr : ContinuousLinearMap.coprod (.inl R M N) (.inr R M N) = .id R (M × N) :=
coe_injective <| LinearMap.coprod_inl_inr
ContinuousLinearMap.coprodEquiv
definition
[ContinuousAdd M₁] [ContinuousAdd M₂] [Semiring S] [Module S M] [ContinuousConstSMul S M] [SMulCommClass R S M] :
((M₁ →L[R] M) × (M₂ →L[R] M)) ≃ₗ[S] M₁ × M₂ →L[R] M
/-- Taking the product of two maps with the same codomain is equivalent to taking the product of
their domains.
See note [bundled maps over different rings] for why separate `R` and `S` semirings are used.
TODO: Upgrade this to a `ContinuousLinearEquiv`. This should be true for any topological
vector space over a normed field thanks to `ContinuousLinearMap.precomp` and
`ContinuousLinearMap.postcomp`. -/
@[simps]
def coprodEquiv [ContinuousAdd M₁] [ContinuousAdd M₂] [Semiring S] [Module S M]
[ContinuousConstSMul S M] [SMulCommClass R S M] :
((M₁ →L[R] M) × (M₂ →L[R] M)) ≃ₗ[S] M₁ × M₂ →L[R] M where
toFun f := f.1.coprod f.2
invFun f := (f.comp (.inl ..), f.comp (.inr ..))
left_inv f := by simp
right_inv f := by simp [← comp_coprod f (.inl R M₁ M₂)]
map_add' a b := coprod_add ..
map_smul' r a := by
dsimp
ext <;> simp [smul_add, smul_apply, Prod.smul_snd, Prod.smul_fst, coprod_apply]
ContinuousLinearMap.ker_coprod_of_disjoint_range
theorem
{f₁ : M₁ →L[R] M} {f₂ : M₂ →L[R] M} (hf : Disjoint (range f₁) (range f₂)) :
LinearMap.ker (f₁.coprod f₂) = (LinearMap.ker f₁).prod (LinearMap.ker f₂)
lemma ker_coprod_of_disjoint_range {f₁ : M₁ →L[R] M} {f₂ : M₂ →L[R] M}
(hf : Disjoint (range f₁) (range f₂)) :
LinearMap.ker (f₁.coprod f₂) = (LinearMap.ker f₁).prod (LinearMap.ker f₂) :=
LinearMap.ker_coprod_of_disjoint_range f₁.toLinearMap f₂.toLinearMap hf