ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.CartesianClosed.uncurry_natural_left
@[reassoc]
theorem uncurry_natural_left (f : X ⟶ X') (g : X' ⟶ A ⟹ Y) :
    uncurry (f ≫ g) = Limits.prod.map (𝟙 _) f ≫ uncurry 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 : X' ⟶ A ⟹ Y)
Goal: CategoryTheory.CartesianClosed.uncurry (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id A) f)
    (CategoryTheory.CartesianClosed.uncurry g)
-- CategoryTheory.CartesianClosed.uncurry_curry
@[simp]
theorem uncurry_curry (f : A ⨯ X ⟶ Y) : uncurry (curry f) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : A ⨯ X ⟶ Y)
Goal: CategoryTheory.CartesianClosed.uncurry (CategoryTheory.CartesianClosed.curry f) = f
-- CategoryTheory.CartesianClosed.curry_uncurry
@[simp]
theorem curry_uncurry (f : X ⟶ A ⟹ Y) : curry (uncurry f) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : X ⟶ A ⟹ Y)
Goal: CategoryTheory.CartesianClosed.curry (CategoryTheory.CartesianClosed.uncurry f) = f
-- CategoryTheory.CartesianClosed.curry_eq_iff
theorem curry_eq_iff (f : A ⨯ Y ⟶ X) (g : Y ⟶ A ⟹ X) : curry f = g ↔ f = uncurry g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : A ⨯ Y ⟶ X) (g : Y ⟶ A ⟹ X)
Goal: CategoryTheory.CartesianClosed.curry f = g ↔ f = CategoryTheory.CartesianClosed.uncurry g
-- CategoryTheory.CartesianClosed.eq_curry_iff
theorem eq_curry_iff (f : A ⨯ Y ⟶ X) (g : Y ⟶ A ⟹ X) : g = curry f ↔ uncurry g = 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) (g : Y ⟶ A ⟹ X)
Goal: g = CategoryTheory.CartesianClosed.curry f ↔ CategoryTheory.CartesianClosed.uncurry g = f
-- CategoryTheory.CartesianClosed.uncurry_eq
theorem uncurry_eq (g : Y ⟶ A ⟹ X) : uncurry g = Limits.prod.map (𝟙 A) g ≫ (exp.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (g : Y ⟶ A ⟹ X)
Goal: CategoryTheory.CartesianClosed.uncurry g =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id A) g)
    ((CategoryTheory.exp.ev A).app X)
-- CategoryTheory.CartesianClosed.curry_eq
theorem curry_eq (g : A ⨯ Y ⟶ X) : curry g = (exp.coev A).app Y ≫ (exp A).map g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (g : A ⨯ Y ⟶ X)
Goal: CategoryTheory.CartesianClosed.curry g =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.exp.coev A).app Y) ((CategoryTheory.exp A).map g)
-- CategoryTheory.CartesianClosed.uncurry_id_eq_ev
theorem uncurry_id_eq_ev (A X : C) [Exponentiable A] : uncurry (𝟙 (A ⟹ X)) = (exp.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] (A X : C) [CategoryTheory.Exponentiable A]
Goal: CategoryTheory.CartesianClosed.uncurry (CategoryTheory.CategoryStruct.id (A ⟹ X)) = (CategoryTheory.exp.ev A).app X
-- CategoryTheory.CartesianClosed.curry_id_eq_coev
theorem curry_id_eq_coev (A X : C) [Exponentiable A] : curry (𝟙 _) = (exp.coev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] (A X : C) [CategoryTheory.Exponentiable A]
Goal: CategoryTheory.CartesianClosed.curry (CategoryTheory.CategoryStruct.id (A ⨯ (CategoryTheory.Functor.id C).obj X)) =
  (CategoryTheory.exp.coev A).app X
