File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

full_name: CategoryTheory.Subgroupoid
code: /-- A sugroupoid of `C` consists of a choice of arrows for each pair of vertices, closed
under composition and inverses.
-/
@[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
goal: Type (max u u_1)

full_name: CategoryTheory.Subgroupoid.mul
code: /-- A sugroupoid of `C` consists of a choice of arrows for each pair of vertices, closed
under composition and inverses.
-/
@[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
goal: p ∈ self.arrows c d → ∀ {q : d ⟶ e}, q ∈ self.arrows d e → CategoryTheory.CategoryStruct.comp p q ∈ self.arrows c e

full_name: CategoryTheory.Subgroupoid.arrows
code: /-- A sugroupoid of `C` consists of a choice of arrows for each pair of vertices, closed
under composition and inverses.
-/
@[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
goal: Set (c ⟶ d)

full_name: CategoryTheory.Subgroupoid.inv
code: /-- A sugroupoid of `C` consists of a choice of arrows for each pair of vertices, closed
under composition and inverses.
-/
@[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
goal: p ∈ self.arrows c d → CategoryTheory.Groupoid.inv p ∈ self.arrows d c

full_name: CategoryTheory.Subgroupoid.inv_mem_iff
code: theorem inv_mem_iff {c d : C} (f : c ⟶ d) :
    Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d 
goal: CategoryTheory.Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d

full_name: CategoryTheory.Subgroupoid.mul_mem_cancel_left
code: 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 
goal: CategoryTheory.CategoryStruct.comp f g ∈ S.arrows c e ↔ g ∈ S.arrows d e

full_name: CategoryTheory.Subgroupoid.mul_mem_cancel_right
code: 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 
goal: CategoryTheory.CategoryStruct.comp f g ∈ S.arrows c e ↔ f ∈ S.arrows c d

full_name: CategoryTheory.Subgroupoid.objs
code: /-- The vertices of `C` on which `S` has non-trivial isotropy -/
def objs : Set C 
goal: Set C

full_name: CategoryTheory.Subgroupoid.mem_objs_of_src
code: theorem mem_objs_of_src {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : c ∈ S.objs 
goal: c ∈ S.objs

full_name: CategoryTheory.Subgroupoid.mem_objs_of_tgt
code: theorem mem_objs_of_tgt {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : d ∈ S.objs 
goal: d ∈ S.objs

full_name: CategoryTheory.Subgroupoid.id_mem_of_nonempty_isotropy
code: theorem id_mem_of_nonempty_isotropy (c : C) : c ∈ objs S → 𝟙 c ∈ S.arrows c c 
goal: c ∈ S.objs → CategoryTheory.CategoryStruct.id c ∈ S.arrows c c

full_name: CategoryTheory.Subgroupoid.id_mem_of_src
code: theorem id_mem_of_src {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : 𝟙 c ∈ S.arrows c c 
goal: CategoryTheory.CategoryStruct.id c ∈ S.arrows c c

full_name: CategoryTheory.Subgroupoid.id_mem_of_tgt
code: theorem id_mem_of_tgt {c d : C} {f : c ⟶ d} (h : f ∈ S.arrows c d) : 𝟙 d ∈ S.arrows d d 
goal: CategoryTheory.CategoryStruct.id d ∈ S.arrows d d

full_name: CategoryTheory.Subgroupoid.asWideQuiver
code: /-- A subgroupoid seen as a quiver on vertex set `C` -/
def asWideQuiver : Quiver C 
goal: Quiver C

full_name: CategoryTheory.Subgroupoid.coe
code: /-- The coercion of a subgroupoid as a groupoid -/
@[simps comp_coe, simps (config := .lemmasOnly) inv_coe]
instance coe : Groupoid S.objs 
goal: CategoryTheory.Groupoid ↑S.objs

full_name: CategoryTheory.Subgroupoid.coe_comp_coe
code: /-- The coercion of a subgroupoid as a groupoid -/
@[simps comp_coe, simps (config := .lemmasOnly) inv_coe]
instance coe : Groupoid S.objs 
goal: ∀ {X Y Z : ↑S.objs} (p : X ⟶ Y) (q : Y ⟶ Z),
  ↑(CategoryTheory.CategoryStruct.comp p q) = CategoryTheory.CategoryStruct.comp ↑p ↑q

full_name: CategoryTheory.Subgroupoid.coe_inv_coe
code: /-- The coercion of a subgroupoid as a groupoid -/
@[simps comp_coe, simps (config := .lemmasOnly) inv_coe]
instance coe : Groupoid S.objs 
goal: ∀ {X Y : ↑S.objs} (p : X ⟶ Y), ↑(CategoryTheory.Groupoid.inv p) = CategoryTheory.Groupoid.inv ↑p

full_name: CategoryTheory.Subgroupoid.coe_inv_coe'
code: @[simp]
theorem coe_inv_coe' {c d : S.objs} (p : c ⟶ d) :
    (CategoryTheory.inv p).val = CategoryTheory.inv p.val 
goal: ↑(CategoryTheory.inv p) = CategoryTheory.inv ↑p

full_name: CategoryTheory.Subgroupoid.hom
code: /-- The embedding of the coerced subgroupoid to its parent-/
def hom : S.objs ⥤ C 
goal: CategoryTheory.Functor (↑S.objs) C

full_name: CategoryTheory.Subgroupoid.hom.inj_on_objects
code: theorem hom.inj_on_objects : Function.Injective (hom S).obj 
goal: Function.Injective S.hom.obj

full_name: CategoryTheory.Subgroupoid.hom.faithful
code: theorem hom.faithful : ∀ c d, Function.Injective fun f : c ⟶ d => (hom S).map f 
goal: Function.Injective fun f => S.hom.map f

full_name: CategoryTheory.Subgroupoid.vertexSubgroup
code: /-- The subgroup of the vertex group at `c` given by the subgroupoid -/
def vertexSubgroup {c : C} (hc : c ∈ S.objs) : Subgroup (c ⟶ c) 
goal: Subgroup (c ⟶ c)

full_name: CategoryTheory.Subgroupoid.toSet
code: /-- The set of all arrows of a subgroupoid, as a set in `Σ c d : C, c ⟶ d`. -/
@[coe] def toSet (S : Subgroupoid C) : Set (Σ c d : C, c ⟶ d) 
goal: Set ((c : C) × (d : C) × (c ⟶ d))

full_name: CategoryTheory.Subgroupoid.instSetLikeSigmaHom
code: instance : SetLike (Subgroupoid C) (Σ c d : C, c ⟶ d) 
goal: SetLike (CategoryTheory.Subgroupoid C) ((c : C) × (d : C) × (c ⟶ d))

full_name: CategoryTheory.Subgroupoid.mem_iff
code: theorem mem_iff (S : Subgroupoid C) (F : Σ c d, c ⟶ d) : F ∈ S ↔ F.2.2 ∈ S.arrows F.1 F.2.1 
goal: F ∈ S ↔ F.snd.snd ∈ S.arrows F.fst F.snd.fst

full_name: CategoryTheory.Subgroupoid.le_iff
code: theorem le_iff (S T : Subgroupoid C) : S ≤ T ↔ ∀ {c d}, S.arrows c d ⊆ T.arrows c d 
goal: S ≤ T ↔ ∀ {c d : C}, S.arrows c d ⊆ T.arrows c d

full_name: CategoryTheory.Subgroupoid.instTop
code: instance : Top (Subgroupoid C) 
goal: Top (CategoryTheory.Subgroupoid C)

full_name: CategoryTheory.Subgroupoid.mem_top
code: theorem mem_top {c d : C} (f : c ⟶ d) : f ∈ (⊤ : Subgroupoid C).arrows c d 
goal: f ∈ ⊤.arrows c d

full_name: CategoryTheory.Subgroupoid.mem_top_objs
code: theorem mem_top_objs (c : C) : c ∈ (⊤ : Subgroupoid C).objs 
goal: c ∈ ⊤.objs

full_name: CategoryTheory.Subgroupoid.instBot
code: instance : Bot (Subgroupoid C) 
goal: Bot (CategoryTheory.Subgroupoid C)

full_name: CategoryTheory.Subgroupoid.instInhabited
code: instance : Inhabited (Subgroupoid C) 
goal: Inhabited (CategoryTheory.Subgroupoid C)

full_name: CategoryTheory.Subgroupoid.instInf
code: instance : Inf (Subgroupoid C) 
goal: Inf (CategoryTheory.Subgroupoid C)

full_name: CategoryTheory.Subgroupoid.instInfSet
code: instance : InfSet (Subgroupoid C) 
goal: InfSet (CategoryTheory.Subgroupoid C)

full_name: CategoryTheory.Subgroupoid.mem_sInf_arrows
code: 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 
goal: p ∈ (sInf s).arrows c d ↔ ∀ S ∈ s, p ∈ S.arrows c d

full_name: CategoryTheory.Subgroupoid.mem_sInf
code: theorem mem_sInf {s : Set (Subgroupoid C)} {p : Σ c d : C, c ⟶ d} :
    p ∈ sInf s ↔ ∀ S ∈ s, p ∈ S 
goal: p ∈ sInf s ↔ ∀ S ∈ s, p ∈ S

full_name: CategoryTheory.Subgroupoid.instCompleteLattice
code: instance : CompleteLattice (Subgroupoid C) 
goal: CompleteLattice (CategoryTheory.Subgroupoid C)

full_name: CategoryTheory.Subgroupoid.le_objs
code: theorem le_objs {S T : Subgroupoid C} (h : S ≤ T) : S.objs ⊆ T.objs 
goal: S.objs ⊆ T.objs

full_name: CategoryTheory.Subgroupoid.inclusion
code: /-- The functor associated to the embedding of subgroupoids -/
def inclusion {S T : Subgroupoid C} (h : S ≤ T) : S.objs ⥤ T.objs 
goal: CategoryTheory.Functor ↑S.objs ↑T.objs

full_name: CategoryTheory.Subgroupoid.inclusion_inj_on_objects
code: theorem inclusion_inj_on_objects {S T : Subgroupoid C} (h : S ≤ T) :
    Function.Injective (inclusion h).obj 
goal: Function.Injective (CategoryTheory.Subgroupoid.inclusion h).obj

full_name: CategoryTheory.Subgroupoid.inclusion_faithful
code: theorem inclusion_faithful {S T : Subgroupoid C} (h : S ≤ T) (s t : S.objs) :
    Function.Injective fun f : s ⟶ t => (inclusion h).map f 
goal: Function.Injective fun f => (CategoryTheory.Subgroupoid.inclusion h).map f

full_name: CategoryTheory.Subgroupoid.inclusion_refl
code: theorem inclusion_refl {S : Subgroupoid C} : inclusion (le_refl S) = 𝟭 S.objs 
goal: CategoryTheory.Subgroupoid.inclusion ⋯ = CategoryTheory.Functor.id ↑S.objs

full_name: CategoryTheory.Subgroupoid.inclusion_trans
code: theorem inclusion_trans {R S T : Subgroupoid C} (k : R ≤ S) (h : S ≤ T) :
    inclusion (k.trans h) = inclusion k ⋙ inclusion h 
goal: CategoryTheory.Subgroupoid.inclusion ⋯ =
  (CategoryTheory.Subgroupoid.inclusion k).comp (CategoryTheory.Subgroupoid.inclusion h)

full_name: CategoryTheory.Subgroupoid.inclusion_comp_embedding
code: theorem inclusion_comp_embedding {S T : Subgroupoid C} (h : S ≤ T) : inclusion h ⋙ T.hom = S.hom 
goal: (CategoryTheory.Subgroupoid.inclusion h).comp T.hom = S.hom

full_name: CategoryTheory.Subgroupoid.Discrete.Arrows.id
code: /-- The family of arrows of the discrete groupoid -/
inductive Discrete.Arrows : ∀ c d : C, (c ⟶ d) → Prop
  | id (c : C) : Discrete.Arrows c c (𝟙 c)
goal: CategoryTheory.Subgroupoid.Discrete.Arrows c c (CategoryTheory.CategoryStruct.id c)

full_name: CategoryTheory.Subgroupoid.Discrete.Arrows
code: /-- The family of arrows of the discrete groupoid -/
inductive Discrete.Arrows : ∀ c d : C, (c ⟶ d) → Prop
  | id (c : C) : Discrete.Arrows c c (𝟙 c)
goal: (c ⟶ d) → Prop

full_name: CategoryTheory.Subgroupoid.discrete
code: /-- The only arrows of the discrete groupoid are the identity arrows. -/
def discrete : Subgroupoid C 
goal: CategoryTheory.Subgroupoid C

full_name: CategoryTheory.Subgroupoid.mem_discrete_iff
code: theorem mem_discrete_iff {c d : C} (f : c ⟶ d) :
    f ∈ discrete.arrows c d ↔ ∃ h : c = d, f = eqToHom h 
goal: f ∈ CategoryTheory.Subgroupoid.discrete.arrows c d ↔ ∃ (h : c = d), f = CategoryTheory.eqToHom h

full_name: CategoryTheory.Subgroupoid.IsWide.wide
code: /-- A subgroupoid is wide if its carrier set is all of `C`-/
structure IsWide : Prop where
  wide : ∀ c, 𝟙 c ∈ S.arrows c c
goal: CategoryTheory.CategoryStruct.id c ∈ S.arrows c c

full_name: CategoryTheory.Subgroupoid.IsWide
code: /-- A subgroupoid is wide if its carrier set is all of `C`-/
structure IsWide : Prop where
  wide : ∀ c, 𝟙 c ∈ S.arrows c c
goal: Prop

full_name: CategoryTheory.Subgroupoid.isWide_iff_objs_eq_univ
code: theorem isWide_iff_objs_eq_univ : S.IsWide ↔ S.objs = Set.univ 
goal: S.IsWide ↔ S.objs = Set.univ

full_name: CategoryTheory.Subgroupoid.IsWide.id_mem
code: theorem IsWide.id_mem {S : Subgroupoid C} (Sw : S.IsWide) (c : C) : 𝟙 c ∈ S.arrows c c 
goal: CategoryTheory.CategoryStruct.id c ∈ S.arrows c c

full_name: CategoryTheory.Subgroupoid.IsWide.eqToHom_mem
code: theorem IsWide.eqToHom_mem {S : Subgroupoid C} (Sw : S.IsWide) {c d : C} (h : c = d) :
    eqToHom h ∈ S.arrows c d 
goal: CategoryTheory.eqToHom h ∈ S.arrows c d

full_name: CategoryTheory.Subgroupoid.IsNormal.conj
code: /-- A subgroupoid is normal if it is wide and satisfies the expected stability under conjugacy. -/
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
goal: γ ∈ S.arrows c c →
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv p) (CategoryTheory.CategoryStruct.comp γ p) ∈
    S.arrows d d

full_name: CategoryTheory.Subgroupoid.IsNormal
code: /-- A subgroupoid is normal if it is wide and satisfies the expected stability under conjugacy. -/
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
goal: Prop

full_name: CategoryTheory.Subgroupoid.IsNormal.conj'
code: 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 
goal: γ ∈ S.arrows c c →
  CategoryTheory.CategoryStruct.comp p (CategoryTheory.CategoryStruct.comp γ (CategoryTheory.Groupoid.inv p)) ∈
    S.arrows d d

full_name: CategoryTheory.Subgroupoid.IsNormal.conjugation_bij
code: 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) 
goal: Set.BijOn
  (fun γ => CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv p) (CategoryTheory.CategoryStruct.comp γ p))
  (S.arrows c c) (S.arrows d d)

full_name: CategoryTheory.Subgroupoid.top_isNormal
code: theorem top_isNormal : IsNormal (⊤ : Subgroupoid C) 
goal: ⊤.IsNormal

full_name: CategoryTheory.Subgroupoid.sInf_isNormal
code: theorem sInf_isNormal (s : Set <| Subgroupoid C) (sn : ∀ S ∈ s, IsNormal S) : IsNormal (sInf s) 
goal: (sInf s).IsNormal

full_name: CategoryTheory.Subgroupoid.discrete_isNormal
code: theorem discrete_isNormal : (@discrete C _).IsNormal 
goal: CategoryTheory.Subgroupoid.discrete.IsNormal

full_name: CategoryTheory.Subgroupoid.IsNormal.vertexSubgroup
code: theorem IsNormal.vertexSubgroup (Sn : IsNormal S) (c : C) (cS : c ∈ S.objs) :
    (S.vertexSubgroup cS).Normal 
goal: (S.vertexSubgroup cS).Normal

full_name: CategoryTheory.Subgroupoid.generated
code: /-- The subgropoid generated by the set of arrows `X` -/
def generated : Subgroupoid C 
goal: CategoryTheory.Subgroupoid C

full_name: CategoryTheory.Subgroupoid.subset_generated
code: theorem subset_generated (c d : C) : X c d ⊆ (generated X).arrows c d 
goal: X c d ⊆ (CategoryTheory.Subgroupoid.generated X).arrows c d

full_name: CategoryTheory.Subgroupoid.generatedNormal
code: /-- The normal sugroupoid generated by the set of arrows `X` -/
def generatedNormal : Subgroupoid C 
goal: CategoryTheory.Subgroupoid C

full_name: CategoryTheory.Subgroupoid.generated_le_generatedNormal
code: theorem generated_le_generatedNormal : generated X ≤ generatedNormal X 
goal: CategoryTheory.Subgroupoid.generated X ≤ CategoryTheory.Subgroupoid.generatedNormal X

full_name: CategoryTheory.Subgroupoid.generatedNormal_isNormal
code: theorem generatedNormal_isNormal : (generatedNormal X).IsNormal 
goal: (CategoryTheory.Subgroupoid.generatedNormal X).IsNormal

full_name: CategoryTheory.Subgroupoid.IsNormal.generatedNormal_le
code: theorem IsNormal.generatedNormal_le {S : Subgroupoid C} (Sn : S.IsNormal) :
    generatedNormal X ≤ S ↔ ∀ c d, X c d ⊆ S.arrows c d 
goal: CategoryTheory.Subgroupoid.generatedNormal X ≤ S ↔ ∀ (c d : C), X c d ⊆ S.arrows c d

full_name: CategoryTheory.Subgroupoid.comap
code: /-- A functor between groupoid defines a map of subgroupoids in the reverse direction
by taking preimages.
 -/
def comap (S : Subgroupoid D) : Subgroupoid C 
goal: CategoryTheory.Subgroupoid C

full_name: CategoryTheory.Subgroupoid.comap_mono
code: theorem comap_mono (S T : Subgroupoid D) : S ≤ T → comap φ S ≤ comap φ T 
goal: S ≤ T → CategoryTheory.Subgroupoid.comap φ S ≤ CategoryTheory.Subgroupoid.comap φ T

full_name: CategoryTheory.Subgroupoid.isNormal_comap
code: theorem isNormal_comap {S : Subgroupoid D} (Sn : IsNormal S) : IsNormal (comap φ S) 
goal: (CategoryTheory.Subgroupoid.comap φ S).IsNormal

full_name: CategoryTheory.Subgroupoid.comap_comp
code: @[simp]
theorem comap_comp {E : Type*} [Groupoid E] (ψ : D ⥤ E) : comap (φ ⋙ ψ) = comap φ ∘ comap ψ 
goal: CategoryTheory.Subgroupoid.comap (φ.comp ψ) = CategoryTheory.Subgroupoid.comap φ ∘ CategoryTheory.Subgroupoid.comap ψ

full_name: CategoryTheory.Subgroupoid.ker
code: /-- The kernel of a functor between subgroupoid is the preimage. -/
def ker : Subgroupoid C 
goal: CategoryTheory.Subgroupoid C

full_name: CategoryTheory.Subgroupoid.mem_ker_iff
code: theorem mem_ker_iff {c d : C} (f : c ⟶ d) :
    f ∈ (ker φ).arrows c d ↔ ∃ h : φ.obj c = φ.obj d, φ.map f = eqToHom h 
goal: f ∈ (CategoryTheory.Subgroupoid.ker φ).arrows c d ↔ ∃ (h : φ.obj c = φ.obj d), φ.map f = CategoryTheory.eqToHom h

full_name: CategoryTheory.Subgroupoid.ker_isNormal
code: theorem ker_isNormal : (ker φ).IsNormal 
goal: (CategoryTheory.Subgroupoid.ker φ).IsNormal

full_name: CategoryTheory.Subgroupoid.ker_comp
code: @[simp]
theorem ker_comp {E : Type*} [Groupoid E] (ψ : D ⥤ E) : ker (φ ⋙ ψ) = comap φ (ker ψ) 
goal: CategoryTheory.Subgroupoid.ker (φ.comp ψ) = CategoryTheory.Subgroupoid.comap φ (CategoryTheory.Subgroupoid.ker ψ)

full_name: CategoryTheory.Subgroupoid.Map.Arrows.im
code: /-- The family of arrows of the image of a subgroupoid under a functor injective on objects -/
inductive Map.Arrows (hφ : Function.Injective φ.obj) (S : Subgroupoid C) : ∀ c d : D, (c ⟶ d) → Prop
  | im {c d : C} (f : c ⟶ d) (hf : f ∈ S.arrows c d) : Map.Arrows hφ S (φ.obj c) (φ.obj d) (φ.map f)
goal: CategoryTheory.Subgroupoid.Map.Arrows φ hφ S (φ.obj c) (φ.obj d) (φ.map f)

full_name: CategoryTheory.Subgroupoid.Map.Arrows
code: /-- The family of arrows of the image of a subgroupoid under a functor injective on objects -/
inductive Map.Arrows (hφ : Function.Injective φ.obj) (S : Subgroupoid C) : ∀ c d : D, (c ⟶ d) → Prop
  | im {c d : C} (f : c ⟶ d) (hf : f ∈ S.arrows c d) : Map.Arrows hφ S (φ.obj c) (φ.obj d) (φ.map f)
goal: (c ⟶ d) → Prop

full_name: CategoryTheory.Subgroupoid.Map.arrows_iff
code: 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 
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))

full_name: CategoryTheory.Subgroupoid.map
code: /-- The "forward" image of a subgroupoid under a functor injective on objects -/
def map (hφ : Function.Injective φ.obj) (S : Subgroupoid C) : Subgroupoid D 
goal: CategoryTheory.Subgroupoid D

full_name: CategoryTheory.Subgroupoid.mem_map_iff
code: 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 
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))

