{
"cells": [
{
"cell_type": "markdown",
"id": "4cb32582",
"metadata": {},
"source": [
"---\n",
"title: \"Trabajar con DAG en pasadas del transpilador\"\n",
"description: \"Cómo utilizar grafos acíclicos dirigidos (DAG) para analizar y transformar circuitos cuánticos en pasadas del transpilador Qiskit\"\n",
"---\n",
"\n",
"{/* cspell:ignore subdag DAGOpNode qargs cargs dag_drawer couplinglist */}\n",
"\n",
"\n",
"\n",
"# Trabajar con DAG en pasadas del transpilador\n",
"\n",
"En Qiskit, dentro de las etapas de transpilación, los circuitos se representan mediante un DAG. En general, un DAG se compone de vértices (también conocidos como \"nodos\") y aristas dirigidas que conectan pares de vértices en una orientación determinada. Esta representación se almacena mediante objetos `qiskit.dagcircuit.DAGCircuit` que se componen de objetos `DagNode` individuales. La ventaja de esta representación frente a una lista de puertas (es decir, un netlist) es que el flujo de información entre operaciones es explícito, lo que facilita la toma de decisiones de transformación.\n",
"\n",
"Esta guía muestra cómo trabajar con DAGs y utilizarlos para escribir pases de transpilador personalizados. Comenzará construyendo un circuito sencillo y examinando su representación DAG, después explorará las operaciones DAG básicas e implementará un pase personalizado `BasicMapper` .\n",
"\n",
"\n",
"\n",
"## Construye un circuito y examina su DAG\n",
"\n",
"El siguiente fragmento de código ilustra el DAG mediante la creación de un circuito sencillo que prepara un estado Bell y aplica una rotación $R_Z$, en función del resultado de la medición.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "version-info-cell",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"{/*\n",
" DO NOT EDIT THIS CELL!!!\n",
" This cell's content is generated automatically by a script. Anything you add\n",
" here will be removed next time the notebook is run. To add new content, create\n",
" a new cell before or after this one.\n",
" */}\n",
"\n",
"\n",
" \n",
" El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos.\n",
" Recomendamos utilizar estas versiones o versiones más recientes.\n",
"\n",
" ```\n",
" qiskit[all]~=2.5.0\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "1d16892a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n",
"from qiskit.converters import circuit_to_dag\n",
"from qiskit.visualization import circuit_drawer\n",
"from qiskit.visualization.dag_visualization import dag_drawer\n",
"\n",
"# Create circuit\n",
"q = QuantumRegister(3, \"q\")\n",
"c = ClassicalRegister(3, \"c\")\n",
"circ = QuantumCircuit(q, c)\n",
"circ.h(q[0])\n",
"circ.cx(q[0], q[1])\n",
"circ.measure(q[0], c[0])\n",
"\n",
"# Qiskit 2.0 uses if_test instead of c_if\n",
"with circ.if_test((c, 2)):\n",
" circ.rz(0.5, q[1])\n",
"\n",
"circuit_drawer(circ, output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "5971b6ed",
"metadata": {},
"source": [
"En el DAG, hay tres tipos de nodos gráficos: nodos de entrada qubit/clbit (verdes), nodos de operación (azules) y nodos de salida (rojos). Cada arista indica el flujo de datos (o dependencia) entre dos nodos. Utilice la función qiskit.tools.visualization.dag\\_drawer () para ver el DAG de este circuito. (Instale la [biblioteca Graphviz](https://graphviz.org/download/) para ejecutarlo)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "e498faa3",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Convert to DAG\n",
"dag = circuit_to_dag(circ)\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "3b728136",
"metadata": {},
"source": [
"\n",
"\n",
"## Operaciones básicas de DAG\n",
"\n",
"Los siguientes ejemplos de código muestran operaciones comunes con DAGs, incluyendo el acceso a nodos, operaciones de adición y sustitución de subcircuitos. Estas operaciones constituyen la base para construir pases de transpilador.\n",
"\n",
"\n",
"\n",
"## Obtener todos los nodos operativos en el DAG\n",
"\n",
"El método `op_nodes()` devuelve una lista iterable de objetos `DAGOpNode` en el circuito:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "4f848695",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[DAGOpNode(op=Instruction(name='h', num_qubits=1, num_clbits=0, params=[]), qargs=(,), cargs=()),\n",
" DAGOpNode(op=Instruction(name='cx', num_qubits=2, num_clbits=0, params=[]), qargs=(, ), cargs=()),\n",
" DAGOpNode(op=Instruction(name='measure', num_qubits=1, num_clbits=1, params=[]), qargs=(,), cargs=(,)),\n",
" DAGOpNode(op=Instruction(name='if_else', num_qubits=1, num_clbits=3, params=[, None]), qargs=(,), cargs=(, , ))]"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.op_nodes()"
]
},
{
"cell_type": "markdown",
"id": "8f2676b9",
"metadata": {},
"source": [
"Cada nodo es una instancia de la clase `DAGOpNode` :\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "5866159f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"node name: if_else\n",
"op: Instruction(name='if_else', num_qubits=1, num_clbits=3, params=[, None])\n",
"qargs: (,)\n",
"cargs: (, , )\n",
"condition: (ClassicalRegister(3, 'c'), 2)\n"
]
}
],
"source": [
"node = dag.op_nodes()[3]\n",
"print(\"node name:\", node.name)\n",
"print(\"op:\", node.op)\n",
"print(\"qargs:\", node.qargs)\n",
"print(\"cargs:\", node.cargs)\n",
"print(\"condition:\", node.op.condition)"
]
},
{
"cell_type": "markdown",
"id": "f2560cc1",
"metadata": {},
"source": [
"\n",
"\n",
"## Añadir una operación a la parte posterior\n",
"\n",
"Se añade una operación al final del DAGCircuit utilizando el método `apply_operation_back()` . Esto añade la puerta especificada para actuar sobre los qubits dados después de todas las operaciones existentes en el circuito.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "3c144b49",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.circuit.library import HGate\n",
"\n",
"dag.apply_operation_back(HGate(), qargs=[q[0]])\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "80af1d3d",
"metadata": {},
"source": [
"\n",
"\n",
"## Añadir una operación al frente\n",
"\n",
"Se añade una operación al principio del DAGCircuit utilizando el método `apply_operation_front()` . Esto inserta la puerta especificada antes de todas las operaciones existentes en el circuito, convirtiéndola en la primera operación ejecutada.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "ed80a69f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.circuit.library import CCXGate\n",
"\n",
"dag.apply_operation_front(CCXGate(), qargs=[q[0], q[1], q[2]])\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "4bcdf5fe",
"metadata": {},
"source": [
"\n",
"\n",
"## Sustituir un nodo por un subcircuito\n",
"\n",
"Un nodo que representa una operación específica en el DAGCircuit se sustituye por un subcircuito. En primer lugar, se construye un nuevo sub-DAG con la secuencia de puertas deseada y, a continuación, se sustituye el nodo objetivo por este sub-DAG utilizando `substitute_node_with_dag()`, preservando las conexiones con el resto del circuito.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "fdb3dd70",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.dagcircuit import DAGCircuit\n",
"from qiskit.circuit.library import CHGate, U2Gate, CXGate\n",
"\n",
"# Build sub-DAG\n",
"mini_dag = DAGCircuit()\n",
"p = QuantumRegister(2, \"p\")\n",
"mini_dag.add_qreg(p)\n",
"mini_dag.apply_operation_back(CHGate(), qargs=[p[1], p[0]])\n",
"mini_dag.apply_operation_back(U2Gate(0.1, 0.2), qargs=[p[1]])\n",
"\n",
"# Replace CX with mini_dag\n",
"cx_node = dag.op_nodes(op=CXGate).pop()\n",
"dag.substitute_node_with_dag(cx_node, mini_dag, wires=[p[0], p[1]])\n",
"dag_drawer(dag)"
]
},
{
"cell_type": "markdown",
"id": "028566f7",
"metadata": {},
"source": [
"Una vez completadas todas las transformaciones, el DAG puede convertirse de nuevo en un objeto normal de `QuantumCircuit` . Así funciona el transpilador. Se toma un circuito, se procesa en forma de DAG y se obtiene como salida un circuito transformado.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "786571f7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.converters import dag_to_circuit\n",
"\n",
"new_circ = dag_to_circuit(dag)\n",
"circuit_drawer(new_circ, output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "f743bb3b",
"metadata": {},
"source": [
"\n",
"\n",
"## Implementar un pase « BasicMapper »\n",
"\n",
"La estructura DAG puede aprovecharse para escribir pases de transpilador. En el siguiente ejemplo, se implementa un pase `BasicMapper` para mapear un circuito arbitrario en un dispositivo con conectividad qubit restringida. Para más información, consulte la guía sobre cómo [escribir pases de transpilador personalizados](/docs/guides/custom-transpiler-pass).\n",
"\n",
"El pase se define como `TransformationPass`, lo que significa que modifica el circuito. Para ello, recorre el DAG capa por capa, comprobando si cada instrucción cumple las restricciones impuestas por el mapa de acoplamiento del dispositivo. Si se detecta una infracción, se determina una ruta de intercambio y se insertan en consecuencia las puertas SWAP necesarias.\n",
"\n",
"Al crear un pase de transpilador, la primera decisión consiste en seleccionar si el pase debe heredar de `TransformationPass` o de `AnalysisPass`. Los pases de transformación están diseñados para modificar el circuito, mientras que los pases de análisis sólo pretenden extraer información para utilizarla en pases posteriores. La funcionalidad principal se implementa en el método `run(dag)` . Por último, el pase debe registrarse en el módulo `qiskit.transpiler.passes` .\n",
"\n",
"En este paso específico, el DAG se recorre capa por capa (donde cada capa contiene operaciones que actúan sobre conjuntos disjuntos de qubits y, por tanto, pueden ejecutarse independientemente). Para cada operación, si no se cumplen las restricciones del mapa de acoplamiento, se identifica una ruta de intercambio adecuada y se insertan los intercambios necesarios para poner en adyacencia los qubits implicados.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "8c0d7e5a",
"metadata": {},
"outputs": [],
"source": [
"from qiskit.transpiler.basepasses import TransformationPass\n",
"from qiskit.transpiler import Layout\n",
"from qiskit.circuit.library import SwapGate\n",
"\n",
"\n",
"class BasicSwap(TransformationPass):\n",
" def __init__(self, coupling_map, initial_layout=None):\n",
" super().__init__()\n",
" self.coupling_map = coupling_map\n",
" self.initial_layout = initial_layout\n",
"\n",
" def run(self, dag):\n",
" new_dag = DAGCircuit()\n",
" for qreg in dag.qregs.values():\n",
" new_dag.add_qreg(qreg)\n",
" for creg in dag.cregs.values():\n",
" new_dag.add_creg(creg)\n",
"\n",
" if self.initial_layout is None:\n",
" self.initial_layout = Layout.generate_trivial_layout(\n",
" *dag.qregs.values()\n",
" )\n",
"\n",
" current_layout = self.initial_layout.copy()\n",
"\n",
" for layer in dag.serial_layers():\n",
" subdag = layer[\"graph\"]\n",
" for gate in subdag.two_qubit_ops():\n",
" q0, q1 = gate.qargs\n",
" p0 = current_layout[q0]\n",
" p1 = current_layout[q1]\n",
"\n",
" if self.coupling_map.distance(p0, p1) != 1:\n",
" path = self.coupling_map.shortest_undirected_path(p0, p1)\n",
" for i in range(len(path) - 2):\n",
" wire1, wire2 = path[i], path[i + 1]\n",
" qubit1 = current_layout[wire1]\n",
" qubit2 = current_layout[wire2]\n",
" new_dag.apply_operation_back(\n",
" SwapGate(), qargs=[qubit1, qubit2]\n",
" )\n",
" current_layout.swap(wire1, wire2)\n",
"\n",
" new_dag.compose(\n",
" subdag, qubits=current_layout.reorder_bits(new_dag.qubits)\n",
" )\n",
"\n",
" return new_dag"
]
},
{
"cell_type": "markdown",
"id": "4a95eaab",
"metadata": {},
"source": [
"El pase puede probarse ahora en un pequeño circuito de ejemplo. Se construye un gestor de pases con el pase recién definido incluido. A continuación, se proporciona el circuito de ejemplo a este gestor de paso y se obtiene como salida un nuevo circuito transformado.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "2f35375f",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.transpiler import CouplingMap, PassManager\n",
"from qiskit import QuantumRegister, QuantumCircuit\n",
"\n",
"q = QuantumRegister(7, \"q\")\n",
"in_circ = QuantumCircuit(q)\n",
"in_circ.h(q[0])\n",
"in_circ.cx(q[0], q[4])\n",
"in_circ.cx(q[2], q[3])\n",
"in_circ.cx(q[6], q[1])\n",
"in_circ.cx(q[5], q[0])\n",
"in_circ.rz(0.1, q[2])\n",
"in_circ.cx(q[5], q[0])\n",
"\n",
"coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]\n",
"coupling_map = CouplingMap(couplinglist=coupling)\n",
"\n",
"pm = PassManager()\n",
"pm.append(BasicSwap(coupling_map))\n",
"\n",
"out_circ = pm.run(in_circ)\n",
"\n",
"in_circ.draw(output=\"mpl\")\n",
"out_circ.draw(output=\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "56b80ce3",
"metadata": {},
"source": [
"\n",
"\n",
"## Próximos pasos\n",
"\n",
"\n",
" * Consulte la guía sobre cómo crear una [pasada de transpilador personalizada](/docs/guides/custom-transpiler-pass)\n",
" * Descubre cómo [crear y transpilar utilizando backends personalizados](/docs/guides/custom-backend)\n",
" * Prueba la guía [de configuración del transpilador Compare](/docs/guides/circuit-transpilation-settings).\n",
" * Revisa la [documentación de la API del circuito DAG](/docs/api/qiskit/dagcircuit).\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
}
},
"nbformat": 4,
"nbformat_minor": 5
}