File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

full_name: CircleDeg1Lift.map_add_one'
code: /-- A lift of a monotone degree one map `S¹ → S¹`. -/
structure CircleDeg1Lift extends ℝ →o ℝ : Type where
  map_add_one' : ∀ x, toFun (x + 1) = toFun x + 1
goal: self.toFun (x + 1) = self.toFun x + 1

full_name: CircleDeg1Lift
code: /-- A lift of a monotone degree one map `S¹ → S¹`. -/
structure CircleDeg1Lift extends ℝ →o ℝ : Type where
  map_add_one' : ∀ x, toFun (x + 1) = toFun x + 1
goal: Type

full_name: CircleDeg1Lift.instFunLikeReal
code: instance : FunLike CircleDeg1Lift ℝ ℝ 
goal: FunLike CircleDeg1Lift ℝ ℝ

full_name: CircleDeg1Lift.instOrderHomClassReal
code: instance : OrderHomClass CircleDeg1Lift ℝ ℝ 
goal: OrderHomClass CircleDeg1Lift ℝ ℝ

full_name: CircleDeg1Lift.coe_mk
code: @[simp] theorem coe_mk (f h) : ⇑(mk f h) = f 
goal: ⇑{ toOrderHom := f, map_add_one' := h } = ⇑f

full_name: CircleDeg1Lift.coe_toOrderHom
code: @[simp] theorem coe_toOrderHom : ⇑f.toOrderHom = f 
goal: ⇑f.toOrderHom = ⇑f

full_name: CircleDeg1Lift.monotone
code: protected theorem monotone : Monotone f 
goal: Monotone ⇑f

full_name: CircleDeg1Lift.mono
code: @[mono] theorem mono {x y} (h : x ≤ y) : f x ≤ f y 
goal: f x ≤ f y

full_name: CircleDeg1Lift.strictMono_iff_injective
code: theorem strictMono_iff_injective : StrictMono f ↔ Injective f 
goal: StrictMono ⇑f ↔ Function.Injective ⇑f

full_name: CircleDeg1Lift.map_add_one
code: @[simp]
theorem map_add_one : ∀ x, f (x + 1) = f x + 1 
goal: f (x + 1) = f x + 1

full_name: CircleDeg1Lift.map_one_add
code: @[simp]
theorem map_one_add (x : ℝ) : f (1 + x) = 1 + f x 
goal: f (1 + x) = 1 + f x

full_name: CircleDeg1Lift.ext
code: @[ext]
theorem ext ⦃f g : CircleDeg1Lift⦄ (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: CircleDeg1Lift.ext_iff
code: protected theorem ext_iff {f g : CircleDeg1Lift} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : ℝ), f x = g x

full_name: CircleDeg1Lift.instMonoid
code: instance : Monoid CircleDeg1Lift 
goal: Monoid CircleDeg1Lift

full_name: CircleDeg1Lift.instInhabited
code: instance : Inhabited CircleDeg1Lift 
goal: Inhabited CircleDeg1Lift

full_name: CircleDeg1Lift.coe_mul
code: @[simp]
theorem coe_mul : ⇑(f * g) = f ∘ g 
goal: ⇑(f * g) = ⇑f ∘ ⇑g

full_name: CircleDeg1Lift.mul_apply
code: theorem mul_apply (x) : (f * g) x = f (g x) 
goal: (f * g) x = f (g x)

full_name: CircleDeg1Lift.coe_one
code: @[simp]
theorem coe_one : ⇑(1 : CircleDeg1Lift) = id 
goal: ⇑1 = id

full_name: CircleDeg1Lift.unitsHasCoeToFun
code: instance unitsHasCoeToFun : CoeFun CircleDeg1Liftˣ fun _ => ℝ → ℝ 
goal: CoeFun CircleDeg1Liftˣ fun x => ℝ → ℝ

full_name: CircleDeg1Lift.units_inv_apply_apply
code: @[simp]
theorem units_inv_apply_apply (f : CircleDeg1Liftˣ) (x : ℝ) :
    (f⁻¹ : CircleDeg1Liftˣ) (f x) = x 
goal: ↑f⁻¹ (↑f x) = x

full_name: CircleDeg1Lift.units_apply_inv_apply
code: @[simp]
theorem units_apply_inv_apply (f : CircleDeg1Liftˣ) (x : ℝ) :
    f ((f⁻¹ : CircleDeg1Liftˣ) x) = x 
goal: ↑f (↑f⁻¹ x) = x

full_name: CircleDeg1Lift.toOrderIso
code: /-- If a lift of a circle map is bijective, then it is an order automorphism of the line. -/
def toOrderIso : CircleDeg1Liftˣ →* ℝ ≃o ℝ 
goal: CircleDeg1Liftˣ →* ℝ ≃o ℝ

full_name: CircleDeg1Lift.coe_toOrderIso
code: @[simp]
theorem coe_toOrderIso (f : CircleDeg1Liftˣ) : ⇑(toOrderIso f) = f 
goal: ⇑(CircleDeg1Lift.toOrderIso f) = ⇑↑f

full_name: CircleDeg1Lift.coe_toOrderIso_symm
code: @[simp]
theorem coe_toOrderIso_symm (f : CircleDeg1Liftˣ) :
    ⇑(toOrderIso f).symm = (f⁻¹ : CircleDeg1Liftˣ) 
goal: ⇑(CircleDeg1Lift.toOrderIso f).symm = ⇑↑f⁻¹

full_name: CircleDeg1Lift.coe_toOrderIso_inv
code: @[simp]
theorem coe_toOrderIso_inv (f : CircleDeg1Liftˣ) : ⇑(toOrderIso f)⁻¹ = (f⁻¹ : CircleDeg1Liftˣ) 
goal: ⇑(CircleDeg1Lift.toOrderIso f)⁻¹ = ⇑↑f⁻¹

full_name: CircleDeg1Lift.isUnit_iff_bijective
code: theorem isUnit_iff_bijective {f : CircleDeg1Lift} : IsUnit f ↔ Bijective f 
goal: IsUnit f ↔ Function.Bijective ⇑f

full_name: CircleDeg1Lift.coe_pow
code: theorem coe_pow : ∀ n : ℕ, ⇑(f ^ n) = f^[n]
  
goal: ⇑(f ^ n) = (⇑f)^[n]

full_name: CircleDeg1Lift.semiconjBy_iff_semiconj
code: theorem semiconjBy_iff_semiconj {f g₁ g₂ : CircleDeg1Lift} :
    SemiconjBy f g₁ g₂ ↔ Semiconj f g₁ g₂ 
goal: SemiconjBy f g₁ g₂ ↔ Function.Semiconj ⇑f ⇑g₁ ⇑g₂

full_name: CircleDeg1Lift.commute_iff_commute
code: theorem commute_iff_commute {f g : CircleDeg1Lift} : Commute f g ↔ Function.Commute f g 
goal: Commute f g ↔ Function.Commute ⇑f ⇑g

full_name: CircleDeg1Lift.translate
code: /-- The map `y ↦ x + y` as a `CircleDeg1Lift`. More precisely, we define a homomorphism from
`Multiplicative ℝ` to `CircleDeg1Liftˣ`, so the translation by `x` is
`translation (Multiplicative.ofAdd x)`. -/
def translate : Multiplicative ℝ →* CircleDeg1Liftˣ 
goal: Multiplicative ℝ →* CircleDeg1Liftˣ

full_name: CircleDeg1Lift.translate_apply
code: @[simp]
theorem translate_apply (x y : ℝ) : translate (Multiplicative.ofAdd x) y = x + y 
goal: ↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x)) y = x + y

