ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.imageSubobjectCompIso_hom_arrow
@[reassoc (attr := simp)]
theorem imageSubobjectCompIso_hom_arrow (f : X ⟶ Y) [HasImage f] {Y' : C} (h : Y ⟶ Y') [IsIso h] :
    (imageSubobjectCompIso f h).hom ≫ (imageSubobject f).arrow =
      (imageSubobject (f ≫ h)).arrow ≫ inv h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasEqualizers C] (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] {Y' : C} (h : Y ⟶ Y') [CategoryTheory.IsIso h]
Goal: (CategoryTheory.Limits.imageSubobjectCompIso f h).hom ≫ (CategoryTheory.Limits.imageSubobject f).arrow =
  (CategoryTheory.Limits.imageSubobject (f ≫ h)).arrow ≫ CategoryTheory.inv h
-- CategoryTheory.Limits.imageSubobjectCompIso_inv_arrow
@[reassoc (attr := simp)]
theorem imageSubobjectCompIso_inv_arrow (f : X ⟶ Y) [HasImage f] {Y' : C} (h : Y ⟶ Y') [IsIso h] :
    (imageSubobjectCompIso f h).inv ≫ (imageSubobject (f ≫ h)).arrow =
      (imageSubobject f).arrow ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasEqualizers C] (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] {Y' : C} (h : Y ⟶ Y') [CategoryTheory.IsIso h]
Goal: (CategoryTheory.Limits.imageSubobjectCompIso f h).inv ≫ (CategoryTheory.Limits.imageSubobject (f ≫ h)).arrow =
  (CategoryTheory.Limits.imageSubobject f).arrow ≫ h
-- CategoryTheory.Limits.imageSubobject_mono
theorem imageSubobject_mono (f : X ⟶ Y) [Mono f] : imageSubobject f = Subobject.mk f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: CategoryTheory.Limits.imageSubobject f = CategoryTheory.Subobject.mk f
-- CategoryTheory.Limits.imageSubobject_iso_comp
theorem imageSubobject_iso_comp [HasEqualizers C] {X' : C} (h : X' ⟶ X) [IsIso h] (f : X ⟶ Y)
    [HasImage f] : imageSubobject (h ≫ f) = imageSubobject f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasEqualizers C] {X' : C} (h : X' ⟶ X) [CategoryTheory.IsIso h] (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: CategoryTheory.Limits.imageSubobject (h ≫ f) = CategoryTheory.Limits.imageSubobject f
-- CategoryTheory.Limits.imageSubobject_le
theorem imageSubobject_le {A B : C} {X : Subobject B} (f : A ⟶ B) [HasImage f] (h : A ⟶ X)
    (w : h ≫ X.arrow = f) : imageSubobject f ≤ X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} {X : CategoryTheory.Subobject B} (f : A ⟶ B) [CategoryTheory.Limits.HasImage f] (h : A ⟶ CategoryTheory.Subobject.underlying.obj X) (w : h ≫ X.arrow = f)
Goal: CategoryTheory.Limits.imageSubobject f ≤ X
-- CategoryTheory.Limits.imageSubobject_le_mk
theorem imageSubobject_le_mk {A B : C} {X : C} (g : X ⟶ B) [Mono g] (f : A ⟶ B) [HasImage f]
    (h : A ⟶ X) (w : h ≫ g = f) : imageSubobject f ≤ Subobject.mk g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B X : C} (g : X ⟶ B) [CategoryTheory.Mono g] (f : A ⟶ B) [CategoryTheory.Limits.HasImage f] (h : A ⟶ X) (w : h ≫ g = f)
Goal: CategoryTheory.Limits.imageSubobject f ≤ CategoryTheory.Subobject.mk g
-- CategoryTheory.Limits.imageSubobjectMap_arrow
@[reassoc (attr := simp)]
theorem imageSubobjectMap_arrow {W X Y Z : C} {f : W ⟶ X} [HasImage f] {g : Y ⟶ Z} [HasImage g]
    (sq : Arrow.mk f ⟶ Arrow.mk g) [HasImageMap sq] :
    imageSubobjectMap sq ≫ (imageSubobject g).arrow = (imageSubobject f).arrow ≫ sq.right 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} [CategoryTheory.Limits.HasImage f] {g : Y ⟶ Z} [CategoryTheory.Limits.HasImage g] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) [CategoryTheory.Limits.HasImageMap sq]
