File: Mathlib/Dynamics/PeriodicPts.lean

full_name: Function.IsPeriodicPt
code: /-- A point `x` is a periodic point of `f : α → α` of period `n` if `f^[n] x = x`.
Note that we do not require `0 < n` in this definition. Many theorems about periodic points
need this assumption. -/
def IsPeriodicPt (f : α → α) (n : ℕ) (x : α) 
goal: Prop

full_name: Function.IsFixedPt.isPeriodicPt
code: /-- A fixed point of `f` is a periodic point of `f` of any prescribed period. -/
theorem IsFixedPt.isPeriodicPt (hf : IsFixedPt f x) (n : ℕ) : IsPeriodicPt f n x 
goal: Function.IsPeriodicPt f n x

full_name: Function.is_periodic_id
code: /-- For the identity map, all points are periodic. -/
theorem is_periodic_id (n : ℕ) (x : α) : IsPeriodicPt id n x 
goal: Function.IsPeriodicPt id n x

full_name: Function.isPeriodicPt_zero
code: /-- Any point is a periodic point of period `0`. -/
theorem isPeriodicPt_zero (f : α → α) (x : α) : IsPeriodicPt f 0 x 
goal: Function.IsPeriodicPt f 0 x

full_name: Function.IsPeriodicPt.instDecidableOfDecidableEq
code: instance [DecidableEq α] {f : α → α} {n : ℕ} {x : α} : Decidable (IsPeriodicPt f n x) 
goal: Decidable (Function.IsPeriodicPt f n x)

full_name: Function.IsPeriodicPt.isFixedPt
code: protected theorem isFixedPt (hf : IsPeriodicPt f n x) : IsFixedPt f^[n] x 
goal: Function.IsFixedPt f^[n] x

full_name: Function.IsPeriodicPt.map
code: protected theorem map (hx : IsPeriodicPt fa n x) {g : α → β} (hg : Semiconj g fa fb) :
    IsPeriodicPt fb n (g x) 
goal: Function.IsPeriodicPt fb n (g x)

full_name: Function.IsPeriodicPt.apply_iterate
code: theorem apply_iterate (hx : IsPeriodicPt f n x) (m : ℕ) : IsPeriodicPt f n (f^[m] x) 
goal: Function.IsPeriodicPt f n (f^[m] x)

full_name: Function.IsPeriodicPt.apply
code: protected theorem apply (hx : IsPeriodicPt f n x) : IsPeriodicPt f n (f x) 
goal: Function.IsPeriodicPt f n (f x)

full_name: Function.IsPeriodicPt.add
code: protected theorem add (hn : IsPeriodicPt f n x) (hm : IsPeriodicPt f m x) :
    IsPeriodicPt f (n + m) x 
goal: Function.IsPeriodicPt f (n + m) x

full_name: Function.IsPeriodicPt.left_of_add
code: theorem left_of_add (hn : IsPeriodicPt f (n + m) x) (hm : IsPeriodicPt f m x) :
    IsPeriodicPt f n x 
goal: Function.IsPeriodicPt f n x

full_name: Function.IsPeriodicPt.right_of_add
code: theorem right_of_add (hn : IsPeriodicPt f (n + m) x) (hm : IsPeriodicPt f n x) :
    IsPeriodicPt f m x 
goal: Function.IsPeriodicPt f m x

full_name: Function.IsPeriodicPt.sub
code: protected theorem sub (hm : IsPeriodicPt f m x) (hn : IsPeriodicPt f n x) :
    IsPeriodicPt f (m - n) x 
goal: Function.IsPeriodicPt f (m - n) x

full_name: Function.IsPeriodicPt.mul_const
code: protected theorem mul_const (hm : IsPeriodicPt f m x) (n : ℕ) : IsPeriodicPt f (m * n) x 
goal: Function.IsPeriodicPt f (m * n) x

full_name: Function.IsPeriodicPt.const_mul
code: protected theorem const_mul (hm : IsPeriodicPt f m x) (n : ℕ) : IsPeriodicPt f (n * m) x 
goal: Function.IsPeriodicPt f (n * m) x

full_name: Function.IsPeriodicPt.trans_dvd
code: theorem trans_dvd (hm : IsPeriodicPt f m x) {n : ℕ} (hn : m ∣ n) : IsPeriodicPt f n x 
goal: Function.IsPeriodicPt f n x

full_name: Function.IsPeriodicPt.iterate
code: protected theorem iterate (hf : IsPeriodicPt f n x) (m : ℕ) : IsPeriodicPt f^[m] n x 
goal: Function.IsPeriodicPt f^[m] n x

full_name: Function.IsPeriodicPt.comp
code: theorem comp {g : α → α} (hco : Commute f g) (hf : IsPeriodicPt f n x) (hg : IsPeriodicPt g n x) :
    IsPeriodicPt (f ∘ g) n x 
goal: Function.IsPeriodicPt (f ∘ g) n x

full_name: Function.IsPeriodicPt.comp_lcm
code: theorem comp_lcm {g : α → α} (hco : Commute f g) (hf : IsPeriodicPt f m x)
    (hg : IsPeriodicPt g n x) : IsPeriodicPt (f ∘ g) (Nat.lcm m n) x 
