Fixstars Amplify makes it easier and more efficient for developing applications that require complex and specialized skills of quantum annealing.

Fixstars Amplify automates the 3 steps of "logical model conversion", "physical model conversion", and "machine execution", thereby enabling a more intuitive workflow for quantum annealing programming.

Express the problem in the form of mathematical expressions that can be run by an Ising machine

Convert the objective functions and constraints of the problem into the Ising model or QUBO

Reconvert the logical model into a physical model that meets machine specifications and limitations

Convert the physical model to data in accordance with the machine's API specifications

Can run only a specific machine

Amplify SDK automatically converts your model into the form suitable for the Ising machine of your choice.
Amplify SDK also converts the output from the machine into the form that is easy for you to use.

Express the problem in terms of mathematical expressions and write a corresponding code

Can choose a machine from multiple machines

Amplify SDK provides an intuitive platform to handle various input forms and constraints for running the
Ising machines.

In addition, it also reconciles complicated model transformation of inputs and inverse transformation of
outputs for each machine.

```
# Formulate the input model
q = gen_symbols(BinaryPoly, 2)
f = 1 - q[0] * q[1]
# Set up the machine to run
client = FixstarsClient()
# Run the machine to get results
s = Solver(client)
result = s.solve(f)
values = result.solutions[0].values
# Interpret the results
solution = decode_solution(q, values)
>>> print(f"result: {q} = {solution}")
result: [q_0, q_1] = [1, 1]
```

Amplify makes it possible to handle various mathematical formulas independent of the machine of
your choice.

It also supports the input of higher order polynomials, which are difficult for ordinary
annealing machines to handle.

```
q = gen_symbols(BinaryPoly, 3)
f = 1 - q[0] * q[1] + q[2]
>>> f
- q_0 q_1 + q_2 + 1.000000
```

```
s = gen_symbols(IsingPoly, 3)
f = 1 - s[0] * s[1] + s[2]
>>> f
- s_0 s_1 + s_2 + 1.000000
```

```
q = BinaryMatrix(4)
>>> q
[[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
```

```
q = IsingMatrix(4)
>>> q
[[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]]
```

```
q = gen_symbols(BinaryPoly, 3)
f = q[0] * q[1] * q[2] + q[0] * q[0]
>>> f
q_0 q_1 q_2 + q_0
```

```
s = gen_symbols(IsingPoly, 3)
f = s[0] * s[1] * s[2] + s[0] * s[0]
>>> f
s_0 s_1 s_2 + 1.000000
```

```
x = gen_symbols(LogicPoly, 3)
f = (x[0] | x[1]) & (x[1] | x[2])
>>> f
- x_0 x_1 x_2 + x_0 x_2 + x_1
```

For binary and Ising polynomials, Amplify performs arithmetic operations and high-spped mathematical
processing specialized for each algebraic law.

It also provides useful functions for representing
mathematical expressions in natural ways.

` ````
q = gen_symbols(BinaryPoly, 8) # Generate 8 binary variables
f = sum_poly(q) # Sum all variables
>>> f
q_0 + q_1 + q_2 + q_3 + q_4 + q_5 + q_6 + q_7
```

` ````
q = gen_symbols(BinaryPoly, 3) # Generate 3 binary variables
f = sum_poly(3, lambda i: # Sum the combinations of all variables
sum_poly(3, lambda j: q[i] * q[j]))
>>> f
2.0 q_0 q_1 + 2.0 q_0 q_2 + 2.0 q_1 q_2 + q_0 + q_1 + q_2
```

` ````
q = gen_symbols(BinaryPoly, 2, 2) # Generate 2x2 binary variables
f = sum_poly(2, lambda i: ( # Double summation of mathematical expressions
sum_poly(2, lambda j: q[i][j]) - 1) ** 2)
>>> f
2.0 q_0 q_1 + 2.0 q_2 q_3 - q_0 - q_1 - q_2 - q_3 + 2.0
```

Amplify abstracts the constraint conditions imposed on the input variables. It automatically generates penalty functions for the Ising machines and checks if the constraints are satisfied. This greatly reduces difficulties in handling constraint conditions with the Ising machines.

```
q = gen_symbols(BinaryPoly, 2) # Generate 2 binary variables
penalty(q[0] * q[1]) # Minimum value constraint q_0 q_1 = 0
```

```
q = gen_symbols(BinaryPoly, 8) # Generate 8 variables
equal_to(sum_poly(q), 1) # Equality constraints \sum q = 1
```

```
q = gen_symbols(BinaryPoly, 3) # Generate 3 binary variables
less_equal(3 * q[0] + 2 * q[1] + q[2], 3) # Inequality constraints 3 * q[0] + 2 * q[1] + q[2] <= 3
```

Amplify is compatible with almost all available annealing machines.

By providing a common driver, it absorbs the difficulties that arise when using various machines due to
their differences in hardware and interface specifications. This makes it possible to seamlessly switch
between multiple machines with minimal changes.

```
# Example for Fixstars Amplify AE
client = FixstarsClient()
# Example for D-Wave 2000Q
client = DWaveClient()
# Example for Fujitsu Digital Annealer
client = FujitsuDASolverClient()
# Example for Toshiba SQBM+
client = ToshibaClient()
# Set Solver for the machine
s = Solver(client)
```

Fixstars Amplify SDK is significantly faster than other modules. It works perfectly well for real problems since its performance does not degrade even on large problems.

Performance ratio when dimod(CQM) is set to 1