Goal: CategoryTheory.Limits.imageSubobjectMap sq ≫ (CategoryTheory.Limits.imageSubobject g).arrow =
  (CategoryTheory.Limits.imageSubobject f).arrow ≫ sq.right
-- CategoryTheory.Limits.image_map_comp_imageSubobjectIso_inv
theorem image_map_comp_imageSubobjectIso_inv {W X Y Z : C} {f : W ⟶ X} [HasImage f] {g : Y ⟶ Z}
    [HasImage g] (sq : Arrow.mk f ⟶ Arrow.mk g) [HasImageMap sq] :
    image.map sq ≫ (imageSubobjectIso _).inv =
      (imageSubobjectIso _).inv ≫ imageSubobjectMap sq 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} [CategoryTheory.Limits.HasImage f] {g : Y ⟶ Z} [CategoryTheory.Limits.HasImage g] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) [CategoryTheory.Limits.HasImageMap sq]
Goal: CategoryTheory.Limits.image.map sq ≫ (CategoryTheory.Limits.imageSubobjectIso (CategoryTheory.Arrow.mk g).hom).inv =
  (CategoryTheory.Limits.imageSubobjectIso f).inv ≫ CategoryTheory.Limits.imageSubobjectMap sq
-- CategoryTheory.Limits.imageSubobjectIso_comp_image_map
theorem imageSubobjectIso_comp_image_map {W X Y Z : C} {f : W ⟶ X} [HasImage f] {g : Y ⟶ Z}
    [HasImage g] (sq : Arrow.mk f ⟶ Arrow.mk g) [HasImageMap sq] :
    (imageSubobjectIso _).hom ≫ image.map sq =
      imageSubobjectMap sq ≫ (imageSubobjectIso _).hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : W ⟶ X} [CategoryTheory.Limits.HasImage f] {g : Y ⟶ Z} [CategoryTheory.Limits.HasImage g] (sq : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) [CategoryTheory.Limits.HasImageMap sq]
Goal: (CategoryTheory.Limits.imageSubobjectIso (CategoryTheory.Arrow.mk f).hom).hom ≫ CategoryTheory.Limits.image.map sq =
  CategoryTheory.Limits.imageSubobjectMap sq ≫ (CategoryTheory.Limits.imageSubobjectIso g).hom
-- CategoryTheory.Quotient.Linear.smul_eq
@[simp]
lemma smul_eq (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y) (_ : r f₁ f₂), r (a • f₁) (a • f₂))
    (a : R) {X Y : C} (f : X ⟶ Y) :
    letI := smul r hr
    a • (functor r).map f = (functor r).map (a • f) 
Arguments: {R : Type u_1} {C : Type u_2} [Semiring R] [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Preadditive C] [CategoryTheory.Linear R C] (r : HomRel C) [CategoryTheory.Congruence r] (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y), r f₁ f₂ → r (a • f₁) (a • f₂)) (a : R) {X Y : C} (f : X ⟶ Y)
Goal: a • (CategoryTheory.Quotient.functor r).map f = (CategoryTheory.Quotient.functor r).map (a • f)
-- CategoryTheory.ClosedUnderIsomorphisms.of_iso
class ClosedUnderIsomorphisms : Prop where
  of_iso {X Y : C} (_ : X ≅ Y) (_ : P X) : P Y
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {P : C → Prop} [self : CategoryTheory.ClosedUnderIsomorphisms P] {X Y : C}
Goal: (X ≅ Y) → P X → P Y
-- CategoryTheory.mem_of_iso
lemma mem_of_iso [ClosedUnderIsomorphisms P] {X Y : C} (e : X ≅ Y) (hX : P X) : P Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : C → Prop) [CategoryTheory.ClosedUnderIsomorphisms P] {X Y : C} (e : X ≅ Y) (hX : P X)
Goal: P Y
-- CategoryTheory.mem_iff_of_iso
lemma mem_iff_of_iso [ClosedUnderIsomorphisms P] {X Y : C} (e : X ≅ Y) : P X ↔ P Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : C → Prop) [CategoryTheory.ClosedUnderIsomorphisms P] {X Y : C} (e : X ≅ Y)
Goal: P X ↔ P Y
-- CategoryTheory.mem_of_isIso
lemma mem_of_isIso [ClosedUnderIsomorphisms P] {X Y : C} (f : X ⟶ Y) [IsIso f] (hX : P X) : P Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : C → Prop) [CategoryTheory.ClosedUnderIsomorphisms P] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f] (hX : P X)
Goal: P Y
-- CategoryTheory.mem_iff_of_isIso
lemma mem_iff_of_isIso [ClosedUnderIsomorphisms P] {X Y : C} (f : X ⟶ Y) [IsIso f] : P X ↔ P Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : C → Prop) [CategoryTheory.ClosedUnderIsomorphisms P] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: P X ↔ P Y
-- CategoryTheory.mem_isoClosure_iff
lemma mem_isoClosure_iff (X : C) :
    isoClosure P X ↔ ∃ (Y : C) (_ : P Y), Nonempty (X ≅ Y) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : C → Prop) (X : C)
