l3lab/ntp-mathlib huggingface dataset:
theorem toGroup.unique (g : PresentedGroup rels →* G)
    (hg : ∀ x : α, g (PresentedGroup.of x) = f x) : ∀ {x}, g x = toGroup h x := by
  

Proof state:
α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
⊢ ∀ {x : PresentedGroup rels}, g x = (toGroup h) x

Next tactic:
intro x
theorem toGroup.unique (g : PresentedGroup rels →* G)
    (hg : ∀ x : α, g (PresentedGroup.of x) = f x) : ∀ {x}, g x = toGroup h x := by
  intro x
  

Proof state:
α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ g x = (toGroup h) x

Next tactic:
refine' QuotientGroup.induction_on x _
theorem toGroup.unique (g : PresentedGroup rels →* G)
    (hg : ∀ x : α, g (PresentedGroup.of x) = f x) : ∀ {x}, g x = toGroup h x := by
  intro x
  refine' QuotientGroup.induction_on x _
  

Proof state:
α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ ∀ (z : FreeGroup α), g ↑z = (toGroup h) ↑z

Next tactic:
exact fun _ ↦ FreeGroup.lift.unique (g.comp (QuotientGroup.mk' _)) hg
@[ext]
theorem ext {φ ψ : PresentedGroup rels →* G} (hx : ∀ (x : α), φ (.of x) = ψ (.of x)) : φ = ψ := by
  

Proof state:
α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
φ ψ : PresentedGroup rels →* G
hx : ∀ (x : α), φ (of x) = ψ (of x)
⊢ φ = ψ

Next tactic:
unfold PresentedGroup
@[ext]
theorem ext {φ ψ : PresentedGroup rels →* G} (hx : ∀ (x : α), φ (.of x) = ψ (.of x)) : φ = ψ := by
  unfold PresentedGroup
  

Proof state:
α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
φ ψ : PresentedGroup rels →* G
hx : ∀ (x : α), φ (of x) = ψ (of x)
⊢ φ = ψ

Next tactic:
ext
@[ext]
theorem ext {φ ψ : PresentedGroup rels →* G} (hx : ∀ (x : α), φ (.of x) = ψ (.of x)) : φ = ψ := by
  unfold PresentedGroup
  ext
  

Proof state:
case h.h
α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
φ ψ : PresentedGroup rels →* G
hx : ∀ (x : α), φ (of x) = ψ (of x)
a✝ : α
⊢ (MonoidHom.comp φ (QuotientGroup.mk' (Subgroup.normalClosure rels))) (FreeGroup.of a✝) =
    (MonoidHom.comp ψ (QuotientGroup.mk' (Subgroup.normalClosure rels))) (FreeGroup.of a✝)

Next tactic:
apply hx
instance : Fintype SignType :=
   Fintype.ofMultiset (zero :: neg :: pos :: List.nil) (fun x ↦ by 

Proof state:
x : SignType
⊢ x ∈ ↑[zero, neg, pos]

Next tactic:
cases x
instance : Fintype SignType :=
   Fintype.ofMultiset (zero :: neg :: pos :: List.nil) (fun x ↦ by cases x <;> 

Proof state:
case zero
⊢ zero ∈ ↑[zero, neg, pos]

Next tactic:
simp
instance : Fintype SignType :=
   Fintype.ofMultiset (zero :: neg :: pos :: List.nil) (fun x ↦ by cases x <;> 

Proof state:
case neg
⊢ neg ∈ ↑[zero, neg, pos]

Next tactic:
simp
instance : Fintype SignType :=
   Fintype.ofMultiset (zero :: neg :: pos :: List.nil) (fun x ↦ by cases x <;> 

Proof state:
case pos
⊢ pos ∈ ↑[zero, neg, pos]

Next tactic:
simp
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  

Proof state:
a b : SignType
⊢ Decidable (SignType.LE a b)

Next tactic:
cases a
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> 

Proof state:
case zero
b : SignType
⊢ Decidable (SignType.LE SignType.zero b)

Next tactic:
cases b
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> 

Proof state:
case neg
b : SignType
⊢ Decidable (SignType.LE neg b)

Next tactic:
cases b
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> 

Proof state:
case pos
b : SignType
⊢ Decidable (SignType.LE pos b)

Next tactic:
cases b
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case zero.zero
⊢ Decidable (SignType.LE SignType.zero SignType.zero)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case zero.zero
⊢ Decidable (SignType.LE SignType.zero SignType.zero)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE SignType.zero SignType.zero

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case zero.neg
⊢ Decidable (SignType.LE SignType.zero neg)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case zero.neg
⊢ Decidable (SignType.LE SignType.zero neg)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE SignType.zero neg

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

Proof state:
case zero.neg
⊢ Decidable (SignType.LE SignType.zero neg)

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬SignType.LE SignType.zero neg

Next tactic:
rintro ⟨_⟩
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case zero.pos
⊢ Decidable (SignType.LE SignType.zero pos)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case zero.pos
⊢ Decidable (SignType.LE SignType.zero pos)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE SignType.zero pos

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case neg.zero
⊢ Decidable (SignType.LE neg SignType.zero)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case neg.zero
⊢ Decidable (SignType.LE neg SignType.zero)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE neg SignType.zero

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case neg.neg
⊢ Decidable (SignType.LE neg neg)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case neg.neg
⊢ Decidable (SignType.LE neg neg)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE neg neg

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case neg.pos
⊢ Decidable (SignType.LE neg pos)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case neg.pos
⊢ Decidable (SignType.LE neg pos)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE neg pos

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case pos.zero
⊢ Decidable (SignType.LE pos SignType.zero)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case pos.zero
⊢ Decidable (SignType.LE pos SignType.zero)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE pos SignType.zero

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

Proof state:
case pos.zero
⊢ Decidable (SignType.LE pos SignType.zero)

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬SignType.LE pos SignType.zero

Next tactic:
rintro ⟨_⟩
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case pos.neg
⊢ Decidable (SignType.LE pos neg)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case pos.neg
⊢ Decidable (SignType.LE pos neg)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE pos neg

Next tactic:
constructor
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

Proof state:
case pos.neg
⊢ Decidable (SignType.LE pos neg)

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬SignType.LE pos neg

Next tactic:
rintro ⟨_⟩
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case pos.pos
⊢ Decidable (SignType.LE pos pos)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case pos.pos
⊢ Decidable (SignType.LE pos pos)

Next tactic:
exact isTrue (by constructor)
instance LE.decidableRel : DecidableRel SignType.LE := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ SignType.LE pos pos

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  

Proof state:
a b : SignType
⊢ Decidable (a = b)

Next tactic:
cases a
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> 

Proof state:
case zero
b : SignType
⊢ Decidable (zero = b)

Next tactic:
cases b
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> 

Proof state:
case neg
b : SignType
⊢ Decidable (neg = b)

Next tactic:
cases b
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> 

Proof state:
case pos
b : SignType
⊢ Decidable (pos = b)

Next tactic:
cases b
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case zero.zero
⊢ Decidable (zero = zero)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case zero.zero
⊢ Decidable (zero = zero)

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ zero = zero

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case zero.neg
⊢ Decidable (zero = neg)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case zero.neg
⊢ Decidable (zero = neg)

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ zero = neg

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

Proof state:
case zero.neg
⊢ Decidable (zero = neg)

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬zero = neg

Next tactic:
rintro ⟨_⟩
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

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

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

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

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ zero = pos

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

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

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬zero = pos

Next tactic:
rintro ⟨_⟩
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case neg.zero
⊢ Decidable (neg = zero)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case neg.zero
⊢ Decidable (neg = zero)

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ neg = zero

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

Proof state:
case neg.zero
⊢ Decidable (neg = zero)

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬neg = zero

Next tactic:
rintro ⟨_⟩
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

Proof state:
case neg.neg
⊢ Decidable (neg = neg)

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

Proof state:
case neg.neg
⊢ Decidable (neg = neg)

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ neg = neg

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

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

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

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

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ neg = pos

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

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

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬neg = pos

Next tactic:
rintro ⟨_⟩
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

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

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

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

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ pos = zero

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

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

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬pos = zero

Next tactic:
rintro ⟨_⟩
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

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

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

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

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ pos = neg

Next tactic:
constructor
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| 

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

Next tactic:
exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by constructor)| exact isFalse (by 

Proof state:
⊢ ¬pos = neg

Next tactic:
rintro ⟨_⟩
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> 

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

Next tactic:
first | exact isTrue (by constructor)| exact isFalse (by rintro ⟨_⟩)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | 

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

Next tactic:
exact isTrue (by constructor)
instance decidableEq : DecidableEq SignType := fun a b => by
  cases a <;> cases b <;> first | exact isTrue (by 

Proof state:
⊢ pos = pos

Next tactic:
constructor
private lemma mul_comm : ∀ (a b : SignType), a * b = b * a := by 

Proof state:
⊢ ∀ (a b : SignType), a * b = b * a

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

Proof state:
case zero.zero
⊢ zero * zero = zero * zero

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

Proof state:
case zero.neg
⊢ zero * neg = neg * zero

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

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

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

Proof state:
case neg.zero
⊢ neg * zero = zero * neg

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

Proof state:
case neg.neg
⊢ neg * neg = neg * neg

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

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

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

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

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

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

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

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

Next tactic:
rfl
private lemma mul_assoc : ∀ (a b c : SignType), (a * b) * c = a * (b * c) := by
  

Proof state:
⊢ ∀ (a b c : SignType), a * b * c = a * (b * c)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Next tactic:
rfl