Supported Quantum Frameworks

Marqov provides a backend-agnostic Circuit class that can import from and export to all major quantum frameworks. You can write circuits in your preferred framework and Marqov handles the conversion.

Marqov Circuit API

The Circuit class offers a fluent API for building circuits with method chaining:


from marqov import Circuit
 
# Bell state
circuit = Circuit().h(0).cnot(0, 1)
 
print(circuit)           # Circuit(qubits=2, gates=2)
print(circuit.num_qubits)  # 2

Available Gates

Method	Gate	Qubits	Parameters
`h(qubit)`	Hadamard	1	—
`x(qubit)`	Pauli-X	1	—
`y(qubit)`	Pauli-Y	1	—
`z(qubit)`	Pauli-Z	1	—
`s(qubit)`	S (phase)	1	—
`t(qubit)`	T	1	—
`rx(angle, qubit)`	Rx rotation	1	angle (radians)
`ry(angle, qubit)`	Ry rotation	1	angle (radians)
`rz(angle, qubit)`	Rz rotation	1	angle (radians)
`cnot(control, target)`	CNOT/CX	2	—
`cx(control, target)`	CX (alias)	2	—
`cz(control, target)`	CZ	2	—
`swap(qubit0, qubit1)`	SWAP	2	—

Convenience Constructors


from marqov import bell_state, ghz_state
 
bell = bell_state()          # H(0), CNOT(0,1)
ghz = ghz_state(4)          # H(0), CNOT(0,1), CNOT(1,2), CNOT(2,3)

Bell State in Every Framework

Here is the same Bell state circuit written in each supported framework, plus how to import it into Marqov.

Marqov (native)


from marqov import Circuit
 
circuit = Circuit().h(0).cnot(0, 1)

Qiskit


from qiskit import QuantumCircuit
from marqov import Circuit
 
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
 
circuit = Circuit.from_qiskit(qc)

Unsupported gates are automatically decomposed into the supported basis set via Qiskit’s transpiler, so any valid Qiskit circuit can be imported.

Install: pip install marqov[qiskit]

Amazon Braket


from braket.circuits import Circuit as BraketCircuit
from marqov import Circuit
 
bc = BraketCircuit()
bc.h(0)
bc.cnot(0, 1)
 
circuit = Circuit.from_braket(bc)

Install: pip install marqov[braket]

Cirq


import cirq
from marqov import Circuit
 
q0, q1 = cirq.LineQubit.range(2)
cc = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
])
 
circuit = Circuit.from_cirq(cc)

Only cirq.LineQubit circuits are accepted. For GridQubit or NamedQubit circuits, convert to LineQubit first.

Unsupported gates are automatically decomposed via cirq.decompose().

Install: pip install marqov[cirq]

PennyLane


import pennylane as qml
from marqov import Circuit
 
with qml.tape.QuantumTape() as tape:
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
 
circuit = Circuit.from_pennylane(tape)

Only integer wires are accepted. For string wires, remap to integers before calling from_pennylane().

Unsupported gates are automatically decomposed via op.decomposition().

Install: pip install marqov[pennylane]

OpenQASM


from marqov import Circuit
 
qasm_2 = """
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
h q[0];
cx q[0],q[1];
"""
 
circuit = Circuit.from_openqasm(qasm_2)

Both QASM 2.0 and QASM 3.0 are supported. The version is auto-detected from the header.

Install: pip install marqov[openqasm] (requires Qiskit for parsing)

Export Methods

Convert a Marqov Circuit to any backend format:


from marqov import Circuit
 
circuit = Circuit().h(0).cnot(0, 1)
 
braket_circuit = circuit.to_braket()     # braket.circuits.Circuit
qiskit_circuit = circuit.to_qiskit()     # qiskit.circuit.QuantumCircuit
cirq_circuit   = circuit.to_cirq()       # cirq.Circuit
pyquil_program = circuit.to_pyquil()     # pyquil.Program
qasm2_string   = circuit.to_openqasm(2)  # str (QASM 2.0)
qasm3_string   = circuit.to_openqasm(3)  # str (QASM 3.0)

Serialization for Workflows

When passing circuits between @task functions in a workflow, serialize to a dict:


from marqov import task, workflow, Circuit
 
@task
async def run_circuit(circuit_dict: dict) -> dict:
    circuit = Circuit.from_dict(circuit_dict)
    braket_circuit = circuit.to_braket()
    # ... execute ...
    return {"counts": {"00": 500, "11": 500}}
 
@workflow
def experiment():
    circuit = Circuit().h(0).cnot(0, 1)
    return run_circuit(circuit.to_dict())

to_dict() serializes the gate sequence as JSON-compatible data. from_dict() reconstructs the circuit.

Local Simulation

Run a circuit on the built-in statevector simulator:


from marqov import Circuit
 
circuit = Circuit().h(0).cnot(0, 1)
state = circuit.simulate()  # Returns a QuantumFlow State object

Import/Export Summary

Framework	Import	Export	Install Extra
Marqov native	—	—	—
Qiskit	`Circuit.from_qiskit(qc)`	`circuit.to_qiskit()`	`marqov[qiskit]`
Braket	`Circuit.from_braket(bc)`	`circuit.to_braket()`	`marqov[braket]`
Cirq	`Circuit.from_cirq(cc)`	`circuit.to_cirq()`	`marqov[cirq]`
PennyLane	`Circuit.from_pennylane(tape)`	—	`marqov[pennylane]`
PyQuil	—	`circuit.to_pyquil()`	—
OpenQASM	`Circuit.from_openqasm(qasm)`	`circuit.to_openqasm(2\|3)`	`marqov[openqasm]`