full_name: CircleDeg1Lift.translate_inv_apply
code: @[simp]
theorem translate_inv_apply (x y : ℝ) : (translate <| Multiplicative.ofAdd x)⁻¹ y = -x + y 
goal: ↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x))⁻¹ y = -x + y

full_name: CircleDeg1Lift.translate_zpow
code: @[simp]
theorem translate_zpow (x : ℝ) (n : ℤ) :
    translate (Multiplicative.ofAdd x) ^ n = translate (Multiplicative.ofAdd <| ↑n * x) 
goal: CircleDeg1Lift.translate (Multiplicative.ofAdd x) ^ n = CircleDeg1Lift.translate (Multiplicative.ofAdd (↑n * x))

full_name: CircleDeg1Lift.translate_pow
code: @[simp]
theorem translate_pow (x : ℝ) (n : ℕ) :
    translate (Multiplicative.ofAdd x) ^ n = translate (Multiplicative.ofAdd <| ↑n * x) 
goal: CircleDeg1Lift.translate (Multiplicative.ofAdd x) ^ n = CircleDeg1Lift.translate (Multiplicative.ofAdd (↑n * x))

full_name: CircleDeg1Lift.translate_iterate
code: @[simp]
theorem translate_iterate (x : ℝ) (n : ℕ) :
    (translate (Multiplicative.ofAdd x))^[n] = translate (Multiplicative.ofAdd <| ↑n * x) 
goal: (⇑↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x)))^[n] =
  ⇑↑(CircleDeg1Lift.translate (Multiplicative.ofAdd (↑n * x)))

full_name: CircleDeg1Lift.commute_nat_add
code: theorem commute_nat_add (n : ℕ) : Function.Commute f (n + ·) 
goal: Function.Commute ⇑f fun x => ↑n + x

full_name: CircleDeg1Lift.commute_add_nat
code: theorem commute_add_nat (n : ℕ) : Function.Commute f (· + n) 
goal: Function.Commute ⇑f fun x => x + ↑n

full_name: CircleDeg1Lift.commute_sub_nat
code: theorem commute_sub_nat (n : ℕ) : Function.Commute f (· - n) 
goal: Function.Commute ⇑f fun x => x - ↑n

full_name: CircleDeg1Lift.commute_add_int
code: theorem commute_add_int : ∀ n : ℤ, Function.Commute f (· + n)
  
goal: Function.Commute ⇑f fun x => x + ↑n

full_name: CircleDeg1Lift.commute_int_add
code: theorem commute_int_add (n : ℤ) : Function.Commute f (n + ·) 
goal: Function.Commute ⇑f fun x => ↑n + x

