> ## Documentation Index
> Fetch the complete documentation index at: https://prod-mint.classiq.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Arithmetic Expressions

<Card title="View on GitHub" icon="github" href="https://github.com/Classiq/classiq-library/blob/main/tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb">
  Open this notebook in GitHub to run it yourself
</Card>

This tutorial demonstrates automatic arithmetic operation management by the synthesis engine. It synthesizes a complex arithmetic expression, where uncomputation procedure, together with initialization and reuse of auxiliary qubits, are all automated.

Given different **global** width or depth constraints results in different circuits.

Define a quantum model that applies some quantum arithmetic operation on `QNum` variables.

```python theme={null}
from classiq import *
from classiq.qmod.symbolic import max


@qfunc
def main(z: Output[QNum]):
    x = QNum()
    y = QNum()
    x |= 2
    y |= 1
    z |= (2 * x + y + max(3 * y, 2)) > 4
    drop(x)
    drop(y)


qmod = create_model(main)
qmod = set_preferences(qmod, random_seed=424788457)
```

You can try different optimization scenarios, below we introduce two examples:

1. Optimizing over depth and constraining the maximal width to 9 qubits.
2. Optimizing over depth and constraining the maximal width to 12 qubits.

Optimizing over depth and constraining the maximal width to 9 qubits

```python theme={null}
NUM_QUBITS_1 = 9
qmod_1 = set_constraints(qmod, optimization_parameter="depth", max_width=NUM_QUBITS_1)
qprog_1 = synthesize(qmod_1)
show(qprog_1)

result = execute(qprog_1).result_value()
print("The result of the arithmetic calculation: ", result.parsed_counts)
```

<Info>
  **Output:**

  ```

  Quantum program link: https://platform.classiq.io/circuit/30eUHZJyfNuCdGpLdJhEcX9rCUp
    The result of the arithmetic calculation:  [{'z': 1}: 2048]
    

  ```
</Info>

Change the quantum model constraint to treat the second scenario for optimizing over depth and constraining the maximal width to 12 qubits:

```python theme={null}
NUM_QUBITS_2 = 12
qmod_2 = set_constraints(qmod, optimization_parameter="depth", max_width=NUM_QUBITS_2)
qprog_2 = synthesize(qmod_2)
show(qprog_2)

result = execute(qprog_2).result_value()
print("The result of the arithmetic calculation: ", result.parsed_counts)
```

<Info>
  **Output:**

  ```

  Quantum program link: https://platform.classiq.io/circuit/30eUJhEVwKFryUCOwnNzg7TvB9c
    The result of the arithmetic calculation:  [{'z': 1}: 2048]
    

  ```
</Info>

#

## Mathematical Background

The given mathematical expression:

$$
z = (2 \cdot x + y + \max(3 \cdot y, 2)) > 4
$$

is solved by the automatic arithmetic operation management, optimizing over depth and constraining the maximal width to 9 and 12 qubits, which outputs the value for z.

**The `parsed_counts` result:**

* Optimizing over depth and constraining the maximal width to 9 qubits: `[{'z': 1.0}: 2048]`
* Optimizing over depth and constraining the maximal width to 12 qubits: `[{'z': 1.0}: 2048]`

Both the result are same which verifies the arithmetic expression to be True.

**The expected result**:<br />

Allocated values:

$$
x = 2, \,\,\, y = 1
$$

Expression Calculation:

$$
2 \cdot x + y = 2 \cdot 2 + 1 = 4 + 1 = 5 \,\,\, 3 \cdot y = 3 \cdot 1 = 3 \,\,\, \max(3 \cdot y, 2) = \max(3, 2) = 3
$$

Therefore:

$$
2 \cdot x + y + \max(3 \cdot y, 2) = 5 + 3 = 8
$$

As

$$
8 > 4 \implies \text{True}
$$

z is assigned the value True : $z \implies 1$