[Question]
  [
Given two integers greater than one, A and B, output four mathematical expressions in this order:
1. The plain expression A^B (A to the power B). e.g. if A = 2 and B = 3, `2^3`.
2. The expansion of A^B in terms of repeated multiplications of A. e.g. `2*2*2`.
3. The expansion of A^B in terms of repeated additions of A. e.g. `2+2+2+2`.
4. The expansion of A^B in terms of repeated additions of 1. e.g. `1+1+1+1+1+1+1+1`.
The four expressions may be output in any reasonable way as long as they are in order and clearly distinct. For example, you might put them in a list, or print them on separate lines
```
2^3
2*2*2
2+2+2+2
1+1+1+1+1+1+1+1
```
or perhaps on one line separated by equals signs:
```
2^3=2*2*2=2+2+2+2=1+1+1+1+1+1+1+1
```
Spaces may be inserted next to math operators so
```
2^3 = 2 * 2 * 2 = 2 + 2 + 2 + 2 = 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1
```
would be equally valid output when A = 2 and B = 3.
You may use symbols alternative to `^`, `*`, and `+`, but *only if* the new symbols are more idiomatic for your language (e.g. `**` instead of `^` in Python).
You may assume that A and B are sufficiently small so that A^B will not overflow your language's default integer type (given that that type has a reasonable maximum, 255 at least).
**The shortest code in bytes wins.**
# Test Cases
One output per line. The input can be inferred as the first expression is always A^B.
```
2^2 = 2*2 = 2+2 = 1+1+1+1
2^3 = 2*2*2 = 2+2+2+2 = 1+1+1+1+1+1+1+1
2^4 = 2*2*2*2 = 2+2+2+2+2+2+2+2 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
2^5 = 2*2*2*2*2 = 2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^2 = 3*3 = 3+3+3 = 1+1+1+1+1+1+1+1+1
3^3 = 3*3*3 = 3+3+3+3+3+3+3+3+3 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^4 = 3*3*3*3 = 3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^5 = 3*3*3*3*3 = 3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^2 = 4*4 = 4+4+4+4 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^3 = 4*4*4 = 4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
10^2 = 10*10 = 10+10+10+10+10+10+10+10+10+10 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
13^2 = 13*13 = 13+13+13+13+13+13+13+13+13+13+13+13+13 = 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
```
  
[Answer]
# [Python 3.6](https://docs.python.org/3.6), ~~88~~ 74 bytes
-2 bytes thanks to Dada (use `~`)  
-5 bytes thanks to Erwan (use f-strings from Python 3.6) 
```
lambda a,b:f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"+"+1"*~-a**b
```
*online ide anyone?*
### How?
This is an unnamed function taking the two integer inputs `a` and `b` each greater than `0` (even though the specification is only for those greater than `1`).
In Python 3.6 a new feature is available, namely [formatted string literals](https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings) or "f-strings". These allow run-time evaluated string construction. A leading `f` (or `F`) creates such a construct, e.g. `f"blah"` or `f'blah'`. Inside an f-string anything between a pair of braces, `{...}`, is an expression to be evaluated.
As such `f"{a}^{b}={a}{f'*{a}'*~-b}={a}{f'+{a}'*~-a**~-b}=1"` evaluates each of `a`, `b`, `a`, `f'*{a}'*~-b`, `a`, and `f'+{a}'*~-a**~-b}` as expressions, keeping the `^`, `=`, `=`, and `=1` as strings,all of which gets concatenated together.
The `a` and `b` expressions evaluate to the representations of `a` and `b` respectively.
The `f'*{a}'` and `f'+{a}'` in turn are also f-strings inside these expressions, which evaluate to `a` with a leading `'*'` and a leading `'+'` respectively
To create the required number of `a`s and operations for the `*` and `+` portions note that there will be `b` `a`s multiplied together and `a**(b-1)` `a`s added together. Each case then requires one less operator sign than the number of `a`s. So we can repeat the f-strings `f'*{a}`and `f'+{a}'` (using `*`) as many times as there are operators and prepend each with a single `a`. `(b-1)` is `~-b` and `(a**(b-1))-1` is `~-a**~-b`.
The same is done for the `1`s using `(a**b)-1` being `~-**b`, but we don't need the overhead of f-strings since `1` is constant, so a standard string repeated is concatenated with `+`.
---
Prior Python versions, 81:
```
lambda a,b:'%s^%s=%s=%s=1'%(a,b,('*%s'%a*b)[1:],('+%s'%a*a**~-b)[1:])+'+1'*~-a**b
```
**[Try it online!](https://tio.run/nexus/python3#PczNCgIhFIbhdV2FGznHnyBH2whzJf2AUsJAzcTouls350iBfPA@HEzjpT7DK94DCzp64PnG89ifAY4NNYLkGXiQUZyNv7ZWvYOUn0NHoUAZaNks1rSsrDxyYdPMEAc9CN3W0jraU1tLbsktuSV35I7cHCnMdiv8fvdep7ng9rf4RUJJ/QdR6xc)**
[Answer]
# Cubix, ~~238 234 217 151 110~~ 100 bytes
*Saved 14 bytes thanks to ETHProductions*
```
u'^.:s+.;;;\-?W?rsos\(rrOIO:ur>'=o;^u.;;.>$.vUo^'rsu1;;@!\q?s*su;;IOu*+qU../;(*\(s.;<..r:''uq....qu\
```
Expanded:
```
          u ' ^ . :
          s + . ; ;
          ; \ - ? W
          ? r s o s
          \ ( r r O
I O : u r > ' = o ; ^ u . ; ; . > $ . v
U o ^ ' r s u 1 ; ; @ ! \ q ? s * s u ;
; I O u * + q U . . / ; ( * \ ( s . ; <
. . r : ' ' u q . . . . q u \ . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
```
# Try it online!
[Try it here](https://ethproductions.github.io/cubix/?code=dSdeLjpzKy47OztcLT9XP3Jzb3NcKHJyT0lPOnVyPic9bztedS47Oy4+JC52VW9eJ3JzdTE7O0AhXHE/cypzdTs7SU91KitxVS4uLzsoKlwocy47PC4ucjonJ3VxLi4uLnF1XA==&input=Miwz&speed=10)
# Explanation
The code consists of 8 steps, with two loops. I'll go over the code part by part.
# Step 1 (A^B)
```
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
I O : u . . . . . . . . . . . . . . . .
U o ^ ' . . . . . . . . . . . . . . . .
; I O u . . . . . . / ; ( * \ . . . . .
? ? r : . . . . . . ? . . . \ ? ? ? ? ?
. . . . ? . . . . . ? . . . . . . . . .
          ? ? ? ? ?
          . . . . .
          . . . . .
          . . . . .
          . . . . .
```
This is the cube with the parts that are irrelevant to the first step removed. The question mark shows the no-ops the IP will visit, to make its path more clear.
```
IO:'^o;IO:r*(; # Explanation
I              # Push the first input (A)
 O             #   output that
  :            #   duplicate it
   '^          # Push the character "^"
     o         #   output that
      ;        #   pop it from the stack
       I       # Push the second input (B)
        O      #   output that 
         :     #   duplicate
          r    #   rotate top 3 elements
           *   # Push the product of the top two elements
            (  #   decrease it by one
             ; #   pop it from the stack (making the last
               #   two operations useless, but doing it
               #   this way saves 10B)
```
Now, the stack looks like this: `A, B, A, B`
# Step 2 (prepare for print loop)
The print loop takes 3 arguments (the top 3 elements on the stack): `P`, `Q` and `R`. `P` is the amount of repetitions, `Q` is the separator (character code) and `R` is the number to repeat. Luckily, the loop also takes care of the requirement that the resulting string should end in `R`, not `Q`.
We want to repeat `A*` exactly `B` times, so the separator is `*`. Note that the stack starts as `A, B, A, B`. Once again, I removed all irrelevant instructions. The IP start at the `S` pointing north.
```
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
. . . . r . . . . . . . . . . . . . . .
. . . . r . . . . . . . . . . . . . . .
. . . . * . . . . . . . . . . . . . . .
. . . . ' . . . . . . . . . . . . . . .
. . . . S . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
'*rr # Explanation
'*   # Push * (Stack: A, B, A, B, *)
  rr # Rotate top three elements twice
```
The stack is now `A, B, B, *, A`.
# Step 3/6/8 (the print loop)
## Concept
```
E . . . . .
? r s o s u 
\ ( r r O <
. . . . . S
```
The IP enters the loop through `S`, pointing north, and exits the loop at `E`, pointing north again. For this explanation, the stack is set to `[..., A, B, C]`. The following instructions are executed. Note that the IP can't leave the loop before the question mark, so the first four instructions will always be executed.
```
Orr(?rsos # Explanation
O         # Output `C`
 rr       # Rotate top three elements twice (Stack: [..., B, C, A])
   (      # Decrease A by one (Stack: [..., B, C, A-1])
    ?     # If top of stack (A) > 0:
     r    #    Rotate top of stack (Stack: [..., A-1, B, C])
      s   #    Swap top elements (Stack: [..., A-1, C, B])
       o  #    Output top of stack (B) as character code
        s #    Swap top elements (Stack: [..., A-1, B, C]
          #
          # ... and repeat ...
```
## Implementation
Here's the cube again, with the irrelevant parts removed. The IP starts at `S`, pointing east.
```
          . . . . .
          . . . . .
          . . . . .
          ? r s o s
          \ ( r r O
. . . . . S ' = o ; ^ u . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
```
As you can see, the IP comes across four instructions before it enters the loop. Since the character code is removed again, we reach the loop with the exact same stack as we entered this part.
```
'=o; # Explanation
'=   # Push =
  o  #     Output
   ; #     Pop from stack
```
Inside the loop, the explanation above holds.
# Step 4 (differentiating the IPs)
Since we use the above loop multiple times, and they all cause the IP to end up in the same spot, we have to differentiate between multiple runs. First, we can distinguish between the separator (first run has a `*`, whereas runs two and three have a `+` as separator). We can differentiate between runs 2 and 3 by checking the value of the number that is repeated. If that is one, the program should terminate.
## First comparison
Here's what it looks like on the cube. The IP starts at S and points north. The stack contains `[..., * or +, A or 1, 0]`. The number 1 shows where the IP will end up if this is the first loop (pointing north) and the number 2 shows where the IP will end up if this is the second (or third) loop (pointing east).
```
          u ' . . .
          s + . 1 .
          ; \ - ? 2
          S . . . .
          . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
;s'+-? # Explanation
;      # Delete top element (0)
 s     # Swap the top two elements (Stack: 1/A, */+)
  '+   # Push the character code of + 
    -  # Subtract the top two elements and push
       #  that to the stack (Stack: 1/A, */+, +, (*/+)-+)
     ? # Changes the direction based on the top
       # item on the stack. If it's 0 (if (*/+) == +)
       # the IP continues going right, otherwise, it
       # turns and continues going north.
```
If the IP now is at `1`, the stack is `[A, *, +, -1]`. Otherwise, the stack is `[A or 1, +, +, 0]`. As you can see, there still is an unknown in the stack of the second case, so we have to do another comparison.
## Second comparison
Because the IP has gone through step 5, the stack looks like this: `[A^(B-1) or nothing, A or 1, +, +, 0]`. If the first element is `nothing`, the second element is `1`, and the reverse holds too. The cube looks like this, with the IP starting at S and pointing east. If this is the second loop, the IP ends up at `E`, pointing west. Otherwise, the program hits the `@` and terminates.
```
          . . . . .
          . . . . ;
          . . . S W
          . . . . .
          . . . . .
. . . . . . . . . . . . . ; . . . . . .
. . . . . . . . . E @ ! \ q . . . . . .
. . . . . . . . . . . . ( * . . . . . .
. . . . . . . . . . . . q u . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
```
The instructions executed that don't do anything to the control flow are listed below.
```
;;q*q(!@
;;       # Delete top two elements (Stack [A^(B-1)/null, A/1, +])
  q      # Send top element to the bottom (Stack [+, A^(B-1)/0, A/1])
   *     # Push product of top two elements 
         #    (Stack [+, A^(B-1)/0, A/1, A^B/0])
    q    # Send top element to the bottom 
         #    (Stack [A^B/0, +, A^(B-1)/0, A/1])
     (   # Decrease the top element by 1 
         #    (Stack [A^B/0, +, A^(B-1)/0, (A-1)/0])
      !  # If (top element == 0):
       @ #  Stop program
```
The stack is now `[A^B, +, A^(B-1), A-1]`, provided the program didn't terminate.
# Step 5 (preparing for "A+" (repeat A^(B-1)))
Sadly, Cubix doesn't have a power operator, so we need another loop. However, we need to clean up the stack first, which now contains `[B, A, *, +, -1]`.
## Cleaning up
Here's the cube again. As usual, the IP starts at S (pointing north), and ends at E, pointing west.
```
          . . . ? .
          . . . ; .
          . . . S .
          . . . . .
          . . . . .
. . . . . . . . . . . . . . . . > $ . v
. . . . . . . . . . . . . . . . . . . ;
. . . . . . . . . . . . . . . . . . E <
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
;; # Explanation
;; # Remove top 2 elements (Stack: [B, A, *])
```
## Calculating A^(B-1)
Another loop which works roughly the same as the print loop, but it's a bit more compact. The IP starts at `S`, pointing west, with stack `[B, A, *]`. The IP exits at `E` pointing north.
```
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
. . . . . . . . . . . . . . E . . . . .
. . . . . . . . . . . . . . ? s * s u .
. . . . . . . . . . . . . . \ ( s . ; S
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
```
The loop body is the following.
```
;s(?s*s # Explanation
;       # Pop top element.
 s      # Shift top elements.
  (     # Decrease top element by one
   ?    # If not 0:
    s   #    Shift top elements again
     *  #    Multiply
      s #    Shift back
        #
        # ... and repeat ...
```
The resulting stack is `[A, A^(B-1), 0]`.
## Cleaning up the stack (again)
Now we need to get to the print loop again, with the top of the stack containing `[..., A^(B-1), +, A]`. To do this, we execute the following. Here's the cube again,
```
          . . ^ ? :
          . . . . .
          . . . . .
          . . . . .
          E . . . .
. . . . . s . . . . . . . . ; . . $ . .
. . . . . + q U . . . . . . S . . s . .
. . . . . ' u q . . . . . . . . . ? . .
. . . . . . . ? . . . . . . . . . ? . .
. . . . . . . ? . . . . . . . . . ? . .
          . . ? . .
          . . ? . .
          . . ? . .
          . . ? . .
          . . ? . .
;:$sqq'+s # Explanation
;         # Delete top element (Stack: [A, A^(B-1)])
 :        # Copy top element
  $s      # No-op
    qq    # Send top two elements to the bottom
          #   (Stack: [A^(B-1), A^(B-1), A])
      '+  # Push +
          #   (Stack: [A^(B-1), A^(B-1), A, +])
        s # Swap top two elements
          #   (Stack: [A^(B-1), A^(B-1), +, A])
```
# Step 7 (preparing for last loop)
The stack is now `[A^B, +, A^(B-1), A-1]`, the IP starts at `S`, going west, and ends at `E`, going right.
```
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
. . . . . E . . . . . . . . . . . . . .
. . . . . . u 1 ; ; S . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
          . . . . .
```
The instructions executed:
```
;;1 # Explanation
;;  # Delete top two elements
  1 # Push 1
```
The stack now looks like `[A^B, +, 1]`, and the IP is about to enter the print loop, so we're done.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 46 bytes
```
XH'^'i'='XJ2G:"H'*']xJ&Gq^:"H'+']xJ&G^:"1'+']x
```
[Try it online!](https://tio.run/nexus/matl#@x/hoR6nnqluqx7hZeRupeShrqUeW@Gl5l4YB@JoQzhAtiGY/f@/EZcxAA "MATL – TIO Nexus")
Stretching the limits of "reasonable way" here, but the expressions are separated.
## Explanation
First expression:
```
XH'^'i'='XJ
XH         % implicitly take input A, save it to clipboard H
'^'        % push literal '^'
i          % take input B
'='        % push literal '='
XJ         % copy '=' to clipboard J, we'll use this twice more so it's worth it
```
Second expression:
```
2G:"H'*']xJ
2G         % paste the second input (B) again
:"         % do the following B times
  H        % paste A from clipboard H
  '*'      % push literal '*'
]          % end loop
x          % delete the final element (at the moment we have a trailing *)
J          % paste '=' from clipboard J
```
Third expression:
```
&Gq^:"H'+']xJ
&G         % paste all of the input, ie push A and B
q          % decrement B
^          % power, giving A^(B-1)
:"         % do the following A^(B-1) times 
  H        % paste A from clipboard H
  '+'      % push literal '+'
]          % end loop
x          % delete the final element (at the moment we have a trailing +)
J          % paste '=' from clipboard J
```
Fourth expression:
```
&G^:"1'+']x
&G         % paste all of the input, ie push A and B
^          % power, giving A^B
:"         % do the following A^B times 
  1        % push 1
  '+'      % push '+'
]          % end loop
x          % delete the final element (at the moment we have a trailing +)
           % (implicit) convert all to string and display
```
[Answer]
## JavaScript (ES7), 78 bytes
Takes input in currying syntax `(a)(b)`. Outputs a string.
```
a=>b=>a+'^'+b+(g=o=>'='+a+('+*'[+!o]+a).repeat(b-1))()+g(b=a**~-b)+g(b*=a,a=1)
```
### Test cases
```
let f =
a=>b=>a+'^'+b+(g=o=>'='+a+('+*'[+!o]+a).repeat(b-1))()+g(b=a**~-b)+g(b*=a,a=1)
console.log(f(2)(2));
console.log(f(2)(3));
console.log(f(2)(4));
console.log(f(2)(5));
console.log(f(3)(2));
console.log(f(3)(3));
console.log(f(3)(4));
console.log(f(3)(5));
console.log(f(4)(2));
console.log(f(4)(3));
console.log(f(10)(2));
console.log(f(13)(2));
```
[Answer]
## Ruby, 52 bytes
```
->a,b{[[a,b]*?^,[a]*b*?*,[a]*a**~-b*?+,[1]*a**b*?+]}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 30 bytes
```
mUð¹'^²J'*¹«²×'+¹«X¹÷×„+1X×)€¦
```
Explanation:
```
mU                               # Store a^b in variable X
  ð                              # Push a space character to the stack (will be deleted at the end, but this is needed to keep the character count low)
   ¹'^²J                         # Push the string "a^b" to the stack
        '*¹«                     # Push the string "*a" to the stack
            ²×                   # Repeat b times
              '+¹«               # Push the string "+a" to the stack
                  «X¹÷×          # Repeat a^b / a times
                       „+1       # Push the string "+1" to the stack
                          X×     # Repeat a^b times
                            )    # Wrap stack to array
                             €¦  # Remove the first character from each element in the array
```
[Try it online!](https://tio.run/nexus/05ab1e#@58benjDoZ3qcYc2ealrHdp5aPWhTYenq2uDWBGHdh7efnj6o4Z52oYRh6drPmpac2jZ//9GXMYA "05AB1E – TIO Nexus")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~156~~ 149 bytes
```
#define q for(x=0;x
x,y;p(a,b,c){printf("%c%d",x?b:61,c),x+=a;}e(n,i){x=1;p(0,0,n);p(0,94,i);y=!!i;q<i;y*=n)p(1,42,n);q<y;)p(n,43,n);q<y;)p(1,43,1);}
```
*-2 bytes* if we can ignore 0 powers; `y=!!i` may become `y=1` 
[Try it online!](https://tio.run/nexus/c-gcc#bY3NDoIwEAbvPEXBkLS4hxariS6Nz1L@Yg9WIJi0Ep4dW7148DYz2c237dquN7YjI@kfE3WKo0sceByohhoatgyTsXNPs7zJ2wzctb6cROjg9krj2lELhi1OifDBgYNlHzjLkNGrNDU4VgZ9oSwbqABZxpOx8hjUgjz8qIgqGK5bmCR3bSyN8ALS3PRUFJ6RJSGEdLQEGXaec@xUcIbffAT@L0soA67bGw "C (gcc) – TIO Nexus")
[Answer]
# Java 7, 170 bytes
```
String c(int a,int b){String s="=",r=a+"^"+b+s+a;double i=0,x=Math.pow(a,b);for(;++i<b;r+="*"+a);r+=s+a;for(i=0;++i<x/a;r+="+"+a);r+=s+1;for(i=0;++i<x;r+="+1");return r;}
```
**Ungolfed:**
```
String c(int a, int b){
  String s = "=",
         r = a+"^"+b+s+a;
  double i = 0,
         x = Math.pow(a,b);
  for(; ++i < b; r += "*"+a);
  r += s+a;
  for(i = 0; ++i < x/a; r += "+"+a);
  r += s+1;
  for(i = 0; ++i < x; r += "+1");
  return r;
}
```
**Test code:**
[Try it here.](https://ideone.com/B8xNea)
```
class M{
  static String c(int a,int b){String s="=",r=a+"^"+b+s+a;double i=0,x=Math.pow(a,b);for(;++i<b;r+="*"+a);r+=s+a;for(i=0;++i<x/a;r+="+"+a);r+=s+1;for(i=0;++i<x;r+="+1");return r;}
  public static void main(String[] a){
    System.out.println(c(2,2));
    System.out.println(c(2,3));
    System.out.println(c(2,4));
    System.out.println(c(2,5));
    System.out.println(c(3,2));
    System.out.println(c(3,3));
    System.out.println(c(3,4));
    System.out.println(c(3,5));
    System.out.println(c(4,2));
    System.out.println(c(4,3));
    System.out.println(c(10,2));
    System.out.println(c(13,2));
  }
}
```
**Output:**
```
2^2=2*2=2+2=1+1+1+1
2^3=2*2*2=2+2+2+2=1+1+1+1+1+1+1+1
2^4=2*2*2*2=2+2+2+2+2+2+2+2=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
2^5=2*2*2*2*2=2+2+2+2+2+2+2+2+2+2+2+2+2+2+2+2=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^2=3*3=3+3+3=1+1+1+1+1+1+1+1+1
3^3=3*3*3=3+3+3+3+3+3+3+3+3=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^4=3*3*3*3=3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
3^5=3*3*3*3*3=3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3+3=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^2=4*4=4+4+4+4=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
4^3=4*4*4=4+4+4+4+4+4+4+4+4+4+4+4+4+4+4+4=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
10^2=10*10=10+10+10+10+10+10+10+10+10+10=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
13^2=13*13=13+13+13+13+13+13+13+13+13+13+13+13+13=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1
```
[Answer]
# [Brainfuck](https://github.com/TryItOnline/tio-transpilers), 372 bytes
```
,.>++++++++[>++++++++++++>++++++++>+++++<<<-]>--.<,.>>---.>++>++++++++[<<<<------>>>>-]<<<<-[<.>>>>.>>+<<<<<-]<.>>>.<<++++++++[<------>-]<[>+>>>>+<<<<<-]>>>>>>>+<[->[-<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<<]>[-<+>]<<]>[<+>>+<-]>[<+>-]<<<<<<<<++++++++[>++++++<-]>>>>+>>-[<<<<<.>>>.>>-]<<<<<.>>.>>>>[<+>-]<<[->[->+>+<<]>>[-<<+>>]<<<]>>>++++++++[<<<++++++>>>-]<<<+>>-[<<.<.>>>-]<<.
```
[Try it online!](https://tio.run/nexus/brainfuck#XVBLFgMhCDuQhUVflzwu4vP@x7BJwE5nWGj4JET3y3N0zB9i5B1EhK008wADt5F3UYN9RSJsKZ/hzHCQTgEVPOLiNQktrOf0Gc2KEdNyWvBCVm01WYQS4WIJ@WjE6qAGUZnR7OOhvQXDpgeUu2OfmfwfERkpC6vWD62Wnf@f6H9roZZ3qbPie78/Xw "brainfuck – TIO Nexus")
# Notes
1. The two inputs must be chosen in such a way, that `A**B` does not exceed `255`. This is because brainfuck can only store values of one byte.
2. If one input is bigger than 9, use the next ASCII character. `10` becomes `:`, `11` becomes `;` etc. This is because Brainfuck can only take inputs of one byte.
# Explanation
Here is my somewhat commented code. I'll expand on this later.
```
,.                      print A
> +++++ +++
[
    > +++++ +++++ ++    set up 96 (for ^ sign)
    > +++++ +++         set up 64 (for = sign)
    > +++++             set up 40 (for plus and * sign)
    <<< -
]
> --.                   print ^
< ,.                    print B
>
> ---.                  print =
> ++                    prepare *
> +++++ +++             convert B from char code
[
    <<<< ----- -
    >>>> -
]
<<<< -                  print loop "A*"
[
    < .
    >>>> .
    >> +
    <<<<< -
]
< .                     print final A
>>> .                   print =
<< +++++ +++            convert A from char code
[
    < ----- -
    > -
]
<
[                       duplicate A
    > +
    >>>> +
    <<<<< -
]
>>>>>                   exponentiation (A**(B minus 1))
>>+<[->[-<<[->>>+>+<<<<]>>>>[-<<<<+>>>>]<<]>[-<+>]<<]<
>>
[                       duplicate
    < +
    >> +
    < -
]
>[<+>-]                 move
<<<<< <<< +++++ +++     convert A to char code
[
    > +++++ +
    < -
]
>>>> +                  convert * to plus sign
>> -                    print loop "A plus"
[
    <<<< < .
    >>> .
    >> -
]
<<<<< .                 print final A
>> .                    print =
>>>>                    move
[
    < +
    > -
]
                        multiply A**(B minus 1) by A
