l3lab/ntp-mathlib huggingface dataset:
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    

Proof state:
X✝ : Type u
Y : Type v
inst✝¹ : TopologicalSpace X✝
inst✝ : TopologicalSpace Y
x₀ x₁ : X✝
X : TopCat
⊢ CategoryTheory.Functor.mk
      { obj := fun x => { as := (𝟙 X) x.as }, map := fun {X_1 Y} p => Path.Homotopic.Quotient.mapFn p (𝟙 X) } =
    CategoryTheory.Functor.mk { obj := fun X => X, map := fun {X_1 Y} f => f }

Next tactic:
congr
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    

Proof state:
case e_toPrefunctor.e_map
X✝ : Type u
Y : Type v
inst✝¹ : TopologicalSpace X✝
inst✝ : TopologicalSpace Y
x₀ x₁ : X✝
X : TopCat
⊢ (fun {X_1 Y} p => Path.Homotopic.Quotient.mapFn p (𝟙 X)) = fun {X_1 Y} f => f

Next tactic:
ext x y p
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    

Proof state:
case e_toPrefunctor.e_map.h.h.h
X✝ : Type u
Y : Type v
inst✝¹ : TopologicalSpace X✝
inst✝ : TopologicalSpace Y
x₀ x₁ : X✝
X : TopCat
x y : FundamentalGroupoid ↑X
p : x ⟶ y
⊢ Path.Homotopic.Quotient.mapFn p (𝟙 X) = p

Next tactic:
refine' Quotient.inductionOn p fun q => _
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    

Proof state:
case e_toPrefunctor.e_map.h.h.h
X✝ : Type u
Y : Type v
inst✝¹ : TopologicalSpace X✝
inst✝ : TopologicalSpace Y
x₀ x₁ : X✝
X : TopCat
x y : FundamentalGroupoid ↑X
p : x ⟶ y
q : Path x.as y.as
⊢ Path.Homotopic.Quotient.mapFn ⟦q⟧ (𝟙 X) = ⟦q⟧

Next tactic:
rw [← Path.Homotopic.map_lift]
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    

Proof state:
case e_toPrefunctor.e_map.h.h.h
X✝ : Type u
Y : Type v
inst✝¹ : TopologicalSpace X✝
inst✝ : TopologicalSpace Y
x₀ x₁ : X✝
X : TopCat
x y : FundamentalGroupoid ↑X
p : x ⟶ y
q : Path x.as y.as
⊢ ⟦Path.map q (_ : Continuous ⇑(𝟙 X))⟧ = ⟦q⟧

Next tactic:
conv_rhs => rw [← q.map_id]
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    conv_rhs => 

Proof state:
X✝ : Type u
Y : Type v
inst✝¹ : TopologicalSpace X✝
inst✝ : TopologicalSpace Y
x₀ x₁ : X✝
X : TopCat
x y : FundamentalGroupoid ↑X
p : x ⟶ y
q : Path x.as y.as
| ⟦q⟧

Next tactic:
rw [← q.map_id]
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    conv_rhs => rw [← q.map_id]
  map_comp f g := by
    

Proof state:
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
X✝ Y✝ Z✝ : TopCat
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun X => Bundled.mk (FundamentalGroupoid ↑X),
          map := fun {X Y} f =>
            CategoryTheory.Functor.mk
              { obj := fun x => { as := f x.as }, map := fun {X_1 Y_1} p => Path.Homotopic.Quotient.mapFn p f } }.map
      (f ≫ g) =
    { obj := fun X => Bundled.mk (FundamentalGroupoid ↑X),
            map := fun {X Y} f =>
              CategoryTheory.Functor.mk
                { obj := fun x => { as := f x.as }, map := fun {X_1 Y_1} p => Path.Homotopic.Quotient.mapFn p f } }.map
        f ≫
      { obj := fun X => Bundled.mk (FundamentalGroupoid ↑X),
            map := fun {X Y} f =>
              CategoryTheory.Functor.mk
                { obj := fun x => { as := f x.as }, map := fun {X_1 Y_1} p => Path.Homotopic.Quotient.mapFn p f } }.map
        g