Goal: CategoryTheory.isoClosure P X ↔ ∃ Y x, Nonempty (X ≅ Y)
-- CategoryTheory.mem_isoClosure
lemma mem_isoClosure {X Y : C} (h : P X) (e : X ⟶ Y) [IsIso e] : isoClosure P Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {P : C → Prop} {X Y : C} (h : P X) (e : X ⟶ Y) [CategoryTheory.IsIso e]
Goal: CategoryTheory.isoClosure P Y
-- CategoryTheory.le_isoClosure
lemma le_isoClosure : P ≤ isoClosure P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : C → Prop)
Goal: P ≤ CategoryTheory.isoClosure P
-- CategoryTheory.monotone_isoClosure
lemma monotone_isoClosure (h : P ≤ Q) : isoClosure P ≤ isoClosure Q 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {P Q : C → Prop} (h : P ≤ Q)
Goal: CategoryTheory.isoClosure P ≤ CategoryTheory.isoClosure Q
-- CategoryTheory.isoClosure_eq_self
lemma isoClosure_eq_self [ClosedUnderIsomorphisms P] : isoClosure P = P 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P : C → Prop) [CategoryTheory.ClosedUnderIsomorphisms P]
Goal: CategoryTheory.isoClosure P = P
-- CategoryTheory.isoClosure_le_iff
lemma isoClosure_le_iff [ClosedUnderIsomorphisms Q] : isoClosure P ≤ Q ↔ P ≤ Q 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (P Q : C → Prop) [CategoryTheory.ClosedUnderIsomorphisms Q]
Goal: CategoryTheory.isoClosure P ≤ Q ↔ P ≤ Q
-- CircleDeg1Lift.map_add_one'
structure CircleDeg1Lift extends ℝ →o ℝ : Type where
  map_add_one' : ∀ x, toFun (x + 1) = toFun x + 1
