File: Mathlib/LinearAlgebra/AffineSpace/ContinuousAffineEquiv.lean

full_name: ContinuousAffineEquiv.continuous_toFun
code: /-- A continuous affine equivalence, denoted `P₁ ≃ᵃL[k] P₂`, between two affine topological spaces
is an affine equivalence such that forward and inverse maps are continuous. -/
structure ContinuousAffineEquiv (k P₁ P₂ : Type*) {V₁ V₂ : Type*} [Ring k]
    [AddCommGroup V₁] [Module k V₁] [AddTorsor V₁ P₁] [TopologicalSpace P₁]
    [AddCommGroup V₂] [Module k V₂] [AddTorsor V₂ P₂] [TopologicalSpace P₂]
    extends P₁ ≃ᵃ[k] P₂ where
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous (↑self).toFun

full_name: ContinuousAffineEquiv
code: /-- A continuous affine equivalence, denoted `P₁ ≃ᵃL[k] P₂`, between two affine topological spaces
is an affine equivalence such that forward and inverse maps are continuous. -/
structure ContinuousAffineEquiv (k P₁ P₂ : Type*) {V₁ V₂ : Type*} [Ring k]
    [AddCommGroup V₁] [Module k V₁] [AddTorsor V₁ P₁] [TopologicalSpace P₁]
    [AddCommGroup V₂] [Module k V₂] [AddTorsor V₂ P₂] [TopologicalSpace P₂]
    extends P₁ ≃ᵃ[k] P₂ where
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Type (max (max (max u_2 u_3) u_4) u_5)

full_name: ContinuousAffineEquiv.continuous_invFun
code: /-- A continuous affine equivalence, denoted `P₁ ≃ᵃL[k] P₂`, between two affine topological spaces
is an affine equivalence such that forward and inverse maps are continuous. -/
structure ContinuousAffineEquiv (k P₁ P₂ : Type*) {V₁ V₂ : Type*} [Ring k]
    [AddCommGroup V₁] [Module k V₁] [AddTorsor V₁ P₁] [TopologicalSpace P₁]
    [AddCommGroup V₂] [Module k V₂] [AddTorsor V₂ P₂] [TopologicalSpace P₂]
    extends P₁ ≃ᵃ[k] P₂ where
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous (↑self).invFun

full_name: _aux_Mathlib_LinearAlgebra_AffineSpace_ContinuousAffineEquiv___unexpand_ContinuousAffineEquiv_1
code: @[inherit_doc]
notation:25 P₁ " ≃ᵃL[" k:25 "] " P₂:0 => ContinuousAffineEquiv k P₁ P₂
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_LinearAlgebra_AffineSpace_ContinuousAffineEquiv___macroRules_term_≃ᵃL[_]__1»
code: @[inherit_doc]
notation:25 P₁ " ≃ᵃL[" k:25 "] " P₂:0 => ContinuousAffineEquiv k P₁ P₂
goal: Lean.Macro

full_name: ContinuousAffineEquiv.toHomeomorph
code: /-- A continuous affine equivalence is a homeomorphism. -/
def toHomeomorph (e : P₁ ≃ᵃL[k] P₂) : P₁ ≃ₜ P₂ 
goal: P₁ ≃ₜ P₂

full_name: ContinuousAffineEquiv.toAffineEquiv_injective
code: theorem toAffineEquiv_injective : Injective (toAffineEquiv : (P₁ ≃ᵃL[k] P₂) → P₁ ≃ᵃ[k] P₂) 
goal: Function.Injective ContinuousAffineEquiv.toAffineEquiv

full_name: ContinuousAffineEquiv.instEquivLike
code: instance instEquivLike : EquivLike (P₁ ≃ᵃL[k] P₂) P₁ P₂ 
goal: EquivLike (P₁ ≃ᵃL[k] P₂) P₁ P₂

full_name: ContinuousAffineEquiv.instCoeFunForall
code: instance : CoeFun (P₁ ≃ᵃL[k] P₂) fun _ ↦ P₁ → P₂ 
goal: CoeFun (P₁ ≃ᵃL[k] P₂) fun x => P₁ → P₂

full_name: ContinuousAffineEquiv.coe
code: /-- Coerce continuous affine equivalences to affine equivalences. -/
instance coe : Coe (P₁ ≃ᵃL[k] P₂) (P₁ ≃ᵃ[k] P₂) 
goal: Coe (P₁ ≃ᵃL[k] P₂) (P₁ ≃ᵃ[k] P₂)

full_name: ContinuousAffineEquiv.coe_injective
code: theorem coe_injective : Function.Injective ((↑) : (P₁ ≃ᵃL[k] P₂) → P₁ ≃ᵃ[k] P₂) 
goal: Function.Injective ContinuousAffineEquiv.toAffineEquiv

