File: Mathlib/Topology/Algebra/ContinuousAffineMap.lean

full_name: ContinuousAffineMap.cont
code: /-- A continuous map of affine spaces. -/
structure ContinuousAffineMap (R : Type*) {V W : Type*} (P Q : Type*) [Ring R] [AddCommGroup V]
  [Module R V] [TopologicalSpace P] [AddTorsor V P] [AddCommGroup W] [Module R W]
  [TopologicalSpace Q] [AddTorsor W Q] extends P →ᵃ[R] Q where
  cont : Continuous toFun
goal: Continuous self.toFun

full_name: ContinuousAffineMap
code: /-- A continuous map of affine spaces. -/
structure ContinuousAffineMap (R : Type*) {V W : Type*} (P Q : Type*) [Ring R] [AddCommGroup V]
  [Module R V] [TopologicalSpace P] [AddTorsor V P] [AddCommGroup W] [Module R W]
  [TopologicalSpace Q] [AddTorsor W Q] extends P →ᵃ[R] Q where
  cont : Continuous toFun
goal: Type (max (max (max u_2 u_3) u_4) u_5)

full_name: _aux_Mathlib_Topology_Algebra_ContinuousAffineMap___unexpand_ContinuousAffineMap_1
code: /-- A continuous map of affine spaces. -/
notation:25 P " →ᴬ[" R "] " Q => ContinuousAffineMap R P Q
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Topology_Algebra_ContinuousAffineMap___macroRules_term_→ᴬ[_]__1»
code: /-- A continuous map of affine spaces. -/
notation:25 P " →ᴬ[" R "] " Q => ContinuousAffineMap R P Q
goal: Lean.Macro

full_name: ContinuousAffineMap.instCoeAffineMap
code: instance : Coe (P →ᴬ[R] Q) (P →ᵃ[R] Q) 
goal: Coe (P →ᴬ[R] Q) (P →ᵃ[R] Q)

full_name: ContinuousAffineMap.to_affineMap_injective
code: theorem to_affineMap_injective {f g : P →ᴬ[R] Q} (h : (f : P →ᵃ[R] Q) = (g : P →ᵃ[R] Q)) :
    f = g 
goal: f = g

full_name: ContinuousAffineMap.instFunLike
code: instance : FunLike (P →ᴬ[R] Q) P Q 
goal: FunLike (P →ᴬ[R] Q) P Q

full_name: ContinuousAffineMap.instContinuousMapClass
code: instance : ContinuousMapClass (P →ᴬ[R] Q) P Q 
goal: ContinuousMapClass (P →ᴬ[R] Q) P Q

full_name: ContinuousAffineMap.toFun_eq_coe
code: theorem toFun_eq_coe (f : P →ᴬ[R] Q) : f.toFun = ⇑f 
goal: f.toFun = ⇑f

full_name: ContinuousAffineMap.coe_injective
code: theorem coe_injective : @Function.Injective (P →ᴬ[R] Q) (P → Q) (⇑) 
goal: Function.Injective DFunLike.coe

full_name: ContinuousAffineMap.ext
code: @[ext]
theorem ext {f g : P →ᴬ[R] Q} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: ContinuousAffineMap.ext_iff
code: theorem ext_iff {f g : P →ᴬ[R] Q} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : P), f x = g x

full_name: ContinuousAffineMap.congr_fun
code: theorem congr_fun {f g : P →ᴬ[R] Q} (h : f = g) (x : P) : f x = g x 
goal: f x = g x

full_name: ContinuousAffineMap.toContinuousMap
code: /-- Forgetting its algebraic properties, a continuous affine map is a continuous map. -/
def toContinuousMap (f : P →ᴬ[R] Q) : C(P, Q) 
goal: C(P, Q)

full_name: ContinuousAffineMap.instCoeHeadContinuousMap
code: instance : CoeHead (P →ᴬ[R] Q) C(P, Q) 
goal: CoeHead (P →ᴬ[R] Q) C(P, Q)

full_name: ContinuousAffineMap.toContinuousMap_coe
code: @[simp]
theorem toContinuousMap_coe (f : P →ᴬ[R] Q) : f.toContinuousMap = ↑f 
goal: f.toContinuousMap = ↑f

