Exponenciación por el cuadrado

En matemáticas y programación informática, la exponenciación al cuadrado es un método general para el cálculo rápido de grandes potencias enteras positivas de un número, o más generalmente de un elemento de un semigrupo, como un polinomio o un matriz cuadrada. Algunas variantes se conocen comúnmente como algoritmos cuadrar y multiplicar o potenciación binaria. Estos pueden ser de uso bastante general, por ejemplo en aritmética modular o potenciación de matrices. Para los semigrupos para los que se usa comúnmente la notación aditiva, como las curvas elípticas que se usan en criptografía, este método también se conoce como doble y suma.

Método básico

Versión recursiva

El método se basa en la observación de que, para un entero positivo n, uno tiene

${displaystyle x^{n}={begin{cases}x,(x^{2})^{frac {n-1}{2}}, {mbox{if}n{mbox{ is odd}\(x^{2})^{frac {n}{2}}} {mbox{if}n{mbox{ is even}} {mbox{ is even}} {mbox{}}}} {mbox {mbox{}}} {mbox{}}}}}}}} {mbox{}}}}}}} {mbox{}}}}}} {mbox{}}}}}} {mbox{}}} {mbox {}}}}}}}} {mbox {}}}}}}}}}} {mbox {mbox {}}}} {} {}}}}} {mbox {c}}}}}} {c}}}}}} {c}}}} {c}}}}}}}}}}}}}}} {c}}}}}}}} {fnMicrosoft Sans Serif}}$

Esto se puede implementar directamente como el siguiente algoritmo recursivo:

 Función exp_by_squaring()x, n) si n . 0 entonces retorno exp_by_squaring()1 / x, -n); más si n = 0 entonces retorno 1; más si n es incluso entonces retorno exp_by_squaring()x * x, n / 2); más si n es extraño entonces retorno x * exp_by_squaring()x * x, ()n - 1) / 2);

Exponenciación recursiva en C++

#include ■iostreamutilizando namespace std;int exponentiation()int a, int b){ si()b==1) retorno a; si()b%2==1) retorno a*exponentiation()a, b-1); int tmp_exp = exponentiation()a, b/2); retorno tmp_exp * tmp_exp;}int principal(){} int a, b; Cout.."Da un "; cinc>a; Cout.."Give b"; cinc>b; Cout..exponentiation()a, b); retorno 0;}

En cada llamada recursiva, los dígitos menos significativos de la representación binaria n es eliminado. Sigue que el número de llamadas recursivas es ${displaystyle lceil log _{2}nrceil}$ el número de bits de la representación binaria de n. Así que este algoritmo calcula este número de plazas y un menor número de multiplicación, que es igual al número de plazas 1 en la representación binaria de n. Este número de operaciones logarítmicas se comparará con el algoritmo trivial que requiere n − 1 multiplicaciones.

Este algoritmo no es recursivo a la cola. Esto implica que requiere una memoria auxiliar que es aproximadamente proporcional (o mayor, si se tiene en cuenta el tamaño creciente de los datos) al número de llamadas recursivas.

Los algoritmos de la siguiente sección usan un enfoque diferente y los algoritmos resultantes necesitan la misma cantidad de operaciones, pero usan una memoria auxiliar que es aproximadamente la misma que la memoria requerida para almacenar el resultado.

Con memoria auxiliar constante

Las variantes descritas en esta sección se basan en la fórmula

${fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif} {mbox{if}n{mbox}n{mbox {mbox}mbox}mbox {mbox}mbox {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {mbox} {m} {m} {m} {m}{}{m} {mbox} {} {mbox} {mbox} {m} {m} {m} {m} {m}{} {m}{} {m} {m} {m} {m}{m} {m} {m} {m} {m {fnMicrosoft Sans Serif}}$

Si se aplica recursivamente esta fórmula, comenzando con y = 1, se obtiene finalmente un exponente igual a 0, y el resultado deseado es entonces el factor de la izquierda.

Esto puede implementarse como una función recursiva de cola:

 Función exp_by_squaring()x, n) retorno exp_by_squaring2()1, x, n) Función exp_by_squaring2()Sí., x, n) si n . 0 entonces retorno exp_by_squaring2()Sí., 1 / x, - n); más si n = 0 entonces retorno Sí.; más si n es incluso entonces retorno exp_by_squaring2()Sí., x * x, n / 2); más si n es extraño entonces retorno exp_by_squaring2()x * Sí., x * x, ()n - 1) / 2).

