ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Equivalence.map_projective_iff
theorem map_projective_iff (P : C) : Projective (F.functor.obj P) ↔ Projective P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : C ≌ D) (P : C)
Goal: CategoryTheory.Projective (F.functor.obj P) ↔ CategoryTheory.Projective P
-- CategoryTheory.Equivalence.enoughProjectives_iff
theorem enoughProjectives_iff (F : C ≌ D) : EnoughProjectives C ↔ EnoughProjectives D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : C ≌ D)
Goal: CategoryTheory.EnoughProjectives C ↔ CategoryTheory.EnoughProjectives D
-- CategoryTheory.unop_add
@[simp]
theorem unop_add {X Y : Cᵒᵖ} (f g : X ⟶ Y) : (f + g).unop = f.unop + g.unop 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : Cᵒᵖ} (f g : X ⟶ Y)
Goal: (f + g).unop = f.unop + g.unop
-- CategoryTheory.unop_zsmul
@[simp]
theorem unop_zsmul {X Y : Cᵒᵖ} (k : ℤ) (f : X ⟶ Y) : (k • f).unop = k • f.unop 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : Cᵒᵖ} (k : ℤ) (f : X ⟶ Y)
Goal: (k • f).unop = k • f.unop
-- CategoryTheory.unop_neg
@[simp]
theorem unop_neg {X Y : Cᵒᵖ} (f : X ⟶ Y) : (-f).unop = -f.unop 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: (-f).unop = -f.unop
-- CategoryTheory.op_add
@[simp]
theorem op_add {X Y : C} (f g : X ⟶ Y) : (f + g).op = f.op + g.op 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : C} (f g : X ⟶ Y)
Goal: (f + g).op = f.op + g.op
-- CategoryTheory.op_zsmul
@[simp]
theorem op_zsmul {X Y : C} (k : ℤ) (f : X ⟶ Y) : (k • f).op = k • f.op 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : C} (k : ℤ) (f : X ⟶ Y)
Goal: (k • f).op = k • f.op
-- CategoryTheory.op_neg
@[simp]
theorem op_neg {X Y : C} (f : X ⟶ Y) : (-f).op = -f.op 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {X Y : C} (f : X ⟶ Y)
Goal: (-f).op = -f.op
-- CategoryTheory.unopHom_apply
@[simps!]
def unopHom (X Y : Cᵒᵖ) : (X ⟶ Y) →+ (Opposite.unop Y ⟶ Opposite.unop X) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (X Y : Cᵒᵖ) (f : X ⟶ Y)
Goal: (CategoryTheory.unopHom X Y) f = f.unop
-- CategoryTheory.unop_sum
@[simp]
theorem unop_sum (X Y : Cᵒᵖ) {ι : Type*} (s : Finset ι) (f : ι → (X ⟶ Y)) :
    (s.sum f).unop = s.sum fun i => (f i).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] (X Y : Cᵒᵖ) {ι : Type u_2} (s : Finset ι) (f : ι → (X ⟶ Y))
Goal: (s.sum f).unop = ∑ i ∈ s, (f i).unop
-- CategoryTheory.opHom_apply
@[simps!]
def opHom (X Y : C) : (X ⟶ Y) →+ (Opposite.op Y ⟶ Opposite.op X) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (X Y : C) (f : X ⟶ Y)
Goal: (CategoryTheory.opHom X Y) f = f.op
-- CategoryTheory.op_sum
@[simp]
theorem op_sum (X Y : C) {ι : Type*} (s : Finset ι) (f : ι → (X ⟶ Y)) :
    (s.sum f).op = s.sum fun i => (f i).op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] (X Y : C) {ι : Type u_2} (s : Finset ι) (f : ι → (X ⟶ Y))