goal: Function.IsPeriodicPt (f ∘ g) (m.lcm n) x

full_name: Function.IsPeriodicPt.left_of_comp
code: theorem left_of_comp {g : α → α} (hco : Commute f g) (hfg : IsPeriodicPt (f ∘ g) n x)
    (hg : IsPeriodicPt g n x) : IsPeriodicPt f n x 
goal: Function.IsPeriodicPt f n x

full_name: Function.IsPeriodicPt.iterate_mod_apply
code: theorem iterate_mod_apply (h : IsPeriodicPt f n x) (m : ℕ) : f^[m % n] x = f^[m] x 
goal: f^[m % n] x = f^[m] x

full_name: Function.IsPeriodicPt.mod
code: protected theorem mod (hm : IsPeriodicPt f m x) (hn : IsPeriodicPt f n x) :
    IsPeriodicPt f (m % n) x 
goal: Function.IsPeriodicPt f (m % n) x

full_name: Function.IsPeriodicPt.gcd
code: protected theorem gcd (hm : IsPeriodicPt f m x) (hn : IsPeriodicPt f n x) :
    IsPeriodicPt f (m.gcd n) x 
goal: Function.IsPeriodicPt f (m.gcd n) x

full_name: Function.IsPeriodicPt.eq_of_apply_eq_same
code: /-- If `f` sends two periodic points `x` and `y` of the same positive period to the same point,
then `x = y`. For a similar statement about points of different periods see `eq_of_apply_eq`. -/
theorem eq_of_apply_eq_same (hx : IsPeriodicPt f n x) (hy : IsPeriodicPt f n y) (hn : 0 < n)
    (h : f x = f y) : x = y 
goal: x = y

full_name: Function.IsPeriodicPt.eq_of_apply_eq
code: /-- If `f` sends two periodic points `x` and `y` of positive periods to the same point,
then `x = y`. -/
theorem eq_of_apply_eq (hx : IsPeriodicPt f m x) (hy : IsPeriodicPt f n y) (hm : 0 < m) (hn : 0 < n)
    (h : f x = f y) : x = y 
goal: x = y

full_name: Function.ptsOfPeriod
code: /-- The set of periodic points of a given (possibly non-minimal) period. -/
def ptsOfPeriod (f : α → α) (n : ℕ) : Set α 
goal: Set α

full_name: Function.mem_ptsOfPeriod
code: @[simp]
theorem mem_ptsOfPeriod : x ∈ ptsOfPeriod f n ↔ IsPeriodicPt f n x 
goal: x ∈ Function.ptsOfPeriod f n ↔ Function.IsPeriodicPt f n x

full_name: Function.Semiconj.mapsTo_ptsOfPeriod
code: theorem Semiconj.mapsTo_ptsOfPeriod {g : α → β} (h : Semiconj g fa fb) (n : ℕ) :
    MapsTo g (ptsOfPeriod fa n) (ptsOfPeriod fb n) 
goal: Set.MapsTo g (Function.ptsOfPeriod fa n) (Function.ptsOfPeriod fb n)

full_name: Function.bijOn_ptsOfPeriod
code: theorem bijOn_ptsOfPeriod (f : α → α) {n : ℕ} (hn : 0 < n) :
    BijOn f (ptsOfPeriod f n) (ptsOfPeriod f n) 
goal: Set.BijOn f (Function.ptsOfPeriod f n) (Function.ptsOfPeriod f n)

full_name: Function.directed_ptsOfPeriod_pNat
code: theorem directed_ptsOfPeriod_pNat (f : α → α) : Directed (· ⊆ ·) fun n : ℕ+ => ptsOfPeriod f n 
goal: Directed (fun x x_1 => x ⊆ x_1) fun n => Function.ptsOfPeriod f ↑n

full_name: Function.periodicPts
code: /-- The set of periodic points of a map `f : α → α`. -/
def periodicPts (f : α → α) : Set α 
goal: Set α

full_name: Function.mk_mem_periodicPts
code: theorem mk_mem_periodicPts (hn : 0 < n) (hx : IsPeriodicPt f n x) : x ∈ periodicPts f 
goal: x ∈ Function.periodicPts f

full_name: Function.mem_periodicPts
code: theorem mem_periodicPts : x ∈ periodicPts f ↔ ∃ n > 0, IsPeriodicPt f n x 
goal: x ∈ Function.periodicPts f ↔ ∃ n > 0, Function.IsPeriodicPt f n x

full_name: Function.isPeriodicPt_of_mem_periodicPts_of_isPeriodicPt_iterate
code: theorem isPeriodicPt_of_mem_periodicPts_of_isPeriodicPt_iterate (hx : x ∈ periodicPts f)
    (hm : IsPeriodicPt f m (f^[n] x)) : IsPeriodicPt f m x 
goal: Function.IsPeriodicPt f m x

