Uso de la biblioteca de valores numéricos cuánticos

Sugerencia

Si desea acelerar el recorrido de la computación cuántica, consulte Código con Azure Quantum, una característica única del sitio web de Azure Quantum. Aquí puede ejecutar ejemplos integrados Q# o sus propios Q# programas, generar código nuevo Q# a partir de las indicaciones, abrir y ejecutar el código en VS Code para web y formular a Copilot cualquier pregunta sobre la computación cuántica.

Información general

La biblioteca Numerics consta de tres componentes:

1. Aritmética básica de enteros con comparadores y sumadores de enteros
2. Funciones de enteros de alto nivel que se basan en las funciones básicas; incluyen multiplicación, división, inversión, etc. para enteros con y sin signo.
3. Funciones aritméticas de punto fijo con inicialización de punto fijo, suma, multiplicación, evaluación polinómica y recíproca, y medida.

Se puede acceder a todos estos componentes mediante una sola instrucción open:

open Microsoft.Quantum.Arithmetic;

Requisitos previos

• El kit de desarrollo de Microsoft Quantum o un área de trabajo de Azure Quantum.
• La Microsoft.Quantum.Numerics biblioteca. Para obtener información sobre cómo instalar bibliotecas adicionales Q# , consulte Q# bibliotecas.

Tipos

La biblioteca de valores numéricos admite los siguientes tipos:

1. LittleEndian : matriz de cúbits qArr : Qubit[] que representa un entero donde qArr[0] indica el bit menos significativo.
2. SignedLittleEndian : igual que LittleEndian, salvo que representa un entero con signo almacenado en el complemento de 2.
3. FixedPoint : representa un número real que consta de una matriz de cúbits qArr2 : Qubit[] y una posición de punto binario pos, que cuenta el número de dígitos binarios a la izquierda del punto binario. qArr2 se almacena de la misma manera que SignedLittleEndian.

Operations

Para cada uno de los tres tipos admitidos, hay disponible una variedad de operaciones:

1. LittleEndian

   • Suma
   • De comparación
   • Multiplicación
   • Cuadrado
   • División (con resto)

2. SignedLittleEndian

   • Suma
   • De comparación
   • Complemento de 2 del módulo de inversión
   • Multiplicación
   • Cuadrado

3. FixedPoint

   • Preparación o inicialización en valores clásicos
   • Adición (constante clásica u otro punto fijo cuántico)
   • De comparación
   • Multiplicación
   • Cuadrado
   • Evaluación polinómica con especialización para funciones pares e impares
   • Recíproca (1/x)
   • Medida (doble clásica)

Ejemplo: adición de enteros

Como ejemplo básico, considere la operación $$ \ket x\ket y\mapsto \ket x\ket{x+y} $$, es decir, una operación que toma un entero de n cúbits $x$ y un registro de n o (n+1) cúbits $y$ como entrada, el último de los cuales se asigna a la suma $(x+y)$. Tenga en cuenta que la suma se calcula en el módulo $2^n$ si $y$ se almacena en un registro de $n$ bits.

Con , esta operación se puede aplicar de la Quantum Development Kitsiguiente manera:

operation TestMyAddition(xValue : Int, yValue : Int, n : Int) : Unit {
    use (xQubits, yQubits) = (Qubit[n], Qubit[n]);
    let x = LittleEndian(xQubits); // define bit order
    let y = LittleEndian(yQubits);

    ApplyXorInPlace(xValue, x); // initialize values
    ApplyXorInPlace(yValue, y);

    AddI(x, y); // perform addition x+y into y

    // ... (use the result)
    
}

Ejemplo: Evaluación de funciones fluidas

Para evaluar funciones fluidas como $\sin(x)$ en un equipo cuántico, donde $x$ es un número cuántico FixedPoint , la Quantum Development Kit biblioteca numérica proporciona las operaciones EvaluatePolynomialFxP y Evaluate[Even/Odd]PolynomialFxP.

La primera, EvaluatePolynomialFxP, permite evaluar un polinomio con la forma $$ P(x) = a_0 + a_1x + a_2x^2 + \cdots + a_dx^d, $$ donde $d$ indica el grado. Para ello, lo único que se necesita son los coeficientes polinómicos [a_0,..., a_d] (de tipo Double[]), la entrada x : FixedPoint y la salida y : FixedPoint (inicialmente cero):

EvaluatePolynomialFxP([1.0, 2.0], x, y);

El resultado, $P(x)=1+2x$, se almacena en yFxP.

La segunda, EvaluateEvenPolynomialFxP, y la tercera, EvaluateOddPolynomialFxP, son especializaciones para los casos de funciones pares e impares, respectivamente. Es decir, para una función par/impar $f(x)$ y $$ P_{even}(x)=a_0 + a_1 x^2 + a_2 x^4 + \cdots + a_d x^{2d}, $$ $f(x)$ se aproxima bien mediante $P_{even}(x)$ o $P_{odd}(x) := x\cdot P_{even}(x)$, respectivamente. En Q#, estos dos casos se pueden controlar de la siguiente manera:

EvaluateEvenPolynomialFxP([1.0, 2.0], x, y);

que evalúa $P_{even}(x) = 1 + 2x^2$, y

EvaluateOddPolynomialFxP([1.0, 2.0], x, y);

que evalúa $P_{odd}(x) = x + 2x^3$.

Más ejemplos

Puede encontrar más ejemplos en el repositorio principal de ejemplos.

Para empezar, clone el repositorio y abra la subcarpeta Numerics:

git clone https://github.com/Microsoft/Quantum.git
cd Quantum/samples/numerics

A continuación, ejecute cd en una de las carpetas de ejemplo y ejecute el ejemplo a través de

dotnet run