l3lab/ntp-mathlib huggingface dataset:
theorem zipWith_neLocus_eq_right [DecidableEq M] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f₁ f₂ : α →₀ M) (g : α →₀ N)
    (hF : ∀ g, Function.Injective fun f => F f g) :
    (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂ := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq M
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f₁ f₂ : α →₀ M
g : α →₀ N
hF : ∀ (g : N), Function.Injective fun f => F f g
⊢ neLocus (zipWith F F0 f₁ g) (zipWith F F0 f₂ g) = neLocus f₁ f₂

Next tactic:
ext
theorem zipWith_neLocus_eq_right [DecidableEq M] [Zero M] [DecidableEq P] [Zero P] [Zero N]
    {F : M → N → P} (F0 : F 0 0 = 0) (f₁ f₂ : α →₀ M) (g : α →₀ N)
    (hF : ∀ g, Function.Injective fun f => F f g) :
    (zipWith F F0 f₁ g).neLocus (zipWith F F0 f₂ g) = f₁.neLocus f₂ := by
  ext
  

Proof state:
case a
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq M
inst✝³ : Zero M
inst✝² : DecidableEq P
inst✝¹ : Zero P
inst✝ : Zero N
F : M → N → P
F0 : F 0 0 = 0
f₁ f₂ : α →₀ M
g : α →₀ N
hF : ∀ (g : N), Function.Injective fun f => F f g
a✝ : α
⊢ a✝ ∈ neLocus (zipWith F F0 f₁ g) (zipWith F F0 f₂ g) ↔ a✝ ∈ neLocus f₁ f₂

Next tactic:
simpa only [mem_neLocus] using (hF _).ne_iff
theorem mapRange_neLocus_eq [DecidableEq N] [DecidableEq M] [Zero M] [Zero N] (f g : α →₀ N)
    {F : N → M} (F0 : F 0 = 0) (hF : Function.Injective F) :
    (f.mapRange F F0).neLocus (g.mapRange F F0) = f.neLocus g := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq N
inst✝² : DecidableEq M
inst✝¹ : Zero M
inst✝ : Zero N
f g : α →₀ N
F : N → M
F0 : F 0 = 0
hF : Function.Injective F
⊢ neLocus (mapRange F F0 f) (mapRange F F0 g) = neLocus f g

Next tactic:
ext
theorem mapRange_neLocus_eq [DecidableEq N] [DecidableEq M] [Zero M] [Zero N] (f g : α →₀ N)
    {F : N → M} (F0 : F 0 = 0) (hF : Function.Injective F) :
    (f.mapRange F F0).neLocus (g.mapRange F F0) = f.neLocus g := by
  ext
  

Proof state:
case a
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq N
inst✝² : DecidableEq M
inst✝¹ : Zero M
inst✝ : Zero N
f g : α →₀ N
F : N → M
F0 : F 0 = 0
hF : Function.Injective F
a✝ : α
⊢ a✝ ∈ neLocus (mapRange F F0 f) (mapRange F F0 g) ↔ a✝ ∈ neLocus f g

Next tactic:
simpa only [mem_neLocus] using hF.ne_iff
theorem neLocus_neg : neLocus (-f) g = f.neLocus (-g) := by 

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus (-f) g = neLocus f (-g)

Next tactic:
rw [← neLocus_neg_neg, neg_neg]
theorem neLocus_eq_support_sub : f.neLocus g = (f - g).support := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus f g = (f - g).support

Next tactic:
rw [← neLocus_add_right _ _ (-g), add_right_neg, neLocus_zero_right, sub_eq_add_neg]
@[simp]
theorem neLocus_sub_left : neLocus (f - g₁) (f - g₂) = neLocus g₁ g₂ := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus (f - g₁) (f - g₂) = neLocus g₁ g₂

Next tactic:
simp only [sub_eq_add_neg, neLocus_add_left, neLocus_neg_neg]
@[simp]
theorem neLocus_sub_right : neLocus (f₁ - g) (f₂ - g) = neLocus f₁ f₂ := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus (f₁ - g) (f₂ - g) = neLocus f₁ f₂

Next tactic:
simpa only [sub_eq_add_neg] using neLocus_add_right _ _ _
@[simp]
theorem neLocus_self_add_right : neLocus f (f + g) = g.support := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus f (f + g) = g.support

Next tactic:
rw [← neLocus_zero_left, ← neLocus_add_left f 0 g, add_zero]
@[simp]
theorem neLocus_self_add_left : neLocus (f + g) f = g.support := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus (f + g) f = g.support

Next tactic:
rw [neLocus_comm, neLocus_self_add_right]
@[simp]
theorem neLocus_self_sub_right : neLocus f (f - g) = g.support := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus f (f - g) = g.support

Next tactic:
rw [sub_eq_add_neg, neLocus_self_add_right, support_neg]
@[simp]
theorem neLocus_self_sub_left : neLocus (f - g) f = g.support := by
  

Proof state:
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus (f - g) f = g.support

Next tactic:
rw [neLocus_comm, neLocus_self_sub_right]
protected theorem Decidable.exists_ne [Nontrivial α] [DecidableEq α] (x : α) : ∃ y, y ≠ x := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : Nontrivial α
inst✝ : DecidableEq α
x : α
⊢ ∃ y, y ≠ x

Next tactic:
rcases exists_pair_ne α with ⟨y, y', h⟩
protected theorem Decidable.exists_ne [Nontrivial α] [DecidableEq α] (x : α) : ∃ y, y ≠ x := by
  rcases exists_pair_ne α with ⟨y, y', h⟩
  

Proof state:
case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : Nontrivial α
inst✝ : DecidableEq α
x y y' : α
h : y ≠ y'
⊢ ∃ y, y ≠ x

Next tactic:
by_cases hx:x = y
protected theorem Decidable.exists_ne [Nontrivial α] [DecidableEq α] (x : α) : ∃ y, y ≠ x := by
  rcases exists_pair_ne α with ⟨y, y', h⟩
  by_cases hx:x = y
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝¹ : Nontrivial α
inst✝ : DecidableEq α
x y y' : α
h : y ≠ y'
hx : x = y
⊢ ∃ y, y ≠ x

Next tactic:
rw [← hx] at h
protected theorem Decidable.exists_ne [Nontrivial α] [DecidableEq α] (x : α) : ∃ y, y ≠ x := by
  rcases exists_pair_ne α with ⟨y, y', h⟩
  by_cases hx:x = y
  · rw [← hx] at h
    

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝¹ : Nontrivial α
inst✝ : DecidableEq α
x y y' : α
h : x ≠ y'
hx : x = y
⊢ ∃ y, y ≠ x

Next tactic:
exact ⟨y', h.symm⟩
protected theorem Decidable.exists_ne [Nontrivial α] [DecidableEq α] (x : α) : ∃ y, y ≠ x := by
  rcases exists_pair_ne α with ⟨y, y', h⟩
  by_cases hx:x = y
  · rw [← hx] at h
    exact ⟨y', h.symm⟩
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝¹ : Nontrivial α
inst✝ : DecidableEq α
x y y' : α
h : y ≠ y'
hx : ¬x = y
⊢ ∃ y, y ≠ x

Next tactic:
exact ⟨y, Ne.symm hx⟩
theorem subsingleton_iff : Subsingleton α ↔ ∀ x y : α, x = y :=
  ⟨by
    

Proof state:
α : Type u_1
β : Type u_2
⊢ Subsingleton α → ∀ (x y : α), x = y

Next tactic:
intro h
theorem subsingleton_iff : Subsingleton α ↔ ∀ x y : α, x = y :=
  ⟨by
    intro h
    

Proof state:
α : Type u_1
β : Type u_2
h : Subsingleton α
⊢ ∀ (x y : α), x = y

Next tactic:
exact Subsingleton.elim
theorem not_nontrivial_iff_subsingleton : ¬Nontrivial α ↔ Subsingleton α := by
  

Proof state:
α : Type u_1
β : Type u_2
⊢ ¬Nontrivial α ↔ Subsingleton α

Next tactic:
simp only [nontrivial_iff, subsingleton_iff, not_exists, Ne.def, not_not]
lemma not_subsingleton_iff_nontrivial : ¬ Subsingleton α ↔ Nontrivial α := by
  

Proof state:
α : Type u_1
β : Type u_2
⊢ ¬Subsingleton α ↔ Nontrivial α

Next tactic:
rw [← not_nontrivial_iff_subsingleton, not_not]
/-- A type is either a subsingleton or nontrivial. -/
theorem subsingleton_or_nontrivial (α : Type*) : Subsingleton α ∨ Nontrivial α := by
  

Proof state:
α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ Subsingleton α ∨ Nontrivial α

Next tactic:
rw [← not_nontrivial_iff_subsingleton, or_comm]
/-- A type is either a subsingleton or nontrivial. -/
theorem subsingleton_or_nontrivial (α : Type*) : Subsingleton α ∨ Nontrivial α := by
  rw [← not_nontrivial_iff_subsingleton, or_comm]
  

Proof state:
α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ Nontrivial α ∨ ¬Nontrivial α

Next tactic:
exact Classical.em _
/-- Pullback a `Nontrivial` instance along a surjective function. -/
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
⊢ Nontrivial α

Next tactic:
rcases exists_pair_ne β with ⟨x, y, h⟩
/-- Pullback a `Nontrivial` instance along a surjective function. -/
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α := by
  rcases exists_pair_ne β with ⟨x, y, h⟩
  

Proof state:
case intro.intro
α : Type u_1
β : Type u_2
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
⊢ Nontrivial α

Next tactic:
rcases hf x with ⟨x', hx'⟩
/-- Pullback a `Nontrivial` instance along a surjective function. -/
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α := by
  rcases exists_pair_ne β with ⟨x, y, h⟩
  rcases hf x with ⟨x', hx'⟩
  

Proof state:
case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
⊢ Nontrivial α

Next tactic:
rcases hf y with ⟨y', hy'⟩
/-- Pullback a `Nontrivial` instance along a surjective function. -/
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α := by
  rcases exists_pair_ne β with ⟨x, y, h⟩
  rcases hf x with ⟨x', hx'⟩
  rcases hf y with ⟨y', hy'⟩
  

Proof state:
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
⊢ Nontrivial α

Next tactic:
have : x' ≠ y' := by
    refine fun H ↦ h ?_
    rw [← hx', ← hy', H]
/-- Pullback a `Nontrivial` instance along a surjective function. -/
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α := by
  rcases exists_pair_ne β with ⟨x, y, h⟩
  rcases hf x with ⟨x', hx'⟩
  rcases hf y with ⟨y', hy'⟩
  have : x' ≠ y' := by
    

Proof state:
α : Type u_1
β : Type u_2
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
⊢ x' ≠ y'

Next tactic:
refine fun H ↦ h ?_
/-- Pullback a `Nontrivial` instance along a surjective function. -/
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α := by
  rcases exists_pair_ne β with ⟨x, y, h⟩
  rcases hf x with ⟨x', hx'⟩
  rcases hf y with ⟨y', hy'⟩
  have : x' ≠ y' := by
    refine fun H ↦ h ?_
    

Proof state:
α : Type u_1
β : Type u_2
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
H : x' = y'
⊢ x = y

Next tactic:
rw [← hx', ← hy', H]
/-- Pullback a `Nontrivial` instance along a surjective function. -/
protected theorem Function.Surjective.nontrivial [Nontrivial β] {f : α → β}
    (hf : Function.Surjective f) : Nontrivial α := by
  rcases exists_pair_ne β with ⟨x, y, h⟩
  rcases hf x with ⟨x', hx'⟩
  rcases hf y with ⟨y', hy'⟩
  have : x' ≠ y' := by
    refine fun H ↦ h ?_
    rw [← hx', ← hy', H]
  

Proof state:
case intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : Nontrivial β
f : α → β
hf : Surjective f
x y : β
h : x ≠ y
x' : α
hx' : f x' = x
y' : α
hy' : f y' = y
this : x' ≠ y'
⊢ Nontrivial α

Next tactic:
exact ⟨⟨x', y', this⟩⟩
instance finBicone [Fintype J] : Fintype (Bicone J)
    where
  elems := [Bicone.left, Bicone.right].toFinset ∪ Finset.image Bicone.diagram Fintype.elems
  complete j := by
    

Proof state:
J : Type u₁
inst✝ : Fintype J
j : Bicone J
⊢ j ∈ List.toFinset [Bicone.left, Bicone.right] ∪ Finset.image Bicone.diagram Fintype.elems

Next tactic:
cases j
instance finBicone [Fintype J] : Fintype (Bicone J)
    where
  elems := [Bicone.left, Bicone.right].toFinset ∪ Finset.image Bicone.diagram Fintype.elems
  complete j := by
    cases j <;> 

Proof state:
case left
J : Type u₁
inst✝ : Fintype J
⊢ Bicone.left ∈ List.toFinset [Bicone.left, Bicone.right] ∪ Finset.image Bicone.diagram Fintype.elems

Next tactic:
simp
instance finBicone [Fintype J] : Fintype (Bicone J)
    where
  elems := [Bicone.left, Bicone.right].toFinset ∪ Finset.image Bicone.diagram Fintype.elems
  complete j := by
    cases j <;> 

Proof state:
case right
J : Type u₁
inst✝ : Fintype J
⊢ Bicone.right ∈ List.toFinset [Bicone.left, Bicone.right] ∪ Finset.image Bicone.diagram Fintype.elems

Next tactic:
simp
instance finBicone [Fintype J] : Fintype (Bicone J)
    where
  elems := [Bicone.left, Bicone.right].toFinset ∪ Finset.image Bicone.diagram Fintype.elems
  complete j := by
    cases j <;> 

Proof state:
case diagram
J : Type u₁
inst✝ : Fintype J
val✝ : J
⊢ Bicone.diagram val✝ ∈ List.toFinset [Bicone.left, Bicone.right] ∪ Finset.image Bicone.diagram Fintype.elems

Next tactic:
simp
instance finBicone [Fintype J] : Fintype (Bicone J)
    where
  elems := [Bicone.left, Bicone.right].toFinset ∪ Finset.image Bicone.diagram Fintype.elems
  complete j := by
    cases j <;> simp
    

Proof state:
case diagram
J : Type u₁
inst✝ : Fintype J
val✝ : J
⊢ val✝ ∈ Fintype.elems

Next tactic:
apply Fintype.complete
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  

Proof state:
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j k : Bicone J
f g : BiconeHom J j k
⊢ Decidable (f = g)

Next tactic:
cases f
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> 

Proof state:
case left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
g : BiconeHom J Bicone.left Bicone.left
⊢ Decidable (left_id = g)

Next tactic:
cases g
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> 

Proof state:
case right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
g : BiconeHom J Bicone.right Bicone.right
⊢ Decidable (right_id = g)

Next tactic:
cases g
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> 

Proof state:
case left
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
g : BiconeHom J Bicone.left (Bicone.diagram j✝)
⊢ Decidable (left j✝ = g)

Next tactic:
cases g
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> 

Proof state:
case right
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
g : BiconeHom J Bicone.right (Bicone.diagram j✝)
⊢ Decidable (right j✝ = g)

Next tactic:
cases g
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> 

Proof state:
case diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ k✝ : J
f✝ : j✝ ⟶ k✝
g : BiconeHom J (Bicone.diagram j✝) (Bicone.diagram k✝)
⊢ Decidable (diagram f✝ = g)

Next tactic:
cases g
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> 

Proof state:
case left_id.left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ Decidable (left_id = left_id)

Next tactic:
simp
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> 

Proof state:
case right_id.right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ Decidable (right_id = right_id)

Next tactic:
simp
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> 

Proof state:
case left.left
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
⊢ Decidable (left j✝ = left j✝)

Next tactic:
simp
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> 

Proof state:
case right.right
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
⊢ Decidable (right j✝ = right j✝)

Next tactic:
simp
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> 

Proof state:
case diagram.diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ k✝ : J
f✝¹ f✝ : j✝ ⟶ k✝
⊢ Decidable (diagram f✝¹ = diagram f✝)

Next tactic:
simp
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> simp <;> 

Proof state:
case left_id.left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ Decidable True

Next tactic:
infer_instance
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> simp <;> 

Proof state:
case right_id.right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ Decidable True

Next tactic:
infer_instance
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> simp <;> 

Proof state:
case left.left
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
⊢ Decidable True

Next tactic:
infer_instance
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> simp <;> 

Proof state:
case right.right
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
⊢ Decidable True

Next tactic:
infer_instance
instance BiconeHom.decidableEq {j k : Bicone J} : DecidableEq (BiconeHom J j k) := fun f g => by
  cases f <;> cases g <;> simp <;> 

Proof state:
case diagram.diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ k✝ : J
f✝¹ f✝ : j✝ ⟶ k✝
⊢ Decidable (f✝¹ = f✝)

Next tactic:
infer_instance
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    

Proof state:
J : Type u₁
inst✝ : Category.{v₁, u₁} J
X✝ Y✝ Z✝ : Bicone J
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ X✝ ⟶ Z✝

Next tactic:
rcases f with (_ | _ | _ | _ | f)
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · 

Proof state:
case left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
g : Bicone.left ⟶ Z✝
⊢ Bicone.left ⟶ Z✝

Next tactic:
exact g
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · exact g
    · 

Proof state:
case right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
g : Bicone.right ⟶ Z✝
⊢ Bicone.right ⟶ Z✝

Next tactic:
exact g
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · exact g
    · exact g
    · 

Proof state:
case left
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ Bicone.left ⟶ Z✝

Next tactic:
cases g
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · exact g
    · exact g
    · cases g
      

Proof state:
case left.diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ k✝ : J
f✝ : j✝ ⟶ k✝
⊢ Bicone.left ⟶ Bicone.diagram k✝

Next tactic:
apply BiconeHom.left
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · exact g
    · exact g
    · cases g
      apply BiconeHom.left
    · 

Proof state:
case right
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ Bicone.right ⟶ Z✝

Next tactic:
cases g
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · exact g
    · exact g
    · cases g
      apply BiconeHom.left
    · cases g
      

Proof state:
case right.diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ k✝ : J
f✝ : j✝ ⟶ k✝
⊢ Bicone.right ⟶ Bicone.diagram k✝

Next tactic:
apply BiconeHom.right
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · exact g
    · exact g
    · cases g
      apply BiconeHom.left
    · cases g
      apply BiconeHom.right
    · 

Proof state:
case diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ k✝ : J
f : j✝ ⟶ k✝
g : Bicone.diagram k✝ ⟶ Z✝
⊢ Bicone.diagram j✝ ⟶ Z✝

Next tactic:
rcases g with (_|_|_|_|g)
@[simps]
instance biconeCategoryStruct : CategoryStruct (Bicone J)
    where
  Hom := BiconeHom J
  id j := Bicone.casesOn j BiconeHom.left_id BiconeHom.right_id fun k => BiconeHom.diagram (𝟙 k)
  comp f g := by
    rcases f with (_ | _ | _ | _ | f)
    · exact g
    · exact g
    · cases g
      apply BiconeHom.left
    · cases g
      apply BiconeHom.right
    · rcases g with (_|_|_|_|g)
      

Proof state:
case diagram.diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ k✝¹ : J
f : j✝ ⟶ k✝¹
k✝ : J
g : k✝¹ ⟶ k✝
⊢ Bicone.diagram j✝ ⟶ Bicone.diagram k✝

Next tactic:
exact BiconeHom.diagram (f ≫ g)
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by 

Proof state:
J : Type u₁
inst✝ : Category.{v₁, u₁} J
X✝ Y✝ : Bicone J
f : X✝ ⟶ Y✝
⊢ 𝟙 X✝ ≫ f = f

Next tactic:
cases f
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> 

Proof state:
case left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ 𝟙 Bicone.left ≫ BiconeHom.left_id = BiconeHom.left_id

Next tactic:
simp
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> 

Proof state:
case right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ 𝟙 Bicone.right ≫ BiconeHom.right_id = BiconeHom.right_id

Next tactic:
simp
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> 

Proof state:
case left
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
⊢ 𝟙 Bicone.left ≫ BiconeHom.left j✝ = BiconeHom.left j✝

Next tactic:
simp
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> 

Proof state:
case right
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ : J
⊢ 𝟙 Bicone.right ≫ BiconeHom.right j✝ = BiconeHom.right j✝

Next tactic:
simp
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> 

Proof state:
case diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
j✝ k✝ : J
f✝ : j✝ ⟶ k✝
⊢ 𝟙 (Bicone.diagram j✝) ≫ BiconeHom.diagram f✝ = BiconeHom.diagram f✝

Next tactic:
simp
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> simp
  comp_id f := by 

Proof state:
J : Type u₁
inst✝ : Category.{v₁, u₁} J
X✝ Y✝ : Bicone J
f : X✝ ⟶ Y✝
⊢ f ≫ 𝟙 Y✝ = f

Next tactic:
cases f
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> simp
  comp_id f := by cases f <;> 

Proof state:
case left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ BiconeHom.left_id ≫ 𝟙 Bicone.left = BiconeHom.left_id

Next tactic:
simp
instance biconeCategory : Category (Bicone J)
    where
  id_comp f := by cases f <;> simp
  comp_id f := by cases f <;> 

Proof state:
case right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
⊢ BiconeHom.right_id ≫ 𝟙 Bicone.right = BiconeHom.right_id

Next tactic:
simp