full_name: CircleDeg1Lift.commute_sub_int
code: theorem commute_sub_int (n : ℤ) : Function.Commute f (· - n) 
goal: Function.Commute ⇑f fun x => x - ↑n

full_name: CircleDeg1Lift.map_int_add
code: @[simp]
theorem map_int_add (m : ℤ) (x : ℝ) : f (m + x) = m + f x 
goal: f (↑m + x) = ↑m + f x

full_name: CircleDeg1Lift.map_add_int
code: @[simp]
theorem map_add_int (x : ℝ) (m : ℤ) : f (x + m) = f x + m 
goal: f (x + ↑m) = f x + ↑m

full_name: CircleDeg1Lift.map_sub_int
code: @[simp]
theorem map_sub_int (x : ℝ) (n : ℤ) : f (x - n) = f x - n 
goal: f (x - ↑n) = f x - ↑n

full_name: CircleDeg1Lift.map_add_nat
code: @[simp]
theorem map_add_nat (x : ℝ) (n : ℕ) : f (x + n) = f x + n 
goal: f (x + ↑n) = f x + ↑n

full_name: CircleDeg1Lift.map_nat_add
code: @[simp]
theorem map_nat_add (n : ℕ) (x : ℝ) : f (n + x) = n + f x 
goal: f (↑n + x) = ↑n + f x

full_name: CircleDeg1Lift.map_sub_nat
code: @[simp]
theorem map_sub_nat (x : ℝ) (n : ℕ) : f (x - n) = f x - n 
goal: f (x - ↑n) = f x - ↑n

full_name: CircleDeg1Lift.map_int_of_map_zero
code: theorem map_int_of_map_zero (n : ℤ) : f n = f 0 + n 
goal: f ↑n = f 0 + ↑n

full_name: CircleDeg1Lift.map_fract_sub_fract_eq
code: @[simp]
theorem map_fract_sub_fract_eq (x : ℝ) : f (fract x) - fract x = f x - x 
goal: f (Int.fract x) - Int.fract x = f x - x

full_name: CircleDeg1Lift.instLattice
code: /-- Monotone circle maps form a lattice with respect to the pointwise order -/
noncomputable instance : Lattice CircleDeg1Lift 
goal: Lattice CircleDeg1Lift

full_name: CircleDeg1Lift.sup_apply
code: @[simp]
theorem sup_apply (x : ℝ) : (f ⊔ g) x = max (f x) (g x) 
goal: (f ⊔ g) x = max (f x) (g x)

full_name: CircleDeg1Lift.inf_apply
code: @[simp]
theorem inf_apply (x : ℝ) : (f ⊓ g) x = min (f x) (g x) 
goal: (f ⊓ g) x = min (f x) (g x)

full_name: CircleDeg1Lift.iterate_monotone
code: theorem iterate_monotone (n : ℕ) : Monotone fun f : CircleDeg1Lift => f^[n] 
goal: Monotone fun f => (⇑f)^[n]

full_name: CircleDeg1Lift.iterate_mono
code: theorem iterate_mono {f g : CircleDeg1Lift} (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] 
goal: (⇑f)^[n] ≤ (⇑g)^[n]

full_name: CircleDeg1Lift.pow_mono
code: theorem pow_mono {f g : CircleDeg1Lift} (h : f ≤ g) (n : ℕ) : f ^ n ≤ g ^ n 
goal: f ^ n ≤ g ^ n

full_name: CircleDeg1Lift.pow_monotone
code: theorem pow_monotone (n : ℕ) : Monotone fun f : CircleDeg1Lift => f ^ n 
goal: Monotone fun f => f ^ n

full_name: CircleDeg1Lift.map_le_of_map_zero
code: theorem map_le_of_map_zero (x : ℝ) : f x ≤ f 0 + ⌈x⌉ 
goal: f x ≤ f 0 + ↑⌈x⌉

full_name: CircleDeg1Lift.map_map_zero_le
code: theorem map_map_zero_le : f (g 0) ≤ f 0 + ⌈g 0⌉ 
goal: f (g 0) ≤ f 0 + ↑⌈g 0⌉

full_name: CircleDeg1Lift.floor_map_map_zero_le
code: theorem floor_map_map_zero_le : ⌊f (g 0)⌋ ≤ ⌊f 0⌋ + ⌈g 0⌉ 
goal: ⌊f (g 0)⌋ ≤ ⌊f 0⌋ + ⌈g 0⌉

full_name: CircleDeg1Lift.ceil_map_map_zero_le
code: theorem ceil_map_map_zero_le : ⌈f (g 0)⌉ ≤ ⌈f 0⌉ + ⌈g 0⌉ 
goal: ⌈f (g 0)⌉ ≤ ⌈f 0⌉ + ⌈g 0⌉

full_name: CircleDeg1Lift.map_map_zero_lt
code: theorem map_map_zero_lt : f (g 0) < f 0 + g 0 + 1 
goal: f (g 0) < f 0 + g 0 + 1

