Algoritmo Cuántico para Logaritmos Discretos en Curvas Elípticas con Suma de Puntos Eficiente en Espacio

Este repositorio contiene código Qiskit para la estimación de recursos de los circuitos cuánticos de inversión modular eficiente en espacio y suma de puntos afín utilizados en configuraciones de logaritmos discretos en curvas elípticas.

La base de código actual se centra en tres flujos de trabajo:

conteo recursivo por fragmentos del circuito de inversión modular;
optimización opcional local de la plantilla NCT del circuito;
estimación de recursos compilada por bloques del circuito de suma de puntos afín envuelto.

Estructura del repositorio

.
├── README.md
│
├── eea_model/: original classical EEA reference implementation used for algorithm prototyping and correctness validation.
│
├── run_eea_s835_fastdual_recursive_chunks_checkpoint.py
├── run_eea_s835_fastdual_recursive_chunks_checkpoint_nctopt.py
├── count_s835_fastdual_wrapped_point_addition_blocks_compiled.py
│
├── eea_circuit.py
├── eea_circuit_s835_fastdual.py
├── eea_circuit_s835_lowaux.py
├── eea_circuit_updated.py
├── under1000_eea_shared_s835_fastdual_wrapped.py
├── under1000_modular_arithmetic_base.py
│
├── point_addition_fig14_s835_fastdual_wrapped_quadratic.py
├── quadratic_fig15_inplace_s835_fastdual_wrapped.py
├── quadratic_gidney_arithmetic.py
├── quadratic_lazy_instruction.py
├── quadratic_modular_arithmetic.py
├── quadratic_squ_minus.py
│
├── ccx_recursive_block_counter.py
├── nct_template_segment_optimizer.py
│
├── test_eea_strict_main.py
└── test_point_addition_strict_main.py

Scripts de entrada principales

run_eea_s835_fastdual_recursive_chunks_checkpoint.py
Cuenta los pasos del Algoritmo-3 EEA recursivamente, en fragmentos con puntos de control.
run_eea_s835_fastdual_recursive_chunks_checkpoint_nctopt.py
Mismo flujo de trabajo de conteo EEA, pero con optimización local de plantilla NCT.
count_s835_fastdual_wrapped_point_addition_blocks_compiled.py
Cuenta el circuito de suma de puntos envuelto contando recursivamente subbloques compilados reutilizables y ensamblando los componentes aritméticos repetidos con multiplicidades exactas.

Archivos EEA

eea_circuit_s835_fastdual.py: Implementación principal del circuito EEA de producción.
eea_circuit_s835_lowaux.py: Rutinas auxiliares de baja ayuda utilizadas por la implementación principal.
eea_circuit_updated.py: Bloques de construcción EEA compartidos y utilidades recursivas de conteo de recursos.
eea_circuit.py: Envoltorio de compatibilidad hacia atrás para pruebas.

Archivos de suma de puntos y aritmética

point_addition_fig14_s835_fastdual_wrapped_quadratic.py: construye el circuito de suma de puntos afín envuelto correspondiente al cronograma de la Fig.14.
quadratic_fig15_inplace_s835_fastdual_wrapped.py: construye la estructura de división in situ y multiplicación in situ de la Fig.15 con EEA, multiplicación, medición, reinicio y corrección de fase feed-forward.
quadratic_modular_arithmetic.py: instrucciones de suma/resta modular, multiplicación, multiplicación inversa, duplicación y reducción a la mitad utilizadas por el contador de suma de puntos.
quadratic_gidney_arithmetic.py: primitivas aritméticas estilo Gidney y ayudantes de medición y feed-forward utilizados por la capa aritmética modular cuadrática.
quadratic_squ_minus.py: bloque cuadrado-menos utilizado en el cronograma de suma de puntos afín.
under1000_eea_shared_s835_fastdual_wrapped.py: envoltorio EEA compartido y ayudante utilizado por el circuito de suma de puntos.
under1000_modular_arithmetic_base.py: pequeñas utilidades compartidas de aritmética modular.

Utilidades de conteo y optimización

ccx_recursive_block_counter.py: contador recursivo para circuitos Qiskit, con políticas para expansión MCX y expansión SWAP.
nct_template_segment_optimizer.py: optimizador local basado en plantillas para segmentos {X, CX, CCX}.