full_name: CategoryTheory.Subgroupoid.galoisConnection_map_comap
code: theorem galoisConnection_map_comap (hφ : Function.Injective φ.obj) :
    GaloisConnection (map φ hφ) (comap φ) 
goal: GaloisConnection (CategoryTheory.Subgroupoid.map φ hφ) (CategoryTheory.Subgroupoid.comap φ)

full_name: CategoryTheory.Subgroupoid.map_mono
code: theorem map_mono (hφ : Function.Injective φ.obj) (S T : Subgroupoid C) :
    S ≤ T → map φ hφ S ≤ map φ hφ T 
goal: S ≤ T → CategoryTheory.Subgroupoid.map φ hφ S ≤ CategoryTheory.Subgroupoid.map φ hφ T

full_name: CategoryTheory.Subgroupoid.le_comap_map
code: theorem le_comap_map (hφ : Function.Injective φ.obj) (S : Subgroupoid C) :
    S ≤ comap φ (map φ hφ S) 
goal: S ≤ CategoryTheory.Subgroupoid.comap φ (CategoryTheory.Subgroupoid.map φ hφ S)

full_name: CategoryTheory.Subgroupoid.map_comap_le
code: theorem map_comap_le (hφ : Function.Injective φ.obj) (T : Subgroupoid D) :
    map φ hφ (comap φ T) ≤ T 