Next tactic:
simp only
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    conv_rhs => rw [← q.map_id]
  map_comp f g := by
    simp only
    

Proof state:
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
X✝ Y✝ Z✝ : TopCat
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ CategoryTheory.Functor.mk
      { obj := fun x => { as := (f ≫ g) x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p (f ≫ g) } =
    CategoryTheory.Functor.mk
        { obj := fun x => { as := f x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p f } ≫
      CategoryTheory.Functor.mk
        { obj := fun x => { as := g x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p g }

Next tactic:
congr
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    conv_rhs => rw [← q.map_id]
  map_comp f g := by
    simp only
    congr
    

Proof state:
case e_toPrefunctor.e_map
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
X✝ Y✝ Z✝ : TopCat
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ (fun {X Y} p => Path.Homotopic.Quotient.mapFn p (f ≫ g)) = fun {X Y} f_1 =>
    (CategoryTheory.Functor.mk
          { obj := fun x => { as := g x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p g }).map
      ((CategoryTheory.Functor.mk
            { obj := fun x => { as := f x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p f }).map
        f_1)

Next tactic:
ext x y p
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    conv_rhs => rw [← q.map_id]
  map_comp f g := by
    simp only
    congr
    ext x y p
    

Proof state:
case e_toPrefunctor.e_map.h.h.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
X✝ Y✝ Z✝ : TopCat
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
x y : FundamentalGroupoid ↑X✝
p : x ⟶ y
⊢ Path.Homotopic.Quotient.mapFn p (f ≫ g) =
    (CategoryTheory.Functor.mk
          { obj := fun x => { as := g x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p g }).map
      ((CategoryTheory.Functor.mk
            { obj := fun x => { as := f x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p f }).map
        p)

Next tactic:
refine' Quotient.inductionOn p fun q => _
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    conv_rhs => rw [← q.map_id]
  map_comp f g := by
    simp only
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    

Proof state:
case e_toPrefunctor.e_map.h.h.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
X✝ Y✝ Z✝ : TopCat
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
x y : FundamentalGroupoid ↑X✝
p : x ⟶ y
q : Path x.as y.as
⊢ Path.Homotopic.Quotient.mapFn ⟦q⟧ (f ≫ g) =
    (CategoryTheory.Functor.mk
          { obj := fun x => { as := g x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p g }).map
      ((CategoryTheory.Functor.mk
            { obj := fun x => { as := f x.as }, map := fun {X Y} p => Path.Homotopic.Quotient.mapFn p f }).map
        ⟦q⟧)

Next tactic:
simp only [Quotient.map_mk, Path.map_map, Quotient.eq']
/-- The functor sending a topological space `X` to its fundamental groupoid. -/
def fundamentalGroupoidFunctor : TopCat ⥤ CategoryTheory.Grpd where
  obj X := { α := FundamentalGroupoid X }
  map f :=
    { obj := fun x => ⟨f x.as⟩
      map := fun {X Y} p => by exact Path.Homotopic.Quotient.mapFn p f
      map_id := fun X => rfl
      map_comp := fun {x y z} p q => by
        refine Quotient.inductionOn₂ p q fun a b => ?_
        simp only [comp_eq, ← Path.Homotopic.map_lift, ← Path.Homotopic.comp_lift, Path.map_trans]
        -- This was not needed before leanprover/lean4#2644
        erw [ ← Path.Homotopic.comp_lift]; rfl}
  map_id X := by
    simp only
    change _ = (⟨_, _, _⟩ : FundamentalGroupoid X ⥤ FundamentalGroupoid X)
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    rw [← Path.Homotopic.map_lift]
    conv_rhs => rw [← q.map_id]
  map_comp f g := by
    simp only
    congr
    ext x y p
    refine' Quotient.inductionOn p fun q => _
    simp only [Quotient.map_mk, Path.map_map, Quotient.eq']
    

Proof state:
case e_toPrefunctor.e_map.h.h.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
X✝ Y✝ Z✝ : TopCat
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
x y : FundamentalGroupoid ↑X✝
p : x ⟶ y
q : Path x.as y.as
⊢ Path.Homotopic.Quotient.mapFn ⟦q⟧ (f ≫ g) = Path.Homotopic.Quotient.mapFn (Path.Homotopic.Quotient.mapFn ⟦q⟧ f) g

Next tactic:
rfl
/-- `GroupFilterBasis` constructor in the commutative group case. -/
@[to_additive "`AddGroupFilterBasis` constructor in the additive commutative group case."]
def groupFilterBasisOfComm {G : Type*} [CommGroup G] (sets : Set (Set G))
    (nonempty : sets.Nonempty) (inter_sets : ∀ x y, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y)
    (one : ∀ U ∈ sets, (1 : G) ∈ U) (mul : ∀ U ∈ sets, ∃ V ∈ sets, V * V ⊆ U)
    (inv : ∀ U ∈ sets, ∃ V ∈ sets, V ⊆ (fun x ↦ x⁻¹) ⁻¹' U) : GroupFilterBasis G :=
  { sets := sets
    nonempty := nonempty
    inter_sets := inter_sets _ _
    one' := one _
    mul' := mul _
    inv' := inv _
    conj' := fun x U U_in ↦ ⟨U, U_in, by 

Proof state:
G : Type u_1
inst✝ : CommGroup G
sets : Set (Set G)
nonempty : Set.Nonempty sets
inter_sets : ∀ (x y : Set G), x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y
one : ∀ U ∈ sets, 1 ∈ U
mul : ∀ U ∈ sets, ∃ V ∈ sets, V * V ⊆ U
inv : ∀ U ∈ sets, ∃ V ∈ sets, V ⊆ (fun x => x⁻¹) ⁻¹' U
x : G
U : Set G
U_in :
  U ∈
    { sets := sets, nonempty := nonempty,
        inter_sets := (_ : ∀ {x y : Set G}, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y) }.sets
⊢ U ⊆ (fun x_1 => x * x_1 * x⁻¹) ⁻¹' U

Next tactic:
simp only [mul_inv_cancel_comm, preimage_id']
/-- `GroupFilterBasis` constructor in the commutative group case. -/
@[to_additive "`AddGroupFilterBasis` constructor in the additive commutative group case."]
def groupFilterBasisOfComm {G : Type*} [CommGroup G] (sets : Set (Set G))
    (nonempty : sets.Nonempty) (inter_sets : ∀ x y, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y)
    (one : ∀ U ∈ sets, (1 : G) ∈ U) (mul : ∀ U ∈ sets, ∃ V ∈ sets, V * V ⊆ U)
    (inv : ∀ U ∈ sets, ∃ V ∈ sets, V ⊆ (fun x ↦ x⁻¹) ⁻¹' U) : GroupFilterBasis G :=
  { sets := sets
    nonempty := nonempty
    inter_sets := inter_sets _ _
    one' := one _
    mul' := mul _
    inv' := inv _
    conj' := fun x U U_in ↦ ⟨U, U_in, by simp only [mul_inv_cancel_comm, preimage_id']; 

Proof state:
G : Type u_1
inst✝ : CommGroup G
sets : Set (Set G)
nonempty : Set.Nonempty sets
inter_sets : ∀ (x y : Set G), x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y
one : ∀ U ∈ sets, 1 ∈ U
mul : ∀ U ∈ sets, ∃ V ∈ sets, V * V ⊆ U
inv : ∀ U ∈ sets, ∃ V ∈ sets, V ⊆ (fun x => x⁻¹) ⁻¹' U
x : G
U : Set G
U_in :
  U ∈
    { sets := sets, nonempty := nonempty,
        inter_sets := (_ : ∀ {x y : Set G}, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y) }.sets
⊢ U ⊆ U

Next tactic:
rfl
/-- The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive "The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete."]
instance : Inhabited (GroupFilterBasis G) := ⟨by
  

Proof state:
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ GroupFilterBasis G

Next tactic:
refine'
    { sets := {{1}}
      nonempty := singleton_nonempty _.. }
/-- The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive "The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete."]
instance : Inhabited (GroupFilterBasis G) := ⟨by
  refine'
    { sets := {{1}}
      nonempty := singleton_nonempty _.. }
  

Proof state:
case refine'_1
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y
case refine'_2
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {U : Set G}, U ∈ { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}), inter_sets := ?refine'_1 }.sets → 1 ∈ U
case refine'_3
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {U : Set G},
    U ∈ { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}), inter_sets := ?refine'_1 }.sets →
      ∃ V ∈ { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}), inter_sets := ?refine'_1 }.sets, V * V ⊆ U
case refine'_4
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {U : Set G},
    U ∈ { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}), inter_sets := ?refine'_1 }.sets →
      ∃ V ∈ { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}), inter_sets := ?refine'_1 }.sets,
        V ⊆ (fun x => x⁻¹) ⁻¹' U
case refine'_5
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ (x₀ : G) {U : Set G},
    U ∈ { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}), inter_sets := ?refine'_1 }.sets →
      ∃ V ∈ { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}), inter_sets := ?refine'_1 }.sets,
        V ⊆ (fun x => x₀ * x * x₀⁻¹) ⁻¹' U

Next tactic:
all_goals simp only [exists_prop, mem_singleton_iff]
/-- The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive "The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete."]
instance : Inhabited (GroupFilterBasis G) := ⟨by
  refine'
    { sets := {{1}}
      nonempty := singleton_nonempty _.. }
  all_goals 

Proof state:
case refine'_1
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y

Next tactic:
simp only [exists_prop, mem_singleton_iff]
/-- The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive "The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete."]
instance : Inhabited (GroupFilterBasis G) := ⟨by
  refine'
    { sets := {{1}}
      nonempty := singleton_nonempty _.. }
  all_goals 

Proof state:
case refine'_2
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {U : Set G},
    U ∈
        { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}),
            inter_sets := (_ : ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y) }.sets →
      1 ∈ U

Next tactic:
simp only [exists_prop, mem_singleton_iff]
/-- The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive "The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete."]
instance : Inhabited (GroupFilterBasis G) := ⟨by
  refine'
    { sets := {{1}}
      nonempty := singleton_nonempty _.. }
  all_goals 

