> ## Documentation Index
> Fetch the complete documentation index at: https://dynex.mintlify.app/llms.txt
> Use this file to discover all available pages before exploring further.

# DynexCircuit

> Execute PennyLane, Qiskit, and OpenQASM circuits on the Dynex platform

# DynexCircuit

`DynexCircuit` executes quantum gate circuits on the Dynex neuromorphic computing platform. It accepts circuits in PennyLane, Qiskit, Cirq, and OpenQASM formats.

## Installation

```bash theme={null}
# PennyLane circuits
pip install pennylane

# Qiskit circuits
pip install qiskit pennylane-qiskit

# OpenQASM circuits — no additional packages needed
```

## Imports

```python theme={null}
from dynex import DynexConfig, ComputeBackend, DynexCircuit
```

## Basic usage

```python theme={null}
import pennylane as qml
from dynex import DynexConfig, ComputeBackend, DynexCircuit

def my_circuit(params):
    qml.PauliX(wires=0)
    qml.Hadamard(wires=1)
    qml.CNOT(wires=[0, 1])
    return qml.state()

config = DynexConfig(
    compute_backend=ComputeBackend.QPU,
    qpu_model='apollo_rc1'
)

dynex_circuit = DynexCircuit(config=config)
result = dynex_circuit.execute(
    my_circuit,
    params=[],
    wires=2,
    method='measure'
)
print("Result:", result)
```

## `execute()` — method reference

```python theme={null}
result = dynex_circuit.execute(
    circuit,           # Circuit function or object
    params,            # List of circuit parameters
    wires,             # Number of qubits (int)
    method='measure',  # Measurement type (see below)
    shots=1,               # Minimum solutions from network (QPU: up to 5)
    description="",        # Job description
    debugging=False,       # Verbose output
    num_reads=100,         # Parallel samples (QPU: 1–100)
    integration_steps=100, # ODE integration depth (QPU: 10–1000)
    qpu_max_coeff=9.0,     # Max absolute coefficient for QPU auto-scaling
    # ... advanced ODE params (alpha, beta, gamma, delta, epsilon, zeta)
    block_fee=None,        # Priority fee in nanoDNX
)
```

<Note>
  For QPU backends, keep `num_reads` in the range 1–100, `integration_steps` in 10–1000, and `shots` up to 5. These are hardware limits on the current QPU models.
</Note>

### `method` values

| Value         | Returns                                                      |
| ------------- | ------------------------------------------------------------ |
| `"measure"`   | Samples from a single measurement in the computational basis |
| `"probs"`     | Probability of each computational basis state per qubit      |
| `"all"`       | All solutions as arrays, one per shot                        |
| `"sampleset"` | dimod `SampleSet` object                                     |

## PennyLane circuits

```python theme={null}
import pennylane as qml
import numpy as np
from dynex import DynexConfig, ComputeBackend, DynexCircuit

def variational_circuit(params):
    qml.RX(params[0], wires=0)
    qml.RY(params[1], wires=1)
    qml.CNOT(wires=[0, 1])
    qml.RZ(params[2], wires=0)
    return qml.state()

config = DynexConfig(
    compute_backend=ComputeBackend.QPU,
    qpu_model='apollo_rc1',
    use_notebook_output=True
)
dynex_circuit = DynexCircuit(config=config)

params = [np.pi/4, np.pi/3, np.pi/6]
result = dynex_circuit.execute(variational_circuit, params, wires=2, method='probs')
print("Measurement probabilities:", result)
```

## Qiskit circuits

```python theme={null}
from qiskit import QuantumCircuit
from dynex import DynexConfig, ComputeBackend, DynexCircuit

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.ry(0.5, 1)

config = DynexConfig(
    compute_backend=ComputeBackend.QPU,
    qpu_model='apollo_rc1'
)
dynex_circuit = DynexCircuit(config=config)
result = dynex_circuit.execute(qc, params=[], wires=2, method='measure')
print("Measurement:", result)
```

## OpenQASM circuits

OpenQASM circuits are provided as strings. No additional plugins required.

```python theme={null}
from dynex import DynexConfig, ComputeBackend, DynexCircuit

qasm_circuit = """
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
h q[0];
cx q[0], q[1];
"""

config = DynexConfig(
    compute_backend=ComputeBackend.QPU,
    qpu_model='apollo_rc1'
)
dynex_circuit = DynexCircuit(config=config)
result = dynex_circuit.execute(qasm_circuit, params=[], wires=2, method='measure')
print("Measurement:", result)
```

## Getting probabilities

```python theme={null}
result = dynex_circuit.execute(
    my_circuit, params, wires=3, method='probs'
)
# Returns probability array over 2^n basis states
for i, prob in enumerate(result):
    if prob > 0.01:
        print(f"|{i:0{3}b}⟩ : {prob:.4f}")
```

## Getting all solutions

```python theme={null}
result = dynex_circuit.execute(
    my_circuit, params, wires=2, method='all', shots=3
)
# Returns list of solution arrays, one per shot
for i, solution in enumerate(result):
    print(f"Shot {i}: {solution}")
```

## Using as dimod SampleSet

```python theme={null}
sampleset = dynex_circuit.execute(
    my_circuit, params, wires=4, method='sampleset'
)
print(sampleset.first.sample)
print(sampleset.first.energy)
```