ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- GenLoop.fromLoop_trans_toLoop
theorem fromLoop_trans_toLoop {i : N} {p q : Ω^ N X x} :
    fromLoop i ((toLoop i p).trans <| toLoop i q) = transAt i p q 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] {i : N} {p q : ↑(Ω^ N X x)}
Goal: GenLoop.fromLoop i (Path.trans (GenLoop.toLoop i p) (GenLoop.toLoop i q)) = GenLoop.transAt i p q
-- GenLoop.fromLoop_symm_toLoop
theorem fromLoop_symm_toLoop {i : N} {p : Ω^ N X x} : fromLoop i (toLoop i p).symm = symmAt i p 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] {i : N} {p : ↑(Ω^ N X x)}
Goal: GenLoop.fromLoop i (Path.symm (GenLoop.toLoop i p)) = GenLoop.symmAt i p
-- HomotopyGroup.isUnital_auxGroup
theorem isUnital_auxGroup (i : N) :
    EckmannHilton.IsUnital (auxGroup i).mul (⟦const⟧ : HomotopyGroup N X x) 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i : N)
Goal: EckmannHilton.IsUnital Mul.mul ⟦GenLoop.const⟧
-- HomotopyGroup.auxGroup_indep
theorem auxGroup_indep (i j : N) : (auxGroup i : Group (HomotopyGroup N X x)) = auxGroup j 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] (i j : N)
Goal: HomotopyGroup.auxGroup i = HomotopyGroup.auxGroup j
-- HomotopyGroup.transAt_indep
theorem transAt_indep {i} (j) (f g : Ω^ N X x) :
    (⟦transAt i f g⟧ : HomotopyGroup N X x) = ⟦transAt j f g⟧ 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] {i : N} (j : N) (f g : ↑(Ω^ N X x))
Goal: ⟦GenLoop.transAt i f g⟧ = ⟦GenLoop.transAt j f g⟧
-- HomotopyGroup.symmAt_indep
theorem symmAt_indep {i} (j) (f : Ω^ N X x) :
    (⟦symmAt i f⟧ : HomotopyGroup N X x) = ⟦symmAt j f⟧ 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] {i : N} (j : N) (f : ↑(Ω^ N X x))
Goal: ⟦GenLoop.symmAt i f⟧ = ⟦GenLoop.symmAt j f⟧
-- HomotopyGroup.one_def
theorem one_def [Nonempty N] : (1 : HomotopyGroup N X x) = ⟦const⟧ 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] [Nonempty N]
Goal: 1 = ⟦GenLoop.const⟧
-- HomotopyGroup.mul_spec
theorem mul_spec [Nonempty N] {i} {p q : Ω^ N X x} :
    -- Porting note (#11215): TODO: introduce `HomotopyGroup.mk` and remove defeq abuse.
    ((· * ·) : _ → _ → HomotopyGroup N X x) ⟦p⟧ ⟦q⟧ = ⟦transAt i q p⟧ 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] [Nonempty N] {i : N} {p q : ↑(Ω^ N X x)}
Goal: (fun x_1 x_2 => x_1 * x_2) ⟦p⟧ ⟦q⟧ = ⟦GenLoop.transAt i q p⟧
-- HomotopyGroup.inv_spec
theorem inv_spec [Nonempty N] {i} {p : Ω^ N X x} :
    ((⟦p⟧)⁻¹ : HomotopyGroup N X x) = ⟦symmAt i p⟧ 
Arguments: {N : Type u_1} {X : Type u_2} [TopologicalSpace X] {x : X} [DecidableEq N] [Nonempty N] {i : N} {p : ↑(Ω^ N X x)}
Goal: (⟦p⟧)⁻¹ = ⟦GenLoop.symmAt i p⟧
-- Stonean.effectiveEpi_tfae
theorem effectiveEpi_tfae
    {B X : Stonean.{u}} (π : X ⟶ B) :
    TFAE
    [ EffectiveEpi π
    , Epi π
    , Function.Surjective π
    ] 
Arguments: {B X : Stonean} (π : X ⟶ B)
Goal: [CategoryTheory.EffectiveEpi π, CategoryTheory.Epi π, Function.Surjective ⇑π].TFAE
-- Stonean.effectiveEpiFamily_tfae
theorem effectiveEpiFamily_tfae
    {α : Type} [Finite α] {B : Stonean.{u}}
    (X : α → Stonean.{u}) (π : (a : α) → (X a ⟶ B)) :
    TFAE
    [ EffectiveEpiFamily X π
    , Epi (Sigma.desc π)
    , ∀ b : B, ∃ (a : α) (x : X a), π a x = b
    ] 