Requisitos

Entorno recomendado:

Python 3.10+
Qiskit

Instale la dependencia principal con:

python -m pip install --upgrade pip
python -m pip install qiskit

Inicio rápido

Ejecute la suite de pruebas:

python test_eea_strict_main.py
python test_point_addition_strict_main.py

Para una prueba rápida de suma de puntos:

python test_point_addition_strict_main.py --skip-n256 --skip-report

1. Conteo recursivo por fragmentos EEA

El punto de entrada estándar para el conteo EEA es:

python run_eea_s835_fastdual_recursive_chunks_checkpoint.py \
  --n 192 \
  --chunk-size 25 \
  --measurement-uncompute \
  --resume \
  --workdir eea_s835_fastdual_chunks25 \
  --out eea_s835_fastdual_algorithm3_recursive_chunks_n192_measurement.json

Argumentos importantes:

--n: ancho de bits.
--T-max: anulación opcional del número de pasos del Algoritmo-3; por defecto se usa el valor de eea.get_n_config(n).
--chunk-size: número de pasos del Algoritmo-3 contados por fragmento de punto de control.
--aux-size: anulación opcional del grupo de qubits auxiliares; si se omite, el tamaño del diseño auxiliar se calcula automáticamente.
--measurement-uncompute: habilita la anulación basada en medición en los bloques EEA contados.
--resume: reutiliza archivos JSON de fragmentos existentes no vacíos en --workdir.
--workdir: directorio para archivos de punto de control por fragmento.
--out: resumen JSON acumulativo escrito después de cada fragmento.

El script escribe archivos por fragmento como:

eea_s835_fastdual_chunks25/eea_s835_fastdual_n192_T0001_0025.json

y un JSON de salida acumulativo que contiene campos como:

mode
n
T_max
num_qubits
len_width
shift_width
aux_size
measurement_based
ops
chunks
elapsed_s_so_far

2. Conteo EEA con optimización de plantilla NCT

El punto de entrada para el conteo optimizado es:

python run_eea_s835_fastdual_recursive_chunks_checkpoint_nctopt.py \
  --n 128 \
  --chunk-size 25 \
  --measurement-uncompute \
  --templates small-nct \
  --rounds 1 \
  --max-nct-segment-gates 40 \
  --segment-timeout-s 10 \
  --timeout-mode auto \
  --resume \
  --workdir eea_s835_fastdual_chunks_nctopt_failopen_r1_128_seg40_to10 \
  --out eea_s835_fastdual_algorithm3_recursive_chunks_n128_measurement_nctopt_failopen_r1_seg40_to10.json

Este flujo de trabajo intenta la optimización local de plantillas en segmentos {X, CX, CCX}. Está diseñado como un contador acotado con fallo abierto: si un paso optimizado agota el tiempo o genera una excepción, ese paso se cuenta exactamente sin rondas de plantilla y luego se marca como punto de control, por lo que los recuentos finales informados permanecen completos.

Argumentos útiles además de los argumentos EEA estándar:

--templates {small-nct,all-nct}: selección de biblioteca de plantillas.
--rounds: número de rondas de optimización de plantillas.
--max-nct-segment-gates: tamaño máximo de un segmento reversible enviado a optimización de plantillas.
--max-nct-segment-qubits: número máximo de qubits en un segmento.
--segment-timeout-s: tiempo de espera para la optimización de un segmento individual.
--step-timeout-s: tiempo de espera para un paso completo del Algoritmo-3 antes de retroceder al conteo sin cambios.
--fallback-step-timeout-s: tiempo de espera para el conteo de retroceso exacto.
--force: recalcula incluso si ya existen puntos de control de paso/fragmento.
--ignore-policy-mismatch: reutilizar puntos de control antiguos incluso si la política de optimización difiere; esto es principalmente para depuración.

El flujo de trabajo optimizado escribe puntos de control a nivel de paso en:

<workdir>/steps/

y resúmenes a nivel de fragmento en:

<workdir>/

Quantum-Algorithm-for-Elliptic-Curve-Discrete-Logarithms-with-Space-Efficient-Point-Addition

Más Populares