English

IEEE Quantum Week · QCE26 · tutorial de 3 horas · 18 de septiembre

De circuitos monolíticos a redes multi-QPU

Fundamentos de programación distribuida en HPC, el estándar MPI, su traslación al dominio cuántico con NetQMPI, el emulador CUNQA por dentro, y la integración de ambos. Material de apoyo de las dos sesiones del tutorial.

BloquesLas dos sesiones · tres horas
RequisitosPython; circuitos cuánticos básicos
Herramientasmpi4py · NetQMPI · CUNQA
ObjetivoEscribir, desplegar y ejecutar una aplicación distribuida
Parte I · Capítulo 1

Por qué paralelizamos

La computación distribuida no es una técnica de optimización avanzada que se aplica cuando ya no queda nada más que hacer. Es la consecuencia directa de dos límites físicos que se alcanzaron hace dos décadas y que no se han levantado desde entonces. Conviene empezar por ahí, porque exactamente los mismos dos límites reaparecen —con otro vocabulario— cuando hablamos de conectar varias QPU.

1.1 El escalado de Dennard y su final

En 1974, Robert Dennard y sus coautores formularon la regla que gobernó el diseño de microprocesadores durante treinta años.19 El enunciado, simplificado: si reduces las dimensiones lineales de un transistor por un factor k, y reduces proporcionalmente la tensión de alimentación, entonces la densidad de potencia por unidad de área se mantiene constante. Traducido a consecuencias prácticas: cada nueva generación de proceso te daba más transistores y más frecuencia de reloj sin pagar más vatios por milímetro cuadrado.

Eso es lo que se llamó the free lunch. Un programador podía escribir código secuencial y confiar en que, sin tocar una línea, ese mismo código iría más rápido en el hardware del año siguiente. No era una promesa de marketing: era una propiedad física del escalado.

El escalado de Dennard se rompe alrededor de 2004–2006. La razón inmediata es que la tensión de umbral de los transistores no puede seguir bajando sin que la corriente de fuga (leakage) se dispare, y la potencia estática empieza a dominar el presupuesto térmico. A partir de ahí, subir la frecuencia significa subir la potencia de forma superlineal, y la potencia se convierte en el recurso restrictivo del diseño.

Es importante ser preciso con el vocabulario aquí, porque es el error más común al contar esta historia: lo que se rompió no fue la ley de Moore, sino el escalado de Dennard. El número de transistores por chip ha seguido creciendo. Lo que dejó de crecer fue lo que podías hacer con ellos manteniendo un único hilo de ejecución. La respuesta de la industria fue replicar: si no puedes hacer que un núcleo vaya más rápido, pon más núcleos. Y en el momento en que hay más de un núcleo, el rendimiento deja de ser un problema del fabricante y pasa a ser un problema del programador.

Divergencia de las tendencias de microprocesador 1 10² 10⁴ 10⁶ 10⁸ 2005 · fin del escalado de Dennard transistores monohilo frecuencia núcleos 1971 1980 1990 2000 2010 2020 Escala vertical logarítmica · unidades normalizadas por serie

Las cuatro curvas comparten un solo eje logarítmico y unidades arbitrarias por serie: lo que importa no es el valor absoluto sino la forma. La curva de transistores no se dobla. La de frecuencia se aplana hacia 2005 y desde entonces es esencialmente horizontal. La de núcleos permanece en 1 durante treinta y cuatro años y despega exactamente en el mismo punto donde la frecuencia se detiene. Valores esquemáticos de orden de magnitud; para cifras auditables, véase el conjunto de datos de tendencias de microprocesador de Rupp.20

1.2 El muro de memoria

El segundo límite es independiente del primero y, en la práctica actual, más restrictivo. Wulf y McKee lo bautizaron en 1995 con un artículo de cuatro páginas cuyo argumento sigue siendo válido treinta años después.18 La observación es sencilla: la velocidad de cómputo y la latencia de acceso a memoria principal han mejorado a ritmos radicalmente distintos. El ancho de banda de memoria ha crecido de forma respetable; la latencia, casi nada. Un acceso a DRAM sigue costando del orden de decenas o centenares de ciclos de reloj, igual que hace décadas.

La consecuencia se formaliza con el concepto de intensidad aritmética: el número de operaciones en coma flotante que ejecutas por cada byte que mueves desde memoria. Si tu algoritmo tiene intensidad aritmética baja, no importa cuántos FLOPS tenga tu máquina —estarás limitado por el movimiento de datos, no por el cálculo. En aceleradores modernos el punto de equilibrio se sitúa en el orden de decenas de FLOP por byte, lo que deja a la mayoría de los núcleos computacionales científicos del lado limitado por memoria. El modelo roofline es la herramienta estándar para visualizar esto y aparece en cualquier tratamiento serio del tema.17

La lección operativa, que conviene grabar porque va a reaparecer en la parte cuántica sin apenas cambios: mover un dato cuesta más que operar con él. Todo el diseño de algoritmos paralelos consiste, en el fondo, en reorganizar el cálculo para mover menos.

Parte I · Capítulo 2

Anatomía de un sistema distribuido

Antes de repartir trabajo hay que saber sobre qué se reparte. La jerarquía física de un supercomputador determina qué operaciones son baratas y cuáles caras, y esa jerarquía es la que después se refleja —a veces mal— en el modelo de programación.

2.1 La jerarquía física

De dentro hacia fuera, un supercomputador contemporáneo se organiza en cuatro niveles:

  • Núcleo (core): la unidad de ejecución. Tiene sus propios registros y sus cachés de primer nivel.
  • Socket: un encapsulado físico que agrupa decenas de núcleos con una caché de último nivel compartida y un controlador de memoria.
  • Nodo: una placa con uno o varios sockets, su memoria DRAM y, cada vez más, aceleradores (GPU y —esta es la apuesta del campo— QPU). Todo lo que hay dentro de un nodo comparte un espacio de direcciones.
  • Clúster: el conjunto de nodos unidos por una red de interconexión de baja latencia. Entre nodos no hay memoria compartida.

Esa última frase es la bisagra de todo el curso. La frontera del nodo es la frontera del espacio de direcciones, y cruzarla exige un mecanismo explícito de comunicación. Dentro del nodo puedes usar hilos y variables compartidas; fuera, tienes que enviar mensajes.

Jerarquía núcleo, socket, nodo, clúster nodo 0 memoria local · un único espacio de direcciones socket 0 caché compartida socket 1 caché compartida nodo 1 memoria local · un único espacio de direcciones socket 0 caché compartida acelerador QPU futuro cercano red de interconexión · paso de mensajes explícito, sin memoria común la frontera del nodo es la frontera del espacio de direcciones

Dentro de un nodo, los núcleos comparten memoria y la comunicación es implícita: escribir una variable basta. Al cruzar a otro nodo hay que empaquetar, enviar y recibir. Nótese el acelerador dibujado en el nodo 1: la tesis de la integración HPC-QC es exactamente esta, tratar la QPU como un acelerador más dentro de la jerarquía existente.1

2.2 Memoria compartida frente a memoria distribuida

De la jerarquía se derivan dos modelos de programación con propiedades opuestas.

En memoria compartida todos los hilos ven las mismas direcciones. Comunicar es escribir en una variable; no hay coste explícito de transferencia. A cambio, aparecen las condiciones de carrera, hace falta sincronización (cerrojos, barreras, secciones críticas) y el modelo no escala más allá del nodo. OpenMP es el estándar de referencia.

En memoria distribuida cada proceso tiene su propio espacio de direcciones privado. No hay carreras de datos porque no hay datos compartidos; a cambio, toda comunicación es explícita y tiene un coste que el programador debe contabilizar. El modelo escala a cientos de miles de procesos. MPI es el estándar de referencia.15

En la práctica los códigos reales son híbridos: MPI entre nodos, OpenMP o CUDA dentro. Pero para lo que nos ocupa aquí, el modelo relevante es el distribuido puro, porque es el que describe una red de QPU: cada nodo cuántico tiene su propio registro de qubits y no existe ningún mecanismo por el que otro nodo lea ese registro directamente. La memoria distribuida no es una elección de diseño en computación cuántica distribuida; es la única topología posible.

Parte I · Capítulo 3

Cómo se reparte el trabajo

Dado un problema y N procesadores, hay esencialmente dos formas de dividirlo. La elección entre ambas no es estética: determina el patrón de comunicación resultante, y el patrón de comunicación determina el rendimiento.

3.1 Descomposición de datos

Se reparte el dominio del problema y todos los procesos ejecutan el mismo código sobre su porción. Es la estrategia dominante en cálculo científico: mallas de diferencias finitas, matrices densas, cuerpos en una simulación gravitatoria, píxeles de una imagen. Cada proceso conoce su bloque, opera sobre él y sólo necesita comunicarse en las fronteras del bloque —lo que en simulación por dominios se llama intercambio de halo o ghost cells.

Sus propiedades: el código es único y no depende de N; la comunicación se concentra en momentos discretos (una distribución inicial, un intercambio de fronteras por iteración, una reducción final); y escala bien mientras el bloque local sea grande comparado con su frontera, es decir, mientras la razón volumen/superficie sea favorable.

3.2 Descomposición de tareas

Se reparten las etapas del cálculo y los datos fluyen a través de ellas. Cada proceso hace algo distinto. Es el modelo de un cauce de procesamiento: adquirir, filtrar, transformar, escribir. También el de los grafos de tareas irregulares.

Sus propiedades son casi complementarias: el código es distinto en cada rank, la comunicación es continua en lugar de discreta, y el rendimiento global lo fija la etapa más lenta, no la suma de las etapas. Balancear un cauce es más difícil que balancear un dominio, porque las etapas rara vez cuestan lo mismo.

3.3 El caso feliz: embarrassingly parallel

El límite degenerado de la descomposición de datos, cuando la comunicación entre procesos es nula. Muestreo Monte Carlo, barridos de parámetros, evaluación de un mismo circuito con distintas semillas. No hay fronteras que intercambiar porque las porciones son independientes. El escalado es lineal por construcción y el único coste es la agregación final de resultados.

Descomposición de datos frente a descomposición de tareas descomposición de datos misma operación, datos distintos vectores a, b · n elementos rank 0 bloque 0 rank 1 bloque 1 rank 2 bloque 2 todos ejecutan c[i] = a[i] + b[i] descomposición de tareas operaciones distintas, datos en cadena flujo de datos entrante rank 0 filtrar rank 1 transformar rank 2 escribir cada rank ejecuta una etapa distinta caso límite · embarrassingly parallel descomposición de datos con comunicación nula entre ranks · escalado lineal por construcción

El eje que separa ambas estrategias no es «datos» frente a «tareas» sino el patrón de comunicación que inducen. A la izquierda, comunicación concentrada en los extremos y proporcional al tamaño del bloque. A la derecha, comunicación continua y dominada por la latencia de mensajes pequeños. Son dos regímenes distintos del modelo de coste que se introduce en el capítulo 5.

Parte I · Capítulo 4

Cuánto se puede ganar

Existe un límite superior a lo que la paralelización puede darte, y ese límite lo fija la parte del programa que se niega a paralelizarse. Las dos formulaciones clásicas de ese límite no se contradicen: responden a preguntas distintas.

4.1 La ley de Amdahl

Gene Amdahl planteó en 1967 el argumento que aún hoy modera las expectativas.16 Sea s la fracción del tiempo de ejecución que es intrínsecamente secuencial, y 1−s la fracción paralelizable. Con N procesadores, la aceleración es

S(N) = 1 / ( s + (1 − s)/N )

Cuando N tiende a infinito, el segundo término se anula y queda S ≤ 1/s. Con un 5 % secuencial, la aceleración máxima alcanzable con infinitos procesadores es 20×. Con un 25 %, es 4×. No hay hardware que arregle eso.

La lectura correcta de Amdahl no es «paralelizar no merece la pena». Es «identifica y ataca la fracción serie antes de comprar más nodos». En la práctica, esa fracción serie casi nunca es cálculo puro: suele ser entrada/salida, inicialización, sincronización global y —muy en particular— comunicación.

4.2 La ley de Gustafson

John Gustafson observó en 1988 que Amdahl asume algo que casi nunca se cumple: que el tamaño del problema es fijo.16 Nadie compra un supercomputador para resolver el mismo problema más rápido; lo compra para resolver un problema mayor en el mismo tiempo. Si al aumentar N aumentas también el tamaño del problema, la fracción paralelizable crece con él mientras la serie permanece aproximadamente constante. La aceleración escalada resulta

S(N) = s + (1 − s) · N

que es lineal en N y no está acotada. Ambas leyes son ciertas; describen escenarios distintos.

Ley de Amdahl frente a ley de Gustafson Amdahl · problema de tamaño fijo la aceleración satura en 1/s 01020 s=5% s=10% s=25% ideal 141664 procesadores N · escala log₂ Gustafson · problema que crece con N la aceleración escalada no satura 03264 5% 10% 25% 141664 procesadores N · escala log₂

La misma fracción serie produce dos diagnósticos opuestos según qué se mantenga fijo. Con el problema congelado (izquierda), un 25 % secuencial hace inútil pasar de ocho procesadores. Con el problema escalando (derecha), esa misma fracción sigue dando retorno hasta sesenta y cuatro. Antes de citar cualquiera de las dos leyes hay que declarar cuál de los dos experimentos se está haciendo.

4.3 Escalado fuerte y escalado débil

Las dos leyes anteriores tienen su contrapartida experimental, y son los dos únicos gráficos que un revisor va a mirar en un artículo de rendimiento:

  • Escalado fuerte (strong scaling): el tamaño del problema se mantiene constante y se aumenta N. Se mide el tiempo de ejecución. Es el experimento que corresponde a Amdahl. Su curva siempre acaba doblándose, porque al aumentar N el trabajo local se reduce y la comunicación acaba dominando.
  • Escalado débil (weak scaling): el tamaño del problema por proceso se mantiene constante, de modo que el problema total crece con N. Se mide si el tiempo permanece plano. Es el experimento que corresponde a Gustafson.

Un resultado de escalado débil impecable con un escalado fuerte pésimo es perfectamente posible, y es una situación común. Presentar sólo uno de los dos es la forma más habitual de maquillar un resultado de rendimiento.

Parte I · Capítulo 5

Cuánto cuesta comunicar

Este es el capítulo que hay que entender de verdad, porque es el único de la primera parte que se traslada al dominio cuántico casi sin modificaciones. Todo lo demás se adapta; esto se aplica.

5.1 El modelo latencia–ancho de banda

El coste de enviar un mensaje de n bytes entre dos procesos se modela, en primera aproximación, con dos parámetros:

T(n) = α + β·n

donde α es la latencia —el coste fijo de iniciar la transferencia, independiente del tamaño— y β es el inverso del ancho de banda —el coste marginal por byte. En una red moderna de altas prestaciones, α está en el orden de uno o pocos microsegundos y 1/β en el orden de decenas o centenares de gigabits por segundo.

De este modelo se deriva la magnitud más útil del capítulo: el tamaño de media potencia, n½ = α/β. Es el tamaño de mensaje para el cual el coste fijo iguala al coste variable, y por tanto el punto donde alcanzas la mitad del ancho de banda asintótico. Por debajo de n½ estás pagando sobre todo latencia y la red está prácticamente ociosa; por encima, empiezas a explotar el ancho de banda real.

La consecuencia de diseño es contundente y contraintuitiva para quien viene de programar en serie: enviar mil mensajes de un kilobyte es dramáticamente peor que enviar un mensaje de un megabyte, aunque el volumen total sea idéntico. Agrupar mensajes (message aggregation) es casi siempre la primera optimización que hay que aplicar a un código distribuido que rinde mal.

Modelo de coste de comunicación coste de un mensaje T(n) = α + β·n α pendiente β dominado por latencia dominado por ancho de banda tamaño del mensaje n ancho de banda efectivo n / T(n), normalizado a 1/β 1/β 50% 0 n½ = α/β 1 B100 B10 kB1 MB tamaño del mensaje · escala log₁₀

El mismo modelo visto de dos formas. A la izquierda, la ordenada en el origen α es el peaje que se paga por mensaje enviado, sea cual sea su tamaño. A la derecha, la consecuencia: por debajo del tamaño de media potencia la red entrega una fracción despreciable de su capacidad nominal. Los valores del eje horizontal son ilustrativos; el punto n½ concreto se mide empíricamente con un test de ping-pong.

5.2 Granularidad y razón comunicación/cómputo

La granularidad de una descomposición es la cantidad de trabajo que hace un proceso entre dos comunicaciones consecutivas. Grano fino significa mucha comunicación y poco cálculo entre mensajes; grano grueso, lo contrario.

