File: Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean

full_name: AffineEquiv.map_vadd'
code: /-- An affine equivalence, denoted `P₁ ≃ᵃ[k] P₂`, is an equivalence between affine spaces
such that both forward and inverse maps are affine.

We define it using an `Equiv` for the map and a `LinearEquiv` for the linear part in order
to allow affine equivalences with good definitional equalities. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure AffineEquiv (k P₁ P₂ : Type*) {V₁ V₂ : Type*} [Ring k] [AddCommGroup V₁] [Module k V₁]
  [AddTorsor V₁ P₁] [AddCommGroup V₂] [Module k V₂] [AddTorsor V₂ P₂] extends P₁ ≃ P₂ where
  linear : V₁ ≃ₗ[k] V₂
  map_vadd' : ∀ (p : P₁) (v : V₁), toEquiv (v +ᵥ p) = linear v +ᵥ toEquiv p
goal: self.toEquiv (v +ᵥ p) = self.linear v +ᵥ self.toEquiv p

full_name: AffineEquiv
code: /-- An affine equivalence, denoted `P₁ ≃ᵃ[k] P₂`, is an equivalence between affine spaces
such that both forward and inverse maps are affine.

We define it using an `Equiv` for the map and a `LinearEquiv` for the linear part in order
to allow affine equivalences with good definitional equalities. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure AffineEquiv (k P₁ P₂ : Type*) {V₁ V₂ : Type*} [Ring k] [AddCommGroup V₁] [Module k V₁]
  [AddTorsor V₁ P₁] [AddCommGroup V₂] [Module k V₂] [AddTorsor V₂ P₂] extends P₁ ≃ P₂ where
  linear : V₁ ≃ₗ[k] V₂
  map_vadd' : ∀ (p : P₁) (v : V₁), toEquiv (v +ᵥ p) = linear v +ᵥ toEquiv p
goal: Type (max (max (max u_2 u_3) u_4) u_5)

full_name: AffineEquiv.linear
code: /-- An affine equivalence, denoted `P₁ ≃ᵃ[k] P₂`, is an equivalence between affine spaces
such that both forward and inverse maps are affine.

We define it using an `Equiv` for the map and a `LinearEquiv` for the linear part in order
to allow affine equivalences with good definitional equalities. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure AffineEquiv (k P₁ P₂ : Type*) {V₁ V₂ : Type*} [Ring k] [AddCommGroup V₁] [Module k V₁]
  [AddTorsor V₁ P₁] [AddCommGroup V₂] [Module k V₂] [AddTorsor V₂ P₂] extends P₁ ≃ P₂ where
  linear : V₁ ≃ₗ[k] V₂
  map_vadd' : ∀ (p : P₁) (v : V₁), toEquiv (v +ᵥ p) = linear v +ᵥ toEquiv p
goal: V₁ ≃ₗ[k] V₂

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

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

full_name: AffineEquiv.toAffineMap
code: /-- Reinterpret an `AffineEquiv` as an `AffineMap`. -/
@[coe]
def toAffineMap (e : P₁ ≃ᵃ[k] P₂) : P₁ →ᵃ[k] P₂ 
goal: P₁ →ᵃ[k] P₂

