ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CircleDeg1Lift.transnumAuxSeq_dist_lt
theorem transnumAuxSeq_dist_lt (n : ℕ) :
    dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / 2 / 2 ^ n 
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: dist (f.transnumAuxSeq n) (f.transnumAuxSeq (n + 1)) < 1 / 2 / 2 ^ n
-- CircleDeg1Lift.tendsto_translationNumber_aux
theorem tendsto_translationNumber_aux : Tendsto f.transnumAuxSeq atTop (𝓝 <| τ f) 
Arguments: (f : CircleDeg1Lift)
Goal: Filter.Tendsto f.transnumAuxSeq Filter.atTop (𝓝 f.translationNumber)
-- CircleDeg1Lift.dist_map_zero_translationNumber_le
theorem dist_map_zero_translationNumber_le : dist (f 0) (τ f) ≤ 1 
Arguments: (f : CircleDeg1Lift)
Goal: dist (f 0) f.translationNumber ≤ 1
-- CircleDeg1Lift.tendsto_translationNumber_of_dist_bounded_aux
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) 
Arguments: (f : CircleDeg1Lift) (x : ℕ → ℝ) (C : ℝ) (H : ∀ (n : ℕ), dist ((f ^ n) 0) (x n) ≤ C)
Goal: Filter.Tendsto (fun n => x (2 ^ n) / 2 ^ n) Filter.atTop (𝓝 f.translationNumber)
-- CircleDeg1Lift.translationNumber_eq_of_dist_bounded
theorem translationNumber_eq_of_dist_bounded {f g : CircleDeg1Lift} (C : ℝ)
    (H : ∀ n : ℕ, dist ((f ^ n) 0) ((g ^ n) 0) ≤ C) : τ f = τ g 
Arguments: {f g : CircleDeg1Lift} (C : ℝ) (H : ∀ (n : ℕ), dist ((f ^ n) 0) ((g ^ n) 0) ≤ C)
Goal: f.translationNumber = g.translationNumber
-- CircleDeg1Lift.translationNumber_one
@[simp]
theorem translationNumber_one : τ 1 = 0 
Goal: CircleDeg1Lift.translationNumber 1 = 0
-- CircleDeg1Lift.translationNumber_eq_of_semiconjBy
theorem translationNumber_eq_of_semiconjBy {f g₁ g₂ : CircleDeg1Lift} (H : SemiconjBy f g₁ g₂) :
    τ g₁ = τ g₂ 
Arguments: {f g₁ g₂ : CircleDeg1Lift} (H : SemiconjBy f g₁ g₂)
Goal: g₁.translationNumber = g₂.translationNumber
-- CircleDeg1Lift.translationNumber_eq_of_semiconj
theorem translationNumber_eq_of_semiconj {f g₁ g₂ : CircleDeg1Lift}
    (H : Function.Semiconj f g₁ g₂) : τ g₁ = τ g₂ 
Arguments: {f g₁ g₂ : CircleDeg1Lift} (H : Function.Semiconj ⇑f ⇑g₁ ⇑g₂)
Goal: g₁.translationNumber = g₂.translationNumber
-- CircleDeg1Lift.translationNumber_mul_of_commute
theorem translationNumber_mul_of_commute {f g : CircleDeg1Lift} (h : Commute f g) :
    τ (f * g) = τ f + τ g 
Arguments: {f g : CircleDeg1Lift} (h : Commute f g)
Goal: (f * g).translationNumber = f.translationNumber + g.translationNumber
-- CircleDeg1Lift.translationNumber_units_inv
@[simp]
theorem translationNumber_units_inv (f : CircleDeg1Liftˣ) : τ ↑f⁻¹ = -τ f 
Arguments: (f : CircleDeg1Liftˣ)
Goal: (↑f⁻¹).translationNumber = -(↑f).translationNumber
-- CircleDeg1Lift.translationNumber_pow
@[simp]
theorem translationNumber_pow : ∀ n : ℕ, τ (f ^ n) = n * τ f
  
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: (f ^ n).translationNumber = ↑n * f.translationNumber
-- CircleDeg1Lift.translationNumber_zpow
@[simp]
theorem translationNumber_zpow (f : CircleDeg1Liftˣ) : ∀ n : ℤ, τ (f ^ n : Units _) = n * τ f
  