La métrica que gobierna el escalado es la razón entre tiempo de comunicación y tiempo de cómputo. Al aumentar N con el problema fijo, el trabajo por proceso disminuye pero el número de mensajes suele aumentar, así que esta razón empeora inevitablemente. Ese es el mecanismo físico detrás del techo de Amdahl: no es que exista un fragmento místico de código secuencial, es que la comunicación crece hasta comerse el beneficio.

5.3 Patologías clásicas

Cuatro fallos que aparecen sistemáticamente en código distribuido y que conviene nombrar antes de escribir la primera línea de MPI:

Patología Qué ocurre y cómo se evita
Interbloqueo Dos procesos esperan mutuamente un mensaje que el otro no ha enviado todavía. Se evita ordenando las operaciones, usando primitivas combinadas o pasando a comunicación no bloqueante.
Desbalanceo Un proceso tarda más que el resto y todos esperan en la barrera siguiente. El tiempo total lo fija el más lento, no la media.
Sobresincronización Barreras globales innecesarias que serializan de facto el programa. Cada barrera es una fracción serie regalada a Amdahl.
Grano demasiado fino Muchos mensajes pequeños, todos por debajo de n½. La red trabaja al 5 % de su capacidad nominal y el perfil de rendimiento parece inexplicable.
Parte II · Capítulo 6

MPI: SPMD, rank y communicator

MPI no es una biblioteca: es una especificación de interfaz, mantenida por el MPI Forum, de la que existen múltiples implementaciones independientes —Open MPI, MPICH, y las variantes de los fabricantes.<Ref n={15} /> Que sea un estándar y no un producto es la razón de que un código escrito en 1996 siga compilando y ejecutando hoy en máquinas que no existían entonces. En Python, el acceso al estándar se hace a través de `mpi4py`.<Ref n={21} />

6.1 El paradigma SPMD

La idea que sostiene todo el edificio se llama Single Program, Multiple Data. Se escribe un único fichero fuente. El lanzador arranca N copias de ese mismo programa como procesos independientes, y a cada copia le inyecta un identificador distinto. El programa consulta ese identificador y decide qué rama de su propia lógica ejecutar.

Conviene subrayar por qué esto es una elección de diseño y no una obviedad. La alternativa —MPMD, escribir un programa distinto por rol— parece más natural al principio y produce código ilegible en cuanto hay más de tres participantes: para pasar de tres a cuatro nodos hay que escribir un fichero nuevo y modificar los existentes. SPMD desacopla el código del número de procesos. Ese desacoplo es, literalmente, el argumento central de NetQMPI, y por eso merece la pena insistir aquí.

El paradigma SPMD script.py rank = comm.Get_rank() size = comm.Get_size() ifrank == 0: reparte_datos() else: procesa_bloque() un único fuente mpirun -n 3 el lanzador inyecta rank rank 0 size 3 → ejecuta reparte_datos() rank 2 size 3 → ejecuta procesa_bloque() rank 1 size 3 → ejecuta procesa_bloque() tres procesos, misma imagen de código

El fichero es uno; los procesos, N. El valor de rank es lo único que difiere entre ellos, y sobre esa única diferencia se construye toda la asimetría de roles del programa. Cambiar de tres a treinta y dos procesos no toca ni una línea del fuente: sólo el argumento del lanzador.

6.2 Rank: la identidad lógica

El rank es un entero en el intervalo [0, size−1] asignado a cada proceso dentro de un communicator. No es un número de nodo, ni un identificador de proceso del sistema operativo, ni una dirección de red. Es una etiqueta lógica, y esa es precisamente su virtud: el programa razona sobre ranks y delega en el entorno de ejecución la correspondencia con recursos físicos.

Por convención universal, el rank 0 hace de coordinador cuando hace falta uno —lee ficheros, distribuye trabajo, recoge resultados—. Es una convención, no una regla del estándar; en MPI, el rank 0 no tiene ningún privilegio.

6.3 Communicator: el contexto de comunicación

Un communicator encapsula dos cosas: un grupo de procesos y un contexto de comunicación aislado. Todo mensaje se envía dentro de un communicator, y los mensajes de contextos distintos nunca se confunden entre sí —propiedad que hace posible escribir bibliotecas paralelas seguras sin miedo a colisionar con los mensajes del programa que las usa.

Al arrancar existe MPI_COMM_WORLD, que contiene a todos los procesos lanzados. Se pueden derivar subcomunicadores para agrupar procesos por criterios propios.

La lectura conceptual que interesa para lo que viene después: el communicator es una capa de virtualización. Presenta al programador un conjunto de participantes numerados de 0 a N−1 sobre lo que en realidad es un conjunto heterogéneo de recursos físicos conectados por una topología concreta. El programa se escribe contra la vista lógica; el mapeo lo resuelve el sistema.

El communicator como capa de virtualización COMM_WORLD · vista lógica rank 0 rank 1 rank 2 rank 3 el planificador decide el mapeo · el programa no lo sabe ni lo necesita nodo físico A socket 0 recurso socket 1 recurso nodo físico B socket 0 recurso socket 1 recurso ranks contiguos no implican recursos contiguos

Las líneas de puntos se cruzan deliberadamente. Que dos ranks sean consecutivos no significa que estén en el mismo nodo ni que su comunicación sea barata: el mapeo lo decide el planificador según la política de asignación. Esta separación entre identidad lógica y recurso físico es idéntica a la que introduce el QMPICommunicator de NetQMPI al asociar ranks con QPU.2

from mpi4py import MPI

comm = MPI.COMM_WORLD
rank = comm.Get_rank()      # quién soy
size = comm.Get_size()      # cuántos somos
name = MPI.Get_processor_name()

print(f"soy el rank {rank} de {size}, en {name}")

Se ejecuta con mpirun -n 4 python hello.py. En mpi4py no hace falta llamar a Init ni a Finalize: la importación del módulo inicializa el entorno y la finalización se registra automáticamente al terminar el intérprete.

Parte II · Capítulo 7

Comunicación punto a punto

La operación elemental de MPI es el envío de un mensaje de un rank a otro. Todo lo demás —incluidas las colectivas— se puede construir sobre ella.

7.1 Send y Recv

Un envío especifica el destino, y una recepción especifica el origen. Ambos llevan una etiqueta (tag) que permite distinguir mensajes distintos entre la misma pareja de procesos, y ambos ocurren dentro de un communicator. Una recepción sólo casa con un envío si coinciden origen, destino, etiqueta y communicator.

from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()

if rank == 0:
    datos = {"iteracion": 7, "residuo": 1e-6}
    comm.send(datos, dest=1, tag=11)
elif rank == 1:
    datos = comm.recv(source=0, tag=11)
    print("recibido:", datos)

7.2 Bloqueante frente a no bloqueante

Las operaciones bloqueantes (send, recv) no retornan hasta que es seguro reutilizar el búfer. Las no bloqueantes (Isend, Irecv) retornan inmediatamente devolviendo un objeto request, y el programa debe esperar más tarde con Wait o comprobar con Test. Las no bloqueantes permiten solapar comunicación y cálculo —empezar a enviar, hacer trabajo útil mientras el mensaje viaja, y esperar sólo cuando se necesita el dato—, que es la técnica estándar para ocultar la latencia α del capítulo anterior.

7.3 Interbloqueo: el error canónico

Considérese el intercambio de fronteras entre dos vecinos, escrito de la forma aparentemente más natural: cada proceso envía primero y recibe después. Si la implementación de MPI no dispone de espacio de buffering suficiente —y con mensajes grandes no lo tendrá—, send bloquea hasta que el destinatario ejecute su recv. Pero el destinatario está bloqueado en su propio send, esperando lo mismo. Ninguno de los dos llegará jamás a su recv.

Lo pernicioso de este fallo es que puede funcionar en pruebas y colgarse en producción: con mensajes pequeños la implementación los almacena en un búfer interno y el send retorna, ocultando el error. El programa es incorrecto en ambos casos; simplemente no se manifiesta hasta que el tamaño del problema crece.

Interbloqueo en un intercambio bidireccional y su solución incorrecto · ambos envían primero rank 0 rank 1 send(→1) send(→0) bloqueado esperando bloqueado esperando ✕ ningún recv llega a ejecutarse puede pasar los tests con mensajes pequeños correcto · se alterna el orden rank 0 rank 1 send(→1) recv(←0) recv(←1) send(→0) ambos progresan o, mejor, una única llamada a Sendrecv

Tres soluciones válidas al mismo problema, en orden de preferencia: usar Sendrecv, que delega en la implementación la ordenación segura; usar comunicación no bloqueante con Isend/Irecv seguida de Waitall; o alternar manualmente el orden según la paridad del rank, como muestra el panel derecho. La tercera funciona pero es frágil y no generaliza bien a topologías complejas.

Parte II · Capítulo 8

Operaciones colectivas

Una colectiva es una operación en la que participan *todos* los procesos de un communicator. Todos deben invocarla; si uno la omite, el programa se cuelga. A cambio, expresan patrones de comunicación habituales en una sola llamada y permiten a la implementación usar algoritmos óptimos —árboles binomiales, algoritmos en anillo— en lugar del bucle ingenuo que escribiría el usuario.

8.1 Las cuatro fundamentales

Colectivas fundamentales de MPI Bcast · el root replica un dato a todos 0123 A A A A A antesdespués Scatter · el root reparte porciones 0123 A B C D A B C D antesdespués Gather · el root recoge las porciones 0123 A B C D A B C D antesdespués Reduce · combina con un operador 0123 a b c d a ⊕ b ⊕ c ⊕ d antesdespués

Cada fila es un rank y cada celda una posición de su búfer. Bcast copia; Scatter y Gather mueven; Reduce combina con un operador asociativo (suma, máximo, producto…). Esta distinción entre copiar, mover y combinar es la que va a determinar qué colectivas sobreviven a la transición al dominio cuántico y cuáles no.

Variantes que conviene conocer: Allgather deja el resultado de un Gather en todos los procesos, no sólo en el root; Allreduce hace lo propio con Reduce y es probablemente la colectiva más usada del estándar; Barrier sincroniza sin transferir datos; y Scatterv/Gatherv admiten porciones de tamaño desigual, necesarias cuando el número de elementos no es divisible entre el número de procesos.

Parte II · Capítulo 9

Ejercicios con mpi4py

Cuatro ejercicios en orden creciente de dificultad. El tercero es opcional; el cuarto es el que conecta con la segunda parte del tutorial y merece hacerse aunque no dé tiempo a los demás.

from mpi4py import MPI
import numpy as np

comm = MPI.COMM_WORLD
rank, size = comm.Get_rank(), comm.Get_size()

N = 1_000_000
assert N % size == 0, "usa Scatterv si N no es divisible"
local_n = N // size

# sólo el root materializa los vectores completos
if rank == 0:
    a = np.arange(N, dtype=np.float64)
    b = np.ones(N,      dtype=np.float64)
    c = np.empty(N,     dtype=np.float64)
else:
    a = b = c = None

a_local = np.empty(local_n, dtype=np.float64)
b_local = np.empty(local_n, dtype=np.float64)

comm.Scatter(a, a_local, root=0)      # reparte
comm.Scatter(b, b_local, root=0)

c_local = a_local + b_local           # cálculo puramente local

comm.Gather(c_local, c, root=0)       # recoge

if rank == 0:
    print("correcto:", np.allclose(c, np.arange(N) + 1.0))

Puntos de discusión al corregirlo. Primero: Scatter con mayúscula, porque los datos son arrays de NumPy y no queremos que pickle los serialice. Segundo: los no-root pasan None como búfer de envío, lo cual es correcto —sólo el root necesita tenerlo. Tercero, y es el punto pedagógico importante: este programa no acelera nada. La suma de vectores tiene intensidad aritmética ínfima, así que el tiempo lo domina el Scatter y el Gather. Es un ejercicio de mecánica de la API, no de rendimiento, y conviene decirlo en voz alta para no crear una expectativa falsa.

parcial = np.array(np.dot(a_local, b_local))
total   = np.empty(1) if rank == 0 else None
comm.Reduce(parcial, total, op=MPI.SUM, root=0)

Merece la pena señalar aquí que el resultado en coma flotante puede diferir del secuencial, porque la suma en punto flotante no es asociativa y el orden de acumulación depende del algoritmo interno de la reducción. No es un error del programa: es una propiedad del cálculo distribuido que sorprende a mucha gente la primera vez.