Arguments: (self : CircleDeg1Lift) (x : ℝ)
Goal: self.toFun (x + 1) = self.toFun x + 1
-- CircleDeg1Lift.coe_mk
@[simp] theorem coe_mk (f h) : ⇑(mk f h) = f 
Arguments: (f : ℝ →o ℝ) (h : ∀ (x : ℝ), f.toFun (x + 1) = f.toFun x + 1)
Goal: ⇑{ toOrderHom := f, map_add_one' := h } = ⇑f
-- CircleDeg1Lift.coe_toOrderHom
@[simp] theorem coe_toOrderHom : ⇑f.toOrderHom = f 
Arguments: (f : CircleDeg1Lift)
Goal: ⇑f.toOrderHom = ⇑f
-- CircleDeg1Lift.monotone
protected theorem monotone : Monotone f 
Arguments: (f : CircleDeg1Lift)
Goal: Monotone ⇑f
-- CircleDeg1Lift.mono
@[mono] theorem mono {x y} (h : x ≤ y) : f x ≤ f y 
Arguments: (f : CircleDeg1Lift) {x y : ℝ} (h : x ≤ y)
Goal: f x ≤ f y
-- CircleDeg1Lift.strictMono_iff_injective
theorem strictMono_iff_injective : StrictMono f ↔ Injective f 
Arguments: (f : CircleDeg1Lift)
Goal: StrictMono ⇑f ↔ Function.Injective ⇑f
-- CircleDeg1Lift.map_add_one
@[simp]
theorem map_add_one : ∀ x, f (x + 1) = f x + 1 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f (x + 1) = f x + 1
-- CircleDeg1Lift.map_one_add
@[simp]
theorem map_one_add (x : ℝ) : f (1 + x) = 1 + f x 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f (1 + x) = 1 + f x
-- CircleDeg1Lift.ext
@[ext]
theorem ext ⦃f g : CircleDeg1Lift⦄ (h : ∀ x, f x = g x) : f = g 
Arguments: ⦃f g : CircleDeg1Lift⦄ (h : ∀ (x : ℝ), f x = g x)
Goal: f = g
-- CircleDeg1Lift.ext_iff
protected theorem ext_iff {f g : CircleDeg1Lift} : f = g ↔ ∀ x, f x = g x 
Arguments: {f g : CircleDeg1Lift}
Goal: f = g ↔ ∀ (x : ℝ), f x = g x
-- CircleDeg1Lift.coe_mul
@[simp]
theorem coe_mul : ⇑(f * g) = f ∘ g 
Arguments: (f g : CircleDeg1Lift)
Goal: ⇑(f * g) = ⇑f ∘ ⇑g
-- CircleDeg1Lift.mul_apply
theorem mul_apply (x) : (f * g) x = f (g x) 
Arguments: (f g : CircleDeg1Lift) (x : ℝ)
Goal: (f * g) x = f (g x)
-- CircleDeg1Lift.coe_one
@[simp]
theorem coe_one : ⇑(1 : CircleDeg1Lift) = id 
Goal: ⇑1 = id
-- CircleDeg1Lift.units_inv_apply_apply
@[simp]
theorem units_inv_apply_apply (f : CircleDeg1Liftˣ) (x : ℝ) :
    (f⁻¹ : CircleDeg1Liftˣ) (f x) = x 
Arguments: (f : CircleDeg1Liftˣ) (x : ℝ)
Goal: ↑f⁻¹ (↑f x) = x
-- CircleDeg1Lift.units_apply_inv_apply
@[simp]
theorem units_apply_inv_apply (f : CircleDeg1Liftˣ) (x : ℝ) :
    f ((f⁻¹ : CircleDeg1Liftˣ) x) = x 
Arguments: (f : CircleDeg1Liftˣ) (x : ℝ)
Goal: ↑f (↑f⁻¹ x) = x
-- CircleDeg1Lift.coe_toOrderIso
@[simp]
theorem coe_toOrderIso (f : CircleDeg1Liftˣ) : ⇑(toOrderIso f) = f 
Arguments: (f : CircleDeg1Liftˣ)
Goal: ⇑(CircleDeg1Lift.toOrderIso f) = ⇑↑f
-- CircleDeg1Lift.coe_toOrderIso_symm
@[simp]
theorem coe_toOrderIso_symm (f : CircleDeg1Liftˣ) :
    ⇑(toOrderIso f).symm = (f⁻¹ : CircleDeg1Liftˣ) 
Arguments: (f : CircleDeg1Liftˣ)
Goal: ⇑(CircleDeg1Lift.toOrderIso f).symm = ⇑↑f⁻¹
-- CircleDeg1Lift.coe_toOrderIso_inv
@[simp]
theorem coe_toOrderIso_inv (f : CircleDeg1Liftˣ) : ⇑(toOrderIso f)⁻¹ = (f⁻¹ : CircleDeg1Liftˣ) 
Arguments: (f : CircleDeg1Liftˣ)
Goal: ⇑(CircleDeg1Lift.toOrderIso f)⁻¹ = ⇑↑f⁻¹
-- CircleDeg1Lift.isUnit_iff_bijective
theorem isUnit_iff_bijective {f : CircleDeg1Lift} : IsUnit f ↔ Bijective f 
Arguments: {f : CircleDeg1Lift}
Goal: IsUnit f ↔ Function.Bijective ⇑f
-- CircleDeg1Lift.coe_pow
theorem coe_pow : ∀ n : ℕ, ⇑(f ^ n) = f^[n]
  
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: ⇑(f ^ n) = (⇑f)^[n]
-- CircleDeg1Lift.semiconjBy_iff_semiconj
theorem semiconjBy_iff_semiconj {f g₁ g₂ : CircleDeg1Lift} :
    SemiconjBy f g₁ g₂ ↔ Semiconj f g₁ g₂ 
Arguments: {f g₁ g₂ : CircleDeg1Lift}
Goal: SemiconjBy f g₁ g₂ ↔ Function.Semiconj ⇑f ⇑g₁ ⇑g₂
-- CircleDeg1Lift.commute_iff_commute
theorem commute_iff_commute {f g : CircleDeg1Lift} : Commute f g ↔ Function.Commute f g 
Arguments: {f g : CircleDeg1Lift}
Goal: Commute f g ↔ Function.Commute ⇑f ⇑g
-- CircleDeg1Lift.translate_apply
@[simp]
theorem translate_apply (x y : ℝ) : translate (Multiplicative.ofAdd x) y = x + y 
Arguments: (x y : ℝ)
Goal: ↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x)) y = x + y
-- CircleDeg1Lift.translate_inv_apply
@[simp]
theorem translate_inv_apply (x y : ℝ) : (translate <| Multiplicative.ofAdd x)⁻¹ y = -x + y 
Arguments: (x y : ℝ)
Goal: ↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x))⁻¹ y = -x + y
-- CircleDeg1Lift.translate_zpow
@[simp]
theorem translate_zpow (x : ℝ) (n : ℤ) :
    translate (Multiplicative.ofAdd x) ^ n = translate (Multiplicative.ofAdd <| ↑n * x) 
Arguments: (x : ℝ) (n : ℤ)
Goal: CircleDeg1Lift.translate (Multiplicative.ofAdd x) ^ n = CircleDeg1Lift.translate (Multiplicative.ofAdd (↑n * x))
-- CircleDeg1Lift.translate_pow
@[simp]
theorem translate_pow (x : ℝ) (n : ℕ) :
    translate (Multiplicative.ofAdd x) ^ n = translate (Multiplicative.ofAdd <| ↑n * x) 
Arguments: (x : ℝ) (n : ℕ)
Goal: CircleDeg1Lift.translate (Multiplicative.ofAdd x) ^ n = CircleDeg1Lift.translate (Multiplicative.ofAdd (↑n * x))
-- CircleDeg1Lift.translate_iterate
@[simp]
theorem translate_iterate (x : ℝ) (n : ℕ) :
    (translate (Multiplicative.ofAdd x))^[n] = translate (Multiplicative.ofAdd <| ↑n * x) 
Arguments: (x : ℝ) (n : ℕ)
Goal: (⇑↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x)))^[n] =
  ⇑↑(CircleDeg1Lift.translate (Multiplicative.ofAdd (↑n * x)))
-- CircleDeg1Lift.commute_nat_add
theorem commute_nat_add (n : ℕ) : Function.Commute f (n + ·) 
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: Function.Commute ⇑f fun x => ↑n + x
-- CircleDeg1Lift.commute_add_nat
theorem commute_add_nat (n : ℕ) : Function.Commute f (· + n) 
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: Function.Commute ⇑f fun x => x + ↑n
-- CircleDeg1Lift.commute_sub_nat
theorem commute_sub_nat (n : ℕ) : Function.Commute f (· - n) 
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: Function.Commute ⇑f fun x => x - ↑n
-- CircleDeg1Lift.commute_add_int
theorem commute_add_int : ∀ n : ℤ, Function.Commute f (· + n)
  
