l3lab/ntp-mathlib huggingface dataset:
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case neg.pos.zero
⊢ neg * pos * zero = neg * (pos * zero)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case neg.pos.neg
⊢ neg * pos * neg = neg * (pos * neg)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case neg.pos.pos
⊢ neg * pos * pos = neg * (pos * pos)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.zero.zero
⊢ pos * zero * zero = pos * (zero * zero)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.zero.neg
⊢ pos * zero * neg = pos * (zero * neg)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.zero.pos
⊢ pos * zero * pos = pos * (zero * pos)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.neg.zero
⊢ pos * neg * zero = pos * (neg * zero)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.neg.neg
⊢ pos * neg * neg = pos * (neg * neg)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.neg.pos
⊢ pos * neg * pos = pos * (neg * pos)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.pos.zero
⊢ pos * pos * zero = pos * (pos * zero)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.pos.neg
⊢ pos * pos * neg = pos * (pos * neg)

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  rintro ⟨⟩ ⟨⟩ ⟨⟩ <;> 

Proof state:
case pos.pos.pos
⊢ pos * pos * pos = pos * (pos * pos)

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by 

Proof state:
a : SignType
⊢ 1 * a = a

Next tactic:
cases a
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> 

Proof state:
case zero
⊢ 1 * zero = zero

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> 

Proof state:
case neg
⊢ 1 * neg = neg

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> 

Proof state:
case pos
⊢ 1 * pos = pos

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by 

Proof state:
a : SignType
⊢ a * 1 = a

Next tactic:
cases a
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> 

Proof state:
case zero
⊢ zero * 1 = zero

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> 

Proof state:
case neg
⊢ neg * 1 = neg

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> 

Proof state:
case pos
⊢ pos * 1 = pos

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by 

Proof state:
a : SignType
⊢ 0 * a = 0

Next tactic:
cases a
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> 

Proof state:
case zero
⊢ 0 * zero = 0

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> 

Proof state:
case neg
⊢ 0 * neg = 0

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> 

Proof state:
case pos
⊢ 0 * pos = 0

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by 

Proof state:
a : SignType
⊢ a * 0 = 0

Next tactic:
cases a
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> 

Proof state:
case zero
⊢ zero * 0 = 0

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> 

Proof state:
case neg
⊢ neg * 0 = 0

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> 

Proof state:
case pos
⊢ pos * 0 = 0

Next tactic:
rfl
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> rfl
  mul_inv_cancel a ha := by cases a <;> trivial
  mul_comm := mul_comm
  mul_assoc := mul_assoc
  exists_pair_ne := ⟨0, 1, by 

Proof state:
⊢ 0 ≠ 1

Next tactic:
rintro ⟨_⟩
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> rfl
  mul_inv_cancel a ha := by 

Proof state:
a : SignType
ha : a ≠ 0
⊢ a * a⁻¹ = 1

Next tactic:
cases a
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> rfl
  mul_inv_cancel a ha := by cases a <;> 

Proof state:
case zero
ha : zero ≠ 0
⊢ zero * zero⁻¹ = 1

Next tactic:
trivial
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> rfl
  mul_inv_cancel a ha := by cases a <;> 

Proof state:
case neg
ha : neg ≠ 0
⊢ neg * neg⁻¹ = 1

Next tactic:
trivial
instance : CommGroupWithZero SignType where
  zero := 0
  one := 1
  mul := (· * ·)
  inv := id
  mul_zero a := by cases a <;> rfl
  zero_mul a := by cases a <;> rfl
  mul_one a := by cases a <;> rfl
  one_mul a := by cases a <;> rfl
  mul_inv_cancel a ha := by cases a <;> 

Proof state:
case pos
ha : pos ≠ 0
⊢ pos * pos⁻¹ = 1

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  

Proof state:
a b : SignType
x✝¹ : a ≤ b
x✝ : b ≤ a
⊢ a = b

Next tactic:
cases a
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> 

Proof state:
case zero
b : SignType
x✝¹ : zero ≤ b
x✝ : b ≤ zero
⊢ zero = b

Next tactic:
cases b
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> 

Proof state:
case neg
b : SignType
x✝¹ : neg ≤ b
x✝ : b ≤ neg
⊢ neg = b

Next tactic:
cases b
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> 

Proof state:
case pos
b : SignType
x✝¹ : pos ≤ b
x✝ : b ≤ pos
⊢ pos = b