full_name: Function.bUnion_ptsOfPeriod
code: theorem bUnion_ptsOfPeriod : ⋃ n > 0, ptsOfPeriod f n = periodicPts f 
goal: ⋃ n, ⋃ (_ : n > 0), Function.ptsOfPeriod f n = Function.periodicPts f

full_name: Function.iUnion_pNat_ptsOfPeriod
code: theorem iUnion_pNat_ptsOfPeriod : ⋃ n : ℕ+, ptsOfPeriod f n = periodicPts f 
goal: ⋃ n, Function.ptsOfPeriod f ↑n = Function.periodicPts f

full_name: Function.bijOn_periodicPts
code: theorem bijOn_periodicPts : BijOn f (periodicPts f) (periodicPts f) 
goal: Set.BijOn f (Function.periodicPts f) (Function.periodicPts f)

full_name: Function.Semiconj.mapsTo_periodicPts
code: theorem Semiconj.mapsTo_periodicPts {g : α → β} (h : Semiconj g fa fb) :
    MapsTo g (periodicPts fa) (periodicPts fb) 
goal: Set.MapsTo g (Function.periodicPts fa) (Function.periodicPts fb)

full_name: Function.minimalPeriod
code: /-- Minimal period of a point `x` under an endomorphism `f`. If `x` is not a periodic point of `f`,
then `minimalPeriod f x = 0`. -/
def minimalPeriod (f : α → α) (x : α) 
goal: ℕ

full_name: Function.isPeriodicPt_minimalPeriod
code: theorem isPeriodicPt_minimalPeriod (f : α → α) (x : α) : IsPeriodicPt f (minimalPeriod f x) x 
goal: Function.IsPeriodicPt f (Function.minimalPeriod f x) x

full_name: Function.iterate_minimalPeriod
code: @[simp]
theorem iterate_minimalPeriod : f^[minimalPeriod f x] x = x 
goal: f^[Function.minimalPeriod f x] x = x

full_name: Function.iterate_add_minimalPeriod_eq
code: @[simp]
theorem iterate_add_minimalPeriod_eq : f^[n + minimalPeriod f x] x = f^[n] x 
goal: f^[n + Function.minimalPeriod f x] x = f^[n] x

full_name: Function.iterate_mod_minimalPeriod_eq
code: @[simp]
theorem iterate_mod_minimalPeriod_eq : f^[n % minimalPeriod f x] x = f^[n] x 
goal: f^[n % Function.minimalPeriod f x] x = f^[n] x

full_name: Function.minimalPeriod_pos_of_mem_periodicPts
code: theorem minimalPeriod_pos_of_mem_periodicPts (hx : x ∈ periodicPts f) : 0 < minimalPeriod f x 
goal: 0 < Function.minimalPeriod f x

full_name: Function.minimalPeriod_eq_zero_of_nmem_periodicPts
code: theorem minimalPeriod_eq_zero_of_nmem_periodicPts (hx : x ∉ periodicPts f) :
    minimalPeriod f x = 0 
goal: Function.minimalPeriod f x = 0

full_name: Function.IsPeriodicPt.minimalPeriod_pos
code: theorem IsPeriodicPt.minimalPeriod_pos (hn : 0 < n) (hx : IsPeriodicPt f n x) :
    0 < minimalPeriod f x 
goal: 0 < Function.minimalPeriod f x

full_name: Function.minimalPeriod_pos_iff_mem_periodicPts
code: theorem minimalPeriod_pos_iff_mem_periodicPts : 0 < minimalPeriod f x ↔ x ∈ periodicPts f 
goal: 0 < Function.minimalPeriod f x ↔ x ∈ Function.periodicPts f

full_name: Function.minimalPeriod_eq_zero_iff_nmem_periodicPts
code: theorem minimalPeriod_eq_zero_iff_nmem_periodicPts : minimalPeriod f x = 0 ↔ x ∉ periodicPts f 
goal: Function.minimalPeriod f x = 0 ↔ x ∉ Function.periodicPts f

full_name: Function.IsPeriodicPt.minimalPeriod_le
code: theorem IsPeriodicPt.minimalPeriod_le (hn : 0 < n) (hx : IsPeriodicPt f n x) :
    minimalPeriod f x ≤ n 
goal: Function.minimalPeriod f x ≤ n

full_name: Function.minimalPeriod_apply_iterate
code: theorem minimalPeriod_apply_iterate (hx : x ∈ periodicPts f) (n : ℕ) :
    minimalPeriod f (f^[n] x) = minimalPeriod f x 
goal: Function.minimalPeriod f (f^[n] x) = Function.minimalPeriod f x

full_name: Function.minimalPeriod_apply
code: theorem minimalPeriod_apply (hx : x ∈ periodicPts f) : minimalPeriod f (f x) = minimalPeriod f x 
goal: Function.minimalPeriod f (f x) = Function.minimalPeriod f x

full_name: Function.le_of_lt_minimalPeriod_of_iterate_eq
code: theorem le_of_lt_minimalPeriod_of_iterate_eq {m n : ℕ} (hm : m < minimalPeriod f x)
    (hmn : f^[m] x = f^[n] x) : m ≤ n 
goal: m ≤ n

