awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
d : ℕ
x : SimplexCategoryᵒᵖ
n : ℕ
c₁ : Cell i d
f₁ : ⦋n⦌ ⟶ ⦋d⦌
w : Epi f₁
hx₁ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
c₂ : Cell i d
f₂ : ⦋n⦌ ⟶ ⦋d⦌
w_1 : Epi f₂
hx₂ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₂.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₂ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
h :
  Eq.{u + 1} (α := Y _⦋n⦌)
    (↑((ConcreteCategory.hom (FC := TypeCat.Fun) ((b i d).app (op ⦋n⦌)) :
            (a : sigmaStdSimplex i d _⦋n⦌) →
              (↑(((skeletonOfMono i : (a : ℕ) → Y.Subcomplex) (d + 1)).obj (op ⦋n⦌)) : Type u))
          ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
              (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
            ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌))) :
      Y _⦋n⦌)
    (↑((ConcreteCategory.hom (FC := TypeCat.Fun) ((b i d).app (op ⦋n⦌)) :
            (a : sigmaStdSimplex i d _⦋n⦌) →
              (↑(((skeletonOfMono i : (a : ℕ) → Y.Subcomplex) (d + 1)).obj (op ⦋n⦌)) : Type u))
          ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₂.ιSigmaStdSimplex.app (op ⦋n⦌)) :
              (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
            ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₂ : Δ[d] _⦋n⦌))) :
      Y _⦋n⦌)
⊢ Eq (α := (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₁.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₂.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₂.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))

Tactic:
replace h : Y.map f₁.op c₁.simplex = Y.map f₂.op c₂.simplex := by
        rwa [← c₁.b_app_ι_app_objEquiv_symm_val f₁, ← c₂.b_app_ι_app_objEquiv_symm_val f₂]
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
d : ℕ
x : SimplexCategoryᵒᵖ
n : ℕ
c₁ : Cell i d
f₁ : ⦋n⦌ ⟶ ⦋d⦌
w : Epi f₁
hx₁ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
c₂ : Cell i d
f₂ : ⦋n⦌ ⟶ ⦋d⦌
w_1 : Epi f₂
hx₂ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₂.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₂ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
h :
  Eq (α := (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₁.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₂.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₂.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
simplex : c₁.simplex = c₂.simplex
⊢ c₁ = c₂

Tactic:
ext
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
d : ℕ
x : SimplexCategoryᵒᵖ
n : ℕ
c₁ : Cell i d
f₁ : ⦋n⦌ ⟶ ⦋d⦌
w : Epi f₁
hx₁ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
c₂ : Cell i d
f₂ : ⦋n⦌ ⟶ ⦋d⦌
w_1 : Epi f₂
hx₂ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₂.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₂ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
h :
  Eq (α := (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₁.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₂.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₂.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
⊢ c₁.simplex = c₂.simplex

Tactic:
Subtype.ext_iff.mp
          (Y.unique_nonDegenerate_simplex _ f₁ ⟨_, c₁.nonDegenerate⟩ rfl
            f₂ ⟨_, c₂.nonDegenerate⟩ h)

Premises used: SSet.unique_nonDegenerate_simplex, Subtype.ext_iff, Subtype.mk, SSet.relativeCellComplexOfMono.Cell.nonDegenerate, Iff.mp, rfl
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
d : ℕ
x : SimplexCategoryᵒᵖ
n : ℕ
c₁ : Cell i d
f₁ : ⦋n⦌ ⟶ ⦋d⦌
w : Epi f₁
hx₁ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
c₂ : Cell i d
f₂ : ⦋n⦌ ⟶ ⦋d⦌
w_1 : Epi f₂
hx₂ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₂.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₂ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
h :
  Eq (α := (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₁.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₂.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₂.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
⊢ c₁.simplex = c₂.simplex

Tactic:
exact Subtype.ext_iff.mp
          (Y.unique_nonDegenerate_simplex _ f₁ ⟨_, c₁.nonDegenerate⟩ rfl
            f₂ ⟨_, c₂.nonDegenerate⟩ h)

Premises used: SSet.unique_nonDegenerate_simplex, Subtype.ext_iff, Subtype.mk, SSet.relativeCellComplexOfMono.Cell.nonDegenerate, Iff.mp, rfl
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
d : ℕ
x : SimplexCategoryᵒᵖ
n : ℕ
c₁ : Cell i d
f₁ : ⦋n⦌ ⟶ ⦋d⦌
w : Epi f₁
hx₁ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
f₂ : ⦋n⦌ ⟶ ⦋d⦌
w_1 : Epi f₂
hx₂ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₂ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
h :
  Eq (α := (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₁.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₂.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
⊢ f₁ = f₂

Tactic:
Y.unique_nonDegenerate_map _ f₁ ⟨_, c₁.nonDegenerate⟩ rfl
          f₂ ⟨_, c₁.nonDegenerate⟩ h

Premises used: Subtype.mk, SSet.relativeCellComplexOfMono.Cell.nonDegenerate, SSet.unique_nonDegenerate_map, rfl
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
d : ℕ
x : SimplexCategoryᵒᵖ
n : ℕ
c₁ : Cell i d
f₁ : ⦋n⦌ ⟶ ⦋d⦌
w : Epi f₁
hx₁ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
w_1 : Epi f₁
hx₂ :
  ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌)) ∉
    Set.range (ι := sigmaBoundary i d _⦋n⦌)
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) ((l i d).app (op ⦋n⦌))) :
        (a : sigmaBoundary i d _⦋n⦌) → sigmaStdSimplex i d _⦋n⦌)
h :
  Eq (α := (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₁.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (Y.map f₁.op) :
          (a : (fun (X : Type u) ↦ X) (Y _⦋d⦌)) → (fun (X : Type u) ↦ X) (Y _⦋n⦌))
        c₁.simplex :
      (fun (X : Type u) ↦ X) (Y _⦋n⦌))
⊢ Eq (α := sigmaStdSimplex i d _⦋n⦌)
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (c₁.ιSigmaStdSimplex.app (op ⦋n⦌)) :
          (a : (fun (X : Type u) ↦ X) (Δ[d] _⦋n⦌)) → (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))
        ((Equiv.symm stdSimplex.objEquiv : (a : unop (op ⦋n⦌) ⟶ ⦋d⦌) → Δ[d] _⦋n⦌) f₁ : Δ[d] _⦋n⦌) :
      (fun (X : Type u) ↦ X) (sigmaStdSimplex i d _⦋n⦌))

Tactic:
rfl
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
inst : Mono i
⊢ ⋯.functor.obj ⊥ = Subcomplex.range i

Tactic:
simp
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
s : X.N
⊢ ¬IsMax s.dim

Tactic:
simp
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Skeleton
Goal:
X Y : SSet
i : X ⟶ Y
s : X.N
⊢ s.simplex ∉
    Set.range (ι := (fun (X : Type u) ↦ X) (Subcomplex.toSSet (X := X) ⊥ _⦋s.dim⦌))
      (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) (NatTrans.app (Subcomplex.ι ⊥) (op ⦋s.dim⦌))) :
        (a : (fun (X : Type u) ↦ X) (⊥.toSSet _⦋s.dim⦌)) → (fun (X : Type u) ↦ X) (X _⦋s.dim⦌))