Arguments: (f : CircleDeg1Liftˣ) (n : ℤ)
Goal: (↑(f ^ n)).translationNumber = ↑n * (↑f).translationNumber
-- CircleDeg1Lift.translationNumber_conj_eq
@[simp]
theorem translationNumber_conj_eq (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift) :
    τ (↑f * g * ↑f⁻¹) = τ g 
Arguments: (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift)
Goal: (↑f * g * ↑f⁻¹).translationNumber = g.translationNumber
-- CircleDeg1Lift.translationNumber_conj_eq'
@[simp]
theorem translationNumber_conj_eq' (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift) :
    τ (↑f⁻¹ * g * f) = τ g 
Arguments: (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift)
Goal: (↑f⁻¹ * g * ↑f).translationNumber = g.translationNumber
-- CircleDeg1Lift.dist_pow_map_zero_mul_translationNumber_le
theorem dist_pow_map_zero_mul_translationNumber_le (n : ℕ) :
    dist ((f ^ n) 0) (n * f.translationNumber) ≤ 1 
Arguments: (f : CircleDeg1Lift) (n : ℕ)
Goal: dist ((f ^ n) 0) (↑n * f.translationNumber) ≤ 1
-- CircleDeg1Lift.tendsto_translation_number₀'
theorem tendsto_translation_number₀' :
    Tendsto (fun n : ℕ => (f ^ (n + 1) : CircleDeg1Lift) 0 / ((n : ℝ) + 1)) atTop (𝓝 <| τ f) 
Arguments: (f : CircleDeg1Lift)
Goal: Filter.Tendsto (fun n => (f ^ (n + 1)) 0 / (↑n + 1)) Filter.atTop (𝓝 f.translationNumber)
-- CircleDeg1Lift.tendsto_translation_number₀
theorem tendsto_translation_number₀ : Tendsto (fun n : ℕ => (f ^ n) 0 / n) atTop (𝓝 <| τ f) 
Arguments: (f : CircleDeg1Lift)
Goal: Filter.Tendsto (fun n => (f ^ n) 0 / ↑n) Filter.atTop (𝓝 f.translationNumber)
-- CircleDeg1Lift.tendsto_translationNumber
theorem tendsto_translationNumber (x : ℝ) :
    Tendsto (fun n : ℕ => ((f ^ n) x - x) / n) atTop (𝓝 <| τ f) 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: Filter.Tendsto (fun n => ((f ^ n) x - x) / ↑n) Filter.atTop (𝓝 f.translationNumber)
-- CircleDeg1Lift.tendsto_translation_number'
theorem tendsto_translation_number' (x : ℝ) :
    Tendsto (fun n : ℕ => ((f ^ (n + 1) : CircleDeg1Lift) x - x) / (n + 1)) atTop (𝓝 <| τ f) 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: Filter.Tendsto (fun n => ((f ^ (n + 1)) x - x) / (↑n + 1)) Filter.atTop (𝓝 f.translationNumber)
