File: Mathlib/Dynamics/FixedPoints/Basic.lean

full_name: Function.IsFixedPt
code: /-- A point `x` is a fixed point of `f : α → α` if `f x = x`. -/
def IsFixedPt (f : α → α) (x : α) 
goal: Prop

full_name: Function.isFixedPt_id
code: /-- Every point is a fixed point of `id`. -/
theorem isFixedPt_id (x : α) : IsFixedPt id x 
goal: Function.IsFixedPt id x

full_name: Function.IsFixedPt.decidable
code: instance decidable [h : DecidableEq α] {f : α → α} {x : α} : Decidable (IsFixedPt f x) 
goal: Decidable (Function.IsFixedPt f x)

full_name: Function.IsFixedPt.eq
code: /-- If `x` is a fixed point of `f`, then `f x = x`. This is useful, e.g., for `rw` or `simp`. -/
protected theorem eq (hf : IsFixedPt f x) : f x = x 
goal: f x = x

full_name: Function.IsFixedPt.comp
code: /-- If `x` is a fixed point of `f` and `g`, then it is a fixed point of `f ∘ g`. -/
protected theorem comp (hf : IsFixedPt f x) (hg : IsFixedPt g x) : IsFixedPt (f ∘ g) x 
goal: Function.IsFixedPt (f ∘ g) x

full_name: Function.IsFixedPt.iterate
code: /-- If `x` is a fixed point of `f`, then it is a fixed point of `f^[n]`. -/
protected theorem iterate (hf : IsFixedPt f x) (n : ℕ) : IsFixedPt f^[n] x 
goal: Function.IsFixedPt f^[n] x

full_name: Function.IsFixedPt.left_of_comp
code: /-- If `x` is a fixed point of `f ∘ g` and `g`, then it is a fixed point of `f`. -/
theorem left_of_comp (hfg : IsFixedPt (f ∘ g) x) (hg : IsFixedPt g x) : IsFixedPt f x 
goal: Function.IsFixedPt f x

full_name: Function.IsFixedPt.to_leftInverse
code: /-- If `x` is a fixed point of `f` and `g` is a left inverse of `f`, then `x` is a fixed
point of `g`. -/
theorem to_leftInverse (hf : IsFixedPt f x) (h : LeftInverse g f) : IsFixedPt g x 
goal: Function.IsFixedPt g x

full_name: Function.IsFixedPt.map
code: /-- If `g` (semi)conjugates `fa` to `fb`, then it sends fixed points of `fa` to fixed points
of `fb`. -/
protected theorem map {x : α} (hx : IsFixedPt fa x) {g : α → β} (h : Semiconj g fa fb) :
    IsFixedPt fb (g x) 
goal: Function.IsFixedPt fb (g x)

full_name: Function.IsFixedPt.apply
code: protected theorem apply {x : α} (hx : IsFixedPt f x) : IsFixedPt f (f x) 
goal: Function.IsFixedPt f (f x)

full_name: Function.IsFixedPt.preimage_iterate
code: theorem preimage_iterate {s : Set α} (h : IsFixedPt (Set.preimage f) s) (n : ℕ) :
    IsFixedPt (Set.preimage f^[n]) s 
goal: Function.IsFixedPt (Set.preimage f^[n]) s

full_name: Function.IsFixedPt.image_iterate
code: lemma image_iterate {s : Set α} (h : IsFixedPt (Set.image f) s) (n : ℕ) :
    IsFixedPt (Set.image f^[n]) s 
goal: Function.IsFixedPt (Set.image f^[n]) s

full_name: Function.IsFixedPt.equiv_symm
code: protected theorem equiv_symm (h : IsFixedPt e x) : IsFixedPt e.symm x 
goal: Function.IsFixedPt (⇑(Equiv.symm e)) x

full_name: Function.IsFixedPt.perm_inv
code: protected theorem perm_inv (h : IsFixedPt e x) : IsFixedPt (⇑e⁻¹) x 
goal: Function.IsFixedPt (⇑e⁻¹) x

full_name: Function.IsFixedPt.perm_pow
code: protected theorem perm_pow (h : IsFixedPt e x) (n : ℕ) : IsFixedPt (⇑(e ^ n)) x 
goal: Function.IsFixedPt (⇑(e ^ n)) x

full_name: Function.IsFixedPt.perm_zpow
code: protected theorem perm_zpow (h : IsFixedPt e x) : ∀ n : ℤ, IsFixedPt (⇑(e ^ n)) x
  
goal: Function.IsFixedPt (⇑(e ^ n)) x

full_name: Function.Injective.isFixedPt_apply_iff
code: @[simp]
theorem Injective.isFixedPt_apply_iff (hf : Injective f) {x : α} :
    IsFixedPt f (f x) ↔ IsFixedPt f x 
goal: Function.IsFixedPt f (f x) ↔ Function.IsFixedPt f x

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