full_name: Function.iterate_injOn_Iio_minimalPeriod
code: theorem iterate_injOn_Iio_minimalPeriod : (Iio <| minimalPeriod f x).InjOn (f^[·] x) 
goal: Set.InjOn (fun x_1 => f^[x_1] x) (Set.Iio (Function.minimalPeriod f x))

full_name: Function.iterate_eq_iterate_iff_of_lt_minimalPeriod
code: theorem iterate_eq_iterate_iff_of_lt_minimalPeriod {m n : ℕ} (hm : m < minimalPeriod f x)
    (hn : n < minimalPeriod f x) : f^[m] x = f^[n] x ↔ m = n 
goal: f^[m] x = f^[n] x ↔ m = n

full_name: Function.minimalPeriod_id
code: @[simp] theorem minimalPeriod_id : minimalPeriod id x = 1 
goal: Function.minimalPeriod id x = 1

full_name: Function.minimalPeriod_eq_one_iff_isFixedPt
code: theorem minimalPeriod_eq_one_iff_isFixedPt : minimalPeriod f x = 1 ↔ IsFixedPt f x 
goal: Function.minimalPeriod f x = 1 ↔ Function.IsFixedPt f x

full_name: Function.IsPeriodicPt.eq_zero_of_lt_minimalPeriod
code: theorem IsPeriodicPt.eq_zero_of_lt_minimalPeriod (hx : IsPeriodicPt f n x)
    (hn : n < minimalPeriod f x) : n = 0 
goal: n = 0

full_name: Function.not_isPeriodicPt_of_pos_of_lt_minimalPeriod
code: theorem not_isPeriodicPt_of_pos_of_lt_minimalPeriod :
    ∀ {n : ℕ} (_ : n ≠ 0) (_ : n < minimalPeriod f x), ¬IsPeriodicPt f n x
  
goal: n ≠ 0 → n < Function.minimalPeriod f x → ¬Function.IsPeriodicPt f n x

full_name: Function.IsPeriodicPt.minimalPeriod_dvd
code: theorem IsPeriodicPt.minimalPeriod_dvd (hx : IsPeriodicPt f n x) : minimalPeriod f x ∣ n 
goal: Function.minimalPeriod f x ∣ n

full_name: Function.isPeriodicPt_iff_minimalPeriod_dvd
code: theorem isPeriodicPt_iff_minimalPeriod_dvd : IsPeriodicPt f n x ↔ minimalPeriod f x ∣ n 
goal: Function.IsPeriodicPt f n x ↔ Function.minimalPeriod f x ∣ n

full_name: Function.minimalPeriod_eq_minimalPeriod_iff
code: theorem minimalPeriod_eq_minimalPeriod_iff {g : β → β} {y : β} :
    minimalPeriod f x = minimalPeriod g y ↔ ∀ n, IsPeriodicPt f n x ↔ IsPeriodicPt g n y 
goal: Function.minimalPeriod f x = Function.minimalPeriod g y ↔
  ∀ (n : ℕ), Function.IsPeriodicPt f n x ↔ Function.IsPeriodicPt g n y

full_name: Function.minimalPeriod_eq_prime
code: theorem minimalPeriod_eq_prime {p : ℕ} [hp : Fact p.Prime] (hper : IsPeriodicPt f p x)
    (hfix : ¬IsFixedPt f x) : minimalPeriod f x = p 
goal: Function.minimalPeriod f x = p

full_name: Function.minimalPeriod_eq_prime_pow
code: theorem minimalPeriod_eq_prime_pow {p k : ℕ} [hp : Fact p.Prime] (hk : ¬IsPeriodicPt f (p ^ k) x)
    (hk1 : IsPeriodicPt f (p ^ (k + 1)) x) : minimalPeriod f x = p ^ (k + 1) 
goal: Function.minimalPeriod f x = p ^ (k + 1)

full_name: Function.Commute.minimalPeriod_of_comp_dvd_lcm
code: theorem Commute.minimalPeriod_of_comp_dvd_lcm {g : α → α} (h : Commute f g) :
    minimalPeriod (f ∘ g) x ∣ Nat.lcm (minimalPeriod f x) (minimalPeriod g x) 
goal: Function.minimalPeriod (f ∘ g) x ∣ (Function.minimalPeriod f x).lcm (Function.minimalPeriod g x)

full_name: Function.Commute.minimalPeriod_of_comp_dvd_mul
code: theorem Commute.minimalPeriod_of_comp_dvd_mul {g : α → α} (h : Commute f g) :
    minimalPeriod (f ∘ g) x ∣ minimalPeriod f x * minimalPeriod g x 
goal: Function.minimalPeriod (f ∘ g) x ∣ Function.minimalPeriod f x * Function.minimalPeriod g x

full_name: Function.Commute.minimalPeriod_of_comp_eq_mul_of_coprime
code: theorem Commute.minimalPeriod_of_comp_eq_mul_of_coprime {g : α → α} (h : Commute f g)
    (hco : Coprime (minimalPeriod f x) (minimalPeriod g x)) :
    minimalPeriod (f ∘ g) x = minimalPeriod f x * minimalPeriod g x 