Proof state:
case refine'_3
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {U : Set G},
    U ∈
        { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}),
            inter_sets := (_ : ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y) }.sets →
      ∃
        V ∈
          { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}),
              inter_sets := (_ : ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y) }.sets,
        V * V ⊆ U

Next tactic:
simp only [exists_prop, mem_singleton_iff]
/-- The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive "The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete."]
instance : Inhabited (GroupFilterBasis G) := ⟨by
  refine'
    { sets := {{1}}
      nonempty := singleton_nonempty _.. }
  all_goals 

Proof state:
case refine'_4
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ {U : Set G},
    U ∈
        { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}),
            inter_sets := (_ : ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y) }.sets →
      ∃
        V ∈
          { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}),
              inter_sets := (_ : ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y) }.sets,
        V ⊆ (fun x => x⁻¹) ⁻¹' U

Next tactic:
simp only [exists_prop, mem_singleton_iff]
/-- The trivial group filter basis consists of `{1}` only. The associated topology
is discrete. -/
@[to_additive "The trivial additive group filter basis consists of `{0}` only. The associated
topology is discrete."]
instance : Inhabited (GroupFilterBasis G) := ⟨by
  refine'
    { sets := {{1}}
      nonempty := singleton_nonempty _.. }
  all_goals 

Proof state:
case refine'_5
G : Type u
inst✝ : Group G
B : GroupFilterBasis G
⊢ ∀ (x₀ : G) {U : Set G},
    U ∈
        { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}),
            inter_sets := (_ : ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y) }.sets →
      ∃
        V ∈
          { sets := {{1}}, nonempty := (_ : Set.Nonempty {{1}}),
              inter_sets := (_ : ∀ {x y : Set G}, x ∈ {{1}} → y ∈ {{1}} → ∃ z ∈ {{1}}, z ⊆ x ∩ y) }.sets,
        V ⊆ (fun x => x₀ * x * x₀⁻¹) ⁻¹' U

Next tactic:
simp only [exists_prop, mem_singleton_iff]