Arguments: {α : Type} [Finite α] {B : Stonean} (X : α → Stonean) (π : (a : α) → X a ⟶ B)
Goal: [CategoryTheory.EffectiveEpiFamily X π, CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π),
    ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b].TFAE
-- Stonean.effectiveEpiFamily_of_jointly_surjective
theorem effectiveEpiFamily_of_jointly_surjective
    {α : Type} [Finite α] {B : Stonean.{u}}
    (X : α → Stonean.{u}) (π : (a : α) → (X a ⟶ B))
    (surj : ∀ b : B, ∃ (a : α) (x : X a), π a x = b) :
    EffectiveEpiFamily X π 
Arguments: {α : Type} [Finite α] {B : Stonean} (X : α → Stonean) (π : (a : α) → X a ⟶ B) (surj : ∀ (b : ↑B.toTop), ∃ a x, (π a) x = b)
Goal: CategoryTheory.EffectiveEpiFamily X π
-- LightProfinite.effectiveEpi_iff_surjective
theorem effectiveEpi_iff_surjective {X Y : LightProfinite.{u}} (f : X ⟶ Y) :
    EffectiveEpi f ↔ Function.Surjective f 
Arguments: {X Y : LightProfinite} (f : X ⟶ Y)
Goal: CategoryTheory.EffectiveEpi f ↔ Function.Surjective ⇑f
-- TietzeExtension.exists_restrict_eq'
class TietzeExtension (Y : Type v) [TopologicalSpace Y] : Prop where
  exists_restrict_eq' {X : Type u} [TopologicalSpace X] [NormalSpace X] (s : Set X)
    (hs : IsClosed s) (f : C(s, Y)) : ∃ (g : C(X, Y)), g.restrict s = f
Arguments: {Y : Type v} [TopologicalSpace Y] [self : TietzeExtension Y] {X : Type u} [TopologicalSpace X] [NormalSpace X] (s : Set X) (hs : IsClosed s) (f : C(↑s, Y))
Goal: ∃ g, ContinuousMap.restrict s g = f
-- ContinuousMap.exists_restrict_eq
theorem ContinuousMap.exists_restrict_eq (f : C(s, Y)) : ∃ (g : C(X, Y)), g.restrict s = f 
Arguments: {X : Type u} [TopologicalSpace X] [NormalSpace X] {s : Set X} (hs : IsClosed s) {Y : Type v} [TopologicalSpace Y] [TietzeExtension Y] (f : C(↑s, Y))
Goal: ∃ g, ContinuousMap.restrict s g = f
-- ContinuousMap.exists_extension
theorem ContinuousMap.exists_extension (f : C(X₁, Y)) :
    ∃ (g : C(X, Y)), g.comp ⟨e, he.continuous⟩ = f 
Arguments: {X₁ : Type u₁} [TopologicalSpace X₁] {X : Type u} [TopologicalSpace X] [NormalSpace X] {e : X₁ → X} (he : ClosedEmbedding e) {Y : Type v} [TopologicalSpace Y] [TietzeExtension Y] (f : C(X₁, Y))
Goal: ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f
-- ContinuousMap.exists_extension'
theorem ContinuousMap.exists_extension' (f : C(X₁, Y)) : ∃ (g : C(X, Y)), g ∘ e = f 
Arguments: {X₁ : Type u₁} [TopologicalSpace X₁] {X : Type u} [TopologicalSpace X] [NormalSpace X] {e : X₁ → X} (he : ClosedEmbedding e) {Y : Type v} [TopologicalSpace Y] [TietzeExtension Y] (f : C(X₁, Y))
Goal: ∃ g, ⇑g ∘ e = ⇑f
-- ContinuousMap.exists_forall_mem_restrict_eq
theorem ContinuousMap.exists_forall_mem_restrict_eq {Y : Type v} [TopologicalSpace Y] (f : C(s, Y))
    {t : Set Y} (hf : ∀ x, f x ∈ t) [ht : TietzeExtension.{u, v} t] :
    ∃ (g : C(X, Y)), (∀ x, g x ∈ t) ∧ g.restrict s = f 