Next tactic:
cases b
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case zero.zero
x✝¹ x✝ : zero ≤ zero
⊢ zero = zero

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case zero.neg
x✝¹ : zero ≤ neg
x✝ : neg ≤ zero
⊢ zero = neg

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case zero.pos
x✝¹ : zero ≤ pos
x✝ : pos ≤ zero
⊢ zero = pos

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case neg.zero
x✝¹ : neg ≤ zero
x✝ : zero ≤ neg
⊢ neg = zero

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case neg.neg
x✝¹ x✝ : neg ≤ neg
⊢ neg = neg

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case neg.pos
x✝¹ : neg ≤ pos
x✝ : pos ≤ neg
⊢ neg = pos

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case pos.zero
x✝¹ : pos ≤ zero
x✝ : zero ≤ pos
⊢ pos = zero

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case pos.neg
x✝¹ : pos ≤ neg
x✝ : neg ≤ pos
⊢ pos = neg

Next tactic:
trivial
private lemma le_antisymm (a b : SignType) (_ : a ≤ b) (_: b ≤ a) : a = b := by
  cases a <;> cases b <;> 

Proof state:
case pos.pos
x✝¹ x✝ : pos ≤ pos
⊢ pos = pos

Next tactic:
trivial
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  

Proof state:
a b c : SignType
x✝¹ : a ≤ b
x✝ : b ≤ c
⊢ a ≤ c

Next tactic:
cases a
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> 

Proof state:
case zero
b c : SignType
x✝¹ : b ≤ c
x✝ : zero ≤ b
⊢ zero ≤ c

Next tactic:
cases b
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> 

Proof state:
case neg
b c : SignType
x✝¹ : b ≤ c
x✝ : neg ≤ b
⊢ neg ≤ c

Next tactic:
cases b
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> 

Proof state:
case pos
b c : SignType
x✝¹ : b ≤ c
x✝ : pos ≤ b
⊢ pos ≤ c

Next tactic:
cases b
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case zero.zero
c : SignType
x✝¹ : zero ≤ c
x✝ : zero ≤ zero
⊢ zero ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case zero.neg
c : SignType
x✝¹ : neg ≤ c
x✝ : zero ≤ neg
⊢ zero ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case zero.pos
c : SignType
x✝¹ : pos ≤ c
x✝ : zero ≤ pos
⊢ zero ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case neg.zero
c : SignType
x✝¹ : zero ≤ c
x✝ : neg ≤ zero
⊢ neg ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case neg.neg
c : SignType
x✝¹ : neg ≤ c
x✝ : neg ≤ neg
⊢ neg ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case neg.pos
c : SignType
x✝¹ : pos ≤ c
x✝ : neg ≤ pos
⊢ neg ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case pos.zero
c : SignType
x✝¹ : zero ≤ c
x✝ : pos ≤ zero
⊢ pos ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case pos.neg
c : SignType
x✝¹ : neg ≤ c
x✝ : pos ≤ neg
⊢ pos ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> 

Proof state:
case pos.pos
c : SignType
x✝¹ : pos ≤ c
x✝ : pos ≤ pos
⊢ pos ≤ c

Next tactic:
cases c
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.zero.zero
x✝¹ x✝ : zero ≤ zero
⊢ zero ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.zero.zero
x✝¹ x✝ : zero ≤ zero
⊢ zero ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.zero.neg
x✝¹ : zero ≤ zero
x✝ : zero ≤ neg
⊢ zero ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.zero.neg
x✝¹ : zero ≤ zero
x✝ : zero ≤ neg
⊢ zero ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.zero.pos
x✝¹ : zero ≤ zero
x✝ : zero ≤ pos
⊢ zero ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.zero.pos
x✝¹ : zero ≤ zero
x✝ : zero ≤ pos
⊢ zero ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.neg.zero
x✝¹ : zero ≤ neg
x✝ : neg ≤ zero
⊢ zero ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.neg.zero
x✝¹ : zero ≤ neg
x✝ : neg ≤ zero
⊢ zero ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.neg.neg
x✝¹ : zero ≤ neg
x✝ : neg ≤ neg
⊢ zero ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.neg.neg
x✝¹ : zero ≤ neg
x✝ : neg ≤ neg
⊢ zero ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.neg.pos
x✝¹ : zero ≤ neg
x✝ : neg ≤ pos
⊢ zero ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.neg.pos
x✝¹ : zero ≤ neg
x✝ : neg ≤ pos
⊢ zero ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.pos.zero
x✝¹ : zero ≤ pos
x✝ : pos ≤ zero
⊢ zero ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.pos.zero
x✝¹ : zero ≤ pos
x✝ : pos ≤ zero
⊢ zero ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.pos.neg
x✝¹ : zero ≤ pos
x✝ : pos ≤ neg
⊢ zero ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.pos.neg
x✝¹ : zero ≤ pos
x✝ : pos ≤ neg
⊢ zero ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case zero.pos.pos
x✝¹ : zero ≤ pos
x✝ : pos ≤ pos
⊢ zero ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case zero.pos.pos
x✝¹ : zero ≤ pos
x✝ : pos ≤ pos
⊢ zero ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.zero.zero
x✝¹ : neg ≤ zero
x✝ : zero ≤ zero
⊢ neg ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.zero.zero
x✝¹ : neg ≤ zero
x✝ : zero ≤ zero
⊢ neg ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.zero.neg
x✝¹ : neg ≤ zero
x✝ : zero ≤ neg
⊢ neg ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.zero.neg
x✝¹ : neg ≤ zero
x✝ : zero ≤ neg
⊢ neg ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.zero.pos
x✝¹ : neg ≤ zero
x✝ : zero ≤ pos
⊢ neg ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.zero.pos
x✝¹ : neg ≤ zero
x✝ : zero ≤ pos
⊢ neg ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | tauto | 