goal: CategoryTheory.Subgroupoid.map φ hφ (CategoryTheory.Subgroupoid.comap φ T) ≤ T

full_name: CategoryTheory.Subgroupoid.map_le_iff_le_comap
code: theorem map_le_iff_le_comap (hφ : Function.Injective φ.obj) (S : Subgroupoid C)
    (T : Subgroupoid D) : map φ hφ S ≤ T ↔ S ≤ comap φ T 
goal: CategoryTheory.Subgroupoid.map φ hφ S ≤ T ↔ S ≤ CategoryTheory.Subgroupoid.comap φ T

full_name: CategoryTheory.Subgroupoid.mem_map_objs_iff
code: theorem mem_map_objs_iff (hφ : Function.Injective φ.obj) (d : D) :
    d ∈ (map φ hφ S).objs ↔ ∃ c ∈ S.objs, φ.obj c = d 
goal: d ∈ (CategoryTheory.Subgroupoid.map φ hφ S).objs ↔ ∃ c ∈ S.objs, φ.obj c = d

full_name: CategoryTheory.Subgroupoid.map_objs_eq
code: @[simp]
theorem map_objs_eq (hφ : Function.Injective φ.obj) : (map φ hφ S).objs = φ.obj '' S.objs 
goal: (CategoryTheory.Subgroupoid.map φ hφ S).objs = φ.obj '' S.objs