Arguments: {X : Type u} [TopologicalSpace X] [NormalSpace X] {s : Set X} (hs : IsClosed s) {Y : Type v} [TopologicalSpace Y] (f : C(↑s, Y)) {t : Set Y} (hf : ∀ (x : ↑s), f x ∈ t) [ht : TietzeExtension ↑t]
Goal: ∃ g, (∀ (x : X), g x ∈ t) ∧ ContinuousMap.restrict s g = f
-- ContinuousMap.exists_extension_forall_mem
theorem ContinuousMap.exists_extension_forall_mem {Y : Type v} [TopologicalSpace Y] (f : C(X₁, Y))
    {t : Set Y} (hf : ∀ x, f x ∈ t) [ht : TietzeExtension.{u, v} t] :
    ∃ (g : C(X, Y)), (∀ x, g x ∈ t) ∧ g.comp ⟨e, he.continuous⟩ = f 
Arguments: {X₁ : Type u₁} [TopologicalSpace X₁] {X : Type u} [TopologicalSpace X] [NormalSpace X] {e : X₁ → X} (he : ClosedEmbedding e) {Y : Type v} [TopologicalSpace Y] (f : C(X₁, Y)) {t : Set Y} (hf : ∀ (x : X₁), f x ∈ t) [ht : TietzeExtension ↑t]
Goal: ∃ g, (∀ (x : X), g x ∈ t) ∧ g.comp { toFun := e, continuous_toFun := ⋯ } = f
-- TietzeExtension.of_retract
theorem TietzeExtension.of_retract {Y : Type v} {Z : Type w} [TopologicalSpace Y]
    [TopologicalSpace Z] [TietzeExtension.{u, w} Z] (ι : C(Y, Z)) (r : C(Z, Y))
    (h : r.comp ι = .id Y) : TietzeExtension.{u, v} Y 
Arguments: {Y : Type v} {Z : Type w} [TopologicalSpace Y] [TopologicalSpace Z] [TietzeExtension Z] (ι : C(Y, Z)) (r : C(Z, Y)) (h : r.comp ι = ContinuousMap.id Y)
Goal: TietzeExtension Y
-- TietzeExtension.of_homeo
theorem TietzeExtension.of_homeo {Y : Type v} {Z : Type w} [TopologicalSpace Y]
    [TopologicalSpace Z] [TietzeExtension.{u, w} Z] (e : Y ≃ₜ Z) :
    TietzeExtension.{u, v} Y 
Arguments: {Y : Type v} {Z : Type w} [TopologicalSpace Y] [TopologicalSpace Z] [TietzeExtension Z] (e : Y ≃ₜ Z)
Goal: TietzeExtension Y
-- BoundedContinuousFunction.tietze_extension_step
theorem tietze_extension_step (f : X →ᵇ ℝ) (e : C(X, Y)) (he : ClosedEmbedding e) :
    ∃ g : Y →ᵇ ℝ, ‖g‖ ≤ ‖f‖ / 3 ∧ dist (g.compContinuous e) f ≤ 2 / 3 * ‖f‖ 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [NormalSpace Y] (f : X →ᵇ ℝ) (e : C(X, Y)) (he : ClosedEmbedding ⇑e)
Goal: ∃ g, ‖g‖ ≤ ‖f‖ / 3 ∧ dist (g.compContinuous e) f ≤ 2 / 3 * ‖f‖
-- BoundedContinuousFunction.exists_extension_norm_eq_of_closedEmbedding'
theorem exists_extension_norm_eq_of_closedEmbedding' (f : X →ᵇ ℝ) (e : C(X, Y))
    (he : ClosedEmbedding e) : ∃ g : Y →ᵇ ℝ, ‖g‖ = ‖f‖ ∧ g.compContinuous e = f 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [NormalSpace Y] (f : X →ᵇ ℝ) (e : C(X, Y)) (he : ClosedEmbedding ⇑e)
Goal: ∃ g, ‖g‖ = ‖f‖ ∧ g.compContinuous e = f
-- BoundedContinuousFunction.exists_extension_norm_eq_of_closedEmbedding
theorem exists_extension_norm_eq_of_closedEmbedding (f : X →ᵇ ℝ) {e : X → Y}
    (he : ClosedEmbedding e) : ∃ g : Y →ᵇ ℝ, ‖g‖ = ‖f‖ ∧ g ∘ e = f 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [NormalSpace Y] (f : X →ᵇ ℝ) {e : X → Y} (he : ClosedEmbedding e)