full_name: ContinuousAffineMap.coe_to_affineMap
code: @[simp] -- Porting note: removed `norm_cast`
theorem coe_to_affineMap (f : P →ᴬ[R] Q) : ((f : P →ᵃ[R] Q) : P → Q) = f 
goal: ⇑f.toAffineMap = ⇑f

full_name: ContinuousAffineMap.coe_to_continuousMap
code: theorem coe_to_continuousMap (f : P →ᴬ[R] Q) : ((f : C(P, Q)) : P → Q) = f 
goal: ⇑↑f = ⇑f

full_name: ContinuousAffineMap.to_continuousMap_injective
code: theorem to_continuousMap_injective {f g : P →ᴬ[R] Q} (h : (f : C(P, Q)) = (g : C(P, Q))) :
    f = g 
goal: f = g

full_name: ContinuousAffineMap.coe_affineMap_mk
code: theorem coe_affineMap_mk (f : P →ᵃ[R] Q) (h) : ((⟨f, h⟩ : P →ᴬ[R] Q) : P →ᵃ[R] Q) = f 
goal: { toAffineMap := f, cont := h }.toAffineMap = f

full_name: ContinuousAffineMap.coe_continuousMap_mk
code: @[norm_cast]
theorem coe_continuousMap_mk (f : P →ᵃ[R] Q) (h) : ((⟨f, h⟩ : P →ᴬ[R] Q) : C(P, Q)) = ⟨f, h⟩ 
goal: ↑{ toAffineMap := f, cont := h } = { toFun := ⇑f, continuous_toFun := h }

full_name: ContinuousAffineMap.coe_mk
code: @[simp]
theorem coe_mk (f : P →ᵃ[R] Q) (h) : ((⟨f, h⟩ : P →ᴬ[R] Q) : P → Q) = f 
goal: ⇑{ toAffineMap := f, cont := h } = ⇑f

full_name: ContinuousAffineMap.mk_coe
code: @[simp]
theorem mk_coe (f : P →ᴬ[R] Q) (h) : (⟨(f : P →ᵃ[R] Q), h⟩ : P →ᴬ[R] Q) = f 
goal: { toAffineMap := f.toAffineMap, cont := h } = f

full_name: ContinuousAffineMap.continuous
code: @[continuity]
protected theorem continuous (f : P →ᴬ[R] Q) : Continuous f 
goal: Continuous ⇑f

full_name: ContinuousAffineMap.const
code: /-- The constant map is a continuous affine map. -/
def const (q : Q) : P →ᴬ[R] Q 
goal: P →ᴬ[R] Q

full_name: ContinuousAffineMap.coe_const
code: @[simp]
theorem coe_const (q : Q) : (const R P q : P → Q) = Function.const P q 
goal: ⇑(ContinuousAffineMap.const R P q) = Function.const P q

full_name: ContinuousAffineMap.instInhabited
code: noncomputable instance : Inhabited (P →ᴬ[R] Q) 
goal: Inhabited (P →ᴬ[R] Q)

full_name: ContinuousAffineMap.comp
code: /-- The composition of morphisms is a morphism. -/
def comp (f : Q →ᴬ[R] Q₂) (g : P →ᴬ[R] Q) : P →ᴬ[R] Q₂ 
goal: P →ᴬ[R] Q₂

full_name: ContinuousAffineMap.coe_comp
code: @[simp, norm_cast]
theorem coe_comp (f : Q →ᴬ[R] Q₂) (g : P →ᴬ[R] Q) :
    (f.comp g : P → Q₂) = (f : Q → Q₂) ∘ (g : P → Q) 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: ContinuousAffineMap.comp_apply
code: theorem comp_apply (f : Q →ᴬ[R] Q₂) (g : P →ᴬ[R] Q) (x : P) : f.comp g x = f (g x) 
goal: (f.comp g) x = f (g x)

full_name: ContinuousAffineMap.instZero
code: instance : Zero (P →ᴬ[R] W) 
goal: Zero (P →ᴬ[R] W)

full_name: ContinuousAffineMap.coe_zero
code: @[norm_cast, simp]
theorem coe_zero : ((0 : P →ᴬ[R] W) : P → W) = 0 
goal: ⇑0 = 0

full_name: ContinuousAffineMap.zero_apply
code: theorem zero_apply (x : P) : (0 : P →ᴬ[R] W) x = 0 
goal: 0 x = 0

