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.

from dynex import DynexCircuit

Constructor

DynexCircuit(config: DynexConfig)

config · DynexConfig · required

Configuration object. For circuits, QPU backend is recommended.

execute() method

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

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

params · list · required

Parameters passed to the circuit function. Use [] for circuits with no parameters.

wires · int · required

Number of qubits the circuit operates on.

method · str · default: "\"measure\""

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

shots · int · default: "1"

Minimum number of solutions to collect from workers before returning. shots > 1 collects multiple independent circuit runs.

num_reads · int · default: "100"

Number of parallel ODE integrations. Higher values improve measurement statistics. For QPU backends, keep in the range 1–100.

integration_steps · 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.

qpu_max_coeff · 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.

block_fee · int

Priority fee in nanoDNX (1 DNX = 10⁹ nanoDNX).

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

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

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

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

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()