full_name: CircleDeg1Lift.le_map_of_map_zero
code: theorem le_map_of_map_zero (x : ℝ) : f 0 + ⌊x⌋ ≤ f x 
goal: f 0 + ↑⌊x⌋ ≤ f x

full_name: CircleDeg1Lift.le_map_map_zero
code: theorem le_map_map_zero : f 0 + ⌊g 0⌋ ≤ f (g 0) 
goal: f 0 + ↑⌊g 0⌋ ≤ f (g 0)

full_name: CircleDeg1Lift.le_floor_map_map_zero
code: theorem le_floor_map_map_zero : ⌊f 0⌋ + ⌊g 0⌋ ≤ ⌊f (g 0)⌋ 
goal: ⌊f 0⌋ + ⌊g 0⌋ ≤ ⌊f (g 0)⌋

full_name: CircleDeg1Lift.le_ceil_map_map_zero
code: theorem le_ceil_map_map_zero : ⌈f 0⌉ + ⌊g 0⌋ ≤ ⌈(f * g) 0⌉ 
goal: ⌈f 0⌉ + ⌊g 0⌋ ≤ ⌈(f * g) 0⌉

full_name: CircleDeg1Lift.lt_map_map_zero
code: theorem lt_map_map_zero : f 0 + g 0 - 1 < f (g 0) 
goal: f 0 + g 0 - 1 < f (g 0)

full_name: CircleDeg1Lift.dist_map_map_zero_lt
code: theorem dist_map_map_zero_lt : dist (f 0 + g 0) (f (g 0)) < 1 
goal: dist (f 0 + g 0) (f (g 0)) < 1

full_name: CircleDeg1Lift.dist_map_zero_lt_of_semiconj
code: theorem dist_map_zero_lt_of_semiconj {f g₁ g₂ : CircleDeg1Lift} (h : Function.Semiconj f g₁ g₂) :
    dist (g₁ 0) (g₂ 0) < 2 
goal: dist (g₁ 0) (g₂ 0) < 2

full_name: CircleDeg1Lift.dist_map_zero_lt_of_semiconjBy
code: theorem dist_map_zero_lt_of_semiconjBy {f g₁ g₂ : CircleDeg1Lift} (h : SemiconjBy f g₁ g₂) :
    dist (g₁ 0) (g₂ 0) < 2 
goal: dist (g₁ 0) (g₂ 0) < 2

full_name: CircleDeg1Lift.tendsto_atBot
code: protected theorem tendsto_atBot : Tendsto f atBot atBot 
goal: Filter.Tendsto (⇑f) Filter.atBot Filter.atBot

full_name: CircleDeg1Lift.tendsto_atTop
code: protected theorem tendsto_atTop : Tendsto f atTop atTop 
goal: Filter.Tendsto (⇑f) Filter.atTop Filter.atTop

full_name: CircleDeg1Lift.continuous_iff_surjective
code: theorem continuous_iff_surjective : Continuous f ↔ Function.Surjective f 
goal: Continuous ⇑f ↔ Function.Surjective ⇑f

full_name: CircleDeg1Lift.iterate_le_of_map_le_add_int
code: theorem iterate_le_of_map_le_add_int {x : ℝ} {m : ℤ} (h : f x ≤ x + m) (n : ℕ) :
    f^[n] x ≤ x + n * m 
goal: (⇑f)^[n] x ≤ x + ↑n * ↑m

full_name: CircleDeg1Lift.le_iterate_of_add_int_le_map
code: theorem le_iterate_of_add_int_le_map {x : ℝ} {m : ℤ} (h : x + m ≤ f x) (n : ℕ) :
    x + n * m ≤ f^[n] x 
goal: x + ↑n * ↑m ≤ (⇑f)^[n] x

full_name: CircleDeg1Lift.iterate_eq_of_map_eq_add_int
code: theorem iterate_eq_of_map_eq_add_int {x : ℝ} {m : ℤ} (h : f x = x + m) (n : ℕ) :
    f^[n] x = x + n * m 
goal: (⇑f)^[n] x = x + ↑n * ↑m

full_name: CircleDeg1Lift.iterate_pos_le_iff
code: theorem iterate_pos_le_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    f^[n] x ≤ x + n * m ↔ f x ≤ x + m 
goal: (⇑f)^[n] x ≤ x + ↑n * ↑m ↔ f x ≤ x + ↑m

full_name: CircleDeg1Lift.iterate_pos_lt_iff
code: theorem iterate_pos_lt_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    f^[n] x < x + n * m ↔ f x < x + m 
goal: (⇑f)^[n] x < x + ↑n * ↑m ↔ f x < x + ↑m

full_name: CircleDeg1Lift.iterate_pos_eq_iff
code: theorem iterate_pos_eq_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    f^[n] x = x + n * m ↔ f x = x + m 
goal: (⇑f)^[n] x = x + ↑n * ↑m ↔ f x = x + ↑m

full_name: CircleDeg1Lift.le_iterate_pos_iff
code: theorem le_iterate_pos_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    x + n * m ≤ f^[n] x ↔ x + m ≤ f x 
goal: x + ↑n * ↑m ≤ (⇑f)^[n] x ↔ x + ↑m ≤ f x

