File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

full_name: Path.Homotopy.reflTransSymmAux
code: /-- Auxiliary function for `reflTransSymm`. -/
def reflTransSymmAux (x : I × I) : ℝ 
goal: ℝ

full_name: Path.Homotopy.continuous_reflTransSymmAux
code: @[continuity]
theorem continuous_reflTransSymmAux : Continuous reflTransSymmAux 
goal: Continuous Path.Homotopy.reflTransSymmAux

full_name: Path.Homotopy.reflTransSymmAux_mem_I
code: theorem reflTransSymmAux_mem_I (x : I × I) : reflTransSymmAux x ∈ I 
goal: Path.Homotopy.reflTransSymmAux x ∈ I

full_name: Path.Homotopy.reflTransSymm
code: /-- For any path `p` from `x₀` to `x₁`, we have a homotopy from the constant path based at `x₀` to
  `p.trans p.symm`. -/
def reflTransSymm (p : Path x₀ x₁) : Homotopy (Path.refl x₀) (p.trans p.symm) 
goal: (Path.refl x₀).Homotopy (p.trans p.symm)

full_name: Path.Homotopy.reflSymmTrans
code: /-- For any path `p` from `x₀` to `x₁`, we have a homotopy from the constant path based at `x₁` to
  `p.symm.trans p`. -/
def reflSymmTrans (p : Path x₀ x₁) : Homotopy (Path.refl x₁) (p.symm.trans p) 
goal: (Path.refl x₁).Homotopy (p.symm.trans p)

full_name: Path.Homotopy.transReflReparamAux
code: /-- Auxiliary function for `trans_refl_reparam`. -/
def transReflReparamAux (t : I) : ℝ 
goal: ℝ

full_name: Path.Homotopy.continuous_transReflReparamAux
code: @[continuity]
theorem continuous_transReflReparamAux : Continuous transReflReparamAux 
goal: Continuous Path.Homotopy.transReflReparamAux

full_name: Path.Homotopy.transReflReparamAux_mem_I
code: theorem transReflReparamAux_mem_I (t : I) : transReflReparamAux t ∈ I 
goal: Path.Homotopy.transReflReparamAux t ∈ I

full_name: Path.Homotopy.transReflReparamAux_zero
code: theorem transReflReparamAux_zero : transReflReparamAux 0 = 0 
goal: Path.Homotopy.transReflReparamAux 0 = 0

full_name: Path.Homotopy.transReflReparamAux_one
code: theorem transReflReparamAux_one : transReflReparamAux 1 = 1 
goal: Path.Homotopy.transReflReparamAux 1 = 1

full_name: Path.Homotopy.trans_refl_reparam
code: theorem trans_refl_reparam (p : Path x₀ x₁) :
    p.trans (Path.refl x₁) =
      p.reparam (fun t => ⟨transReflReparamAux t, transReflReparamAux_mem_I t⟩) (by continuity)
        (Subtype.ext transReflReparamAux_zero) (Subtype.ext transReflReparamAux_one) 
goal: p.trans (Path.refl x₁) = p.reparam (fun t => ⟨Path.Homotopy.transReflReparamAux t, ⋯⟩) ⋯ ⋯ ⋯

full_name: Path.Homotopy.transRefl
code: /-- For any path `p` from `x₀` to `x₁`, we have a homotopy from `p.trans (Path.refl x₁)` to `p`. -/
def transRefl (p : Path x₀ x₁) : Homotopy (p.trans (Path.refl x₁)) p 
goal: (p.trans (Path.refl x₁)).Homotopy p

full_name: Path.Homotopy.reflTrans
code: /-- For any path `p` from `x₀` to `x₁`, we have a homotopy from `(Path.refl x₀).trans p` to `p`. -/
def reflTrans (p : Path x₀ x₁) : Homotopy ((Path.refl x₀).trans p) p 
goal: ((Path.refl x₀).trans p).Homotopy p

full_name: Path.Homotopy.transAssocReparamAux
code: /-- Auxiliary function for `trans_assoc_reparam`. -/
def transAssocReparamAux (t : I) : ℝ 
goal: ℝ

full_name: Path.Homotopy.continuous_transAssocReparamAux
code: @[continuity]
theorem continuous_transAssocReparamAux : Continuous transAssocReparamAux 
goal: Continuous Path.Homotopy.transAssocReparamAux

full_name: Path.Homotopy.transAssocReparamAux_mem_I
code: theorem transAssocReparamAux_mem_I (t : I) : transAssocReparamAux t ∈ I 
goal: Path.Homotopy.transAssocReparamAux t ∈ I

full_name: Path.Homotopy.transAssocReparamAux_zero
code: theorem transAssocReparamAux_zero : transAssocReparamAux 0 = 0 
goal: Path.Homotopy.transAssocReparamAux 0 = 0