Goal: ∃ g, ‖g‖ = ‖f‖ ∧ ⇑g ∘ e = ⇑f
-- BoundedContinuousFunction.exists_norm_eq_restrict_eq_of_closed
theorem exists_norm_eq_restrict_eq_of_closed {s : Set Y} (f : s →ᵇ ℝ) (hs : IsClosed s) :
    ∃ g : Y →ᵇ ℝ, ‖g‖ = ‖f‖ ∧ g.restrict s = f 
Arguments: {Y : Type u_2} [TopologicalSpace Y] [NormalSpace Y] {s : Set Y} (f : ↑s →ᵇ ℝ) (hs : IsClosed s)
Goal: ∃ g, ‖g‖ = ‖f‖ ∧ g.restrict s = f
-- BoundedContinuousFunction.exists_extension_forall_mem_Icc_of_closedEmbedding
theorem exists_extension_forall_mem_Icc_of_closedEmbedding (f : X →ᵇ ℝ) {a b : ℝ} {e : X → Y}
    (hf : ∀ x, f x ∈ Icc a b) (hle : a ≤ b) (he : ClosedEmbedding e) :
    ∃ g : Y →ᵇ ℝ, (∀ y, g y ∈ Icc a b) ∧ g ∘ e = f 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [NormalSpace Y] (f : X →ᵇ ℝ) {a b : ℝ} {e : X → Y} (hf : ∀ (x : X), f x ∈ Set.Icc a b) (hle : a ≤ b) (he : ClosedEmbedding e)
Goal: ∃ g, (∀ (y : Y), g y ∈ Set.Icc a b) ∧ ⇑g ∘ e = ⇑f
-- BoundedContinuousFunction.exists_extension_forall_exists_le_ge_of_closedEmbedding
theorem exists_extension_forall_exists_le_ge_of_closedEmbedding [Nonempty X] (f : X →ᵇ ℝ)
    {e : X → Y} (he : ClosedEmbedding e) :
    ∃ g : Y →ᵇ ℝ, (∀ y, ∃ x₁ x₂, g y ∈ Icc (f x₁) (f x₂)) ∧ g ∘ e = f 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [NormalSpace Y] [Nonempty X] (f : X →ᵇ ℝ) {e : X → Y} (he : ClosedEmbedding e)
Goal: ∃ g, (∀ (y : Y), ∃ x₁ x₂, g y ∈ Set.Icc (f x₁) (f x₂)) ∧ ⇑g ∘ e = ⇑f
-- BoundedContinuousFunction.exists_extension_forall_mem_of_closedEmbedding
theorem exists_extension_forall_mem_of_closedEmbedding (f : X →ᵇ ℝ) {t : Set ℝ} {e : X → Y}
    [hs : OrdConnected t] (hf : ∀ x, f x ∈ t) (hne : t.Nonempty) (he : ClosedEmbedding e) :
    ∃ g : Y →ᵇ ℝ, (∀ y, g y ∈ t) ∧ g ∘ e = f 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [NormalSpace Y] (f : X →ᵇ ℝ) {t : Set ℝ} {e : X → Y} [hs : t.OrdConnected] (hf : ∀ (x : X), f x ∈ t) (hne : t.Nonempty) (he : ClosedEmbedding e)
Goal: ∃ g, (∀ (y : Y), g y ∈ t) ∧ ⇑g ∘ e = ⇑f
-- BoundedContinuousFunction.exists_forall_mem_restrict_eq_of_closed
theorem exists_forall_mem_restrict_eq_of_closed {s : Set Y} (f : s →ᵇ ℝ) (hs : IsClosed s)
    {t : Set ℝ} [OrdConnected t] (hf : ∀ x, f x ∈ t) (hne : t.Nonempty) :
    ∃ g : Y →ᵇ ℝ, (∀ y, g y ∈ t) ∧ g.restrict s = f 
