l3lab/ntp-mathlib huggingface dataset:
theorem other_invol {a : α} {z : Sym2 α} (ha : a ∈ z) (hb : Mem.other ha ∈ z) : Mem.other hb = a :=
  by classical
    rw [other_eq_other'] at hb ⊢
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
ha : a ∈ z
hb✝ : Mem.other ha ∈ z
hb : Mem.other' ha ∈ z
⊢ Mem.other' hb✝ = a

Next tactic:
convert other_invol' ha hb using 2
theorem other_invol {a : α} {z : Sym2 α} (ha : a ∈ z) (hb : Mem.other ha ∈ z) : Mem.other hb = a :=
  by classical
    rw [other_eq_other'] at hb ⊢
    convert other_invol' ha hb using 2
    

Proof state:
case h.e'_2.h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
a : α
z : Sym2 α
ha : a ∈ z
hb✝ : Mem.other ha ∈ z
hb : Mem.other' ha ∈ z
⊢ Mem.other ha = Mem.other' ha

Next tactic:
apply other_eq_other'
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
⊢ filter IsDiag (image Quotient.mk'' (s ×ˢ s)) = image Quotient.mk'' (Finset.diag s)

Next tactic:
ext z
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  

Proof state:
case a
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
z : Sym2 α
⊢ z ∈ filter IsDiag (image Quotient.mk'' (s ×ˢ s)) ↔ z ∈ image Quotient.mk'' (Finset.diag s)

Next tactic:
induction' z using Sym2.inductionOn
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  

Proof state:
case a.hf
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ ⟦(x✝, y✝)⟧ ∈ filter IsDiag (image Quotient.mk'' (s ×ˢ s)) ↔ ⟦(x✝, y✝)⟧ ∈ image Quotient.mk'' (Finset.diag s)

Next tactic:
simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
  

Proof state:
case a.hf
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ IsDiag ⟦(x✝, y✝)⟧ ↔
    ∃ a b, (a ∈ s ∧ a = b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
constructor
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
  constructor
  · 

Proof state:
case a.hf.mp
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ IsDiag ⟦(x✝, y✝)⟧ →
    ∃ a b, (a ∈ s ∧ a = b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    

Proof state:
case a.hf.mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
hab : IsDiag ⟦(x✝, y✝)⟧
a b : α
h : ⟦(a, b)⟧ = ⟦(x✝, y✝)⟧
ha : a ∈ s
hb : b ∈ s
⊢ ∃ a b, (a ∈ s ∧ a = b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
rw [← h, Sym2.mk''_isDiag_iff] at hab
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    

Proof state:
case a.hf.mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ a b : α
hab : a = b
h : ⟦(a, b)⟧ = ⟦(x✝, y✝)⟧
ha : a ∈ s
hb : b ∈ s
⊢ ∃ a b, (a ∈ s ∧ a = b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
exact ⟨a, b, ⟨ha, hab⟩, h⟩
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    exact ⟨a, b, ⟨ha, hab⟩, h⟩
  · 

Proof state:
case a.hf.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ (∃ a b, (a ∈ s ∧ a = b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) →
    (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ IsDiag ⟦(x✝, y✝)⟧

Next tactic:
rintro ⟨a, b, ⟨ha, rfl⟩, h⟩
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    exact ⟨a, b, ⟨ha, hab⟩, h⟩
  · rintro ⟨a, b, ⟨ha, rfl⟩, h⟩
    

Proof state:
case a.hf.mpr.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ a : α
ha : a ∈ s
h : Quotient.mk'' (a, a) = ⟦(x✝, y✝)⟧
⊢ (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ IsDiag ⟦(x✝, y✝)⟧

Next tactic:
rw [← h]
theorem filter_image_quotient_mk''_isDiag [DecidableEq α] (s : Finset α) :
    ((s ×ˢ s).image Quotient.mk'').filter IsDiag = s.diag.image Quotient.mk'' := by
  ext z
  induction' z using Sym2.inductionOn
  simp only [mem_image, mem_diag, exists_prop, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    exact ⟨a, b, ⟨ha, hab⟩, h⟩
  · rintro ⟨a, b, ⟨ha, rfl⟩, h⟩
    rw [← h]
    

Proof state:
case a.hf.mpr.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ a : α
ha : a ∈ s
h : Quotient.mk'' (a, a) = ⟦(x✝, y✝)⟧
⊢ (∃ a_1 b, (a_1 ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a_1, b) = Quotient.mk'' (a, a)) ∧ IsDiag (Quotient.mk'' (a, a))

Next tactic:
exact ⟨⟨a, a, ⟨ha, ha⟩, rfl⟩, rfl⟩
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
⊢ filter (fun a => ¬IsDiag a) (image Quotient.mk'' (s ×ˢ s)) = image Quotient.mk'' (offDiag s)

Next tactic:
ext z
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  

Proof state:
case a
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
z : Sym2 α
⊢ z ∈ filter (fun a => ¬IsDiag a) (image Quotient.mk'' (s ×ˢ s)) ↔ z ∈ image Quotient.mk'' (offDiag s)

Next tactic:
induction z using Sym2.inductionOn
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  

Proof state:
case a.hf
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ ⟦(x✝, y✝)⟧ ∈ filter (fun a => ¬IsDiag a) (image Quotient.mk'' (s ×ˢ s)) ↔ ⟦(x✝, y✝)⟧ ∈ image Quotient.mk'' (offDiag s)

Next tactic:
simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
  

Proof state:
case a.hf
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ ¬IsDiag ⟦(x✝, y✝)⟧ ↔
    ∃ a b, (a ∈ s ∧ b ∈ s ∧ a ≠ b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
constructor
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
  constructor
  · 

Proof state:
case a.hf.mp
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ ¬IsDiag ⟦(x✝, y✝)⟧ →
    ∃ a b, (a ∈ s ∧ b ∈ s ∧ a ≠ b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    

Proof state:
case a.hf.mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
hab : ¬IsDiag ⟦(x✝, y✝)⟧
a b : α
h : ⟦(a, b)⟧ = ⟦(x✝, y✝)⟧
ha : a ∈ s
hb : b ∈ s
⊢ ∃ a b, (a ∈ s ∧ b ∈ s ∧ a ≠ b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
rw [← h, Sym2.mk''_isDiag_iff] at hab
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    

Proof state:
case a.hf.mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ a b : α
hab : ¬a = b
h : ⟦(a, b)⟧ = ⟦(x✝, y✝)⟧
ha : a ∈ s
hb : b ∈ s
⊢ ∃ a b, (a ∈ s ∧ b ∈ s ∧ a ≠ b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧

Next tactic:
exact ⟨a, b, ⟨ha, hb, hab⟩, h⟩
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    exact ⟨a, b, ⟨ha, hb, hab⟩, h⟩
  · 

Proof state:
case a.hf.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ : α
⊢ (∃ a b, (a ∈ s ∧ b ∈ s ∧ a ≠ b) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) →
    (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ ¬IsDiag ⟦(x✝, y✝)⟧

Next tactic:
rintro ⟨a, b, ⟨ha, hb, hab⟩, (h : Quotient.mk _ _ = _)⟩
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    exact ⟨a, b, ⟨ha, hb, hab⟩, h⟩
  · rintro ⟨a, b, ⟨ha, hb, hab⟩, (h : Quotient.mk _ _ = _)⟩
    

Proof state:
case a.hf.mpr.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ a b : α
h : ⟦(a, b)⟧ = ⟦(x✝, y✝)⟧
ha : a ∈ s
hb : b ∈ s
hab : a ≠ b
⊢ (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ ¬IsDiag ⟦(x✝, y✝)⟧

Next tactic:
rw [Ne.def, ← Sym2.mk''_isDiag_iff, h] at hab
theorem filter_image_quotient_mk''_not_isDiag [DecidableEq α] (s : Finset α) :
    (((s ×ˢ s).image Quotient.mk'').filter fun a : Sym2 α => ¬a.IsDiag) =
      s.offDiag.image Quotient.mk'' := by
  ext z
  induction z using Sym2.inductionOn
  simp only [mem_image, mem_offDiag, mem_filter, Prod.exists, mem_product]
  constructor
  · rintro ⟨⟨a, b, ⟨ha, hb⟩, (h : Quotient.mk _ _ = _)⟩, hab⟩
    rw [← h, Sym2.mk''_isDiag_iff] at hab
    exact ⟨a, b, ⟨ha, hb, hab⟩, h⟩
  · rintro ⟨a, b, ⟨ha, hb, hab⟩, (h : Quotient.mk _ _ = _)⟩
    rw [Ne.def, ← Sym2.mk''_isDiag_iff, h] at hab
    

Proof state:
case a.hf.mpr.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
s : Finset α
x✝ y✝ a b : α
h : ⟦(a, b)⟧ = ⟦(x✝, y✝)⟧
ha : a ∈ s
hb : b ∈ s
hab : ¬IsDiag ⟦(x✝, y✝)⟧
⊢ (∃ a b, (a ∈ s ∧ b ∈ s) ∧ Quotient.mk'' (a, b) = ⟦(x✝, y✝)⟧) ∧ ¬IsDiag ⟦(x✝, y✝)⟧

Next tactic:
exact ⟨⟨a, b, ⟨ha, hb⟩, h⟩, hab⟩
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> cases h <;> aesop_cat
  comp_id f := by 

Proof state:
J : Type w
X✝ Y✝ : WalkingParallelFamily J
f : X✝ ⟶ Y✝
⊢ f ≫ 𝟙 Y✝ = f

Next tactic:
cases f
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> cases h <;> aesop_cat
  comp_id f := by cases f <;> 

Proof state:
case id
J : Type w
X✝ : WalkingParallelFamily J
⊢ Hom.id X✝ ≫ 𝟙 X✝ = Hom.id X✝

Next tactic:
aesop_cat
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> cases h <;> aesop_cat
  comp_id f := by cases f <;> 

Proof state:
case line
J : Type w
x✝ : J
⊢ line x✝ ≫ 𝟙 one = line x✝

Next tactic:
aesop_cat
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by 

Proof state:
J : Type w
W✝ X✝ Y✝ Z✝ : WalkingParallelFamily J
f : W✝ ⟶ X✝
g : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
⊢ (f ≫ g) ≫ h = f ≫ g ≫ h

Next tactic:
cases f
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> 

Proof state:
case id
J : Type w
W✝ Y✝ Z✝ : WalkingParallelFamily J
h : Y✝ ⟶ Z✝
g : W✝ ⟶ Y✝
⊢ (Hom.id W✝ ≫ g) ≫ h = Hom.id W✝ ≫ g ≫ h

Next tactic:
cases g
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> 

Proof state:
case line
J : Type w
Y✝ Z✝ : WalkingParallelFamily J
h : Y✝ ⟶ Z✝
x✝ : J
g : one ⟶ Y✝
⊢ (line x✝ ≫ g) ≫ h = line x✝ ≫ g ≫ h

Next tactic:
cases g
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> 

Proof state:
case id.id
J : Type w
W✝ Z✝ : WalkingParallelFamily J
h : W✝ ⟶ Z✝
⊢ (Hom.id W✝ ≫ Hom.id W✝) ≫ h = Hom.id W✝ ≫ Hom.id W✝ ≫ h

Next tactic:
cases h
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> 

Proof state:
case id.line
J : Type w
Z✝ : WalkingParallelFamily J
x✝ : J
h : one ⟶ Z✝
⊢ (Hom.id zero ≫ line x✝) ≫ h = Hom.id zero ≫ line x✝ ≫ h

Next tactic:
cases h
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> 

Proof state:
case line.id
J : Type w
Z✝ : WalkingParallelFamily J
x✝ : J
h : one ⟶ Z✝
⊢ (line x✝ ≫ Hom.id one) ≫ h = line x✝ ≫ Hom.id one ≫ h

Next tactic:
cases h
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> cases h <;> 

Proof state:
case id.id.id
J : Type w
W✝ : WalkingParallelFamily J
⊢ (Hom.id W✝ ≫ Hom.id W✝) ≫ Hom.id W✝ = Hom.id W✝ ≫ Hom.id W✝ ≫ Hom.id W✝

Next tactic:
aesop_cat
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> cases h <;> 

Proof state:
case id.id.line
J : Type w
x✝ : J
⊢ (Hom.id zero ≫ Hom.id zero) ≫ line x✝ = Hom.id zero ≫ Hom.id zero ≫ line x✝

Next tactic:
aesop_cat
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> cases h <;> 

Proof state:
case id.line.id
J : Type w
x✝ : J
⊢ (Hom.id zero ≫ line x✝) ≫ Hom.id one = Hom.id zero ≫ line x✝ ≫ Hom.id one

Next tactic:
aesop_cat
instance WalkingParallelFamily.category : SmallCategory (WalkingParallelFamily J) where
  Hom := WalkingParallelFamily.Hom J
  id := WalkingParallelFamily.Hom.id
  comp := WalkingParallelFamily.Hom.comp
  assoc f g h := by cases f <;> cases g <;> cases h <;> 

Proof state:
case line.id.id
J : Type w
x✝ : J
⊢ (line x✝ ≫ Hom.id one) ≫ Hom.id one = line x✝ ≫ Hom.id one ≫ Hom.id one

Next tactic:
aesop_cat
/-- `parallelFamily f` is the diagram in `C` consisting of the given family of morphisms, each with
common domain and codomain.
-/
def parallelFamily : WalkingParallelFamily J ⥤ C where
  obj x := WalkingParallelFamily.casesOn x X Y
  map {x y} h :=
    match x, y, h with
    | _, _, Hom.id _ => 𝟙 _
    | _, _, line j => f j
  map_comp := by
    

Proof state:
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X_1 Y_1 Z : WalkingParallelFamily J} (f_1 : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z),
    { obj := fun x => WalkingParallelFamily.casesOn x X Y,
            map := fun {x y} h =>
              match x, y, h with
              | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
              | .(zero), .(one), line j => f j }.map
        (f_1 ≫ g) =
      { obj := fun x => WalkingParallelFamily.casesOn x X Y,
              map := fun {x y} h =>
                match x, y, h with
                | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
                | .(zero), .(one), line j => f j }.map
          f_1 ≫
        { obj := fun x => WalkingParallelFamily.casesOn x X Y,
              map := fun {x y} h =>
                match x, y, h with
                | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
                | .(zero), .(one), line j => f j }.map
          g

Next tactic:
rintro _ _ _ ⟨⟩ ⟨⟩
/-- `parallelFamily f` is the diagram in `C` consisting of the given family of morphisms, each with
common domain and codomain.
-/
def parallelFamily : WalkingParallelFamily J ⥤ C where
  obj x := WalkingParallelFamily.casesOn x X Y
  map {x y} h :=
    match x, y, h with
    | _, _, Hom.id _ => 𝟙 _
    | _, _, line j => f j
  map_comp := by
    rintro _ _ _ ⟨⟩ ⟨⟩ <;>
      · 

Proof state:
case id.id
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
X✝ : WalkingParallelFamily J
⊢ { obj := fun x => WalkingParallelFamily.casesOn x X Y,
          map := fun {x y} h =>
            match x, y, h with
            | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
            | .(zero), .(one), line j => f j }.map
      (Hom.id X✝ ≫ Hom.id X✝) =
    { obj := fun x => WalkingParallelFamily.casesOn x X Y,
            map := fun {x y} h =>
              match x, y, h with
              | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
              | .(zero), .(one), line j => f j }.map
        (Hom.id X✝) ≫
      { obj := fun x => WalkingParallelFamily.casesOn x X Y,
            map := fun {x y} h =>
              match x, y, h with
              | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
              | .(zero), .(one), line j => f j }.map
        (Hom.id X✝)

Next tactic:
aesop_cat
/-- `parallelFamily f` is the diagram in `C` consisting of the given family of morphisms, each with
common domain and codomain.
-/
def parallelFamily : WalkingParallelFamily J ⥤ C where
  obj x := WalkingParallelFamily.casesOn x X Y
  map {x y} h :=
    match x, y, h with
    | _, _, Hom.id _ => 𝟙 _
    | _, _, line j => f j
  map_comp := by
    rintro _ _ _ ⟨⟩ ⟨⟩ <;>
      · 

Proof state:
case id.line
J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
x✝ : J
⊢ { obj := fun x => WalkingParallelFamily.casesOn x X Y,
          map := fun {x y} h =>
            match x, y, h with
            | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
            | .(zero), .(one), line j => f j }.map
      (Hom.id zero ≫ line x✝) =
    { obj := fun x => WalkingParallelFamily.casesOn x X Y,
            map := fun {x y} h =>
              match x, y, h with
              | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
              | .(zero), .(one), line j => f j }.map
        (Hom.id zero) ≫
      { obj := fun x => WalkingParallelFamily.casesOn x X Y,
            map := fun {x y} h =>
              match x, y, h with
              | x, .(x), Hom.id .(x) => 𝟙 ((fun x => WalkingParallelFamily.casesOn x X Y) x)
              | .(zero), .(one), line j => f j }.map
        (line x✝)

Next tactic:
aesop_cat