<<[->[->+>+<<]>>[-<<+>>]<<<]        
>>> +++++ +++           generate the char code for 1 (49)
[                           generate 8*6 = 48
    <<< +++++ +
    >>> -
]
<<< +                       add one
>> -                    print loop "1 plus"
[
    << .
    < .
    >>> -
]
<< .                    print final 1
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), ~~38~~ ~~35~~ 34 bytes
33 bytes of code, +1 for `-n` flag.
```
Ya**b[gJ'^aRLbJ'*aRLy/aJ'+1XyJ'+]
```
Takes A and B as command-line arguments; prints one expression per line. [Try it online!](https://tio.run/nexus/pip#@x@ZqKWVFJ3upR6XGOST5KWuBaQq9RO91LUNIyqBZOz///918/4b/zcGAA "Pip – TIO Nexus")
### Explanation
`Ya**b` is setup code: yank `a**b` into the `y` variable. After that, we have a list (in `[]`) containing our four expressions:
* `gJ'^`: take full ar`g`list (here, a list containing `a` and `b`) and `J`oin it on `^`
* `aRLbJ'*`: use `R`epeat`L`ist to create a list with `b` copies of `a`, then `J`oin it on `*`
* `aRLy/aJ'+`: use `RL` to create a list with `y/a` (i.e. `a**(b-1)`) copies of `a`, then `J`oin it on `+`
* `1XyJ'+`: `1`, string-multiplied by `y`, `J`oined on `+`
The list is printed with newline as the separator thanks to the `-n` flag.
[Answer]
## Javascript ~~115~~ ~~113~~ 104 bytes
Thanks to @Neil and @TuukkaX for golfing off one byte each and @ETHproductions and Luke for golfing off 9 bytes
```
a=>b=>[a+'^'+b,(a+'*').repeat(b-1)+a,(a+'+').repeat(Math.pow(a,b-1)-1)+a,1+'+1'.repeat(Math.pow(a,b)-1)]
```
[Try it Online](https://tio.run/nexus/javascript-node#S7P9r5Gok6RpaxedqK0ep66dpKMBZGipa@oVpRakJpZoJOkaamongkW1EaK@iSUZegX55SDNQAUQNYZAJYbq2JSAFMT@T87PK87PSdXLyU/XSNMw1jHW1EnTMIFQRjqmmpr/AQ)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 29 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
*⁹’,¤;@
,`;1ẋ"ç
,W;çj"“^*++”Y
```
**[Try it online!](https://tio.run/nexus/jelly#ATIAzf//KuKBueKAmSzCpDtACixgOzHhuosiw6cKLFc7w6dqIuKAnF4qKyvigJ1Z////MTP/Mg "Jelly – TIO Nexus")**
### How?
```
*⁹’,¤;@ - Link 1, get list lengths: a, b
    ¤   - nilad followed by link(s) as a nilad
 ⁹      - right: b
  ’     - decrement: b-1
   ,    - pair with right: [b-1, b]
*       - exponentiate: [a^(b-1), a^b]
     ;@ - concatenate with reversed arguments: [b, a^(b-1), a^b]
,`;1ẋ"ç - Link 2, create lists: a, b
 `      - monad from dyad by repeating argument
,       - pair: [a, a]
  ;1    - concatenate 1: [a, a, 1]
      ç - last link (1) as a dyad: [b, a^(b-1), a^b]
     "  - zip with the dyad...
    ẋ   -     repeat list:  [[a, a, ..., a], [a, a, ..., a], [1, 1, ..., 1]]
                                <- b ->       <- a^(b-1) ->     <- a^b ->
,W;çj"“^*++”Y - Main link: a, b
,             - pair: [a, b]
 W            - wrap: [[a, b]]
   ç          - last link (2) as a dyad: [[a, a, ..., a], [a, a, ..., a], [1, 1, ..., 1]]
  ;           - concatenate [[a, b], [a, a, ..., a], [a, a, ..., a], [1, 1, ..., 1]]
      “^*++”  - list of characters: ['^', '*', '+', '+']
     "        - zip with the dyad...
    j         -     join: ["a^b", "a*a*...*a", "a+a+...+a", "1+1+...+1"]
            Y - join with line feeds
              - implicit print
```
[Answer]
# [tinylisp](https://github.com/dloscutoff/Esolangs/tree/master/tinylisp) repl, ~~178~~ 186 bytes
```
(load library
(d W(q((_ N S #)(i(e # 1)(c N _)(W(c S(c N _))N S(s # 1
(d ^(q((x y)(i y(*(^ x(s y 1))x)1
(d X(q((A B)(list(list A(q ^)B)(W()A(q *)B)(W()A(q +)(^ A(s B 1)))(W()1(q +)(^ A B
```
Using the repl saves 8 bytes in implied closing parentheses at the ends of lines. Defines a function `X` which takes two numbers and returns a list of expressions. Each expression is parenthesized, with spaces around the operators (actually, it's a list of numbers and operator symbols):
```
((2 ^ 3) (2 * 2 * 2) (2 + 2 + 2 + 2) (1 + 1 + 1 + 1 + 1 + 1 + 1 + 1))
```
Hopefully this output format is acceptable. [Try it online!](https://tio.run/nexus/tinylisp#TU0xDoMwENv7CkssPjoF2gfAA7owwASipQMSUgV0IK9P76K0aobY5/PZgctrnLDM923cvJw4oeVKDrihQSac@UQGJ3yoMghbJU0aRD3c4zo@u@7t@oDXS3jm7HGoxZvlEPd1deaqUAuXeX/HDxVX9FJbhRjP//hZNKjSoDp2mex@ssak@g4FioRlwkvCa8Qy7cu0dyaE8AE "tinylisp – TIO Nexus") (with several test cases).
### Explanation
```
(load library)
```
We need two functions from the standard library: `list` and `*`.
```
(d W(q((_ N S #)(i(e # 1)(c N _)(W(c S(c N _))N S(s # 1))))))
```
Define a function `W` (short for "weave") that takes an accumulator `_`, a number `N`, a symbol `S`, and a count `#`. We will use this function to generate most our expressions: for example, `(W () 2 (q +) 3)` will result in `(2 + 2 + 2)`.
If the count is 1 `(e # 1)`, then cons the number to the front of the accumulator `(c N _)` and return that. Otherwise, recurse:
* New accumulator is `(c S(c N _))`: the symbol and the number cons'd to the front of the previous accumulator;
* `N` and `S` are the same;
* New count is `(s # 1)`: count - 1.
The accumulator idiom is needed to achieve [proper tail recursion](https://en.wikipedia.org/wiki/Tail_call), preventing a recursion depth error. (This change is responsible for the +8 to the byte count. The `13^2` case didn't work in the previous version.)
```
(d ^(q((x y)(i y(*(^ x(s y 1))x)1))))
```
Unfortunately, the library has no exponentiation function at this time, so we have to define one. `^` takes `x` and `y`. If `y` is truthy (nonzero), we recurse with `y-1` (`(s y 1)`) and multiply the result by `x`. Otherwise, `y` is zero and we return `1`.
(Note: This function does *not* use proper tail recursion. I assume that the exponents will be small enough that it won't matter. Some experimenting on TIO indicated a maximum exponent of 325, which I would argue should be sufficient for this question. If the OP disagrees, I will change it.)
```
(d X(q((A B)(list(list A(q ^)B)(W()A(q *)B)(W()A(q +)(^ A(s B 1)))(W()1(q +)(^ A B))))))
```
Finally, the function we're interested in, `X`, takes `A` and `B` and returns a list of four items:
* `(list A(q ^)B)`: a list containing `A`, a literal `^`, and `B`;
* `(W()A(q *)B)`: call `W` to get a list of `B` copies of `A`, interwoven with literal `*`;
* `(W()A(q +)(^ A(s B 1)))`: call `W` to get a list of `A^(B-1)` copies of `A`, interwoven with literal `+`;
* `(W()1(q +)(^ A B))`: call `W` to get a list of `A^B` copies of `1`, interwoven with literal `+`.
[Answer]
# Pyth, ~~32~~ 31 bytes
```
AQjMC,"^*++"[Q*]GH*^GtH]G*]1^GH
```
Takes input as `[2,10]`, outputs as `["2^10", "2*2*2*2*2*2*2*2*2*2", "2+2+...`
Explanation:
```
Q = eval(input())                     #  
G, H = Q                              #  AQ
operators = "^*++"                    #        "^*++"
operands = [Q,                        #              [Q
  [G]*H,                              #                *]GH
  G**(H-1)*[G]                        #                    *^GtH]G
  [1]*G**H                            #                           *]1^GH
]                                     #
map( lambda d: join(*d),              #    jM
     zip(operators, operands)         #      C,...
)                                     #
```
[Try it here.](http://pyth.herokuapp.com/?code=AQjMC%2C%22%5E%2a%2B%2B%22%5BQ%2a%5DGH%2a%5EGtH%5DG%2a%5D1%5EGH&test_suite=1&test_suite_input=%5B2%2C2%5D%0A%5B2%2C3%5D%0A%5B2%2C4%5D%0A%5B2%2C5%5D%0A%5B3%2C2%5D%0A%5B3%2C3%5D%0A%5B3%2C4%5D%0A%5B3%2C5%5D%0A%5B4%2C2%5D%0A%5B4%2C3%5D%0A%5B10%2C2%5D%0A%5B13%2C2%5D&debug=1)
[Answer]
# [Perl](https://www.perl.org/), 81 bytes
78 bytes of code + `-n` flag (counted as 3 bytes since the code contains `$'`).
```
$,=$/;print s/ /^/r,map{/\D/;join$&,($`)x$'}"$`*$'","$`+".$`**~-$',"1+".$`**$'
```
[Try it online!](https://tio.run/nexus/perl#U1bULy0u0k/KzNMvSC3KUdDNy/mvomOrom9dUJSZV6JQrK@gH6dfpJObWFCtH@Oib52Vn5mnoqajoZKgWaGiXqukkqCloq6kA6S1lfSAHK06XRV1HSVDKE9F/f9/YwVjLiMFEy5jBRMA "Perl – TIO Nexus")
[Answer]
## R, 147 bytes
```
w=switch;function(A,B)for(s in letters[1:4]){cat(rep(w(s,d=1,a=c(A,B),b=,c=A),w(s,a=1,b=B,c=A^B/A,d=A^B)),sep=w(s,a="^",b="*",d=,c="+"));cat("\n")}
```
Anonymous function that outputs the required, well, outputs, line-by-line. This solution makes extensive use of the `switch` function. 
The `switch` function takes an expression (here, `s`) that evaluates to a number or a character string (see `?switch`), followed by the alernatives corresponding to `s`. If an alternative is missing (e.g. `switch(s, a=, b= "PPCG")`, the next non-missing alternative is evaluated (in the example, `s="a"` outputs `"PPCG"`).
The `rep` functions repeats (replicates, actually) its first argument the number of times indicated in the second argument.
`cat`, to finish, concatenate and prints the objects, with a separator that can be chosen with the `sep =` argument. The second `cat` function is here for the line-break.
**Ungolfed:**
```
f=function(A,B)
    for(s in letters[1:4]){
        cat(
            rep(switch(s, d = 1, a = c(A,B), b =, c = A),
            switch(s, a = 1, b = B, c = A^B/A, d = A^B)),
        sep=switch(s,a = "^", b = "*", d =, c = "+"))
    cat("\n")
}
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 42 bytes
```
q_'#/)i*_'**\__:i:*_@0=i/@0=*'+*\'1*'+*]N*
```
[Try it online!](https://tio.run/nexus/cjam#@18Yr66sr5mpFa@upRUTH2@VaaUV72Bgm6kPJLTUtbVi1A1BVKyf1v//xsomAA "CJam – TIO Nexus")
[Answer]
# k, 44 bytes
```
{"^*++"{x/$y}'(x,y;y#x;(x*y-1)#x;(*/y#x)#1)}
```
[Test cases.](http://johnearnest.github.io/ok/?run=%20%7B%22%5E%2a%2B%2B%22%7Bx%2F%24y%7D%27%28x%2Cy%3By%23x%3B%28x%2ay-1%29%23x%3B%28%2a%2Fy%23x%29%231%29%7D.%27%282%202%3B2%203%3B2%204%3B2%205%3B3%202%3B3%203%3B3%204%3B3%205%3B4%202%3B4%203%3B10%202%3B13%202%29)
[Answer]
# [Cardinal](https://esolangs.org/wiki/Cardinal) 202 bytes
```
%:.~:#"^"."=">v
x            "~
             *.
     >~=088v "~
     v88+88< ?
     8       -
     8      x#<
     v     < 0
     >   t / <
v~.~ <#"="?<
-
#?"+"^t
0
V
#?"="  >"1"-v
/ {   <^"+"?<
>     ^
```
Will only work for numbers where the calculated value <256 due to limitations in the values that can be held by pointers in Cardinal
[Try it Online](https://tio.run/nexus/cardinal#VY7BCsMwCIbvPoUYdllJmu4kxSRvsWOeokhh4KtnaRtGJyh@@PFje6zBVkeVAiXKCjveigzuiM9wcbYUmfV3V@aJWbBcyEP3f7g7GfY5BeMI673hjAJqwVBcf6QIeHCFJqobRHgfe6Lu0kJeYcbPkVD7vZv5jKmtLRFeXw)
# Explanation:
## Step 1
```
%:.~:#"^"."="
```
Receives two numbers a and b as input and outputs as "a^b="  
Passes a pointer with active value a and inactive value b
## Step 2
```
        >v
        "~
        *.
>~=088v "~
v88+88< ?
8       -
8      x#<
v     < 0
>   t / <
```
Receives a pointer with active value a and inactive value b printing "a"+("\*a")(b-1) times  
Passes a pointer with active value a^(b-1) to the next part
## Step 3
```
v~.~ <#"="?<
-
#?"+"^t
0
V
#?"="  
/ {   <
>     ^ 
```
Receives a pointer with value of a^(b-1) and outputs "=a"+("+a")repeated(a^(b-1)-1)times+"="  
Passes a pointer with value a^b to the next part
## Step 4
```
>"1"-v
^"+"?<
```
Receives a pointer with value a^b and prints out "1"+("+1")repeated a^b-1 times
[Answer]
# Retina, ~~89~~ 88 bytes
```
*`,
^
+`(1+),1
$1*$1,
:`.1+.$
{`^[1+]+
a$&z
+`a(.+)z.1
$1+a$1z*
)`.a.+z.
:`a
+`11
1+1
```
Input is comma separated unary numbers.
[Try it online!](https://tio.run/nexus/retina#FcvBDYAwEAPBv@s4oSSOTvKXVhDoXAfFh7Dv2TVq4gGriX0KoRGaOCvFDOCt5xJvwnF4M7dkd/6QDnmgVzrpxJ6MTSSIWkua2n0)
]