full_name: ContinuousAffineEquiv.instFunLike
code: instance instFunLike : FunLike (P₁ ≃ᵃL[k] P₂) P₁ P₂ 
goal: FunLike (P₁ ≃ᵃL[k] P₂) P₁ P₂

full_name: ContinuousAffineEquiv.coe_coe
code: @[simp, norm_cast]
theorem coe_coe (e : P₁ ≃ᵃL[k] P₂) : ⇑(e : P₁ ≃ᵃ[k] P₂) = e 
goal: ⇑↑e = ⇑e

full_name: ContinuousAffineEquiv.coe_toEquiv
code: @[simp]
theorem coe_toEquiv (e : P₁ ≃ᵃL[k] P₂) : ⇑e.toEquiv = e 
goal: ⇑(↑e).toEquiv = ⇑e

full_name: ContinuousAffineEquiv.Simps.apply
code: /-- See Note [custom simps projection].
  We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (e : P₁ ≃ᵃL[k] P₂) : P₁ → P₂ 
goal: P₁ → P₂

full_name: ContinuousAffineEquiv.Simps.coe
code: /-- See Note [custom simps projection]. -/
def Simps.coe (e : P₁ ≃ᵃL[k] P₂) : P₁ ≃ᵃ[k] P₂ 
goal: P₁ ≃ᵃ[k] P₂

full_name: ContinuousAffineEquiv.ext
code: @[ext]
theorem ext {e e' : P₁ ≃ᵃL[k] P₂} (h : ∀ x, e x = e' x) : e = e' 
goal: e = e'

full_name: ContinuousAffineEquiv.ext_iff
code: theorem ext_iff {e e' : P₁ ≃ᵃL[k] P₂} : e = e' ↔ ∀ x, e x = e' x 
goal: e = e' ↔ ∀ (x : P₁), e x = e' x

full_name: ContinuousAffineEquiv.continuous
code: @[continuity]
protected theorem continuous (e : P₁ ≃ᵃL[k] P₂) : Continuous e 
goal: Continuous ⇑e

full_name: ContinuousAffineEquiv.refl
code: /-- Identity map as a `ContinuousAffineEquiv`. -/
def refl : P₁ ≃ᵃL[k] P₁ 
goal: P₁ ≃ᵃL[k] P₁

full_name: ContinuousAffineEquiv.coe_refl
code: @[simp]
theorem coe_refl : ⇑(refl k P₁) = id 
goal: ⇑(ContinuousAffineEquiv.refl k P₁) = id

full_name: ContinuousAffineEquiv.refl_apply
code: @[simp]
theorem refl_apply (x : P₁) : refl k P₁ x = x 
goal: (ContinuousAffineEquiv.refl k P₁) x = x

full_name: ContinuousAffineEquiv.toAffineEquiv_refl
code: @[simp]
theorem toAffineEquiv_refl : (refl k P₁).toAffineEquiv = AffineEquiv.refl k P₁ 
goal: ↑(ContinuousAffineEquiv.refl k P₁) = AffineEquiv.refl k P₁

full_name: ContinuousAffineEquiv.toEquiv_refl
code: @[simp]
theorem toEquiv_refl : (refl k P₁).toEquiv = Equiv.refl P₁ 
goal: (↑(ContinuousAffineEquiv.refl k P₁)).toEquiv = Equiv.refl P₁

full_name: ContinuousAffineEquiv.symm
code: /-- Inverse of a continuous affine equivalence as a continuous affine equivalence. -/
@[symm]
def symm (e : P₁ ≃ᵃL[k] P₂) : P₂ ≃ᵃL[k] P₁ 
goal: P₂ ≃ᵃL[k] P₁

full_name: ContinuousAffineEquiv.symm_toAffineEquiv
code: @[simp]
theorem symm_toAffineEquiv (e : P₁ ≃ᵃL[k] P₂) : e.toAffineEquiv.symm = e.symm.toAffineEquiv 
goal: (↑e).symm = ↑e.symm

full_name: ContinuousAffineEquiv.symm_toEquiv
code: @[simp]
theorem symm_toEquiv (e : P₁ ≃ᵃL[k] P₂) : e.toEquiv.symm = e.symm.toEquiv 
goal: (↑e).symm = (↑e.symm).toEquiv

full_name: ContinuousAffineEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : P₁ ≃ᵃL[k] P₂) (p : P₂) : e (e.symm p) = p 
goal: e (e.symm p) = p

