File: Mathlib/Algebra/AddConstMap/Basic.lean

full_name: AddConstMap.map_add_const'
code: /-- A bundled map `f : G → H` such that `f (x + a) = f x + b` for all `x`.

One can think about `f` as a lift to `G` of a map between two `AddCircle`s. -/
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
  /-- The underlying function of an `AddConstMap`.
  Use automatic coercion to function instead. -/
  protected toFun : G → H
  /-- An `AddConstMap` satisfies `f (x + a) = f x + b`. Use `map_add_const` instead. -/
  map_add_const' (x : G) : toFun (x + a) = toFun x + b
goal: self.toFun (x + a) = self.toFun x + b

full_name: AddConstMap
code: /-- A bundled map `f : G → H` such that `f (x + a) = f x + b` for all `x`.

One can think about `f` as a lift to `G` of a map between two `AddCircle`s. -/
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
  /-- The underlying function of an `AddConstMap`.
  Use automatic coercion to function instead. -/
  protected toFun : G → H
  /-- An `AddConstMap` satisfies `f (x + a) = f x + b`. Use `map_add_const` instead. -/
  map_add_const' (x : G) : toFun (x + a) = toFun x + b
goal: Type (max u_1 u_2)

full_name: AddConstMap.toFun
code: /-- A bundled map `f : G → H` such that `f (x + a) = f x + b` for all `x`.

One can think about `f` as a lift to `G` of a map between two `AddCircle`s. -/
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
  /-- The underlying function of an `AddConstMap`.
  Use automatic coercion to function instead. -/
  protected toFun : G → H
  /-- An `AddConstMap` satisfies `f (x + a) = f x + b`. Use `map_add_const` instead. -/
  map_add_const' (x : G) : toFun (x + a) = toFun x + b
goal: G → H

full_name: AddConstMap._aux_Mathlib_Algebra_AddConstMap_Basic___unexpand_AddConstMap_1
code: @[inherit_doc]
scoped [AddConstMap] notation:25 G " →+c[" a ", " b "] " H => AddConstMap G H a b
goal: Lean.PrettyPrinter.Unexpander

full_name: AddConstMap.«_aux_Mathlib_Algebra_AddConstMap_Basic___macroRules_AddConstMap_term_→+c[_,_]__1»
code: @[inherit_doc]
scoped [AddConstMap] notation:25 G " →+c[" a ", " b "] " H => AddConstMap G H a b
goal: Lean.Macro

full_name: AddConstMapClass
code: /-- Typeclass for maps satisfying `f (x + a) = f x + b`.

Note that `a` and `b` are `outParam`s,
so one should not add instances like
`[AddConstMapClass F G H a b] : AddConstMapClass F G H (-a) (-b)`. -/
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
    (a : outParam G) (b : outParam H) [FunLike F G H] : Prop where
  /-- A map of `AddConstMapClass` class semiconjugates shift by `a` to the shift by `b`:
  `∀ x, f (x + a) = f x + b`. -/
  map_add_const (f : F) (x : G) : f (x + a) = f x + b
goal: Prop

full_name: AddConstMapClass.map_add_const
code: /-- Typeclass for maps satisfying `f (x + a) = f x + b`.

Note that `a` and `b` are `outParam`s,
so one should not add instances like
`[AddConstMapClass F G H a b] : AddConstMapClass F G H (-a) (-b)`. -/
class AddConstMapClass (F : Type*) (G H : outParam Type*) [Add G] [Add H]
    (a : outParam G) (b : outParam H) [FunLike F G H] : Prop where
  /-- A map of `AddConstMapClass` class semiconjugates shift by `a` to the shift by `b`:
  `∀ x, f (x + a) = f x + b`. -/
  map_add_const (f : F) (x : G) : f (x + a) = f x + b
goal: f (x + a) = f x + b

full_name: AddConstMapClass.semiconj
code: protected theorem semiconj [Add G] [Add H] [AddConstMapClass F G H a b] (f : F) :
    Semiconj f (· + a) (· + b) 
goal: Function.Semiconj (⇑f) (fun x => x + a) fun x => x + b

full_name: AddConstMapClass.map_add_nsmul
code: @[scoped simp]
theorem map_add_nsmul [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
    (f : F) (x : G) (n : ℕ) : f (x + n • a) = f x + n • b 
goal: f (x + n • a) = f x + n • b

full_name: AddConstMapClass.map_add_nat'
code: @[scoped simp]
theorem map_add_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) (n : ℕ) : f (x + n) = f x + n • b 
goal: f (x + ↑n) = f x + n • b

