File: Mathlib/CategoryTheory/Galois/GaloisObjects.lean

full_name: CategoryTheory.PreGaloisCategory.instPreservesColimitsOfShapeFintypeCatSingleObjInclOfFinite
code: noncomputable instance {G : Type v} [Group G] [Finite G] :
    PreservesColimitsOfShape (SingleObj G) FintypeCat.incl.{w} 
goal: CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.SingleObj G) FintypeCat.incl

full_name: CategoryTheory.PreGaloisCategory.IsGalois.quotientByAutTerminal
code: /-- A connected object `X` of `C` is Galois if the quotient `X / Aut X` is terminal. -/
class IsGalois {C : Type u₁} [Category.{u₂, u₁} C] [GaloisCategory C] (X : C)
    extends IsConnected X : Prop where
  quotientByAutTerminal : Nonempty (IsTerminal <| colimit <| SingleObj.functor <| Aut.toEnd X)
goal: Nonempty
  (CategoryTheory.Limits.IsTerminal
    (CategoryTheory.Limits.colimit (CategoryTheory.SingleObj.functor (CategoryTheory.Aut.toEnd X))))

full_name: CategoryTheory.PreGaloisCategory.IsGalois
code: /-- A connected object `X` of `C` is Galois if the quotient `X / Aut X` is terminal. -/
class IsGalois {C : Type u₁} [Category.{u₂, u₁} C] [GaloisCategory C] (X : C)
    extends IsConnected X : Prop where
  quotientByAutTerminal : Nonempty (IsTerminal <| colimit <| SingleObj.functor <| Aut.toEnd X)
goal: Prop

full_name: CategoryTheory.PreGaloisCategory.autMulFiber
code: /-- The natural action of `Aut X` on `F.obj X`. -/
instance autMulFiber (F : C ⥤ FintypeCat.{w}) (X : C) : MulAction (Aut X) (F.obj X) 
goal: MulAction (CategoryTheory.Aut X) ↑(F.obj X)

full_name: CategoryTheory.PreGaloisCategory.quotientByAutTerminalEquivUniqueQuotient
code: /-- For a connected object `X` of `C`, the quotient `X / Aut X` is terminal if and only if
the quotient `F.obj X / Aut X` has exactly one element. -/
noncomputable def quotientByAutTerminalEquivUniqueQuotient
    (X : C) [IsConnected X] :
    IsTerminal (colimit <| SingleObj.functor <| Aut.toEnd X) ≃
    Unique (MulAction.orbitRel.Quotient (Aut X) (F.obj X)) 
goal: CategoryTheory.Limits.IsTerminal
    (CategoryTheory.Limits.colimit (CategoryTheory.SingleObj.functor (CategoryTheory.Aut.toEnd X))) ≃
  Unique (MulAction.orbitRel.Quotient (CategoryTheory.Aut X) ↑(F.obj X))

full_name: CategoryTheory.PreGaloisCategory.isGalois_iff_aux
code: lemma isGalois_iff_aux (X : C) [IsConnected X] :
    IsGalois X ↔ Nonempty (IsTerminal <| colimit <| SingleObj.functor <| Aut.toEnd X) 
goal: CategoryTheory.PreGaloisCategory.IsGalois X ↔
  Nonempty
    (CategoryTheory.Limits.IsTerminal
      (CategoryTheory.Limits.colimit (CategoryTheory.SingleObj.functor (CategoryTheory.Aut.toEnd X))))

full_name: CategoryTheory.PreGaloisCategory.isGalois_iff_pretransitive
code: /-- Given a fiber functor `F` and a connected object `X` of `C`. Then `X` is Galois if and only if
the natural action of `Aut X` on `F.obj X` is transitive. -/
theorem isGalois_iff_pretransitive (X : C) [IsConnected X] :
    IsGalois X ↔ MulAction.IsPretransitive (Aut X) (F.obj X) 
goal: CategoryTheory.PreGaloisCategory.IsGalois X ↔ MulAction.IsPretransitive (CategoryTheory.Aut X) ↑(F.obj X)

full_name: CategoryTheory.PreGaloisCategory.isTerminalQuotientOfIsGalois
code: /-- If `X` is Galois, the quotient `X / Aut X` is terminal.  -/
noncomputable def isTerminalQuotientOfIsGalois (X : C) [IsGalois X] :
    IsTerminal <| colimit <| SingleObj.functor <| Aut.toEnd X 
goal: CategoryTheory.Limits.IsTerminal
  (CategoryTheory.Limits.colimit (CategoryTheory.SingleObj.functor (CategoryTheory.Aut.toEnd X)))

full_name: CategoryTheory.PreGaloisCategory.isPretransitive_of_isGalois
code: /-- If `X` is Galois, then the action of `Aut X` on `F.obj X` is
transitive for every fiber functor `F`. -/
instance isPretransitive_of_isGalois (X : C) [IsGalois X] :
    MulAction.IsPretransitive (Aut X) (F.obj X) 
goal: MulAction.IsPretransitive (CategoryTheory.Aut X) ↑(F.obj X)

full_name: CategoryTheory.PreGaloisCategory.evaluation_aut_surjective_of_isGalois
code: theorem evaluation_aut_surjective_of_isGalois (A : C) [IsGalois A] (a : F.obj A) :
    Function.Surjective (fun f : Aut A ↦ F.map f.hom a) 
goal: Function.Surjective fun f => F.map f.hom a

full_name: CategoryTheory.PreGaloisCategory.evaluation_aut_bijective_of_isGalois
code: theorem evaluation_aut_bijective_of_isGalois (A : C) [IsGalois A] (a : F.obj A) :
    Function.Bijective (fun f : Aut A ↦ F.map f.hom a) 