La versión iterativa del algoritmo también utiliza un espacio auxiliar acotado y está dada por

 Función exp_by_squaring_iterative()x, n) si n . 0 entonces x := 1 / x; n := -n; si n = 0 entonces retorno 1 Sí. := 1; mientras n ■ 1 do si n es incluso entonces x := x * x; n := n / 2; más Sí. := x * Sí.; x := x * x; n := ()n – 1) / 2; retorno x * Sí.

La corrección del algoritmo resulta del hecho de que ${displaystyle yx^{n}$ es invariante durante el cálculo; ${displaystyle 1cdot x^{n}=x^{n}$ al principio; y ${displaystyle yx^{0}=y}$ al final.

Estos algoritmos usan exactamente el mismo número de operaciones que el algoritmo de la sección anterior, pero las multiplicaciones se realizan en un orden diferente.

Complejidad computacional

Un breve análisis muestra que tal algoritmo utiliza ${displaystyle lfloor log ¿Qué?$ squarings and at most ${displaystyle lfloor log ¿Qué?$ multiplicaciones, donde ${displaystyle lfloor ;rfloor }$ denota la función del suelo. Más precisamente, el número de multiplicaciones es menor que el número de las presentes en la expansión binaria n. Para n más grande que alrededor de 4 esto es computacionalmente más eficiente que multiplicar ingenuamente la base con sí misma repetidamente.

Cada elevación al cuadrado da como resultado aproximadamente el doble del número de dígitos del anterior, por lo que, si la multiplicación de números de dos ddígitos se implementa en O(d^k) operaciones para algunos k fijos, luego la complejidad de calcular xⁿ viene dado por

${displaystyle sum limits _{i=0}{O(log n)}{big (}2^{i}O(log x){big)}}{k}=O{big (}(nlog x)^{k}{big)}}}}}$

Método 2k-ario

Este algoritmo calcula el valor de xⁿ después de expandir el exponente en base 2^k. Brauer lo propuso por primera vez en 1939. En el siguiente algoritmo, utilizamos la siguiente función f(0) = (k,0) y f< /i>(m) = (s,u), donde m = u·2^s con u impar.

Algoritmo:

Input

