File: Mathlib/Algebra/GroupPower/IterateHom.lean

full_name: hom_coe_pow
code: /-- An auxiliary lemma that can be used to prove `⇑(f ^ n) = ⇑f^[n]`. -/
theorem hom_coe_pow {F : Type*} [Monoid F] (c : F → M → M) (h1 : c 1 = id)
    (hmul : ∀ f g, c (f * g) = c f ∘ c g) (f : F) : ∀ n, c (f ^ n) = (c f)^[n]
  
goal: c (f ^ n) = (c f)^[n]

full_name: iterate_map_add
code: @[to_additive (attr := simp)]
theorem iterate_map_mul {M F : Type*} [Mul M] [FunLike F M M] [MulHomClass F M M]
    (f : F) (n : ℕ) (x y : M) :
    f^[n] (x * y) = f^[n] x * f^[n] y 
goal: (⇑f)^[n] (x + y) = (⇑f)^[n] x + (⇑f)^[n] y

full_name: iterate_map_mul
code: @[to_additive (attr := simp)]
theorem iterate_map_mul {M F : Type*} [Mul M] [FunLike F M M] [MulHomClass F M M]
    (f : F) (n : ℕ) (x y : M) :
    f^[n] (x * y) = f^[n] x * f^[n] y 
goal: (⇑f)^[n] (x * y) = (⇑f)^[n] x * (⇑f)^[n] y

full_name: iterate_map_zero
code: @[to_additive (attr := simp)]
theorem iterate_map_one {M F : Type*} [One M] [FunLike F M M] [OneHomClass F M M]
    (f : F) (n : ℕ) :
    f^[n] 1 = 1 
goal: (⇑f)^[n] 0 = 0

full_name: iterate_map_one
code: @[to_additive (attr := simp)]
theorem iterate_map_one {M F : Type*} [One M] [FunLike F M M] [OneHomClass F M M]
    (f : F) (n : ℕ) :
    f^[n] 1 = 1 
goal: (⇑f)^[n] 1 = 1

full_name: iterate_map_neg
code: @[to_additive (attr := simp)]
theorem iterate_map_inv {M F : Type*} [Group M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) :
    f^[n] x⁻¹ = (f^[n] x)⁻¹ 
goal: (⇑f)^[n] (-x) = -(⇑f)^[n] x

full_name: iterate_map_inv
code: @[to_additive (attr := simp)]
theorem iterate_map_inv {M F : Type*} [Group M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) :
    f^[n] x⁻¹ = (f^[n] x)⁻¹ 
goal: (⇑f)^[n] x⁻¹ = ((⇑f)^[n] x)⁻¹

full_name: iterate_map_sub
code: @[to_additive (attr := simp)]
theorem iterate_map_div {M F : Type*} [Group M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x y : M) :
    f^[n] (x / y) = f^[n] x / f^[n] y 
goal: (⇑f)^[n] (x - y) = (⇑f)^[n] x - (⇑f)^[n] y

full_name: iterate_map_div
code: @[to_additive (attr := simp)]
theorem iterate_map_div {M F : Type*} [Group M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x y : M) :
    f^[n] (x / y) = f^[n] x / f^[n] y 
goal: (⇑f)^[n] (x / y) = (⇑f)^[n] x / (⇑f)^[n] y

full_name: iterate_map_pow
code: @[to_additive (attr := simp)]
theorem iterate_map_pow {M F : Type*} [Monoid M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) (k : ℕ) :
    f^[n] (x ^ k) = f^[n] x ^ k 
goal: (⇑f)^[n] (x ^ k) = (⇑f)^[n] x ^ k

full_name: iterate_map_nsmul
code: @[to_additive (attr := simp)]
theorem iterate_map_pow {M F : Type*} [Monoid M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) (k : ℕ) :
    f^[n] (x ^ k) = f^[n] x ^ k 
goal: (⇑f)^[n] (k • x) = k • (⇑f)^[n] x

full_name: iterate_map_zpow
code: @[to_additive (attr := simp)]
theorem iterate_map_zpow {M F : Type*} [Group M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) (k : ℤ) :
    f^[n] (x ^ k) = f^[n] x ^ k 
goal: (⇑f)^[n] (x ^ k) = (⇑f)^[n] x ^ k

full_name: iterate_map_zsmul
code: @[to_additive (attr := simp)]
theorem iterate_map_zpow {M F : Type*} [Group M] [FunLike F M M] [MonoidHomClass F M M]
    (f : F) (n : ℕ) (x : M) (k : ℤ) :
    f^[n] (x ^ k) = f^[n] x ^ k 
goal: (⇑f)^[n] (k • x) = k • (⇑f)^[n] x

full_name: vadd_iterate
code: @[to_additive (attr := simp)]
theorem smul_iterate [MulAction G H] : (a • · : H → H)^[n] = (a ^ n • ·) 
goal: (fun x => a +ᵥ x)^[n] = fun x => n • a +ᵥ x

full_name: smul_iterate
code: @[to_additive (attr := simp)]
theorem smul_iterate [MulAction G H] : (a • · : H → H)^[n] = (a ^ n • ·) 
goal: (fun x => a • x)^[n] = fun x => a ^ n • x

full_name: smul_iterate_apply
code: @[to_additive]
lemma smul_iterate_apply [MulAction G H] {b : H} : (a • ·)^[n] b = a ^ n • b 
goal: (fun x => a • x)^[n] b = a ^ n • b