goal: Function.minimalPeriod (f ∘ g) x = Function.minimalPeriod f x * Function.minimalPeriod g x

full_name: _private.Mathlib.Dynamics.PeriodicPts.0.Function.minimalPeriod_iterate_eq_div_gcd_aux
code: private theorem minimalPeriod_iterate_eq_div_gcd_aux (h : 0 < gcd (minimalPeriod f x) n) :
    minimalPeriod f^[n] x = minimalPeriod f x / Nat.gcd (minimalPeriod f x) n 
goal: Function.minimalPeriod f^[n] x = Function.minimalPeriod f x / (Function.minimalPeriod f x).gcd n

full_name: Function.minimalPeriod_iterate_eq_div_gcd
code: theorem minimalPeriod_iterate_eq_div_gcd (h : n ≠ 0) :
    minimalPeriod f^[n] x = minimalPeriod f x / Nat.gcd (minimalPeriod f x) n 
goal: Function.minimalPeriod f^[n] x = Function.minimalPeriod f x / (Function.minimalPeriod f x).gcd n

full_name: Function.minimalPeriod_iterate_eq_div_gcd'
code: theorem minimalPeriod_iterate_eq_div_gcd' (h : x ∈ periodicPts f) :
    minimalPeriod f^[n] x = minimalPeriod f x / Nat.gcd (minimalPeriod f x) n 
goal: Function.minimalPeriod f^[n] x = Function.minimalPeriod f x / (Function.minimalPeriod f x).gcd n

full_name: Function.periodicOrbit
code: /-- The orbit of a periodic point `x` of `f` is the cycle `[x, f x, f (f x), ...]`. Its length is
the minimal period of `x`.

If `x` is not a periodic point, then this is the empty (aka nil) cycle. -/
def periodicOrbit (f : α → α) (x : α) : Cycle α 
goal: Cycle α

full_name: Function.periodicOrbit_def
code: /-- The definition of a periodic orbit, in terms of `List.map`. -/
theorem periodicOrbit_def (f : α → α) (x : α) :
    periodicOrbit f x = (List.range (minimalPeriod f x)).map fun n => f^[n] x 
goal: Function.periodicOrbit f x = ↑(List.map (fun n => f^[n] x) (List.range (Function.minimalPeriod f x)))

full_name: Function.periodicOrbit_eq_cycle_map
code: /-- The definition of a periodic orbit, in terms of `Cycle.map`. -/
theorem periodicOrbit_eq_cycle_map (f : α → α) (x : α) :
    periodicOrbit f x = (List.range (minimalPeriod f x) : Cycle ℕ).map fun n => f^[n] x 
goal: Function.periodicOrbit f x = Cycle.map (fun n => f^[n] x) ↑(List.range (Function.minimalPeriod f x))

full_name: Function.periodicOrbit_length
code: @[simp]
theorem periodicOrbit_length : (periodicOrbit f x).length = minimalPeriod f x 
goal: (Function.periodicOrbit f x).length = Function.minimalPeriod f x

full_name: Function.periodicOrbit_eq_nil_iff_not_periodic_pt
code: @[simp]
theorem periodicOrbit_eq_nil_iff_not_periodic_pt :
    periodicOrbit f x = Cycle.nil ↔ x ∉ periodicPts f 
goal: Function.periodicOrbit f x = Cycle.nil ↔ x ∉ Function.periodicPts f

full_name: Function.periodicOrbit_eq_nil_of_not_periodic_pt
code: theorem periodicOrbit_eq_nil_of_not_periodic_pt (h : x ∉ periodicPts f) :
    periodicOrbit f x = Cycle.nil 
goal: Function.periodicOrbit f x = Cycle.nil

full_name: Function.mem_periodicOrbit_iff
code: @[simp]
theorem mem_periodicOrbit_iff (hx : x ∈ periodicPts f) :
    y ∈ periodicOrbit f x ↔ ∃ n, f^[n] x = y 
goal: y ∈ Function.periodicOrbit f x ↔ ∃ n, f^[n] x = y

full_name: Function.iterate_mem_periodicOrbit
code: @[simp]
theorem iterate_mem_periodicOrbit (hx : x ∈ periodicPts f) (n : ℕ) :
    f^[n] x ∈ periodicOrbit f x 
goal: f^[n] x ∈ Function.periodicOrbit f x

full_name: Function.self_mem_periodicOrbit
code: @[simp]
theorem self_mem_periodicOrbit (hx : x ∈ periodicPts f) : x ∈ periodicOrbit f x 
goal: x ∈ Function.periodicOrbit f x

full_name: Function.nodup_periodicOrbit
code: theorem nodup_periodicOrbit : (periodicOrbit f x).Nodup 
goal: (Function.periodicOrbit f x).Nodup

full_name: Function.periodicOrbit_apply_iterate_eq
code: theorem periodicOrbit_apply_iterate_eq (hx : x ∈ periodicPts f) (n : ℕ) :
    periodicOrbit f (f^[n] x) = periodicOrbit f x 