-- CategoryTheory.CartesianClosed.curry_injective
theorem curry_injective : Function.Injective (curry : (A ⨯ Y ⟶ X) → (Y ⟶ A ⟹ X)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A]
Goal: Function.Injective CategoryTheory.CartesianClosed.curry
-- CategoryTheory.CartesianClosed.uncurry_injective
theorem uncurry_injective : Function.Injective (uncurry : (Y ⟶ A ⟹ X) → (A ⨯ Y ⟶ X)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A X Y : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A]
Goal: Function.Injective CategoryTheory.CartesianClosed.uncurry
-- CategoryTheory.prod_map_pre_app_comp_ev
theorem prod_map_pre_app_comp_ev (f : B ⟶ A) [Exponentiable B] (X : C) :
    Limits.prod.map (𝟙 B) ((pre f).app X) ≫ (exp.ev B).app X =
      Limits.prod.map f (𝟙 (A ⟹ X)) ≫ (exp.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : B ⟶ A) [CategoryTheory.Exponentiable B] (X : C)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id B) ((CategoryTheory.pre f).app X))
    ((CategoryTheory.exp.ev B).app X) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f (CategoryTheory.CategoryStruct.id (A ⟹ X)))
    ((CategoryTheory.exp.ev A).app X)
-- CategoryTheory.uncurry_pre
theorem uncurry_pre (f : B ⟶ A) [Exponentiable B] (X : C) :
    CartesianClosed.uncurry ((pre f).app X) = Limits.prod.map f (𝟙 _) ≫ (exp.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : B ⟶ A) [CategoryTheory.Exponentiable B] (X : C)
Goal: CategoryTheory.CartesianClosed.uncurry ((CategoryTheory.pre f).app X) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f (CategoryTheory.CategoryStruct.id (A ⟹ X)))
    ((CategoryTheory.exp.ev A).app X)
-- CategoryTheory.coev_app_comp_pre_app
theorem coev_app_comp_pre_app (f : B ⟶ A) [Exponentiable B] :
    (exp.coev A).app X ≫ (pre f).app (A ⨯ X) =
      (exp.coev B).app X ≫ (exp B).map (Limits.prod.map f (𝟙 _)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A B X : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] (f : B ⟶ A) [CategoryTheory.Exponentiable B]
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.exp.coev A).app X) ((CategoryTheory.pre f).app (A ⨯ X)) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.exp.coev B).app X)
    ((CategoryTheory.exp B).map (CategoryTheory.Limits.prod.map f (CategoryTheory.CategoryStruct.id X)))
-- CategoryTheory.pre_id
@[simp]
theorem pre_id (A : C) [Exponentiable A] : pre (𝟙 A) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] (A : C) [CategoryTheory.Exponentiable A]
Goal: CategoryTheory.pre (CategoryTheory.CategoryStruct.id A) = CategoryTheory.CategoryStruct.id (CategoryTheory.exp A)
-- CategoryTheory.pre_map
@[simp]
theorem pre_map {A₁ A₂ A₃ : C} [Exponentiable A₁] [Exponentiable A₂] [Exponentiable A₃]
    (f : A₁ ⟶ A₂) (g : A₂ ⟶ A₃) : pre (f ≫ g) = pre g ≫ pre f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] {A₁ A₂ A₃ : C} [CategoryTheory.Exponentiable A₁] [CategoryTheory.Exponentiable A₂] [CategoryTheory.Exponentiable A₃] (f : A₁ ⟶ A₂) (g : A₂ ⟶ A₃)
