File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.lean

full_name: BitVec.Literal
code: /-- A bit-vector literal -/
structure Literal where
  /-- Size. -/
  n     : Nat
  /-- Actual value. -/
  value : BitVec n
  deriving DecidableEq, Repr
goal: Type

full_name: BitVec.instReprLiteral
code: /-- A bit-vector literal -/
structure Literal where
  /-- Size. -/
  n     : Nat
  /-- Actual value. -/
  value : BitVec n
  deriving DecidableEq, Repr
goal: Repr BitVec.Literal

full_name: BitVec.Literal.n
code: /-- A bit-vector literal -/
structure Literal where
  /-- Size. -/
  n     : Nat
  /-- Actual value. -/
  value : BitVec n
  deriving DecidableEq, Repr
goal: Nat

full_name: BitVec.Literal.value
code: /-- A bit-vector literal -/
structure Literal where
  /-- Size. -/
  n     : Nat
  /-- Actual value. -/
  value : BitVec n
  deriving DecidableEq, Repr
goal: BitVec self.n

full_name: BitVec.fromExpr?
code: /--
Try to convert `OfNat.ofNat`/`BitVec.OfNat` application into a
bitvector literal.
-/
def fromExpr? (e : Expr) : SimpM (Option Literal) 
goal: Lean.Meta.SimpM (Option BitVec.Literal)

full_name: BitVec.reduceUnary
code: /--
Helper function for reducing homogenous unary bitvector operators.
-/
@[inline] def reduceUnary (declName : Name) (arity : Nat)
    (op : {n : Nat} → BitVec n → BitVec n) (e : Expr) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: BitVec.reduceBin
code: /--
Helper function for reducing homogenous binary bitvector operators.
-/
@[inline] def reduceBin (declName : Name) (arity : Nat)
    (op : {n : Nat} → BitVec n → BitVec n → BitVec n) (e : Expr) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: BitVec.reduceExtend
code: /-- Simplification procedure for `zeroExtend` and `signExtend` on `BitVec`s. -/
@[inline] def reduceExtend (declName : Name)
    (op : {n : Nat} → (m : Nat) → BitVec n → BitVec m) (e : Expr) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: BitVec.reduceGetBit
code: /--
Helper function for reducing bitvector functions such as `getLsb` and `getMsb`.
-/
@[inline] def reduceGetBit (declName : Name) (op : {n : Nat} → BitVec n → Nat → Bool) (e : Expr)
    : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: BitVec.reduceShift
code: /--
Helper function for reducing bitvector functions such as `shiftLeft` and `rotateRight`.
-/
@[inline] def reduceShift (declName : Name) (arity : Nat)
    (op : {n : Nat} → BitVec n → Nat → BitVec n) (e : Expr) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: BitVec.reduceShiftWithBitVecLit
code: /--
Helper function for reducing `x <<< i` and `x >>> i` where `i` is a bitvector literal,
into one that is a natural number literal.
-/
@[inline] def reduceShiftWithBitVecLit (declName : Name) (e : Expr) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: BitVec.reduceBinPred
code: /--
Helper function for reducing bitvector predicates.
-/
@[inline] def reduceBinPred (declName : Name) (arity : Nat)
    (op : {n : Nat} → BitVec n → BitVec n → Bool) (e : Expr) : SimpM Step 
goal: Lean.Meta.SimpM Lean.Meta.Simp.Step

full_name: BitVec.reduceBoolPred
code: @[inline] def reduceBoolPred (declName : Name) (arity : Nat)
    (op : {n : Nat} → BitVec n → BitVec n → Bool) (e : Expr) : SimpM DStep 
goal: Lean.Meta.SimpM Lean.Meta.Simp.DStep