-- CircleDeg1Lift.translationNumber_mono
theorem translationNumber_mono : Monotone τ 
Goal: Monotone CircleDeg1Lift.translationNumber
-- CircleDeg1Lift.translationNumber_translate
theorem translationNumber_translate (x : ℝ) : τ (translate <| Multiplicative.ofAdd x) = x 
Arguments: (x : ℝ)
Goal: (↑(CircleDeg1Lift.translate (Multiplicative.ofAdd x))).translationNumber = x
-- CircleDeg1Lift.translationNumber_le_of_le_add
theorem translationNumber_le_of_le_add {z : ℝ} (hz : ∀ x, f x ≤ x + z) : τ f ≤ z 
Arguments: (f : CircleDeg1Lift) {z : ℝ} (hz : ∀ (x : ℝ), f x ≤ x + z)
Goal: f.translationNumber ≤ z
-- CircleDeg1Lift.le_translationNumber_of_add_le
theorem le_translationNumber_of_add_le {z : ℝ} (hz : ∀ x, x + z ≤ f x) : z ≤ τ f 
Arguments: (f : CircleDeg1Lift) {z : ℝ} (hz : ∀ (x : ℝ), x + z ≤ f x)
Goal: z ≤ f.translationNumber
-- CircleDeg1Lift.translationNumber_le_of_le_add_int
theorem translationNumber_le_of_le_add_int {x : ℝ} {m : ℤ} (h : f x ≤ x + m) : τ f ≤ m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} (h : f x ≤ x + ↑m)
Goal: f.translationNumber ≤ ↑m
-- CircleDeg1Lift.translationNumber_le_of_le_add_nat
theorem translationNumber_le_of_le_add_nat {x : ℝ} {m : ℕ} (h : f x ≤ x + m) : τ f ≤ m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℕ} (h : f x ≤ x + ↑m)
Goal: f.translationNumber ≤ ↑m
-- CircleDeg1Lift.le_translationNumber_of_add_int_le
theorem le_translationNumber_of_add_int_le {x : ℝ} {m : ℤ} (h : x + m ≤ f x) : ↑m ≤ τ f 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} (h : x + ↑m ≤ f x)
Goal: ↑m ≤ f.translationNumber
-- CircleDeg1Lift.le_translationNumber_of_add_nat_le
theorem le_translationNumber_of_add_nat_le {x : ℝ} {m : ℕ} (h : x + m ≤ f x) : ↑m ≤ τ f 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℕ} (h : x + ↑m ≤ f x)
Goal: ↑m ≤ f.translationNumber
-- CircleDeg1Lift.translationNumber_of_eq_add_int
theorem translationNumber_of_eq_add_int {x : ℝ} {m : ℤ} (h : f x = x + m) : τ f = m 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {m : ℤ} (h : f x = x + ↑m)
Goal: f.translationNumber = ↑m
-- CircleDeg1Lift.floor_sub_le_translationNumber
theorem floor_sub_le_translationNumber (x : ℝ) : ↑⌊f x - x⌋ ≤ τ f 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: ↑⌊f x - x⌋ ≤ f.translationNumber
-- CircleDeg1Lift.translationNumber_le_ceil_sub
theorem translationNumber_le_ceil_sub (x : ℝ) : τ f ≤ ⌈f x - x⌉ 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f.translationNumber ≤ ↑⌈f x - x⌉
-- CircleDeg1Lift.map_lt_of_translationNumber_lt_int
theorem map_lt_of_translationNumber_lt_int {n : ℤ} (h : τ f < n) (x : ℝ) : f x < x + n 
Arguments: (f : CircleDeg1Lift) {n : ℤ} (h : f.translationNumber < ↑n) (x : ℝ)
Goal: f x < x + ↑n
-- CircleDeg1Lift.map_lt_of_translationNumber_lt_nat
theorem map_lt_of_translationNumber_lt_nat {n : ℕ} (h : τ f < n) (x : ℝ) : f x < x + n 
Arguments: (f : CircleDeg1Lift) {n : ℕ} (h : f.translationNumber < ↑n) (x : ℝ)
Goal: f x < x + ↑n
-- CircleDeg1Lift.map_lt_add_floor_translationNumber_add_one
theorem map_lt_add_floor_translationNumber_add_one (x : ℝ) : f x < x + ⌊τ f⌋ + 1 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f x < x + ↑⌊f.translationNumber⌋ + 1
-- CircleDeg1Lift.map_lt_add_translationNumber_add_one
theorem map_lt_add_translationNumber_add_one (x : ℝ) : f x < x + τ f + 1 
Arguments: (f : CircleDeg1Lift) (x : ℝ)
Goal: f x < x + f.translationNumber + 1
-- CircleDeg1Lift.lt_map_of_int_lt_translationNumber
theorem lt_map_of_int_lt_translationNumber {n : ℤ} (h : ↑n < τ f) (x : ℝ) : x + n < f x 
Arguments: (f : CircleDeg1Lift) {n : ℤ} (h : ↑n < f.translationNumber) (x : ℝ)
Goal: x + ↑n < f x
-- CircleDeg1Lift.lt_map_of_nat_lt_translationNumber
theorem lt_map_of_nat_lt_translationNumber {n : ℕ} (h : ↑n < τ f) (x : ℝ) : x + n < f x 
Arguments: (f : CircleDeg1Lift) {n : ℕ} (h : ↑n < f.translationNumber) (x : ℝ)
Goal: x + ↑n < f x
-- CircleDeg1Lift.translationNumber_of_map_pow_eq_add_int
theorem translationNumber_of_map_pow_eq_add_int {x : ℝ} {n : ℕ} {m : ℤ} (h : (f ^ n) x = x + m)
    (hn : 0 < n) : τ f = m / n 