full_name: CircleDeg1Lift.lt_iterate_pos_iff
code: theorem lt_iterate_pos_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    x + n * m < f^[n] x ↔ x + m < f x 
goal: x + ↑n * ↑m < (⇑f)^[n] x ↔ x + ↑m < f x

full_name: CircleDeg1Lift.mul_floor_map_zero_le_floor_iterate_zero
code: theorem mul_floor_map_zero_le_floor_iterate_zero (n : ℕ) : ↑n * ⌊f 0⌋ ≤ ⌊f^[n] 0⌋ 
goal: ↑n * ⌊f 0⌋ ≤ ⌊(⇑f)^[n] 0⌋

full_name: CircleDeg1Lift.transnumAuxSeq
code: /-- An auxiliary sequence used to define the translation number. -/
def transnumAuxSeq (n : ℕ) : ℝ 
goal: ℝ

full_name: CircleDeg1Lift.translationNumber
code: /-- The translation number of a `CircleDeg1Lift`, $τ(f)=\lim_{n→∞}\frac{f^n(x)-x}{n}$. We use
an auxiliary sequence `\frac{f^{2^n}(0)}{2^n}` to define `τ(f)` because some proofs are simpler
this way. -/
def translationNumber : ℝ 
goal: ℝ

full_name: CircleDeg1Lift._aux_Mathlib_Dynamics_Circle_RotationNumber_TranslationNumber___unexpand_CircleDeg1Lift_translationNumber_1
code: local notation "τ" => translationNumber
goal: Lean.PrettyPrinter.Unexpander

full_name: CircleDeg1Lift._aux_Mathlib_Dynamics_Circle_RotationNumber_TranslationNumber___macroRules_CircleDeg1Lift_termτ_1
code: local notation "τ" => translationNumber
goal: Lean.Macro

full_name: CircleDeg1Lift.transnumAuxSeq_def
code: theorem transnumAuxSeq_def : f.transnumAuxSeq = fun n : ℕ => (f ^ (2 ^ n : ℕ)) 0 / 2 ^ n 
goal: f.transnumAuxSeq = fun n => (f ^ 2 ^ n) 0 / 2 ^ n

full_name: CircleDeg1Lift.translationNumber_eq_of_tendsto_aux
code: theorem translationNumber_eq_of_tendsto_aux {τ' : ℝ} (h : Tendsto f.transnumAuxSeq atTop (𝓝 τ')) :
    τ f = τ' 
goal: f.translationNumber = τ'