full_name: ContinuousAffineMap.instSMul
code: instance : SMul S (P →ᴬ[R] W) 
goal: SMul S (P →ᴬ[R] W)

full_name: ContinuousAffineMap.coe_smul
code: @[norm_cast, simp]
theorem coe_smul (t : S) (f : P →ᴬ[R] W) : ⇑(t • f) = t • ⇑f 
goal: ⇑(t • f) = t • ⇑f

full_name: ContinuousAffineMap.smul_apply
code: theorem smul_apply (t : S) (f : P →ᴬ[R] W) (x : P) : (t • f) x = t • f x 
goal: (t • f) x = t • f x

full_name: ContinuousAffineMap.instIsCentralScalar
code: instance [DistribMulAction Sᵐᵒᵖ W] [IsCentralScalar S W] : IsCentralScalar S (P →ᴬ[R] W) 
goal: IsCentralScalar S (P →ᴬ[R] W)

full_name: ContinuousAffineMap.instMulAction
code: instance : MulAction S (P →ᴬ[R] W) 
goal: MulAction S (P →ᴬ[R] W)

full_name: ContinuousAffineMap.instAdd
code: instance : Add (P →ᴬ[R] W) 
goal: Add (P →ᴬ[R] W)

full_name: ContinuousAffineMap.coe_add
code: @[norm_cast, simp]
theorem coe_add (f g : P →ᴬ[R] W) : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: ContinuousAffineMap.add_apply
code: theorem add_apply (f g : P →ᴬ[R] W) (x : P) : (f + g) x = f x + g x 
goal: (f + g) x = f x + g x

full_name: ContinuousAffineMap.instSub
code: instance : Sub (P →ᴬ[R] W) 
goal: Sub (P →ᴬ[R] W)

full_name: ContinuousAffineMap.coe_sub
code: @[norm_cast, simp]
theorem coe_sub (f g : P →ᴬ[R] W) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: ContinuousAffineMap.sub_apply
code: theorem sub_apply (f g : P →ᴬ[R] W) (x : P) : (f - g) x = f x - g x 
goal: (f - g) x = f x - g x

full_name: ContinuousAffineMap.instNeg
code: instance : Neg (P →ᴬ[R] W) 
goal: Neg (P →ᴬ[R] W)

full_name: ContinuousAffineMap.coe_neg
code: @[norm_cast, simp]
theorem coe_neg (f : P →ᴬ[R] W) : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: ContinuousAffineMap.neg_apply
code: theorem neg_apply (f : P →ᴬ[R] W) (x : P) : (-f) x = -f x 
goal: (-f) x = -f x

full_name: ContinuousAffineMap.instAddCommGroup
code: instance : AddCommGroup (P →ᴬ[R] W) 
goal: AddCommGroup (P →ᴬ[R] W)

full_name: ContinuousAffineMap.instDistribMulActionOfSMulCommClassOfContinuousConstSMul
code: instance [Monoid S] [DistribMulAction S W] [SMulCommClass R S W] [ContinuousConstSMul S W] :
    DistribMulAction S (P →ᴬ[R] W) 
goal: DistribMulAction S (P →ᴬ[R] W)

full_name: ContinuousAffineMap.instModuleOfSMulCommClassOfContinuousConstSMul
code: instance [Semiring S] [Module S W] [SMulCommClass R S W] [ContinuousConstSMul S W] :
    Module S (P →ᴬ[R] W) 
goal: Module S (P →ᴬ[R] W)

full_name: ContinuousLinearMap.toContinuousAffineMap
code: /-- A continuous linear map can be regarded as a continuous affine map. -/
def toContinuousAffineMap (f : V →L[R] W) : V →ᴬ[R] W 
goal: V →ᴬ[R] W

full_name: ContinuousLinearMap.coe_toContinuousAffineMap
code: @[simp]
theorem coe_toContinuousAffineMap (f : V →L[R] W) : ⇑f.toContinuousAffineMap = f 
goal: ⇑f.toContinuousAffineMap = ⇑f

full_name: ContinuousLinearMap.toContinuousAffineMap_map_zero
code: @[simp]
theorem toContinuousAffineMap_map_zero (f : V →L[R] W) : f.toContinuousAffineMap 0 = 0 
goal: f.toContinuousAffineMap 0 = 0