Arguments: (f : CircleDeg1Lift) {x : ℝ} {n : ℕ} {m : ℤ} (h : (f ^ n) x = x + ↑m) (hn : 0 < n)
Goal: f.translationNumber = ↑m / ↑n
-- CircleDeg1Lift.forall_map_sub_of_Icc
theorem forall_map_sub_of_Icc (P : ℝ → Prop) (h : ∀ x ∈ Icc (0 : ℝ) 1, P (f x - x)) (x : ℝ) :
    P (f x - x) 
Arguments: (f : CircleDeg1Lift) (P : ℝ → Prop) (h : ∀ x ∈ Set.Icc 0 1, P (f x - x)) (x : ℝ)
Goal: P (f x - x)
-- CircleDeg1Lift.translationNumber_lt_of_forall_lt_add
theorem translationNumber_lt_of_forall_lt_add (hf : Continuous f) {z : ℝ} (hz : ∀ x, f x < x + z) :
    τ f < z 
Arguments: (f : CircleDeg1Lift) (hf : Continuous ⇑f) {z : ℝ} (hz : ∀ (x : ℝ), f x < x + z)
Goal: f.translationNumber < z
-- CircleDeg1Lift.lt_translationNumber_of_forall_add_lt
theorem lt_translationNumber_of_forall_add_lt (hf : Continuous f) {z : ℝ} (hz : ∀ x, x + z < f x) :
    z < τ f 
Arguments: (f : CircleDeg1Lift) (hf : Continuous ⇑f) {z : ℝ} (hz : ∀ (x : ℝ), x + z < f x)
Goal: z < f.translationNumber
-- CircleDeg1Lift.exists_eq_add_translationNumber
theorem exists_eq_add_translationNumber (hf : Continuous f) : ∃ x, f x = x + τ f 
Arguments: (f : CircleDeg1Lift) (hf : Continuous ⇑f)
Goal: ∃ x, f x = x + f.translationNumber
-- CircleDeg1Lift.translationNumber_eq_int_iff
theorem translationNumber_eq_int_iff (hf : Continuous f) {m : ℤ} :
    τ f = m ↔ ∃ x : ℝ, f x = x + m 
Arguments: (f : CircleDeg1Lift) (hf : Continuous ⇑f) {m : ℤ}
Goal: f.translationNumber = ↑m ↔ ∃ x, f x = x + ↑m
-- CircleDeg1Lift.continuous_pow
theorem continuous_pow (hf : Continuous f) (n : ℕ) : Continuous (f ^ n : CircleDeg1Lift) 
Arguments: (f : CircleDeg1Lift) (hf : Continuous ⇑f) (n : ℕ)
Goal: Continuous ⇑(f ^ n)
-- CircleDeg1Lift.translationNumber_eq_rat_iff
theorem translationNumber_eq_rat_iff (hf : Continuous f) {m : ℤ} {n : ℕ} (hn : 0 < n) :
    τ f = m / n ↔ ∃ x, (f ^ n) x = x + m 
Arguments: (f : CircleDeg1Lift) (hf : Continuous ⇑f) {m : ℤ} {n : ℕ} (hn : 0 < n)
Goal: f.translationNumber = ↑m / ↑n ↔ ∃ x, (f ^ n) x = x + ↑m
-- CircleDeg1Lift.semiconj_of_group_action_of_forall_translationNumber_eq
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) 
Arguments: {G : Type u_1} [Group G] (f₁ f₂ : G →* CircleDeg1Lift) (h : ∀ (g : G), (f₁ g).translationNumber = (f₂ g).translationNumber)
Goal: ∃ F, ∀ (g : G), Function.Semiconj ⇑F ⇑(f₁ g) ⇑(f₂ g)
-- CircleDeg1Lift.units_semiconj_of_translationNumber_eq
theorem units_semiconj_of_translationNumber_eq {f₁ f₂ : CircleDeg1Liftˣ} (h : τ f₁ = τ f₂) :
    ∃ F : CircleDeg1Lift, Semiconj F f₁ f₂ 