Arguments: (f : CircleDeg1Lift) (n : ℤ)
Goal: Function.Commute ⇑f fun x => x + ↑n
-- CircleDeg1Lift.commute_int_add
theorem commute_int_add (n : ℤ) : Function.Commute f (n + ·) 
Arguments: (f : CircleDeg1Lift) (n : ℤ)
Goal: Function.Commute ⇑f fun x => ↑n + x
-- CircleDeg1Lift.commute_sub_int
theorem commute_sub_int (n : ℤ) : Function.Commute f (· - n) 
Arguments: (f : CircleDeg1Lift) (n : ℤ)
Goal: Function.Commute ⇑f fun x => x - ↑n
-- CircleDeg1Lift.map_int_add
@[simp]
theorem map_int_add (m : ℤ) (x : ℝ) : f (m + x) = m + f x 
Arguments: (f : CircleDeg1Lift) (m : ℤ) (x : ℝ)
Goal: f (↑m + x) = ↑m + f x
-- CircleDeg1Lift.map_add_int
@[simp]
theorem map_add_int (x : ℝ) (m : ℤ) : f (x + m) = f x + m 
Arguments: (f : CircleDeg1Lift) (x : ℝ) (m : ℤ)
Goal: f (x + ↑m) = f x + ↑m
-- CircleDeg1Lift.map_sub_int
@[simp]
theorem map_sub_int (x : ℝ) (n : ℤ) : f (x - n) = f x - n 
Arguments: (f : CircleDeg1Lift) (x : ℝ) (n : ℤ)
Goal: f (x - ↑n) = f x - ↑n
-- CircleDeg1Lift.map_add_nat
@[simp]
theorem map_add_nat (x : ℝ) (n : ℕ) : f (x + n) = f x + n 
Arguments: (f : CircleDeg1Lift) (x : ℝ) (n : ℕ)
Goal: f (x + ↑n) = f x + ↑n
-- CircleDeg1Lift.map_nat_add
@[simp]
theorem map_nat_add (n : ℕ) (x : ℝ) : f (n + x) = n + f x 
Arguments: (f : CircleDeg1Lift) (n : ℕ) (x : ℝ)
Goal: f (↑n + x) = ↑n + f x
-- CircleDeg1Lift.map_sub_nat
@[simp]
theorem map_sub_nat (x : ℝ) (n : ℕ) : f (x - n) = f x - n 
Arguments: (f : CircleDeg1Lift) (x : ℝ) (n : ℕ)
Goal: f (x - ↑n) = f x - ↑n
-- CircleDeg1Lift.map_int_of_map_zero
theorem map_int_of_map_zero (n : ℤ) : f n = f 0 + n 
Arguments: (f : CircleDeg1Lift) (n : ℤ)
Goal: f ↑n = f 0 + ↑n
-- CircleDeg1Lift.map_fract_sub_fract_eq
@[simp]
theorem map_fract_sub_fract_eq (x : ℝ) : f (fract x) - fract x = f x - x 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f (Int.fract x) - Int.fract x = f x - x
-- CircleDeg1Lift.sup_apply
@[simp]
theorem sup_apply (x : ℝ) : (f ⊔ g) x = max (f x) (g x) 
Arguments: (f g : CircleDeg1Lift) (x : ℝ)
Goal: (f ⊔ g) x = max (f x) (g x)
-- CircleDeg1Lift.inf_apply
@[simp]
theorem inf_apply (x : ℝ) : (f ⊓ g) x = min (f x) (g x) 
Arguments: (f g : CircleDeg1Lift) (x : ℝ)
Goal: (f ⊓ g) x = min (f x) (g x)
-- CircleDeg1Lift.iterate_monotone
theorem iterate_monotone (n : ℕ) : Monotone fun f : CircleDeg1Lift => f^[n] 
Arguments: (n : ℕ)
Goal: Monotone fun f => (⇑f)^[n]
-- CircleDeg1Lift.iterate_mono
theorem iterate_mono {f g : CircleDeg1Lift} (h : f ≤ g) (n : ℕ) : f^[n] ≤ g^[n] 
Arguments: {f g : CircleDeg1Lift} (h : f ≤ g) (n : ℕ)
Goal: (⇑f)^[n] ≤ (⇑g)^[n]
-- CircleDeg1Lift.pow_mono
theorem pow_mono {f g : CircleDeg1Lift} (h : f ≤ g) (n : ℕ) : f ^ n ≤ g ^ n 
Arguments: {f g : CircleDeg1Lift} (h : f ≤ g) (n : ℕ)
Goal: f ^ n ≤ g ^ n
-- CircleDeg1Lift.pow_monotone
theorem pow_monotone (n : ℕ) : Monotone fun f : CircleDeg1Lift => f ^ n 
Arguments: (n : ℕ)
Goal: Monotone fun f => f ^ n
-- CircleDeg1Lift.map_le_of_map_zero
theorem map_le_of_map_zero (x : ℝ) : f x ≤ f 0 + ⌈x⌉ 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f x ≤ f 0 + ↑⌈x⌉
-- CircleDeg1Lift.map_map_zero_le
theorem map_map_zero_le : f (g 0) ≤ f 0 + ⌈g 0⌉ 
Arguments: (f g : CircleDeg1Lift)
Goal: f (g 0) ≤ f 0 + ↑⌈g 0⌉
-- CircleDeg1Lift.floor_map_map_zero_le
theorem floor_map_map_zero_le : ⌊f (g 0)⌋ ≤ ⌊f 0⌋ + ⌈g 0⌉ 
Arguments: (f g : CircleDeg1Lift)
Goal: ⌊f (g 0)⌋ ≤ ⌊f 0⌋ + ⌈g 0⌉
-- CircleDeg1Lift.ceil_map_map_zero_le
theorem ceil_map_map_zero_le : ⌈f (g 0)⌉ ≤ ⌈f 0⌉ + ⌈g 0⌉ 
Arguments: (f g : CircleDeg1Lift)
Goal: ⌈f (g 0)⌉ ≤ ⌈f 0⌉ + ⌈g 0⌉
-- CircleDeg1Lift.map_map_zero_lt
theorem map_map_zero_lt : f (g 0) < f 0 + g 0 + 1 
Arguments: (f g : CircleDeg1Lift)
Goal: f (g 0) < f 0 + g 0 + 1
-- CircleDeg1Lift.le_map_of_map_zero
theorem le_map_of_map_zero (x : ℝ) : f 0 + ⌊x⌋ ≤ f x 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f 0 + ↑⌊x⌋ ≤ f x
-- CircleDeg1Lift.le_map_map_zero
theorem le_map_map_zero : f 0 + ⌊g 0⌋ ≤ f (g 0) 
Arguments: (f g : CircleDeg1Lift)
Goal: f 0 + ↑⌊g 0⌋ ≤ f (g 0)
-- CircleDeg1Lift.le_floor_map_map_zero
theorem le_floor_map_map_zero : ⌊f 0⌋ + ⌊g 0⌋ ≤ ⌊f (g 0)⌋ 
Arguments: (f g : CircleDeg1Lift)
Goal: ⌊f 0⌋ + ⌊g 0⌋ ≤ ⌊f (g 0)⌋
-- CircleDeg1Lift.le_ceil_map_map_zero
theorem le_ceil_map_map_zero : ⌈f 0⌉ + ⌊g 0⌋ ≤ ⌈(f * g) 0⌉ 
Arguments: (f g : CircleDeg1Lift)
Goal: ⌈f 0⌉ + ⌊g 0⌋ ≤ ⌈(f * g) 0⌉
-- CircleDeg1Lift.lt_map_map_zero
theorem lt_map_map_zero : f 0 + g 0 - 1 < f (g 0) 
Arguments: (f g : CircleDeg1Lift)
Goal: f 0 + g 0 - 1 < f (g 0)
-- CircleDeg1Lift.dist_map_map_zero_lt
theorem dist_map_map_zero_lt : dist (f 0 + g 0) (f (g 0)) < 1 
Arguments: (f g : CircleDeg1Lift)
Goal: dist (f 0 + g 0) (f (g 0)) < 1
-- CircleDeg1Lift.dist_map_zero_lt_of_semiconj
theorem dist_map_zero_lt_of_semiconj {f g₁ g₂ : CircleDeg1Lift} (h : Function.Semiconj f g₁ g₂) :
    dist (g₁ 0) (g₂ 0) < 2 