full_name: AddConstMapClass.map_add_one
code: theorem map_add_one [AddMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) : f (x + 1) = f x + b 
goal: f (x + 1) = f x + b

full_name: AddConstMapClass.map_add_ofNat'
code: @[scoped simp]
theorem map_add_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) (n : ℕ) [n.AtLeastTwo] :
    f (x + no_index (OfNat.ofNat n)) = f x + (OfNat.ofNat n : ℕ) • b 
goal: f (x + OfNat.ofNat n) = f x + OfNat.ofNat n • b

full_name: AddConstMapClass.map_add_nat
code: theorem map_add_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (x : G) (n : ℕ) : f (x + n) = f x + n 
goal: f (x + ↑n) = f x + ↑n

full_name: AddConstMapClass.map_add_ofNat
code: theorem map_add_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (x : G) (n : ℕ) [n.AtLeastTwo] :
    f (x + OfNat.ofNat n) = f x + OfNat.ofNat n 
goal: f (x + OfNat.ofNat n) = f x + OfNat.ofNat n

full_name: AddConstMapClass.map_const
code: @[scoped simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
    f a = f 0 + b 
goal: f a = f 0 + b

full_name: AddConstMapClass.map_one
code: theorem map_one [AddZeroClass G] [One G] [Add H] [AddConstMapClass F G H 1 b] (f : F) :
    f 1 = f 0 + b 
goal: f 1 = f 0 + b

full_name: AddConstMapClass.map_nsmul_const
code: @[scoped simp]
theorem map_nsmul_const [AddMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
    (f : F) (n : ℕ) : f (n • a) = f 0 + n • b 
goal: f (n • a) = f 0 + n • b

full_name: AddConstMapClass.map_nat'
code: @[scoped simp]
theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (n : ℕ) : f n = f 0 + n • b 
goal: f ↑n = f 0 + n • b

full_name: AddConstMapClass.map_ofNat'
code: theorem map_ofNat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (n : ℕ) [n.AtLeastTwo] :
    f (OfNat.ofNat n) = f 0 + (OfNat.ofNat n : ℕ) • b 
goal: f (OfNat.ofNat n) = f 0 + OfNat.ofNat n • b

full_name: AddConstMapClass.map_nat
code: theorem map_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (n : ℕ) : f n = f 0 + n 
goal: f ↑n = f 0 + ↑n

full_name: AddConstMapClass.map_ofNat
code: theorem map_ofNat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (n : ℕ) [n.AtLeastTwo] :
    f (OfNat.ofNat n) = f 0 + OfNat.ofNat n 
goal: f (OfNat.ofNat n) = f 0 + OfNat.ofNat n

full_name: AddConstMapClass.map_const_add
code: @[scoped simp]
theorem map_const_add [AddCommSemigroup G] [Add H] [AddConstMapClass F G H a b]
    (f : F) (x : G) : f (a + x) = f x + b 
goal: f (a + x) = f x + b

full_name: AddConstMapClass.map_one_add
code: theorem map_one_add [AddCommMonoidWithOne G] [Add H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) : f (1 + x) = f x + b 
goal: f (1 + x) = f x + b

full_name: AddConstMapClass.map_nsmul_add
code: @[scoped simp]
theorem map_nsmul_add [AddCommMonoid G] [AddMonoid H] [AddConstMapClass F G H a b]
    (f : F) (n : ℕ) (x : G) : f (n • a + x) = f x + n • b 
goal: f (n • a + x) = f x + n • b

full_name: AddConstMapClass.map_nat_add'
code: @[scoped simp]
theorem map_nat_add' [AddCommMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (n : ℕ) (x : G) : f (↑n + x) = f x + n • b 
goal: f (↑n + x) = f x + n • b

full_name: AddConstMapClass.map_ofNat_add'
code: theorem map_ofNat_add' [AddCommMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
    (f : F) (n : ℕ) [n.AtLeastTwo] (x : G) :
    f (OfNat.ofNat n + x) = f x + OfNat.ofNat n • b 
goal: f (OfNat.ofNat n + x) = f x + OfNat.ofNat n • b

full_name: AddConstMapClass.map_nat_add
code: theorem map_nat_add [AddCommMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (n : ℕ) (x : G) : f (↑n + x) = f x + n 
goal: f (↑n + x) = f x + ↑n

full_name: AddConstMapClass.map_ofNat_add
code: theorem map_ofNat_add [AddCommMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (n : ℕ) [n.AtLeastTwo] (x : G) :
    f (OfNat.ofNat n + x) = f x + OfNat.ofNat n 
goal: f (OfNat.ofNat n + x) = f x + OfNat.ofNat n

full_name: AddConstMapClass.map_sub_nsmul
code: @[scoped simp]
theorem map_sub_nsmul [AddGroup G] [AddGroup H] [AddConstMapClass F G H a b]
    (f : F) (x : G) (n : ℕ) : f (x - n • a) = f x - n • b 
goal: f (x - n • a) = f x - n • b

full_name: AddConstMapClass.map_sub_const
code: @[scoped simp]
theorem map_sub_const [AddGroup G] [AddGroup H] [AddConstMapClass F G H a b]
    (f : F) (x : G) : f (x - a) = f x - b 
goal: f (x - a) = f x - b

full_name: AddConstMapClass.map_sub_one
code: theorem map_sub_one [AddGroup G] [One G] [AddGroup H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) : f (x - 1) = f x - b 
goal: f (x - 1) = f x - b

full_name: AddConstMapClass.map_sub_nat'
code: @[scoped simp]
theorem map_sub_nat' [AddGroupWithOne G] [AddGroup H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) (n : ℕ) : f (x - n) = f x - n • b 
goal: f (x - ↑n) = f x - n • b

full_name: AddConstMapClass.map_sub_ofNat'
code: @[scoped simp]
theorem map_sub_ofNat' [AddGroupWithOne G] [AddGroup H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) (n : ℕ) [n.AtLeastTwo] :
    f (x - no_index (OfNat.ofNat n)) = f x - OfNat.ofNat n • b 
goal: f (x - OfNat.ofNat n) = f x - OfNat.ofNat n • b

full_name: AddConstMapClass.map_add_zsmul
code: @[scoped simp]
theorem map_add_zsmul [AddGroup G] [AddGroup H] [AddConstMapClass F G H a b]
    (f : F) (x : G) : ∀ n : ℤ, f (x + n • a) = f x + n • b
  
goal: f (x + n • a) = f x + n • b

full_name: AddConstMapClass.map_zsmul_const
code: @[scoped simp]
theorem map_zsmul_const [AddGroup G] [AddGroup H] [AddConstMapClass F G H a b]
    (f : F) (n : ℤ) : f (n • a) = f 0 + n • b 
goal: f (n • a) = f 0 + n • b

full_name: AddConstMapClass.map_add_int'
code: @[scoped simp]
theorem map_add_int' [AddGroupWithOne G] [AddGroup H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) (n : ℤ) : f (x + n) = f x + n • b 
goal: f (x + ↑n) = f x + n • b

full_name: AddConstMapClass.map_add_int
code: theorem map_add_int [AddGroupWithOne G] [AddGroupWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (x : G) (n : ℤ) : f (x + n) = f x + n 
goal: f (x + ↑n) = f x + ↑n

full_name: AddConstMapClass.map_sub_zsmul
code: @[scoped simp]
theorem map_sub_zsmul [AddGroup G] [AddGroup H] [AddConstMapClass F G H a b]
    (f : F) (x : G) (n : ℤ) : f (x - n • a) = f x - n • b 
goal: f (x - n • a) = f x - n • b

full_name: AddConstMapClass.map_sub_int'
code: @[scoped simp]
theorem map_sub_int' [AddGroupWithOne G] [AddGroup H] [AddConstMapClass F G H 1 b]
    (f : F) (x : G) (n : ℤ) : f (x - n) = f x - n • b 
goal: f (x - ↑n) = f x - n • b

full_name: AddConstMapClass.map_sub_int
code: theorem map_sub_int [AddGroupWithOne G] [AddGroupWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (x : G) (n : ℤ) : f (x - n) = f x - n 
goal: f (x - ↑n) = f x - ↑n

full_name: AddConstMapClass.map_zsmul_add
code: @[scoped simp]
theorem map_zsmul_add [AddCommGroup G] [AddGroup H] [AddConstMapClass F G H a b]
    (f : F) (n : ℤ) (x : G) : f (n • a + x) = f x + n • b 
goal: f (n • a + x) = f x + n • b

full_name: AddConstMapClass.map_int_add'
code: @[scoped simp]
theorem map_int_add' [AddCommGroupWithOne G] [AddGroup H] [AddConstMapClass F G H 1 b]
    (f : F) (n : ℤ) (x : G) : f (↑n + x) = f x + n • b 
goal: f (↑n + x) = f x + n • b

full_name: AddConstMapClass.map_int_add
code: theorem map_int_add [AddCommGroupWithOne G] [AddGroupWithOne H] [AddConstMapClass F G H 1 1]
    (f : F) (n : ℤ) (x : G) : f (↑n + x) = f x + n 
goal: f (↑n + x) = f x + ↑n

full_name: AddConstMapClass.map_fract
code: theorem map_fract {R : Type*} [LinearOrderedRing R] [FloorRing R] [AddGroup H]
    [FunLike F R H] [AddConstMapClass F R H 1 b] (f : F) (x : R) :
    f (Int.fract x) = f x - ⌊x⌋ • b 
goal: f (Int.fract x) = f x - ⌊x⌋ • b

full_name: AddConstMapClass.rel_map_of_Icc
code: /-- Auxiliary lemmas for the "monotonicity on a fundamental interval implies monotonicity" lemmas.
We formulate it for any relation so that the proof works both for `Monotone` and `StrictMono`. -/
protected theorem rel_map_of_Icc [LinearOrderedAddCommGroup G] [Archimedean G] [AddGroup H]
    [AddConstMapClass F G H a b] {f : F} {R : H → H → Prop} [IsTrans H R]
    [hR : CovariantClass H H (fun x y ↦ y + x) R] (ha : 0 < a) {l : G}
    (hf : ∀ x ∈ Icc l (l + a), ∀ y ∈ Icc l (l + a), x < y → R (f x) (f y)) :
    ((· < ·) ⇒ R) f f 
goal: ((fun x x_1 => x < x_1) ⇒ R) ⇑f ⇑f

full_name: AddConstMapClass.monotone_iff_Icc
code: theorem monotone_iff_Icc [LinearOrderedAddCommGroup G] [Archimedean G] [OrderedAddCommGroup H]
    [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
    Monotone f ↔ MonotoneOn f (Icc l (l + a)) 
goal: Monotone ⇑f ↔ MonotoneOn (⇑f) (Set.Icc l (l + a))

full_name: AddConstMapClass.antitone_iff_Icc
code: theorem antitone_iff_Icc [LinearOrderedAddCommGroup G] [Archimedean G] [OrderedAddCommGroup H]
    [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
    Antitone f ↔ AntitoneOn f (Icc l (l + a)) 
goal: Antitone ⇑f ↔ AntitoneOn (⇑f) (Set.Icc l (l + a))

full_name: AddConstMapClass.strictMono_iff_Icc
code: theorem strictMono_iff_Icc [LinearOrderedAddCommGroup G] [Archimedean G] [OrderedAddCommGroup H]
    [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
    StrictMono f ↔ StrictMonoOn f (Icc l (l + a)) 
goal: StrictMono ⇑f ↔ StrictMonoOn (⇑f) (Set.Icc l (l + a))

full_name: AddConstMapClass.strictAnti_iff_Icc
code: theorem strictAnti_iff_Icc [LinearOrderedAddCommGroup G] [Archimedean G] [OrderedAddCommGroup H]
    [AddConstMapClass F G H a b] {f : F} (ha : 0 < a) (l : G) :
    StrictAnti f ↔ StrictAntiOn f (Icc l (l + a)) 
goal: StrictAnti ⇑f ↔ StrictAntiOn (⇑f) (Set.Icc l (l + a))

full_name: AddConstMap.instFunLike
code: instance : FunLike (G →+c[a, b] H) G H 
goal: FunLike (AddConstMap G H a b) G H

full_name: AddConstMap.coe_mk
code: @[simp, push_cast] theorem coe_mk (f : G → H) (hf) : ⇑(mk f hf : G →+c[a, b] H) = f 
goal: ⇑{ toFun := f, map_add_const' := hf } = f

full_name: AddConstMap.mk_coe
code: @[simp] theorem mk_coe (f : G →+c[a, b] H) : mk f f.2 = f 
goal: { toFun := ⇑f, map_add_const' := ⋯ } = f

full_name: AddConstMap.toFun_eq_coe
code: @[simp] theorem toFun_eq_coe (f : G →+c[a, b] H) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: AddConstMap.instAddConstMapClass
code: instance : AddConstMapClass (G →+c[a, b] H) G H a b 
goal: AddConstMapClass (AddConstMap G H a b) G H a b

full_name: AddConstMap.ext
code: @[ext] protected theorem ext {f g : G →+c[a, b] H} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: AddConstMap.id
code: /-- The identity map as `G →+c[a, a] G`. -/
@[simps (config := .asFn)]
protected def id : G →+c[a, a] G 
goal: AddConstMap G G a a

full_name: AddConstMap.coe_id
code: /-- The identity map as `G →+c[a, a] G`. -/
@[simps (config := .asFn)]
protected def id : G →+c[a, a] G 
goal: ⇑AddConstMap.id = id

full_name: AddConstMap.instInhabited
code: instance : Inhabited (G →+c[a, a] G) 
goal: Inhabited (AddConstMap G G a a)

full_name: AddConstMap.coe_comp
code: /-- Composition of two `AddConstMap`s. -/
@[simps (config := .asFn)]
def comp {K : Type*} [Add K] {c : K} (g : H →+c[b, c] K) (f : G →+c[a, b] H) :
    G →+c[a, c] K 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: AddConstMap.comp
code: /-- Composition of two `AddConstMap`s. -/
@[simps (config := .asFn)]
def comp {K : Type*} [Add K] {c : K} (g : H →+c[b, c] K) (f : G →+c[a, b] H) :
    G →+c[a, c] K 
goal: AddConstMap G K a c

full_name: AddConstMap.comp_id
code: @[simp] theorem comp_id (f : G →+c[a, b] H) : f.comp .id = f 
goal: f.comp AddConstMap.id = f

full_name: AddConstMap.id_comp
code: @[simp] theorem id_comp (f : G →+c[a, b] H) : .comp .id f = f 
goal: AddConstMap.id.comp f = f

full_name: AddConstMap.coe_replaceConsts
code: /-- Change constants `a` and `b` in `(f : G →+c[a, b] H)` to improve definitional equalities. -/
@[simps (config := .asFn)]
def replaceConsts (f : G →+c[a, b] H) (a' b') (ha : a = a') (hb : b = b') :
    G →+c[a', b'] H 
goal: ⇑(f.replaceConsts a' b' ha hb) = ⇑f

full_name: AddConstMap.replaceConsts
code: /-- Change constants `a` and `b` in `(f : G →+c[a, b] H)` to improve definitional equalities. -/
@[simps (config := .asFn)]
def replaceConsts (f : G →+c[a, b] H) (a' b') (ha : a = a') (hb : b = b') :
    G →+c[a', b'] H 
goal: AddConstMap G H a' b'

full_name: AddConstMap.instVAddOfVAddAssocClass
code: /-- If `f` is an `AddConstMap`, then so is `(c +ᵥ f ·)`. -/
instance {K : Type*} [VAdd K H] [VAddAssocClass K H H] : VAdd K (G →+c[a, b] H) 
goal: VAdd K (AddConstMap G H a b)

full_name: AddConstMap.coe_vadd
code: @[simp, norm_cast]
theorem coe_vadd {K : Type*} [VAdd K H] [VAddAssocClass K H H] (c : K) (f : G →+c[a, b] H) :
    ⇑(c +ᵥ f) = c +ᵥ ⇑f 
goal: ⇑(c +ᵥ f) = c +ᵥ ⇑f

full_name: AddConstMap.instAddActionOfVAddAssocClass
code: instance {K : Type*} [AddMonoid K] [AddAction K H] [VAddAssocClass K H H] :
    AddAction K (G →+c[a, b] H) 
goal: AddAction K (AddConstMap G H a b)

full_name: AddConstMap.instMul
code: instance : Mul (G →+c[a, a] G) 
goal: Mul (AddConstMap G G a a)

full_name: AddConstMap.instOne
code: instance : One (G →+c[a, a] G) 
goal: One (AddConstMap G G a a)

full_name: AddConstMap.instPowNat
code: instance : Pow (G →+c[a, a] G) ℕ 
goal: Pow (AddConstMap G G a a) ℕ

full_name: AddConstMap.instMonoid
code: instance : Monoid (G →+c[a, a] G) 
goal: Monoid (AddConstMap G G a a)

full_name: AddConstMap.mul_def
code: theorem mul_def (f g : G →+c[a, a] G) : f * g = f.comp g 
goal: f * g = f.comp g

full_name: AddConstMap.coe_mul
code: @[simp, push_cast] theorem coe_mul (f g : G →+c[a, a] G) : ⇑(f * g) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: AddConstMap.one_def
code: theorem one_def : (1 : G →+c[a, a] G) = .id 
goal: 1 = AddConstMap.id

full_name: AddConstMap.coe_one
code: @[simp, push_cast] theorem coe_one : ⇑(1 : G →+c[a, a] G) = id 
goal: ⇑1 = id

full_name: AddConstMap.coe_pow
code: @[simp, push_cast] theorem coe_pow (f : G →+c[a, a] G) (n : ℕ) : ⇑(f ^ n) = f^[n] 
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: AddConstMap.pow_apply
code: theorem pow_apply (f : G →+c[a, a] G) (n : ℕ) (x : G) : (f ^ n) x = f^[n] x 
goal: (f ^ n) x = (⇑f)^[n] x

full_name: AddConstMap.toEnd_apply
code: /-- Coercion to functions as a monoid homomorphism to `Function.End G`. -/
@[simps (config := .asFn)]
def toEnd : (G →+c[a, a] G) →* Function.End G 
goal: ⇑AddConstMap.toEnd = DFunLike.coe

full_name: AddConstMap.toEnd
code: /-- Coercion to functions as a monoid homomorphism to `Function.End G`. -/
@[simps (config := .asFn)]
def toEnd : (G →+c[a, a] G) →* Function.End G 
goal: AddConstMap G G a a →* Function.End G

full_name: AddConstMap.coe_smul
code: /-- Pointwise scalar multiplication of `f : G →+c[a, b] H` as a map `G →+c[a, c • b] H`. -/
@[simps (config := .asFn)]
def smul [DistribSMul K H] (c : K) (f : G →+c[a, b] H) : G →+c[a, c • b] H 
goal: ⇑(AddConstMap.smul c f) = c • ⇑f

full_name: AddConstMap.smul
code: /-- Pointwise scalar multiplication of `f : G →+c[a, b] H` as a map `G →+c[a, c • b] H`. -/
@[simps (config := .asFn)]
def smul [DistribSMul K H] (c : K) (f : G →+c[a, b] H) : G →+c[a, c • b] H 
goal: AddConstMap G H a (c • b)

full_name: AddConstMap.addLeftHom
code: /-- The map that sends `c` to a translation by `c`
as a monoid homomorphism from `Multiplicative G` to `G →+c[a, a] G`. -/
@[simps! (config := .asFn)]
def addLeftHom : Multiplicative G →* (G →+c[a, a] G) 
goal: Multiplicative G →* AddConstMap G G a a

full_name: AddConstMap.coe_addLeftHom_apply
code: /-- The map that sends `c` to a translation by `c`
as a monoid homomorphism from `Multiplicative G` to `G →+c[a, a] G`. -/
@[simps! (config := .asFn)]
def addLeftHom : Multiplicative G →* (G →+c[a, a] G) 
goal: ⇑(AddConstMap.addLeftHom c) = c • id

full_name: AddConstMap.coe_conjNeg_apply
code: /-- If `f : G → H` is an `AddConstMap`, then so is `fun x ↦ -f (-x)`. -/
@[simps! apply_coe]
def conjNeg : (G →+c[a, b] H) ≃ (G →+c[a, b] H) 
goal: (AddConstMap.conjNeg f) x = -f (-x)

full_name: AddConstMap.conjNeg
code: /-- If `f : G → H` is an `AddConstMap`, then so is `fun x ↦ -f (-x)`. -/
@[simps! apply_coe]
def conjNeg : (G →+c[a, b] H) ≃ (G →+c[a, b] H) 
goal: AddConstMap G H a b ≃ AddConstMap G H a b

full_name: AddConstMap.conjNeg_symm
code: @[simp] theorem conjNeg_symm : (conjNeg (a := a) (b := b)).symm = conjNeg 
goal: AddConstMap.conjNeg.symm = AddConstMap.conjNeg

full_name: AddConstMap.mkFract
code: /-- A map `f : R →+c[1, a] G` is defined by its values on `Set.Ico 0 1`. -/
def mkFract : (Ico (0 : R) 1 → G) ≃ (R →+c[1, a] G) 
goal: (↑(Set.Ico 0 1) → G) ≃ AddConstMap R G 1 a