Skip to content

Dashboard Core — Graphical Builder

Turns the ops list produced by the graphical (drag-and-drop) circuit builder component into dense_evolution's own (name, *qubits[, param]) gate-tuple format, so a circuit built visually runs through the exact same execution path as one written in OpenQASM.

from dashboard_core.graphical_builder import ops_to_native_tuples

# A Bell pair, as the drag-and-drop grid would emit it:
ops = [{"gate": "h", "qubits": [0]}, {"gate": "cx", "qubits": [0, 1]}]
tuples = ops_to_native_tuples(n_qubits=2, ops=ops)
print(tuples)  # [('h', 0), ('cx', 0, 1)]

# Feed straight into gate_tuples_to_qasm for the QASM the rest of the Composer runs on:
from dashboard_core.qasm_library import gate_tuples_to_qasm
print(gate_tuples_to_qasm(tuples, n_qubits=2))

graphical_builder

Turns the ops list produced by the graphical (drag-and-drop) circuit builder component into dense_evolution's own (name, *qubits[, param]) gate tuples -- the same format dashboard_core.engine already runs on the real dense_evolution DenseSVSimulator (via dashboard_core.qasm_library. gate_tuples_to_qasm for the QASM round-trip). No separate execution path for graphically-built circuits, and no Qiskit QuantumCircuit ever built here: they go through the exact same engine as typed OpenQASM.

ops_to_native_tuples 

ops_to_native_tuples(n_qubits: int, ops: list) -> list

Build dense_evolution's own (name, *qubits[, param]) gate tuples from the builder's op list -- the same shape dashboard_core.engine's QASMParser-based pipeline and qasm_library.gate_tuples_to_qasm both already accept, and the same validation the old QuantumCircuit-based version did (qubit range, unknown gate name), just performed by hand instead of relying on Qiskit's own checks.

Parameters:

Name Type Description Default
n_qubits int
required
ops list[dict]

Each dict has 'gate' (one of the GATE_PALETTE gate ids: h/x/y/z/s/t/ rx/ry/rz/cx/cy/cz/swap) and 'qubits' (list[int]).

 required
Notes

A graphically-placed rx/ry/rz always gets a fixed pi/2 rotation angle (_DEFAULT_ROTATION_ANGLE, prog.txt dashboard_core audit point 5d) -- the drag-and-drop grid has no angle-entry UI yet, so this places a real, working rotation rather than a fake/placeholder one. A user who drops an Rx expecting to pick its own angle should know this is fixed, not something this function silently decided for them.

Returns:

Type Description
list[tuple]

Pass to qasm_library.gate_tuples_to_qasm(tuples, n_qubits) for the QASM text the rest of the Composer already runs on (measure_all equivalent included there by default).

Examples:

>>> from dashboard_core.graphical_builder import ops_to_native_tuples
>>> ops = [{'gate': 'h', 'qubits': [0]}, {'gate': 'cx', 'qubits': [0, 1]}]
>>> ops_to_native_tuples(2, ops)
[('h', 0), ('cx', 0, 1)]
Source code in tools/dashboard/core/graphical_builder.py 
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
def ops_to_native_tuples(n_qubits: int, ops: list) -> list:
    """Build dense_evolution's own (name, *qubits[, param]) gate tuples
    from the builder's op list -- the same shape dashboard_core.engine's
    QASMParser-based pipeline and qasm_library.gate_tuples_to_qasm both
    already accept, and the same validation the old QuantumCircuit-based
    version did (qubit range, unknown gate name), just performed by hand
    instead of relying on Qiskit's own checks.

    Parameters
    ----------
    n_qubits : int
    ops : list[dict]
        Each dict has 'gate' (one of the GATE_PALETTE gate ids: h/x/y/z/s/t/
        rx/ry/rz/cx/cy/cz/swap) and 'qubits' (list[int]).

    Notes
    -----
    A graphically-placed rx/ry/rz always gets a fixed pi/2 rotation angle
    (_DEFAULT_ROTATION_ANGLE, prog.txt dashboard_core audit point 5d) --
    the drag-and-drop grid has no angle-entry UI yet, so this places a
    real, working rotation rather than a fake/placeholder one. A user
    who drops an Rx expecting to pick its own angle should know this is
    fixed, not something this function silently decided for them.

    Returns
    -------
    list[tuple]
        Pass to qasm_library.gate_tuples_to_qasm(tuples, n_qubits) for the
        QASM text the rest of the Composer already runs on (measure_all
        equivalent included there by default).

    Examples
    --------
    >>> from dashboard_core.graphical_builder import ops_to_native_tuples
    >>> ops = [{'gate': 'h', 'qubits': [0]}, {'gate': 'cx', 'qubits': [0, 1]}]
    >>> ops_to_native_tuples(2, ops)
    [('h', 0), ('cx', 0, 1)]
    """
    if n_qubits < 1:
        raise ValueError("circuit must have at least 1 qubit")

    tuples = []
    for op in ops:
        gate = op.get("gate")
        qubits = op.get("qubits", [])
        for q in qubits:
            if not (0 <= q < n_qubits):
                raise ValueError(f"qubit index {q} out of range for {n_qubits}-qubit circuit")

        if gate in _SINGLE_QUBIT_METHODS:
            (q,) = qubits
            tuples.append((gate, q))
        elif gate in _ROTATION_METHODS:
            (q,) = qubits
            tuples.append((gate, q, _DEFAULT_ROTATION_ANGLE))
        elif gate == "swap":
            a, b = qubits
            tuples.append(("swap", a, b))
        elif gate in ("cx", "cy", "cz"):
            control, target = qubits
            tuples.append((gate, control, target))
        else:
            raise ValueError(f"unknown gate from circuit builder: {gate!r}")

    return tuples

See also: dashboard_core.circuit_builder_component, the UI component this module's output feeds.