Arguments: {Y : Type u_2} [TopologicalSpace Y] [NormalSpace Y] {s : Set Y} (f : ↑s →ᵇ ℝ) (hs : IsClosed s) {t : Set ℝ} [t.OrdConnected] (hf : ∀ (x : ↑s), f x ∈ t) (hne : t.Nonempty)
Goal: ∃ g, (∀ (y : Y), g y ∈ t) ∧ g.restrict s = f
-- ContinuousMap.exists_extension_forall_mem_of_closedEmbedding
theorem exists_extension_forall_mem_of_closedEmbedding (f : C(X, ℝ)) {t : Set ℝ} {e : X → Y}
    [hs : OrdConnected t] (hf : ∀ x, f x ∈ t) (hne : t.Nonempty) (he : ClosedEmbedding e) :
    ∃ g : C(Y, ℝ), (∀ y, g y ∈ t) ∧ g ∘ e = f 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [NormalSpace Y] (f : C(X, ℝ)) {t : Set ℝ} {e : X → Y} [hs : t.OrdConnected] (hf : ∀ (x : X), f x ∈ t) (hne : t.Nonempty) (he : ClosedEmbedding e)
Goal: ∃ g, (∀ (y : Y), g y ∈ t) ∧ ⇑g ∘ e = ⇑f
-- ContinuousMap.exists_restrict_eq_forall_mem_of_closed
theorem exists_restrict_eq_forall_mem_of_closed {s : Set Y} (f : C(s, ℝ)) {t : Set ℝ}
    [OrdConnected t] (ht : ∀ x, f x ∈ t) (hne : t.Nonempty) (hs : IsClosed s) :
    ∃ g : C(Y, ℝ), (∀ y, g y ∈ t) ∧ g.restrict s = f 
Arguments: {Y : Type u_2} [TopologicalSpace Y] [NormalSpace Y] {s : Set Y} (f : C(↑s, ℝ)) {t : Set ℝ} [t.OrdConnected] (ht : ∀ (x : ↑s), f x ∈ t) (hne : t.Nonempty) (hs : IsClosed s)
Goal: ∃ g, (∀ (y : Y), g y ∈ t) ∧ ContinuousMap.restrict s g = f
-- Profinite.IndexFunctor.surjective_π_app
theorem surjective_π_app :
    Function.Surjective (π_app C J) 
Arguments: {ι : Type u} {X : ι → Type} [(i : ι) → TopologicalSpace (X i)] (C : Set ((i : ι) → X i)) {J : ι → Prop}
Goal: Function.Surjective ⇑(Profinite.IndexFunctor.π_app C J)
-- Profinite.IndexFunctor.map_comp_π_app
theorem map_comp_π_app (h : ∀ i, J i → K i) : map C h ∘ π_app C K = π_app C J 
Arguments: {ι : Type u} {X : ι → Type} [(i : ι) → TopologicalSpace (X i)] (C : Set ((i : ι) → X i)) {J K : ι → Prop} (h : ∀ (i : ι), J i → K i)
Goal: ⇑(Profinite.IndexFunctor.map C h) ∘ ⇑(Profinite.IndexFunctor.π_app C K) = ⇑(Profinite.IndexFunctor.π_app C J)
-- Profinite.IndexFunctor.eq_of_forall_π_app_eq
theorem eq_of_forall_π_app_eq (a b : C)
    (h : ∀ (J : Finset ι), π_app C (· ∈ J) a = π_app C (· ∈ J) b) : a = b 
Arguments: {ι : Type u} {X : ι → Type} [(i : ι) → TopologicalSpace (X i)] {C : Set ((i : ι) → X i)} (a b : ↑C) (h :
  ∀ (J : Finset ι),
    (Profinite.IndexFunctor.π_app C fun x => x ∈ J) a = (Profinite.IndexFunctor.π_app C fun x => x ∈ J) b)
Goal: a = b
-- Profinite.pullback.condition
@[reassoc]
lemma pullback.condition : pullback.fst f g ≫ f = pullback.snd f g ≫ g 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B)
Goal: CategoryTheory.CategoryStruct.comp (Profinite.pullback.fst f g) f =
  CategoryTheory.CategoryStruct.comp (Profinite.pullback.snd f g) g