Goal: (s.sum f).op = ∑ i ∈ s, (f i).op
-- CategoryTheory.Subgroupoid.mul
@[ext]
structure Subgroupoid (C : Type u) [Groupoid C] where
  arrows : ∀ c d : C, Set (c ⟶ d)
  protected inv : ∀ {c d} {p : c ⟶ d}, p ∈ arrows c d → Groupoid.inv p ∈ arrows d c
  protected mul : ∀ {c d e} {p}, p ∈ arrows c d → ∀ {q}, q ∈ arrows d e → p ≫ q ∈ arrows c e
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (self : CategoryTheory.Subgroupoid C) {c d e : C} {p : c ⟶ d}
Goal: p ∈ self.arrows c d → ∀ {q : d ⟶ e}, q ∈ self.arrows d e → CategoryTheory.CategoryStruct.comp p q ∈ self.arrows c e
-- CategoryTheory.Subgroupoid.inv
@[ext]
structure Subgroupoid (C : Type u) [Groupoid C] where
  arrows : ∀ c d : C, Set (c ⟶ d)
  protected inv : ∀ {c d} {p : c ⟶ d}, p ∈ arrows c d → Groupoid.inv p ∈ arrows d c
  protected mul : ∀ {c d e} {p}, p ∈ arrows c d → ∀ {q}, q ∈ arrows d e → p ≫ q ∈ arrows c e
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (self : CategoryTheory.Subgroupoid C) {c d : C} {p : c ⟶ d}
Goal: p ∈ self.arrows c d → CategoryTheory.Groupoid.inv p ∈ self.arrows d c
-- CategoryTheory.Subgroupoid.inv_mem_iff
theorem inv_mem_iff {c d : C} (f : c ⟶ d) :
    Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d : C} (f : c ⟶ d)
Goal: CategoryTheory.Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d
-- CategoryTheory.Subgroupoid.mul_mem_cancel_left
theorem mul_mem_cancel_left {c d e : C} {f : c ⟶ d} {g : d ⟶ e} (hf : f ∈ S.arrows c d) :
    f ≫ g ∈ S.arrows c e ↔ g ∈ S.arrows d e 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d e : C} {f : c ⟶ d} {g : d ⟶ e} (hf : f ∈ S.arrows c d)
Goal: CategoryTheory.CategoryStruct.comp f g ∈ S.arrows c e ↔ g ∈ S.arrows d e
-- CategoryTheory.Subgroupoid.mul_mem_cancel_right
theorem mul_mem_cancel_right {c d e : C} {f : c ⟶ d} {g : d ⟶ e} (hg : g ∈ S.arrows d e) :
    f ≫ g ∈ S.arrows c e ↔ f ∈ S.arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d e : C} {f : c ⟶ d} {g : d ⟶ e} (hg : g ∈ S.arrows d e)
Goal: CategoryTheory.CategoryStruct.comp f g ∈ S.arrows c e ↔ f ∈ S.arrows c d
-- CategoryTheory.Subgroupoid.mem_objs_of_src
theorem mem_objs_of_src {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : c ∈ S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d)
Goal: c ∈ S.objs
-- CategoryTheory.Subgroupoid.mem_objs_of_tgt
theorem mem_objs_of_tgt {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : d ∈ S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d)
Goal: d ∈ S.objs
-- CategoryTheory.Subgroupoid.id_mem_of_nonempty_isotropy
theorem id_mem_of_nonempty_isotropy (c : C) : c ∈ objs S → 𝟙 c ∈ S.arrows c c 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (c : C)
Goal: c ∈ S.objs → CategoryTheory.CategoryStruct.id c ∈ S.arrows c c
-- CategoryTheory.Subgroupoid.id_mem_of_src
theorem id_mem_of_src {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : 𝟙 c ∈ S.arrows c c 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d)
Goal: CategoryTheory.CategoryStruct.id c ∈ S.arrows c c
-- CategoryTheory.Subgroupoid.id_mem_of_tgt
theorem id_mem_of_tgt {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : 𝟙 d ∈ S.arrows d d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d)
Goal: CategoryTheory.CategoryStruct.id d ∈ S.arrows d d
-- CategoryTheory.Subgroupoid.coe_comp_coe
@[simps comp_coe, simps (config := .lemmasOnly) inv_coe]
instance coe : Groupoid S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: ∀ {X Y Z : ↑S.objs} (p : X ⟶ Y) (q : Y ⟶ Z),
  ↑(CategoryTheory.CategoryStruct.comp p q) = CategoryTheory.CategoryStruct.comp ↑p ↑q
