Represent n as an expression containing all the digits Related Challenge: Single Digit Representations of Natural Numbers

Task

Write a program/function that when given a non-negative integer \$n \le 100000\$ outputs an expression which uses all the digits from \$0\$ to \$9\$ exactly once and evaluates to \$n\$

The expression outputted by your program may only use the operations listed below:


addition
subtraction and unary minus (both must have the same symbol)
multiplication
division (fractional, i.e. 1/2 = 0.5)
exponentiation
parentheses


Note: Concatenation is not allowed

Output Format


Output can be a string, list of operations and numbers or a list of lists in place of brackets.
You may choose the precedence of the operators but it must be consistent for all outputs produced by your program/function
Output may be in polish, reverse polish or infix notation but it must be consistent for all outputs produced by your program/function.
You can use custom symbols for representing the digits and operations but the symbols used for representing the digits and operations should be distinct.


Scoring

This is code-golf so shortest bytes wins

Sample Testcases

0 -&gt; 0 ^ (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9)
4 -&gt; (0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8) / 9
7 -&gt; 0 * (1 + 2 + 3 + 4 + 5 + 6 + 8 + 9) + 7
45 -&gt; 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0
29 -&gt; 1 + 2 + 7 + 6 + 5 + 4 + 3 + 0 + (9 - 8)
29 -&gt; (((9 + 8 + 7 + 6) * 0) + 5 + 4) * 3 + 2 * 1
100 -&gt; (9 * 8) + 7 + 4 + 5 + 6 + 3 + 2 + 1 + 0




A proof by exhaustion (also contains program used to generate the proof) that shows that all number less than or equal to \$100000\$ have an expression that uses all the digits.
05AB1E, 25 24 bytes
9Ýœ&quot;+-*m&quot;9ãðδšδ.ιJ˜.Δ.VQ

Brute-force approach, so obviously extremely slow.
Outputs in reverse Polish notation, with the characters +-*m for addition, subtraction, multiplication, and exponentiation respectively. Division isn't necessary for the \$[0,100000]\$ range we have to support.
Try it online with additional (first) input to specify the digit-range \$[0,n]\$ instead of \$[0,9]\$, for which I've used 4 right now as example.
Explanation:

9Ý           # Push a list in the range [0,9]
  œ          # Get all possible permutations of this list
&quot;+-*m&quot;       # Push string &quot;+-*m&quot;
      9ã     # Get all possible combinations of size 9 with the cartesian product
         δ   # Map over each string of operations:
        ð š  #  Convert it to a list of characters, and prepend a space
δ            # Apply double-vectorized with both lists of lists:
 .ι          #  Interleave the lists
J            # Then join each inner list together to a string
.Δ           # Find the first string which is truthy for:
  .V         #  Evaluate/execute the string as 05AB1E code
    Q        #  And check if the result is equal to the (implicit) input-integer
             # (after which the found result is output implicitly)

If we are allowed to output all possible results instead of just one, the .Δ (find first) could be ʒ (filter) for -1 byte. Although in that case it would become even slower than it already is..