Exponentiation to multiplication to addition Multiplication between 2 integers can be reduced into a series of addition like so

3 * 5 = 3 + 3 + 3 + 3 + 3 = 5 + 5 + 5


Exponentiation (raising a to the power b) can also be reduced into a series of multiplications:

5 ^ 3 = 5 * 5 * 5


Therefore, exponentiation can be reduced into a series of additions, by creating a multiplication expression, then into a series of additions. For example, 5 ^ 3 (5 cubed) can be rewritten as

5 ^ 3 = 5 * 5 * 5
      = (5 + 5 + 5 + 5 + 5) * 5
      = (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5)
      = 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5


Your task is, given expressions added together consisting of exponentiation, multiplication and addition, reduce it to the shortest series of additions. The "shortest" expression is defined as the expression with the fewest number of + symbols, still using only one of the two numbers in the original expression. For example, the shortest expression of 10 * 2 is 10 + 10.

The numbers involved in the input will all be positive integers, and the expression will consist of only + (addition), * (multiplication) and ^ (exponentiation), along with integers and brackets (()) to indicate precedence.

The output should consist of positive integers and + symbols only. You shouldn't output the individual steps of the reductions, just the final output. The output may not consist of any numbers that don't appear in the input. However, you may use any 3 distinct symbols instead of +*^, but please say what symbols they are

The spaces  separating inputs and outputs may or may not be used in your programs, i.e. 3 * 5 can be outputted as either 5 + 5 + 5 or 5+5+5.

Note that in most cases, addition is not actually performed. The only case where addition is to be performed is when you have something like 5 ^ (1 + 2), in which case, addition is necessary to continue -&gt; 5 ^ 3 -&gt; 5 * 5 * 5 -&gt; .... See test case #4.

Your code does not need to handle inputs that arrive at an ambiguous expression. For example, (2 + 2) * (4 + 1). Because of the rules set forth so far, the goal is not to calculate the answer, the goal is to simplify to additions. So the result could be different depending on the order that expressions are resolved or commuted (which additions to simplify, which to leave?). Another invalid example: ((3 + 2) ^ 2) ^ 3 -&gt; ((3 + 2) * (3 + 2)) ^ 3 -&gt; ???.

This is code-golf so shortest code wins

Test cases

Input =&gt; output

5 ^ 3 + 4 * 1 ^ 5 =&gt; 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 4
2 ^ 1 * 2 + 3 + 9 =&gt; 2 + 2 + 3 + 9
2 ^ 1 * (2 + 3) + 9 =&gt; 2 + 3 + 2 + 3 + 9
2 ^ (1 * (2 + 3)) + 9 =&gt; 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 9
10 + 3 * 2 + 33 ^ 2 =&gt; 10 + 3 + 3 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33
100 * 3 =&gt; 100 + 100 + 100
2 ^ 1 + 2 ^ 1 + 2 ^ 2 + 8 ^ 1 =&gt; 2 + 2 + 2 + 2 + 8
(1 + 2 + 5 * 8 + 2 ^ 4) * 2 =&gt; 1 + 2 + 8 + 8 + 8 + 8 + 8 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 1 + 2 + 8 + 8 + 8 + 8 + 8 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2
Retina, 302 bytes
I'm sure this can be golfed, but at this point, I'm just glad it works. The exponentiation and multiplication sections are both very similar, but since order of operations is important, I don't know how to combine them.
y - Exponentiation
x - Multiplication
p - Addition
\d+
$*
{1`(\(\w+\)|1+)y(\(\w+\)|1+)
&gt;$0&lt;
(?&lt;=&gt;(\(\w+\)|1+)y1*)1
$1x
&gt;(\(\w+\)|1+)y
(
x&lt;
)
\((1+(x1+)*)\)(?!y)
$1
(?&lt;!1)(1+)x(\(\w+\)|1+\1)(?!1)
$2x$1
1`(\(\w+\)|1+)x1+
&gt;$0&lt;
(?&lt;=&gt;(\(\w+\)|1+)x1*)1
$1p
&gt;(\(\w+\)|1+)x
(
p&lt;
)
(?&lt;!x|y)\((1+(p1+)*)\)(?!x|y)
$1
y\((1+)p([1p]*\))
y($1$2
}`y\((1+)\)
y$1
1+
$.0

Try it online - all test cases
Test case converter
Explanation
\d+                             Convert to unary
$*
{1`(\(\w+\)|1+)y(\(\w+\)|1+)    Begin loop: Delimit current exponentiation group
&gt;$0&lt;
(?&lt;=&gt;(\(\w+\)|1+)y1*)1          Replace exponentiation with multiplication
$1x
&gt;(\(\w+\)|1+)y                  Replace garbage with parentheses
(
x&lt;
)
\((1+(x1+)*)\)(?!y)             Remove unnecessary parentheses around multiplication
$1
(?&lt;!1)(1+)x(\(\w+\)|1+\1)(?!1)  Maybe swap order of multiplicands
$2x$1
1`(\(\w+\)|1+)x1+               Delimit current multiplication group
&gt;$0&lt;
(?&lt;=&gt;(\(\w+\)|1+)x1*)1          Replace multiplication with addition
$1p
&gt;(\(\w+\)|1+)x                  Replace garbage with parentheses
(
p&lt;
)
(?&lt;!x|y)\((1+(p1+)*)\)(?!x|y)   Remove unnecessary parentheses around addition
$1
y\((1+)p([1p]*\))               Handle the 4th test case by adding if necessary
y($1$2
}`y\((1+)\)                     End of loop
y$1
1+                              Convert unary back to decimal
$.0

You may also notice that the most commonly used group is (\(\w+\)|1+). This matches an inner expression with parentheses, or an integer. I chose to use the symbols I did so that I could use \w rather than a character class. I'm not sure if it would be better to use non-word symbols and replace some lookarounds with word borders (\b).