Goal: CategoryTheory.pre (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.pre g) (CategoryTheory.pre f)
-- CategoryTheory.zeroMul_inv
@[simps]
def zeroMul {I : C} (t : IsInitial I) : A ⨯ I ≅ I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] {I : C} (t : CategoryTheory.Limits.IsInitial I)
Goal: (CategoryTheory.zeroMul t).inv = t.to (A ⨯ I)
-- CategoryTheory.zeroMul_hom
@[simps]
def zeroMul {I : C} (t : IsInitial I) : A ⨯ I ≅ I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] {I : C} (t : CategoryTheory.Limits.IsInitial I)
Goal: (CategoryTheory.zeroMul t).hom = CategoryTheory.Limits.prod.snd
-- CategoryTheory.strict_initial
theorem strict_initial {I : C} (t : IsInitial I) (f : A ⟶ I) : IsIso f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : C} [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Exponentiable A] {I : C} (t : CategoryTheory.Limits.IsInitial I) (f : A ⟶ I)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.initial_mono
theorem initial_mono {I : C} (B : C) (t : IsInitial I) [CartesianClosed C] : Mono (t.to B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasFiniteProducts C] {I : C} (B : C) (t : CategoryTheory.Limits.IsInitial I) [CategoryTheory.CartesianClosed C]
Goal: CategoryTheory.Mono (t.to B)
-- gal_zero_isSolvable
theorem gal_zero_isSolvable : IsSolvable (0 : F[X]).Gal 
Arguments: {F : Type u_1} [Field F]
Goal: IsSolvable (Polynomial.Gal 0)
-- gal_one_isSolvable
theorem gal_one_isSolvable : IsSolvable (1 : F[X]).Gal 
Arguments: {F : Type u_1} [Field F]
Goal: IsSolvable (Polynomial.Gal 1)
-- gal_C_isSolvable
theorem gal_C_isSolvable (x : F) : IsSolvable (C x).Gal 
Arguments: {F : Type u_1} [Field F] (x : F)
Goal: IsSolvable (Polynomial.C x).Gal
-- gal_X_isSolvable
theorem gal_X_isSolvable : IsSolvable (X : F[X]).Gal 
Arguments: {F : Type u_1} [Field F]
Goal: IsSolvable Polynomial.X.Gal
-- gal_X_sub_C_isSolvable
theorem gal_X_sub_C_isSolvable (x : F) : IsSolvable (X - C x).Gal 
Arguments: {F : Type u_1} [Field F] (x : F)
Goal: IsSolvable (Polynomial.X - Polynomial.C x).Gal
-- gal_X_pow_isSolvable
theorem gal_X_pow_isSolvable (n : ℕ) : IsSolvable (X ^ n : F[X]).Gal 
Arguments: {F : Type u_1} [Field F] (n : ℕ)
Goal: IsSolvable (Polynomial.X ^ n).Gal
-- gal_mul_isSolvable
theorem gal_mul_isSolvable {p q : F[X]} (_ : IsSolvable p.Gal) (_ : IsSolvable q.Gal) :
    IsSolvable (p * q).Gal 
Arguments: {F : Type u_1} [Field F] {p q : F[X]}
Goal: IsSolvable p.Gal → IsSolvable q.Gal → IsSolvable (p * q).Gal
-- gal_prod_isSolvable
theorem gal_prod_isSolvable {s : Multiset F[X]} (hs : ∀ p ∈ s, IsSolvable (Gal p)) :
    IsSolvable s.prod.Gal 
Arguments: {F : Type u_1} [Field F] {s : Multiset F[X]} (hs : ∀ p ∈ s, IsSolvable p.Gal)
Goal: IsSolvable s.prod.Gal
-- gal_isSolvable_of_splits
theorem gal_isSolvable_of_splits {p q : F[X]}
    (_ : Fact (p.Splits (algebraMap F q.SplittingField))) (hq : IsSolvable q.Gal) :
    IsSolvable p.Gal 
Arguments: {F : Type u_1} [Field F] {p q : F[X]}
Goal: Fact (Polynomial.Splits (algebraMap F q.SplittingField) p) → IsSolvable q.Gal → IsSolvable p.Gal
-- gal_isSolvable_tower
theorem gal_isSolvable_tower (p q : F[X]) (hpq : p.Splits (algebraMap F q.SplittingField))
    (hp : IsSolvable p.Gal) (hq : IsSolvable (q.map (algebraMap F p.SplittingField)).Gal) :
    IsSolvable q.Gal 