Un elemento x de G, un parámetro k in 0, un entero no negativo n =n_l−1, n_l−2,... n₀)_2^k y los valores precomputados ${displaystyle x^{3},x^{5},x^{2^{k}-1}$.

Producto

El elemento xⁿ dentro G

y:= 1; i:= l - 1
mientras i ≥ 0 do
(s, u):= f(ni)
 para J:= 1 a k - s doY... Sí.2 Y...u para J:= 1 a s doY... Sí.2i:= I - 1
retorno Sí.

Para una eficiencia óptima, k debe ser el entero más pequeño que satisfaga

${displaystyle log n made{frac {k(k+1)cdot 2^{2k}{2^{k+1}-k-2}+1.}$

Método de ventana deslizante

Este método es una variante eficiente del método 2^k-ario. Por ejemplo, para calcular el exponente 398, que tiene expansión binaria (110 001 110)₂, tomamos una ventana de longitud 3 usando el 2^{k-ary y calcular 1, x3, x6, x12, x24, x48, x49, x98, x99, x198, x199, x398. Pero también podemos calcular 1, x3, x6, x12, x24, x< sup>48}, x⁹⁶, x¹⁹², x¹⁹⁹, x³⁹⁸, lo que ahorra una multiplicación y equivale a evaluar (110 001 110)₂

Este es el algoritmo general:

Algoritmo:

Input

Un elemento x de G, un entero no negativo n=n_l−1, n_l−2,... n₀)₂, un parámetro k Ø 0 y los valores precomputados ${displaystyle x^{3},x^{5},x^{2^{k}-1}$.

Producto

El elemento xⁿ ▪ G.

Algoritmo:

y:= 1; i:= l - 1
mientras i do si ni = 0 entoncesY... Sí.2Yo... i - 1
 másS:= max{i - k + 1, 0}
 mientras ns = 0 dos:= s + 1
 para h:= 1 a i - s + 1 doY... Sí.2No.i, ni-1,...s)2Y...ui:= s - 1
retorno Sí.

Técnica de la escalera de Montgomery

Muchos algoritmos de exponenciación no brindan defensa contra los ataques de canal lateral. Es decir, un atacante que observa la secuencia de elevaciones al cuadrado y multiplicaciones puede recuperar (parcialmente) el exponente involucrado en el cálculo. Este es un problema si el exponente debe permanecer en secreto, como ocurre con muchos criptosistemas de clave pública. Una técnica llamada 'escalera de Montgomery' aborda esta inquietud.

Dada la expansión binaria de un entero positivo distinto de cero n = (n_k−1...n₀)₂ con n_k−1 = 1, podemos calcular xⁿ de la siguiente manera:

x1 = x; x2 = x2para i = k - 2 a 0 do si ni = 0 entoncesx2 = x1 *2; x1 = x12 másx1 = x1 *2; x2 = x22retorno x1

El algoritmo realiza una secuencia fija de operaciones (hasta logn): se realiza una multiplicación y un cuadrado para cada bit en el exponente, independientemente del valor específico del bit. Existe un algoritmo similar para la multiplicación por duplicación.

Esta implementación específica de la escalera de Montgomery aún no está protegida contra ataques de tiempo de caché: las latencias de acceso a la memoria aún pueden ser observables para un atacante, ya que se accede a diferentes variables según el valor de los bits del exponente secreto. Las implementaciones criptográficas modernas utilizan una "dispersión" técnica para asegurarse de que el procesador siempre pierda el caché más rápido.

Exponente de base fija

Hay varios métodos que se pueden emplear para calcular xⁿ cuando la base es fija y el exponente varía. Como se puede ver, los cálculos previos juegan un papel clave en estos algoritmos.

El método de Yao

El método de Yao es ortogonal al método 2^k-ary donde el exponente se expande en radix b = 2^k y el cálculo se realiza como en el algoritmo anterior. Sea n, n_i , b y b_i sean números enteros.

Deje que el exponente n se escriba como

${displaystyle n=sum ¿Qué?$

Donde ${displaystyle 0leqslant No.$ para todos ${displaystyle iin [0,w-1]$.

Sea x_i = x^b_i< /i>.

Entonces el algoritmo usa la igualdad

${displaystyle x^{n}=prod ¿Qué? {fnMicrosoft Sans Serif} ¿Qué?$

Dado el elemento x de G, y el exponente n escrito en el formulario anterior, junto con los valores precalculados x^b₀...x ^b_w−1, el elemento xⁿ se calcula utilizando el siguiente algoritmo:

y = 1, u = 1, j = h - 1
mientras j latitud 0 do para I = 0 a w - 1 do si ni j entoncesU = u × xbiy
j = j) 1
retorno Sí.

Si nos fijamos h = 2^k y b_i = hⁱ, entonces el n_i valores son simplemente los dígitos de n en base h. El método de Yao se acumula en u primero x_i que parecen al poder más alto ${displaystyle h-1}$; en la siguiente vuelta aquellos con poder ${displaystyle h-2}$ se recogen en u así como etc. La variable Sí. se multiplica ${displaystyle h-1}$ tiempos con la inicial u, ${displaystyle h-2}$ tiempos con los siguientes poderes más altos, y así sucesivamente. El algoritmo utiliza ${displaystyle w+h-2}$ multiplicaciones, y ${displaystyle w+1}$ elementos deben almacenarse para calcular xⁿ.

Método euclidiano

El método euclidiano se introdujo por primera vez en Exponenciación eficiente mediante precálculo y cadenas de suma de vectores de P.D Rooij.

Este método de cálculo ${displaystyle x^{n}$ en grupo G, donde n es un entero natural, cuyo algoritmo se da a continuación, está utilizando la siguiente igualdad recursivamente:

${displaystyle ¿Qué? x_{1} {n_{1}=left(x_{0}cdot ¿Qué? x_{1} {n_{1}mod No.$

Donde ${displaystyle q=leftlfloor {frac Está bien. }$. En otras palabras, una división euclidiana del exponente n₁ por n₀ se utiliza para devolver un cociente q y un descanso n₁ mod n₀.

Dado el elemento base x en grupo G, y el exponente ${displaystyle n}$ escrito como en el método de Yao, el elemento ${displaystyle x^{n}$ se calcula utilizando ${displaystyle l}$ valores precomputados ${displaystyle x^{b_{0}}},x^{b_{l_{i}}$ y luego el algoritmo debajo.

Comience el bucle Encontrar ${displaystyle Min [0,l-1]$, tales que ${displaystyle forall iin [0,l-1],n_{M}gq n_{i}$. Encontrar ${displaystyle Nin {big (}[0,l-1]-M{big)}$, tales que ${displaystyle forall iin {big [0,l-1]-M{big]},n_{N}geq No.$. Bucle de ruptura si ${displaystyle No.$. Vamos ${displaystyle q=lfloor No.$, y luego Deja ${displaystyle No. {n}_{N}}$. Computar recursivamente ${displaystyle #$, y luego Deja ${displaystyle x_{N}=x_{N}cdot x_{M} {q}$.Loop final;
Regreso ${displaystyle #$.

El algoritmo primero encuentra el valor más grande entre n_i y luego el supremo dentro del conjunto de { n_i i ≠ M . Luego eleva x_M a la potencia q, multiplica este valor por x_N, y luego asigna x_N el resultado de este cálculo y n_M el valor n< /i>_M módulo n_N .

Otras aplicaciones

La misma idea permite el cálculo rápido de exponentes grandes módulo un número. Especialmente en criptografía, es útil calcular potencias en un anillo de números enteros módulo q. También se puede usar para calcular potencias enteras en un grupo, usando la regla

Poder(x, −n(Power)x, n)⁻¹.

El método funciona en todos los semigrupos y se usa a menudo para calcular potencias de matrices.

Por ejemplo, la evaluación de

13789⁷²²³⁴¹ (mod 2345) = 2029

tomaría mucho tiempo y mucho espacio de almacenamiento si se utiliza el método ingenuo: computar 13789⁷²²³⁴¹, entonces tome el resto cuando se divide en 2345. Incluso utilizando un método más eficaz tomará mucho tiempo: cuadrado 13789, tomar el resto cuando se divide en 2345, multiplicar el resultado por 13789, y así sucesivamente. Esto tomará menos que ${displaystyle 2log _{2}(722340)leq 40}$ multiplicaciones modulares.

Aplicando el algoritmo exp-by-squareing anterior, con "*" interpretado como x * y = xy mod 2345 (es decir, una multiplicación seguida de una división con resto) conduce a solo 27 multiplicaciones y divisiones de números enteros, que pueden almacenarse en una sola palabra de máquina.

Grabación de dígitos con signo

En ciertos cálculos, puede ser más eficiente permitir coeficientes negativos y, por lo tanto, usar el inverso de la base, siempre que se invierta en G es "rápido" o ha sido precalculada. Por ejemplo, al calcular x^2k−1, el método binario requiere k−1 multiplicaciones y k−1 cuadraturas. Sin embargo, uno podría realizar k cuadrados para obtener x^2k y luego multiplicar por x⁻¹ para obtener x^2k−1.

Con este fin, definimos la representación de dígitos con signo de un número entero n en radix b como

${displaystyle n=sum - ¿Por qué?$

Representación binaria firmada corresponde a la elección particular b = 2 y ${displaystyle n_{i}in {-1,0,1}}$. Es denotado por ${displaystyle (n_{l-1}dots No.$. Hay varios métodos para calcular esta representación. La representación no es única. Por ejemplo, tome n = 478: dos representaciones firmadas-binarias distintas son dadas por ${displaystyle (10{bar {1}}1100{bar {1}}} {}} {}}} {}} {}}} {}}} {}}}} {}}}}} {}}}} {}}}}}} {}}}}}}}}}}} {}}}} {}}}}} {}}}}} {}}}}}}}}}}}}}}}$ y ${displaystyle (100{bar {1}000{bar {1}0} {} {}}} {}}}$, donde ${displaystyle {bar}}}$ se utiliza para denotar −1. Puesto que el método binario calcula una multiplicación por cada entrada no cero en la base-2 representación de n, estamos interesados en encontrar la representación binaria firmada con el menor número de entradas no cero, es decir, la con mínimo Hamming peso. Un método de hacer esto es calcular la representación en forma no adyacente, o NAF por corto, que es uno que satisface ${displaystyle ################################################################################################################################################################################################################################################################ 0}$ y denotado por ${displaystyle (n_{l-1}dots No.$. Por ejemplo, la representación de la NAF de 478 es ${displaystyle (1000{bar {1}000{bar {1}0}_{text{NAF}}}$. Esta representación siempre tiene un peso mínimo de Hamming. Un simple algoritmo para calcular la representación de NAF de un entero dado ${displaystyle n=(n_{l-1}dots No.$ con ${displaystyle No.$ es el siguiente:

${displaystyle C_{0}=0}$para i = 0 a l − 1 do
 ${displaystyle c_{i+1}=leftlfloor {fn_} {fn_} {fn_fn_}fn_fn_}derecharfloor }$ ${displaystyle No.$retorno ${displaystyle (n_{l-1}dots No.$

Otro algoritmo de Koyama y Tsuruoka no requiere la condición de que ${displaystyle No.$; todavía minimiza el peso de Hamming.

Alternativas y generalizaciones

La exponenciación por elevación al cuadrado puede verse como un algoritmo de potenciación de cadena de suma subóptimo: calcula el exponente por una cadena de suma que consiste en duplicaciones repetidas de exponentes (elevaciones al cuadrado) y/o exponentes incrementados por uno (multiplicando por x) solamente. De manera más general, si uno permite que se sumen cualquier exponentes previamente calculados (multiplicando esas potencias de x), a veces se puede realizar la exponenciación usando menos multiplicaciones (pero típicamente usando más memoria). La potencia más pequeña donde esto ocurre es para n = 15:

${displaystyle x^{15}=xtimes (xtimes [xtimes x^{2}]^{2}}}{2}}$(squaring, 6 multiplicados),

${displaystyle x^{15}=x^{3}times ([x^{3})^{2}}}$(cadena adicional óptima, 5 multiplica si x³ es reutilizado).

En general, encontrar la cadena de suma óptima para un exponente dado es un problema difícil, para el cual no se conocen algoritmos eficientes, por lo que las cadenas óptimas generalmente solo se usan para exponentes pequeños (por ejemplo, en compiladores donde las cadenas para pequeñas potencias han sido pre-tabuladas). Sin embargo, hay una serie de algoritmos heurísticos que, si bien no son óptimos, tienen menos multiplicaciones que exponenciaciones al elevar al cuadrado a costa de un trabajo adicional de contabilidad y uso de memoria. Independientemente, el número de multiplicaciones nunca crece más lentamente que Θ(log n), por lo que estos algoritmos solo mejoran asintóticamente con la exponenciación al elevar al cuadrado por un factor constante en el mejor de los casos.