full_name: CategoryTheory.Subgroupoid.im
code: /-- The image of a functor injective on objects -/
def im (hφ : Function.Injective φ.obj) 
goal: CategoryTheory.Subgroupoid D

full_name: CategoryTheory.Subgroupoid.mem_im_iff
code: theorem mem_im_iff (hφ : Function.Injective φ.obj) {c d : D} (f : c ⟶ d) :
    f ∈ (im φ hφ).arrows c d ↔
      ∃ (a b : C) (g : a ⟶ b) (ha : φ.obj a = c) (hb : φ.obj b = d),
        f = eqToHom ha.symm ≫ φ.map g ≫ eqToHom hb 
goal: f ∈ (CategoryTheory.Subgroupoid.im φ hφ).arrows c d ↔
  ∃ a b g,
    ∃ (ha : φ.obj a = c) (hb : φ.obj b = d),
      f =
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
          (CategoryTheory.CategoryStruct.comp (φ.map g) (CategoryTheory.eqToHom hb))

full_name: CategoryTheory.Subgroupoid.mem_im_objs_iff
code: theorem mem_im_objs_iff (hφ : Function.Injective φ.obj) (d : D) :
    d ∈ (im φ hφ).objs ↔ ∃ c : C, φ.obj c = d 
goal: d ∈ (CategoryTheory.Subgroupoid.im φ hφ).objs ↔ ∃ c, φ.obj c = d