Arguments: {F : Type u_1} [Field F] (p q : F[X]) (hpq : Polynomial.Splits (algebraMap F q.SplittingField) p) (hp : IsSolvable p.Gal) (hq : IsSolvable (Polynomial.map (algebraMap F p.SplittingField) q).Gal)
Goal: IsSolvable q.Gal
-- gal_X_pow_sub_one_isSolvable
theorem gal_X_pow_sub_one_isSolvable (n : ℕ) : IsSolvable (X ^ n - 1 : F[X]).Gal 
Arguments: {F : Type u_1} [Field F] (n : ℕ)
Goal: IsSolvable (Polynomial.X ^ n - 1).Gal
-- gal_X_pow_sub_C_isSolvable_aux
theorem gal_X_pow_sub_C_isSolvable_aux (n : ℕ) (a : F)
    (h : (X ^ n - 1 : F[X]).Splits (RingHom.id F)) : IsSolvable (X ^ n - C a).Gal 
Arguments: {F : Type u_1} [Field F] (n : ℕ) (a : F) (h : Polynomial.Splits (RingHom.id F) (Polynomial.X ^ n - 1))
Goal: IsSolvable (Polynomial.X ^ n - Polynomial.C a).Gal
-- splits_X_pow_sub_one_of_X_pow_sub_C
theorem splits_X_pow_sub_one_of_X_pow_sub_C {F : Type*} [Field F] {E : Type*} [Field E]
    (i : F →+* E) (n : ℕ) {a : F} (ha : a ≠ 0) (h : (X ^ n - C a).Splits i) :
    (X ^ n - 1 : F[X]).Splits i 
Arguments: {F : Type u_3} [Field F] {E : Type u_4} [Field E] (i : F →+* E) (n : ℕ) {a : F} (ha : a ≠ 0) (h : Polynomial.Splits i (Polynomial.X ^ n - Polynomial.C a))
Goal: Polynomial.Splits i (Polynomial.X ^ n - 1)
-- gal_X_pow_sub_C_isSolvable
theorem gal_X_pow_sub_C_isSolvable (n : ℕ) (x : F) : IsSolvable (X ^ n - C x).Gal 
Arguments: {F : Type u_1} [Field F] (n : ℕ) (x : F)
Goal: IsSolvable (Polynomial.X ^ n - Polynomial.C x).Gal
-- solvableByRad.induction
theorem induction (P : solvableByRad F E → Prop)
    (base : ∀ α : F, P (algebraMap F (solvableByRad F E) α))
    (add : ∀ α β : solvableByRad F E, P α → P β → P (α + β))
    (neg : ∀ α : solvableByRad F E, P α → P (-α))
    (mul : ∀ α β : solvableByRad F E, P α → P β → P (α * β))
    (inv : ∀ α : solvableByRad F E, P α → P α⁻¹)
    (rad : ∀ α : solvableByRad F E, ∀ n : ℕ, n ≠ 0 → P (α ^ n) → P α) (α : solvableByRad F E) :
    P α 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (P : ↥(solvableByRad F E) → Prop) (base : ∀ (α : F), P ((algebraMap F ↥(solvableByRad F E)) α)) (add : ∀ (α β : ↥(solvableByRad F E)), P α → P β → P (α + β)) (neg : ∀ (α : ↥(solvableByRad F E)), P α → P (-α)) (mul : ∀ (α β : ↥(solvableByRad F E)), P α → P β → P (α * β)) (inv : ∀ (α : ↥(solvableByRad F E)), P α → P α⁻¹) (rad : ∀ (α : ↥(solvableByRad F E)) (n : ℕ), n ≠ 0 → P (α ^ n) → P α) (α : ↥(solvableByRad F E))