-- CategoryTheory.Subgroupoid.coe_inv_coe
@[simps comp_coe, simps (config := .lemmasOnly) inv_coe]
instance coe : Groupoid S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: ∀ {X Y : ↑S.objs} (p : X ⟶ Y), ↑(CategoryTheory.Groupoid.inv p) = CategoryTheory.Groupoid.inv ↑p
-- CategoryTheory.Subgroupoid.coe_inv_coe'
@[simp]
theorem coe_inv_coe' {c d : S.objs} (p : c ⟶ d) :
    (CategoryTheory.inv p).val = CategoryTheory.inv p.val 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {c d : ↑S.objs} (p : c ⟶ d)
Goal: ↑(CategoryTheory.inv p) = CategoryTheory.inv ↑p
-- CategoryTheory.Subgroupoid.hom.inj_on_objects
theorem hom.inj_on_objects : Function.Injective (hom S).obj 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: Function.Injective S.hom.obj
-- CategoryTheory.Subgroupoid.hom.faithful
theorem hom.faithful : ∀ c d, Function.Injective fun f : c ⟶ d => (hom S).map f 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (c d : ↑S.objs)
Goal: Function.Injective fun f => S.hom.map f
-- CategoryTheory.Subgroupoid.mem_iff
theorem mem_iff (S : Subgroupoid C) (F : Σ c d, c ⟶ d) : F ∈ S ↔ F.2.2 ∈ S.arrows F.1 F.2.1 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (F : (c : C) × (d : C) × (c ⟶ d))
Goal: F ∈ S ↔ F.snd.snd ∈ S.arrows F.fst F.snd.fst
-- CategoryTheory.Subgroupoid.le_iff
theorem le_iff (S T : Subgroupoid C) : S ≤ T ↔ ∀ {c d}, S.arrows c d ⊆ T.arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S T : CategoryTheory.Subgroupoid C)
Goal: S ≤ T ↔ ∀ {c d : C}, S.arrows c d ⊆ T.arrows c d
-- CategoryTheory.Subgroupoid.mem_top
theorem mem_top {c d : C} (f : c ⟶ d) : f ∈ (⊤ : Subgroupoid C).arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {c d : C} (f : c ⟶ d)
Goal: f ∈ ⊤.arrows c d
-- CategoryTheory.Subgroupoid.mem_top_objs
theorem mem_top_objs (c : C) : c ∈ (⊤ : Subgroupoid C).objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (c : C)
Goal: c ∈ ⊤.objs
-- CategoryTheory.Subgroupoid.mem_sInf_arrows
theorem mem_sInf_arrows {s : Set (Subgroupoid C)} {c d : C} {p : c ⟶ d} :
    p ∈ (sInf s).arrows c d ↔ ∀ S ∈ s, p ∈ S.arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {s : Set (CategoryTheory.Subgroupoid C)} {c d : C} {p : c ⟶ d}
Goal: p ∈ (sInf s).arrows c d ↔ ∀ S ∈ s, p ∈ S.arrows c d
-- CategoryTheory.Subgroupoid.mem_sInf
theorem mem_sInf {s : Set (Subgroupoid C)} {p : Σ c d : C, c ⟶ d} :
    p ∈ sInf s ↔ ∀ S ∈ s, p ∈ S 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {s : Set (CategoryTheory.Subgroupoid C)} {p : (c : C) × (d : C) × (c ⟶ d)}