Arguments: {f g₁ g₂ : CircleDeg1Lift} (h : Function.Semiconj ⇑f ⇑g₁ ⇑g₂)
Goal: dist (g₁ 0) (g₂ 0) < 2
-- CircleDeg1Lift.dist_map_zero_lt_of_semiconjBy
theorem dist_map_zero_lt_of_semiconjBy {f g₁ g₂ : CircleDeg1Lift} (h : SemiconjBy f g₁ g₂) :
    dist (g₁ 0) (g₂ 0) < 2 
Arguments: {f g₁ g₂ : CircleDeg1Lift} (h : SemiconjBy f g₁ g₂)
Goal: dist (g₁ 0) (g₂ 0) < 2
-- CircleDeg1Lift.tendsto_atBot
protected theorem tendsto_atBot : Tendsto f atBot atBot 
Arguments: (f : CircleDeg1Lift)
Goal: Filter.Tendsto (⇑f) Filter.atBot Filter.atBot
-- CircleDeg1Lift.tendsto_atTop
protected theorem tendsto_atTop : Tendsto f atTop atTop 
Arguments: (f : CircleDeg1Lift)
Goal: Filter.Tendsto (⇑f) Filter.atTop Filter.atTop
-- CircleDeg1Lift.continuous_iff_surjective
theorem continuous_iff_surjective : Continuous f ↔ Function.Surjective f 
Arguments: (f : CircleDeg1Lift)
Goal: Continuous ⇑f ↔ Function.Surjective ⇑f
-- CircleDeg1Lift.iterate_le_of_map_le_add_int
theorem iterate_le_of_map_le_add_int {x : ℝ} {m : ℤ} (h : f x ≤ x + m) (n : ℕ) :
    f^[n] x ≤ x + n * m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} (h : f x ≤ x + ↑m) (n : ℕ)
Goal: (⇑f)^[n] x ≤ x + ↑n * ↑m
-- CircleDeg1Lift.le_iterate_of_add_int_le_map
theorem le_iterate_of_add_int_le_map {x : ℝ} {m : ℤ} (h : x + m ≤ f x) (n : ℕ) :
    x + n * m ≤ f^[n] x 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} (h : x + ↑m ≤ f x) (n : ℕ)
