Skip to main content

​
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:
ValueReturns
"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:
methodReturn typeDescription
"measure"arrayBit string measurement
"probs"arrayProbability for each qubit
"all"list[array]One array per shot
"sampleset"dimod.SampleSetFull 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()