 
         ref.forType(comps.classes.exponentiation, {
           base: ->
-            ref.refine(@unrefined().base()).toString()
+            ref.refine(@unrefined().base()).toString(include_parentheses_if_single: false)
           power: ->
-            ref.refine(@unrefined().power()).toString()
+            ref.refine(@unrefined().power()).toString(include_parentheses_if_single: false)
           toString: ->
             "#{@base()} ^ #{@power()}"
+
           toHTMLString: ->
             "#{@base()} &circ; #{@power()}"
           });

          })

        ref.forType(comps.classes.expression, {
          toString: (wrap_with_parentheses=true)->
            ret = @mapconcatWithMethod('toString')
            @maybeWrapWithParentheses(ret, wrap_with_parentheses)

          toHTMLString: (wrap_with_parentheses=true)->
            ret = @mapconcatWithMethod('toHTMLString')
            @maybeWrapWithParentheses(ret, wrap_with_parentheses)

          mapconcatWithMethod: (method)->
            _(@expression).map((it)-> ref.refine(it)[method]()).join(' ')

          maybeWrapWithParentheses: (str, do_wrap)->
            if do_wrap and @decideWrap()
              opening_paren = "( "
              closing_paren = if @isOpen() then "" else " )"
              "#{opening_paren}#{str}#{closing_paren}"
            else
              str

          decideWrap: ->
            @expression.length > 1

          });

        ref.forType(comps.classes.blank, {

          })

      toString: ->
        @ref.refine(@expression).toString(skip_parentheses: true)
      toHTMLString: ->
        @ref.refine(@expression).toHTMLString(skip_parentheses: true)

    class_mixer ExpressionToString