Goal: p ∈ sInf s ↔ ∀ S ∈ s, p ∈ S
-- CategoryTheory.Subgroupoid.le_objs
theorem le_objs {S T : Subgroupoid C} (h : S ≤ T) : S.objs ⊆ T.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S T : CategoryTheory.Subgroupoid C} (h : S ≤ T)
Goal: S.objs ⊆ T.objs
-- CategoryTheory.Subgroupoid.inclusion_inj_on_objects
theorem inclusion_inj_on_objects {S T : Subgroupoid C} (h : S ≤ T) :
    Function.Injective (inclusion h).obj 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S T : CategoryTheory.Subgroupoid C} (h : S ≤ T)
Goal: Function.Injective (CategoryTheory.Subgroupoid.inclusion h).obj
-- CategoryTheory.Subgroupoid.inclusion_faithful
theorem inclusion_faithful {S T : Subgroupoid C} (h : S ≤ T) (s t : S.objs) :
    Function.Injective fun f : s ⟶ t => (inclusion h).map f 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S T : CategoryTheory.Subgroupoid C} (h : S ≤ T) (s t : ↑S.objs)
Goal: Function.Injective fun f => (CategoryTheory.Subgroupoid.inclusion h).map f
-- CategoryTheory.Subgroupoid.inclusion_refl
theorem inclusion_refl {S : Subgroupoid C} : inclusion (le_refl S) = 𝟭 S.objs 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C}
Goal: CategoryTheory.Subgroupoid.inclusion ⋯ = CategoryTheory.Functor.id ↑S.objs
-- CategoryTheory.Subgroupoid.inclusion_trans
theorem inclusion_trans {R S T : Subgroupoid C} (k : R ≤ S) (h : S ≤ T) :
    inclusion (k.trans h) = inclusion k ⋙ inclusion h 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {R S T : CategoryTheory.Subgroupoid C} (k : R ≤ S) (h : S ≤ T)
Goal: CategoryTheory.Subgroupoid.inclusion ⋯ =
  (CategoryTheory.Subgroupoid.inclusion k).comp (CategoryTheory.Subgroupoid.inclusion h)
-- CategoryTheory.Subgroupoid.inclusion_comp_embedding
theorem inclusion_comp_embedding {S T : Subgroupoid C} (h : S ≤ T) : inclusion h ⋙ T.hom = S.hom 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S T : CategoryTheory.Subgroupoid C} (h : S ≤ T)
Goal: (CategoryTheory.Subgroupoid.inclusion h).comp T.hom = S.hom
-- CategoryTheory.Subgroupoid.mem_discrete_iff
theorem mem_discrete_iff {c d : C} (f : c ⟶ d) :
    f ∈ discrete.arrows c d ↔ ∃ h : c = d, f = eqToHom h 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {c d : C} (f : c ⟶ d)
Goal: f ∈ CategoryTheory.Subgroupoid.discrete.arrows c d ↔ ∃ (h : c = d), f = CategoryTheory.eqToHom h
-- CategoryTheory.Subgroupoid.IsWide.wide
structure IsWide : Prop where
  wide : ∀ c, 𝟙 c ∈ S.arrows c c
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C} (self : S.IsWide) (c : C)
Goal: CategoryTheory.CategoryStruct.id c ∈ S.arrows c c
-- CategoryTheory.Subgroupoid.isWide_iff_objs_eq_univ
theorem isWide_iff_objs_eq_univ : S.IsWide ↔ S.objs = Set.univ 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C)
Goal: S.IsWide ↔ S.objs = Set.univ
-- CategoryTheory.Subgroupoid.IsWide.id_mem
theorem IsWide.id_mem {S : Subgroupoid C} (Sw : S.IsWide) (c : C) : 𝟙 c ∈ S.arrows c c 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C} (Sw : S.IsWide) (c : C)
Goal: CategoryTheory.CategoryStruct.id c ∈ S.arrows c c
-- CategoryTheory.Subgroupoid.IsWide.eqToHom_mem
theorem IsWide.eqToHom_mem {S : Subgroupoid C} (Sw : S.IsWide) {c d : C} (h : c = d) :
    eqToHom h ∈ S.arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C} (Sw : S.IsWide) {c d : C} (h : c = d)