full_name: ContinuousAffineEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : P₁ ≃ᵃL[k] P₂) (p : P₁) : e.symm (e p) = p 
goal: e.symm (e p) = p

full_name: ContinuousAffineEquiv.apply_eq_iff_eq_symm_apply
code: theorem apply_eq_iff_eq_symm_apply (e : P₁ ≃ᵃL[k] P₂) {p₁ p₂} : e p₁ = p₂ ↔ p₁ = e.symm p₂ 
goal: e p₁ = p₂ ↔ p₁ = e.symm p₂

full_name: ContinuousAffineEquiv.apply_eq_iff_eq
code: theorem apply_eq_iff_eq (e : P₁ ≃ᵃL[k] P₂) {p₁ p₂ : P₁} : e p₁ = e p₂ ↔ p₁ = p₂ 
goal: e p₁ = e p₂ ↔ p₁ = p₂

full_name: ContinuousAffineEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : P₁ ≃ᵃL[k] P₂) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: ContinuousAffineEquiv.symm_symm_apply
code: theorem symm_symm_apply (e : P₁ ≃ᵃL[k] P₂) (x : P₁) : e.symm.symm x = e x 
goal: e.symm.symm x = e x

full_name: ContinuousAffineEquiv.symm_apply_eq
code: theorem symm_apply_eq (e : P₁ ≃ᵃL[k] P₂)  {x y} : e.symm x = y ↔ x = e y 
goal: e.symm x = y ↔ x = e y

full_name: ContinuousAffineEquiv.eq_symm_apply
code: theorem eq_symm_apply (e : P₁ ≃ᵃL[k] P₂) {x y} : y = e.symm x ↔ e y = x 
goal: y = e.symm x ↔ e y = x

full_name: ContinuousAffineEquiv.image_symm
code: @[simp]
theorem image_symm (f : P₁ ≃ᵃL[k] P₂) (s : Set P₂) : f.symm '' s = f ⁻¹' s 
goal: ⇑f.symm '' s = ⇑f ⁻¹' s

full_name: ContinuousAffineEquiv.preimage_symm
code: @[simp]
theorem preimage_symm (f : P₁ ≃ᵃL[k] P₂) (s : Set P₁) : f.symm ⁻¹' s = f '' s 
goal: ⇑f.symm ⁻¹' s = ⇑f '' s

full_name: ContinuousAffineEquiv.bijective
code: protected theorem bijective (e : P₁ ≃ᵃL[k] P₂) : Bijective e 
goal: Function.Bijective ⇑e

full_name: ContinuousAffineEquiv.surjective
code: protected theorem surjective (e : P₁ ≃ᵃL[k] P₂) : Surjective e 
goal: Function.Surjective ⇑e

full_name: ContinuousAffineEquiv.injective
code: protected theorem injective (e : P₁ ≃ᵃL[k] P₂) : Injective e 
goal: Function.Injective ⇑e

full_name: ContinuousAffineEquiv.image_eq_preimage
code: protected theorem image_eq_preimage (e : P₁ ≃ᵃL[k] P₂) (s : Set P₁) : e '' s = e.symm ⁻¹' s 
goal: ⇑e '' s = ⇑e.symm ⁻¹' s

full_name: ContinuousAffineEquiv.image_symm_eq_preimage
code: protected theorem image_symm_eq_preimage (e : P₁ ≃ᵃL[k] P₂) (s : Set P₂) :
    e.symm '' s = e ⁻¹' s 
goal: ⇑e.symm '' s = ⇑e ⁻¹' s