full_name: Path.Homotopy.transAssocReparamAux_one
code: theorem transAssocReparamAux_one : transAssocReparamAux 1 = 1 
goal: Path.Homotopy.transAssocReparamAux 1 = 1

full_name: Path.Homotopy.trans_assoc_reparam
code: theorem trans_assoc_reparam {x₀ x₁ x₂ x₃ : X} (p : Path x₀ x₁) (q : Path x₁ x₂) (r : Path x₂ x₃) :
    (p.trans q).trans r =
      (p.trans (q.trans r)).reparam
        (fun t => ⟨transAssocReparamAux t, transAssocReparamAux_mem_I t⟩) (by continuity)
        (Subtype.ext transAssocReparamAux_zero) (Subtype.ext transAssocReparamAux_one) 
goal: (p.trans q).trans r = (p.trans (q.trans r)).reparam (fun t => ⟨Path.Homotopy.transAssocReparamAux t, ⋯⟩) ⋯ ⋯ ⋯

full_name: Path.Homotopy.transAssoc
code: /-- For paths `p q r`, we have a homotopy from `(p.trans q).trans r` to `p.trans (q.trans r)`. -/
def transAssoc {x₀ x₁ x₂ x₃ : X} (p : Path x₀ x₁) (q : Path x₁ x₂) (r : Path x₂ x₃) :
    Homotopy ((p.trans q).trans r) (p.trans (q.trans r)) 
goal: ((p.trans q).trans r).Homotopy (p.trans (q.trans r))

full_name: FundamentalGroupoid.as
code: /-- The fundamental groupoid of a space `X` is defined to be a wrapper around `X`, and we
subsequently put a `CategoryTheory.Groupoid` structure on it. -/
@[ext]
structure FundamentalGroupoid (X : Type u) where
  /-- View a term of `FundamentalGroupoid X` as a term of `X`. -/
  as : X
goal: X

full_name: FundamentalGroupoid
code: /-- The fundamental groupoid of a space `X` is defined to be a wrapper around `X`, and we
subsequently put a `CategoryTheory.Groupoid` structure on it. -/
@[ext]
structure FundamentalGroupoid (X : Type u) where
  /-- View a term of `FundamentalGroupoid X` as a term of `X`. -/
  as : X
goal: Type u

full_name: FundamentalGroupoid.equiv_apply
code: /-- The equivalence between `X` and the underlying type of its fundamental groupoid.
  This is useful for transferring constructions (instances, etc.)
  from `X` to `πₓ X`. -/
@[simps]
def equiv (X : Type*) : FundamentalGroupoid X ≃ X 
goal: (FundamentalGroupoid.equiv X) x = x.as

full_name: FundamentalGroupoid.equiv
code: /-- The equivalence between `X` and the underlying type of its fundamental groupoid.
  This is useful for transferring constructions (instances, etc.)
  from `X` to `πₓ X`. -/
@[simps]
def equiv (X : Type*) : FundamentalGroupoid X ≃ X 
goal: FundamentalGroupoid X ≃ X

full_name: FundamentalGroupoid.equiv_symm_apply_as
code: /-- The equivalence between `X` and the underlying type of its fundamental groupoid.
  This is useful for transferring constructions (instances, etc.)
  from `X` to `πₓ X`. -/
@[simps]
def equiv (X : Type*) : FundamentalGroupoid X ≃ X 
goal: ((FundamentalGroupoid.equiv X).symm x).as = x

full_name: FundamentalGroupoid.isEmpty_iff
code: @[simp]
lemma isEmpty_iff (X : Type*) :
    IsEmpty (FundamentalGroupoid X) ↔ IsEmpty X 
goal: IsEmpty (FundamentalGroupoid X) ↔ IsEmpty X

full_name: FundamentalGroupoid.instIsEmpty
code: instance (X : Type*) [IsEmpty X] :
    IsEmpty (FundamentalGroupoid X) 
goal: IsEmpty (FundamentalGroupoid X)

full_name: FundamentalGroupoid.nonempty_iff
code: @[simp]
lemma nonempty_iff (X : Type*) :
    Nonempty (FundamentalGroupoid X) ↔ Nonempty X 
goal: Nonempty (FundamentalGroupoid X) ↔ Nonempty X

full_name: FundamentalGroupoid.instNonempty
code: instance (X : Type*) [Nonempty X] :
    Nonempty (FundamentalGroupoid X) 
goal: Nonempty (FundamentalGroupoid X)

full_name: FundamentalGroupoid.subsingleton_iff
code: @[simp]
lemma subsingleton_iff (X : Type*) :
    Subsingleton (FundamentalGroupoid X) ↔ Subsingleton X 