full_name: BitVec.reduceNeg
code: /-- Simplification procedure for negation of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceNeg ((- _ : BitVec _)) := reduceUnary ``Neg.neg 3 (- ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceNot
code: /-- Simplification procedure for bitwise not of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceNot ((~~~ _ : BitVec _)) :=
  reduceUnary ``Complement.complement 3 (~~~ ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceAbs
code: /-- Simplification procedure for absolute value of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceAbs (BitVec.abs _) := reduceUnary ``BitVec.abs 2 BitVec.abs
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceAnd
code: /-- Simplification procedure for bitwise and of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceAnd ((_ &&& _ : BitVec _)) := reduceBin ``HAnd.hAnd 6 (· &&& ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceOr
code: /-- Simplification procedure for bitwise or of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceOr ((_ ||| _ : BitVec _)) := reduceBin ``HOr.hOr 6 (· ||| ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceXOr
code: /-- Simplification procedure for bitwise xor of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceXOr ((_ ^^^ _ : BitVec _)) := reduceBin ``HXor.hXor 6 (· ^^^ ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceAdd
code: /-- Simplification procedure for addition of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceAdd ((_ + _ : BitVec _)) := reduceBin ``HAdd.hAdd 6 (· + ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceMul
code: /-- Simplification procedure for multiplication of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceMul ((_ * _ : BitVec _)) := reduceBin ``HMul.hMul 6 (· * ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSub
code: /-- Simplification procedure for subtraction of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceSub ((_ - _ : BitVec _)) := reduceBin ``HSub.hSub 6 (· - ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceDiv
code: /-- Simplification procedure for division of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceDiv ((_ / _ : BitVec _)) := reduceBin ``HDiv.hDiv 6 (· / ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceMod
code: /-- Simplification procedure for the modulo operation on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceMod ((_ % _ : BitVec _)) := reduceBin ``HMod.hMod 6 (· % ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceUMod
code: /-- Simplification procedure for for the unsigned modulo operation on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceUMod ((umod _ _ : BitVec _)) := reduceBin ``umod 3 umod
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceUDiv
code: /-- Simplification procedure for unsigned division of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceUDiv ((udiv _ _ : BitVec _)) := reduceBin ``udiv 3 udiv
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSMTUDiv
code: /-- Simplification procedure for division of `BitVec`s using the SMT-Lib conventions. -/
builtin_dsimproc [simp, seval] reduceSMTUDiv ((smtUDiv _ _ : BitVec _)) := reduceBin ``smtUDiv 3 smtUDiv
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSMod
code: /-- Simplification procedure for the signed modulo operation on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceSMod ((smod _ _ : BitVec _)) := reduceBin ``smod 3 smod
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSRem
code: /-- Simplification procedure for signed remainder of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceSRem ((srem _ _ : BitVec _)) := reduceBin ``srem 3 srem
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSDiv
code: /-- Simplification procedure for signed t-division of `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceSDiv ((sdiv _ _ : BitVec _)) := reduceBin ``sdiv 3 sdiv
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSMTSDiv
code: /-- Simplification procedure for signed division of `BitVec`s using the SMT-Lib conventions. -/
builtin_dsimproc [simp, seval] reduceSMTSDiv ((smtSDiv _ _ : BitVec _)) := reduceBin ``smtSDiv 3 smtSDiv
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceGetLsb
code: /-- Simplification procedure for `getLsb` (lowest significant bit) on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceGetLsb (getLsb _ _) := reduceGetBit ``getLsb getLsb
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceGetMsb
code: /-- Simplification procedure for `getMsb` (most significant bit) on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceGetMsb (getMsb _ _) := reduceGetBit ``getMsb getMsb
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceShiftLeft
code: /-- Simplification procedure for shift left on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceShiftLeft (BitVec.shiftLeft _ _) :=
  reduceShift ``BitVec.shiftLeft 3 BitVec.shiftLeft
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceUShiftRight
code: /-- Simplification procedure for unsigned shift right on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceUShiftRight (BitVec.ushiftRight _ _) :=
  reduceShift ``BitVec.ushiftRight 3 BitVec.ushiftRight
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSShiftRight
code: /-- Simplification procedure for signed shift right on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceSShiftRight (BitVec.sshiftRight _ _) :=
  reduceShift ``BitVec.sshiftRight 3 BitVec.sshiftRight
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceHShiftLeft
code: /-- Simplification procedure for shift left on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceHShiftLeft ((_ <<< _ : BitVec _)) :=
  reduceShift ``HShiftLeft.hShiftLeft 6 (· <<< ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceHShiftLeft'
code: /-- Simplification procedure for converting a shift with a bit-vector literal into a natural number literal. -/
builtin_dsimproc [simp, seval] reduceHShiftLeft' ((_ <<< (_ : BitVec _) : BitVec _)) :=
  reduceShiftWithBitVecLit ``HShiftLeft.hShiftLeft
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceHShiftRight
code: /-- Simplification procedure for shift right on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceHShiftRight ((_ >>> _ : BitVec _)) :=
  reduceShift ``HShiftRight.hShiftRight 6 (· >>> ·)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceHShiftRight'
code: /-- Simplification procedure for converting a shift with a bit-vector literal into a natural number literal. -/
builtin_dsimproc [simp, seval] reduceHShiftRight' ((_ >>> (_ : BitVec _) : BitVec _)) :=
  reduceShiftWithBitVecLit ``HShiftRight.hShiftRight
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceRotateLeft
code: /-- Simplification procedure for rotate left on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceRotateLeft (BitVec.rotateLeft _ _) :=
  reduceShift ``BitVec.rotateLeft 3 BitVec.rotateLeft
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceRotateRight
code: /-- Simplification procedure for rotate right on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceRotateRight (BitVec.rotateRight _ _) :=
  reduceShift ``BitVec.rotateRight 3 BitVec.rotateRight
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceAppend
code: /-- Simplification procedure for append on `BitVec`. -/
builtin_dsimproc [simp, seval] reduceAppend ((_ ++ _ : BitVec _)) := fun e => do
  let_expr HAppend.hAppend _ _ _ _ a b ← e | return .continue
  let some v₁ ← fromExpr? a | return .continue
  let some v₂ ← fromExpr? b | return .continue
  return .done <| toExpr (v₁.value ++ v₂.value)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceCast
code: /-- Simplification procedure for casting `BitVec`s along an equality of the size. -/
builtin_dsimproc [simp, seval] reduceCast (cast _ _) := fun e => do
  let_expr cast _ m _ v ← e | return .continue
  let some v ← fromExpr? v | return .continue
  let some m ← Nat.fromExpr? m | return .continue
  return .done <| toExpr (BitVec.ofNat m v.value.toNat)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceToNat
code: /-- Simplification procedure for `BitVec.toNat`. -/
builtin_dsimproc [simp, seval] reduceToNat (BitVec.toNat _) := fun e => do
  let_expr BitVec.toNat _ v ← e | return .continue
  let some v ← fromExpr? v | return .continue
  return .done <| mkNatLit v.value.toNat
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceToInt
code: /-- Simplification procedure for `BitVec.toInt`. -/
builtin_dsimproc [simp, seval] reduceToInt (BitVec.toInt _) := fun e => do
  let_expr BitVec.toInt _ v ← e | return .continue
  let some v ← fromExpr? v | return .continue
  return .done <| toExpr v.value.toInt
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceOfInt
code: /-- Simplification procedure for `BitVec.ofInt`. -/
builtin_dsimproc [simp, seval] reduceOfInt (BitVec.ofInt _ _) := fun e => do
  let_expr BitVec.ofInt n i ← e | return .continue
  let some n ← Nat.fromExpr? n | return .continue
  let some i ← Int.fromExpr? i | return .continue
  return .done <| toExpr (BitVec.ofInt n i)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceOfNat
code: /-- Simplification procedure for ensuring `BitVec.ofNat` literals are normalized. -/
builtin_dsimproc [simp, seval] reduceOfNat (BitVec.ofNat _ _) := fun e => do
  let_expr BitVec.ofNat n v ← e | return .continue
  let some n ← Nat.fromExpr? n | return .continue
  let some v ← Nat.fromExpr? v | return .continue
  let bv := BitVec.ofNat n v
  if bv.toNat == v then return .continue -- already normalized
  return .done <| toExpr (BitVec.ofNat n v)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceEq
code: builtin_simproc [simp, seval] reduceEq  (( _ : BitVec _) = _)  := reduceBinPred ``Eq 3 (. = .)
goal: Lean.Meta.Simp.Simproc

full_name: BitVec.reduceNe
code: builtin_simproc [simp, seval] reduceNe  (( _ : BitVec _) ≠ _)  := reduceBinPred ``Ne 3 (. ≠ .)
goal: Lean.Meta.Simp.Simproc

full_name: BitVec.reduceLT
code: /-- Simplification procedure for `<` on `BitVec`s. -/
builtin_simproc [simp, seval] reduceLT (( _ : BitVec _) < _)  := reduceBinPred ``LT.lt 4 (· < ·)
goal: Lean.Meta.Simp.Simproc

full_name: BitVec.reduceLE
code: /-- Simplification procedure for `≤` on `BitVec`s. -/
builtin_simproc [simp, seval] reduceLE (( _ : BitVec _) ≤ _)  := reduceBinPred ``LE.le 4 (. ≤ .)
goal: Lean.Meta.Simp.Simproc

full_name: BitVec.reduceGT
code: /-- Simplification procedure for `>` on `BitVec`s. -/
builtin_simproc [simp, seval] reduceGT (( _ : BitVec _) > _)  := reduceBinPred ``GT.gt 4 (. > .)
goal: Lean.Meta.Simp.Simproc

full_name: BitVec.reduceGE
code: /-- Simplification procedure for `≥` on `BitVec`s. -/
builtin_simproc [simp, seval] reduceGE (( _ : BitVec _) ≥ _)  := reduceBinPred ``GE.ge 4 (. ≥ .)
goal: Lean.Meta.Simp.Simproc

full_name: BitVec.reduceULT
code: /-- Simplification procedure for unsigned less than `ult` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceULT (BitVec.ult _ _) :=
  reduceBoolPred ``BitVec.ult 3 BitVec.ult
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceULE
code: /-- Simplification procedure for unsigned less than or equal `ule` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceULE (BitVec.ule _ _) :=
  reduceBoolPred ``BitVec.ule 3 BitVec.ule
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSLT
code: /-- Simplification procedure for signed less than `slt` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceSLT (BitVec.slt _ _) :=
  reduceBoolPred ``BitVec.slt 3 BitVec.slt
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSLE
code: /-- Simplification procedure for signed less than or equal `sle` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceSLE (BitVec.sle _ _) :=
  reduceBoolPred ``BitVec.sle 3 BitVec.sle
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceZeroExtend'
code: /-- Simplification procedure for `zeroExtend'` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceZeroExtend' (zeroExtend' _ _) := fun e => do
  let_expr zeroExtend' _ w _ v ← e | return .continue
  let some v ← fromExpr? v | return .continue
  let some w ← Nat.fromExpr? w | return .continue
  if h : v.n ≤ w then
    return .done <| toExpr (v.value.zeroExtend' h)
  else
    return .continue
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceShiftLeftZeroExtend
code: /-- Simplification procedure for `shiftLeftZeroExtend` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceShiftLeftZeroExtend (shiftLeftZeroExtend _ _) := fun e => do
  let_expr shiftLeftZeroExtend _ v m ← e | return .continue
  let some v ← fromExpr? v | return .continue
  let some m ← Nat.fromExpr? m | return .continue
  return .done <| toExpr (v.value.shiftLeftZeroExtend m)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceExtracLsb'
code: /-- Simplification procedure for `extractLsb'` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceExtracLsb' (extractLsb' _ _ _) := fun e => do
  let_expr extractLsb' _ start len v ← e | return .continue
  let some v ← fromExpr? v | return .continue
  let some start ← Nat.fromExpr? start | return .continue
  let some len ← Nat.fromExpr? len | return .continue
  return .done <| toExpr (v.value.extractLsb' start len)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceReplicate
code: /-- Simplification procedure for `replicate` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceReplicate (replicate _ _) := fun e => do
  let_expr replicate _ i v ← e | return .continue
  let some v ← fromExpr? v | return .continue
  let some i ← Nat.fromExpr? i | return .continue
  return .done <| toExpr (v.value.replicate i)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceZeroExtend
code: /-- Simplification procedure for `zeroExtend` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceZeroExtend (zeroExtend _ _) := reduceExtend ``zeroExtend zeroExtend
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceSignExtend
code: /-- Simplification procedure for `signExtend` on `BitVec`s. -/
builtin_dsimproc [simp, seval] reduceSignExtend (signExtend _ _) := reduceExtend ``signExtend signExtend
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceAllOnes
code: /-- Simplification procedure for `allOnes` -/
builtin_dsimproc [simp, seval] reduceAllOnes (allOnes _) := fun e => do
  let_expr allOnes n ← e | return .continue
  let some n ← Nat.fromExpr? n | return .continue
  return .done <| toExpr (allOnes n)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceBitVecOfFin
code: builtin_dsimproc [simp, seval] reduceBitVecOfFin (BitVec.ofFin _)  := fun e => do
  let_expr BitVec.ofFin w v ← e | return .continue
  let some w ← evalNat w |>.run | return .continue
  let some ⟨_, v⟩ ← getFinValue? v | return .continue
  return .done <| toExpr (BitVec.ofNat w v.val)
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceBitVecToFin
code: builtin_dsimproc [simp, seval] reduceBitVecToFin (BitVec.toFin _)  := fun e => do
  let_expr BitVec.toFin _ v ← e | return .continue
  let some ⟨_, v⟩ ← getBitVecValue? v | return .continue
  return .done <| toExpr v.toFin
goal: Lean.Meta.Simp.DSimproc

full_name: BitVec.reduceShiftShift
code: /--
Helper function for reducing `(x <<< i) <<< j` (and `(x >>> i) >>> j`) where `i` and `j` are
natural number literals.
-/
@[inline] def reduceShiftShift (declName : Name) (thmName : Name) (e : Expr) : SimpM Step 
goal: Lean.Meta.SimpM Lean.Meta.Simp.Step

full_name: BitVec.reduceShiftLeftShiftLeft
code: builtin_simproc reduceShiftLeftShiftLeft (((_ <<< _ : BitVec _) <<< _ : BitVec _)) :=
  reduceShiftShift ``HShiftLeft.hShiftLeft ``shiftLeft_add
goal: Lean.Meta.Simp.Simproc

full_name: BitVec.reduceShiftRightShiftRight
code: builtin_simproc reduceShiftRightShiftRight (((_ >>> _ : BitVec _) >>> _ : BitVec _)) :=
  reduceShiftShift ``HShiftRight.hShiftRight ``shiftRight_add
goal: Lean.Meta.Simp.Simproc