Arguments: {f₁ f₂ : CircleDeg1Liftˣ} (h : (↑f₁).translationNumber = (↑f₂).translationNumber)
Goal: ∃ F, Function.Semiconj ⇑F ⇑↑f₁ ⇑↑f₂
-- CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq
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₂ 
Arguments: {f₁ f₂ : CircleDeg1Lift} (h₁ : IsUnit f₁) (h₂ : IsUnit f₂) (h : f₁.translationNumber = f₂.translationNumber)
Goal: ∃ F, Function.Semiconj ⇑F ⇑f₁ ⇑f₂
-- CircleDeg1Lift.semiconj_of_bijective_of_translationNumber_eq
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₂ 
Arguments: {f₁ f₂ : CircleDeg1Lift} (h₁ : Function.Bijective ⇑f₁) (h₂ : Function.Bijective ⇑f₂) (h : f₁.translationNumber = f₂.translationNumber)
Goal: ∃ F, Function.Semiconj ⇑F ⇑f₁ ⇑f₂
-- CategoryTheory.StructuredArrow.projectSubobject_mk
@[simp]
theorem projectSubobject_mk [HasLimits C] [PreservesLimits T] {A P : StructuredArrow S T}
    (f : P ⟶ A) [Mono f] : projectSubobject (Subobject.mk f) = Subobject.mk f.right 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : D} {T : CategoryTheory.Functor C D} [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits T] {A P : CategoryTheory.StructuredArrow S T} (f : P ⟶ A) [CategoryTheory.Mono f]
Goal: CategoryTheory.StructuredArrow.projectSubobject (CategoryTheory.Subobject.mk f) = CategoryTheory.Subobject.mk f.right
-- CategoryTheory.StructuredArrow.projectSubobject_factors
theorem projectSubobject_factors [HasLimits C] [PreservesLimits T] {A : StructuredArrow S T} :
    ∀ P : Subobject A, ∃ q, q ≫ T.map (projectSubobject P).arrow = A.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : D} {T : CategoryTheory.Functor C D} [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits T] {A : CategoryTheory.StructuredArrow S T} (P : CategoryTheory.Subobject A)
Goal: ∃ q, CategoryTheory.CategoryStruct.comp q (T.map (CategoryTheory.StructuredArrow.projectSubobject P).arrow) = A.hom
-- CategoryTheory.StructuredArrow.lift_projectSubobject
theorem lift_projectSubobject [HasLimits C] [PreservesLimits T] {A : StructuredArrow S T} :
    ∀ (P : Subobject A) {q} (hq : q ≫ T.map (projectSubobject P).arrow = A.hom),
      liftSubobject (projectSubobject P) hq = P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : D} {T : CategoryTheory.Functor C D} [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits T] {A : CategoryTheory.StructuredArrow S T} (P : CategoryTheory.Subobject A) {q :
  (CategoryTheory.Functor.fromPUnit S).obj A.left ⟶
    T.obj (CategoryTheory.Subobject.underlying.obj (CategoryTheory.StructuredArrow.projectSubobject P))} (hq : CategoryTheory.CategoryStruct.comp q (T.map (CategoryTheory.StructuredArrow.projectSubobject P).arrow) = A.hom)