goal: Subsingleton (FundamentalGroupoid X) ↔ Subsingleton X

full_name: FundamentalGroupoid.instSubsingleton
code: instance (X : Type*) [Subsingleton X] :
    Subsingleton (FundamentalGroupoid X) 
goal: Subsingleton (FundamentalGroupoid X)

full_name: FundamentalGroupoid.instInhabited
code: instance {X : Type u} [Inhabited X] : Inhabited (FundamentalGroupoid X) 
goal: Inhabited (FundamentalGroupoid X)

full_name: FundamentalGroupoid.instGroupoid
code: instance : CategoryTheory.Groupoid (FundamentalGroupoid X) 
goal: CategoryTheory.Groupoid (FundamentalGroupoid X)

full_name: FundamentalGroupoid.comp_eq
code: theorem comp_eq (x y z : FundamentalGroupoid X) (p : x ⟶ y) (q : y ⟶ z) : p ≫ q = p.comp q 
goal: p ≫ q = Path.Homotopic.Quotient.comp p q

full_name: FundamentalGroupoid.id_eq_path_refl
code: theorem id_eq_path_refl (x : FundamentalGroupoid X) : 𝟙 x = ⟦Path.refl x.as⟧ 
goal: 𝟙 x = ⟦Path.refl x.as⟧

full_name: FundamentalGroupoid.fundamentalGroupoidFunctor
code: /-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd 
goal: TopCat ⥤ CategoryTheory.Grpd

full_name: FundamentalGroupoid._aux_Mathlib_AlgebraicTopology_FundamentalGroupoid_Basic___unexpand_FundamentalGroupoid_fundamentalGroupoidFunctor_1
code: @[inherit_doc] scoped notation "π" => FundamentalGroupoid.fundamentalGroupoidFunctor
goal: Lean.PrettyPrinter.Unexpander

full_name: FundamentalGroupoid._aux_Mathlib_AlgebraicTopology_FundamentalGroupoid_Basic___macroRules_FundamentalGroupoid_termπ_1
code: @[inherit_doc] scoped notation "π" => FundamentalGroupoid.fundamentalGroupoidFunctor
goal: Lean.Macro

full_name: FundamentalGroupoid._aux_Mathlib_AlgebraicTopology_FundamentalGroupoid_Basic___macroRules_FundamentalGroupoid_termπₓ_1
code: /-- The fundamental groupoid of a topological space. -/
scoped notation "πₓ" => FundamentalGroupoid.fundamentalGroupoidFunctor.obj
goal: Lean.Macro

full_name: FundamentalGroupoid._aux_Mathlib_AlgebraicTopology_FundamentalGroupoid_Basic___macroRules_FundamentalGroupoid_termπₘ_1
code: /-- The functor between fundamental groupoids induced by a continuous map. -/
scoped notation "πₘ" => FundamentalGroupoid.fundamentalGroupoidFunctor.map
goal: Lean.Macro

full_name: FundamentalGroupoid.map_eq
code: theorem map_eq {X Y : TopCat} {x₀ x₁ : X} (f : C(X, Y)) (p : Path.Homotopic.Quotient x₀ x₁) :
    (πₘ f).map p = p.mapFn f 
goal: (FundamentalGroupoid.fundamentalGroupoidFunctor.map f).map p = p.mapFn f

full_name: FundamentalGroupoid.toTop
code: /-- Help the typechecker by converting a point in a groupoid back to a point in
the underlying topological space. -/
abbrev toTop {X : TopCat} (x : πₓ X) : X 
goal: ↑X

full_name: FundamentalGroupoid.fromTop
code: /-- Help the typechecker by converting a point in a topological space to a
point in the fundamental groupoid of that space. -/
abbrev fromTop {X : TopCat} (x : X) : πₓ X 
goal: ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj X)

full_name: FundamentalGroupoid.toPath
code: /-- Help the typechecker by converting an arrow in the fundamental groupoid of
a topological space back to a path in that space (i.e., `Path.Homotopic.Quotient`). -/
-- Porting note: Added `(X := X)` to the type.
abbrev toPath {X : TopCat} {x₀ x₁ : πₓ X} (p : x₀ ⟶ x₁) :
    Path.Homotopic.Quotient (X := X) x₀.as x₁.as 
goal: Path.Homotopic.Quotient x₀.as x₁.as

full_name: FundamentalGroupoid.fromPath
code: /-- Help the typechecker by converting a path in a topological space to an arrow in the
fundamental groupoid of that space. -/
abbrev fromPath {X : TopCat} {x₀ x₁ : X} (p : Path.Homotopic.Quotient x₀ x₁) :
    FundamentalGroupoid.mk x₀ ⟶ FundamentalGroupoid.mk x₁ 
goal: { as := x₀ } ⟶ { as := x₁ }