Goal: CategoryTheory.eqToHom h ∈ S.arrows c d
-- CategoryTheory.Subgroupoid.IsNormal.conj
structure IsNormal extends IsWide S : Prop where
  conj : ∀ {c d} (p : c ⟶ d) {γ : c ⟶ c}, γ ∈ S.arrows c c → Groupoid.inv p ≫ γ ≫ p ∈ S.arrows d d
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C} (self : S.IsNormal) {c d : C} (p : c ⟶ d) {γ : c ⟶ c}
Goal: γ ∈ S.arrows c c →
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv p) (CategoryTheory.CategoryStruct.comp γ p) ∈
    S.arrows d d
-- CategoryTheory.Subgroupoid.IsNormal.conj'
theorem IsNormal.conj' {S : Subgroupoid C} (Sn : IsNormal S) :
    ∀ {c d} (p : d ⟶ c) {γ : c ⟶ c}, γ ∈ S.arrows c c → p ≫ γ ≫ Groupoid.inv p ∈ S.arrows d d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C} (Sn : S.IsNormal) {c d : C} (p : d ⟶ c) {γ : c ⟶ c}
Goal: γ ∈ S.arrows c c →
  CategoryTheory.CategoryStruct.comp p (CategoryTheory.CategoryStruct.comp γ (CategoryTheory.Groupoid.inv p)) ∈
    S.arrows d d
-- CategoryTheory.Subgroupoid.IsNormal.conjugation_bij
theorem IsNormal.conjugation_bij (Sn : IsNormal S) {c d} (p : c ⟶ d) :
    Set.BijOn (fun γ : c ⟶ c => Groupoid.inv p ≫ γ ≫ p) (S.arrows c c) (S.arrows d d) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (Sn : S.IsNormal) {c d : C} (p : c ⟶ d)
Goal: Set.BijOn
  (fun γ => CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv p) (CategoryTheory.CategoryStruct.comp γ p))
  (S.arrows c c) (S.arrows d d)
-- CategoryTheory.Subgroupoid.top_isNormal
theorem top_isNormal : IsNormal (⊤ : Subgroupoid C) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C]
Goal: ⊤.IsNormal
-- CategoryTheory.Subgroupoid.sInf_isNormal
theorem sInf_isNormal (s : Set <| Subgroupoid C) (sn : ∀ S ∈ s, IsNormal S) : IsNormal (sInf s) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (s : Set (CategoryTheory.Subgroupoid C)) (sn : ∀ S ∈ s, S.IsNormal)
Goal: (sInf s).IsNormal
-- CategoryTheory.Subgroupoid.discrete_isNormal
theorem discrete_isNormal : (@discrete C _).IsNormal 
Arguments: {C : Type u} [CategoryTheory.Groupoid C]
Goal: CategoryTheory.Subgroupoid.discrete.IsNormal
-- CategoryTheory.Subgroupoid.IsNormal.vertexSubgroup
theorem IsNormal.vertexSubgroup (Sn : IsNormal S) (c : C) (cS : c ∈ S.objs) :
    (S.vertexSubgroup cS).Normal 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (Sn : S.IsNormal) (c : C) (cS : c ∈ S.objs)
Goal: (S.vertexSubgroup cS).Normal
-- CategoryTheory.Subgroupoid.subset_generated
theorem subset_generated (c d : C) : X c d ⊆ (generated X).arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (X : (c d : C) → Set (c ⟶ d)) (c d : C)
Goal: X c d ⊆ (CategoryTheory.Subgroupoid.generated X).arrows c d
-- CategoryTheory.Subgroupoid.generated_le_generatedNormal
theorem generated_le_generatedNormal : generated X ≤ generatedNormal X 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (X : (c d : C) → Set (c ⟶ d))
Goal: CategoryTheory.Subgroupoid.generated X ≤ CategoryTheory.Subgroupoid.generatedNormal X
-- CategoryTheory.Subgroupoid.generatedNormal_isNormal
theorem generatedNormal_isNormal : (generatedNormal X).IsNormal 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (X : (c d : C) → Set (c ⟶ d))
Goal: (CategoryTheory.Subgroupoid.generatedNormal X).IsNormal
-- CategoryTheory.Subgroupoid.IsNormal.generatedNormal_le
theorem IsNormal.generatedNormal_le {S : Subgroupoid C} (Sn : S.IsNormal) :
    generatedNormal X ≤ S ↔ ∀ c d, X c d ⊆ S.arrows c d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (X : (c d : C) → Set (c ⟶ d)) {S : CategoryTheory.Subgroupoid C} (Sn : S.IsNormal)
