> ## 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 quantum gate circuits on the Dynex platform

# DynexCircuit

`DynexCircuit` executes quantum gate circuits on the Dynex neuromorphic platform. Accepts PennyLane, Qiskit, Cirq, and OpenQASM circuits.

```python theme={null}
from dynex import DynexCircuit
```

## Constructor

```python theme={null}
DynexCircuit(config: DynexConfig)
```

<ParamField path="config" type="DynexConfig" required>
  Configuration object. For circuits, QPU backend is recommended.
</ParamField>

## `execute()` method

```python theme={null}
result = dynex_circuit.execute(
    circuit,                  # PennyLane function | Qiskit QuantumCircuit | QASM string
    params: list,             # Parameters passed to the circuit function
    wires: int,               # Number of qubits
    method: str = 'measure',  # Measurement type
    shots: int = 1,               # Minimum solutions from network (QPU: up to 5)
    description: str = "",        # Job description
    debugging: bool = False,      # Verbose output
    num_reads: int = 100,         # Parallel samples (QPU: 1–100)
    integration_steps: int = 100, # ODE integration depth (QPU: 10–1000)
    # ODE parameters: alpha, beta, gamma, delta, epsilon, zeta, minimum_stepsize
    block_fee: int = None,        # Priority fee in nanoDNX
)
```

### Parameters

<ParamField path="circuit" required>
  The quantum circuit in one of the following formats:

  * **PennyLane**: a Python function that applies gates and returns a measurement
  * **Qiskit**: a `QuantumCircuit` object
  * **OpenQASM**: a string containing QASM 2.0 instructions
  * **Cirq**: a Cirq circuit object
</ParamField>

<ParamField path="params" type="list" required>
  Parameters passed to the circuit function. Use `[]` for circuits with no parameters.
</ParamField>

<ParamField path="wires" type="int" required>
  Number of qubits the circuit operates on.
</ParamField>

<ParamField path="method" type="str" default="&#x22;measure&#x22;">
  Measurement type:

  | Value         | Returns                                   |
  | ------------- | ----------------------------------------- |
  | `"measure"`   | Computational basis measurement samples   |
  | `"probs"`     | Probability of each basis state per qubit |
  | `"all"`       | All solutions, one array per shot         |
  | `"sampleset"` | dimod `SampleSet` object                  |
</ParamField>

<ParamField path="shots" type="int" default="1">
  Minimum number of solutions to collect from workers before returning. `shots > 1` collects multiple independent circuit runs.
</ParamField>

<ParamField path="num_reads" type="int" default="100">
  Number of parallel ODE integrations. Higher values improve measurement statistics. For QPU backends, keep in the range 1–100.
</ParamField>

<ParamField path="integration_steps" type="int" default="100">
  ODE integration depth — the number of integration steps used in the neuromorphic circuit simulation. Higher values allow circuits to converge more reliably. For QPU backends, keep in the range 10–1000.
</ParamField>

<ParamField path="qpu_max_coeff" type="float" default="9.0">
  Maximum allowed absolute coefficient value for QPU backends. Coefficients exceeding this are auto-scaled. For circuit BQMs (QASM), scaling is handled by the Apollo API and this parameter is ignored.
</ParamField>

<ParamField path="block_fee" type="int" optional>
  Priority fee in nanoDNX (1 DNX = 10⁹ nanoDNX).
</ParamField>

## Returns

Depends on `method`:

| method        | Return type       | Description                |
| ------------- | ----------------- | -------------------------- |
| `"measure"`   | `array`           | Bit string measurement     |
| `"probs"`     | `array`           | Probability for each qubit |
| `"all"`       | `list[array]`     | One array per shot         |
| `"sampleset"` | `dimod.SampleSet` | Full sample set            |

## Examples

### PennyLane circuit

```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'
)
circuit = DynexCircuit(config=config)
result = circuit.execute(
    variational_circuit,
    params=[np.pi/4, np.pi/3, np.pi/6],
    wires=2,
    method='probs'
)
print("Probabilities:", result)
```

### Qiskit circuit

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

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

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

### OpenQASM circuit

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

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

config = DynexConfig(compute_backend=ComputeBackend.QPU, qpu_model='apollo_rc1')
circuit = DynexCircuit(config=config)
result = circuit.execute(qasm, params=[], wires=3, method='all', shots=3)
for i, shot in enumerate(result):
    print(f"Shot {i}: {shot}")
```

### Getting a SampleSet

```python theme={null}
sampleset = circuit.execute(
    my_circuit, params=[], wires=4, method='sampleset', shots=3
)
print(sampleset.first.sample)
print(sampleset.first.energy)
df = sampleset.to_pandas_dataframe()
```