goal: Function.periodicOrbit f (f^[n] x) = Function.periodicOrbit f x

full_name: Function.periodicOrbit_apply_eq
code: theorem periodicOrbit_apply_eq (hx : x ∈ periodicPts f) :
    periodicOrbit f (f x) = periodicOrbit f x 
goal: Function.periodicOrbit f (f x) = Function.periodicOrbit f x

full_name: Function.periodicOrbit_chain
code: theorem periodicOrbit_chain (r : α → α → Prop) {f : α → α} {x : α} :
    (periodicOrbit f x).Chain r ↔ ∀ n < minimalPeriod f x, r (f^[n] x) (f^[n + 1] x) 
goal: Cycle.Chain r (Function.periodicOrbit f x) ↔ ∀ n < Function.minimalPeriod f x, r (f^[n] x) (f^[n + 1] x)

full_name: Function.periodicOrbit_chain'
code: theorem periodicOrbit_chain' (r : α → α → Prop) {f : α → α} {x : α} (hx : x ∈ periodicPts f) :
    (periodicOrbit f x).Chain r ↔ ∀ n, r (f^[n] x) (f^[n + 1] x) 
goal: Cycle.Chain r (Function.periodicOrbit f x) ↔ ∀ (n : ℕ), r (f^[n] x) (f^[n + 1] x)

full_name: Function.isFixedPt_prod_map
code: @[simp]
theorem isFixedPt_prod_map (x : α × β) :
    IsFixedPt (Prod.map f g) x ↔ IsFixedPt f x.1 ∧ IsFixedPt g x.2 
goal: Function.IsFixedPt (Prod.map f g) x ↔ Function.IsFixedPt f x.1 ∧ Function.IsFixedPt g x.2

full_name: Function.isPeriodicPt_prod_map
code: @[simp]
theorem isPeriodicPt_prod_map (x : α × β) :
    IsPeriodicPt (Prod.map f g) n x ↔ IsPeriodicPt f n x.1 ∧ IsPeriodicPt g n x.2 
goal: Function.IsPeriodicPt (Prod.map f g) n x ↔ Function.IsPeriodicPt f n x.1 ∧ Function.IsPeriodicPt g n x.2

full_name: Function.minimalPeriod_prod_map
code: theorem minimalPeriod_prod_map (f : α → α) (g : β → β) (x : α × β) :
    minimalPeriod (Prod.map f g) x = (minimalPeriod f x.1).lcm (minimalPeriod g x.2) 
goal: Function.minimalPeriod (Prod.map f g) x = (Function.minimalPeriod f x.1).lcm (Function.minimalPeriod g x.2)

full_name: Function.minimalPeriod_fst_dvd
code: theorem minimalPeriod_fst_dvd : minimalPeriod f x.1 ∣ minimalPeriod (Prod.map f g) x 
goal: Function.minimalPeriod f x.1 ∣ Function.minimalPeriod (Prod.map f g) x

full_name: Function.minimalPeriod_snd_dvd
code: theorem minimalPeriod_snd_dvd : minimalPeriod g x.2 ∣ minimalPeriod (Prod.map f g) x 
goal: Function.minimalPeriod g x.2 ∣ Function.minimalPeriod (Prod.map f g) x

