       isEqual: (buildIsEqual(comps.multiplication))
       })
 
-
     # Number
     ref.forType(comps.number, {
-      isEqual: (buildIsEqual(comps.number)),
-      _simpleIsEqual: (other)->
+      isEqual: (buildIsEqual(comps.number, "checkNumberValues")),
+      checkNumberValues: (other, eq_calc)->
+
         # this is bad; TODO fix
         # The real "todo" here is that
         # numbers are internally of questionable state.
         # Im not entirely sure how to state that number expresison components are equal
-        "#{@value()}" == "#{other.value()}"
+        check = "#{@value()}" == "#{other.value()}"
+        eq_calc.saveFalseForReport(check, @unrefined(), other, "Numeric values not equal")
     })
 
-    ref.forType(comps.addition, {
-      isEqual: (buildIsEqual(comps.addition))
-      })
 
-    ref.forType(comps.multiplication, {
-      isEqual: (buildIsEqual(comps.multiplication))
-      })
-
-
-    ref.forType(comps.blank, {
-      isEqual: (buildIsEqual(comps.blank))
-      })
 
     ref.forType(comps.exponentiation, {
       isEqual: (buildIsEqual(comps.exponentiation)),

    })

    class ExpressionEquality
      initialize: (@first)->
      isEqual: (@second)->
        firstp = ref.refine @first
        firstp.isEqual @second

    class_mixer ExpressionEquality

    ExpressionEquality.isEqual = (a,b)->
      ExpressionEquality.build(a).isEqual(b)

    return ExpressionEquality


    logger = logger_builder.build(stringify_objects: false)

    buildIsEqual = (for_type, additional_method=false)->
      isEqualFunction = (other, eq_calc)->
        same_type = eq_calc.saveFalseForReport((other instanceof for_type), @unrefined(), other,
          "Wrong types")
        if same_type
          if additional_method
            @[additional_method](other, eq_calc)
          else
            true
        else
          false
      logger.instrument(name: "buildIsEqual function", fn: isEqualFunction)
