/-- `SignType` is equivalent to `Fin 3`. -/
def fin3Equiv : SignType ≃* Fin 3 where
  toFun a :=
    match a with
    | 0 => ⟨0, by simp⟩
    | 1 => ⟨1, by simp⟩
    | -1 => ⟨2, by simp⟩
  invFun a :=
    match a with
    | ⟨0, _⟩ => 0
    | ⟨1, _⟩ => 1
    | ⟨2, _⟩ => -1
    | ⟨n + 3, h⟩ => (h.not_le le_add_self).elim
  left_inv a := by cases a <;> rfl
  right_inv a :=
    match a with
    | ⟨0, _⟩ => by simp
    | ⟨1, _⟩ => by simp
    | ⟨2, _⟩ => by simp
    | ⟨n + 3, h⟩ => by simp at h
  map_mul' a b := by
    cases a <;> cases b <;> 

Proof state:
case neg.pos
⊢ Equiv.toFun
      {
        toFun := fun a =>
          match a with
          | zero => { val := 0, isLt := (_ : 0 < 3) }
          | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
          | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) },
        invFun := fun a =>
          match a with
          | { val := 0, isLt := isLt } => 0
          | { val := 1, isLt := isLt } => 1
          | { val := 2, isLt := isLt } => -1
          | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim,
        left_inv :=
          (_ :
            ∀ (a : SignType),
              (fun a =>
                    match a with
                    | { val := 0, isLt := isLt } => 0
                    | { val := 1, isLt := isLt } => 1
                    | { val := 2, isLt := isLt } => -1
                    | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim)
                  ((fun a =>
                      match a with
                      | zero => { val := 0, isLt := (_ : 0 < 3) }
                      | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
                      | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) })
                    a) =
                a),
        right_inv :=
          (_ :
            ∀ (a : Fin 3),
              (fun a =>
                    match a with
                    | zero => { val := 0, isLt := (_ : 0 < 3) }
                    | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
                    | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) })
                  ((fun a =>
                      match a with
                      | { val := 0, isLt := isLt } => 0
                      | { val := 1, isLt := isLt } => 1
                      | { val := 2, isLt := isLt } => -1
                      | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim)
                    a) =
                a) }
      (neg * pos) =
    Equiv.toFun
        {
          toFun := fun a =>
            match a with
            | zero => { val := 0, isLt := (_ : 0 < 3) }
            | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
            | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) },
          invFun := fun a =>
            match a with
            | { val := 0, isLt := isLt } => 0
            | { val := 1, isLt := isLt } => 1
            | { val := 2, isLt := isLt } => -1
            | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim,
          left_inv :=
            (_ :
              ∀ (a : SignType),
                (fun a =>
                      match a with
                      | { val := 0, isLt := isLt } => 0
                      | { val := 1, isLt := isLt } => 1
                      | { val := 2, isLt := isLt } => -1
                      | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim)
                    ((fun a =>
                        match a with
                        | zero => { val := 0, isLt := (_ : 0 < 3) }
                        | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
                        | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) })
                      a) =
                  a),
          right_inv :=
            (_ :
              ∀ (a : Fin 3),
                (fun a =>
                      match a with
                      | zero => { val := 0, isLt := (_ : 0 < 3) }
                      | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
                      | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) })
                    ((fun a =>
                        match a with
                        | { val := 0, isLt := isLt } => 0
                        | { val := 1, isLt := isLt } => 1
                        | { val := 2, isLt := isLt } => -1
                        | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim)
                      a) =
                  a) }
        neg *
      Equiv.toFun
        {
          toFun := fun a =>
            match a with
            | zero => { val := 0, isLt := (_ : 0 < 3) }
            | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
            | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) },
          invFun := fun a =>
            match a with
            | { val := 0, isLt := isLt } => 0
            | { val := 1, isLt := isLt } => 1
            | { val := 2, isLt := isLt } => -1
            | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim,
          left_inv :=
            (_ :
              ∀ (a : SignType),
                (fun a =>
                      match a with
                      | { val := 0, isLt := isLt } => 0
                      | { val := 1, isLt := isLt } => 1
                      | { val := 2, isLt := isLt } => -1
                      | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim)
                    ((fun a =>
                        match a with
                        | zero => { val := 0, isLt := (_ : 0 < 3) }
                        | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
                        | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) })
                      a) =
                  a),
          right_inv :=
            (_ :
              ∀ (a : Fin 3),
                (fun a =>
                      match a with
                      | zero => { val := 0, isLt := (_ : 0 < 3) }
                      | pos => { val := 1, isLt := (_ : 1 < Nat.succ (Nat.succ 1)) }
                      | neg => { val := 2, isLt := (_ : 2 < Nat.succ 2) })
                    ((fun a =>
                        match a with
                        | { val := 0, isLt := isLt } => 0
                        | { val := 1, isLt := isLt } => 1
                        | { val := 2, isLt := isLt } => -1
                        | { val := Nat.succ (Nat.succ (Nat.succ n)), isLt := h } => (_ : False).elim)
                      a) =
                  a) }
        pos

Next tactic:
rfl