full_name: MulAction.period
code: /--
The period of a multiplicative action of `g` on `a` is the smallest positive `n` such that
`g ^ n • a = a`, or `0` if such an `n` does not exist.
-/
@[to_additive "The period of an additive action of `g` on `a` is the smallest positive `n`
such that `(n • g) +ᵥ a = a`, or `0` if such an `n` does not exist."]
noncomputable def period (m : M) (a : α) : ℕ 
goal: ℕ

full_name: AddAction.period
code: /--
The period of a multiplicative action of `g` on `a` is the smallest positive `n` such that
`g ^ n • a = a`, or `0` if such an `n` does not exist.
-/
@[to_additive "The period of an additive action of `g` on `a` is the smallest positive `n`
such that `(n • g) +ᵥ a = a`, or `0` if such an `n` does not exist."]
noncomputable def period (m : M) (a : α) : ℕ 
goal: ℕ

full_name: MulAction.period_eq_minimalPeriod
code: /-- `MulAction.period m a` is definitionally equal to `Function.minimalPeriod (m • ·) a`. -/
@[to_additive "`AddAction.period m a` is definitionally equal to
`Function.minimalPeriod (m +ᵥ ·) a`"]
theorem period_eq_minimalPeriod {m : M} {a : α} :
    MulAction.period m a = minimalPeriod (fun x => m • x) a 
goal: MulAction.period m a = Function.minimalPeriod (fun x => m • x) a

full_name: AddAction.period_eq_minimalPeriod
code: /-- `MulAction.period m a` is definitionally equal to `Function.minimalPeriod (m • ·) a`. -/
@[to_additive "`AddAction.period m a` is definitionally equal to
`Function.minimalPeriod (m +ᵥ ·) a`"]
theorem period_eq_minimalPeriod {m : M} {a : α} :
    MulAction.period m a = minimalPeriod (fun x => m • x) a 
goal: AddAction.period m a = Function.minimalPeriod (fun x => m +ᵥ x) a

full_name: MulAction.pow_period_smul
code: /-- `m ^ (period m a)` fixes `a`. -/
@[to_additive (attr := simp) "`(period m a) • m` fixes `a`."]
theorem pow_period_smul (m : M) (a : α) : m ^ (period m a) • a = a 
goal: m ^ MulAction.period m a • a = a

full_name: AddAction.nsmul_period_vadd
code: /-- `m ^ (period m a)` fixes `a`. -/
@[to_additive (attr := simp) "`(period m a) • m` fixes `a`."]
theorem pow_period_smul (m : M) (a : α) : m ^ (period m a) • a = a 
goal: AddAction.period m a • m +ᵥ a = a

full_name: MulAction.isPeriodicPt_smul_iff
code: @[to_additive]
lemma isPeriodicPt_smul_iff {m : M} {a : α} {n : ℕ} :
    IsPeriodicPt (m • ·) n a ↔ m ^ n • a = a 
goal: Function.IsPeriodicPt (fun x => m • x) n a ↔ m ^ n • a = a

full_name: AddAction.isPeriodicPt_vadd_iff
code: @[to_additive]
lemma isPeriodicPt_smul_iff {m : M} {a : α} {n : ℕ} :
    IsPeriodicPt (m • ·) n a ↔ m ^ n • a = a 
goal: Function.IsPeriodicPt (fun x => m +ᵥ x) n a ↔ n • m +ᵥ a = a

full_name: AddAction.nsmul_vadd_eq_iff_period_dvd
code: @[to_additive]
theorem pow_smul_eq_iff_period_dvd {n : ℕ} {m : M} {a : α} :
    m ^ n • a = a ↔ period m a ∣ n 
goal: n • m +ᵥ a = a ↔ AddAction.period m a ∣ n

full_name: MulAction.pow_smul_eq_iff_period_dvd
code: @[to_additive]
theorem pow_smul_eq_iff_period_dvd {n : ℕ} {m : M} {a : α} :
    m ^ n • a = a ↔ period m a ∣ n 
goal: m ^ n • a = a ↔ MulAction.period m a ∣ n

full_name: AddAction.zsmul_vadd_eq_iff_period_dvd
code: @[to_additive]
theorem zpow_smul_eq_iff_period_dvd {j : ℤ} {g : G} {a : α} :
    g ^ j • a = a ↔ (period g a : ℤ) ∣ j 
goal: j • g +ᵥ a = a ↔ ↑(AddAction.period g a) ∣ j

full_name: MulAction.zpow_smul_eq_iff_period_dvd
code: @[to_additive]
theorem zpow_smul_eq_iff_period_dvd {j : ℤ} {g : G} {a : α} :
    g ^ j • a = a ↔ (period g a : ℤ) ∣ j 
goal: g ^ j • a = a ↔ ↑(MulAction.period g a) ∣ j

full_name: AddAction.nsmul_mod_period_vadd
code: @[to_additive (attr := simp)]
theorem pow_mod_period_smul (n : ℕ) {m : M} {a : α} :
    m ^ (n % period m a) • a = m ^ n • a 
goal: (n % AddAction.period m a) • m +ᵥ a = n • m +ᵥ a

full_name: MulAction.pow_mod_period_smul
code: @[to_additive (attr := simp)]
theorem pow_mod_period_smul (n : ℕ) {m : M} {a : α} :
    m ^ (n % period m a) • a = m ^ n • a 
goal: m ^ (n % MulAction.period m a) • a = m ^ n • a

full_name: MulAction.zpow_mod_period_smul
code: @[to_additive (attr := simp)]
theorem zpow_mod_period_smul (j : ℤ) {g : G} {a : α} :
    g ^ (j % (period g a : ℤ)) • a = g ^ j • a 
goal: g ^ (j % ↑(MulAction.period g a)) • a = g ^ j • a

full_name: AddAction.zsmul_mod_period_vadd
code: @[to_additive (attr := simp)]
theorem zpow_mod_period_smul (j : ℤ) {g : G} {a : α} :
    g ^ (j % (period g a : ℤ)) • a = g ^ j • a 
goal: (j % ↑(AddAction.period g a)) • g +ᵥ a = j • g +ᵥ a

full_name: AddAction.nsmul_add_period_vadd
code: @[to_additive (attr := simp)]
theorem pow_add_period_smul (n : ℕ) (m : M) (a : α) :
    m ^ (n + period m a) • a = m ^ n • a 
goal: (n + AddAction.period m a) • m +ᵥ a = n • m +ᵥ a

full_name: MulAction.pow_add_period_smul
code: @[to_additive (attr := simp)]
theorem pow_add_period_smul (n : ℕ) (m : M) (a : α) :
    m ^ (n + period m a) • a = m ^ n • a 
goal: m ^ (n + MulAction.period m a) • a = m ^ n • a

full_name: MulAction.pow_period_add_smul
code: @[to_additive (attr := simp)]
theorem pow_period_add_smul (n : ℕ) (m : M) (a : α) :
    m ^ (period m a + n) • a = m ^ n • a 
goal: m ^ (MulAction.period m a + n) • a = m ^ n • a

full_name: AddAction.nsmul_period_add_vadd
code: @[to_additive (attr := simp)]
theorem pow_period_add_smul (n : ℕ) (m : M) (a : α) :
    m ^ (period m a + n) • a = m ^ n • a 
goal: (AddAction.period m a + n) • m +ᵥ a = n • m +ᵥ a

full_name: MulAction.zpow_add_period_smul
code: @[to_additive (attr := simp)]
theorem zpow_add_period_smul (i : ℤ) (g : G) (a : α) :
    g ^ (i + period g a) • a = g ^ i • a 
goal: g ^ (i + ↑(MulAction.period g a)) • a = g ^ i • a

full_name: AddAction.zsmul_add_period_vadd
code: @[to_additive (attr := simp)]
theorem zpow_add_period_smul (i : ℤ) (g : G) (a : α) :
    g ^ (i + period g a) • a = g ^ i • a 
goal: (i + ↑(AddAction.period g a)) • g +ᵥ a = i • g +ᵥ a

full_name: AddAction.zsmul_period_add_vadd
code: @[to_additive (attr := simp)]
theorem zpow_period_add_smul (i : ℤ) (g : G) (a : α) :
    g ^ (period g a + i) • a = g ^ i • a 
goal: (↑(AddAction.period g a) + i) • g +ᵥ a = i • g +ᵥ a

full_name: MulAction.zpow_period_add_smul
code: @[to_additive (attr := simp)]
theorem zpow_period_add_smul (i : ℤ) (g : G) (a : α) :
    g ^ (period g a + i) • a = g ^ i • a 
goal: g ^ (↑(MulAction.period g a) + i) • a = g ^ i • a

full_name: MulAction.pow_smul_eq_iff_minimalPeriod_dvd
code: @[to_additive]
theorem pow_smul_eq_iff_minimalPeriod_dvd {n : ℕ} :
    a ^ n • b = b ↔ minimalPeriod (a • ·) b ∣ n 
goal: a ^ n • b = b ↔ Function.minimalPeriod (fun x => a • x) b ∣ n

full_name: AddAction.nsmul_vadd_eq_iff_minimalPeriod_dvd
code: @[to_additive]
theorem pow_smul_eq_iff_minimalPeriod_dvd {n : ℕ} :
    a ^ n • b = b ↔ minimalPeriod (a • ·) b ∣ n 
goal: n • a +ᵥ b = b ↔ Function.minimalPeriod (fun x => a +ᵥ x) b ∣ n

full_name: MulAction.zpow_smul_eq_iff_minimalPeriod_dvd
code: @[to_additive]
theorem zpow_smul_eq_iff_minimalPeriod_dvd {n : ℤ} :
    a ^ n • b = b ↔ (minimalPeriod (a • ·) b : ℤ) ∣ n 
goal: a ^ n • b = b ↔ ↑(Function.minimalPeriod (fun x => a • x) b) ∣ n

full_name: AddAction.zsmul_vadd_eq_iff_minimalPeriod_dvd
code: @[to_additive]
theorem zpow_smul_eq_iff_minimalPeriod_dvd {n : ℤ} :
    a ^ n • b = b ↔ (minimalPeriod (a • ·) b : ℤ) ∣ n 
goal: n • a +ᵥ b = b ↔ ↑(Function.minimalPeriod (fun x => a +ᵥ x) b) ∣ n

full_name: MulAction.pow_smul_mod_minimalPeriod
code: @[to_additive (attr := simp)]
theorem pow_smul_mod_minimalPeriod (n : ℕ) :
    a ^ (n % minimalPeriod (a • ·) b) • b = a ^ n • b 
goal: a ^ (n % Function.minimalPeriod (fun x => a • x) b) • b = a ^ n • b

full_name: AddAction.nsmul_vadd_mod_minimalPeriod
code: @[to_additive (attr := simp)]
theorem pow_smul_mod_minimalPeriod (n : ℕ) :
    a ^ (n % minimalPeriod (a • ·) b) • b = a ^ n • b 
goal: (n % Function.minimalPeriod (fun x => a +ᵥ x) b) • a +ᵥ b = n • a +ᵥ b

full_name: AddAction.zsmul_vadd_mod_minimalPeriod
code: @[to_additive (attr := simp)]
theorem zpow_smul_mod_minimalPeriod (n : ℤ) :
    a ^ (n % (minimalPeriod (a • ·) b : ℤ)) • b = a ^ n • b 
goal: (n % ↑(Function.minimalPeriod (fun x => a +ᵥ x) b)) • a +ᵥ b = n • a +ᵥ b

full_name: MulAction.zpow_smul_mod_minimalPeriod
code: @[to_additive (attr := simp)]
theorem zpow_smul_mod_minimalPeriod (n : ℤ) :
    a ^ (n % (minimalPeriod (a • ·) b : ℤ)) • b = a ^ n • b 
goal: a ^ (n % ↑(Function.minimalPeriod (fun x => a • x) b)) • b = a ^ n • b