Tactic:
simp
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Splitting
Goal:
X : SSet
x : SimplexCategoryᵒᵖ
n : ℕ
rw :
  Functor.CoconeTypes.IsColimit (J := Discrete (SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌))) (F :=
    Discrete.functor
      (SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌)))
    (Cofan.cofanTypes (F :=
      SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
      (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
        (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))
⊢ Nonempty.{u + 2}
    (IsColimit (J := Discrete (SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌))) (F :=
      Discrete.functor
        (SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌)))
      (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
        (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))

Tactic:
rw [← Limits.Cofan.isColimit_cofanTypes_iff]

Premises used: CategoryTheory.Limits.Cofan.isColimit_cofanTypes_iff
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Splitting
Goal:
X : SSet
x : SimplexCategoryᵒᵖ
n : ℕ
⊢ Functor.CoconeTypes.IsColimit (J := Discrete (SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌))) (F :=
    Discrete.functor
      (SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌)))
    (Cofan.cofanTypes (F :=
      SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
      (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
        (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))

Tactic:
CofanTypes.isColimit_mk _ (fun x ↦ ?_) (fun ⟨⟨⟨m⟩⟩, f, _⟩ x y h ↦ ?_)
      (fun ⟨⟨⟨m⟩⟩, f, _⟩ ⟨⟨⟨p⟩⟩, g, _⟩ x y h ↦ ?_)

Premises used: CategoryTheory.Limits.CofanTypes.isColimit_mk, _private.0.SSet.splitting.match_3, _private.0.SSet.splitting.match_2, Subtype.mk, SimplexCategory.mk, Opposite.op, Sigma.mk, Eq, _private.0.SSet.splitting.match_4
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Splitting
Goal:
X : SSet
x_1 : SimplexCategoryᵒᵖ
n : ℕ
x :
  Functor.CoconeTypes.pt (J := Discrete (SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌))) (F :=
    Discrete.functor
      (SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌)))
    (Cofan.cofanTypes (F :=
      SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
      (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
        (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))
refine_1 :
  ∀ (m : ℕ) (f : ⦋n⦌ ⟶ ⦋m⦌),
    Epi f →
      ∀ (y : (↑(X.nonDegenerate m) : Type u)),
        ∃ (i : SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌)) (y_1 :
          SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌) i),
          Eq (α :=
            Functor.CoconeTypes.pt (J := Discrete (SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌))) (F :=
              Discrete.functor
                (SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌)))
              (Cofan.cofanTypes (F :=
                SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
                (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
                  (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌))))
            (CofanTypes.inj (F :=
              SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
              (Cofan.cofanTypes (F :=
                SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
                (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
                  (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))
              i y_1)
            ((ConcreteCategory.hom (FC := Fun) (X.map f.op) :
                (a : (fun (X : Type u) ↦ X) (X _⦋m⦌)) → (fun (X : Type u) ↦ X) (X _⦋n⦌))
              (↑y : X _⦋m⦌))
⊢ ∃ (i : SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌)) (y :
    SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌) i),
    CofanTypes.inj (F :=
        SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
        (Cofan.cofanTypes (F :=
          SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
          (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
            (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))
        i y =
      x

Tactic:
obtain ⟨m, f, _, y, rfl⟩ := X.exists_nonDegenerate x

Premises used: SSet.exists_nonDegenerate, rfl
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Splitting
Goal:
X : SSet
x : SimplexCategoryᵒᵖ
n m : ℕ
f : ⦋n⦌ ⟶ ⦋m⦌
w : Epi f
y : (↑(X.nonDegenerate m) : Type u)
⊢ ∃ (i : SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌)) (y_1 :
    SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌) i),
    Eq (α :=
      Functor.CoconeTypes.pt (J := Discrete (SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌))) (F :=
        Discrete.functor
          (SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌)))
        (Cofan.cofanTypes (F :=
          SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
          (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
            (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌))))
      (CofanTypes.inj (F :=
        SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
        (Cofan.cofanTypes (F :=
          SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
          (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
            (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))
        i y_1)
      ((ConcreteCategory.hom (FC := Fun) (X.map f.op) :
          (a : (fun (X : Type u) ↦ X) (X _⦋m⦌)) → (fun (X : Type u) ↦ X) (X _⦋n⦌))
        (↑y : X _⦋m⦌))

Tactic:
⟨.mk f, y, rfl⟩

Premises used: CategoryTheory.SimplicialObject.Splitting.IndexSet.mk, Exists.intro, rfl
-- Module: Mathlib.AlgebraicTopology.SimplicialSet.Splitting
Goal:
X : SSet
x : SimplexCategoryᵒᵖ
n m : ℕ
f : ⦋n⦌ ⟶ ⦋m⦌
w : Epi f
y : (↑(X.nonDegenerate m) : Type u)
⊢ ∃ (i : SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌)) (y_1 :
    SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌) i),
    Eq (α :=
      Functor.CoconeTypes.pt (J := Discrete (SimplicialObject.Splitting.IndexSet (Opposite.op ⦋n⦌))) (F :=
        Discrete.functor
          (SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌)))
        (Cofan.cofanTypes (F :=
          SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
          (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
            (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌))))
      (CofanTypes.inj (F :=
        SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
        (Cofan.cofanTypes (F :=
          SimplicialObject.Splitting.summand (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) (Opposite.op ⦋n⦌))
          (SimplicialObject.Splitting.cofan' (fun (n : ℕ) ↦ (↑(X.nonDegenerate n) : Type u)) X
            (fun (n : ℕ) ↦ ↾Subtype.val (p := fun (x : X _⦋n⦌) ↦ x ∈ X.nonDegenerate n)) (Opposite.op ⦋n⦌)))
        i y_1)
      ((ConcreteCategory.hom (FC := Fun) (X.map f.op) :
          (a : (fun (X : Type u) ↦ X) (X _⦋m⦌)) → (fun (X : Type u) ↦ X) (X _⦋n⦌))
        (↑y : X _⦋m⦌))

Tactic:
exact ⟨.mk f, y, rfl⟩