Goal: P α
-- solvableByRad.isIntegral
theorem isIntegral (α : solvableByRad F E) : IsIntegral F α 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (α : ↥(solvableByRad F E))
Goal: IsIntegral F α
-- solvableByRad.induction3
theorem induction3 {α : solvableByRad F E} {n : ℕ} (hn : n ≠ 0) (hα : P (α ^ n)) : P α 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {α : ↥(solvableByRad F E)} {n : ℕ} (hn : n ≠ 0) (hα : solvableByRad.P (α ^ n))
Goal: solvableByRad.P α
-- solvableByRad.induction2
theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {α β γ : ↥(solvableByRad F E)} (hγ : γ ∈ F⟮α, β⟯) (hα : solvableByRad.P α) (hβ : solvableByRad.P β)
Goal: solvableByRad.P γ
-- solvableByRad.induction1
theorem induction1 {α β : solvableByRad F E} (hβ : β ∈ F⟮α⟯) (hα : P α) : P β 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {α β : ↥(solvableByRad F E)} (hβ : β ∈ F⟮α⟯) (hα : solvableByRad.P α)
Goal: solvableByRad.P β
-- solvableByRad.isSolvable
theorem isSolvable (α : solvableByRad F E) : IsSolvable (minpoly F α).Gal 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] (α : ↥(solvableByRad F E))
Goal: IsSolvable (minpoly F α).Gal
-- solvableByRad.isSolvable'
theorem isSolvable' {α : E} {q : F[X]} (q_irred : Irreducible q) (q_aeval : aeval α q = 0)
    (hα : IsSolvableByRad F α) : IsSolvable q.Gal 
