     })
 
     ref.forType(comps.addition, {
-      isEqual: (buildIsEqual(comps.addition)),
-      _simpleIsEqual: (other)-> true # two additions are always equal to one another
+      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)),
+      _simpleIsEqual: (other)->
+        ref.refine(@base()).isEqual(other.base()) and
+          ref.refine(@power()).isEqual(other.power())
+      })
+
+    ref.forDefault({
+      isEqual: -> console.log(@); throw "NOT IMPLEMENTED"
+    })
+
 
     class ExpressionEquality
       initialize: (@first)->

  (class_mixer, object_refinement, comps)->
    ref = object_refinement.build()


    buildIsEqual = (for_type)->
      (other)->
        if other instanceof for_type
          @_simpleIsEqual(other)
        else if other instanceof comps.expression
          ref.refine(other).isEqual @
        else

        firstp = ref.refine @first
        firstp.isEqual @second

    class_mixer ExpressionEquality

    ExpressionEquality.isEqual = (a,b)->
