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 ⌀ |
|---|---|---|---|---|---|---|
coe_prodCongr [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (e : M₁ ≃L[R₁] M₂)
(e' : M₃ ≃L[R₁] M₄) :
(e.prodCongr e' : M₁ × M₃ →L[R₁] M₂ × M₄) = (e : M₁ →L[R₁] M₂).prodMap (e' : M₃ →L[R₁] M₄) :=
rfl
@[deprecated (since := "2025-06-06")] alias coe_prod := coe_prodCongr | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_prodCongr | null |
prodCongr_symm [Module R₁ M₂] [Module R₁ M₃] [Module R₁ M₄] (e : M₁ ≃L[R₁] M₂)
(e' : M₃ ≃L[R₁] M₄) : (e.prodCongr e').symm = e.symm.prodCongr e'.symm :=
rfl
@[deprecated (since := "2025-06-06")] alias prod_symm := prodCongr_symm
variable (R₁ M₁ M₂) | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodCongr_symm | null |
@[simps! apply toLinearEquiv]
prodComm [Module R₁ M₂] : (M₁ × M₂) ≃L[R₁] M₂ × M₁ :=
{ LinearEquiv.prodComm R₁ M₁ M₂ with
continuous_toFun := continuous_swap
continuous_invFun := continuous_swap }
@[simp] lemma prodComm_symm [Module R₁ M₂] : (prodComm R₁ M₁ M₂).symm = prodComm R₁ M₂ M₁ := rfl | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodComm | Product of modules is commutative up to continuous linear isomorphism. |
prodAssoc : ((M₁ × M₂) × M₃) ≃L[R] M₁ × M₂ × M₃ where
toLinearEquiv := LinearEquiv.prodAssoc R M₁ M₂ M₃
continuous_toFun := (continuous_fst.comp continuous_fst).prodMk
((continuous_snd.comp continuous_fst).prodMk continuous_snd)
continuous_invFun := (continuous_fst.prodMk (continuous_fst.comp continuous_snd)).prodMk
(continuous_snd.comp continuous_snd)
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodAssoc | The product of topological modules is associative up to continuous linear isomorphism.
This is `LinearEquiv.prodAssoc` prodAssoc as a continuous linear equivalence. |
prodAssoc_toLinearEquiv :
(prodAssoc R M₁ M₂ M₃).toLinearEquiv = LinearEquiv.prodAssoc R M₁ M₂ M₃ := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodAssoc_toLinearEquiv | null |
coe_prodAssoc :
(prodAssoc R M₁ M₂ M₃ : (M₁ × M₂) × M₃ → M₁ × M₂ × M₃) = Equiv.prodAssoc M₁ M₂ M₃ := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_prodAssoc | null |
prodAssoc_apply (p₁ : M₁) (p₂ : M₂) (p₃ : M₃) :
prodAssoc R M₁ M₂ M₃ ((p₁, p₂), p₃) = (p₁, (p₂, p₃)) := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodAssoc_apply | null |
prodAssoc_symm_apply (p₁ : M₁) (p₂ : M₂) (p₃ : M₃) :
(prodAssoc R M₁ M₂ M₃).symm (p₁, (p₂, p₃)) = ((p₁, p₂), p₃) := rfl | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodAssoc_symm_apply | null |
prodProdProdComm : ((M₁ × M₂) × M₃ × M₄) ≃L[R] (M₁ × M₃) × M₂ × M₄ where
toLinearEquiv := LinearEquiv.prodProdProdComm R M₁ M₂ M₃ M₄
continuous_toFun := by fun_prop
continuous_invFun := by fun_prop
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodProdProdComm | The product of topological modules is four-way commutative up to continuous linear isomorphism.
This is `LinearEquiv.prodProdProdComm` prodAssoc as a continuous linear equivalence. |
prodProdProdComm_symm :
(prodProdProdComm R M₁ M₂ M₃ M₄).symm = prodProdProdComm R M₁ M₃ M₂ M₄ :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodProdProdComm_symm | null |
prodProdProdComm_toLinearEquiv :
(prodProdProdComm R M₁ M₂ M₃ M₄).toLinearEquiv = LinearEquiv.prodProdProdComm R M₁ M₂ M₃ M₄ :=
rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodProdProdComm_toLinearEquiv | null |
coe_prodProdProdComm :
(prodProdProdComm R M₁ M₂ M₃ M₄ : (M₁ × M₂) × M₃ × M₄ → (M₁ × M₃) × M₂ × M₄) =
Equiv.prodProdProdComm M₁ M₂ M₃ M₄ := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_prodProdProdComm | null |
prodProdProdComm_apply (p₁ : M₁) (p₂ : M₂) (p₃ : M₃) (p₄ : M₄) :
prodProdProdComm R M₁ M₂ M₃ M₄ ((p₁, p₂), p₃, p₄) = ((p₁, p₃), p₂, p₄) := rfl | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodProdProdComm_apply | null |
prodUnique : (M × N) ≃L[R] M where
toLinearEquiv := LinearEquiv.prodUnique
continuous_toFun := by
change Continuous (Equiv.prodUnique M N)
dsimp; fun_prop
continuous_invFun := by
change Continuous fun x ↦ (x, default)
fun_prop
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodUnique | The natural equivalence `M × N ≃L[R] M` for any `Unique` type `N`.
This is `Equiv.prodUnique` as a continuous linear equivalence. |
coe_prodUnique : (prodUnique R M N).toEquiv = Equiv.prodUnique M N := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_prodUnique | null |
prodUnique_apply (x : M × N) : prodUnique R M N x = x.1 := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodUnique_apply | null |
prodUnique_symm_apply (x : M) : (prodUnique R M N).symm x = (x, default) := rfl | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | prodUnique_symm_apply | null |
uniqueProd : (N × M) ≃L[R] M where
toLinearEquiv := LinearEquiv.uniqueProd
continuous_toFun := by
change Continuous (Equiv.uniqueProd M N)
dsimp; fun_prop
continuous_invFun := by
change Continuous fun x ↦ (default, x)
fun_prop
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | uniqueProd | The natural equivalence `N × M ≃L[R] M` for any `Unique` type `N`.
This is `Equiv.uniqueProd` as a continuous linear equivalence. |
coe_uniqueProd : (uniqueProd R M N).toEquiv = Equiv.uniqueProd M N := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_uniqueProd | null |
uniqueProd_apply (x : N × M) : uniqueProd R M N x = x.2 := rfl
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | uniqueProd_apply | null |
uniqueProd_symm_apply (x : M) : (uniqueProd R M N).symm x = (default, x) := rfl | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | uniqueProd_symm_apply | null |
protected bijective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Bijective e :=
e.toLinearEquiv.toEquiv.bijective | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | bijective | null |
protected injective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Injective e :=
e.toLinearEquiv.toEquiv.injective | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | injective | null |
protected surjective (e : M₁ ≃SL[σ₁₂] M₂) : Function.Surjective e :=
e.toLinearEquiv.toEquiv.surjective
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | surjective | null |
trans_apply (e₁ : M₁ ≃SL[σ₁₂] M₂) (e₂ : M₂ ≃SL[σ₂₃] M₃) (c : M₁) :
(e₁.trans e₂) c = e₂ (e₁ c) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | trans_apply | null |
apply_symm_apply (e : M₁ ≃SL[σ₁₂] M₂) (c : M₂) : e (e.symm c) = c :=
e.1.right_inv c
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | apply_symm_apply | null |
symm_apply_apply (e : M₁ ≃SL[σ₁₂] M₂) (b : M₁) : e.symm (e b) = b :=
e.1.left_inv b
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_apply_apply | null |
symm_trans_apply (e₁ : M₂ ≃SL[σ₂₁] M₁) (e₂ : M₃ ≃SL[σ₃₂] M₂) (c : M₁) :
(e₂.trans e₁).symm c = e₂.symm (e₁.symm c) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_trans_apply | null |
symm_image_image (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) : e.symm '' (e '' s) = s :=
e.toLinearEquiv.toEquiv.symm_image_image s
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_image_image | null |
image_symm_image (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) : e '' (e.symm '' s) = s :=
e.symm.symm_image_image s
@[simp, norm_cast] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | image_symm_image | null |
comp_coe (f : M₁ ≃SL[σ₁₂] M₂) (f' : M₂ ≃SL[σ₂₃] M₃) :
(f' : M₂ →SL[σ₂₃] M₃).comp (f : M₁ →SL[σ₁₂] M₂) = (f.trans f' : M₁ →SL[σ₁₃] M₃) :=
rfl
@[simp high] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | comp_coe | null |
coe_comp_coe_symm (e : M₁ ≃SL[σ₁₂] M₂) :
(e : M₁ →SL[σ₁₂] M₂).comp (e.symm : M₂ →SL[σ₂₁] M₁) = ContinuousLinearMap.id R₂ M₂ :=
ContinuousLinearMap.ext e.apply_symm_apply
@[simp high] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_comp_coe_symm | null |
coe_symm_comp_coe (e : M₁ ≃SL[σ₁₂] M₂) :
(e.symm : M₂ →SL[σ₂₁] M₁).comp (e : M₁ →SL[σ₁₂] M₂) = ContinuousLinearMap.id R₁ M₁ :=
ContinuousLinearMap.ext e.symm_apply_apply
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_symm_comp_coe | null |
symm_comp_self (e : M₁ ≃SL[σ₁₂] M₂) : (e.symm : M₂ → M₁) ∘ (e : M₁ → M₂) = id := by
ext x
exact symm_apply_apply e x
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_comp_self | null |
self_comp_symm (e : M₁ ≃SL[σ₁₂] M₂) : (e : M₁ → M₂) ∘ (e.symm : M₂ → M₁) = id := by
ext x
exact apply_symm_apply e x
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | self_comp_symm | null |
symm_symm (e : M₁ ≃SL[σ₁₂] M₂) : e.symm.symm = e := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_symm | null |
symm_bijective : Function.Bijective (ContinuousLinearEquiv.symm : (M₁ ≃SL[σ₁₂] M₂) → _) :=
Function.bijective_iff_has_inverse.mpr ⟨_, symm_symm, symm_symm⟩
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_bijective | null |
refl_symm : (ContinuousLinearEquiv.refl R₁ M₁).symm = ContinuousLinearEquiv.refl R₁ M₁ :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | refl_symm | null |
symm_symm_apply (e : M₁ ≃SL[σ₁₂] M₂) (x : M₁) : e.symm.symm x = e x :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_symm_apply | null |
symm_apply_eq (e : M₁ ≃SL[σ₁₂] M₂) {x y} : e.symm x = y ↔ x = e y :=
e.toLinearEquiv.symm_apply_eq | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_apply_eq | null |
eq_symm_apply (e : M₁ ≃SL[σ₁₂] M₂) {x y} : y = e.symm x ↔ e y = x :=
e.toLinearEquiv.eq_symm_apply | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | eq_symm_apply | null |
protected image_eq_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) : e '' s = e.symm ⁻¹' s :=
e.toLinearEquiv.toEquiv.image_eq_preimage s | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | image_eq_preimage | null |
protected image_symm_eq_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) :
e.symm '' s = e ⁻¹' s := by rw [e.symm.image_eq_preimage, e.symm_symm]
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | image_symm_eq_preimage | null |
protected symm_preimage_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) :
e.symm ⁻¹' (e ⁻¹' s) = s :=
e.toLinearEquiv.toEquiv.symm_preimage_preimage s
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_preimage_preimage | null |
protected preimage_symm_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) :
e ⁻¹' (e.symm ⁻¹' s) = s :=
e.symm.symm_preimage_preimage s | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | preimage_symm_preimage | null |
isUniformEmbedding {E₁ E₂ : Type*} [UniformSpace E₁] [UniformSpace E₂]
[AddCommGroup E₁] [AddCommGroup E₂] [Module R₁ E₁] [Module R₂ E₂] [IsUniformAddGroup E₁]
[IsUniformAddGroup E₂] (e : E₁ ≃SL[σ₁₂] E₂) : IsUniformEmbedding e :=
e.toLinearEquiv.toEquiv.isUniformEmbedding e.toContinuousLinearMap.uniformContinuous
e.symm.toContinuousLinearMap.uniformContinuous | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | isUniformEmbedding | null |
protected _root_.LinearEquiv.isUniformEmbedding {E₁ E₂ : Type*} [UniformSpace E₁]
[UniformSpace E₂] [AddCommGroup E₁] [AddCommGroup E₂] [Module R₁ E₁] [Module R₂ E₂]
[IsUniformAddGroup E₁] [IsUniformAddGroup E₂] (e : E₁ ≃ₛₗ[σ₁₂] E₂)
(h₁ : Continuous e) (h₂ : Continuous e.symm) : IsUniformEmbedding e :=
ContinuousLinearEquiv.isUniformEmbedding
({ e with
continuous_toFun := h₁
continuous_invFun := h₂ } :
E₁ ≃SL[σ₁₂] E₂) | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | _root_.LinearEquiv.isUniformEmbedding | null |
equivOfInverse (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ : M₂ →SL[σ₂₁] M₁) (h₁ : Function.LeftInverse f₂ f₁)
(h₂ : Function.RightInverse f₂ f₁) : M₁ ≃SL[σ₁₂] M₂ :=
{ f₁ with
continuous_toFun := f₁.continuous
invFun := f₂
continuous_invFun := f₂.continuous
left_inv := h₁
right_inv := h₂ }
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | equivOfInverse | Create a `ContinuousLinearEquiv` from two `ContinuousLinearMap`s that are
inverse of each other. See also `equivOfInverse'`. |
equivOfInverse_apply (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ h₁ h₂ x) :
equivOfInverse f₁ f₂ h₁ h₂ x = f₁ x :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | equivOfInverse_apply | null |
symm_equivOfInverse (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ h₁ h₂) :
(equivOfInverse f₁ f₂ h₁ h₂).symm = equivOfInverse f₂ f₁ h₂ h₁ :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_equivOfInverse | null |
equivOfInverse' (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ : M₂ →SL[σ₂₁] M₁)
(h₁ : f₁.comp f₂ = .id R₂ M₂) (h₂ : f₂.comp f₁ = .id R₁ M₁) : M₁ ≃SL[σ₁₂] M₂ :=
equivOfInverse f₁ f₂
(fun x ↦ by simpa using congr($(h₂) x)) (fun x ↦ by simpa using congr($(h₁) x))
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | equivOfInverse' | Create a `ContinuousLinearEquiv` from two `ContinuousLinearMap`s that are
inverse of each other, in the `ContinuousLinearMap.comp` sense. See also `equivOfInverse`. |
equivOfInverse'_apply (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ h₁ h₂ x) :
equivOfInverse' f₁ f₂ h₁ h₂ x = f₁ x :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | equivOfInverse'_apply | null |
@[simp]
symm_equivOfInverse' (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ h₁ h₂) :
(equivOfInverse' f₁ f₂ h₁ h₂).symm = equivOfInverse' f₂ f₁ h₂ h₁ :=
rfl
variable (M₁) | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_equivOfInverse' | The inverse of `equivOfInverse'` is obtained by swapping the order of its parameters. |
automorphismGroup : Group (M₁ ≃L[R₁] M₁) where
mul f g := g.trans f
one := ContinuousLinearEquiv.refl R₁ M₁
inv f := f.symm
mul_assoc f g h := by
ext
rfl
mul_one f := by
ext
rfl
one_mul f := by
ext
rfl
inv_mul_cancel f := by
ext x
exact f.left_inv x
variable {M₁} {R₄ : Type*} [Semiring R₄] [Module R₄ M₄] {σ₃₄ : R₃ →+* R₄} {σ₄₃ : R₄ →+* R₃}
[RingHomInvPair σ₃₄ σ₄₃] [RingHomInvPair σ₄₃ σ₃₄] {σ₂₄ : R₂ →+* R₄} {σ₁₄ : R₁ →+* R₄}
[RingHomCompTriple σ₂₁ σ₁₄ σ₂₄] [RingHomCompTriple σ₂₄ σ₄₃ σ₂₃] [RingHomCompTriple σ₁₃ σ₃₄ σ₁₄] | instance | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | automorphismGroup | The continuous linear equivalences from `M` to itself form a group under composition. |
ulift : ULift M₁ ≃L[R₁] M₁ :=
{ ULift.moduleEquiv with
continuous_toFun := continuous_uliftDown
continuous_invFun := continuous_uliftUp } | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | ulift | The continuous linear equivalence between `ULift M₁` and `M₁`.
This is a continuous version of `ULift.moduleEquiv`. |
@[simps]
arrowCongrEquiv (e₁₂ : M₁ ≃SL[σ₁₂] M₂) (e₄₃ : M₄ ≃SL[σ₄₃] M₃) :
(M₁ →SL[σ₁₄] M₄) ≃ (M₂ →SL[σ₂₃] M₃) where
toFun f := (e₄₃ : M₄ →SL[σ₄₃] M₃).comp (f.comp (e₁₂.symm : M₂ →SL[σ₂₁] M₁))
invFun f := (e₄₃.symm : M₃ →SL[σ₃₄] M₄).comp (f.comp (e₁₂ : M₁ →SL[σ₁₂] M₂))
left_inv f :=
ContinuousLinearMap.ext fun x => by
simp only [ContinuousLinearMap.comp_apply, symm_apply_apply, coe_coe]
right_inv f :=
ContinuousLinearMap.ext fun x => by
simp only [ContinuousLinearMap.comp_apply, apply_symm_apply, coe_coe] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | arrowCongrEquiv | A pair of continuous (semi)linear equivalences generates an equivalence between the spaces of
continuous linear maps. See also `ContinuousLinearEquiv.arrowCongr`. |
piCongrLeft (R : Type*) [Semiring R] {ι ι' : Type*}
(φ : ι → Type*) [∀ i, AddCommMonoid (φ i)] [∀ i, Module R (φ i)]
[∀ i, TopologicalSpace (φ i)]
(e : ι' ≃ ι) : ((i' : ι') → φ (e i')) ≃L[R] (i : ι) → φ i where
__ := Homeomorph.piCongrLeft e
__ := LinearEquiv.piCongrLeft R φ e | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | piCongrLeft | Combine a family of linear equivalences into a linear equivalence of `pi`-types.
This is `Equiv.piCongrLeft` as a `ContinuousLinearEquiv`. |
sumPiEquivProdPi (R : Type*) [Semiring R] (S T : Type*)
(A : S ⊕ T → Type*) [∀ st, AddCommMonoid (A st)] [∀ st, Module R (A st)]
[∀ st, TopologicalSpace (A st)] :
((st : S ⊕ T) → A st) ≃L[R] ((s : S) → A (Sum.inl s)) × ((t : T) → A (Sum.inr t)) where
__ := LinearEquiv.sumPiEquivProdPi R S T A
__ := Homeomorph.sumPiEquivProdPi S T A | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | sumPiEquivProdPi | The product over `S ⊕ T` of a family of topological modules
is isomorphic (topologically and algebraically) to the product of
(the product over `S`) and (the product over `T`).
This is `Equiv.sumPiEquivProdPi` as a `ContinuousLinearEquiv`. |
@[simps! -fullyApplied]
piUnique {α : Type*} [Unique α] (R : Type*) [Semiring R] (f : α → Type*)
[∀ x, AddCommMonoid (f x)] [∀ x, Module R (f x)] [∀ x, TopologicalSpace (f x)] :
(Π t, f t) ≃L[R] f default where
__ := LinearEquiv.piUnique R f
__ := Homeomorph.piUnique f | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | piUnique | The product `Π t : α, f t` of a family of topological modules is isomorphic
(both topologically and algebraically) to the space `f ⬝` when `α` only contains `⬝`.
This is `Equiv.piUnique` as a `ContinuousLinearEquiv`. |
piCongrRight : ((i : ι) → M i) ≃L[R₁] (i : ι) → N i :=
{ LinearEquiv.piCongrRight fun i ↦ f i with
continuous_toFun := by
exact continuous_pi fun i ↦ (f i).continuous_toFun.comp (continuous_apply i)
continuous_invFun := by
exact continuous_pi fun i => (f i).continuous_invFun.comp (continuous_apply i) }
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | piCongrRight | Combine a family of continuous linear equivalences into a continuous linear equivalence of
pi-types. |
piCongrRight_apply (m : (i : ι) → M i) (i : ι) :
piCongrRight f m i = (f i) (m i) := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | piCongrRight_apply | null |
piCongrRight_symm_apply (n : (i : ι) → N i) (i : ι) :
(piCongrRight f).symm n i = (f i).symm (n i) := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | piCongrRight_symm_apply | null |
@[simps! apply_toLinearEquiv apply_apply]
smulLeft : G →* M₁ ≃L[R₁] M₁ where
toFun g := ⟨DistribMulAction.toModuleAut _ _ g, continuous_const_smul _, continuous_const_smul _⟩
map_mul' _ _ := toLinearEquiv_injective <| map_mul (DistribMulAction.toModuleAut _ _) _ _
map_one' := toLinearEquiv_injective <| map_one <| DistribMulAction.toModuleAut _ _ | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | smulLeft | Scalar multiplication by a group element as a continuous linear equivalence. |
ofUnit (f : (M →L[R] M)ˣ) : M ≃L[R] M where
toLinearEquiv :=
{ toFun := f.val
map_add' := by simp
map_smul' := by simp
invFun := f.inv
left_inv := fun x =>
show (f.inv * f.val) x = x by
rw [f.inv_val]
simp
right_inv := fun x =>
show (f.val * f.inv) x = x by
rw [f.val_inv]
simp }
continuous_toFun := f.val.continuous
continuous_invFun := f.inv.continuous | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | ofUnit | An invertible continuous linear map `f` determines a continuous equivalence from `M` to itself. |
toUnit (f : M ≃L[R] M) : (M →L[R] M)ˣ where
val := f
inv := f.symm
val_inv := by
ext
simp
inv_val := by
ext
simp
variable (R M) | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | toUnit | A continuous equivalence from `M` to itself determines an invertible continuous linear map. |
unitsEquiv : (M →L[R] M)ˣ ≃* M ≃L[R] M where
toFun := ofUnit
invFun := toUnit
map_mul' x y := by
ext
rfl
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | unitsEquiv | The units of the algebra of continuous `R`-linear endomorphisms of `M` is multiplicatively
equivalent to the type of continuous linear equivalences between `M` and itself. |
unitsEquiv_apply (f : (M →L[R] M)ˣ) (x : M) : unitsEquiv R M f x = (f : M →L[R] M) x :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | unitsEquiv_apply | null |
unitsEquivAut : Rˣ ≃ R ≃L[R] R where
toFun u :=
equivOfInverse (ContinuousLinearMap.smulRight (1 : R →L[R] R) ↑u)
(ContinuousLinearMap.smulRight (1 : R →L[R] R) ↑u⁻¹) (fun x => by simp) fun x => by simp
invFun e :=
⟨e 1, e.symm 1, by rw [← smul_eq_mul, ← map_smul, smul_eq_mul, mul_one, symm_apply_apply], by
rw [← smul_eq_mul, ← map_smul, smul_eq_mul, mul_one, apply_symm_apply]⟩
left_inv u := Units.ext <| by simp
right_inv e := ext₁ <| by simp
variable {R}
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | unitsEquivAut | Continuous linear equivalences `R ≃L[R] R` are enumerated by `Rˣ`. |
unitsEquivAut_apply (u : Rˣ) (x : R) : unitsEquivAut R u x = x * u :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | unitsEquivAut_apply | null |
unitsEquivAut_apply_symm (u : Rˣ) (x : R) : (unitsEquivAut R u).symm x = x * ↑u⁻¹ :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | unitsEquivAut_apply_symm | null |
unitsEquivAut_symm_apply (e : R ≃L[R] R) : ↑((unitsEquivAut R).symm e) = e 1 :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | unitsEquivAut_symm_apply | null |
funUnique : (ι → M) ≃L[R] M :=
{ Homeomorph.funUnique ι M with toLinearEquiv := LinearEquiv.funUnique ι R M }
variable {ι R M}
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | funUnique | If `ι` has a unique element, then `ι → M` is continuously linear equivalent to `M`. |
coe_funUnique : ⇑(funUnique ι R M) = Function.eval default :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_funUnique | null |
coe_funUnique_symm : ⇑(funUnique ι R M).symm = Function.const ι :=
rfl
variable (R M) | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_funUnique_symm | null |
@[simps! -fullyApplied apply symm_apply]
piFinTwo (M : Fin 2 → Type*) [∀ i, AddCommMonoid (M i)] [∀ i, Module R (M i)]
[∀ i, TopologicalSpace (M i)] : ((i : _) → M i) ≃L[R] M 0 × M 1 :=
{ Homeomorph.piFinTwo M with toLinearEquiv := LinearEquiv.piFinTwo R M } | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | piFinTwo | Continuous linear equivalence between dependent functions `(i : Fin 2) → M i` and `M 0 × M 1`. |
@[simps! -fullyApplied apply symm_apply]
finTwoArrow : (Fin 2 → M) ≃L[R] M × M :=
{ piFinTwo R fun _ => M with toLinearEquiv := LinearEquiv.finTwoArrow R M } | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | finTwoArrow | Continuous linear equivalence between vectors in `M² = Fin 2 → M` and `M × M`. |
@[simps!]
_root_.Fin.consEquivL : (M 0 × Π i, M (Fin.succ i)) ≃L[R] (Π i, M i) where
__ := Fin.consLinearEquiv R M
continuous_toFun := continuous_id.fst.finCons continuous_id.snd
continuous_invFun := .prodMk (continuous_apply 0) (by continuity) | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | _root_.Fin.consEquivL | `Fin.consEquiv` as a continuous linear equivalence. |
_root_.ContinuousLinearMap.finCons
[AddCommMonoid N] [Module R N] [TopologicalSpace N]
(f : N →L[R] M 0) (fs : N →L[R] Π i, M (Fin.succ i)) :
N →L[R] Π i, M i :=
Fin.consEquivL R M ∘L f.prod fs | abbrev | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | _root_.ContinuousLinearMap.finCons | `Fin.cons` in the codomain of continuous linear maps. |
skewProd (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) : (M × M₃) ≃L[R] M₂ × M₄ :=
{ e.toLinearEquiv.skewProd e'.toLinearEquiv ↑f with
continuous_toFun :=
(e.continuous_toFun.comp continuous_fst).prodMk
((e'.continuous_toFun.comp continuous_snd).add <| f.continuous.comp continuous_fst)
continuous_invFun :=
(e.continuous_invFun.comp continuous_fst).prodMk
(e'.continuous_invFun.comp <|
continuous_snd.sub <| f.continuous.comp <| e.continuous_invFun.comp continuous_fst) }
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | skewProd | Equivalence given by a block lower diagonal matrix. `e` and `e'` are diagonal square blocks,
and `f` is a rectangular block below the diagonal. |
skewProd_apply (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) (x) :
e.skewProd e' f x = (e x.1, e' x.2 + f x.1) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | skewProd_apply | null |
skewProd_symm_apply (e : M ≃L[R] M₂) (e' : M₃ ≃L[R] M₄) (f : M →L[R] M₄) (x) :
(e.skewProd e' f).symm x = (e.symm x.1, e'.symm (x.2 - f (e.symm x.1))) :=
rfl
variable (R) in | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | skewProd_symm_apply | null |
neg [ContinuousNeg M] :
M ≃L[R] M :=
{ LinearEquiv.neg R with
continuous_toFun := continuous_neg
continuous_invFun := continuous_neg }
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | neg | The negation map as a continuous linear equivalence. |
coe_neg [ContinuousNeg M] :
(neg R : M → M) = -id := rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | coe_neg | null |
neg_apply [ContinuousNeg M] (x : M) :
neg R x = -x := by simp
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | neg_apply | null |
symm_neg [ContinuousNeg M] :
(neg R : M ≃L[R] M).symm = neg R := rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | symm_neg | null |
map_sub (e : M ≃SL[σ₁₂] M₂) (x y : M) : e (x - y) = e x - e y :=
(e : M →SL[σ₁₂] M₂).map_sub x y | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | map_sub | null |
map_neg (e : M ≃SL[σ₁₂] M₂) (x : M) : e (-x) = -e x :=
(e : M →SL[σ₁₂] M₂).map_neg x
variable [Module R M₂] [IsTopologicalAddGroup M] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | map_neg | null |
equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M) (h : Function.RightInverse f₂ f₁) :
M ≃L[R] M₂ × ker f₁ :=
equivOfInverse (f₁.prod (f₁.projKerOfRightInverse f₂ h)) (f₂.coprod (ker f₁).subtypeL)
(fun x => by simp) fun ⟨x, y⟩ => by simp [h x]
@[simp] | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | equivOfRightInverse | A pair of continuous linear maps such that `f₁ ∘ f₂ = id` generates a continuous
linear equivalence `e` between `M` and `M₂ × f₁.ker` such that `(e x).2 = x` for `x ∈ f₁.ker`,
`(e x).1 = f₁ x`, and `(e (f₂ y)).2 = 0`. The map is given by `e x = (f₁ x, x - f₂ (f₁ x))`. |
fst_equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
(h : Function.RightInverse f₂ f₁) (x : M) : (equivOfRightInverse f₁ f₂ h x).1 = f₁ x :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | fst_equivOfRightInverse | null |
snd_equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
(h : Function.RightInverse f₂ f₁) (x : M) :
((equivOfRightInverse f₁ f₂ h x).2 : M) = x - f₂ (f₁ x) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | snd_equivOfRightInverse | null |
equivOfRightInverse_symm_apply (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
(h : Function.RightInverse f₂ f₁) (y : M₂ × ker f₁) :
(equivOfRightInverse f₁ f₂ h).symm y = f₂ y.1 + y.2 :=
rfl | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | equivOfRightInverse_symm_apply | null |
IsInvertible (f : M →L[R] M₂) : Prop :=
∃ (A : M ≃L[R] M₂), A = f
open Classical in | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | IsInvertible | A continuous linear map is invertible if it is the forward direction of a continuous linear
equivalence. |
noncomputable inverse : (M →L[R] M₂) → M₂ →L[R] M := fun f =>
if h : f.IsInvertible then ((Classical.choose h).symm : M₂ →L[R] M) else 0
@[simp] lemma isInvertible_equiv {f : M ≃L[R] M₂} : IsInvertible (f : M →L[R] M₂) := ⟨f, rfl⟩ | def | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | inverse | Introduce a function `inverse` from `M →L[R] M₂` to `M₂ →L[R] M`, which sends `f` to `f.symm` if
`f` is a continuous linear equivalence and to `0` otherwise. This definition is somewhat ad hoc,
but one needs a fully (rather than partially) defined inverse function for some purposes, including
for calculus. |
@[simp]
inverse_equiv (e : M ≃L[R] M₂) : inverse (e : M →L[R] M₂) = e.symm := by
simp [inverse] | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | inverse_equiv | By definition, if `f` is invertible then `inverse f = f.symm`. |
@[simp] inverse_of_not_isInvertible
{f : M →L[R] M₂} (hf : ¬ f.IsInvertible) : f.inverse = 0 :=
dif_neg hf
@[simp] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | inverse_of_not_isInvertible | By definition, if `f` is not invertible then `inverse f = 0`. |
isInvertible_zero_iff :
IsInvertible (0 : M →L[R] M₂) ↔ Subsingleton M ∧ Subsingleton M₂ := by
refine ⟨fun ⟨e, he⟩ ↦ ?_, ?_⟩
· have A : Subsingleton M := by
refine ⟨fun x y ↦ e.injective ?_⟩
simp [he, ← ContinuousLinearEquiv.coe_coe]
exact ⟨A, e.toEquiv.symm.subsingleton⟩
· rintro ⟨hM, hM₂⟩
let e : M ≃L[R] M₂ :=
{ toFun := 0
invFun := 0
left_inv x := Subsingleton.elim _ _
right_inv x := Subsingleton.elim _ _
map_add' x y := Subsingleton.elim _ _
map_smul' c x := Subsingleton.elim _ _ }
refine ⟨e, ?_⟩
ext x
exact Subsingleton.elim _ _
@[simp] theorem inverse_zero : inverse (0 : M →L[R] M₂) = 0 := by
by_cases h : IsInvertible (0 : M →L[R] M₂)
· rcases isInvertible_zero_iff.1 h with ⟨hM, hM₂⟩
ext x
exact Subsingleton.elim _ _
· exact inverse_of_not_isInvertible h | theorem | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | isInvertible_zero_iff | null |
IsInvertible.comp {g : M₂ →L[R] M₃} {f : M →L[R] M₂}
(hg : g.IsInvertible) (hf : f.IsInvertible) : (g ∘L f).IsInvertible := by
rcases hg with ⟨N, rfl⟩
rcases hf with ⟨M, rfl⟩
exact ⟨M.trans N, rfl⟩ | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | IsInvertible.comp | null |
IsInvertible.of_inverse {f : M →L[R] M₂} {g : M₂ →L[R] M}
(hf : f ∘L g = id R M₂) (hg : g ∘L f = id R M) :
f.IsInvertible :=
⟨ContinuousLinearEquiv.equivOfInverse' _ _ hf hg, rfl⟩ | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | IsInvertible.of_inverse | null |
inverse_eq {f : M →L[R] M₂} {g : M₂ →L[R] M} (hf : f ∘L g = id R M₂) (hg : g ∘L f = id R M) :
f.inverse = g := by
have : f = ContinuousLinearEquiv.equivOfInverse' f g hf hg := rfl
rw [this, inverse_equiv]
rfl | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | inverse_eq | null |
IsInvertible.inverse_apply_eq {f : M →L[R] M₂} {x : M} {y : M₂} (hf : f.IsInvertible) :
f.inverse y = x ↔ y = f x := by
rcases hf with ⟨M, rfl⟩
simp only [inverse_equiv, ContinuousLinearEquiv.coe_coe]
exact ContinuousLinearEquiv.symm_apply_eq M
@[simp] lemma isInvertible_equiv_comp {e : M₂ ≃L[R] M₃} {f : M →L[R] M₂} :
((e : M₂ →L[R] M₃) ∘L f).IsInvertible ↔ f.IsInvertible := by
constructor
· rintro ⟨A, hA⟩
have : f = e.symm ∘L ((e : M₂ →L[R] M₃) ∘L f) := by ext; simp
rw [this, ← hA]
simp
· rintro ⟨M, rfl⟩
simp
@[simp] lemma isInvertible_comp_equiv {e : M₃ ≃L[R] M} {f : M →L[R] M₂} :
(f ∘L (e : M₃ →L[R] M)).IsInvertible ↔ f.IsInvertible := by
constructor
· rintro ⟨A, hA⟩
have : f = (f ∘L (e : M₃ →L[R] M)) ∘L e.symm := by ext; simp
rw [this, ← hA]
simp
· rintro ⟨M, rfl⟩
simp
@[simp] lemma inverse_equiv_comp {e : M₂ ≃L[R] M₃} {f : M →L[R] M₂} :
(e ∘L f).inverse = f.inverse ∘L (e.symm : M₃ →L[R] M₂) := by
by_cases hf : f.IsInvertible
· rcases hf with ⟨A, rfl⟩
simp only [ContinuousLinearEquiv.comp_coe, inverse_equiv, ContinuousLinearEquiv.coe_inj]
rfl
· rw [inverse_of_not_isInvertible (by simp [hf]), inverse_of_not_isInvertible hf, zero_comp]
@[simp] lemma inverse_comp_equiv {e : M₃ ≃L[R] M} {f : M →L[R] M₂} :
(f ∘L e).inverse = (e.symm : M →L[R] M₃) ∘L f.inverse := by
by_cases hf : f.IsInvertible
· rcases hf with ⟨A, rfl⟩
simp only [ContinuousLinearEquiv.comp_coe, inverse_equiv, ContinuousLinearEquiv.coe_inj]
rfl
· rw [inverse_of_not_isInvertible (by simp [hf]), inverse_of_not_isInvertible hf, comp_zero] | lemma | Topology | [
"Mathlib.Topology.Algebra.Module.LinearMapPiProd"
] | Mathlib/Topology/Algebra/Module/Equiv.lean | IsInvertible.inverse_apply_eq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.