Arguments: {F : Type u_1} [Field F] {E : Type u_2} [Field E] [Algebra F E] {α : E} {q : F[X]} (q_irred : Irreducible q) (q_aeval : (Polynomial.aeval α) q = 0) (hα : IsSolvableByRad F α)
Goal: IsSolvable q.Gal
-- CategoryTheory.Sheaf.isLocallySurjective_iff_epi'
lemma isLocallySurjective_iff_epi' :
    IsLocallySurjective φ ↔ Epi φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (A : Type u') [CategoryTheory.Category.{v', u'} A] [CategoryTheory.ConcreteCategory A] [CategoryTheory.ConcreteCategory.HasFunctorialSurjectiveInjectiveFactorization A] [J.WEqualsLocallyBijective A] [CategoryTheory.HasSheafify J A] [J.HasSheafCompose (CategoryTheory.forget A)] [CategoryTheory.Balanced (CategoryTheory.Sheaf J A)] {F G : CategoryTheory.Sheaf J A} (φ : F ⟶ G)
Goal: CategoryTheory.Sheaf.IsLocallySurjective φ ↔ CategoryTheory.Epi φ
-- CategoryTheory.actionAsFunctor_obj
@[simps]
def actionAsFunctor : SingleObj M ⥤ Type u 
Arguments: (M : Type u_1) [Monoid M] (X : Type u) [MulAction M X]
Goal: ∀ (x : CategoryTheory.SingleObj M), (CategoryTheory.actionAsFunctor M X).obj x = X
-- CategoryTheory.actionAsFunctor_map
@[simps]
def actionAsFunctor : SingleObj M ⥤ Type u 
Arguments: (M : Type u_1) [Monoid M] (X : Type u) [MulAction M X]
Goal: ∀ {X_1 Y : CategoryTheory.SingleObj M} (x : X_1 ⟶ Y) (x_1 : X), (CategoryTheory.actionAsFunctor M X).map x x_1 = x • x_1
-- CategoryTheory.ActionCategory.π_map
@[simp]
theorem π_map (p q : ActionCategory M X) (f : p ⟶ q) : (π M X).map f = f.val 
Arguments: (M : Type u_1) [Monoid M] (X : Type u) [MulAction M X] (p q : CategoryTheory.ActionCategory M X) (f : p ⟶ q)
Goal: (CategoryTheory.ActionCategory.π M X).map f = ↑f
-- CategoryTheory.ActionCategory.π_obj
@[simp]
theorem π_obj (p : ActionCategory M X) : (π M X).obj p = SingleObj.star M 
Arguments: (M : Type u_1) [Monoid M] (X : Type u) [MulAction M X] (p : CategoryTheory.ActionCategory M X)
Goal: (CategoryTheory.ActionCategory.π M X).obj p = CategoryTheory.SingleObj.star M
-- CategoryTheory.ActionCategory.coe_back
@[simp]
theorem coe_back (x : X) : ActionCategory.back (x : ActionCategory M X) = x 
Arguments: {M : Type u_1} [Monoid M] {X : Type u} [MulAction M X] (x : X)
Goal: CategoryTheory.ActionCategory.back ⟨(), x⟩ = x
-- CategoryTheory.ActionCategory.back_coe
@[simp]
theorem back_coe (x : ActionCategory M X) : ↑x.back = x 
Arguments: {M : Type u_1} [Monoid M] {X : Type u} [MulAction M X] (x : CategoryTheory.ActionCategory M X)
Goal: ⟨(), x.back⟩ = x
-- CategoryTheory.ActionCategory.hom_as_subtype
theorem hom_as_subtype (p q : ActionCategory M X) : (p ⟶ q) = { m : M // m • p.back = q.back } 
Arguments: (M : Type u_1) [Monoid M] (X : Type u) [MulAction M X] (p q : CategoryTheory.ActionCategory M X)
Goal: (p ⟶ q) = { m // m • p.back = q.back }
-- CategoryTheory.ActionCategory.stabilizerIsoEnd_apply
@[simp]
theorem stabilizerIsoEnd_apply (f : stabilizerSubmonoid M x) :
    (stabilizerIsoEnd M x) f = f 
Arguments: (M : Type u_1) [Monoid M] {X : Type u} [MulAction M X] (x : X) (f : ↥(MulAction.stabilizerSubmonoid M x))
Goal: (CategoryTheory.ActionCategory.stabilizerIsoEnd M x) f = f
-- CategoryTheory.ActionCategory.stabilizerIsoEnd_symm_apply
@[simp 1100]
theorem stabilizerIsoEnd_symm_apply (f : End _) : (stabilizerIsoEnd M x).symm f = f 
Arguments: (M : Type u_1) [Monoid M] {X : Type u} [MulAction M X] (x : X) (f : CategoryTheory.End ⟨(), x⟩)
Goal: (CategoryTheory.ActionCategory.stabilizerIsoEnd M x).symm f = f
-- CategoryTheory.ActionCategory.id_val
@[simp]
protected theorem id_val (x : ActionCategory M X) : Subtype.val (𝟙 x) = 1 
Arguments: {M : Type u_1} [Monoid M] {X : Type u} [MulAction M X] (x : CategoryTheory.ActionCategory M X)
Goal: ↑(CategoryTheory.CategoryStruct.id x) = 1
-- CategoryTheory.ActionCategory.comp_val
@[simp]
protected theorem comp_val {x y z : ActionCategory M X} (f : x ⟶ y) (g : y ⟶ z) :
    (f ≫ g).val = g.val * f.val 
Arguments: {M : Type u_1} [Monoid M] {X : Type u} [MulAction M X] {x y z : CategoryTheory.ActionCategory M X} (f : x ⟶ y) (g : y ⟶ z)
Goal: ↑(CategoryTheory.CategoryStruct.comp f g) = ↑g * ↑f
-- CategoryTheory.ActionCategory.homOfPair.val
@[simp]
theorem homOfPair.val (t : X) (g : G) : (homOfPair t g).val = g 
Arguments: {X : Type u} {G : Type u_2} [Group G] [MulAction G X] (t : X) (g : G)
Goal: ↑(CategoryTheory.ActionCategory.homOfPair t g) = g
-- CategoryTheory.ActionCategory.cases'
lemma cases' ⦃a' b' : ActionCategory G X⦄ (f : a' ⟶ b') :
    ∃ (a b : X) (g : G) (ha : a' = a) (hb : b' = b) (hg : a = g⁻¹ • b),
      f = eqToHom (by rw [ha, hg]) ≫ homOfPair b g ≫ eqToHom (by rw [hb]) 
Arguments: {X : Type u} {G : Type u_2} [Group G] [MulAction G X] ⦃a' b' : CategoryTheory.ActionCategory G X⦄ (f : a' ⟶ b')
Goal: ∃ a b g,
  ∃ (ha : a' = ⟨(), a⟩) (hb : b' = ⟨(), b⟩) (hg : a = g⁻¹ • b),
    f =
      CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
        (CategoryTheory.CategoryStruct.comp (CategoryTheory.ActionCategory.homOfPair b g) (CategoryTheory.eqToHom ⋯))
-- CategoryTheory.ActionCategory.curry_apply_left
@[simps]
def curry (F : ActionCategory G X ⥤ SingleObj H) : G →* (X → H) ⋊[mulAutArrow] G 
Arguments: {X : Type u} {G : Type u_2} [Group G] [MulAction G X] {H : Type u_3} [Group H] (F : CategoryTheory.Functor (CategoryTheory.ActionCategory G X) (CategoryTheory.SingleObj H)) (g : G) (b : X)
Goal: ((CategoryTheory.ActionCategory.curry F) g).left b = F.map (CategoryTheory.ActionCategory.homOfPair b g)
-- CategoryTheory.ActionCategory.curry_apply_right
@[simps]
def curry (F : ActionCategory G X ⥤ SingleObj H) : G →* (X → H) ⋊[mulAutArrow] G 
Arguments: {X : Type u} {G : Type u_2} [Group G] [MulAction G X] {H : Type u_3} [Group H] (F : CategoryTheory.Functor (CategoryTheory.ActionCategory G X) (CategoryTheory.SingleObj H)) (g : G)
Goal: ((CategoryTheory.ActionCategory.curry F) g).right = g
-- CategoryTheory.ActionCategory.uncurry_obj
@[simps]
def uncurry (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ g, (F g).right = g) :
    ActionCategory G X ⥤ SingleObj H 
Arguments: {X : Type u} {G : Type u_2} [Group G] [MulAction G X] {H : Type u_3} [Group H] (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ (g : G), (F g).right = g)
Goal: ∀ (x : CategoryTheory.ActionCategory G X), (CategoryTheory.ActionCategory.uncurry F sane).obj x = ()
-- CategoryTheory.ActionCategory.uncurry_map
@[simps]
def uncurry (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ g, (F g).right = g) :
    ActionCategory G X ⥤ SingleObj H 
Arguments: {X : Type u} {G : Type u_2} [Group G] [MulAction G X] {H : Type u_3} [Group H] (F : G →* (X → H) ⋊[mulAutArrow] G) (sane : ∀ (g : G), (F g).right = g)
Goal: ∀ {x b : CategoryTheory.ActionCategory G X} (f : x ⟶ b),
  (CategoryTheory.ActionCategory.uncurry F sane).map f = (F ↑f).left b.back
-- CategoryTheory.expComparison_ev
theorem expComparison_ev (A B : C) :
    Limits.prod.map (𝟙 (F.obj A)) ((expComparison F A).app B) ≫ (exp.ev (F.obj A)).app (F.obj B) =
      inv (prodComparison F _ _) ≫ F.map ((exp.ev _).app _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v, u'} D] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasFiniteProducts D] (F : CategoryTheory.Functor C D) [CategoryTheory.CartesianClosed C] [CategoryTheory.CartesianClosed D] [CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F] (A B : C)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id (F.obj A))
      ((CategoryTheory.expComparison F A).app B))
    ((CategoryTheory.exp.ev (F.obj A)).app (F.obj B)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (CategoryTheory.Limits.prodComparison F A (A ⟹ B)))
    (F.map ((CategoryTheory.exp.ev A).app B))
-- CategoryTheory.coev_expComparison
theorem coev_expComparison (A B : C) :
    F.map ((exp.coev A).app B) ≫ (expComparison F A).app (A ⨯ B) =
      (exp.coev _).app (F.obj B) ≫ (exp (F.obj A)).map (inv (prodComparison F A B)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v, u'} D] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasFiniteProducts D] (F : CategoryTheory.Functor C D) [CategoryTheory.CartesianClosed C] [CategoryTheory.CartesianClosed D] [CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F] (A B : C)
Goal: CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.exp.coev A).app B))
    ((CategoryTheory.expComparison F A).app (A ⨯ B)) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.exp.coev (F.obj A)).app (F.obj B))
    ((CategoryTheory.exp (F.obj A)).map (CategoryTheory.inv (CategoryTheory.Limits.prodComparison F A B)))