Proof state:
case neg.zero.pos
x✝¹ : neg ≤ zero
x✝ : zero ≤ pos
⊢ neg ≤ pos

Next tactic:
constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.neg.zero
x✝¹ : neg ≤ neg
x✝ : neg ≤ zero
⊢ neg ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.neg.zero
x✝¹ : neg ≤ neg
x✝ : neg ≤ zero
⊢ neg ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.neg.neg
x✝¹ x✝ : neg ≤ neg
⊢ neg ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.neg.neg
x✝¹ x✝ : neg ≤ neg
⊢ neg ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.neg.pos
x✝¹ : neg ≤ neg
x✝ : neg ≤ pos
⊢ neg ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.neg.pos
x✝¹ : neg ≤ neg
x✝ : neg ≤ pos
⊢ neg ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.pos.zero
x✝¹ : neg ≤ pos
x✝ : pos ≤ zero
⊢ neg ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.pos.zero
x✝¹ : neg ≤ pos
x✝ : pos ≤ zero
⊢ neg ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.pos.neg
x✝¹ : neg ≤ pos
x✝ : pos ≤ neg
⊢ neg ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.pos.neg
x✝¹ : neg ≤ pos
x✝ : pos ≤ neg
⊢ neg ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case neg.pos.pos
x✝¹ : neg ≤ pos
x✝ : pos ≤ pos
⊢ neg ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case neg.pos.pos
x✝¹ : neg ≤ pos
x✝ : pos ≤ pos
⊢ neg ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case pos.zero.zero
x✝¹ : pos ≤ zero
x✝ : zero ≤ zero
⊢ pos ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case pos.zero.zero
x✝¹ : pos ≤ zero
x✝ : zero ≤ zero
⊢ pos ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case pos.zero.neg
x✝¹ : pos ≤ zero
x✝ : zero ≤ neg
⊢ pos ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case pos.zero.neg
x✝¹ : pos ≤ zero
x✝ : zero ≤ neg
⊢ pos ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case pos.zero.pos
x✝¹ : pos ≤ zero
x✝ : zero ≤ pos
⊢ pos ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case pos.zero.pos
x✝¹ : pos ≤ zero
x✝ : zero ≤ pos
⊢ pos ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case pos.neg.zero
x✝¹ : pos ≤ neg
x✝ : neg ≤ zero
⊢ pos ≤ zero

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case pos.neg.zero
x✝¹ : pos ≤ neg
x✝ : neg ≤ zero
⊢ pos ≤ zero

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case pos.neg.neg
x✝¹ : pos ≤ neg
x✝ : neg ≤ neg
⊢ pos ≤ neg

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case pos.neg.neg
x✝¹ : pos ≤ neg
x✝ : neg ≤ neg
⊢ pos ≤ neg

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case pos.neg.pos
x✝¹ : pos ≤ neg
x✝ : neg ≤ pos
⊢ pos ≤ pos

Next tactic:
first | tauto | constructor
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> first | 

Proof state:
case pos.neg.pos
x✝¹ : pos ≤ neg
x✝ : neg ≤ pos
⊢ pos ≤ pos

Next tactic:
tauto
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_: b ≤ c) : a ≤ c := by
  cases a <;> cases b <;> cases c <;> 

Proof state:
case pos.pos.zero
x✝¹ : pos ≤ pos
x✝ : pos ≤ zero
⊢ pos ≤ zero

Next tactic:
first | tauto | constructor