goal: Function.Bijective fun f => F.map f.hom a

full_name: CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois
code: /-- For Galois `A` and a point `a` of the fiber of `A`, the evaluation at `A` as an equivalence. -/
noncomputable def evaluationEquivOfIsGalois (A : C) [IsGalois A] (a : F.obj A) : Aut A ≃ F.obj A 
goal: CategoryTheory.Aut A ≃ ↑(F.obj A)

full_name: CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois_apply
code: @[simp]
lemma evaluationEquivOfIsGalois_apply (A : C) [IsGalois A] (a : F.obj A) (φ : Aut A) :
    evaluationEquivOfIsGalois F A a φ = F.map φ.hom a 
goal: (CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois F A a) φ = F.map φ.hom a

full_name: CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois_symm_fiber
code: @[simp]
lemma evaluationEquivOfIsGalois_symm_fiber (A : C) [IsGalois A] (a b : F.obj A) :
    F.map ((evaluationEquivOfIsGalois F A a).symm b).hom a = b 
goal: F.map ((CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois F A a).symm b).hom a = b

full_name: CategoryTheory.PreGaloisCategory.exists_autMap
code: /-- For a morphism from a connected object `A` to a Galois object `B` and an automorphism
of `A`, there exists a unique automorphism of `B` making the canonical diagram commute. -/
lemma exists_autMap {A B : C} (f : A ⟶ B) [IsConnected A] [IsGalois B] (σ : Aut A) :
    ∃! (τ : Aut B), f ≫ τ.hom = σ.hom ≫ f 
goal: ∃! τ, CategoryTheory.CategoryStruct.comp f τ.hom = CategoryTheory.CategoryStruct.comp σ.hom f

full_name: CategoryTheory.PreGaloisCategory.autMap
code: /-- A morphism from a connected object to a Galois object induces a map on automorphism
groups. This is a group homomorphism (see `autMapHom`). -/
noncomputable def autMap {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A) :
    Aut B 
goal: CategoryTheory.Aut B

full_name: CategoryTheory.PreGaloisCategory.comp_autMap
code: @[simp]
lemma comp_autMap {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A) :
    f ≫ (autMap f σ).hom = σ.hom ≫ f 
goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.PreGaloisCategory.autMap f σ).hom =
  CategoryTheory.CategoryStruct.comp σ.hom f

full_name: CategoryTheory.PreGaloisCategory.comp_autMap_apply
code: @[simp]
lemma comp_autMap_apply {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A)
    (a : F.obj A) :
    F.map (autMap f σ).hom (F.map f a) = F.map f (F.map σ.hom a) 
goal: F.map (CategoryTheory.PreGaloisCategory.autMap f σ).hom (F.map f a) = F.map f (F.map σ.hom a)

full_name: CategoryTheory.PreGaloisCategory.autMap_unique
code: /-- `autMap` is uniquely characterized by making the canonical diagram commute. -/
lemma autMap_unique {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ : Aut A)
    (τ : Aut B) (h : f ≫ τ.hom = σ.hom ≫ f) :
    autMap f σ = τ 
goal: CategoryTheory.PreGaloisCategory.autMap f σ = τ

full_name: CategoryTheory.PreGaloisCategory.autMap_id
code: @[simp]
lemma autMap_id {A : C} [IsGalois A] : autMap (𝟙 A) = id 
goal: CategoryTheory.PreGaloisCategory.autMap (CategoryTheory.CategoryStruct.id A) = id

full_name: CategoryTheory.PreGaloisCategory.autMap_comp
code: @[simp]
lemma autMap_comp {X Y Z : C} [IsConnected X] [IsGalois Y] [IsGalois Z] (f : X ⟶ Y)
    (g : Y ⟶ Z) : autMap (f ≫ g) = autMap g ∘ autMap f 
goal: CategoryTheory.PreGaloisCategory.autMap (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.PreGaloisCategory.autMap g ∘ CategoryTheory.PreGaloisCategory.autMap f

full_name: CategoryTheory.PreGaloisCategory.autMap_surjective_of_isGalois
code: /-- `autMap` is surjective, if the source is also Galois. -/
lemma autMap_surjective_of_isGalois {A B : C} [IsGalois A] [IsGalois B] (f : A ⟶ B) :
    Function.Surjective (autMap f) 
goal: Function.Surjective (CategoryTheory.PreGaloisCategory.autMap f)

full_name: CategoryTheory.PreGaloisCategory.autMap_apply_mul
code: @[simp]
lemma autMap_apply_mul {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) (σ τ : Aut A) :
    autMap f (σ * τ) = autMap f σ * autMap f τ 
goal: CategoryTheory.PreGaloisCategory.autMap f (σ * τ) =
  CategoryTheory.PreGaloisCategory.autMap f σ * CategoryTheory.PreGaloisCategory.autMap f τ

full_name: CategoryTheory.PreGaloisCategory.autMapHom_apply
code: /-- `MonoidHom` version of `autMap`. -/
@[simps!]
noncomputable def autMapHom {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) :
     Aut A →* Aut B 
goal: (CategoryTheory.PreGaloisCategory.autMapHom f) σ = CategoryTheory.PreGaloisCategory.autMap f σ

full_name: CategoryTheory.PreGaloisCategory.autMapHom
code: /-- `MonoidHom` version of `autMap`. -/
@[simps!]
noncomputable def autMapHom {A B : C} [IsConnected A] [IsGalois B] (f : A ⟶ B) :
     Aut A →* Aut B 
goal: CategoryTheory.Aut A →* CategoryTheory.Aut B