Tutorial: Implementación de un generador cuántico de números aleatorios en Q#

En este tutorial, escribirá su primer programa cuántico con el kit de desarrollo de Quantum (QDK). Un ejemplo sencillo de un algoritmo cuántico escrito en Q# es un generador cuántico de números aleatorios. Este algoritmo aprovecha la naturaleza de la mecánica cuántica para generar un número aleatorio.

Prerrequisitos

• Instale el kit de desarrollo de Quantum (QDK) con su lenguaje y entorno de desarrollo preferidos.
• Si ya tiene instalado el QDK, asegúrese de que ha actualizado a la versión más reciente.

En este tutorial, aprenderá a:

Creación de un proyecto Q#

Lo primero que hay que hacer es crear un nuevo proyecto de Q#. En este tutorial se usa el entorno basado en aplicaciones de Q# en VS Code, pero puede usar el IDE que prefiera.

Para crear un proyecto en VS Code:

1. Haga clic en Ver -> Paleta de comandos y seleccione Q#: Crear nuevo proyecto.
2. Haga clic en Aplicación de consola independiente.
3. Vaya a la ubicación para guardar el proyecto y haga clic en Crear proyecto.
4. Cuando el proyecto se haya creado correctamente, haga clic en Abrir nuevo proyecto... abajo a la derecha.

En este caso, el proyecto se denomina Qrng. Esto genera dos archivos: Qrng.csproj, el archivo de proyecto y Program.qs, una plantilla de una aplicación Q# que usaremos para escribir nuestra aplicación. El contenido de Program.qs debe ser:

   namespace Qrng {

      open Microsoft.Quantum.Canon;
      open Microsoft.Quantum.Intrinsic;
      
      @EntryPoint()
      operation HelloQ() : Unit {
          Message("Hello quantum world!");
      }
   }

Escritura de una operación de Q#

Reemplace el contenido del archivo Program.qs por el código siguiente:

namespace Qrng {
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    
    @EntryPoint()
    operation GenerateRandomBit() : Result {
        use q = Qubit();   // Allocate a qubit.
        H(q);              // Put the qubit to superposition. It now has a 50% chance of being 0 or 1.
        return MResetZ(q); // Measure the qubit value.
    }
}

Echemos un vistazo a este código. Defina la operación GenerateRandomBit, que no toma ninguna entrada y genera un valor de tipo Result. El tipo Result representa el resultado de una medición y puede tener dos valores posibles: Zero y One. EntryPoint indica al compilador de Q# que empiece a ejecutar el programa aquí. En Q#, los cúbits se asignan mediante la palabra clave use. La operación H coloca el bit cuántico en superposición. La operación M mide el bit cuántico y devuelve el valor medido (o cero o uno).

Tal y como se mencionó en el artículo Descripción de la computación cuántica, un cúbit es una unidad de información cuántica que puede estar en superposición. Cuando se mide, un cúbit solo puede ser 0 o 1. Sin embargo, antes de la medida, el estado del cúbit representa la probabilidad de leer un 0 o un 1 al tomar una medida. Este estado probabilístico se conoce como superposición. Se puede usar esta probabilidad para generar números aleatorios.

Esta operación de Q# presenta el tipo de datos Qubit, nativo de Q#. Solo se puede asignar un Qubit con una instrucción use. Cuando se asigna un cúbit, siempre está en el estado Zero.

Al colocar Qubit en superposición con la operación H y medirlo con la operación intrínseca M, el resultado será un valor diferente cada vez que se invoque el código.

Cuando se desasigna un Qubit, se debe volver a establecer explícitamente en el estado Zero; de lo contrario, el simulador notificará un error en tiempo de ejecución. Una manera fácil de hacerlo es invocar a Reset.

Visualización del código con la esfera de Bloch

En la esfera Bloch, el polo norte representa el valor clásico 0 y el polo sur representa el valor clásico 1. Cualquier superposición se puede representar mediante un punto en la esfera (representado con una flecha). Cuanto más cerca esté el extremo de la flecha a un polo, mayor será la probabilidad de que el cúbit caiga en el valor clásico asignado a ese polo cuando se mida. Por ejemplo, el estado del cúbit representado por la flecha roja siguiente tiene una mayor probabilidad de dar el valor 0 si lo medimos.

Podemos usar esta representación para visualizar lo que está haciendo el código:

• En primer lugar, empezamos con un cúbit inicializado en el estado 0 y aplicamos H para crear una superposición en la que las probabilidades de 0 y 1 sean las mismas.

• A continuación, se mide el cúbit y se guarda el resultado:

Como el resultado de la medida es completamente aleatorio, hemos obtenido un bit aleatorio. Podemos llamar a esta operación varias veces para crear enteros. Por ejemplo, si llamamos a la operación tres veces para obtener tres bits aleatorios, podemos crear números de 3 bits aleatorios (es decir, un número aleatorio entre 0 y 7).

Creación de un generador completo de números aleatorios

Ahora que tiene una operación de Q# que genera bits aleatorios, podemos usarla para crear un generador cuántico de números cuánticos completo. Puede hacer con una aplicación de Q# o un programa host.

Definición de la lógica del generador de números aleatorios

Primero, vamos a describir cuál debe ser la lógica de un generador de números aleatorios, siempre y cuando dispongamos de uno:

1. Definir max como el número máximo que quiere generar.
2. Definir el número de bits aleatorios que necesita generar. Esto se hace calculando cuántos bits, nBits, necesitamos para expresar los enteros hasta el máximo.
3. Genere una cadena de bits aleatoria con una longitud de nBits.
4. Si la cadena de bits representa un número mayor que max, hay que volver al paso tres.
5. Si no, el proceso habrá finalizado. Devolver el número generado como un entero.

Definición de la operación

Defina la operación SampleRandomNumberInRange, que llama repetidamente a la operación GenerateRandomBit para crear una cadena de bits.

Modifique Program.qs de esta forma:

namespace Qrng {

    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit(); 
        // Put the qubit to superposition.
        H(q);
        // It now has a 50% chance of being measured 0 or 1.
        // Measure the qubit value.
        return M(q);
    }

    operation SampleRandomNumberInRange(max : Int) : Int {
        mutable output = 0; 
        repeat {
            mutable bits = new Result[0]; 
            for idxBit in 1..BitSizeI(max) {
                set bits += [GenerateRandomBit()]; 
            }
            set output = ResultArrayAsInt(bits);
        } until (output <= max);
        return output;
    }
}

Paremos un momento a revisar el nuevo código.

Para calcular el número de bits necesarios para expresar enteros hasta el máximo, la biblioteca Microsoft.Quantum.Math proporciona la función BitSizeI para realizar esta tarea.

La operación SampleRandomNumberInRange usa un bucle repeat para generar números aleatorios hasta que genera uno igual o menor que el máximo.

El bucle for dentro de repeat funciona exactamente igual que un bucle for en otros lenguajes de programación.

En este ejemplo, output y bits son variables mutables. Una variable mutable es aquella que puede cambiar durante el cálculo. Se usa directiva set para cambiar el valor de una variable mutable.

La función ResultArrayAsInt procede de Microsoft.Quantum.Convert library. Esta función convierte la cadena de bits en un entero positivo.

El programa Qrng ahora puede generar números aleatorios. Modifique Program.qs de esta forma para definir el punto de entrada.

namespace Qrng {

    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit();
        // Put the qubit to superposition.
        H(q);
        // It now has a 50% chance of being measured 0 or 1.
        // Measure the qubit value.
        return M(q);
    }

    operation SampleRandomNumberInRange(max : Int) : Int {
        mutable output = 0; 
        repeat {
            mutable bits = new Result[0]; 
            for idxBit in 1..BitSizeI(max) {
                set bits += [GenerateRandomBit()]; 
            }
            set output = ResultArrayAsInt(bits);
        } until (output <= max);
        return output;
    }

    @EntryPoint()
    operation SampleRandomNumber() : Int {
        let max = 50;
        Message($"Sampling a random number between 0 and {max}: ");
        return SampleRandomNumberInRange(max);
    }
}

dotnet build

dotnet run --no-build

import qsharp
from Qrng import SampleQuantumRandomNumberGenerator # We import the 
# quantum operation from the namespace defined in the file Qrng.qs
max = 50 # Here we set the maximum of our range
output = max + 1 # Variable to store the output
while output > max:
    bit_string = [] # We initialize a list to store the bits that
    # will define our random integer
    for i in range(0, max.bit_length()): # We need to call the quantum
        # operation as many times as bits are needed to define the
        # maximum of our range. For example, if max=7 we need 3 bits
        # to generate all the numbers from 0 to 7. 
        bit_string.append(SampleQuantumRandomNumberGenerator.simulate()) 
        # Here we call the quantum operation and store the random bit
        # in the list
    output = int("".join(str(x) for x in bit_string), 2) 
# Transform bit string to integer

print("The random number generated is " + str(output))
# We print the random number

$ python host.py
Preparing Q# environment...
..The random number generated is 42

using System;
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;
using System.Linq;

namespace Qrng
{
    class Driver
    {
        static void Main(string[] args)
        {
            using (var sim = new QuantumSimulator())
            {
                // First we initialize all the variables:
                var bitString = "0"; // To save the bit string
                int max = 50; // The maximum of the range
                int size = Convert.ToInt32(Math.Floor(Math.Log(max, 2.0) + 1));
                // To calculate the amount of needed bits
                int output = max + 1; // Int to store the output
                while (output > max)  // Loop to generate the number
                {
                    bitString = "0"; // Restart the bit string if fails
                    bitString = String.Join("", Enumerable.Range(0, size).Select(idx =>
                        SampleQuantumRandomNumberGenerator.Run(sim).Result == Result.One ? "1" : "0"
                    ));
                    // Generate and concatenate the bits using the Q# operation
                    // Convert the bit string to an integer
                    output = Convert.ToInt32(bitString, 2);
                }
                // Print the result
                Console.WriteLine($"The random number generated is {output}.");
            }
        }
    }
}

$ dotnet run
The random number generated is 42

Pasos siguientes

En el tutorial Exploración del entrelazamiento con Q#, se muestra cómo escribir un programa de Q# que manipula y mide cúbits, y muestra los efectos de la superposición y el entrelazamiento.

En Configuración de Azure Quantum se recomiendan más formas de aprender Q# y programación cuántica.