full_name: CategoryTheory.Subgroupoid.obj_surjective_of_im_eq_top
code: theorem obj_surjective_of_im_eq_top (hφ : Function.Injective φ.obj) (hφ' : im φ hφ = ⊤) :
    Function.Surjective φ.obj 
goal: Function.Surjective φ.obj

full_name: CategoryTheory.Subgroupoid.isNormal_map
code: theorem isNormal_map (hφ : Function.Injective φ.obj) (hφ' : im φ hφ = ⊤) (Sn : S.IsNormal) :
    (map φ hφ S).IsNormal 
goal: (CategoryTheory.Subgroupoid.map φ hφ S).IsNormal

full_name: CategoryTheory.Subgroupoid.IsThin
code: /-- A subgroupoid is thin (`CategoryTheory.Subgroupoid.IsThin`) if it has at most one arrow between
any two vertices. -/
abbrev IsThin 
goal: Prop

full_name: CategoryTheory.Subgroupoid.isThin_iff
code: nonrec theorem isThin_iff : S.IsThin ↔ ∀ c : S.objs, Subsingleton (S.arrows c c) 
goal: S.IsThin ↔ ∀ (c : ↑S.objs), Subsingleton ↑(S.arrows ↑c ↑c)

full_name: CategoryTheory.Subgroupoid.IsTotallyDisconnected
code: /-- A subgroupoid `IsTotallyDisconnected` if it has only isotropy arrows. -/
nonrec abbrev IsTotallyDisconnected 
goal: Prop

full_name: CategoryTheory.Subgroupoid.isTotallyDisconnected_iff
code: theorem isTotallyDisconnected_iff :
    S.IsTotallyDisconnected ↔ ∀ c d, (S.arrows c d).Nonempty → c = d 
goal: S.IsTotallyDisconnected ↔ ∀ (c d : C), (S.arrows c d).Nonempty → c = d

full_name: CategoryTheory.Subgroupoid.disconnect
code: /-- The isotropy subgroupoid of `S` -/
def disconnect : Subgroupoid C 
goal: CategoryTheory.Subgroupoid C

full_name: CategoryTheory.Subgroupoid.disconnect_le
code: theorem disconnect_le : S.disconnect ≤ S 
goal: S.disconnect ≤ S

full_name: CategoryTheory.Subgroupoid.disconnect_normal
code: theorem disconnect_normal (Sn : S.IsNormal) : S.disconnect.IsNormal 
goal: S.disconnect.IsNormal

full_name: CategoryTheory.Subgroupoid.mem_disconnect_objs_iff
code: @[simp]
theorem mem_disconnect_objs_iff {c : C} : c ∈ S.disconnect.objs ↔ c ∈ S.objs 
goal: c ∈ S.disconnect.objs ↔ c ∈ S.objs

full_name: CategoryTheory.Subgroupoid.disconnect_objs
code: theorem disconnect_objs : S.disconnect.objs = S.objs 
goal: S.disconnect.objs = S.objs

full_name: CategoryTheory.Subgroupoid.disconnect_isTotallyDisconnected
code: theorem disconnect_isTotallyDisconnected : S.disconnect.IsTotallyDisconnected 
goal: S.disconnect.IsTotallyDisconnected

full_name: CategoryTheory.Subgroupoid.full
code: /-- The full subgroupoid on a set `D : Set C` -/
def full : Subgroupoid C 
goal: CategoryTheory.Subgroupoid C

full_name: CategoryTheory.Subgroupoid.full_objs
code: theorem full_objs : (full D).objs = D 
goal: (CategoryTheory.Subgroupoid.full D).objs = D

full_name: CategoryTheory.Subgroupoid.mem_full_iff
code: @[simp]
theorem mem_full_iff {c d : C} {f : c ⟶ d} : f ∈ (full D).arrows c d ↔ c ∈ D ∧ d ∈ D 
goal: f ∈ (CategoryTheory.Subgroupoid.full D).arrows c d ↔ c ∈ D ∧ d ∈ D

full_name: CategoryTheory.Subgroupoid.mem_full_objs_iff
code: @[simp]
theorem mem_full_objs_iff {c : C} : c ∈ (full D).objs ↔ c ∈ D 
goal: c ∈ (CategoryTheory.Subgroupoid.full D).objs ↔ c ∈ D

full_name: CategoryTheory.Subgroupoid.full_empty
code: @[simp]
theorem full_empty : full ∅ = (⊥ : Subgroupoid C) 
goal: CategoryTheory.Subgroupoid.full ∅ = ⊥

full_name: CategoryTheory.Subgroupoid.full_univ
code: @[simp]
theorem full_univ : full Set.univ = (⊤ : Subgroupoid C) 
goal: CategoryTheory.Subgroupoid.full Set.univ = ⊤

full_name: CategoryTheory.Subgroupoid.full_mono
code: theorem full_mono {D E : Set C} (h : D ≤ E) : full D ≤ full E 
goal: CategoryTheory.Subgroupoid.full D ≤ CategoryTheory.Subgroupoid.full E

full_name: CategoryTheory.Subgroupoid.full_arrow_eq_iff
code: theorem full_arrow_eq_iff {c d : (full D).objs} {f g : c ⟶ d} :
    f = g ↔ (f.1 : c.val ⟶ d.val) = g.1 
goal: f = g ↔ ↑f = ↑g