-- Profinite.pullback.lift_fst
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : Profinite.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B) {Z : Profinite} (a : Z ⟶ X) (b : Z ⟶ Y) (w : CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g)
Goal: CategoryTheory.CategoryStruct.comp (Profinite.pullback.lift f g a b w) (Profinite.pullback.fst f g) = a
-- Profinite.pullback.lift_snd
@[reassoc (attr := simp)]
lemma pullback.lift_snd {Z : Profinite.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.snd f g = b 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B) {Z : Profinite} (a : Z ⟶ X) (b : Z ⟶ Y) (w : CategoryTheory.CategoryStruct.comp a f = CategoryTheory.CategoryStruct.comp b g)
Goal: CategoryTheory.CategoryStruct.comp (Profinite.pullback.lift f g a b w) (Profinite.pullback.snd f g) = b
-- Profinite.pullback.hom_ext
lemma pullback.hom_ext {Z : Profinite.{u}} (a b : Z ⟶ pullback f g)
    (hfst : a ≫ pullback.fst f g = b ≫ pullback.fst f g)
    (hsnd : a ≫ pullback.snd f g = b ≫ pullback.snd f g) : a = b 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B) {Z : Profinite} (a b : Z ⟶ Profinite.pullback f g) (hfst :
  CategoryTheory.CategoryStruct.comp a (Profinite.pullback.fst f g) =
    CategoryTheory.CategoryStruct.comp b (Profinite.pullback.fst f g)) (hsnd :
  CategoryTheory.CategoryStruct.comp a (Profinite.pullback.snd f g) =
    CategoryTheory.CategoryStruct.comp b (Profinite.pullback.snd f g))
Goal: a = b
-- Profinite.pullback.cone_pt
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B)
Goal: (Profinite.pullback.cone f g).pt = Profinite.pullback f g
-- Profinite.pullback.cone_π
@[simps! pt π]
def pullback.cone : Limits.PullbackCone f g 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B)
Goal: (Profinite.pullback.cone f g).π =
  {
    app := fun j =>
      Option.rec (CategoryTheory.CategoryStruct.comp (Profinite.pullback.fst f g) f)
        (fun val => CategoryTheory.Limits.WalkingPair.rec (Profinite.pullback.fst f g) (Profinite.pullback.snd f g) val)
        j,
    naturality := ⋯ }
-- Profinite.pullback.isLimit_lift
@[simps! lift]
def pullback.isLimit : Limits.IsLimit (pullback.cone f g) 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B) (s : CategoryTheory.Limits.PullbackCone f g)
Goal: (Profinite.pullback.isLimit f g).lift s = Profinite.pullback.lift f g s.fst s.snd ⋯
-- Profinite.pullback_fst_eq
theorem pullback_fst_eq :
    Profinite.pullback.fst f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.fst f g 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B)
Goal: Profinite.pullback.fst f g =
  CategoryTheory.CategoryStruct.comp (Profinite.pullbackIsoPullback f g).hom (CategoryTheory.Limits.pullback.fst f g)
-- Profinite.pullback_snd_eq
theorem pullback_snd_eq :
    Profinite.pullback.snd f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.snd f g 
Arguments: {X Y B : Profinite} (f : X ⟶ B) (g : Y ⟶ B)
Goal: Profinite.pullback.snd f g =
  CategoryTheory.CategoryStruct.comp (Profinite.pullbackIsoPullback f g).hom (CategoryTheory.Limits.pullback.snd f g)
-- Profinite.finiteCoproduct.ι_desc
@[reassoc (attr := simp)]
lemma finiteCoproduct.ι_desc {B : Profinite.{max u w}} (e : (a : α) → (X a ⟶ B)) (a : α) :
    finiteCoproduct.ι X a ≫ finiteCoproduct.desc X e = e a 
Arguments: {α : Type w} [Finite α] (X : α → Profinite) {B : Profinite} (e : (a : α) → X a ⟶ B) (a : α)
Goal: CategoryTheory.CategoryStruct.comp (Profinite.finiteCoproduct.ι X a) (Profinite.finiteCoproduct.desc X e) = e a
-- Profinite.finiteCoproduct.hom_ext
lemma finiteCoproduct.hom_ext {B : Profinite.{max u w}} (f g : finiteCoproduct X ⟶ B)
    (h : ∀ a : α, finiteCoproduct.ι X a ≫ f = finiteCoproduct.ι X a ≫ g) : f = g 
Arguments: {α : Type w} [Finite α] (X : α → Profinite) {B : Profinite} (f g : Profinite.finiteCoproduct X ⟶ B) (h :
  ∀ (a : α),
    CategoryTheory.CategoryStruct.comp (Profinite.finiteCoproduct.ι X a) f =
      CategoryTheory.CategoryStruct.comp (Profinite.finiteCoproduct.ι X a) g)