REPS = 200
for nbytes in [8, 64, 512, 4096, 32768, 262144, 2097152]:
    buf = np.zeros(nbytes // 8, dtype=np.float64)
    comm.Barrier()
    t0 = MPI.Wtime()
    for _ in range(REPS):
        if rank == 0:
            comm.Send(buf, dest=1); comm.Recv(buf, source=1)
        elif rank == 1:
            comm.Recv(buf, source=0); comm.Send(buf, dest=0)
    dt = (MPI.Wtime() - t0) / (2 * REPS)
    if rank == 0:
        print(f"{nbytes:>9} B  {dt*1e6:8.2f} us  {nbytes/dt/1e9:7.2f} GB/s")

Este es el ejercicio que más rendimiento pedagógico da por minuto invertido, porque produce números concretos de la máquina que se está usando y hace tangible el capítulo 5. Y tiene una segunda vida: en la parte cuántica del tutorial se puede plantear el equivalente —medir el tiempo de establecer un par EPR y compararlo con el de una puerta local— para que el asistente vea con sus propios datos cuántos órdenes de magnitud separan ambos costes.

Parte III · Capítulo 10

Qué se rompe al pasar al dominio cuántico

Todo lo anterior se traslada. Pero no se traslada gratis: cuatro propiedades que dábamos por supuestas en MPI dejan de ser ciertas, y de esas cuatro roturas salen todas las decisiones de diseño de NetQMPI. Este capítulo es el eje del tutorial.

10.1 El teorema de no clonación elimina el broadcast

No existe ninguna operación física que, dado un estado cuántico arbitrario y desconocido |ψ⟩, produzca dos copias independientes |ψ⟩⊗|ψ⟩. La demostración es de tres líneas y se sigue de la linealidad de la mecánica cuántica. La consecuencia para nosotros es brutal en su simplicidad: MPI_Bcast no tiene equivalente cuántico. No es que sea caro, ni que esté sin implementar: es que está prohibido.

Esto no es un detalle menor de la API. Es exactamente la objeción que se le hace a la propuesta teórica QMPI de Häner y coautores, que definió la semántica de un MPI cuántico pero no resolvió cómo expresar las colectivas que implican copia.4 Cualquier biblioteca que pretenda ser un «MPI cuántico» tiene que dar una respuesta a esta pregunta, y la respuesta de NetQMPI —las primitivas expose y unexpose— se detalla en el capítulo 13.

El no-broadcast cuántico y su alternativa prohibido · copiar el estado rank 0 |ψ⟩ |ψ⟩ copia |ψ⟩ copia |ψ⟩ copia teorema de no clonación permitido · compartir un estado entrelazado rank 0 |ψ⟩ rank 1 rank 2 rank 3 α|0000⟩ + β|1111⟩ · un único estado, cuatro localizaciones

La diferencia no es de eficiencia sino de ontología. A la izquierda habría cuatro estados independientes; a la derecha hay uno solo, cuyos grados de libertad están repartidos entre cuatro nodos. Ningún nodo posee el estado, y medir en cualquiera de ellos afecta instantáneamente a lo que verán los demás. Es un recurso compartido, no un dato replicado.

10.2 Las otras tres roturas

Supuesto de MPI Qué ocurre en el caso cuántico
Leer no destruye Medir un qubit colapsa su estado. No existe la operación «inspeccionar el búfer sin consumirlo», que es la base de cualquier depuración clásica. Depurar un programa cuántico distribuido es cualitativamente más difícil, y esto justifica por sí solo una capa de abstracción que reduzca la superficie de código.
El canal es reutilizable Cada transferencia consume un par entrelazado, que desaparece al usarse. El «ancho de banda» no es una tasa sostenida sino un inventario de recursos que hay que generar, distribuir y contabilizar.
Un mensaje retrasado sigue siendo válido El entrelazamiento se degrada con el tiempo por decoherencia. Hay un plazo. Un protocolo correcto pero lento puede ser un protocolo incorrecto en la práctica, porque la fidelidad del estado al llegar ya no es aceptable.

10.3 Lo que no cambia: el plano de control clásico

Un malentendido frecuente conviene desactivarlo pronto. Transferir un qubit entre nodos se hace por teleportación, y la teleportación no es una alternativa a la comunicación clásica: la necesita. El protocolo consume un par EPR previamente distribuido, el emisor hace una medida de Bell sobre su qubit y su mitad del par, y envía dos bits clásicos por un canal convencional. Sin esos dos bits, el receptor no sabe qué corrección de Pauli aplicar y su qubit es basura.

De modo que una red cuántica es siempre una red doble: un plano cuántico que distribuye entrelazamiento y un plano clásico que transporta resultados de medida y sincroniza. Cualquier biblioteca que abstraiga esto tiene que gestionar los dos, y la mitad de la verbosidad del SDK de NetQASM viene precisamente de tener que orquestar ambos a mano.6

Parte III · Capítulo 11

La pila software

Antes de ver código conviene situar cada pieza. El ecosistema de software para redes cuánticas está estratificado de forma muy parecida al de HPC, y confundir los niveles es la fuente principal de malentendidos.

11.1 Los niveles

De abajo arriba:

  • Simuladores de eventos discretos. NetSquid modela la física: emisión de fotones, pérdida en fibra, decoherencia de memorias, temporización.7 SeQUeNCe hace lo propio con más énfasis en la capa de red y el encaminamiento.10 Son herramientas para arquitectos de red, no para programadores de aplicaciones: el código está dominado por definiciones de hardware.
  • NetQASM, una arquitectura de conjunto de instrucciones de bajo nivel, independiente de plataforma, para programas híbridos clásico-cuánticos en una internet cuántica.6 Cumple aquí el papel que cumple un ISA en computación clásica: desacopla el software del hardware. Su SDK en Python ofrece la abstracción del EPR socket.
  • Backends de ejecución. SquidASM traduce NetQASM a eventos de NetSquid, dando simulación físicamente realista. SimulaQron ejecuta cada nodo como un proceso separado comunicándose por sockets, lo que impone una separación de memoria estricta muy útil para validar lógica distribuida.8
  • NetQMPI, la capa que nos ocupa: middleware sobre el SDK de NetQASM que aporta el paradigma SPMD, el communicator y las primitivas semánticas.2

Al margen de esta pila existen herramientas de alto nivel con filosofías distintas —QuNetSim, con una API centralizada muy accesible pero sin camino a hardware real;9 Interlinq, que automatiza el particionado de circuitos23— y, en el nivel de representación intermedia, NetQIR, una extensión de QIR para computación cuántica distribuida desarrollada por el mismo grupo que NetQMPI y de donde proceden las primitivas expose/unexpose.3

La pila software de NetQMPI y la posición de CUNQA aplicación del usuario un único fichero, paradigma SPMD NetQMPI QMPICommunicator · qsend / qrecv qscatter / qgather · expose / unexpose NetQASM SDK EPRSocket · NetQASMConnection · flush() NetQASM ISA conjunto de instrucciones independiente de plataforma SquidASM sobre NetSquid SimulaQron un proceso por nodo hardware futuro, si soporta el ISA CUNQA emulador DQC para HPC · QPU emuladas como trabajos del planificador · tres modelos: sin comunicación, clásica, cuántica · API propia de gestión y despliegue · pensado para el supercomputador el punto de integración es un adaptador de backend · lo dibuja el capítulo 22

NetQMPI se apoya en el SDK de NetQASM y, por tanto, en sus backends. CUNQA es un desarrollo independiente, orientado a emular QPU distribuidas dentro de un entorno HPC real, con su propia API y sus tres modelos de comunicación.1 Que ambos se combinen en el título del tutorial exige explicitar por dónde se conectan.

Parte III · Capítulo 12

NetQMPI: la interfaz

Con el marco montado, la API se explica casi sola: es MPI con las restricciones del capítulo 10 aplicadas. Lo interesante no es la sintaxis sino qué decide ocultar y qué decide exponer.

12.1 El problema que resuelve

El SDK de NetQASM sigue un modelo basado en roles: se escribe un fichero por participante —app_alice.py, app_bob.py, app_charlie.py—. Además, no ofrece una primitiva de transferencia de qubits: para mover un estado hay que implementar la teleportación a mano, paso por paso, incluyendo la creación del socket EPR, las puertas locales, la medida, el envío de los bits por un socket clásico aparte y la aplicación de correcciones en el receptor. Y hay que invocar flush() manualmente para sincronizar el flujo cuántico.2

El resultado, medido sobre el caso de estudio del capítulo 14, es que el número de ficheros crece con N y la instanciación de sockets crece como N² en topologías completamente conectadas. Ese es el coste que NetQMPI elimina.

12.2 Inyección de rank y creación del communicator

El usuario escribe una función main que acepta rank y size. La biblioteca los inyecta en tiempo de ejecución, exactamente como mpirun hace con los procesos MPI. El punto de entrada de toda la funcionalidad es el QMPICommunicator.

from netqmpi.sdk.communicator import QMPICommunicator

def main(app_config=None, rank=0, size=1):
    # rank y size los inyecta NetQMPI al arrancar
    COMM_WORLD = QMPICommunicator(rank, size, app_config)
    print(f"hola, soy el rank {rank} de {size}")

Y se lanza con una interfaz de línea de órdenes deliberadamente calcada de la de MPI:

$ netqmpi -n 3 script.py
hola, soy el rank 0 de 3
hola, soy el rank 2 de 3
hola, soy el rank 1 de 3

El paralelismo con mpirun -n 3 es visualmente evidente y conviene explotarlo en la presentación: el asistente que acaba de hacer el ejercicio 0 reconoce la estructura de inmediato, incluida la salida desordenada.

Lo que el communicator automatiza al construirse: asigna el rank lógico, recorre la configuración de red instanciando la malla de EPRSocket necesaria entre los participantes, y guarda esos sockets en una tabla de encaminamiento interna. Además gestiona la sincronización del flujo cuántico, con vaciados implícitos en las primitivas y un flush() explícito disponible cuando hace falta.2 El programador deja de ver sockets.

12.3 qsend y qrecv

Las dos primitivas punto a punto encapsulan el protocolo de teleportación completo. Desde el punto de vista del programador, la operación es «envía este qubit al rank destino» y nada más: no aparecen pares EPR, ni fidelidades, ni identificadores de QPU, ni señalización clásica.

Lo que ocultan qsend y qrecv comm.qsend(q, dest_rank=1) q = comm.qrecv(source_rank=0) por debajo de esta línea, todo lo hace la biblioteca rank 0 · emisor rank 1 · receptor 1 · generar y distribuir el par EPR 2 · medida de Bell local CNOT + H, luego medir 3 · dos bits clásicos de corrección canal clásico convencional esperar entrelazamiento 4 · correcciones X / Z → |ψ⟩

Merece la pena desplegar este diagrama en la presentación en lugar de limitarse a decir que la biblioteca «lo gestiona por ti». Una abstracción cuyo interior no se ha mostrado se percibe como magia, y en una audiencia de investigadores eso cuesta credibilidad. Nótese además que el qubit original queda destruido por la medida del paso 2: la teleportación mueve el estado, no lo duplica, y por tanto es compatible con el no-clonación.

def main(app_config=None, rank=0, size=2):
    comm = QMPICommunicator(rank, size, app_config)

    if rank == 0:
        q = Qubit(comm.connection)
        q.H()                          # prepara |+>
        comm.qsend(q, 1)               # sin gestionar EPR
        print("rank 0: qubit enviado")

    elif rank == 1:
        q = comm.qrecv(0)              # devuelve el estado ya corregido
        m = q.measure()
        print(f"rank 1: recibido, medida = {m}")

La simetría estructural con el ejemplo clásico —mismo if rank == 0, mismo par enviar/recibir— es intencionada y es el argumento pedagógico central de la biblioteca: si sabes MPI, ya sabes leer esto.

Parte III · Capítulo 13

Colectivas cuánticas

Aquí es donde la analogía con MPI deja de ser cómoda y hay que romperla explícitamente. Copiar la lista de colectivas de MPI y ponerles una «q» delante no funciona, porque dos de las cuatro fundamentales no son físicamente realizables.

13.1 Las que sobreviven: qscatter y qgather

qscatter toma una lista de qubits en el proceso raíz y los distribuye, uno a cada rank del communicator. qgather hace la operación inversa. Ambas son legítimas porque mueven estados en lugar de copiarlos, y su implementación es un bucle de operaciones punto a punto: un qscatter equivale a que el root ejecute un qsend por cada rank destino.2

Conviene ser honesto sobre esto en la presentación: en su forma actual son azúcar sintáctico sobre punto a punto, no colectivas optimizadas con algoritmos de árbol como las de MPI. Es una diferencia real respecto al estándar clásico y una línea de trabajo futura evidente.

def main(app_config=None, rank=0, size=4):
    comm = QMPICommunicator(rank, size, app_config)
    conn = comm.connection
    ROOT = 0

    qubits = []
    if rank == ROOT:
        qubits = [Qubit(conn) for _ in range(size)]
        for q in qubits:
            q.H()
        conn.flush()

    local_qs = comm.qscatter(qubits, ROOT)   # devuelve el qubit de este rank
    m = local_qs[0].measure()
    conn.flush()
    print(f"rank {rank}: medida {m}")

13.2 La que no existe: Bcast

Por lo visto en el capítulo 10, no hay qbcast y no puede haberlo. La propuesta teórica QMPI dejó este hueco sin resolver, y es su limitación más citada.4

13.3 La respuesta de NetQMPI: expose y unexpose

En lugar de copiar, NetQMPI distribuye. La primitiva expose, tomada del marco arquitectónico de NetQIR,3 transforma un estado que reside en el root

|ψ⟩ = α|0⟩R₀ + β|1⟩R₀

en un estado global repartido entre todos los rangos participantes

α (|0⟩R₀ ⊗ … ⊗ |0⟩Rₙ) + β (|1⟩R₀ ⊗ … ⊗ |1⟩Rₙ)

La implementación entrelaza el qubit del root con un estado GHZ previamente compartido entre todos los nodos, seguido de medidas locales y correcciones clásicas.2 El resultado no es una copia: es un solo estado cuyos grados de libertad están repartidos. Sobre él se pueden ejecutar operaciones controladas colectivas, que es el uso para el que se diseñó.

Y de ahí la contrapartida: como la operación altera el ámbito de accesibilidad de los qubits, es obligatorio liberar el recurso al terminar. unexpose devuelve el sistema a un estado consistente en el que los qubits vuelven a ser privados de su propietario. No es cortesía: es liberación de recursos, y omitirla deja el communicator en estado inconsistente. La analogía correcta no es Bcast sino la pareja adquirir/liberar de un cerrojo.

Ciclo de vida de expose y unexpose 1 · antes el estado vive en el root rank 0 · α|0⟩ + β|1⟩ rank 1 · |0⟩ rank 2 · |0⟩ rank 3 · |0⟩ expose 2 · expuesto un estado, cuatro localizaciones rank 0 rank 1 rank 2 rank 3 α|0000⟩ + β|1111⟩ aquí van las operaciones colectivas unexpose 3 · liberado obligatorio, no opcional rank 0 · resultado rank 1 · liberado rank 2 · liberado rank 3 · liberado no es copiar y descartar: es repartir un estado y devolverlo · el recurso entrelazado se consume

El ciclo completo. Entre el paso 2 y el 3 es donde el algoritmo hace su trabajo, aplicando operaciones controladas sobre la información cuántica repartida. Omitir unexpose es el equivalente cuántico de una fuga de memoria, con el agravante de que el recurso fugado también se degrada por decoherencia.

13.4 Tabla de correspondencias

MPI NetQMPI Comentario
Send / Recv qsend / qrecv Correspondencia directa. Internamente es teleportación, y el estado original se destruye.
Scatter / Gather qscatter / qgather Correspondencia directa. Implementadas como bucles de punto a punto.
Bcast — No existe. Prohibido por el teorema de no clonación. Su lugar funcional lo ocupa expose, con semántica distinta: reparte, no replica.
Reduce / Allreduce — Requeriría medir para obtener valores combinables, destruyendo la superposición. La reducción de resultados clásicos post-medida sí es posible, pero eso ya es MPI clásico.
Barrier flush() No son equivalentes exactos: flush sincroniza el flujo de instrucciones cuánticas, no es una barrera de procesos.
Parte III · Capítulo 14

Caso de estudio: el estado GHZ distribuido

Generar un estado de Greenberger–Horne–Zeilinger repartido entre N nodos es el «hola mundo» de la internet cuántica: exige entrelazamiento multipartito y control coordinado, y por eso sirve de banco de pruebas para comparar herramientas.<Ref n={2} />

14.1 El protocolo

El objetivo es el estado máximamente entrelazado |GHZ⟩ = (|00…0⟩ + |11…1⟩)/√2 compartido entre N nodos distintos. El protocolo conceptual tiene tres pasos: un nodo raíz prepara un qubit en superposición aplicando una puerta Hadamard; a continuación ejecuta una secuencia de CNOT cuyo control es su qubit y cuyos objetivos residen en los N−1 nodos restantes; y, dado que no hay memoria compartida, cada uno de esos CNOT es remoto y exige por debajo un protocolo de teleportación o de intercambio de entrelazamiento con su correspondiente comunicación clásica y sus correcciones.

Generación distribuida de un estado GHZ rank 0 rank 1 rank 2 rank 3 |0⟩|0⟩|0⟩|0⟩ H (|0000⟩ + |1111⟩) / √2 estado GHZ compartido cada recuadro punteado es un CNOT remoto = 1 par EPR consumido + 2 bits clásicos + correcciones de Pauli

El circuito lógico es trivial: una Hadamard y N−1 puertas CNOT. Lo que no es trivial es que ninguna de esas CNOT se puede ejecutar localmente, porque control y objetivo están en máquinas distintas. Toda la complejidad del problema está oculta dentro de los recuadros punteados, y es exactamente esa complejidad la que las distintas herramientas gestionan de forma más o menos afortunada.

14.2 La misma tarea, dos herramientas

En NetQMPI el programa es un único fichero cuya lógica no depende de N. La primitiva expose se encarga de los CNOT remotos y de la distribución de entrelazamiento subyacente.

def main(app_config=None, rank=0, size=3):
    comm = QMPICommunicator(rank, size, app_config)

    # 1 · el root crea el qubit base en superposición
    qubits = []
    q = Qubit(comm.connection)
    if rank == 0:
        q.H()
    qubits.append(q)

    # 2 · operación colectiva: reparte el control del CNOT remoto
    comm.expose(qubits, root_rank=0)

    # 3 · operaciones locales en los rangos no raíz
    if rank != 0:
        qubits[0].cnot(mi_qubit)

    # 4 · liberar el recurso: obligatorio
    comm.unexpose(root_rank=0)

Pasar de tres a cincuenta nodos consiste en escribir netqmpi -n 50. El fuente no se toca.

El contraste con el SDK crudo es el argumento visual más eficaz de todo el bloque. En NetQASM SDK la lógica está separada estrictamente por roles: para tres nodos hacen falta tres ficheros, la creación de sockets es explícita y por pares, y el CNOT remoto no es una primitiva nativa sino un protocolo que hay que implementar a mano.

# --- app_alice.py (root) ---
sock_bob     = EPRSocket("Bob")          # un socket por destino
sock_charlie = EPRSocket("Charlie")
csock_bob     = Socket("Alice", "Bob")      # y otro clásico por destino
csock_charlie = Socket("Alice", "Charlie")

with NetQASMConnection("Alice", epr_sockets=[sock_bob, sock_charlie]) as c:
    q = Qubit(c); q.H()

    epr_b = sock_bob.create_epr()[0]     # CNOT remoto hacia Bob, a mano
    q.cnot(epr_b)
    m_b = epr_b.measure()
    c.flush()
    csock_bob.send(str(m_b))

    epr_c = sock_charlie.create_epr()[0] # y la lógica duplicada para Charlie
    q.cnot(epr_c)
    m_c = epr_c.measure()
    c.flush()
    csock_charlie.send(str(m_c))

# --- app_bob.py --- y --- app_charlie.py --- : ficheros aparte, casi idénticos

Añadir un cuarto nodo obliga a crear un fichero nuevo y a modificar el del root para instanciar los dos sockets adicionales y duplicar otra vez el bloque de teleportación. Es código repetitivo, estructuralmente necesario y una fuente inagotable de errores de copiar y pegar.

14.3 Cómo escala el código

Escalado del código con el número de nodos 0 300 600 NetQASM SDK · O(N²) QuNetSim · O(N²) de red NetQMPI · O(1) 26101418 número de nodos N · líneas lógicas de código, sin comentarios ni imports

Tendencias cualitativas según el análisis comparativo publicado.2 En los marcos basados en roles, cada nodo nuevo exige un fichero, la instanciación manual de sockets —que crece cuadráticamente en topologías completamente conectadas— y la duplicación de la lógica de control. NetQMPI mantiene la curva plana porque el bucle está dentro de la primitiva colectiva y recorre dinámicamente el tamaño del communicator.

Parte III · Capítulo 15

Cierre y qué queda fuera

El recorrido completo, en una frase: los límites físicos obligan a replicar unidades; replicar unidades obliga a comunicar; comunicar es caro; MPI estandarizó cómo se programa eso en el mundo clásico mediante SPMD, rank y communicator; y NetQMPI traslada esas tres abstracciones al dominio cuántico, adaptando las primitivas allí donde la física prohíbe la traducción literal.

15.1 Lo que este bloque no cubre

  • Fidelidad y ruido. Todo el tratamiento anterior ha sido funcional. El coste real de una operación remota depende de la fidelidad del par EPR y de la tasa de decoherencia, y NetSquid existe precisamente para modelar eso.7
  • Particionado de circuitos. Dado un circuito monolítico y N QPU, ¿cómo se reparte minimizando puertas remotas? Es un problema de optimización combinatoria y una línea de investigación activa.24
  • Topología real de red. Se ha asumido conectividad completa. Una red cuántica realista tiene encaminadores, repetidores e intercambio de entrelazamiento, y el communicator oculta —por ahora— esa estructura.13
  • Comparativa de emuladores. Existe trabajo específico de evaluación comparativa de emuladores de computación cuántica distribuida que conviene consultar antes de elegir herramienta.22

15.2 Enlace con la segunda mitad del tutorial

Los tres modelos de comunicación de CUNQA —sin comunicación, comunicación clásica y comunicación cuántica— corresponden ordenadamente a las tres situaciones descritas en la parte I: el caso embarrassingly parallel, el intercambio de resultados escalares, y el movimiento de estado. La estimación de fase cuántica, que es el algoritmo con el que se demuestra el emulador en la literatura,1 ejercita los tres.

Si el asistente se lleva una sola idea de esta hora y media, que sea esta: la computación cuántica distribuida es computación distribuida, con un modelo de coste de comunicación más severo y una prohibición física —el no clonado— que elimina una de las cuatro colectivas fundamentales. Todo lo demás es transferible.

Parte IV · Capítulo 16

Qué emula CUNQA

La parte III terminó con una interfaz y nada debajo. CUNQA es lo que va debajo —o, más exactamente, la infraestructura emulada que sustituye a una máquina que todavía no se puede comprar—. Saber exactamente qué replica con fidelidad y qué se limita a reproducir en comportamiento es la diferencia entre leer bien sus resultados y leerlos de más.

16.1 Emular no es simular

Las dos palabras se usan indistintamente y no son lo mismo. La emulación busca replicar un sistema fielmente; la simulación busca reproducir su comportamiento. En computación clásica, emular un dispositivo consiste en traducir las instrucciones de la máquina emulada a instrucciones nativas del anfitrión. Esa vía está cerrada para un ordenador cuántico: no hay instrucción clásica a la que traducir una cuántica, porque los paradigmas de cómputo no comparten vocabulario. Queda el camino que planteó Willsch: que la contraparte clásica resuelva las ecuaciones físicas que gobiernan el sistema cuántico, de modo que se reproduzca su comportamiento en lugar de traducir sus instrucciones.26

CUNQA aplica ambas nociones, a alturas distintas de la pila.1

  • A nivel arquitectónico, emula. Las QPU son componentes de primera clase, desplegadas y consultadas a través de las mismas interfaces que expondría una instalación física. Su integración en el sistema HPC está diseñada también para imitar con fidelidad cómo se integraría una QPU real.
  • A nivel de dispositivo, simula. Bibliotecas de terceros reproducen el resultado de las tareas cuánticas; los canales reproducen el efecto de los enlaces sobre lo que transportan.

En una frase: CUNQA emula infraestructuras de DQC cuyas QPU y canales de comunicación se simulan para ejecutar las tareas cuánticas.

Qué emula CUNQA y qué simula EMULADO · la infraestructura replicada con fidelidad · direccionada por las interfaces que expondría un despliegue real interfaces de vQPU procesos que poseen sus recursos clásicos integración en HPC en el nodo o co-localizadas como un acelerador más interacción entre QPU cómo se comunican nula · clásica · cuántica estructura arriba · física abajo SIMULADO · los dispositivos comportamiento reproducido · delegado en una capa inferior siete simuladores Aer · DDSIM · Maestro · Qulacs Qsim · QuEST · CunqaSimulator comportamiento del canal ideal en la versión 3.0.0 aún sin ruido de comunicación el ruido es de comportamiento, así que vive en la mitad inferior: un canal perfecto sigue siendo un canal de primera clase

Esa división es la que autoriza la palabra «emulador» aun cuando todos los canales sean ideales. Lo que se replica es la estructura: procesos que poseen sus recursos, se planifican, se consultan y se direccionan exactamente como lo haría un acelerador de la máquina. Lo que se reproduce es la física, y la física se delega. El ruido pertenece a la mitad inferior —es una propiedad de comportamiento, no estructural—, y por eso un canal de fidelidad perfecta sigue siendo un canal de primera clase.

16.2 Los dos tipos de ruido

Como el ruido vive en el nivel de dispositivo, se reparte por la misma línea que los componentes:

  • Ruido de dispositivo. Errores de puerta y de qubit —decoherencia, lectura—. Está soportado, pero bajo una restricción que el capítulo 17 precisará: solo cuando AerSimulator ejecuta el bucle de shots sin asistencia.
  • Ruido de comunicación. Latencia de los enlaces, fidelidad del entrelazamiento, pérdida heraldada, decoherencia de memoria mientras se distribuye el entrelazamiento. No modelado en la versión 3.0.0. Los canales son ideales.1

16.3 Dónde se colocan las QPU

Hay tres maneras de situar una QPU respecto de una instalación HPC, siguiendo la clasificación de Elsharkawy et al.27 con las dos variantes co-localizadas fundidas en una:

Modelo Qué significa CUNQA
Standalone Ninguna integración con HPC; el entorno es puramente cuántico. Descartado: queda fuera del paradigma de acelerador.
Co-localizado Las QPU viven dentro del entorno HPC pero separadas de los nodos clásicos. Soportado, mediante la opción --co-located.
On-node Las QPU son dispositivos de un nodo clásico, como una GPU. Soportado, y es el modo por defecto.

La elección no es cosmética: decide qué nodos pueden alcanzar una vQPU dada y, por tanto, cómo hay que dimensionar el trabajo que se lanza en el capítulo 18.

16.4 Los tres modelos de comunicación

Son las tres situaciones que la parte I describió en términos clásicos, y el capítulo 15 ya anticipó la correspondencia:

  • Sin comunicación. QPU independientes. Es el caso embarrassingly parallel del capítulo 3: distintas tareas cuánticas en distintas QPU, en paralelo, sin intercambio.
  • Comunicación clásica. Las QPU intercambian bits clásicos en tiempo de ejecución. Estructuralmente idéntico al anterior, salvo que ahora una QPU puede recibir información clásica a mitad de ejecución y condicionar una instrucción a ella. Esto introduce el problema de sincronización que el modelo anterior no tenía y, con él, el riesgo de interbloqueo del capítulo 7.
  • Comunicación cuántica. Las QPU se entrelazan a través de un canal cuántico manteniendo el enlace clásico. Es el modelo que permite que varias QPU limitadas actúen como una máquina mayor, y al que apuntan las hojas de ruta de los fabricantes.

Hasta donde saben los autores, CUNQA es la única herramienta que emula infraestructuras de DQC con los tres modelos dentro de un entorno HPC.1 Los marcos de integración HPCQC —QFw, MQSS, QCCP, XACC— no exponen ningún modelo de comunicación entre QPU; las herramientas de red cuántica —NetSquid, SeQUeNCe, QuISP, SimulaQron, QuNetSim— ofrecen comunicación completa pero ninguna integración con HPC.22 CUNQA ocupa la intersección, y lo paga en modelado de ruido, que es justo donde esas herramientas de red son más fuertes.

16.5 Por qué los recursos los gestiona uno mismo

Hay dos maneras de dibujar una pila de software cuántico. En la habitual, la gestión de recursos vive dentro del middleware y es opaca al usuario. CUNQA toma deliberadamente la otra: la gestión de recursos es responsabilidad del usuario y queda fuera del flujo de ejecución.1

El razonamiento es de práctica HPC, no de computación cuántica. El tiempo de cómputo en una máquina compartida es un recurso contabilizado que el planificador gobierna por usuario. Una herramienta que reservase recursos por su cuenta gastaría una asignación sin la contención que aplicaría su dueño: con avidez en lugar de con deliberación. La consecuencia para el programador es el flujo en dos pasos del capítulo 18: primero se levanta la infraestructura, después se ejecuta contra ella.

Parte IV · Capítulo 17

La vQPU

La infraestructura del capítulo 16 está hecha de una unidad repetida. Una QPU virtual no es una instancia de simulador que aparece cuando se la invoca y se desvanece cuando retorna: es un proceso que existe, que posee recursos y al que se consulta. Y esa distinción es todo el asunto.

17.1 Qué es una vQPU

Una vQPU es un proceso que corre en un entorno HPC, con su propio conjunto de recursos clásicos asignados, que representa a una QPU real del sistema y ejecuta las tareas cuánticas que se le envían.1 El concepto no es del todo nuevo —Claudino et al. ya trabajaron con aceleradores cuánticos virtualizados32—, pero aquí el énfasis está en la propiedad: como la vQPU posee sus recursos, su vida es independiente de las tareas que se ejecutan en ella.

Esa independencia es lo que la hace comportarse como hardware. Se le puede preguntar si está levantada, de qué está hecha, enviarle trabajo y enviarle más trabajo después. Desde el asiento del programador es otro acelerador que resulta estar en la máquina, exactamente como una GPU o una FPGA: recibe tareas, las ejecuta y devuelve resultados.

El contraste con el flujo habitual de simulación cuántica merece una diapositiva explícita. AerSimulator() es un objeto que se construye dentro del script; una vQPU es un trabajo que ya estaba corriendo antes de que el script arrancase y seguirá corriendo cuando termine.

17.2 Tres componentes

Los tres componentes de una vQPU anatomía de una vQPU un proceso con sus propios recursos clásicos tu programa servidor recibe tareas · las encola · devuelve resultados cómo se llega a ella backend qubits · acoplamiento · puertas · ruido · qubits de comunicación qué declara que es simulador uno de siete · más el canal clásico qué la hace computar servidor y simulador son sustituibles · el backend es fijo por versión, pero trivialmente editable

Servidor, backend y simulador. Los dos primeros son lo que hace a la vQPU direccionable como dispositivo; el tercero es lo que la hace computar. Servidor y simulador están desacoplados de cualquier implementación concreta de terceros, de modo que las bibliotecas subyacentes pueden sustituirse o ampliarse; el backend es fijo dentro de cada versión de CUNQA, pero es trivialmente editable para exponer nuevas características de QPU.

  • Servidor. Conecta la vQPU con el usuario: recibe tareas cuánticas, las encola y devuelve resultados. Una estructura cliente-servidor convencional sobre una biblioteca de sockets estándar —Asio o ZMQ en la versión actual—.
  • Backend. Guarda lo que el usuario necesita saber de la QPU simulada: mapa de acoplamiento, número de qubits, puertas base, modelo de ruido y —bajo el modelo de comunicación cuántica— los qubits de comunicación. Algunos campos son genéricos; otros solo adquieren sentido bajo un modelo DQC concreto.
  • Simulador. Hace la ejecución de verdad. La versión 3.0.0 soporta siete: seis de terceros —AerSimulator, MQT-DDSIM, Maestro, Qulacs, Qsim, QuEST— y CunqaSimulator, uno ligero escrito dentro del propio proyecto con fines de prueba.1

17.3 Cómo cambia la ejecución con el modelo

Esta es la parte que sorprende. El modelo DQC que se emula no solo determina lo que el usuario puede escribir: cambia cómo ejecuta el sistema por debajo.

Sin comunicación. No cambia nada respecto de una ejecución de circuito ordinaria. El simulador hace todo el trabajo y CUNQA lo trata como una caja negra. Hay exactamente una excepción: un if clásico sobre una puerta —CIF—. La mayoría de simuladores no lo soportan, así que CUNQA toma el control, ejecuta el bucle de shots por su cuenta y comprueba clásicamente el bit de control antes de decidir si aplica la puerta.

Esa excepción es el origen de la restricción de ruido anunciada en el capítulo 16. El modelado de ruido descansa sobre AerSimulator, que inyecta ruido a nivel de simulador sin un mecanismo documentado para hacerlo puerta a puerta. En cuanto CUNQA se apropia del bucle de shots, la maquinaria de ruido del simulador queda esquivada. De ahí: las vQPU con ruido solo existen allí donde AerSimulator ejecuta sin asistencia: sin comunicación y sin CIF.1

Comunicación clásica. Vale el mismo razonamiento por el mismo motivo: ningún simulador soportado entiende directivas de comunicación. SEND y RECV se ejecutan, por tanto, dentro de un bucle de shots que controla CUNQA, a través de un elemento adicional del componente simulador: el canal de comunicación clásica, disponible sobre ZMQ o MPI.

Comunicación cuántica. Aquí el esquema anterior se rompe del todo. Los dos modelos previos descansan sobre la misma suposición implícita: cada vQPU guarda su propio estado, así que cada una puede ejecutar su bucle de shots y lo único que cruza entre ellas es clásico. Un canal cuántico rompe esa suposición de raíz —en cuanto dos vQPU están entrelazadas ya no tienen dos estados, tienen uno— y ninguna disposición de simuladores independientes puede representar un estado que no se descompone. Alguien que no sean las vQPU tiene que ejecutar, y de eso trata la sección siguiente.

17.4 El ejecutor centralizado

Bajo comunicación nula y clásica, cada vQPU simula su estado de forma independiente: la distribución es puramente clásica. Bajo comunicación cuántica eso deja de ser posible. Los protocolos cuánticos entre vQPU pueden entrelazar sus qubits, y un estado entrelazado no es, por definición, separable; luego el estado de todas las vQPU implicadas debe simularse como un único estado.

La consecuencia es estructural. Un único estado necesita un único ejecutor consciente de todas las operaciones, porque una operación dirigida a una vQPU puede afectar a otra. Así que en este modelo las vQPU dejan de ser ejecutoras y pasan a ser intermediarias: conservan la interfaz que el usuario tendría con un sistema real, reenvían instrucciones a un ejecutor centralizado y devuelven sus resultados.

Quién ejecuta bajo cada modelo de comunicación cómo ejecuta una vQPU el modelo DQC decide quién ejecuta de verdad el circuito sin comunicación · comunicación clásica vQPU simula su propio estado vQPU simula su propio estado vQPU simula su propio estado estados separados, ejecutoras separadas · solo cruzan bits clásicos comunicación cuántica vQPU · intermediaria vQPU · intermediaria vQPU · intermediaria ejecutor centralizado un estado conjunto · un proceso un estado entrelazado no es separable: no puede repartirse entre simulaciones independientes

La misma infraestructura, ejecutando de dos maneras distintas. Arriba, los dos modelos del capítulo 16 que no necesitan canal cuántico: tres vQPU, tres estados, tres ejecutoras, y solo bits clásicos cruzando entre ellas. Abajo, lo que impone la comunicación cuántica: un estado conjunto, luego un único ejecutor, y las vQPU reducidas a la interfaz. Nada cambia en lo que el usuario escribe —las intermediarias exponen exactamente lo que exponían las ejecutoras— y todo cambia en lo que corre por debajo.

El ejecutor centralizado acepta todas las directivas de los dos modelos anteriores más una propia: GEN_ENT, la generación de un estado entrelazado entre QPU. Con un ejecutor centralizado, generar entrelazamiento no es más que preparar un estado GHZ sobre los qubits de comunicación seleccionados; pero definirlo como instrucción atómica permite a CUNQA extraerlo del flujo de operaciones cuánticas, que es lo que hace modelables la generación de entrelazamiento y la contabilidad de qubits de comunicación. Se eligió como el mínimo semántico de una comunicación cuántica: todo protocolo de comunicación cuántica conocido lo necesita como bloque básico.11

17.5 Qubits de datos y qubits de comunicación

El modelo de comunicación cuántica introduce un campo del backend que los otros dos no tienen. Los qubits de comunicación son un subconjunto de los qubits de una vQPU reservado en exclusiva para la comunicación con otras vQPU, frente a los qubits de datos, que son los que computan. La distinción se remonta a los primeros trabajos sobre computación cuántica distribuida31 y se ha mantenido desde entonces.11

CUNQA la adopta por dos razones. La primera, fidelidad al estado del arte. La segunda, gestión: separar los dos recursos implica que pedir más qubits de comunicación de los que tiene la máquina detiene la ejecución hasta que se liberen algunos, en lugar de consumir silenciosamente los de datos. Nada impide a quien no quiera la separación usar los qubits de comunicación como qubits de datos.

Parte IV · Capítulo 18

Levantar la infraestructura

Tres órdenes cubren todo el ciclo de vida de una vQPU. Son programas en C++ expuestos como órdenes de Bash e implementados como envoltorios de SLURM, que es la manera honesta de decir que CUNQA no inventa un gestor de recursos: toma prestado el que la máquina ya tiene.

18.1 Reservar primero, ejecutar después

El modelo de pila del capítulo 16 tiene una consecuencia operativa directa: cuando el programa de Python arranca, los recursos cuánticos ya tienen que existir. No hay reserva perezosa, ni arranque implícito, ni «si no hay vQPU disponible, se crea una». El flujo tiene dos pasos separados, y están separados a propósito.

El ciclo de vida de una infraestructura levantada qraise -n 4 -t T un trabajo de SLURM familia · viva durante T vQPU 0 vQPU 1 vQPU 2 vQPU 3 qinfo las lista · sobreviven a tu programa qdrop --all scancel tu programa get_QPUs() run(...) gather(...) engancha

El ciclo completo. qraise envía un trabajo que mantiene N vQPU vivas durante un tiempo de pared acotado; qinfo informa de lo que está levantado; el programa de Python del capítulo 19 se engancha a las vQPU en marcha mediante get_QPUs, envía trabajo y recoge resultados; qdrop lo libera todo. Nótese que el programa puede ejecutarse muchas veces contra la misma infraestructura levantada, y que olvidar el qdrop quema asignación hasta que expire el reloj de pared.

18.2 qraise

Dos opciones son obligatorias: cuántas vQPU y durante cuánto tiempo.

$ qraise -n 4 -t 00:10:00

Cada invocación despliega una familia: un grupo homogéneo de vQPU que comparten una configuración. Ejecutar qraise dos veces da dos familias, que pueden diferir en todo —número de qubits, simulador, modelo DQC— y que pueden coexistir en la misma sesión. Las familias son la manera de montar una infraestructura heterogénea a partir de piezas homogéneas.

18.3 Las opciones no obligatorias

Se reparten en cinco grupos, que se corresponden exactamente con las cinco cosas que una infraestructura DQC tiene que decidir.1

Grupo Opciones Qué decide
QPU simulada --backend, --infrastructure Número de qubits (de datos y de comunicación), mapa de acoplamiento, instrucciones soportadas, propiedades de ruido. --backend toma un fichero JSON y despliega vQPU homogéneas; --infrastructure toma un JSON con un backend por vQPU, para despliegues heterogéneos.
Simulador --sim Cuál de los siete simuladores ejecuta las tareas. Por defecto, AerSimulator.
Recursos clásicos --cores-per-qpu, --mem-per-qpu, --n-nodes Se pasan a SLURM. Aquí es donde una vQPU deja de ser una abstracción y empieza a costar dinero.
Modelo DQC --classical_comm, --quantum_comm Ninguna: sin comunicación. Una de ellas: ese modelo.
Integración e identidad --co-located, --family Si las vQPU son alcanzables desde cualquier nodo o solo desde el que las aloja; y un nombre con el que direccionar al grupo.

Las propiedades de ruido —T₁, T₂ y demás— se declaran en el JSON del backend y se convierten en modelo de ruido con Qiskit. La restricción del capítulo 17 aparece aquí en su forma operativa: una vQPU con ruido exige sin comunicación, sin CIF y AerSimulator. Pedir ruido fuera de esas condiciones no da el ruido.

18.4 qdrop y qinfo

qdrop envuelve el scancel de SLURM. Libera todo lo levantado, con --all, o una familia, con --family seguido del nombre.

$ qdrop --family qft_demo      # una familia
$ qdrop --all                  # todo lo que hayas levantado

qinfo informa de las vQPU activas en el sistema: qué familias existen, de qué están hechas y si son alcanzables desde donde estás. Es lo primero que hay que ejecutar cuando un programa no encuentra ninguna QPU, y lo segundo cuando encuentra las que no son.

18.5 Las mismas órdenes desde Python

Las tres están también expuestas en la API de Python. Explícitamente no es el flujo principal previsto: existe para que un único script pueda encargarse de la gestión y de la ejecución cuando eso resulte cómodo, sin abandonar el modelo de pila en el que ambas siguen conceptualmente separadas.

from cunqa.qpu import qraise, get_QPUs, run
from cunqa.circuit import CunqaCircuit
from cunqa.qjob import gather

family = qraise(4, "01:00:00", simulator="Aer", co_located=True)
qpus = get_QPUs(co_located=True)
Parte IV · Capítulo 19

El paquete cunqa

Con la infraestructura levantada, la API de Python cubre dos cosas y solo dos: diseñar tareas cuánticas distribuidas y ejecutarlas. En el lado del diseño viven las directivas DQC; el lado de la ejecución es deliberadamente delgado.

19.1 CunqaCircuit

El punto de entrada del diseño es una clase cuyo constructor le resultará familiar a cualquiera que haya escrito Qiskit:

from cunqa.circuit import CunqaCircuit

circuit = CunqaCircuit(num_qubits=3, num_clbits=3, id="circuit_id")

El id no es decoración. Bajo cualquier modelo de comunicación, los circuitos se direccionan entre sí por identificador, no por rank ni por QPU: un envío nombra al circuito receptor, y una generación de entrelazamiento nombra a los circuitos que entrelaza. Es una diferencia real respecto de MPI, donde el destinatario es un rank dentro de un communicator, y conviene señalarla pronto porque es lo primero con lo que tropieza quien llega de la parte II.

Más allá del catálogo habitual de puertas locales, la clase implementa las directivas de comunicación.

19.2 Comunicación clásica: send, recv, cif

Dos circuitos, uno identificado como emisor y otro como receptor. El emisor empuja el contenido de uno o más registros clásicos; el receptor declara de antemano dónde van a aterrizar.

send_circuit.send(clbits=sending_cregs, recving_circuit="recving_circuit_id")

recv_circuit.recv(clbits=recving_cregs, sending_circuit="sending_circuit_id")

Un bit recibido solo sirve si algo puede condicionarse a él, que es lo que proporcionan cif / endcif: un bloque controlado clásicamente que aplica las puertas encerradas cuando el bit de control vale 1.

recv bloquea. Es la misma semántica que MPI_Recv en el capítulo 7, con la misma consecuencia: una cadena de recepciones en la que cada una espera a la anterior serializa el cómputo, y un ciclo de ellas produce interbloqueo. El capítulo 20 muestra un caso en el que esto no es un error, sino la estructura real del algoritmo.

19.3 Comunicación cuántica: gen_ent

Los circuitos que vayan a comunicar información cuántica deben distinguir sus dos clases de qubit, y lo hacen pasando un par ordenado como num_qubits:

circuit_0 = CunqaCircuit(num_qubits=(3, 2), num_clbits=3, id="circuit_0_id")
circuit_1 = CunqaCircuit(num_qubits=(1, 1), num_clbits=1, id="circuit_1_id")

El entrelazamiento se genera después llamando ambos circuitos a gen_ent de forma consistente, cada uno nombrando al otro:

circuit_0.gen_ent(comm_qubit=1, circuits="circuit_1_id")

circuit_1.gen_ent(comm_qubit=0, circuits="circuit_0_id")

Dos circuitos dan un par de Bell. Una lista consistente de identificadores en el argumento circuits da un estado GHZ compartido entre todos sus qubits de comunicación. Esta es la directiva GEN_ENT del capítulo 17 vista desde la capa de aplicación, y es el bloque básico con el que puede montarse cualquier protocolo de comunicación cuántica.

19.4 Los dos protocolos que no hay que escribir

No hace falta construir los protocolos a partir de gen_ent. Los dos estándar vienen con la biblioteca.1

  • Teledata —teleportación cuántica— mueve el estado de un qubit de datos de un circuito a otro. Lo proporcionan qsend y qrecv.
  • Telegate —teleportación de puerta cuántica— comparte el estado de un qubit de control con un qubit de comunicación de un circuito remoto, de modo que una puerta local colocada en medio actúa como puerta controlada no local. Lo proporcionan cat_entangler y cat_disentangler.

En ambos casos la generación de entrelazamiento, las correcciones clásicas y la contabilidad de qubits de comunicación ocurren dentro. El programador escribe las fronteras del protocolo y la operación que va entre ellas.

19.5 Componer circuitos

Tres funciones libres construyen circuitos grandes a partir de pequeños, lo que importa más de lo que parece cuando los circuitos son la unidad que se distribuye:

  • add compone en profundidad: las instrucciones del primer operando seguidas de las del segundo.
  • union compone en anchura: los registros del primer operando con sus puertas, y a continuación los del segundo con las suyas.
  • hsplit invierte union: corta un circuito a lo largo del eje de registros en subcircuitos que actúan sobre bloques contiguos, dado un tamaño de partición o un conjunto explícito de puntos de corte.

hsplit es lo más parecido en la API al particionado automático de circuitos, y conviene ser preciso sobre lo que no es: corta donde se le diga. Decidir dónde cortar para minimizar puertas remotas es el problema abierto que el capítulo 15 dejaba fuera.24

19.6 Ejecución

Conectarse a la infraestructura levantada devuelve una lista de manejadores:

from cunqa.qpu import get_QPUs, run
from cunqa.qjob import gather

qpus = get_QPUs(co_located=True, family="qft_demo")

qjobs = run(circuits, qpus, shots=1000)
results = gather(qjobs)

for r in results:
    print(r.counts, r.time_taken)

Cuatro cosas de ese bloque merecen decirse explícitamente.

  • get_QPUs filtra, no crea. co_located decide si son visibles las vQPU de otros nodos; family selecciona por el nombre dado en el qraise. Ambos conceptos quedaron fijados en el capítulo 18.
  • run asigna circuitos a vQPU en el orden de la lista. Ese es todo el algoritmo de planificación. Es un marcador de posición deliberado: trivial, predecible, y deja sitio para un planificador de verdad por encima.
  • run es asíncrona. Despacha y devuelve un QJob por circuito. Los resultados llegan por QJob.result —un Result con counts y time_taken— o en bloque por gather.
  • upgrade_parameters actualiza in situ los valores de un circuito paramétrico. Para un algoritmo variacional que ejecuta el mismo ansatz mil veces con ángulos distintos, es la diferencia entre retransmitir el circuito y retransmitir los números.

19.7 Qué hace el middleware, y por qué es delgado

Entre el Python anterior y las vQPU en C++ hay un middleware cuyo trabajo es deliberadamente pequeño: convertir un CunqaCircuit en una representación intermedia JSON con un esquema fijo, y conectar al usuario con la vQPU a través de un único punto: un cliente enganchado al servidor de la vQPU.25

De ahí se siguen dos consecuencias, y ambas conviene conocerlas.

JSON se eligió por compatibilidad, no por eficiencia. Simuladores como AerSimulator ya consumen ese tipo de representación. Es también ineficiente en memoria comparado con cualquier cosa que evite literales de cadena, y por eso el capítulo 26 incluye una codificación binaria entre los puntos de la hoja de ruta.

Un único punto de contacto implica que la capa de Python es opcional. Quien quiera otra interfaz puede descartar el paquete cunqa por completo; el único requisito es enviar JSON con la forma correcta al servidor de la vQPU. Esa es la puerta por la que entra la parte V.

La compilación, mientras tanto, no es asunto de CUNQA: se soporta y se aprovecha la transpilación de Qiskit, y no se desarrolla maquinaria de optimización propia. El propósito del proyecto es la integración de DQC en HPC, no la compilación óptima de circuitos, y la simplicidad del middleware es la decisión de diseño que mantiene el esfuerzo apuntando a lo primero.

Parte IV · Capítulo 20

Un algoritmo, tres modelos

La manera más limpia de ver qué le hace cada modelo de comunicación a un programa es fijar el algoritmo y variar solo el modelo. La estimación de fase cuántica es la que usa la literatura de CUNQA justo por eso: emplear un único algoritmo aísla las diferencias que impone el modelo de las que habría impuesto el algoritmo de todos modos.

20.1 El algoritmo, en breve

La QPE, introducida por Kitaev en 1995,30 estima la fase φ de un autovalor de un operador unitario U: dados U y uno de sus autovectores |ψ⟩ con U|ψ⟩ = e^(2πiφ)|ψ⟩, devuelve

φ ≃ ξ / 2ⁿ, con error 1 / 2ⁿ

donde n es el número de qubits ancilla y ξ la lectura decimal de la cadena de salida más frecuente del registro de ancillas. El circuito tiene dos registros: las n ancillas que guardan la fase, y el registro que contiene |ψ⟩ al que se aplican las potencias controladas de U, seguido de una QFT inversa sobre las ancillas.

La demostración toma U = R_z y |ψ⟩ = |1⟩, por dos razones prácticas: los autovectores de R_z son triviales de preparar —y la preparación del autoestado es uno de los cuellos de botella reales de la QPE— y con |1⟩ la respuesta se conoce de antemano por θ = 2πφ, de modo que la corrección es comprobable y no meramente plausible.

20.2 Sin comunicación: repartir los shots

Más precisión significa más ancillas, más resultados posibles y, por tanto, más shots. Nada del circuito necesita distribuirse; el muestreo sí. Este es el caso embarrassingly parallel, y el código lo enseña: el circuito se construye exactamente como se construiría en una sola máquina, y luego se replica.

# Definición del circuito QPE
qpe = CunqaCircuit(num_qubits + 1, num_qubits)
qpe.x(num_qubits)                       # autoestado |psi> = |1>

for i in range(num_qubits):
    qpe.h(i)
    for _ in range(2**i):
        qpe.crz(phase, i, num_qubits)   # U^(2^i) controlada

qpe.IQFT(0, num_qubits - 1)
qpe.measure_all()

# Obtener las vQPU disponibles y repartir los shots
qpus = get_QPUs()
shots_per_qpu = [shots // len(qpus) for _ in range(len(qpus))]

qjobs = run([qpe]*len(qpus), qpus, shots=shots_per_qpu)
results = gather(qjobs)

Lo único distribuido de ese programa son las tres últimas líneas. Ese es el asunto: el modelo sin comunicación no le pide nada al algoritmo.

20.3 Comunicación clásica: el IPEA

El algoritmo iterativo de estimación de fase29 ataca el coste en qubits en lugar del coste en shots: extrae la expansión binaria de la fase bit a bit, usando una sola ancilla por circuito.

La derivación merece hacerse en una diapositiva porque convierte un algoritmo desconocido en uno conocido. Lo último que actúa sobre las ancillas antes de la medida es la QFT inversa: una escalera de Hadamards y rotaciones controladas. Por el principio de medida diferida, medir antes de esas rotaciones controladas es equivalente, y las convierte en puertas controladas clásicamente. Y unas puertas controladas clásicamente cuyos controles vienen de medidas anteriores son exactamente un punto de partición: cada rebanada pasa a ser un circuito independiente que necesita un bit clásico de cada uno de sus predecesores.

qpus_QPE = get_QPUs()
num_qpus = len(qpus_QPE)
circuits = []

for i in range(num_qpus):
    theta = 2 * pi * 2**(num_qpus - i - 1) * phase

    circuits.append(CunqaCircuit(num_qubits=2, num_clbits=2, id=f"circuit_{i}"))
    circuits[i].h(0)
    circuits[i].x(1)
    circuits[i].crz(theta, 0, 1)          # la potencia de U de esta rebanada

    # Recepción de bits de los circuitos anteriores
    for j in range(i):
        circuits[i].recv(clbits=0, sending_circuit=f"circuit_{i - j - 1}")
        circuits[i].cif(clbits=0)
        circuits[i].rz(param=-pi * 2**(-j - 1), qubits=0)
        circuits[i].endcif()

    circuits[i].h(0)

    # Envío de bits a los circuitos posteriores
    circuits[i].measure(0, 0)
    for k in range(num_qpus - i - 1):
        circuits[i].send(clbits=0, recving_circuit=f"circuit_{i + k + 1}")

    circuits[i].measure(1, 1)

qjobs = run(circuits, qpus_QPE)
results = gather(qjobs)

El bucle interno es todo el algoritmo. recv bloquea hasta que el subcircuito i − j − 1 ha medido; cif/endcif aplican la rotación de corrección R_z(−π · 2^−(j+1)) solo cuando el bit recibido vale 1; y el efecto acumulado de todas esas rotaciones condicionadas reproduce la QFT inversa bit a bit, sin ancillas adicionales. Después se mide la ancilla y se difunde a todos los subcircuitos posteriores que la vayan a necesitar.

La partición es legítima por una razón que merece decirse: en el registro del autovector, cada puerta controlada deja el registro en el autoestado, de modo que las rebanadas son genuinamente independientes entre sí salvo por los bits clásicos.

20.4 Comunicación cuántica: partir por registros

La QPE tiene dos registros, así que la partición obvia para comunicación cuántica es un registro por vQPU. Hacerlo convierte cada U controlada en una puerta controlada no local, que es justo para lo que sirve el telegate. El ejemplo usa cat_entangler / cat_disentangler en vez de gen_ent en crudo, lo que hace legible la estructura.

ancilla_circuit  = CunqaCircuit((N_ANCILLA_QUBITS, 1), N_ANCILLA_QUBITS, id="ancilla_circuit")
register_circuit = CunqaCircuit((N_REGISTER_QUBITS, 1), 1, id="register_circuit")

data_qubits_anc, comm_qubits_anc = ancilla_circuit.get_qubits()
data_qubits_reg, comm_qubits_reg = register_circuit.get_qubits()

register_circuit.x(data_qubits_reg[0])          # autoestado |1>
for i in range(N_ANCILLA_QUBITS):
    ancilla_circuit.h(data_qubits_anc[i])

for i in range(N_ANCILLA_QUBITS):
    cat_entangler(
        target_circuits = [ancilla_circuit, register_circuit],
        data_qubit      = data_qubits_anc[N_ANCILLA_QUBITS - 1 - i],
        comm_qubits     = [comm_qubits_anc[0], comm_qubits_reg[0]],
        clbits          = [0, 0],
        tag             = "telegate"
    )

    param = (2**i) * 2 * 2 * pi * PHASE_TO_COMPUTE
    register_circuit.crz(param, comm_qubits_reg[0], data_qubits_reg[0])

    cat_disentangler(
        target_circuits = [ancilla_circuit, register_circuit],
        data_qubit      = data_qubits_anc[N_ANCILLA_QUBITS - 1 - i],
        comm_qubits     = [comm_qubits_reg[0]],
        recv_clbits     = [0],
        send_clbits     = [0]
    )

ancilla_circuit.IQFT(0, N_ANCILLA_QUBITS)
ancilla_circuit.measure_all()

qjobs = run([ancilla_circuit, register_circuit], get_QPUs())
results = gather(qjobs)

El patrón de tres pasos del bucle es lo que hay que retener:

  • cat_entangler comparte el estado de un qubit ancilla con register_circuit a través de los qubits de comunicación reservados, sin destruirlo. Si la ancilla está en α|0⟩ + β|1⟩, el estado conjunto de esa ancilla y del qubit de comunicación remoto pasa a ser α|00⟩ + β|11⟩ con α y β intactos; usar el qubit de comunicación como control equivale, por tanto, a usar la ancilla como control.
  • La crz local es después una puerta local ordinaria dentro de register_circuit. Ahí ha ido a parar la no localidad: no ha desaparecido, se ha pagado por adelantado.
  • cat_disentangler elimina el entrelazamiento residual y deja la ancilla en α′|0⟩ + β′|1⟩ y el qubit de comunicación de vuelta en |0⟩, libre para la siguiente iteración.

Los tres juntos realizan una puerta controlada no local habiendo intercambiado solo un par entrelazado temporal y unos bits clásicos, nunca el estado de la ancilla.

20.5 Leer los números con honestidad

Las tres variantes se ejecutaron para estimar φ = 1/π en el clúster QMIO del CESGA, con 2 núcleos y 30 GB por vQPU, todas co-localizadas, y cada caso repetido 100 veces.1

Modelo vQPU Shots por vQPU Fase estimada Tiempo medio (s)
Sin comunicación 1 10⁸ 0,3183135986328125 123,602
Sin comunicación 128 781 250 0,3183135986328125 1,267
Comunicación clásica 16 10⁸ 0,3183135986328125 4959,346
Comunicación cuántica 2 10⁴ 0,3183135986328125 5124,625

Dos lecturas, y no deben mezclarse.

Corrección. Todos los modelos devuelven la misma estimación, 0,3183135986328125 ± 0,000015, frente al valor real 1/π = 0,31830988…. La incertidumbre es 2⁻¹⁶, exactamente la resolución de la QPE con n = 16 ancillas, y la estimación concuerda holgadamente dentro de ella. La plataforma emula los tres modelos y da la respuesta correcta en los tres. Eso es lo que la tabla sostiene.

Coste. Los tiempos miden el reloj de pared clásico invertido en emular y simular la infraestructura. No son predicciones del tiempo de ejecución de un sistema DQC físico —los canales son ideales y no llevan ningún modelo temporal— y no son un benchmark, porque medir aquí sería sobre todo medir a AerSimulator. Lo que sí muestran es cómo cada modelo moldea la simulación:

  • Sin comunicación escala. 128 vQPU corren unas 100 veces más rápido que una, cerca de la línea de aceleración ideal, porque no hay nada que coordinar. La razón para parar en 128 no es que la curva se aplane, sino la factura: 256 núcleos y 3,84 TB.
  • La comunicación clásica serializa. Los dieciséis subcircuitos podrían solaparse, pero cada subcircuito i debe recibir un bit de cada uno de sus i predecesores, y recv bloquea. La estructura de dependencias del IPEA es una cadena, así que la partición no compra nada y el tráfico de comunicación cuesta bastante: 40 veces más lento que la línea base monolítica con el mismo número de shots.
  • La comunicación cuántica es monolítica y cara. El ejecutor centralizado toma el mando, el estado conjunto es uno solo y el protocolo telegate inserta muchas puertas adicionales. Cuatro órdenes de magnitud menos de shots para un tiempo de pared comparable: un coste por shot del orden de 4 × 10⁵ veces mayor.
Parte IV · Capítulo 21

Ejercicios con CUNQA

Dos ejercicios, y son el mismo programa dos veces. El primero escribe a mano lo que el cuaderno de NetQMPI obtuvo con una sola llamada; el segundo se lo devuelve a NetQMPI y pone los dos ficheros uno al lado del otro. Lo que los separa no es la capacidad: es cuántas decisiones son tuyas, y con qué silencio fallan las equivocadas.

21.1 Una familia para toda la tarde

Los dos ejercicios de este capítulo y los dos del capítulo 25 se ejecutan contra una única familia levantada. Ese es el sentido del flujo en dos pasos del capítulo 18: levantar una vez, engancharse muchas y no pagar coste de planificador por ejecución.

from cunqa.qpu import get_QPUs, qraise

FAMILY, SIZE = "netqmpi_notebook", 3

qpus = get_QPUs(co_located=True, family=FAMILY) or []
if len(qpus) < SIZE:
    qraise(SIZE, "02:00:00",
           simulator="Munich",
           co_located=True,
           quantum_comm=True,               # sin esto no hay gen_ent
           backend="notebook_apps/notebook_vqpu.json",
           family=FAMILY)
    qpus = get_QPUs(co_located=True, family=FAMILY) or []

La definición de la vQPU es el número que decide si la tarde termina. num_qubits es el par [datos, comunicación], y el ejecutor simula toda la familia en un único registro que abarca todos los qubits que cada vQPU declara, se usen o no.

{
    "name": "netqmpi_notebook",
    "num_qubits": [2, 2]
}

Dos qubits de datos porque el rank 0 del ejercicio 9 sostiene un qubit de conteo y el autoestado, y una familia se levanta a partir de una única definición, así que los demás ranks cargan con el segundo qubit sin usarlo. Dos qubits de comunicación porque la QFT inversa del ejercicio 8 mantiene dos ventanas de expose abiertas a la vez, y una ventana abierta cuesta un qubit de comunicación en cada rank que esté dentro. Cuatro qubits por tres vQPU son un registro de doce qubits: 4096 amplitudes, 64 KiB. Eso se lee en la definición, nunca en tu circuito: [4, 4] en tres vQPU son 256 MiB, y [8, 8] en dos son 64 GiB.

NetQMPI la deriva Tú la eliges
Identificador del circuito f"rank_{rank}" Los nombras tú, y los nombres son las direcciones
Qubits de comunicación Tomados de un fondo común por bloque de protocolo Declarados por adelantado en el par (datos, comunicación)
Bits clásicos del protocolo Su propio registro netqmpi_protocol Los reservas tú, aparte de tus propios bits
Emparejar las dos mitades Una etiqueta construida con los ranks y un contador La misma cadena en ambos lados, o la ejecución se cuelga
CunqaCircuit((num_datos, num_comunicacion), num_clbits, id="...")

circuit.add_cl_register("nombre", n)   # devuelve el nombre que ha usado
circuit.classical_regs["nombre"]       # los bits de ese registro
circuit.comm_qubits                    # los índices reservados para comunicación

qsend(circuit, qubit_datos, qubit_comm, clbits, recving_circuit="<id>", tag="...")
qrecv(circuit, qubit_datos, qubit_comm, clbits, control_circuit="<id>", tag="...")

Ambas llamadas necesitan un qubit de comunicación y dos bits clásicos, y la etiqueta tiene que coincidir carácter a carácter en los dos lados.

Dos detalles operativos que la API no anuncia y en los que se pierde tiempo.

  • En un circuito (1, 1), comm_qubits es [1]. Los qubits de comunicación se numeran después de los de datos, y add_cl_register devuelve el nombre que ha usado, así que el registro buscado por ese nombre entra directo en la llamada.
  • La vQPU sobrante necesita un circuito. La familia tiene tres vQPU y este programa usa dos. CUNQA ejecuta un ejecutor por familia y no arranca una ronda hasta que todas las vQPU han enviado algo, así que la que está ociosa no se salta la ronda: la atasca. Hay que darle un circuito de usar y tirar.
spare = CunqaCircuit((1, 0), 1, id="spare")
spare.measure(0, 0)

results = gather(run(circuits + [spare], qpus, shots=1024))

for result in results:
    if result.id != "spare":
        print(f"{result.id}: {result.counts}")

Hay que leer las cuentas antes de seguir. rank_1 se reparte más o menos 50/50, que es el aspecto de |+>, y también exactamente el aspecto de un canal roto que devuelve ruido. Cambiar el h(0) del emisor por un x(0) y volver a ejecutar: el rank 1 tiene que dar 1 en prácticamente todas las tiradas. Esa es la prueba que de verdad distingue los dos casos. rank_0 no aporta nada en ninguno de los dos, porque la teleportación mueve el estado: al terminar, su qubit de datos ha vuelto a |0> y sus únicas medidas son las del propio protocolo.

$ netqmpi -n 2 notebook_apps/ex7_send_recv.py --cunqa --shots 1024

Con exactamente una familia levantada, eso es todo lo que necesita el adaptador: se engancha a lo que esté corriendo y después deja la reserva en paz. Nótese además que dos ranks se han ejecutado sobre una familia de tres vQPU y nada se ha atascado: el adaptador le dio a la vQPU sobrante un circuito de usar y tirar, lo mismo que en el ejercicio 6 había que saber hacer a mano. Una familia sobredimensionada es un desperdicio, nunca un error.

Unas treinta líneas contra seis, y la diferencia son exactamente las cuatro filas de la tabla de arriba. Ninguno de esos valores tiene una versión correcta que puedas consultar; solo tienen que coincidir entre las dos mitades, y nada comprueba que lo hagan. Esa es la clase de error que NetQMPI elimina: no uno difícil, uno silencioso.

Cuatro preguntas para responder por escrito antes de que empiece la parte V:

  • ¿A quién se direcciona? En NetQMPI se envía a un rank; en CUNQA se nombra un identificador de circuito. ¿Cuál de los dos es el communicator, y dónde vive en cada modelo?
  • ¿Cuándo aparece el paralelismo? NetQMPI lanza N copias de un fichero, al estilo SPMD. CUNQA construye N objetos circuito en un fichero y los entrega a N vQPU. Ambos acaban con N cosas ejecutándose, pero solo uno de los dos es SPMD.
  • ¿Quién reserva los recursos? En NetQMPI lo hace el lanzador como parte de arrancar la aplicación. En CUNQA ocurrió antes de que el programa existiera, en una orden aparte, y le sobrevive.
  • ¿Cuál es la unidad de trabajo? Un rank que ejecuta un programa, o un circuito que se ejecuta en un dispositivo. Es la más profunda de las cuatro diferencias y la que la parte V tiene que reconciliar.
Parte V · Capítulo 22

Dos pilas, un punto de contacto

El capítulo 11 dejó una pregunta abierta y la marcó como algo que resolver antes de impartir: el título del tutorial promete «NetQMPI sobre CUNQA», y los dos proyectos se publicaron por separado, cada uno con su pila. Este capítulo la responde. La versión corta es que la integración es un adaptador de backend, y que funciona porque ambos lados dejaron la costura a la altura correcta.

22.1 Qué es realmente cada lado

Merece la pena repetir las dos definiciones una junto a la otra, porque casi toda la confusión sobre la integración viene de suponer que ambas herramientas ocupan el mismo nivel.

NetQMPI CUNQA
Qué es Un modelo de programación: el SPMD, el rank y el communicator de MPI trasladados al dominio cuántico.2 Un emulador de infraestructuras: vQPU desplegadas en un supercomputador a través del planificador.1
Nivel en la pila del capítulo 11 Middleware, sobre el SDK de NetQASM. Capa de sistema más su propia capa de aplicación.
Qué esconde Sockets, pares EPR, correcciones, identidades de nodo. Simuladores, procesos, sockets, el trabajo de SLURM.
Qué insiste en que veas Los ranks y el communicator. La infraestructura: se levanta, se paga, se libera.
Unidad de trabajo Un rank que ejecuta un programa. Un circuito ejecutado en un dispositivo.

No son competidores, y ninguno es subconjunto del otro. NetQMPI necesita algo debajo capaz de sostener estado cuántico, producir entrelazamiento entre nodos y transportar bits clásicos. CUNQA es una de esas cosas, y resulta ser la única que corre dentro de un entorno HPC real con los tres modelos de comunicación.22

22.2 La costura del lado de CUNQA

El capítulo 19 terminaba con la frase que importa aquí: el middleware conecta con el nivel inferior a través de un único punto —un cliente enganchado al servidor de la vQPU— y quien quiera otra interfaz puede descartar el paquete Python cunqa por completo; el único requisito es enviar JSON con la forma correcta a las vQPU.1

Eso no es un accidente de implementación: es la razón por la que el middleware se mantuvo delgado a propósito. Un emulador cuya API de Python estuviese soldada a su capa de ejecución habría que envolverlo. Uno cuyo punto de contacto es un esquema JSON documentado sobre un socket puede tomarse como destino.

22.3 La costura del lado de NetQMPI

NetQMPI se ha movido en la misma dirección. La versión publicada de la biblioteca se describe como middleware sobre el SDK de NetQASM con SquidASM y SimulaQron como backends de ejecución;2 la interfaz se ha reorganizado desde entonces en torno a un Environment explícito que posee tanto el communicator como la construcción de circuitos, de modo que el mismo programa de usuario corre contra el backend que seleccione el lanzador.

from netqmpi.sdk.environment import Environment

def main(env: Environment = None):
    comm = env.comm
    rank = comm.rank

    next_rank     = comm.get_next_rank(rank)
    previous_rank = comm.get_prev_rank(rank)

    with comm:                                    # todo lo de dentro corre en el backend
        if rank == 0:
            circuit = env.create_circuit(num_qubits=1, num_clbits=1)
            circuit.h(0)                          # preparar |+>
            comm.qsend(circuit, [0], next_rank)   # teleportar el qubit
        else:
            circuit = env.create_circuit(num_qubits=1, num_clbits=1)
            comm.qrecv(circuit, [0], previous_rank)
            circuit.measure(0, 0)

    results = comm.results
    if rank != 0:
        print(f"measure: {results}")

Tres cosas de ese fragmento son la integración, y es fácil pasarlas por alto en una primera lectura.

  • env.create_circuit(...) en lugar de Qubit(connection). El usuario ya no instancia qubits contra una conexión viva: construye un objeto circuito que le proporciona el entorno. Qué clase sea depende del backend, y sobre CUNQA es un CunqaCircuit.
  • with comm: como ámbito de ejecución. El bloque delimita lo que se despacha. Bajo un backend NetQASM se traduce en vaciados; bajo CUNQA, en ensamblar los circuitos y llamar a run.
  • comm.results recoge después, que es exactamente el gather del capítulo 19 con sombrero de MPI.
Dónde se encuentran NetQMPI y CUNQA aplicación de usuario un fichero · SPMD · igual en todos los backends NetQMPI Environment · comm · rank / size · qsend / qrecv qscatter / qgather · expose / unexpose todo lo de arriba es igual para cualquier backend adaptador de backend rank → vQPU de get_QPUs() create_circuit → CunqaCircuit + id qsend / qrecv → teledata expose → gen_ent + cat_entangler cierre de ámbito → run() resultados → gather() JSON sobre un socket CUNQA · la infraestructura levantada vQPU · rank 0 vQPU · rank 1 vQPU · rank 2 levantada de antemano con qraise · el único punto de contacto es un esquema JSON documentado

El punto de contacto. NetQMPI conserva todo el modelo de programación —un fichero, SPMD, ranks, qsend/qrecv, colectivas— y delega dos cosas en el adaptador de backend: qué es un objeto circuito y qué ocurre cuando se cierra el ámbito de ejecución. El adaptador asigna ranks a las vQPU levantadas, traduce las primitivas a directivas de CUNQA y devuelve las cuentas. Todo lo que está por encima de la línea discontinua no cambia entre el backend de SquidASM y el de CUNQA; todo lo que está por debajo son los capítulos 17 a 19.

22.4 Por qué esto compone en lugar de chocar

Que las dos abstracciones estén a alturas distintas es lo que hace limpia la composición, y se nota en tres sitios:

  • Ninguno posee la gestión de recursos de la misma manera. El lanzador de NetQMPI arranca N ranks; el qraise de CUNQA reserva N vQPU. Son el mismo acto en dos vocabularios, y el capítulo 24 enseña cómo se alinean las dos órdenes.
  • Ambos son ya agnósticos de backend en la dirección correcta. NetQMPI abstrae sobre lo que ejecuta; CUNQA abstrae sobre lo que lo programa. Se encuentran a mitad de camino y ninguno tiene que renunciar a su modelo.
  • El circuito es el objeto natural de intercambio. NetQMPI necesita dónde acumular puertas antes de despachar; la representación intermedia de CUNQA es un circuito en JSON. El desajuste de impedancias que podría haber existido —un modelo de instrucciones en flujo de un lado y uno de circuito completo del otro— no existe, porque hoy ambos son de circuito completo.
Parte V · Capítulo 23

El diccionario

Identificado el punto de contacto, el adaptador de backend es una tabla de traducción. La mayoría de entradas son uno a uno; las interesantes son aquellas en las que la traducción no es literal, porque ahí es donde los dos modelos discrepan de verdad sobre el mundo.

23.1 Estructura: rank, size, communicator

NetQMPI CUNQA Notas
rank posición en la lista que devuelve get_QPUs() run asigna circuitos a vQPU por orden de lista (capítulo 19), así que el orden es la asignación de ranks. Trivial, determinista, y el sitio al que acabaría yendo un planificador de verdad.
size len(get_QPUs(...)) Por eso tiene que coincidir con el -n dado a qraise. Véase el capítulo 24.
COMM_WORLD una familia El nombre de --family en el levantamiento es lo más parecido a un communicator que tiene CUNQA: un grupo homogéneo, nombrado y filtrable. Los subcommunicators se corresponderían con varias familias.
env.create_circuit(...) CunqaCircuit(...) Con una diferencia que importa: los circuitos de CUNQA llevan un id, y el adaptador tiene que generar uno por rank y mantener el mapa rank → id.
cierre de with comm: run(circuits, qpus, ...) El ámbito de ejecución se convierte en la llamada de despacho.
comm.results gather(qjobs) La misma operación con otro nombre.

El mapa rank → id es lo más importante que mantiene el adaptador, y la razón está en el capítulo 19: NetQMPI direcciona ranks y CUNQA direcciona identificadores de circuito. Todas las primitivas de abajo son, en el fondo, esa traducción aplicada una vez.

23.2 Punto a punto

comm.qsend(circuit, [q], dest)   →   qsend  (teledata) desde el circuito de este
                                     rank al circuito registrado para `dest`

comm.qrecv(circuit, [q], src)    →   qrecv  (teledata) declarado en el circuito de
                                     este rank, nombrando al circuito de `src`

Es la entrada más limpia de toda la tabla, porque ambas bibliotecas implementan el mismo protocolo e incluso usan los mismos dos verbos. Los qsend/qrecv de NetQMPI encapsulan la teleportación;2 los qsend/qrecv de CUNQA son teledata construido sobre gen_ent.1 El adaptador tiene que traducir nombres y destinos, no semántica.

El par clásico es igual de directo: un envío y una recepción clásicos se convierten en send/recv de CUNQA, y cualquier condicional sobre un bit recibido se convierte en un bloque cif/endcif.

23.3 Colectivas

NetQMPI CUNQA Notas
qscatter / qgather un bucle de qsend / qrecv Ambas bibliotecas ya las implementan como bucles punto a punto (capítulo 13). La traducción es literal y hereda la misma advertencia honesta: no son colectivas optimizadas con árboles.
expose / unexpose gen_ent sobre N circuitos, y después cat_entangler / cat_disentangler La entrada interesante. Véase más abajo.
flush() — Sin contrapartida directa. Véase 23.4.
Bcast — No existe en ninguno de los dos lados, y por la misma razón física.

expose en términos de CUNQA. El capítulo 13 definió expose como la transformación de un estado raíz α|0⟩ + β|1⟩ en un único estado global repartido entre todos los ranks participantes, implementada entrelazando el qubit del root con un estado GHZ precompartido, seguido de medidas y correcciones. Cada uno de esos ingredientes es una directiva de CUNQA:

  • el estado GHZ precompartido es gen_ent llamado de forma consistente con una lista de identificadores de circuito —el capítulo 19 lo decía explícitamente: dos circuitos dan un par de Bell, N circuitos dan un GHZ sobre sus qubits de comunicación—;
  • entrelazar el qubit de datos del root con ese estado, más las medidas y correcciones clásicas, es cat_entangler generalizado de dos circuitos a N;
  • unexpose es cat_disentangler, y la razón por la que NetQMPI lo hace obligatorio es la que dio el capítulo 17 para separar qubits de comunicación de qubits de datos: el recurso es finito, y pedir más qubits de comunicación de los que hay detiene la ejecución hasta que se liberen algunos. Saltarse el unexpose no solo deja el communicator inconsistente: sobre este backend consume un qubit de comunicación que el siguiente expose se va a quedar esperando.

Esa última frase es el mejor argumento del tutorial sobre por qué los dos proyectos van juntos: la primitiva más abstracta de NetQMPI adquiere un coste operativo concreto en cuanto corre sobre un emulador que modela recursos. En un simulador de red, olvidar el unexpose es un indicio de incorrección. En CUNQA es un cuelgue.

23.4 Lo que no traduce limpiamente

Tres entradas en las que el diccionario necesita una nota al pie en lugar de una palabra.

flush(). En NetQMPI, flush sincroniza el flujo de instrucciones cuánticas: empuja al backend las instrucciones NetQASM acumuladas. CUNQA no tiene flujo de instrucciones que empujar: un circuito se envía entero, como JSON, y el bucle de shots corre dentro de la vQPU o dentro del ejecutor centralizado. Sobre este backend, flush es por tanto o bien una operación vacía o bien una frontera de ámbito que dispara el despacho, y la advertencia del capítulo 13 se aplica con más fuerza: nunca fue una barrera de procesos, y aquí ni siquiera es un vaciado. Es la diferencia estructural más aguda entre los dos modelos, y el capítulo 26 explica por qué se espera que mengüe.

Semántica de bloqueo. El qrecv de NetQMPI bloquea el rank; el recv de CUNQA bloquea dentro de un bucle de shots que controla CUNQA. El comportamiento observable se parece lo bastante como para que los programas sean correctos, pero los modos de fallo difieren: un interbloqueo al estilo MPI detiene N procesos, mientras que un interbloqueo en CUNQA detiene un bucle de shots hasta que expire el tiempo de pared del qraise. El diagnóstico también es distinto, y peor, que es exactamente por lo que el ejercicio 6b pedía verlo una vez a propósito.

Ruido. Los backends publicados de NetQMPI son simuladores de red cuya aportación central es el ruido de capa física.7 CUNQA no modela ningún ruido de comunicación y solo ruido de dispositivo parcial (capítulos 16 y 18). Un programa que corra idéntico en ambos backends no producirá fidelidades comparables, y leer una ejecución de CUNQA como si fuese una de SquidASM es la interpretación errónea más probable de esta segunda mitad del tutorial.

23.5 La tabla que hay que llevarse

Concepto MPI NetQMPI CUNQA
Unidad proceso rank vQPU
Grupo communicator communicator familia
Lanzamiento mpirun -n N netqmpi -n N qraise -n N -t T
Punto a punto Send / Recv qsend / qrecv qsend / qrecv · send / recv
Repartir Scatter / Gather qscatter / qgather bucles de lo anterior
Replicar Bcast — —
Repartir un control — expose / unexpose gen_ent · cat_entangler / cat_disentangler
Entrelazar — implícito en las primitivas gen_ent, explícito y atómico
Sincronizar Barrier flush() ámbito del bucle de shots
Parte V · Capítulo 24

Lanzarlo

El diccionario del capítulo 23 cubre lo que dice el programa. Este capítulo cubre lo que se teclea, que es donde los dos modelos se diferencian de forma más visible: NetQMPI espera una orden y CUNQA espera dos, y la razón es la decisión de pila del capítulo 16.

24.1 Dos órdenes, no una

Una aplicación NetQMPI sobre sus backends publicados se lanza como se lanza una aplicación MPI:

$ netqmpi -n 3 app.py

Sobre CUNQA la infraestructura no nace cuando arranca el programa: se levantó antes y le sobrevive (capítulo 18). Así que la secuencia es:

$ qraise -n 3 -t 00:30:00 --quantum_comm --co-located --family qce26
$ qinfo
$ netqmpi -n 3 app.py --cunqa --shots 1024
$ qdrop --family qce26

Cuatro observaciones que merecen una diapositiva propia.

  • -n aparece dos veces y tienen que coincidir. qraise -n 3 reserva tres vQPU; netqmpi -n 3 arranca tres ranks. Si no coinciden, o hay vQPU ociosas ya pagadas o hay ranks sin dónde ejecutar. El capítulo 23 explicó por qué: size es len(get_QPUs(...)).
  • El modelo DQC se elige al levantar, no al ejecutar. --quantum_comm es una propiedad de la infraestructura. Un programa que llame a expose contra una infraestructura levantada sin ella falla, y falla en la vQPU y no en tu código.
  • --shots pertenece a la ejecución, no al levantamiento. Es un argumento de ejecución que se reenvía a run (capítulo 19): el único número de la línea de órdenes que habla del algoritmo y no de la máquina.
  • qdrop no es opcional. Las vQPU viven hasta que expire el tiempo de pared, las use alguien o no. Es la pieza del flujo con un coste real asociado, y por la que un público de usuarios de HPC te va a juzgar.

24.2 Dimensionar la petición

Las opciones del capítulo 18 son donde una demostración vive o muere, y la regla de dimensionamiento depende por completo del modelo, por lo que decía el capítulo 17:

Modelo levantado Qué son las vQPU Cómo dimensionar
Sin comunicación N simulaciones independientes La memoria por vQPU escala con los qubits de un solo circuito. Añadir vQPU añade rendimiento a coste lineal.
--classical_comm N simulaciones independientes más una capa de mensajes Mismo dimensionamiento por vQPU. Lo que crece es el tiempo, no la memoria, y crece con la cadena de dependencias, no con N.
--quantum_comm un estado conjunto detrás de N intermediarias La memoria por vQPU no es el modelo mental correcto: el ejecutor centralizado sostiene un único estado cuya dimensión la fija el número total de qubits de todas las vQPU implicadas.

Esa última fila es la que hay que decir en voz alta. En el modelo de comunicación cuántica, pasar de dos vQPU de 10 qubits a cuatro vQPU de 10 qubits no duplica la memoria: eleva dos veces al cuadrado la dimensión del vector de estado. Una sala llena de gente levantando cada una cuatro vQPU con --quantum_comm sobre una asignación compartida es una manera previsible de perder la segunda mitad de la sesión.

24.3 Cuando no funciona

Los modos de fallo son pocos y todos identificables desde fuera. Esta es la diapositiva de diagnóstico que conviene llevar preparada en lugar de improvisar.

Síntoma Causa más probable Comprobación
El programa no encuentra QPU Nada levantado, tiempo de pared expirado, o desajuste de --co-located qinfo. Si la familia aparece pero es invisible, estás en un nodo distinto del de las vQPU y se levantaron en modo on-node.
Menos ranks de los esperados Desacuerdo del -n entre qraise y netqmpi Comparar las dos líneas de órdenes antes de leer código.
Un expose se cuelga Qubits de comunicación agotados: falta un unexpose Capítulo 23. La detención es por diseño: la petición espera a que se libere un recurso.
El programa se cuelga sin error Un ciclo de recv bloqueantes, o dos mitades de una transferencia que no se nombran igual Capítulo 7, ejercicio 6b. Nada lo va a diagnosticar; lo termina el tiempo de pared.
Las opciones de ruido parecen no hacer nada Ruido pedido fuera de sus condiciones soportadas Capítulos 16 y 18: sin comunicación, sin CIF, AerSimulator.
Funciona, pero absurdamente lento --quantum_comm con más qubits de los previstos La cuarta fila del capítulo 20 es el comportamiento esperado, no un error.
Parte V · Capítulo 25

Caso de estudio: una QFT distribuida

La transformada de Fourier cuántica repartida entre tres QPU es el ejercicio hacia el que apunta todo el día. Es un buen caso final por una razón que nada tiene que ver con su fama: a diferencia del estado GHZ del capítulo 14, sus puertas remotas no son todas iguales, y las que menos importan son exactamente las que uno querría cortar. La recompensa llega al final del capítulo: la transformada escrita en el ejercicio 8 se reutiliza, literalmente, como subrutina del ejercicio 9.

25.1 Por qué la QFT particiona mal, y qué enseña eso

La QFT sobre n qubits es una escalera: un Hadamard en cada qubit, seguido de rotaciones de fase controladas entre ese qubit y todos los de debajo, con el ángulo de rotación dividiéndose por dos en cada paso. De ahí se siguen inmediatamente dos propiedades, y ambas importan para distribuir.

  • Es casi toda puertas de dos qubits, y son todos con todos. Cada qubit interactúa con todos los demás. Cualquier partición en bloques corta un número de puertas que crece con el producto de los tamaños de bloque, así que el coste de comunicación de una QFT distribuida es cuadrático en el corte, no lineal.
  • Las puertas que cruzan el corte son las más débiles. El ángulo de rotación entre los qubits j y k decae como 2^−|j−k|, de modo que las puertas entre qubits lejanos —justo las que con más probabilidad cruzan una frontera de partición— son las que menos fase aportan. Esa es la base de la QFT aproximada, y significa que la QFT distribuida es uno de los pocos casos en los que una aproximación con fundamento reduce drásticamente el número de operaciones remotas.

Ese segundo punto merece una diapositiva, porque es la lección general que carga el ejercicio concreto: el particionado de circuitos no es solo un problema de grafos, es un problema algorítmico. El capítulo 15 listaba el particionado como línea de investigación abierta;24 la QFT es el caso en el que un físico le gana al particionador de grafos por saber qué significan las puertas.

25.2 Telegates, y por qué una QFT los quiere

Teleportar un control al otro lado del corte y traerlo de vuelta cuesta dos transferencias en cada sentido y, peor aún, arrastra consigo aquello con lo que el qubit ya estuviera entrelazado. Así que la QFT no quiere mover qubits. Quiere prestarlos: el control se queda donde está y se pone a disposición de los demás mediante un estado GHZ compartido. Eso es un telegate, y es lo que hacen expose / unexpose (capítulo 23).

Tres propiedades de esa pareja sostienen todo el ejercicio.

  • Son colectivas, como MPI_Bcast. Todos los ranks de la ventana las llaman, en el mismo orden, y por eso las llamadas van fuera de las ramas if rank ==. Los ranks que quedan fuera de la ventana reciben None y no consumen nada.
  • expose devuelve el índice que hay que usar como control —el propio qubit en el root, un qubit de comunicación recién reservado en cada receptor—, de modo que la puerta no local se escribe exactamente igual que una local.
  • Las ventanas anidan como ámbitos. Puede haber dos abiertas a la vez, y la interior tiene que cerrarse primero. Eso no es una norma de estilo: es la razón por la que la vQPU del capítulo 21 se levantó con dos qubits de comunicación y no con uno.

25.3 La forma del programa

Tres ranks, un qubit de datos cada uno, y la transformada inversa en lugar de la directa:

H(q2) · CP(q2→q1, −π/2) · H(q1) · CP(q2→q0, −π/4) · CP(q1→q0, −π/2) · H(q0)

Invertir el orden es lo que convierte esto en un ejercicio y no en una transcripción, y obliga a dos cosas que la transformada directa no pide.

  • El Hadamard de q2 va primero, antes de que se lo preste a nadie: el espejo de la transformada directa, donde iba el último.
  • q1 es receptor y después prestamista, así que su ventana se abre dentro de la de q2 y por tanto tiene que cerrarse antes. El rank 0 queda dentro de las dos a la vez, y ahí es donde se va el segundo qubit de comunicación del capítulo 21.

Lo que hay que señalar es el emparejamiento: cada expose tiene su unexpose, la interior primero, con las puertas no locales entre medias. El capítulo 23 explicó por qué ese emparejamiento es más estricto en este backend que en ningún otro: el qubit de comunicación que libera unexpose es el que va a pedir la ventana siguiente.

Nótese también lo que cuesta una ventana: un estado GHZ, ocurran dentro las rotaciones que ocurran. El control del rank 2 se usa dos veces, por dos ranks distintos, al precio de prestarlo una. Teleportar q2 de ida y vuelta habrían sido cuatro bloques de teledata.

25.4 Los ejercicios

El valor de x viaja en el entorno, porque el lanzador no pasa argumentos al programa: la restricción SPMD del capítulo 6, todavía vinculante cuatro partes después.

$ QFT_X=5 netqmpi -n 3 notebook_apps/ex8_iqft.py --cunqa --shots 1024
$ for x in 0 1 2 3 4 5 6 7; do
>   QFT_X=$x netqmpi -n 3 notebook_apps/ex8_iqft.py --cunqa --shots 1024 | tail -1
> done

101 es 5, con el rank 0 delante, y cada marginal debería salir un 1.000 / 0.000 limpio. La bandera de determinismo vale más que el propio valor. Protege la única suposición que viene del formato de las cuentas y no de la física: CUNQA concatena una cadena de bits por registro clásico, primero el registro propio del usuario y después los dos bits del protocolo, y los bits del protocolo son monedas al aire. Si la lectura hubiera cogido uno de esos por error, nada saldría determinista, así que obtienes un honesto deterministic=False en lugar de una respuesta incorrecta pero verosímil. Un valor podría ser suerte; ocho, no.

Es el primer programa del día en el que los ranks no son simétricos: el rank 0 sostiene el bit de conteo 0 y el autoestado en un segundo qubit de datos; los ranks 1 y 2 sostienen un bit de conteo cada uno. Cada controlled-U^(2^j) tiene su control en el rank j y su objetivo en el rank 0: local para el rank 0, una ventana de expose para los otros dos. Esas ventanas no se solapan, así que se van pasando el mismo qubit de comunicación.

Dos cosas que conviene fijar antes de escribir nada. Las colectivas van fuera de las ramas if rank ==, como siempre: todos los ranks llaman a expose y a unexpose, y solo el rank 0 pone una puerta entre medias. Y los ángulos son 2π·2^j·φ, no 2π·φ/2^j. El rank 0 es el bit más significativo, así que le toca la rotación más pequeña, que es el orden que espera la QFT inversa y la razón por la que las dos mitades encajan.

$ QPE_PHI=0.625 netqmpi -n 3 notebook_apps/ex9_qpe.py --cunqa --shots 1024
$ QPE_PHI=0.3333333333333333 netqmpi -n 3 notebook_apps/ex9_qpe.py --cunqa --shots 1024

φ = 5/8 es múltiplo de 1/8, así que tres bits la representan exactamente y el registro de conteo es determinista: 101, en todas las tiradas. φ = 1/3 cae entre 2/8 y 3/8, y la segunda ejecución es la más instructiva de las dos: hay que leerla con cuidado, porque lo que vuelve son tres marginales, y nada en ellos dice qué tirada del rank 0 iba con cuál del rank 2. Con las fases exactas eso era inofensivo, porque un producto de deltas es la distribución conjunta. Aquí no lo es, y el histograma sobre x sencillamente no está en esos datos. 010 y 011 coinciden en los dos primeros bits y difieren en el tercero, que es justo lo que debe verse: los ranks 0 y 1 casi seguros, el rank 2 repartido cerca del 50/50, y deterministic=False como firma honesta.

25.5 Qué llevarse

Los cinco minutos más valiosos no son la ejecución. Son lo que dicen los dos ejercicios juntos.

La composición es el resultado. inverse_qft se copió del ejercicio 8 sin tocar nada y siguió funcionando aunque ahora el rank 0 sostiene dos qubits de datos y llega entrelazado en lugar de en un estado producto. Que una colectiva distribuida componga no es gratis; esta lo hace porque está escrita contra ranks e índices de qubit y no le importa qué pasó antes.

Lo que se paga es la concurrencia máxima, no el total. En todo el ejercicio 9 se abren cinco ventanas y la familia sigue siendo [2, 2]. Las ventanas del retroceso de fase se abren y se cierran de una en una; solo el par anidado de la QFT inversa se sostiene a la vez. La vida de la ventana es el presupuesto de qubits de comunicación: cerrando antes la ventana del rank 2 bastaría con uno, pero el circuito ya no sería la QFT inversa.

Y los recursos siguen siendo tuyos, para devolverlos. La familia lleva levantada desde el capítulo 21, y por eso cada ejecución de aquí se enganchó al instante y no pagó coste de planificador. Sigue siendo una reserva.

qdrop(FAMILY)

Dos extensiones que merece la pena probar después, y que además se responden sobre el papel antes de costar una reserva:

  • Rehacer el ejercicio 8 con teledata en lugar de telegates —mover q1 y q2 al rank 0, transformar y devolverlos— y contar cuántas peticiones gen_ent emite cada versión.
  • Llevar el ejercicio 9 a cuatro nodos. Calcular qué hay que levantar antes de levantarlo: n qubits de conteo en n nodos son n(n−1)/2 rotaciones entre nodos y n−1 qubits de comunicación sostenidos a la vez en el rank 0.
Parte V · Capítulo 26

Cierre del segundo bloque

La segunda mitad en una frase: un modelo de programación necesita una máquina sobre la que correr; esa máquina todavía no existe; CUNQA emula la infraestructura de una dentro de un supercomputador real, simulando sus dispositivos y sus canales; y, como ambos proyectos dejaron una costura delgada y documentada a la altura adecuada de la pila, las abstracciones de NetQMPI pueden bajarse sobre ella sin que ninguno de los dos lados renuncie a su modelo.

26.1 Lo que CUNQA todavía no hace

La lista honesta, en el orden en que aparece en la hoja de ruta.1

  • Ruido de comunicación: ausente. Todos los canales de este tutorial son ideales. La latencia, la fidelidad del entrelazamiento, la pérdida heraldada y la decoherencia de memoria durante la distribución del entrelazamiento son la física característica de un sistema distribuido, y nada de eso está modelado. Se están sopesando dos vías y ambas tienen coste: implementarlo sobre los simuladores existentes, que no se diseñaron para efectos de capa física dependientes del tiempo, o integrar un simulador de red de eventos discretos, que trae modelos de ruido maduros junto con un paradigma de red que no se adapta con facilidad a uno de cómputo y que, al estar escrito en su mayoría en Python, rompería el ecosistema en C++ en el que viven los simuladores actuales.
  • Ruido de dispositivo: parcial. Disponible solo cuando AerSimulator ejecuta el bucle de shots sin asistencia: sin comunicación y sin CIF (capítulos 16 a 18). Levantar esa restricción y extender el ruido a los demás simuladores que lo soportan, como Qulacs, es el más cercano de los dos objetivos.
  • El estado conjunto vive en un proceso. Bajo comunicación cuántica, el ejecutor centralizado simula un único estado sin explotar los vectores de estado distribuidos que ya ofrecen QuEST y AerSimulator bajo MPI. Es el techo del tamaño que puede alcanzar un experimento de comunicación cuántica, y es la ilustración más clara de todo el tutorial del punto del capítulo 17: la distribución de un sistema cuántico y la distribución de su simulación clásica son problemas ortogonales.
  • La ejecución es circuito a circuito. La hoja de ruta apunta a transmitir instrucciones a la vQPU en bloques binarios pequeños, actualizando la vQPU su estado según llega cada bloque, empujada por la perspectiva de circuitos cuya codificación alcance cientos de gigabytes. Eso sustituiría a JSON como formato de intercambio y, de paso, haría que flush() tradujese bien por primera vez (capítulo 23).
  • La planificación es el orden de la lista. run asigna circuitos a vQPU en el orden en que aparecen. Todo lo que haría un planificador —localidad, carga, backends heterogéneos— queda como espacio por encima de la API.

26.2 Lo que la integración todavía tiene que resolver

  • Subcommunicators. El capítulo 23 hizo corresponder COMM_WORLD con una familia. Partir un communicator se corresponde con varias familias, lo cual es viable pero todavía no es la misma abstracción, y quien programa MPI echa mano de Comm_split antes de lo que uno esperaría.
  • Paridad de ruido entre backends. El mismo programa corre sobre SquidASM y sobre CUNQA y devuelve fidelidades incomparables, por las razones de 26.1. Hasta que exista el ruido de comunicación, elegir backend es elegir qué pregunta se está haciendo: realismo físico, o comportamiento de la infraestructura a escala HPC.
  • De dónde salen los ranks. Hoy los dos -n tienen que coincidir a mano (capítulo 24). Un lanzador que levantase la infraestructura y arrancase los ranks en un solo acto sería más cómodo, y desharía por lo bajo la decisión de pila del capítulo 16, que es por lo que no se ha hecho.

26.3 El hilo

Cinco partes, un argumento. Los límites físicos obligaron a replicar unidades, replicar obligó a comunicar, y comunicar resultó ser la parte cara. MPI estandarizó cómo se programa eso mediante tres abstracciones —SPMD, rank, communicator— que han sobrevivido a todas las máquinas para las que se escribieron. NetQMPI llevó esas tres al dominio cuántico, adaptando las primitivas allí donde la física prohíbe la traducción literal y dejando una celda de la tabla permanentemente vacía. Y CUNQA aporta lo que al modelo le faltaba: no un simulador de mecánica cuántica, de los que hay muchos, sino un emulador de la infraestructura, con vQPU que se piden, se pagan, se consultan y se liberan exactamente como lo haría un acelerador de una máquina real.

Si un asistente se lleva una frase de la segunda mitad, que sea la contrapartida de la que cerró la primera: la computación cuántica distribuida se va a ejecutar en sistemas HPC, así que hay que programarla como HPC y gestionarla como HPC. Lo cuántico es lo nuevo. Casi todo lo que la rodea, no; y esa es la buena noticia, porque significa que la disciplina ya existe.

Referencias

  1. J. Vázquez-Pérez, D. Expósito-Patiño, M. Losada, Á. Carballido, A. Gómez, T. F. Pena. CUNQA: a Distributed Quantum Computing emulator for HPC. arXiv:2511.05209 [quant-ph], 2025. arxiv.org/abs/2511.05209 · documentación y código en github.com/CESGA-Quantum-Spain/cunqa
  2. F. J. Cardama, T. F. Pena. NetQMPI: An MPI-Inspired library for programming Distributed Quantum Applications over Quantum Networks using NetQASM SDK. arXiv:2512.11483 [quant-ph], 2025. arxiv.org/abs/2512.11483 · código en github.com/netqir/netqmpi
  3. F. J. Cardama, J. Vázquez-Pérez, C. Piñeiro, T. F. Pena, J. C. Pichel, A. Gómez. NetQIR: An extension of QIR for distributed quantum computing. Future Generation Computer Systems, 174:107989, 2026.
  4. T. Häner, D. S. Steiger, T. Hoefler, M. Troyer. Distributed quantum computing with QMPI. Proc. SC'21, 2021.
  5. Y. Shi et al. A Reference Implementation for a Quantum Message Passing Interface. Proc. SC-W '23, pp. 1420–1425, 2023.
  6. A. Dahlberg, B. van der Vecht, C. Delle Donne, M. Skrzypczyk, I. te Raa, W. Kozlowski, S. Wehner. NetQASM — a low-level instruction set architecture for hybrid quantum-classical programs in a quantum internet. Quantum Science and Technology, 7(3):035023, 2022.
  7. T. Coopmans et al. NetSquid, a NETwork Simulator for QUantum Information using Discrete events. Communications Physics, 4:164, 2021.
  8. A. Dahlberg, S. Wehner. SimulaQron — a simulator for developing quantum internet software. Quantum Science and Technology, 4(1):015001, 2018.
  9. S. DiAdamo, J. Nötzel, B. Zanger, M. M. Beşe. QuNetSim: A Software Framework for Quantum Networks. IEEE Transactions on Quantum Engineering, 2, 2021.
  10. X. Wu et al. SeQUeNCe: a customizable discrete-event simulator of quantum networks. Quantum Science and Technology, 6(4):045027, 2021.
  11. D. Barral, F. J. Cardama, G. Díaz-Camacho, D. Faílde, I. F. Llovo, M. Mussa-Juane, J. Vázquez-Pérez, J. Villasuso, C. Piñeiro, N. Costas, J. C. Pichel, T. F. Pena, A. Gómez. Review of Distributed Quantum Computing: From single QPU to High Performance Quantum Computing. Computer Science Review, 57:100747, 2025.
  12. M. Caleffi, M. Amoretti, D. Ferrari, J. Illiano, A. Manzalini, A. S. Cacciapuoti. Distributed quantum computing: A survey. Computer Networks, 254:110672, 2024.
  13. S. Wehner, D. Elkouss, R. Hanson. Quantum internet: A vision for the road ahead. Science, 362(6412), 2018.
  14. J. Preskill. Quantum Computing in the NISQ era and beyond. Quantum, 2:79, 2018.
  15. MPI Forum. MPI: A Message-Passing Interface Standard. Versión 4.1, 2023. mpi-forum.org/docs
  16. G. M. Amdahl. Validity of the single processor approach to achieving large scale computing capabilities. AFIPS Spring Joint Computer Conference, pp. 483–485, 1967. — J. L. Gustafson. Reevaluating Amdahl's Law. Communications of the ACM, 31(5):532–533, 1988.
  17. J. L. Hennessy, D. A. Patterson. Computer Architecture: A Quantitative Approach. 6.ª ed., Morgan Kaufmann, 2019. — Para el modelo roofline: S. Williams, A. Waterman, D. Patterson, Communications of the ACM, 52(4):65–76, 2009.
  18. W. A. Wulf, S. A. McKee. Hitting the Memory Wall: Implications of the Obvious. ACM SIGARCH Computer Architecture News, 23(1):20–24, 1995.
  19. R. H. Dennard, F. H. Gaensslen, H.-N. Yu, V. L. Rideout, E. Bassous, A. R. LeBlanc. Design of ion-implanted MOSFET's with very small physical dimensions. IEEE Journal of Solid-State Circuits, 9(5):256–268, 1974.
  20. K. Rupp. Microprocessor Trend Data. Conjunto de datos abierto, licencia CC-BY. github.com/karlrupp/microprocessor-trend-data — fuente recomendada si se proyectan cifras concretas en la figura 1.
  21. L. Dalcín, R. Paz, M. Storti, J. D'Elía. MPI for Python: Performance improvements and MPI-2 extensions. Journal of Parallel and Distributed Computing, 68(5):655–662, 2008. · documentación en mpi4py.readthedocs.io
  22. G. Díaz-Camacho, I. F. Llovo, F. J. Cardama, I. Bautista, D. Faílde, M. M. Juane, J. Vázquez-Pérez, N. Costas, T. F. Pena, A. Gómez. Benchmarking Distributed Quantum Computing Emulators. arXiv:2512.01807, 2025.
  23. R. Parekh, A. Ricciardi, A. Darwish, S. DiAdamo. Quantum Algorithms and Simulation for Parallel and Distributed Quantum Computing. Proc. QCS 2021 (SC21), pp. 9–19, 2021.
  24. A. Ovide, S. Rodrigo, M. Bandic, H. van Someren, S. Feld, S. Abadal, E. Alarcón, C. G. Almudever. Mapping quantum algorithms to multi-core quantum computing architectures. Proc. IEEE ISCAS, 2023.
  25. M. Losada, J. Vázquez-Pérez, Á. Carballido, D. Expósito. Documentación de CUNQA, 2025. cesga-quantum-spain.github.io/cunqa
  26. D. Willsch. Supercomputer simulations of transmon quantum computers. Tesis doctoral, RWTH Aachen University, 2020.
  27. A. Elsharkawy et al. Challenges in HPCQC Integration. 2023 IEEE International Conference on Quantum Computing and Engineering (QCE), vol. 2, pp. 405–406, 2023.
  28. S. Gharibian. Strong NP-hardness of the quantum separability problem. Quantum Information and Computation, 10(3):343–360, 2010.
  29. M. Dobšíček, G. Johansson, V. Shumeiko, G. Wendin. Arbitrary accuracy iterative quantum phase estimation algorithm using a single ancillary qubit: A two-qubit benchmark. Physical Review A, 76:030306, 2007.
  30. A. Y. Kitaev. Quantum measurements and the Abelian Stabilizer Problem. Tesis doctoral, Instituto de Física y Tecnología de Moscú, 1995. arxiv.org/abs/quant-ph/9511026
  31. A. Yimsiriwattana, S. J. Lomonaco Jr. Generalized GHZ States and Distributed Quantum Computing. arXiv:quant-ph/0402148, 2004. arxiv.org/abs/quant-ph/0402148
  32. D. Claudino, D. I. Lyakh, A. J. McCaskey. Parallel quantum computing simulations via quantum accelerator platform virtualization. Future Generation Computer Systems, 160:264–273, 2024.