Goal: CategoryTheory.Subgroupoid.generatedNormal X ≤ S ↔ ∀ (c d : C), X c d ⊆ S.arrows c d
-- CategoryTheory.Subgroupoid.comap_mono
theorem comap_mono (S T : Subgroupoid D) : S ≤ T → comap φ S ≤ comap φ T 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (S T : CategoryTheory.Subgroupoid D)
Goal: S ≤ T → CategoryTheory.Subgroupoid.comap φ S ≤ CategoryTheory.Subgroupoid.comap φ T
-- CategoryTheory.Subgroupoid.isNormal_comap
theorem isNormal_comap {S : Subgroupoid D} (Sn : IsNormal S) : IsNormal (comap φ S) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) {S : CategoryTheory.Subgroupoid D} (Sn : S.IsNormal)
Goal: (CategoryTheory.Subgroupoid.comap φ S).IsNormal
-- CategoryTheory.Subgroupoid.comap_comp
@[simp]
theorem comap_comp {E : Type*} [Groupoid E] (ψ : D ⥤ E) : comap (φ ⋙ ψ) = comap φ ∘ comap ψ 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) {E : Type u_2} [CategoryTheory.Groupoid E] (ψ : CategoryTheory.Functor D E)
Goal: CategoryTheory.Subgroupoid.comap (φ.comp ψ) = CategoryTheory.Subgroupoid.comap φ ∘ CategoryTheory.Subgroupoid.comap ψ
-- CategoryTheory.Subgroupoid.mem_ker_iff
theorem mem_ker_iff {c d : C} (f : c ⟶ d) :
    f ∈ (ker φ).arrows c d ↔ ∃ h : φ.obj c = φ.obj d, φ.map f = eqToHom h 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) {c d : C} (f : c ⟶ d)
Goal: f ∈ (CategoryTheory.Subgroupoid.ker φ).arrows c d ↔ ∃ (h : φ.obj c = φ.obj d), φ.map f = CategoryTheory.eqToHom h
-- CategoryTheory.Subgroupoid.ker_isNormal
theorem ker_isNormal : (ker φ).IsNormal 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D)
Goal: (CategoryTheory.Subgroupoid.ker φ).IsNormal
-- CategoryTheory.Subgroupoid.ker_comp
@[simp]
theorem ker_comp {E : Type*} [Groupoid E] (ψ : D ⥤ E) : ker (φ ⋙ ψ) = comap φ (ker ψ) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) {E : Type u_2} [CategoryTheory.Groupoid E] (ψ : CategoryTheory.Functor D E)
Goal: CategoryTheory.Subgroupoid.ker (φ.comp ψ) = CategoryTheory.Subgroupoid.comap φ (CategoryTheory.Subgroupoid.ker ψ)
-- CategoryTheory.Subgroupoid.Map.arrows_iff
theorem Map.arrows_iff (hφ : Function.Injective φ.obj) (S : Subgroupoid C) {c d : D} (f : c ⟶ d) :
    Map.Arrows φ hφ S c d f ↔
      ∃ (a b : C) (g : a ⟶ b) (ha : φ.obj a = c) (hb : φ.obj b = d) (_hg : g ∈ S.arrows a b),
        f = eqToHom ha.symm ≫ φ.map g ≫ eqToHom hb 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (S : CategoryTheory.Subgroupoid C) {c d : D} (f : c ⟶ d)