full_name: vadd_iterate_apply
code: @[to_additive]
lemma smul_iterate_apply [MulAction G H] {b : H} : (a • ·)^[n] b = a ^ n • b 
goal: (fun x => a +ᵥ x)^[n] b = n • a +ᵥ b

full_name: mul_left_iterate
code: @[to_additive (attr := simp)]
theorem mul_left_iterate : (a * ·)^[n] = (a ^ n * ·) 
goal: (fun x => a * x)^[n] = fun x => a ^ n * x

full_name: add_left_iterate
code: @[to_additive (attr := simp)]
theorem mul_left_iterate : (a * ·)^[n] = (a ^ n * ·) 
goal: (fun x => a + x)^[n] = fun x => n • a + x

full_name: mul_right_iterate
code: @[to_additive (attr := simp)]
theorem mul_right_iterate : (· * a)^[n] = (· * a ^ n) 
goal: (fun x => x * a)^[n] = fun x => x * a ^ n

full_name: add_right_iterate
code: @[to_additive (attr := simp)]
theorem mul_right_iterate : (· * a)^[n] = (· * a ^ n) 
goal: (fun x => x + a)^[n] = fun x => x + n • a

full_name: mul_right_iterate_apply_one
code: @[to_additive]
theorem mul_right_iterate_apply_one : (· * a)^[n] 1 = a ^ n 
goal: (fun x => x * a)^[n] 1 = a ^ n

full_name: add_right_iterate_apply_zero
code: @[to_additive]
theorem mul_right_iterate_apply_one : (· * a)^[n] 1 = a ^ n 
goal: (fun x => x + a)^[n] 0 = n • a

full_name: pow_iterate
code: @[to_additive (attr := simp)]
theorem pow_iterate (n : ℕ) (j : ℕ) : (fun x : G => x ^ n)^[j] = fun x : G => x ^ n ^ j 
goal: (fun x => x ^ n)^[j] = fun x => x ^ n ^ j

full_name: nsmul_iterate
code: @[to_additive (attr := simp)]
theorem pow_iterate (n : ℕ) (j : ℕ) : (fun x : G => x ^ n)^[j] = fun x : G => x ^ n ^ j 
goal: (fun x => n • x)^[j] = fun x => n ^ j • x

full_name: zsmul_iterate
code: @[to_additive (attr := simp)]
theorem zpow_iterate (n : ℤ) (j : ℕ) : (fun x : G => x ^ n)^[j] = fun x => x ^ n ^ j 
goal: (fun x => n • x)^[j] = fun x => n ^ j • x

full_name: zpow_iterate
code: @[to_additive (attr := simp)]
theorem zpow_iterate (n : ℤ) (j : ℕ) : (fun x : G => x ^ n)^[j] = fun x => x ^ n ^ j 
goal: (fun x => x ^ n)^[j] = fun x => x ^ n ^ j

full_name: AddSemiconjBy.function_semiconj_add_left
code: @[to_additive]
theorem SemiconjBy.function_semiconj_mul_left (h : SemiconjBy a b c) :
    Function.Semiconj (a * ·) (b * ·) (c * ·) 
goal: Function.Semiconj (fun x => a + x) (fun x => b + x) fun x => c + x

full_name: SemiconjBy.function_semiconj_mul_left
code: @[to_additive]
theorem SemiconjBy.function_semiconj_mul_left (h : SemiconjBy a b c) :
    Function.Semiconj (a * ·) (b * ·) (c * ·) 
goal: Function.Semiconj (fun x => a * x) (fun x => b * x) fun x => c * x

full_name: Commute.function_commute_mul_left
code: @[to_additive]
theorem Commute.function_commute_mul_left (h : Commute a b) :
    Function.Commute (a * ·) (b * ·) 
goal: Function.Commute (fun x => a * x) fun x => b * x

full_name: AddCommute.function_commute_add_left
code: @[to_additive]
theorem Commute.function_commute_mul_left (h : Commute a b) :
    Function.Commute (a * ·) (b * ·) 
goal: Function.Commute (fun x => a + x) fun x => b + x

full_name: SemiconjBy.function_semiconj_mul_right_swap
code: @[to_additive]
theorem SemiconjBy.function_semiconj_mul_right_swap (h : SemiconjBy a b c) :
    Function.Semiconj (· * a) (· * c) (· * b) 
goal: Function.Semiconj (fun x => x * a) (fun x => x * c) fun x => x * b

full_name: AddSemiconjBy.function_semiconj_add_right_swap
code: @[to_additive]
theorem SemiconjBy.function_semiconj_mul_right_swap (h : SemiconjBy a b c) :
    Function.Semiconj (· * a) (· * c) (· * b) 
goal: Function.Semiconj (fun x => x + a) (fun x => x + c) fun x => x + b

full_name: AddCommute.function_commute_add_right
code: @[to_additive]
theorem Commute.function_commute_mul_right (h : Commute a b) :
    Function.Commute (· * a) (· * b) 
goal: Function.Commute (fun x => x + a) fun x => x + b

full_name: Commute.function_commute_mul_right
code: @[to_additive]
theorem Commute.function_commute_mul_right (h : Commute a b) :
    Function.Commute (· * a) (· * b) 
goal: Function.Commute (fun x => x * a) fun x => x * b