full_name: CircleDeg1Lift.translationNumber_eq_of_tendsto₀
code: theorem translationNumber_eq_of_tendsto₀ {τ' : ℝ}
    (h : Tendsto (fun n : ℕ => f^[n] 0 / n) atTop (𝓝 τ')) : τ f = τ' 
goal: f.translationNumber = τ'

full_name: CircleDeg1Lift.translationNumber_eq_of_tendsto₀'
code: theorem translationNumber_eq_of_tendsto₀' {τ' : ℝ}
    (h : Tendsto (fun n : ℕ => f^[n + 1] 0 / (n + 1)) atTop (𝓝 τ')) : τ f = τ' 
goal: f.translationNumber = τ'

full_name: CircleDeg1Lift.transnumAuxSeq_zero
code: theorem transnumAuxSeq_zero : f.transnumAuxSeq 0 = f 0 
goal: f.transnumAuxSeq 0 = f 0

full_name: CircleDeg1Lift.transnumAuxSeq_dist_lt
code: theorem transnumAuxSeq_dist_lt (n : ℕ) :
    dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / 2 / 2 ^ n 
goal: dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / 2 / 2 ^ n

full_name: CircleDeg1Lift.tendsto_translationNumber_aux
code: theorem tendsto_translationNumber_aux : Tendsto f.transnumAuxSeq atTop (𝓝 <| τ f) 
goal: Filter.Tendsto f.transnumAuxSeq Filter.atTop (𝓝 f.translationNumber)

full_name: CircleDeg1Lift.dist_map_zero_translationNumber_le
code: theorem dist_map_zero_translationNumber_le : dist (f 0) (τ f) ≤ 1 
goal: dist (f 0) f.translationNumber ≤ 1

full_name: CircleDeg1Lift.tendsto_translationNumber_of_dist_bounded_aux
code: theorem tendsto_translationNumber_of_dist_bounded_aux (x : ℕ → ℝ) (C : ℝ)
    (H : ∀ n : ℕ, dist ((f ^ n) 0) (x n) ≤ C) :
    Tendsto (fun n : ℕ => x (2 ^ n) / 2 ^ n) atTop (𝓝 <| τ f) 
goal: Filter.Tendsto (fun n => x (2 ^ n) / 2 ^ n) Filter.atTop (𝓝 f.translationNumber)

full_name: CircleDeg1Lift.translationNumber_eq_of_dist_bounded
code: theorem translationNumber_eq_of_dist_bounded {f g : CircleDeg1Lift} (C : ℝ)
    (H : ∀ n : ℕ, dist ((f ^ n) 0) ((g ^ n) 0) ≤ C) : τ f = τ g 
goal: f.translationNumber = g.translationNumber

full_name: CircleDeg1Lift.translationNumber_one
code: @[simp]
theorem translationNumber_one : τ 1 = 0 
goal: CircleDeg1Lift.translationNumber 1 = 0

full_name: CircleDeg1Lift.translationNumber_eq_of_semiconjBy
code: theorem translationNumber_eq_of_semiconjBy {f g₁ g₂ : CircleDeg1Lift} (H : SemiconjBy f g₁ g₂) :
    τ g₁ = τ g₂ 
goal: g₁.translationNumber = g₂.translationNumber

full_name: CircleDeg1Lift.translationNumber_eq_of_semiconj
code: theorem translationNumber_eq_of_semiconj {f g₁ g₂ : CircleDeg1Lift}
    (H : Function.Semiconj f g₁ g₂) : τ g₁ = τ g₂ 
goal: g₁.translationNumber = g₂.translationNumber

full_name: CircleDeg1Lift.translationNumber_mul_of_commute
code: theorem translationNumber_mul_of_commute {f g : CircleDeg1Lift} (h : Commute f g) :
    τ (f * g) = τ f + τ g 
goal: (f * g).translationNumber = f.translationNumber + g.translationNumber

full_name: CircleDeg1Lift.translationNumber_units_inv
code: @[simp]
theorem translationNumber_units_inv (f : CircleDeg1Liftˣ) : τ ↑f⁻¹ = -τ f 
goal: (↑f⁻¹).translationNumber = -(↑f).translationNumber

full_name: CircleDeg1Lift.translationNumber_pow
code: @[simp]
theorem translationNumber_pow : ∀ n : ℕ, τ (f ^ n) = n * τ f
  
goal: (f ^ n).translationNumber = ↑n * f.translationNumber

full_name: CircleDeg1Lift.translationNumber_zpow
code: @[simp]
theorem translationNumber_zpow (f : CircleDeg1Liftˣ) : ∀ n : ℤ, τ (f ^ n : Units _) = n * τ f
  
goal: (↑(f ^ n)).translationNumber = ↑n * (↑f).translationNumber

full_name: CircleDeg1Lift.translationNumber_conj_eq
code: @[simp]
theorem translationNumber_conj_eq (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift) :
    τ (↑f * g * ↑f⁻¹) = τ g 
goal: (↑f * g * ↑f⁻¹).translationNumber = g.translationNumber

full_name: CircleDeg1Lift.translationNumber_conj_eq'
code: @[simp]
theorem translationNumber_conj_eq' (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift) :
    τ (↑f⁻¹ * g * f) = τ g 
goal: (↑f⁻¹ * g * ↑f).translationNumber = g.translationNumber

full_name: CircleDeg1Lift.dist_pow_map_zero_mul_translationNumber_le
code: theorem dist_pow_map_zero_mul_translationNumber_le (n : ℕ) :
    dist ((f ^ n) 0) (n * f.translationNumber) ≤ 1 
goal: dist ((f ^ n) 0) (↑n * f.translationNumber) ≤ 1

full_name: CircleDeg1Lift.tendsto_translation_number₀'
code: theorem tendsto_translation_number₀' :
    Tendsto (fun n : ℕ => (f ^ (n + 1) : CircleDeg1Lift) 0 / ((n : ℝ) + 1)) atTop (𝓝 <| τ f) 
goal: Filter.Tendsto (fun n => (f ^ (n + 1)) 0 / (↑n + 1)) Filter.atTop (𝓝 f.translationNumber)

full_name: CircleDeg1Lift.tendsto_translation_number₀
code: theorem tendsto_translation_number₀ : Tendsto (fun n : ℕ => (f ^ n) 0 / n) atTop (𝓝 <| τ f) 
goal: Filter.Tendsto (fun n => (f ^ n) 0 / ↑n) Filter.atTop (𝓝 f.translationNumber)

full_name: CircleDeg1Lift.tendsto_translationNumber
code: /-- For any `x : ℝ` the sequence $\frac{f^n(x)-x}{n}$ tends to the translation number of `f`.
In particular, this limit does not depend on `x`. -/
theorem tendsto_translationNumber (x : ℝ) :
    Tendsto (fun n : ℕ => ((f ^ n) x - x) / n) atTop (𝓝 <| τ f) 
goal: Filter.Tendsto (fun n => ((f ^ n) x - x) / ↑n) Filter.atTop (𝓝 f.translationNumber)

full_name: CircleDeg1Lift.tendsto_translation_number'
code: theorem tendsto_translation_number' (x : ℝ) :
    Tendsto (fun n : ℕ => ((f ^ (n + 1) : CircleDeg1Lift) x - x) / (n + 1)) atTop (𝓝 <| τ f) 
goal: Filter.Tendsto (fun n => ((f ^ (n + 1)) x - x) / (↑n + 1)) Filter.atTop (𝓝 f.translationNumber)

full_name: CircleDeg1Lift.translationNumber_mono
code: theorem translationNumber_mono : Monotone τ 
goal: Monotone CircleDeg1Lift.translationNumber

full_name: CircleDeg1Lift.translationNumber_translate
code: theorem translationNumber_translate (x : ℝ) : τ (translate <| Multiplicative.ofAdd x) = x 
goal: (↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x))).translationNumber = x

full_name: CircleDeg1Lift.translationNumber_le_of_le_add
code: theorem translationNumber_le_of_le_add {z : ℝ} (hz : ∀ x, f x ≤ x + z) : τ f ≤ z 
goal: f.translationNumber ≤ z

full_name: CircleDeg1Lift.le_translationNumber_of_add_le
code: theorem le_translationNumber_of_add_le {z : ℝ} (hz : ∀ x, x + z ≤ f x) : z ≤ τ f 
goal: z ≤ f.translationNumber

full_name: CircleDeg1Lift.translationNumber_le_of_le_add_int
code: theorem translationNumber_le_of_le_add_int {x : ℝ} {m : ℤ} (h : f x ≤ x + m) : τ f ≤ m 
goal: f.translationNumber ≤ ↑m

full_name: CircleDeg1Lift.translationNumber_le_of_le_add_nat
code: theorem translationNumber_le_of_le_add_nat {x : ℝ} {m : ℕ} (h : f x ≤ x + m) : τ f ≤ m 
goal: f.translationNumber ≤ ↑m

full_name: CircleDeg1Lift.le_translationNumber_of_add_int_le
code: theorem le_translationNumber_of_add_int_le {x : ℝ} {m : ℤ} (h : x + m ≤ f x) : ↑m ≤ τ f 
goal: ↑m ≤ f.translationNumber

full_name: CircleDeg1Lift.le_translationNumber_of_add_nat_le
code: theorem le_translationNumber_of_add_nat_le {x : ℝ} {m : ℕ} (h : x + m ≤ f x) : ↑m ≤ τ f 
goal: ↑m ≤ f.translationNumber

full_name: CircleDeg1Lift.translationNumber_of_eq_add_int
code: /-- If `f x - x` is an integer number `m` for some point `x`, then `τ f = m`.
On the circle this means that a map with a fixed point has rotation number zero. -/
theorem translationNumber_of_eq_add_int {x : ℝ} {m : ℤ} (h : f x = x + m) : τ f = m 
goal: f.translationNumber = ↑m

full_name: CircleDeg1Lift.floor_sub_le_translationNumber
code: theorem floor_sub_le_translationNumber (x : ℝ) : ↑⌊f x - x⌋ ≤ τ f 
goal: ↑⌊f x - x⌋ ≤ f.translationNumber

full_name: CircleDeg1Lift.translationNumber_le_ceil_sub
code: theorem translationNumber_le_ceil_sub (x : ℝ) : τ f ≤ ⌈f x - x⌉ 
goal: f.translationNumber ≤ ↑⌈f x - x⌉

full_name: CircleDeg1Lift.map_lt_of_translationNumber_lt_int
code: theorem map_lt_of_translationNumber_lt_int {n : ℤ} (h : τ f < n) (x : ℝ) : f x < x + n 
goal: f x < x + ↑n

full_name: CircleDeg1Lift.map_lt_of_translationNumber_lt_nat
code: theorem map_lt_of_translationNumber_lt_nat {n : ℕ} (h : τ f < n) (x : ℝ) : f x < x + n 
goal: f x < x + ↑n

full_name: CircleDeg1Lift.map_lt_add_floor_translationNumber_add_one
code: theorem map_lt_add_floor_translationNumber_add_one (x : ℝ) : f x < x + ⌊τ f⌋ + 1 
goal: f x < x + ↑⌊f.translationNumber⌋ + 1

full_name: CircleDeg1Lift.map_lt_add_translationNumber_add_one
code: theorem map_lt_add_translationNumber_add_one (x : ℝ) : f x < x + τ f + 1 
goal: f x < x + f.translationNumber + 1

full_name: CircleDeg1Lift.lt_map_of_int_lt_translationNumber
code: theorem lt_map_of_int_lt_translationNumber {n : ℤ} (h : ↑n < τ f) (x : ℝ) : x + n < f x 
goal: x + ↑n < f x

full_name: CircleDeg1Lift.lt_map_of_nat_lt_translationNumber
code: theorem lt_map_of_nat_lt_translationNumber {n : ℕ} (h : ↑n < τ f) (x : ℝ) : x + n < f x 
goal: x + ↑n < f x

full_name: CircleDeg1Lift.translationNumber_of_map_pow_eq_add_int
code: /-- If `f^n x - x`, `n > 0`, is an integer number `m` for some point `x`, then
`τ f = m / n`. On the circle this means that a map with a periodic orbit has
a rational rotation number. -/
theorem translationNumber_of_map_pow_eq_add_int {x : ℝ} {n : ℕ} {m : ℤ} (h : (f ^ n) x = x + m)
    (hn : 0 < n) : τ f = m / n 
goal: f.translationNumber = ↑m / ↑n

full_name: CircleDeg1Lift.forall_map_sub_of_Icc
code: /-- If a predicate depends only on `f x - x` and holds for all `0 ≤ x ≤ 1`,
then it holds for all `x`. -/
theorem forall_map_sub_of_Icc (P : ℝ → Prop) (h : ∀ x ∈ Icc (0 : ℝ) 1, P (f x - x)) (x : ℝ) :
    P (f x - x) 
goal: P (f x - x)

full_name: CircleDeg1Lift.translationNumber_lt_of_forall_lt_add
code: theorem translationNumber_lt_of_forall_lt_add (hf : Continuous f) {z : ℝ} (hz : ∀ x, f x < x + z) :
    τ f < z 
goal: f.translationNumber < z

full_name: CircleDeg1Lift.lt_translationNumber_of_forall_add_lt
code: theorem lt_translationNumber_of_forall_add_lt (hf : Continuous f) {z : ℝ} (hz : ∀ x, x + z < f x) :
    z < τ f 
goal: z < f.translationNumber

full_name: CircleDeg1Lift.exists_eq_add_translationNumber
code: /-- If `f` is a continuous monotone map `ℝ → ℝ`, `f (x + 1) = f x + 1`, then there exists `x`
such that `f x = x + τ f`. -/
theorem exists_eq_add_translationNumber (hf : Continuous f) : ∃ x, f x = x + τ f 
goal: ∃ x, f x = x + f.translationNumber

full_name: CircleDeg1Lift.translationNumber_eq_int_iff
code: theorem translationNumber_eq_int_iff (hf : Continuous f) {m : ℤ} :
    τ f = m ↔ ∃ x : ℝ, f x = x + m 
goal: f.translationNumber = ↑m ↔ ∃ x, f x = x + ↑m

full_name: CircleDeg1Lift.continuous_pow
code: theorem continuous_pow (hf : Continuous f) (n : ℕ) : Continuous (f ^ n : CircleDeg1Lift) 
goal: Continuous ⇑(f ^ n)

full_name: CircleDeg1Lift.translationNumber_eq_rat_iff
code: theorem translationNumber_eq_rat_iff (hf : Continuous f) {m : ℤ} {n : ℕ} (hn : 0 < n) :
    τ f = m / n ↔ ∃ x, (f ^ n) x = x + m 
goal: f.translationNumber = ↑m / ↑n ↔ ∃ x, (f ^ n) x = x + ↑m

full_name: CircleDeg1Lift.semiconj_of_group_action_of_forall_translationNumber_eq
code: /-- Consider two actions `f₁ f₂ : G →* CircleDeg1Lift` of a group on the real line by lifts of
orientation preserving circle homeomorphisms. Suppose that for each `g : G` the homeomorphisms
`f₁ g` and `f₂ g` have equal rotation numbers. Then there exists `F : CircleDeg1Lift` such that
`F * f₁ g = f₂ g * F` for all `g : G`.

This is a version of Proposition 5.4 from [Étienne Ghys, Groupes d'homeomorphismes du cercle et
cohomologie bornee][ghys87:groupes]. -/
theorem semiconj_of_group_action_of_forall_translationNumber_eq {G : Type*} [Group G]
    (f₁ f₂ : G →* CircleDeg1Lift) (h : ∀ g, τ (f₁ g) = τ (f₂ g)) :
    ∃ F : CircleDeg1Lift, ∀ g, Semiconj F (f₁ g) (f₂ g) 
goal: ∃ F, ∀ (g : G), Function.Semiconj ⇑F ⇑(f₁ g) ⇑(f₂ g)

full_name: CircleDeg1Lift.units_semiconj_of_translationNumber_eq
code: /-- If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses arguments `f₁ f₂ : CircleDeg1Liftˣ`
to assume that `f₁` and `f₂` are homeomorphisms. -/
theorem units_semiconj_of_translationNumber_eq {f₁ f₂ : CircleDeg1Liftˣ} (h : τ f₁ = τ f₂) :
    ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂ 
goal: ∃ F, Function.Semiconj ⇑F ⇑↑f₁ ⇑↑f₂

full_name: CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq
code: /-- If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses assumptions `IsUnit f₁` and `IsUnit f₂`
to assume that `f₁` and `f₂` are homeomorphisms. -/
theorem semiconj_of_isUnit_of_translationNumber_eq {f₁ f₂ : CircleDeg1Lift} (h₁ : IsUnit f₁)
    (h₂ : IsUnit f₂) (h : τ f₁ = τ f₂) : ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂ 
goal: ∃ F, Function.Semiconj ⇑F ⇑f₁ ⇑f₂

full_name: CircleDeg1Lift.semiconj_of_bijective_of_translationNumber_eq
code: /-- If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses assumptions `bijective f₁` and
`bijective f₂` to assume that `f₁` and `f₂` are homeomorphisms. -/
theorem semiconj_of_bijective_of_translationNumber_eq {f₁ f₂ : CircleDeg1Lift} (h₁ : Bijective f₁)
    (h₂ : Bijective f₂) (h : τ f₁ = τ f₂) : ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂ 
goal: ∃ F, Function.Semiconj ⇑F ⇑f₁ ⇑f₂