full_name: Function.fixedPoints.decidable
code: instance fixedPoints.decidable [DecidableEq α] (f : α → α) (x : α) :
    Decidable (x ∈ fixedPoints f) 
goal: Decidable (x ∈ Function.fixedPoints f)

full_name: Function.mem_fixedPoints
code: @[simp]
theorem mem_fixedPoints : x ∈ fixedPoints f ↔ IsFixedPt f x 
goal: x ∈ Function.fixedPoints f ↔ Function.IsFixedPt f x

full_name: Function.mem_fixedPoints_iff
code: theorem mem_fixedPoints_iff {α : Type*} {f : α → α} {x : α} : x ∈ fixedPoints f ↔ f x = x 
goal: x ∈ Function.fixedPoints f ↔ f x = x

full_name: Function.fixedPoints_id
code: @[simp]
theorem fixedPoints_id : fixedPoints (@id α) = Set.univ 
goal: Function.fixedPoints id = Set.univ

full_name: Function.fixedPoints_subset_range
code: theorem fixedPoints_subset_range : fixedPoints f ⊆ Set.range f 
goal: Function.fixedPoints f ⊆ Set.range f

full_name: Function.Semiconj.mapsTo_fixedPoints
code: /-- If `g` semiconjugates `fa` to `fb`, then it sends fixed points of `fa` to fixed points
of `fb`. -/
theorem Semiconj.mapsTo_fixedPoints {g : α → β} (h : Semiconj g fa fb) :
    Set.MapsTo g (fixedPoints fa) (fixedPoints fb) 
goal: Set.MapsTo g (Function.fixedPoints fa) (Function.fixedPoints fb)

full_name: Function.invOn_fixedPoints_comp
code: /-- Any two maps `f : α → β` and `g : β → α` are inverse of each other on the sets of fixed points
of `f ∘ g` and `g ∘ f`, respectively. -/
theorem invOn_fixedPoints_comp (f : α → β) (g : β → α) :
    Set.InvOn f g (fixedPoints <| f ∘ g) (fixedPoints <| g ∘ f) 
goal: Set.InvOn f g (Function.fixedPoints (f ∘ g)) (Function.fixedPoints (g ∘ f))

full_name: Function.mapsTo_fixedPoints_comp
code: /-- Any map `f` sends fixed points of `g ∘ f` to fixed points of `f ∘ g`. -/
theorem mapsTo_fixedPoints_comp (f : α → β) (g : β → α) :
    Set.MapsTo f (fixedPoints <| g ∘ f) (fixedPoints <| f ∘ g) 
goal: Set.MapsTo f (Function.fixedPoints (g ∘ f)) (Function.fixedPoints (f ∘ g))

full_name: Function.bijOn_fixedPoints_comp
code: /-- Given two maps `f : α → β` and `g : β → α`, `g` is a bijective map between the fixed points
of `f ∘ g` and the fixed points of `g ∘ f`. The inverse map is `f`, see `invOn_fixedPoints_comp`. -/
theorem bijOn_fixedPoints_comp (f : α → β) (g : β → α) :
    Set.BijOn g (fixedPoints <| f ∘ g) (fixedPoints <| g ∘ f) 
goal: Set.BijOn g (Function.fixedPoints (f ∘ g)) (Function.fixedPoints (g ∘ f))

full_name: Function.Commute.invOn_fixedPoints_comp
code: /-- If self-maps `f` and `g` commute, then they are inverse of each other on the set of fixed points
of `f ∘ g`. This is a particular case of `Function.invOn_fixedPoints_comp`. -/
theorem Commute.invOn_fixedPoints_comp (h : Commute f g) :
    Set.InvOn f g (fixedPoints <| f ∘ g) (fixedPoints <| f ∘ g) 
goal: Set.InvOn f g (Function.fixedPoints (f ∘ g)) (Function.fixedPoints (f ∘ g))

full_name: Function.Commute.left_bijOn_fixedPoints_comp
code: /-- If self-maps `f` and `g` commute, then `f` is bijective on the set of fixed points of `f ∘ g`.
This is a particular case of `Function.bijOn_fixedPoints_comp`. -/
theorem Commute.left_bijOn_fixedPoints_comp (h : Commute f g) :
    Set.BijOn f (fixedPoints <| f ∘ g) (fixedPoints <| f ∘ g) 
goal: Set.BijOn f (Function.fixedPoints (f ∘ g)) (Function.fixedPoints (f ∘ g))

full_name: Function.Commute.right_bijOn_fixedPoints_comp
code: /-- If self-maps `f` and `g` commute, then `g` is bijective on the set of fixed points of `f ∘ g`.
This is a particular case of `Function.bijOn_fixedPoints_comp`. -/
theorem Commute.right_bijOn_fixedPoints_comp (h : Commute f g) :
    Set.BijOn g (fixedPoints <| f ∘ g) (fixedPoints <| f ∘ g) 
goal: Set.BijOn g (Function.fixedPoints (f ∘ g)) (Function.fixedPoints (f ∘ g))