Goal: f = g
-- Profinite.Sigma.ι_comp_toFiniteCoproduct
theorem Sigma.ι_comp_toFiniteCoproduct (a : α) :
    (Limits.Sigma.ι X a) ≫ (coproductIsoCoproduct X).inv = finiteCoproduct.ι X a 
Arguments: {α : Type w} [Finite α] (X : α → Profinite) (a : α)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι X a) (Profinite.coproductIsoCoproduct X).inv =
  Profinite.finiteCoproduct.ι X a
-- Profinite.finiteCoproduct.ι_injective
lemma finiteCoproduct.ι_injective (a : α) : Function.Injective (finiteCoproduct.ι X a) 
Arguments: {α : Type w} [Finite α] (X : α → Profinite) (a : α)
Goal: Function.Injective ⇑(Profinite.finiteCoproduct.ι X a)
-- Profinite.finiteCoproduct.ι_jointly_surjective
lemma finiteCoproduct.ι_jointly_surjective (R : finiteCoproduct X) :
    ∃ (a : α) (r : X a), R = finiteCoproduct.ι X a r 
Arguments: {α : Type w} [Finite α] (X : α → Profinite) (R : ↑(Profinite.finiteCoproduct X).toTop)
Goal: ∃ a r, R = (Profinite.finiteCoproduct.ι X a) r
-- Profinite.finiteCoproduct.ι_desc_apply
lemma finiteCoproduct.ι_desc_apply {B : Profinite} {π : (a : α) → X a ⟶ B} (a : α) :
    ∀ x, finiteCoproduct.desc X π (finiteCoproduct.ι X a x) = π a x 
Arguments: {α : Type w} [Finite α] (X : α → Profinite) {B : Profinite} {π : (a : α) → X a ⟶ B} (a : α) (x : (CategoryTheory.forget Profinite).obj (X a))
Goal: (Profinite.finiteCoproduct.desc X π) ((Profinite.finiteCoproduct.ι X a) x) = (π a) x
-- CompHaus.toProfinite_obj'
theorem CompHaus.toProfinite_obj' (X : CompHaus) :
    ↥(CompHaus.toProfinite.obj X) = ConnectedComponents X 
Arguments: (X : CompHaus)
Goal: ↑(CompHaus.toProfinite.obj X).toTop = ConnectedComponents ↑X.toTop
-- FintypeCat.discreteTopology
theorem FintypeCat.discreteTopology (A : FintypeCat) : DiscreteTopology A 
Arguments: (A : FintypeCat)
Goal: DiscreteTopology ↑A
-- FintypeCat.toProfinite_obj
@[simps]
def FintypeCat.toProfinite : FintypeCat ⥤ Profinite 
Arguments: (A : FintypeCat)
Goal: FintypeCat.toProfinite.obj A = Profinite.of ↑A
-- FintypeCat.toProfinite_map_apply
@[simps]
def FintypeCat.toProfinite : FintypeCat ⥤ Profinite 
Goal: ∀ {X Y : FintypeCat} (f : X ⟶ Y) (a : ↑X), (FintypeCat.toProfinite.map f) a = f a
-- Profinite.epi_iff_surjective
theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f 
Arguments: {X Y : Profinite} (f : X ⟶ Y)
Goal: CategoryTheory.Epi f ↔ Function.Surjective ⇑f
-- LightProfinite.closedEmbedding_natUnionInftyEmbedding
lemma closedEmbedding_natUnionInftyEmbedding : ClosedEmbedding natUnionInftyEmbedding 
Goal: ClosedEmbedding ⇑LightProfinite.natUnionInftyEmbedding
-- LightProfinite.continuous_iff_convergent
lemma continuous_iff_convergent {Y : Type*} [TopologicalSpace Y] (f : ℕ∪{∞} → Y) :
    Continuous f ↔ Tendsto (fun x : ℕ ↦ f x) atTop (𝓝 (f ∞)) 
Arguments: {Y : Type u_1} [TopologicalSpace Y] (f : ↑LightProfinite.NatUnionInfty.toTop → Y)
Goal: Continuous f ↔ Filter.Tendsto (fun x => f (some x)) Filter.atTop (nhds (f ∞))
-- FinTopCat.coe_of
@[simp]
theorem coe_of (X : Type u) [Fintype X] [TopologicalSpace X] :
    (of X : Type u) = X 