full_name: ContinuousAffineEquiv.image_preimage
code: @[simp]
theorem image_preimage (e : P₁ ≃ᵃL[k] P₂) (s : Set P₂) : e '' (e ⁻¹' s) = s 
goal: ⇑e '' (⇑e ⁻¹' s) = s

full_name: ContinuousAffineEquiv.preimage_image
code: @[simp]
theorem preimage_image (e : P₁ ≃ᵃL[k] P₂) (s : Set P₁) : e ⁻¹' (e '' s) = s 
goal: ⇑e ⁻¹' (⇑e '' s) = s

full_name: ContinuousAffineEquiv.symm_image_image
code: theorem symm_image_image (e : P₁ ≃ᵃL[k] P₂) (s : Set P₁) : e.symm '' (e '' s) = s 
goal: ⇑e.symm '' (⇑e '' s) = s

full_name: ContinuousAffineEquiv.image_symm_image
code: theorem image_symm_image (e : P₁ ≃ᵃL[k] P₂) (s : Set P₂) : e '' (e.symm '' s) = s 
goal: ⇑e '' (⇑e.symm '' s) = s

full_name: ContinuousAffineEquiv.refl_symm
code: @[simp]
theorem refl_symm : (refl k P₁).symm = refl k P₁ 
goal: (ContinuousAffineEquiv.refl k P₁).symm = ContinuousAffineEquiv.refl k P₁

full_name: ContinuousAffineEquiv.symm_refl
code: @[simp]
theorem symm_refl : (refl k P₁).symm = refl k P₁ 
goal: (ContinuousAffineEquiv.refl k P₁).symm = ContinuousAffineEquiv.refl k P₁

full_name: ContinuousAffineEquiv.trans
code: /-- Composition of two `ContinuousAffineEquiv`alences, applied left to right. -/
@[trans]
def trans (e : P₁ ≃ᵃL[k] P₂) (e' : P₂ ≃ᵃL[k] P₃) : P₁ ≃ᵃL[k] P₃ 
goal: P₁ ≃ᵃL[k] P₃

full_name: ContinuousAffineEquiv.coe_trans
code: @[simp]
theorem coe_trans (e : P₁ ≃ᵃL[k] P₂) (e' : P₂ ≃ᵃL[k] P₃) : ⇑(e.trans e') = e' ∘ e 
goal: ⇑(e.trans e') = ⇑e' ∘ ⇑e

full_name: ContinuousAffineEquiv.trans_apply
code: @[simp]
theorem trans_apply (e : P₁ ≃ᵃL[k] P₂) (e' : P₂ ≃ᵃL[k] P₃) (p : P₁) : e.trans e' p = e' (e p) 
goal: (e.trans e') p = e' (e p)

full_name: ContinuousAffineEquiv.trans_assoc
code: theorem trans_assoc (e₁ : P₁ ≃ᵃL[k] P₂) (e₂ : P₂ ≃ᵃL[k] P₃) (e₃ : P₃ ≃ᵃL[k] P₄) :
    (e₁.trans e₂).trans e₃ = e₁.trans (e₂.trans e₃) 
goal: (e₁.trans e₂).trans e₃ = e₁.trans (e₂.trans e₃)

full_name: ContinuousAffineEquiv.trans_refl
code: @[simp]
theorem trans_refl (e : P₁ ≃ᵃL[k] P₂) : e.trans (refl k P₂) = e 
goal: e.trans (ContinuousAffineEquiv.refl k P₂) = e

full_name: ContinuousAffineEquiv.refl_trans
code: @[simp]
theorem refl_trans (e : P₁ ≃ᵃL[k] P₂) : (refl k P₁).trans e = e 
goal: (ContinuousAffineEquiv.refl k P₁).trans e = e

full_name: ContinuousAffineEquiv.self_trans_symm
code: @[simp]
theorem self_trans_symm (e : P₁ ≃ᵃL[k] P₂) : e.trans e.symm = refl k P₁ 
goal: e.trans e.symm = ContinuousAffineEquiv.refl k P₁

full_name: ContinuousAffineEquiv.symm_trans_self
code: @[simp]
theorem symm_trans_self (e : P₁ ≃ᵃL[k] P₂) : e.symm.trans e = refl k P₂ 
goal: e.symm.trans e = ContinuousAffineEquiv.refl k P₂

full_name: ContinuousLinearEquiv.toContinuousAffineEquiv
code: /-- Reinterpret a continuous linear equivalence between modules
as a continuous affine equivalence. -/
def _root_.ContinuousLinearEquiv.toContinuousAffineEquiv (L : E ≃L[k] F) : E ≃ᵃL[k] F 
goal: E ≃ᵃL[k] F

full_name: ContinuousLinearEquiv.coe_toContinuousAffineEquiv
code: @[simp]
theorem _root_.ContinuousLinearEquiv.coe_toContinuousAffineEquiv (e : E ≃L[k] F) :
    ⇑e.toContinuousAffineEquiv = e 
goal: ⇑e.toContinuousAffineEquiv = ⇑e

full_name: ContinuousAffineEquiv.constVAdd
code: /-- The map `p ↦ v +ᵥ p` as a continuous affine automorphism of an affine space
  on which addition is continuous. -/
def constVAdd [ContinuousConstVAdd V₁ P₁] (v : V₁) : P₁ ≃ᵃL[k] P₁ 
goal: P₁ ≃ᵃL[k] P₁

full_name: ContinuousAffineEquiv.constVAdd_coe
code: lemma constVAdd_coe [ContinuousConstVAdd V₁ P₁] (v : V₁) :
    (constVAdd k P₁ v).toAffineEquiv = .constVAdd k P₁ v 
goal: ↑(ContinuousAffineEquiv.constVAdd k P₁ v) = AffineEquiv.constVAdd k P₁ v