Goal: CategoryTheory.StructuredArrow.liftSubobject (CategoryTheory.StructuredArrow.projectSubobject P) hq = P
-- CategoryTheory.StructuredArrow.subobjectEquiv_apply_coe
@[simps!]
def subobjectEquiv [HasLimits C] [PreservesLimits T] (A : StructuredArrow S T) :
    Subobject A ≃o { P : Subobject A.right // ∃ q, q ≫ T.map P.arrow = A.hom } 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : D} {T : CategoryTheory.Functor C D} [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits T] (A : CategoryTheory.StructuredArrow S T) (P : CategoryTheory.Subobject A)
Goal: ↑(A.subobjectEquiv P) = CategoryTheory.StructuredArrow.projectSubobject P
-- CategoryTheory.StructuredArrow.subobjectEquiv_symm_apply
@[simps!]
def subobjectEquiv [HasLimits C] [PreservesLimits T] (A : StructuredArrow S T) :
    Subobject A ≃o { P : Subobject A.right // ∃ q, q ≫ T.map P.arrow = A.hom } 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : D} {T : CategoryTheory.Functor C D} [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits T] (A : CategoryTheory.StructuredArrow S T) (P : { P // ∃ q, CategoryTheory.CategoryStruct.comp q (T.map P.arrow) = A.hom })
Goal: (RelIso.symm A.subobjectEquiv) P = CategoryTheory.Subobject.mk (CategoryTheory.StructuredArrow.homMk (↑P).arrow ⋯)
-- CategoryTheory.CostructuredArrow.projectQuotient_mk
@[simp]
theorem projectQuotient_mk [HasColimits C] [PreservesColimits S] {A : CostructuredArrow S T}
    {P : (CostructuredArrow S T)ᵒᵖ} (f : P ⟶ op A) [Mono f] :
    projectQuotient (Subobject.mk f) = Subobject.mk f.unop.left.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : CategoryTheory.Functor C D} {T : D} [CategoryTheory.Limits.HasColimits C] [CategoryTheory.Limits.PreservesColimits S] {A : CategoryTheory.CostructuredArrow S T} {P : (CategoryTheory.CostructuredArrow S T)ᵒᵖ} (f : P ⟶ Opposite.op A) [CategoryTheory.Mono f]
Goal: CategoryTheory.CostructuredArrow.projectQuotient (CategoryTheory.Subobject.mk f) =
  CategoryTheory.Subobject.mk f.unop.left.op
-- CategoryTheory.CostructuredArrow.projectQuotient_factors
theorem projectQuotient_factors [HasColimits C] [PreservesColimits S] {A : CostructuredArrow S T} :
    ∀ P : Subobject (op A), ∃ q, S.map (projectQuotient P).arrow.unop ≫ q = A.hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : CategoryTheory.Functor C D} {T : D} [CategoryTheory.Limits.HasColimits C] [CategoryTheory.Limits.PreservesColimits S] {A : CategoryTheory.CostructuredArrow S T} (P : CategoryTheory.Subobject (Opposite.op A))
Goal: ∃ q,
  CategoryTheory.CategoryStruct.comp (S.map (CategoryTheory.CostructuredArrow.projectQuotient P).arrow.unop) q = A.hom
-- CategoryTheory.CostructuredArrow.unop_left_comp_underlyingIso_hom_unop
@[simp]
theorem unop_left_comp_underlyingIso_hom_unop {A : CostructuredArrow S T}
    {P : (CostructuredArrow S T)ᵒᵖ} (f : P ⟶ op A) [Mono f.unop.left.op] :
    f.unop.left ≫ (Subobject.underlyingIso f.unop.left.op).hom.unop =
      (Subobject.mk f.unop.left.op).arrow.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : CategoryTheory.Functor C D} {T : D} {A : CategoryTheory.CostructuredArrow S T} {P : (CategoryTheory.CostructuredArrow S T)ᵒᵖ} (f : P ⟶ Opposite.op A) [CategoryTheory.Mono f.unop.left.op]
Goal: CategoryTheory.CategoryStruct.comp f.unop.left (CategoryTheory.Subobject.underlyingIso f.unop.left.op).hom.unop =
  (CategoryTheory.Subobject.mk f.unop.left.op).arrow.unop
-- CategoryTheory.CostructuredArrow.lift_projectQuotient
theorem lift_projectQuotient [HasColimits C] [PreservesColimits S] {A : CostructuredArrow S T} :
    ∀ (P : Subobject (op A)) {q} (hq : S.map (projectQuotient P).arrow.unop ≫ q = A.hom),
      liftQuotient (projectQuotient P) hq = P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : CategoryTheory.Functor C D} {T : D} [CategoryTheory.Limits.HasColimits C] [CategoryTheory.Limits.PreservesColimits S] {A : CategoryTheory.CostructuredArrow S T} (P : CategoryTheory.Subobject (Opposite.op A)) {q :
  S.obj (Opposite.unop (CategoryTheory.Subobject.underlying.obj (CategoryTheory.CostructuredArrow.projectQuotient P))) ⟶
    (CategoryTheory.Functor.fromPUnit T).obj A.right} (hq :
  CategoryTheory.CategoryStruct.comp (S.map (CategoryTheory.CostructuredArrow.projectQuotient P).arrow.unop) q = A.hom)