full_name: AffineEquiv.toAffineMap_mk
code: @[simp]
theorem toAffineMap_mk (f : P₁ ≃ P₂) (f' : V₁ ≃ₗ[k] V₂) (h) :
    toAffineMap (mk f f' h) = ⟨f, f', h⟩ 
goal: ↑{ toEquiv := f, linear := f', map_vadd' := h } = { toFun := ⇑f, linear := ↑f', map_vadd' := h }

full_name: AffineEquiv.linear_toAffineMap
code: @[simp]
theorem linear_toAffineMap (e : P₁ ≃ᵃ[k] P₂) : e.toAffineMap.linear = e.linear 
goal: (↑e).linear = ↑e.linear

full_name: AffineEquiv.toAffineMap_injective
code: theorem toAffineMap_injective : Injective (toAffineMap : (P₁ ≃ᵃ[k] P₂) → P₁ →ᵃ[k] P₂) 
goal: Function.Injective AffineEquiv.toAffineMap

full_name: AffineEquiv.toAffineMap_inj
code: @[simp]
theorem toAffineMap_inj {e e' : P₁ ≃ᵃ[k] P₂} : e.toAffineMap = e'.toAffineMap ↔ e = e' 
goal: ↑e = ↑e' ↔ e = e'

full_name: AffineEquiv.equivLike
code: instance equivLike : EquivLike (P₁ ≃ᵃ[k] P₂) P₁ P₂ 
goal: EquivLike (P₁ ≃ᵃ[k] P₂) P₁ P₂

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

full_name: AffineEquiv.instCoeOutEquiv
code: instance : CoeOut (P₁ ≃ᵃ[k] P₂) (P₁ ≃ P₂) 
goal: CoeOut (P₁ ≃ᵃ[k] P₂) (P₁ ≃ P₂)

full_name: AffineEquiv.map_vadd
code: @[simp]
theorem map_vadd (e : P₁ ≃ᵃ[k] P₂) (p : P₁) (v : V₁) : e (v +ᵥ p) = e.linear v +ᵥ e p 
goal: e (v +ᵥ p) = e.linear v +ᵥ e p

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

full_name: AffineEquiv.instCoeAffineMap
code: instance : Coe (P₁ ≃ᵃ[k] P₂) (P₁ →ᵃ[k] P₂) 
goal: Coe (P₁ ≃ᵃ[k] P₂) (P₁ →ᵃ[k] P₂)

full_name: AffineEquiv.coe_toAffineMap
code: @[simp]
theorem coe_toAffineMap (e : P₁ ≃ᵃ[k] P₂) : (e.toAffineMap : P₁ → P₂) = (e : P₁ → P₂) 
goal: ⇑↑e = ⇑e

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

full_name: AffineEquiv.coe_linear
code: @[simp]
theorem coe_linear (e : P₁ ≃ᵃ[k] P₂) : (e : P₁ →ᵃ[k] P₂).linear = e.linear 
goal: (↑e).linear = ↑e.linear

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

full_name: AffineEquiv.coeFn_injective
code: theorem coeFn_injective : @Injective (P₁ ≃ᵃ[k] P₂) (P₁ → P₂) (⇑) 
goal: Function.Injective DFunLike.coe

full_name: AffineEquiv.coeFn_inj
code: @[norm_cast]
-- Porting note: removed `simp`: proof is `simp only [DFunLike.coe_fn_eq]`
theorem coeFn_inj {e e' : P₁ ≃ᵃ[k] P₂} : (e : P₁ → P₂) = e' ↔ e = e' 
goal: ⇑e = ⇑e' ↔ e = e'

full_name: AffineEquiv.toEquiv_injective
code: theorem toEquiv_injective : Injective (toEquiv : (P₁ ≃ᵃ[k] P₂) → P₁ ≃ P₂) 
goal: Function.Injective AffineEquiv.toEquiv

full_name: AffineEquiv.toEquiv_inj
code: @[simp]
theorem toEquiv_inj {e e' : P₁ ≃ᵃ[k] P₂} : e.toEquiv = e'.toEquiv ↔ e = e' 
goal: e.toEquiv = e'.toEquiv ↔ e = e'

full_name: AffineEquiv.coe_mk
code: @[simp]
theorem coe_mk (e : P₁ ≃ P₂) (e' : V₁ ≃ₗ[k] V₂) (h) : ((⟨e, e', h⟩ : P₁ ≃ᵃ[k] P₂) : P₁ → P₂) = e 
goal: ⇑{ toEquiv := e, linear := e', map_vadd' := h } = ⇑e

full_name: AffineEquiv.mk'
code: /-- Construct an affine equivalence by verifying the relation between the map and its linear part at
one base point. Namely, this function takes a map `e : P₁ → P₂`, a linear equivalence
`e' : V₁ ≃ₗ[k] V₂`, and a point `p` such that for any other point `p'` we have
`e p' = e' (p' -ᵥ p) +ᵥ e p`. -/
def mk' (e : P₁ → P₂) (e' : V₁ ≃ₗ[k] V₂) (p : P₁) (h : ∀ p' : P₁, e p' = e' (p' -ᵥ p) +ᵥ e p) :
    P₁ ≃ᵃ[k] P₂ 
goal: P₁ ≃ᵃ[k] P₂

full_name: AffineEquiv.coe_mk'
code: @[simp]
theorem coe_mk' (e : P₁ ≃ P₂) (e' : V₁ ≃ₗ[k] V₂) (p h) : ⇑(mk' e e' p h) = e 
goal: ⇑(AffineEquiv.mk' (⇑e) e' p h) = ⇑e

full_name: AffineEquiv.linear_mk'
code: @[simp]
theorem linear_mk' (e : P₁ ≃ P₂) (e' : V₁ ≃ₗ[k] V₂) (p h) : (mk' e e' p h).linear = e' 
goal: (AffineEquiv.mk' (⇑e) e' p h).linear = e'

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

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

full_name: AffineEquiv.symm_linear
code: @[simp]
theorem symm_linear (e : P₁ ≃ᵃ[k] P₂) : e.linear.symm = e.symm.linear 
goal: e.linear.symm = e.symm.linear

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

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

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

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

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

full_name: AffineEquiv.linear_ofBijective
code: /-- Bijective affine maps are affine isomorphisms. -/
@[simps! linear apply]
noncomputable def ofBijective {φ : P₁ →ᵃ[k] P₂} (hφ : Function.Bijective φ) : P₁ ≃ᵃ[k] P₂ 
goal: (AffineEquiv.ofBijective hφ).linear = LinearEquiv.ofBijective φ.linear ⋯

full_name: AffineEquiv.ofBijective
code: /-- Bijective affine maps are affine isomorphisms. -/
@[simps! linear apply]
noncomputable def ofBijective {φ : P₁ →ᵃ[k] P₂} (hφ : Function.Bijective φ) : P₁ ≃ᵃ[k] P₂ 
goal: P₁ ≃ᵃ[k] P₂

full_name: AffineEquiv.ofBijective_apply
code: /-- Bijective affine maps are affine isomorphisms. -/
@[simps! linear apply]
noncomputable def ofBijective {φ : P₁ →ᵃ[k] P₂} (hφ : Function.Bijective φ) : P₁ ≃ᵃ[k] P₂ 
goal: (AffineEquiv.ofBijective hφ) a = φ a

full_name: AffineEquiv.ofBijective.symm_eq
code: theorem ofBijective.symm_eq {φ : P₁ →ᵃ[k] P₂} (hφ : Function.Bijective φ) :
    (ofBijective hφ).symm.toEquiv = (Equiv.ofBijective _ hφ).symm 
goal: (AffineEquiv.ofBijective hφ).symm.toEquiv = (Equiv.ofBijective (⇑φ) hφ).symm

full_name: AffineEquiv.range_eq
code: @[simp]
theorem range_eq (e : P₁ ≃ᵃ[k] P₂) : range e = univ 
goal: Set.range ⇑e = Set.univ

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

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

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

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

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

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

full_name: AffineEquiv.refl
code: /-- Identity map as an `AffineEquiv`. -/
-- @[refl] -- Porting note: removed attribute
def refl : P₁ ≃ᵃ[k] P₁ 
goal: P₁ ≃ᵃ[k] P₁

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

full_name: AffineEquiv.coe_refl_to_affineMap
code: @[simp]
theorem coe_refl_to_affineMap : ↑(refl k P₁) = AffineMap.id k P₁ 
goal: ↑(AffineEquiv.refl k P₁) = AffineMap.id k P₁

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

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