Goal: x + ↑n * ↑m ≤ (⇑f)^[n] x
-- CircleDeg1Lift.iterate_eq_of_map_eq_add_int
theorem iterate_eq_of_map_eq_add_int {x : ℝ} {m : ℤ} (h : f x = x + m) (n : ℕ) :
    f^[n] x = x + n * m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} (h : f x = x + ↑m) (n : ℕ)
Goal: (⇑f)^[n] x = x + ↑n * ↑m
-- CircleDeg1Lift.iterate_pos_le_iff
theorem iterate_pos_le_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    f^[n] x ≤ x + n * m ↔ f x ≤ x + m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n)
Goal: (⇑f)^[n] x ≤ x + ↑n * ↑m ↔ f x ≤ x + ↑m
-- CircleDeg1Lift.iterate_pos_lt_iff
theorem iterate_pos_lt_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    f^[n] x < x + n * m ↔ f x < x + m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n)
Goal: (⇑f)^[n] x < x + ↑n * ↑m ↔ f x < x + ↑m
-- CircleDeg1Lift.iterate_pos_eq_iff
theorem iterate_pos_eq_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    f^[n] x = x + n * m ↔ f x = x + m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n)
Goal: (⇑f)^[n] x = x + ↑n * ↑m ↔ f x = x + ↑m
-- CircleDeg1Lift.le_iterate_pos_iff
theorem le_iterate_pos_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    x + n * m ≤ f^[n] x ↔ x + m ≤ f x 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n)
Goal: x + ↑n * ↑m ≤ (⇑f)^[n] x ↔ x + ↑m ≤ f x
-- CircleDeg1Lift.lt_iterate_pos_iff
theorem lt_iterate_pos_iff {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n) :
    x + n * m < f^[n] x ↔ x + m < f x 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} {n : ℕ} (hn : 0 < n)
Goal: x + ↑n * ↑m < (⇑f)^[n] x ↔ x + ↑m < f x
-- CircleDeg1Lift.mul_floor_map_zero_le_floor_iterate_zero
theorem mul_floor_map_zero_le_floor_iterate_zero (n : ℕ) : ↑n * ⌊f 0⌋ ≤ ⌊f^[n] 0⌋ 
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: ↑n * ⌊f 0⌋ ≤ ⌊(⇑f)^[n] 0⌋
-- CircleDeg1Lift.transnumAuxSeq_def
theorem transnumAuxSeq_def : f.transnumAuxSeq = fun n : ℕ => (f ^ (2 ^ n : ℕ)) 0 / 2 ^ n 
Arguments: (f : CircleDeg1Lift)
Goal: f.transnumAuxSeq = fun n => (f ^ 2 ^ n) 0 / 2 ^ n
-- CircleDeg1Lift.translationNumber_eq_of_tendsto_aux
theorem translationNumber_eq_of_tendsto_aux {τ' : ℝ} (h : Tendsto f.transnumAuxSeq atTop (𝓝 τ')) :
    τ f = τ' 
Arguments: (f : CircleDeg1Lift) {τ' : ℝ} (h : Filter.Tendsto f.transnumAuxSeq Filter.atTop (𝓝 τ'))
Goal: f.translationNumber = τ'
-- CircleDeg1Lift.translationNumber_eq_of_tendsto₀
theorem translationNumber_eq_of_tendsto₀ {τ' : ℝ}
    (h : Tendsto (fun n : ℕ => f^[n] 0 / n) atTop (𝓝 τ')) : τ f = τ' 
Arguments: (f : CircleDeg1Lift) {τ' : ℝ} (h : Filter.Tendsto (fun n => (⇑f)^[n] 0 / ↑n) Filter.atTop (𝓝 τ'))
Goal: f.translationNumber = τ'
-- CircleDeg1Lift.translationNumber_eq_of_tendsto₀'
theorem translationNumber_eq_of_tendsto₀' {τ' : ℝ}
    (h : Tendsto (fun n : ℕ => f^[n + 1] 0 / (n + 1)) atTop (𝓝 τ')) : τ f = τ' 
Arguments: (f : CircleDeg1Lift) {τ' : ℝ} (h : Filter.Tendsto (fun n => (⇑f)^[n + 1] 0 / (↑n + 1)) Filter.atTop (𝓝 τ'))
Goal: f.translationNumber = τ'
-- CircleDeg1Lift.transnumAuxSeq_zero
theorem transnumAuxSeq_zero : f.transnumAuxSeq 0 = f 0 
Arguments: (f : CircleDeg1Lift)
Goal: f.transnumAuxSeq 0 = f 0