Goal: CategoryTheory.CostructuredArrow.liftQuotient (CategoryTheory.CostructuredArrow.projectQuotient P) hq = P
-- CategoryTheory.CostructuredArrow.unop_left_comp_ofMkLEMk_unop
theorem unop_left_comp_ofMkLEMk_unop {A : CostructuredArrow S T} {P Q : (CostructuredArrow S T)ᵒᵖ}
    {f : P ⟶ op A} {g : Q ⟶ op A} [Mono f.unop.left.op] [Mono g.unop.left.op]
    (h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op) :
    g.unop.left ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] {S : CategoryTheory.Functor C D} {T : D} {A : CategoryTheory.CostructuredArrow S T} {P Q : (CategoryTheory.CostructuredArrow S T)ᵒᵖ} {f : P ⟶ Opposite.op A} {g : Q ⟶ Opposite.op A} [CategoryTheory.Mono f.unop.left.op] [CategoryTheory.Mono g.unop.left.op] (h : CategoryTheory.Subobject.mk f.unop.left.op ≤ CategoryTheory.Subobject.mk g.unop.left.op)
Goal: CategoryTheory.CategoryStruct.comp g.unop.left
    (CategoryTheory.Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop =
  f.unop.left
-- CategoryTheory.exp.ev_coev
@[simp, reassoc]
theorem ev_coev : Limits.prod.map (𝟙 A) ((coev A).app B) ≫ (ev A).app (A ⨯ B) = 𝟙 (A ⨯ B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A B : C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A]
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id A) ((CategoryTheory.exp.coev A).app B))
    ((CategoryTheory.exp.ev A).app (A ⨯ B)) =
  CategoryTheory.CategoryStruct.id (A ⨯ B)
-- CategoryTheory.exp.coev_ev
@[reassoc]
theorem coev_ev : (coev A).app (A ⟹ B) ≫ (exp A).map ((ev A).app B) = 𝟙 (A ⟹ B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (A B : C) [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A]
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.exp.coev A).app (A ⟹ B))
    ((CategoryTheory.exp A).map ((CategoryTheory.exp.ev A).app B)) =
  CategoryTheory.CategoryStruct.id (A ⟹ B)
-- CategoryTheory.CartesianClosed.homEquiv_apply_eq
@[simp, nolint simpNF]
theorem homEquiv_apply_eq (f : A ⨯ Y ⟶ X) : (exp.adjunction A).homEquiv _ _ f = curry f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : A ⨯ Y ⟶ X)
Goal: ((CategoryTheory.exp.adjunction A).homEquiv Y X) f = CategoryTheory.CartesianClosed.curry f
-- CategoryTheory.CartesianClosed.homEquiv_symm_apply_eq
@[simp, nolint simpNF]
theorem homEquiv_symm_apply_eq (f : Y ⟶ A ⟹ X) :
    ((exp.adjunction A).homEquiv _ _).symm f = uncurry f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : Y ⟶ A ⟹ X)
Goal: ((CategoryTheory.exp.adjunction A).homEquiv Y X).symm f = CategoryTheory.CartesianClosed.uncurry f
-- CategoryTheory.CartesianClosed.curry_natural_left
@[reassoc]
theorem curry_natural_left (f : X ⟶ X') (g : A ⨯ X' ⟶ Y) :
    curry (Limits.prod.map (𝟙 _) f ≫ g) = f ≫ curry g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X X' Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : X ⟶ X') (g : A ⨯ X' ⟶ Y)
Goal: CategoryTheory.CartesianClosed.curry
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id A) f) g) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.CartesianClosed.curry g)
-- CategoryTheory.CartesianClosed.curry_natural_right
@[reassoc]
theorem curry_natural_right (f : A ⨯ X ⟶ Y) (g : Y ⟶ Y') :
    curry (f ≫ g) = curry f ≫ (exp _).map g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y Y' : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : A ⨯ X ⟶ Y) (g : Y ⟶ Y')
Goal: CategoryTheory.CartesianClosed.curry (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianClosed.curry f) ((CategoryTheory.exp A).map g)
-- CategoryTheory.CartesianClosed.uncurry_natural_right
@[reassoc]
theorem uncurry_natural_right (f : X ⟶ A ⟹ Y) (g : Y ⟶ Y') :
    uncurry (f ≫ (exp _).map g) = uncurry f ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y Y' : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : X ⟶ A ⟹ Y) (g : Y ⟶ Y')
Goal: CategoryTheory.CartesianClosed.uncurry (CategoryTheory.CategoryStruct.comp f ((CategoryTheory.exp A).map g)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianClosed.uncurry f) g