Arguments: (X : Type u) [Fintype X] [TopologicalSpace X]
Goal: ↑(FinTopCat.of X).toTop = X
-- CompHausLike.preregular
theorem preregular [HasExplicitPullbacks P]
    (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Function.Surjective f) :
    Preregular (CompHausLike P) 
Arguments: {P : TopCat → Prop} [CompHausLike.HasExplicitPullbacks P] (hs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), CategoryTheory.EffectiveEpi f → Function.Surjective ⇑f)
Goal: CategoryTheory.Preregular (CompHausLike P)
-- CompHaus.toStonean_toTop
@[simps!]
def toStonean (X : CompHaus.{u}) [Projective X] :
    Stonean 
Arguments: (X : CompHaus) [CategoryTheory.Projective X]
Goal: X.toStonean.toTop = X.toTop
-- Stonean.epi_iff_surjective
lemma epi_iff_surjective {X Y : Stonean} (f : X ⟶ Y) :
    Epi f ↔ Function.Surjective f 
Arguments: {X Y : Stonean} (f : X ⟶ Y)
Goal: CategoryTheory.Epi f ↔ Function.Surjective ⇑f
-- CompHaus.lift_lifts
@[simp, reassoc]
lemma lift_lifts {X Y : CompHaus} {Z : Stonean} (e : Z.compHaus ⟶ Y) (f : X ⟶ Y) [Epi f] :
    lift e f ≫ f = e 
Arguments: {X Y : CompHaus} {Z : Stonean} (e : Z.compHaus ⟶ Y) (f : X ⟶ Y) [CategoryTheory.Epi f]
Goal: CompHaus.lift e f ≫ f = e
-- CompHaus.Gleason
lemma Gleason (X : CompHaus.{u}) :
    Projective X ↔ ExtremallyDisconnected X 
Arguments: (X : CompHaus)
Goal: CategoryTheory.Projective X ↔ ExtremallyDisconnected ↑X.toTop
-- Profinite.lift_lifts
@[simp, reassoc]
lemma lift_lifts {X Y : Profinite} {Z : Stonean} (e : Stonean.toProfinite.obj Z ⟶ Y) (f : X ⟶ Y)
    [Epi f] : lift e f ≫ f = e 
Arguments: {X Y : Profinite} {Z : Stonean} (e : Stonean.toProfinite.obj Z ⟶ Y) (f : X ⟶ Y) [CategoryTheory.Epi f]
Goal: Profinite.lift e f ≫ f = e
-- Profinite.projective_of_extrDisc
lemma projective_of_extrDisc {X : Profinite.{u}} (hX : ExtremallyDisconnected X) :
    Projective X 
Arguments: {X : Profinite} (hX : ExtremallyDisconnected ↑X.toTop)
Goal: CategoryTheory.Projective X
-- TopCat.isTopologicalBasis_cofiltered_limit
theorem isTopologicalBasis_cofiltered_limit (T : ∀ j, Set (Set (F.obj j)))
    (hT : ∀ j, IsTopologicalBasis (T j)) (univ : ∀ i : J, Set.univ ∈ T i)
    (inter : ∀ (i) (U1 U2 : Set (F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i)
    (compat : ∀ (i j : J) (f : i ⟶ j) (V : Set (F.obj j)) (_hV : V ∈ T j), F.map f ⁻¹' V ∈ T i) :
    IsTopologicalBasis
      {U : Set C.pt | ∃ (j : _) (V : Set (F.obj j)), V ∈ T j ∧ U = C.π.app j ⁻¹' V} 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.IsCofiltered J] (F : J ⥤ TopCat) (C : CategoryTheory.Limits.Cone F) (hC : CategoryTheory.Limits.IsLimit C) (T : (j : J) → Set (Set ↑(F.obj j))) (hT : ∀ (j : J), TopologicalSpace.IsTopologicalBasis (T j)) (univ : ∀ (i : J), Set.univ ∈ T i) (inter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ U2 ∈ T i) (compat : ∀ (i j : J) (f : i ⟶ j), ∀ V ∈ T j, ⇑(F.map f) ⁻¹' V ∈ T i)
Goal: TopologicalSpace.IsTopologicalBasis {U | ∃ j, ∃ V ∈ T j, U = ⇑(C.π.app j) ⁻¹' V}