Goal: CategoryTheory.Subgroupoid.Map.Arrows φ hφ S c d f ↔
  ∃ a b g,
    ∃ (ha : φ.obj a = c) (hb : φ.obj b = d) (_ : g ∈ S.arrows a b),
      f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
          (CategoryTheory.CategoryStruct.comp (φ.map g) (CategoryTheory.eqToHom hb))
-- CategoryTheory.Subgroupoid.mem_map_iff
theorem mem_map_iff (hφ : Function.Injective φ.obj) (S : Subgroupoid C) {c d : D} (f : c ⟶ d) :
    f ∈ (map φ hφ S).arrows c d ↔
      ∃ (a b : C) (g : a ⟶ b) (ha : φ.obj a = c) (hb : φ.obj b = d) (_hg : g ∈ S.arrows a b),
        f = eqToHom ha.symm ≫ φ.map g ≫ eqToHom hb 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (S : CategoryTheory.Subgroupoid C) {c d : D} (f : c ⟶ d)
Goal: f ∈ (CategoryTheory.Subgroupoid.map φ hφ S).arrows c d ↔
  ∃ a b g,
    ∃ (ha : φ.obj a = c) (hb : φ.obj b = d) (_ : g ∈ S.arrows a b),
      f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
          (CategoryTheory.CategoryStruct.comp (φ.map g) (CategoryTheory.eqToHom hb))
-- CategoryTheory.Subgroupoid.galoisConnection_map_comap
theorem galoisConnection_map_comap (hφ : Function.Injective φ.obj) :
    GaloisConnection (map φ hφ) (comap φ) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj)
Goal: GaloisConnection (CategoryTheory.Subgroupoid.map φ hφ) (CategoryTheory.Subgroupoid.comap φ)
-- CategoryTheory.Subgroupoid.map_mono
theorem map_mono (hφ : Function.Injective φ.obj) (S T : Subgroupoid C) :
    S ≤ T → map φ hφ S ≤ map φ hφ T 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (S T : CategoryTheory.Subgroupoid C)
Goal: S ≤ T → CategoryTheory.Subgroupoid.map φ hφ S ≤ CategoryTheory.Subgroupoid.map φ hφ T
-- CategoryTheory.Subgroupoid.le_comap_map
theorem le_comap_map (hφ : Function.Injective φ.obj) (S : Subgroupoid C) :
    S ≤ comap φ (map φ hφ S) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (S : CategoryTheory.Subgroupoid C)
Goal: S ≤ CategoryTheory.Subgroupoid.comap φ (CategoryTheory.Subgroupoid.map φ hφ S)
-- CategoryTheory.Subgroupoid.map_comap_le
theorem map_comap_le (hφ : Function.Injective φ.obj) (T : Subgroupoid D) :
    map φ hφ (comap φ T) ≤ T 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (T : CategoryTheory.Subgroupoid D)
Goal: CategoryTheory.Subgroupoid.map φ hφ (CategoryTheory.Subgroupoid.comap φ T) ≤ T
-- CategoryTheory.Subgroupoid.map_le_iff_le_comap
theorem map_le_iff_le_comap (hφ : Function.Injective φ.obj) (S : Subgroupoid C)
    (T : Subgroupoid D) : map φ hφ S ≤ T ↔ S ≤ comap φ T 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (S : CategoryTheory.Subgroupoid C) (T : CategoryTheory.Subgroupoid D)
Goal: CategoryTheory.Subgroupoid.map φ hφ S ≤ T ↔ S ≤ CategoryTheory.Subgroupoid.comap φ T
-- CategoryTheory.Subgroupoid.mem_map_objs_iff
theorem mem_map_objs_iff (hφ : Function.Injective φ.obj) (d : D) :
    d ∈ (map φ hφ S).objs ↔ ∃ c ∈ S.objs, φ.obj c = d 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) {D : Type u_1} [CategoryTheory.Groupoid D] (φ : CategoryTheory.Functor C D) (hφ : Function.Injective φ.obj) (d : D)
Goal: d ∈ (CategoryTheory.Subgroupoid.map φ hφ S).objs ↔ ∃ c ∈ S.objs, φ.obj c = d