full_name: AffineEquiv.linear_refl
code: @[simp]
theorem linear_refl : (refl k P₁).linear = LinearEquiv.refl k V₁ 
goal: (AffineEquiv.refl k P₁).linear = LinearEquiv.refl k V₁

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

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

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

full_name: AffineEquiv.coe_trans_to_affineMap
code: @[simp]
theorem coe_trans_to_affineMap (e : P₁ ≃ᵃ[k] P₂) (e' : P₂ ≃ᵃ[k] P₃) :
    (e.trans e' : P₁ →ᵃ[k] P₃) = (e' : P₂ →ᵃ[k] P₃).comp e 
goal: ↑(e.trans e') = (↑e').comp ↑e

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

full_name: AffineEquiv.trans_assoc
code: theorem trans_assoc (e₁ : P₁ ≃ᵃ[k] P₂) (e₂ : P₂ ≃ᵃ[k] P₃) (e₃ : P₃ ≃ᵃ[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: AffineEquiv.trans_refl
code: @[simp]
theorem trans_refl (e : P₁ ≃ᵃ[k] P₂) : e.trans (refl k P₂) = e 
goal: e.trans (AffineEquiv.refl k P₂) = e

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

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

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

full_name: AffineEquiv.apply_lineMap
code: @[simp]
theorem apply_lineMap (e : P₁ ≃ᵃ[k] P₂) (a b : P₁) (c : k) :
    e (AffineMap.lineMap a b c) = AffineMap.lineMap (e a) (e b) c 
goal: e ((AffineMap.lineMap a b) c) = (AffineMap.lineMap (e a) (e b)) c

full_name: AffineEquiv.group
code: instance group : Group (P₁ ≃ᵃ[k] P₁) 
goal: Group (P₁ ≃ᵃ[k] P₁)

full_name: AffineEquiv.one_def
code: theorem one_def : (1 : P₁ ≃ᵃ[k] P₁) = refl k P₁ 
goal: 1 = AffineEquiv.refl k P₁

full_name: AffineEquiv.coe_one
code: @[simp]
theorem coe_one : ⇑(1 : P₁ ≃ᵃ[k] P₁) = id 
goal: ⇑1 = id

full_name: AffineEquiv.mul_def
code: theorem mul_def (e e' : P₁ ≃ᵃ[k] P₁) : e * e' = e'.trans e 
goal: e * e' = e'.trans e

full_name: AffineEquiv.coe_mul
code: @[simp]
theorem coe_mul (e e' : P₁ ≃ᵃ[k] P₁) : ⇑(e * e') = e ∘ e' 
goal: ⇑(e * e') = ⇑e ∘ ⇑e'

full_name: AffineEquiv.inv_def
code: theorem inv_def (e : P₁ ≃ᵃ[k] P₁) : e⁻¹ = e.symm 
goal: e⁻¹ = e.symm

full_name: AffineEquiv.linearHom
code: /-- `AffineEquiv.linear` on automorphisms is a `MonoidHom`. -/
@[simps]
def linearHom : (P₁ ≃ᵃ[k] P₁) →* V₁ ≃ₗ[k] V₁ 
goal: (P₁ ≃ᵃ[k] P₁) →* V₁ ≃ₗ[k] V₁

full_name: AffineEquiv.linearHom_apply
code: /-- `AffineEquiv.linear` on automorphisms is a `MonoidHom`. -/
@[simps]
def linearHom : (P₁ ≃ᵃ[k] P₁) →* V₁ ≃ₗ[k] V₁ 
goal: AffineEquiv.linearHom self = self.linear

full_name: AffineEquiv.linear_equivUnitsAffineMap_symm_apply
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: (AffineEquiv.equivUnitsAffineMap.symm u).linear =
  (LinearMap.GeneralLinearGroup.generalLinearEquiv k V₁) ((Units.map AffineMap.linearHom) u)

full_name: AffineEquiv.equivUnitsAffineMap
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ

full_name: AffineEquiv.equivUnitsAffineMap_symm_apply_toFun
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: (AffineEquiv.equivUnitsAffineMap.symm u) a = ↑u a

full_name: AffineEquiv.val_equivUnitsAffineMap_apply
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: ↑(AffineEquiv.equivUnitsAffineMap e) = ↑e

full_name: AffineEquiv.val_inv_equivUnitsAffineMap_apply
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: ↑(AffineEquiv.equivUnitsAffineMap e)⁻¹ = ↑e.symm

full_name: AffineEquiv.equivUnitsAffineMap_symm_apply_invFun
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: (AffineEquiv.equivUnitsAffineMap.symm u).invFun a = ↑u⁻¹ a

full_name: AffineEquiv.equivUnitsAffineMap_symm_apply_symm_apply
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: (AffineEquiv.equivUnitsAffineMap.symm u).symm a = ↑u⁻¹ a

full_name: AffineEquiv.equivUnitsAffineMap_symm_apply_apply
code: /-- The group of `AffineEquiv`s are equivalent to the group of units of `AffineMap`.

This is the affine version of `LinearMap.GeneralLinearGroup.generalLinearEquiv`. -/
@[simps]
def equivUnitsAffineMap : (P₁ ≃ᵃ[k] P₁) ≃* (P₁ →ᵃ[k] P₁)ˣ 
goal: (AffineEquiv.equivUnitsAffineMap.symm u) a = ↑u a

full_name: AffineEquiv.linear_vaddConst
code: /-- The map `v ↦ v +ᵥ b` as an affine equivalence between a module `V` and an affine space `P` with
tangent space `V`. -/
@[simps! linear apply symm_apply]
def vaddConst (b : P₁) : V₁ ≃ᵃ[k] P₁ 
goal: (AffineEquiv.vaddConst k b).linear = LinearEquiv.refl k V₁

full_name: AffineEquiv.vaddConst
code: /-- The map `v ↦ v +ᵥ b` as an affine equivalence between a module `V` and an affine space `P` with
tangent space `V`. -/
@[simps! linear apply symm_apply]
def vaddConst (b : P₁) : V₁ ≃ᵃ[k] P₁ 
goal: V₁ ≃ᵃ[k] P₁

full_name: AffineEquiv.vaddConst_symm_apply
code: /-- The map `v ↦ v +ᵥ b` as an affine equivalence between a module `V` and an affine space `P` with
tangent space `V`. -/
@[simps! linear apply symm_apply]
def vaddConst (b : P₁) : V₁ ≃ᵃ[k] P₁ 
goal: (AffineEquiv.vaddConst k b).symm p' = p' -ᵥ b

full_name: AffineEquiv.vaddConst_apply
code: /-- The map `v ↦ v +ᵥ b` as an affine equivalence between a module `V` and an affine space `P` with
tangent space `V`. -/
@[simps! linear apply symm_apply]
def vaddConst (b : P₁) : V₁ ≃ᵃ[k] P₁ 
goal: (AffineEquiv.vaddConst k b) v = v +ᵥ b

full_name: AffineEquiv.constVSub
code: /-- `p' ↦ p -ᵥ p'` as an equivalence. -/
def constVSub (p : P₁) : P₁ ≃ᵃ[k] V₁ 
goal: P₁ ≃ᵃ[k] V₁

full_name: AffineEquiv.coe_constVSub
code: @[simp]
theorem coe_constVSub (p : P₁) : ⇑(constVSub k p) = (p -ᵥ ·) 
goal: ⇑(AffineEquiv.constVSub k p) = fun x => p -ᵥ x

full_name: AffineEquiv.coe_constVSub_symm
code: @[simp]
theorem coe_constVSub_symm (p : P₁) : ⇑(constVSub k p).symm = fun v : V₁ => -v +ᵥ p 
goal: ⇑(AffineEquiv.constVSub k p).symm = fun v => -v +ᵥ p

full_name: AffineEquiv.linear_constVAdd
code: /-- The map `p ↦ v +ᵥ p` as an affine automorphism of an affine space.

Note that there is no need for an `AffineMap.constVAdd` as it is always an equivalence.
This is roughly to `DistribMulAction.toLinearEquiv` as `+ᵥ` is to `•`. -/
@[simps! apply linear]
def constVAdd (v : V₁) : P₁ ≃ᵃ[k] P₁ 
goal: (AffineEquiv.constVAdd k P₁ v).linear = LinearEquiv.refl k V₁

full_name: AffineEquiv.constVAdd
code: /-- The map `p ↦ v +ᵥ p` as an affine automorphism of an affine space.

Note that there is no need for an `AffineMap.constVAdd` as it is always an equivalence.
This is roughly to `DistribMulAction.toLinearEquiv` as `+ᵥ` is to `•`. -/
@[simps! apply linear]
def constVAdd (v : V₁) : P₁ ≃ᵃ[k] P₁ 
goal: P₁ ≃ᵃ[k] P₁

full_name: AffineEquiv.constVAdd_apply
code: /-- The map `p ↦ v +ᵥ p` as an affine automorphism of an affine space.

Note that there is no need for an `AffineMap.constVAdd` as it is always an equivalence.
This is roughly to `DistribMulAction.toLinearEquiv` as `+ᵥ` is to `•`. -/
@[simps! apply linear]
def constVAdd (v : V₁) : P₁ ≃ᵃ[k] P₁ 
goal: ∀ (x : P₁), (AffineEquiv.constVAdd k P₁ v) x = v +ᵥ x

full_name: AffineEquiv.constVAdd_zero
code: @[simp]
theorem constVAdd_zero : constVAdd k P₁ 0 = AffineEquiv.refl _ _ 
goal: AffineEquiv.constVAdd k P₁ 0 = AffineEquiv.refl k P₁

full_name: AffineEquiv.constVAdd_add
code: @[simp]
theorem constVAdd_add (v w : V₁) :
    constVAdd k P₁ (v + w) = (constVAdd k P₁ w).trans (constVAdd k P₁ v) 
goal: AffineEquiv.constVAdd k P₁ (v + w) = (AffineEquiv.constVAdd k P₁ w).trans (AffineEquiv.constVAdd k P₁ v)

full_name: AffineEquiv.constVAdd_symm
code: @[simp]
theorem constVAdd_symm (v : V₁) : (constVAdd k P₁ v).symm = constVAdd k P₁ (-v) 
goal: (AffineEquiv.constVAdd k P₁ v).symm = AffineEquiv.constVAdd k P₁ (-v)

full_name: AffineEquiv.constVAddHom
code: /-- A more bundled version of `AffineEquiv.constVAdd`. -/
@[simps]
def constVAddHom : Multiplicative V₁ →* P₁ ≃ᵃ[k] P₁ 
goal: Multiplicative V₁ →* P₁ ≃ᵃ[k] P₁

full_name: AffineEquiv.constVAddHom_apply
code: /-- A more bundled version of `AffineEquiv.constVAdd`. -/
@[simps]
def constVAddHom : Multiplicative V₁ →* P₁ ≃ᵃ[k] P₁ 
goal: (AffineEquiv.constVAddHom k P₁) v = AffineEquiv.constVAdd k P₁ (Multiplicative.toAdd v)

full_name: AffineEquiv.constVAdd_nsmul
code: theorem constVAdd_nsmul (n : ℕ) (v : V₁) : constVAdd k P₁ (n • v) = constVAdd k P₁ v ^ n 
goal: AffineEquiv.constVAdd k P₁ (n • v) = AffineEquiv.constVAdd k P₁ v ^ n

full_name: AffineEquiv.constVAdd_zsmul
code: theorem constVAdd_zsmul (z : ℤ) (v : V₁) : constVAdd k P₁ (z • v) = constVAdd k P₁ v ^ z 
goal: AffineEquiv.constVAdd k P₁ (z • v) = AffineEquiv.constVAdd k P₁ v ^ z

full_name: AffineEquiv.homothetyUnitsMulHom
code: /-- Fixing a point in affine space, homothety about this point gives a group homomorphism from (the
centre of) the units of the scalars into the group of affine equivalences. -/
def homothetyUnitsMulHom (p : P) : Rˣ →* P ≃ᵃ[R] P 
goal: Rˣ →* P ≃ᵃ[R] P

full_name: AffineEquiv.coe_homothetyUnitsMulHom_apply
code: @[simp]
theorem coe_homothetyUnitsMulHom_apply (p : P) (t : Rˣ) :
    (homothetyUnitsMulHom p t : P → P) = AffineMap.homothety p (t : R) 
goal: ⇑((AffineEquiv.homothetyUnitsMulHom p) t) = ⇑(AffineMap.homothety p ↑t)

full_name: AffineEquiv.coe_homothetyUnitsMulHom_apply_symm
code: @[simp]
theorem coe_homothetyUnitsMulHom_apply_symm (p : P) (t : Rˣ) :
    ((homothetyUnitsMulHom p t).symm : P → P) = AffineMap.homothety p (↑t⁻¹ : R) 
goal: ⇑((AffineEquiv.homothetyUnitsMulHom p) t).symm = ⇑(AffineMap.homothety p ↑t⁻¹)

full_name: AffineEquiv.coe_homothetyUnitsMulHom_eq_homothetyHom_coe
code: @[simp]
theorem coe_homothetyUnitsMulHom_eq_homothetyHom_coe (p : P) :
    ((↑) : (P ≃ᵃ[R] P) → P →ᵃ[R] P) ∘ homothetyUnitsMulHom p =
      AffineMap.homothetyHom p ∘ ((↑) : Rˣ → R) 
goal: AffineEquiv.toAffineMap ∘ ⇑(AffineEquiv.homothetyUnitsMulHom p) = ⇑(AffineMap.homothetyHom p) ∘ Units.val

full_name: AffineEquiv.pointReflection
code: /-- Point reflection in `x` as a permutation. -/
def pointReflection (x : P₁) : P₁ ≃ᵃ[k] P₁ 
goal: P₁ ≃ᵃ[k] P₁

full_name: AffineEquiv.pointReflection_apply
code: theorem pointReflection_apply (x y : P₁) : pointReflection k x y = x -ᵥ y +ᵥ x 
goal: (AffineEquiv.pointReflection k x) y = x -ᵥ y +ᵥ x

full_name: AffineEquiv.pointReflection_symm
code: @[simp]
theorem pointReflection_symm (x : P₁) : (pointReflection k x).symm = pointReflection k x 
goal: (AffineEquiv.pointReflection k x).symm = AffineEquiv.pointReflection k x

full_name: AffineEquiv.toEquiv_pointReflection
code: @[simp]
theorem toEquiv_pointReflection (x : P₁) :
    (pointReflection k x).toEquiv = Equiv.pointReflection x 
goal: (AffineEquiv.pointReflection k x).toEquiv = Equiv.pointReflection x

full_name: AffineEquiv.pointReflection_self
code: @[simp]
theorem pointReflection_self (x : P₁) : pointReflection k x x = x 
goal: (AffineEquiv.pointReflection k x) x = x

full_name: AffineEquiv.pointReflection_involutive
code: theorem pointReflection_involutive (x : P₁) : Involutive (pointReflection k x : P₁ → P₁) 
goal: Function.Involutive ⇑(AffineEquiv.pointReflection k x)

full_name: AffineEquiv.pointReflection_fixed_iff_of_injective_bit0
code: /-- `x` is the only fixed point of `pointReflection x`. This lemma requires
`x + x = y + y ↔ x = y`. There is no typeclass to use here, so we add it as an explicit argument. -/
theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P₁} (h : Injective (2 • · : V₁ → V₁)) :
    pointReflection k x y = y ↔ y = x 
goal: (AffineEquiv.pointReflection k x) y = y ↔ y = x

full_name: AffineEquiv.injective_pointReflection_left_of_injective_bit0
code: theorem injective_pointReflection_left_of_injective_bit0
    (h : Injective (2 • · : V₁ → V₁)) (y : P₁) :
    Injective fun x : P₁ => pointReflection k x y 
goal: Function.Injective fun x => (AffineEquiv.pointReflection k x) y

full_name: AffineEquiv.injective_pointReflection_left_of_module
code: theorem injective_pointReflection_left_of_module [Invertible (2 : k)] :
    ∀ y, Injective fun x : P₁ => pointReflection k x y 
goal: Function.Injective fun x => (AffineEquiv.pointReflection k x) y

full_name: AffineEquiv.pointReflection_fixed_iff_of_module
code: theorem pointReflection_fixed_iff_of_module [Invertible (2 : k)] {x y : P₁} :
    pointReflection k x y = y ↔ y = x 
goal: (AffineEquiv.pointReflection k x) y = y ↔ y = x

full_name: LinearEquiv.toAffineEquiv
code: /-- Interpret a linear equivalence between modules as an affine equivalence. -/
def toAffineEquiv (e : V₁ ≃ₗ[k] V₂) : V₁ ≃ᵃ[k] V₂ 
goal: V₁ ≃ᵃ[k] V₂

full_name: LinearEquiv.coe_toAffineEquiv
code: @[simp]
theorem coe_toAffineEquiv (e : V₁ ≃ₗ[k] V₂) : ⇑e.toAffineEquiv = e 
goal: ⇑e.toAffineEquiv = ⇑e

full_name: AffineMap.lineMap_vadd
code: theorem lineMap_vadd (v v' : V₁) (p : P₁) (c : k) :
    lineMap v v' c +ᵥ p = lineMap (v +ᵥ p) (v' +ᵥ p) c 
goal: (AffineMap.lineMap v v') c +ᵥ p = (AffineMap.lineMap (v +ᵥ p) (v' +ᵥ p)) c

full_name: AffineMap.lineMap_vsub
code: theorem lineMap_vsub (p₁ p₂ p₃ : P₁) (c : k) :
    lineMap p₁ p₂ c -ᵥ p₃ = lineMap (p₁ -ᵥ p₃) (p₂ -ᵥ p₃) c 
goal: (AffineMap.lineMap p₁ p₂) c -ᵥ p₃ = (AffineMap.lineMap (p₁ -ᵥ p₃) (p₂ -ᵥ p₃)) c

full_name: AffineMap.vsub_lineMap
code: theorem vsub_lineMap (p₁ p₂ p₃ : P₁) (c : k) :
    p₁ -ᵥ lineMap p₂ p₃ c = lineMap (p₁ -ᵥ p₂) (p₁ -ᵥ p₃) c 
goal: p₁ -ᵥ (AffineMap.lineMap p₂ p₃) c = (AffineMap.lineMap (p₁ -ᵥ p₂) (p₁ -ᵥ p₃)) c

full_name: AffineMap.vadd_lineMap
code: theorem vadd_lineMap (v : V₁) (p₁ p₂ : P₁) (c : k) :
    v +ᵥ lineMap p₁ p₂ c = lineMap (v +ᵥ p₁) (v +ᵥ p₂) c 
goal: v +ᵥ (AffineMap.lineMap p₁ p₂) c = (AffineMap.lineMap (v +ᵥ p₁) (v +ᵥ p₂)) c

full_name: AffineMap.homothety_neg_one_apply
code: theorem homothety_neg_one_apply (c p : P₁) : homothety c (-1 : R') p = pointReflection R' c p 
goal: (AffineMap.homothety c (-1)) p = (AffineEquiv.pointReflection R' c) p