#VS2017 – Using MResetZ() to reset #Qubits in Q# and Microsoft Quantum Development Kit

Hi!

After an intense week of events, this week it’s my turn to go back to the Quantum Computing studio. In this particular case, to a detail that we have to keep in mind when we work with Q #

When a qubit is in an eigenstate of the measurement operator, i.e., either in |0> or in |1>, we need to reset the Qubit before the end of an operation. Qubits need to be in |0> when they are released, so we have to manually reset the qubit before releasing it using the Z() operation if needed.

Well, let’s take as a basis one in which we initialize a Qubit and apply an operation Hadamard operation as shown in the following code

operation HGate (initial: Result) : (Result)
{
body
{
mutable res = Zero;
using (qubits = Qubit[1])
{
let qubit = qubits[0];
H(qubit);
set res = M (qubit);
if (res == One)
{
X(qubit);
}
}
return (res);
}
}

In line 10 I store the state of the Qubit in the return variable and then on lines 11 to 14 verify that the state of the same is Zero. If not, I need to reset the Qubit to Zero before the end of the operation on line 13.

Well, this code works, and that’s amazing! However when we use the Microsoft Quantum DevKit we also have an operation that allows us to obtain the status of a Qubit and release it in a single operation. This operation is MResetZ(). The same previous code using this operation it is much more nice to read

operation HGateUsingMResetZ (initial: Result) : (Result)
{
body
{
mutable res = Zero;
using (qubits = Qubit[1])
{
let qubit = qubits[0];
H(qubit);
set res = MResetZ(qubit);
}
return (res);
}
}

As we can see, the main change is in line 10 where I assign the state of the Qubit to the return variable and also reset the Qubit to Zero.

Finally, from a Console App I invoke both operations and the result is equal.

I1

GitHub Source Code link

Happy QCoding!

Greetings @ Toronto

El Bruno

References

My Posts

 

#VS2017 – Utilizando MResetZ() para liberar #Qubits en Q# con Microsoft Quantum Development Kit

Hola!

Despues de una semana intensa de eventos, esta semana me toca volver al estudio de Quantum Computing. En este caso en particular, a un detalle que tenemos que tener en cuenta cuando trabajamos con Q#

Cuando modificamos los estados de un Qubit, en mismo puede quedar en |0> o en |1>, Los Qubits necesidad de estar en estado 0> para ser liberados al final de cada operación. Es por ello que hay que restablecer este estado en cada Qubit antes de liberarlo.

Pues bien, tomemos como base una en la que inicializamos un Qubit y aplicamos una operación Hadamard operación como muestra el siguiente código

operation HGate (initial: Result) : (Result)
{
body
{
mutable res = Zero;
using (qubits = Qubit[1])
{
let qubit = qubits[0];
H(qubit);
set res = M (qubit);
if (res == One)
{
X(qubit);
}
}
return (res);
}
}

En la línea 10 almaceno el estado del Qubit en la variable de retorno y luego en las líneas 11 a 14 verifico que el estado del mismo sea Zero. En caso contrario, reseteo el estado Qubit a Zero antes del final de la operación en la línea 13.

Pues bien, este código funciona. Sin embargo, dentro del DevKit tenemos también una operación que nos permite obtener el estado de un Qubit y liberar el mismo en una única operación. Esta operación es MResetZ(). El mismo código anterior utilizando esta operación, se simplifica bastante

operation HGateUsingMResetZ (initial: Result) : (Result)
{
body
{
mutable res = Zero;
using (qubits = Qubit[1])
{
let qubit = qubits[0];
H(qubit);
set res = MResetZ(qubit);
}
return (res);
}
}

Como podemos ver, el principal cambio está en la línea 10 donde asigno el estado del Qubit a la variable de retorno y además reseteo el Qubit a Zero.

Finalmente, desde una ConsoleApp invoco a ambas operaciones y el resultado es igual.

I1

GitHub Source Code link

Happy QCoding!

Saludos @ Toronto

El Bruno

References

My Posts

 

#QuantumDevKit – #Qubit operations in Q#

Clipboard02

Hi!

I’m still at the Microsoft Tech Summit Toronto, so it’s time to share another interesting learned lesson from the Microsoft Quantum Development Kit.

In today’s post, I will talk about the possible operations that we can perform on a Qubit. Well, the post is short:

We can only perform test for identity on Qubits (equality).

That’s the only operation we can do with a Qubit in Q#. Not really, we can use and pass Qubits as parameters between operations (reference model), and if we want to modify the state of them we have to use Q# Qubits .

In example, if we want to measure the status of a Qubit, we can use the M() operation

let measure = M(qubit[0]);

If, we want to change the value of Zero to One, or vice versa in a Qubit, we can use the X() operation

X(qubit[0]);

If, we want to apply a Hadamard transformation to a Qubit, we need to use the H() operation, the syntax would be

H(qubit[0]);

Almost all operations can be found under the namespace [Microsoft Quantum. Primitive]. I strongly advise to spend some time reading and understanding how quantum mechanics works before you start working with this type of gates (Pauli Gates). Hey, but this is material for other post!

Happy QCoding!

Greetings @ Microsoft Tech Summit

El Bruno

References

Images

#QuantumDevKit – Tipos de operaciones posibles a realizar con #Qubit en Q#

Clipboard02

Buenas!

Sigo en el Microsoft Tech Summit, asi que es momento de soltar otra píldora sobre algo interesantes aprendido de Microsoft Quantum Development Kit. En el post de hoy, hablare sobre las posibles operaciones que podemos realizar sobre un Qubit.

Pues bien, el post es corto:

La única operación permitida que podemos realizar con Qubits es la comparación (equality).

Esa es la única operación que podemos realizar sobre un Qubit con Q#. En realidad, esto no es tan así, podemos pasar Qubits como parámetros entre operaciones (siempre punteros fijos al mismo objeto), y si queremos modificar el estado de los mismos tenemos que utilizar operaciones propias de Q#.

Por ejemplo si queremos medir el estado de un Qubit, podemos utilizar la operación M()

let measure = M(qubit[0]);

Si, queremos cambiar el valor de zero a uno o viceversa en un Qubit, podemos utilizar la operación X()

X(qubit[0]);

Si, en cambio, queremos aplicar una transformación Hadamard a un Qubit, la operación es H() y la sintaxis seria

H(qubit[0]);

Casi todas las operaciones se pueden encontrar en [Microsoft.Quantum.Primitive]. Personalmente aconsejo leer y comprender un poco sobre cómo funcionan los conceptos de mecánica cuántica antes de comenzar a trabajar con este tipo de compuertas (Pauli Gates)

Happy QCoding!

Saludos @ Microsoft Tech Summit

El Bruno

References

Images

#Quantum – Information about Simulators on Microsoft Quantum Development Kit (Do you have 16 TB RAM?)

36626328074_f9372acb8f_b

Hi!

Today is Microsoft Tech Summit Day in Toronto, so I will write a quick post about simulators on Microsoft Quantum Development Kit.

I’m sure you already downloaded and installed he tools to work with Q#. So you see that when we created a Q# project, we can see that we have a Q# file and another file in a standard programming language, for example, C#. The approach Microsoft has taken in this case is based on a coprocessor scheme. It is very similar to how a GPU or a FPGA works. Once a GPU is programmed, we can call that code from external environments, like a CPU.

We still don’t have access to Quantum Computers (sad emoticon here), however Microsoft Quantum Development Kit allows us to have a 1st approach, by using simulators to work with Q#. There are two classes in [Microsoft.Quantum. Simulation.Simulators] which allow us to run simulators.

In this scenarios we can work with a finite number of Qubits. The main restriction we have on the amount of Qubits is given by the Hardware characteristics of our development machine.

Clipboard02

Let’s do some numbers. To simulate 30 Qubits, we need 16 GB of RAM. However, if we want to add a new single Qubit, I mean work with 31 Qubits, we have to duplicate the RAM: 32 GB of RAM. If we move to the order of 40 Qubits, we have to think about 16 of RAM. That’s why, One of the simulator’s options is to use Azure’s ability for simulations that require 40 Qubits or more.

Finally, I have to comment that, Q# allows us to have a high level of abstraction to work with Quantum Computing models. And, while at this time we use simulators for the execution of the Q# algorithms, in the near future we will be able to execute these algorithms directly in a Quantum Computer.

Happy QCoding!

Greetings @ Microsoft Tech Summit

El Bruno

References

Images

#Quantum – Capacidades e información de los emuladores en Microsoft Quantum Development Kit (tienes 16TB de RAM?)

36626328074_f9372acb8f_b

Buenas!

Hoy es día de Microsoft Tech Summit en Toronto, así que aprovechare para dejar un par de datos sobre los emuladores de Microsoft Quantum Development Kit.

Cuando creamos un proyecto de Q#, podemos ver que en el mismo tenemos un archivo en el Q # y el otro en un lenguaje de programación estándar, por ejemplo, C#. El enfoque que ha tomado Microsoft en este caso está basado en un esquema de coprocesador. Es muy parecido a cómo se programa una GPU o FPGA. Una vez programadas, podemos llamar ese código desde entornos externos, como una CPU.

Como todavía no tenemos acceso a Quantum Computers físicos, Microsoft Quantum Development Kit nos permite utilizar emuladores para trabajar con Q#. Hay dos clases en [Microsoft.Quantum.Simulation.Simulators] que nos permiten ejecutar emuladores, donde podemos trabajar con un numero finito de Qubits. La principal restricción que tenemos sobre la cantidad de Qubits esta dada por las características de Hardware del equipo de desarrollo.

Clipboard02

Así para simular 30 Qubits, necesitamos 16 GB de RAM. Sin embargo, si queremos agregar un nuevo Qubit, es decir trabajar con 31 Qubits tenemos que duplicar la RAM: 32 GB de RAM. Si hablamos de 40 Qubits, tenemos que pensar en 16TB de RAM. Es por esto que, una de las opciones del simulador es utilizar la capacidad de Azure para las simulaciones que requieran 40 Qubits o más.

Por último, tengo que comentar que, Q# nos permite tener un nivel abstracción alto para trabajar con modelos de Quantum Computing. Y, si bien, en este momento utilizamos emuladores para la ejecución de los algoritmos que creamos en Q#, en un futuro cercano podremos ejecutar estos algoritmos directamente en una Quantum Computer.

Happy QCoding!

Saludos @ Microsoft Tech Summit

El Bruno

References

Images

#VS2017 – Hello QWorld using Microsoft #Quantum Development Kit (fix to build the project) [Updated]

Hi!

Today is a special day, from this moment on, 98% of what I learned at the university is no longer useful for me. I will no longer use binary states in my computing devices, now is time to work with Quantum States.

In fact, there is still a long way to make this a reality. However, now we can start to learn some of the basis of Quantum Computing using Visual Studio 2017. The name of the language also gives honor to the elements that we already know: Q# (Q Sharp).

Note: I know, surely some freak will say that the IDE is very heavy, slow, etc. The answer is always: your opinion is important I am very interested, please tell me more!

So, now we can download Microsoft Quantum Development Kit and create our first [Hello QWorld] to understand the new logic gates model, how to work with Qubits, and much more of the exciting world of quantum Computing.

The Microsoft Quantum DevKit we have an excellent step by step to build a Console App which allows us to work with 2 Qubits and also show the entaglement between them. Well, the 1st steps are very encouraging.

We start installing a package to have the Q# DevKit in Visual Studio 2017

I1

Then we will be able to create Q # applications, as well as libraries and test projects.

I2

And that’s it, this is the end of the fun, it’s fixing configuration error time! We have a very good looking error when trying to build the project:

I4

This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is ..\packages\Microsoft.Quantum.Development.Kit.0.1.1712.901-preview\build\Microsoft.Quantum.Development.Kit.props

[Update: Microsoft Quantum have already published the packages in Nuget.org, so the build will work fine the 1st time. https://www.nuget.org/packages?q=Microsoft.Quantum]

I first thought that this was related to the NuGet packages, maybe these two were not the right ones. The project template of Q # adds these 2 packages

  • Microsoft.Quantum.Canon
  • Microsoft.Quantum.Development.Kit

I3

I ended up spending a lot of time thinking that the error was that these packages were not available in NuGet. (When I write this both packages are still not available)

So, I took some smart time and I read the error. The problem is that the project can not process any of the Q# compilation targets. If you wonder what imaginary beat are related to the Q# compilation targets? Let me tell you that the Q# source code files uses an .qs extension. and are processed with a special compiler. (A Quantum compiler!)

I5

Let me get back to my story, in every step I lose the thread. The problem is that the project that is created can not find any of the libraries or targets of Microsoft.Quantun. And since they are not yet published in nuget.org, it’s time to fix this in the old fashion way.

If we edit the project file of the Q# App, we will see that the location where the Microsoft.Quantum.* elements are located. is  [..\packages\Microsoft.Quantum…]

I6

However, the project template adds the [packages\Microsoft.Quantum…] folder inside the project folder.

I7

You can imagine the solution, copy/move the folder [packages] to the top folder of the project. Now you can compile your project and go ahead with the tutorial!

I8

In next posts I will write a little bit about the capabilities of the Microsoft Quantum Development Kit. Although the first thing was to have the ability to finish the Hello Q World tutorial.

Happy QCoding!

Greetings @ Burlington

El Bruno

References

#VS2017 – 1er Hola QMundo con Microsoft #Quantum Development Kit (fix para que funcione) [Updated]

Buenas!

Hoy es un día especial, a partir de este momento el 98% de lo aprendido en la Universidad deja de ser útil. La informática deja de depender de unos y ceros y pasamos a trabajar con estados quánticos. En realidad, todavía falta mucho para que esto sea una realidad, pero ya podemos ir aprendiendo un poco de computación quántica utilizando Visual Studio 2017. El nombre del lenguaje además hace honor a los elementos que ya conocemos: Q# (Q Sharp).

Nota: ya lo sé, seguramente algún frikazo dirá que el IDE es muy pesado, que tarda mucho, etc. La respuesta es la de siempre: tu opinión me interesa mucho, ¡por favor cuéntame más!

Retomo, desde hoy ya podemos descargar Microsoft Quantum Development Kit y crear nuestro primer [Hello QWorld] para comprender los nuevos modelos de compuertas logicas, la forma de trabajo con Qubits, y mucho más del apasionante mundo de Quantum Computing.

En las referencias del Quantum DevKit tenemos un excelente paso a paso para construir una app de Consola que nos permita trabajar con 2 Qubits y además mostrar el entaglement entre ellos.

Importante: he decidido no traducir los términos de Quantum Computing para no inventarme palabras que no existen.

Pues bien, los 1ros pasos son muy alentadores. Comenzamos instalando un paquete para tener el DevKit en Visual Studio 2017

I1

Luego ya podremos crear aplicaciones Q#, además de libraries y test Projects.

I2

Y hasta aquí duro la alegría con el tutorial. Llega el momento de las ostias, al momento de intentar compilar tenemos un error de los bonitos:

I4

This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is ..\packages\Microsoft.Quantum.Development.Kit.0.1.1712.901-preview\build\Microsoft.Quantum.Development.Kit.props

[Update: Microsoft Quantum ha publicado los paquetes en Nuget.org, la primera Build descargara los elementos necesarios sin el error. https://www.nuget.org/packages?q=Microsoft.Quantum]

Lo primero que pensé era que los paquetes NuGet no eran los correctos. El template de proyectos de Q# agrega estos 2 paquetes

  • Microsoft.Quantum.Canon
  • Microsoft.Quantum.Development.Kit

I3

Es más, termine dedicando mucho tiempo pensando que el error era que estos paquetes no estaban disponibles en NuGet.

Luego me tome un segundo y lei el error, el problema esta en que el proyecto no puede procesar alguno de los targets de compilación de Q#. ¿Si te preguntas que extraño ser del infierno son los Q# Compilation Targets? solo hay que ver que los archivos de código de Q#, con extension [.qs], se procesan con un compilador especial.

I5

Vuelvo a retomar el post, que en cada paso pierdo el hilo. El problema esta en que el proyecto que se crea no puede encontrar ninguna de las librerias ni targets de Microsoft.Quantun. Y como todavía no están publicados en nuget.org, toca arreglar esto a mano.

Si editamos el archivo de proyecto de la App Q#, veremos que la ubicación en la que se ubican los elementos de Microsoft.Quantum.* es [..\packages\Microsoft.Quantum…]

I6

Si embargo la plantilla de proyecto agrega la carpeta [packages\Microsoft.Quantum…] dentro del folder del proyecto.

I7

Ya te imaginas la solución, copia / mueve la carpeta [packages] al folder superior del proyecto. ¡Ahora ya puedes compilar tu proyecto y seguir adelante con el tutorial!

I8

En próximos posts hablare un poco sobre las capacidades del Microsoft Quantum Development Kit. Aunque lo primero era tener la capacidad de terminar el Hello Q.

Happy QCoding!

Saludos @ Burlington

El Bruno

References

#Opinion – More information about the Microsoft bet in Quantum Computing

Hello!

After yesterday’s announcement where Microsoft made public its commitment to Quantum Computing, it is time to review a little more details of it. We start from the base that QC is not something new, today, there are other greats like IBM that already offer us a service of QC in cloud mode and even we can test machines with 5 Qubits of capacity and to program them for free (see references)

Well, yesterday in a waste of IQ during the KeyNote of Microsoft Ignite, Satya Nadella invited a panel to discuss and talk about Quantum Computing to Michael Freedman, Microsoft technical fellow, Station Q; Leo Kouwenhoven, Charlie Marcus, Microsoft principal researchers, Qfab; and Krysta Svore, Microsoft principal researcher, QuArC Software. Here you go …

I1

Each one of the people on the panel deals with different topics, although the central axis is the approach that Microsoft is taking with respect to the Qubits. Michael Freedman was talking about the special topology they’ve designed for this new Quantum Computer.

Remember that one of the most important problems that this presents, is to be able to “read accurately” the values of each Qubit. For this, the QC must work with temperatures close to absolute zero. But I will not go this way, that I have much to study and learn about it.

Update: Thanks to Eduard notes, I’ve updated the numbers. In this context, temperatures close to absolute zero means 0.015 Kelvin degrees, which can be translated into -273 Celsius degrees or -459 Fahrenheit degrees.

What if I am interested is the future where we will program on Quantum computers, here we must start from scratch. A very simple analogy to understand is this:

I guess many programmers know that the basis of a computer is 0 and 1. Many programmers are familiar with programming languages such as JavaScript, C # or Java. However, only a few understand and can explain how we came from the zero and ones layer to C# code. There are many levels of abstraction in between and so it seems to me, the programming of Qubits will be almost at the lower levels.

From what we see in the Screenshots that have been used, we are talking about programming using logical gates like AND, OR, XOR, etc. Added to that, these are not conventional operations, because we have to take into account the superposition and the  entanglement which involves the work with Qubits. This is back to the grassroots, and I think I’ll thank Ramon, when I made it down to the chip programming level in Arduino a few years ago.

Important: A greater amount of Qubits in a quantum processor, the higher the level of errors that we can find. Today, one of the great barriers, is the way to work with a high number of Qubits and a low rate of errors.

I’ll go back to the main topic, I am easily distracted about this topics. At the end of the panel. Krysta was speaking about what we can expect as programmers in the near future.

  • Complete integration in Visual Studio. This is a great one for developers. Learning a new technology/platform or language in a known IDE always makes the challenge more bearable.
  • Debugging capabilities. That is, to be able to see and analyze the step by step of the states of each Qubits while the same ones change. This seems somewhat trivial, however, being able to debug simple sentences step by step, is usually a great help to understand how quantum computing works. We’ll see what we find inside the IDE. Personally, the way in which IBM has embodied it in its online environment, is quite didactic.
  • Of course, the classics, Intellisense, auto-completion, and more. We’re talking about a new specific domain translated into a programming language. All we can take advantage of the IDE, will be welcome.
  • And finally, a simulator. It will allow us to test our algorithms without the need to have a Quantum Computer by hand. So they comment, we will have 2 modes to use the same
  • Local mode where we can simulate 30 Qubits and we will need a nice 32 GB of RAM.
  • And also in cloud mode, where we can upload the configuration to 40Qubits.

The important thing here is that, the jump from 30 Qubits to 40 Qubits is not trivial, it should be remembered that the ability to handle states with Qubits grows exponentially. And 40 Qubits is much more than “only 10 Qubits more”

Well, I recommend you see the KeyNote of Ignite and give a look at the references.

Happy Quantum Coding!

Greetings @ Toronto

El Bruno

References

#Opinion – Mas detalles sobre Microsoft en Quantum Computing

Hola!

Después del anuncio de ayer donde Microsoft hizo pública su apuesta por Quantum Computing, es momento de revisar un poco más a fondo los detalles de la misma. Partimos de la base que QC no es algo nuevo, hoy por hoy, hay otros grandes como IBM que ya nos ofrecen un servicio de QC en modo cloud e inclusive podemos probar maquinas con 5 Qubits de capacidad y programar las mismas de forma gratuita (ver referencias).

Pues bien, ayer en un derroche de IQ durante el KeyNote de Microsoft Ignite, Satya Nadella invito a un panel para discutir y hablar sobre Quantum Computing a Michael Freedman, Microsoft technical fellow, Station Q; Leo Kouwenhoven, Charlie Marcus, Microsoft principal researchers, Qfab; and Krysta Svore, Microsoft principal researcher, QuArC Software. Ahí es nada.

I1

Cada uno trato temas diferentes, aunque el eje central es el enfoque que Microsoft está tomando con respecto a los Qubits. Michael Freedman hablo sobre la topología especial que han diseñado para este nuevo ordenador cuántico. Recordemos que uno de los problemas más importantes que esto presenta, es poder “leer con exactitud” los valores de cada Qubit. Para esto, se trabaja con temperaturas cercanas a 0 grados Kelvin. Pero no ire por este camino, que tengo mucho que estudiar y aprender al respecto, antes de poder escribir de manera simple.

Update: Gracias al aporte y correcion de Eduard, he modificado los numeros. Por un lado, la temperatura que se pone como referencia es 0.015 grados Kelvin, que es aproximadamente -273 grados Celsius o -459 grados Fahrenheit.

Lo que si me interesa es el futuro donde programaremos sobre Quantum Computers, aquí deberemos comenzar desde cero. Una analogía muy simple de comprender es la siguiente:

Supongo que muchos programadores saben que la base de un ordenador son 0 y 1. Muchos programadores conocen lenguajes de programación como JavaScript, C# o Java. Sin embargo, solo unos pocos comprenden y pueden explicar cómo llegamos desde la capa de ceros y unos hasta el código C#. Hay muchos niveles de abstracción en medio y por lo que me parece, la programación de Qubits será casi en los niveles inferiores.

Por lo que vemos en los screenshots que han usado, estamos hablando de programar utilizando compuertas AND, OR, XOR, etc. Sumado a que no son operaciones convencionales, ya que tenemos que tener en cuenta la superposición y el mallado que conlleva el trabajo con Qubits. Esto es volver a las bases, y creo que agradeceré a Ramon, cuando me hizo bajar a nivel de programación de chips en Arduino hace unos años.

Importante: A mayor cantidad de Qubits en un procesador cuántico, mayor el nivel de errores que podemos encontrar. Hoy por hoy, una de las grandes barreras, está en la forma de lograr trabajar con un número alto de Qubits y con una tasa baja de errores.

Retomo el hilo que me voy liando sobre la marcha. Al final del panel Krysta hablo sobre lo que podemos esperar a nivel programadores en un futuro cercano.

  • Integración completa con Visual Studio. Esto es un puntazo y de los buenos. Aprender una nueva tecnología / plataforma o lenguaje en un IDE conocido siempre hace más llevadero el desafío.
  • Tener capacidad de depuración (Debugging). Es decir, poder ver y analizar el paso a paso de los estados de cada Qubits mientras los mismos cambian. Esto parece algo trivial, sin embargo, el hecho de poder depurar sentencias simples paso a paso, suele ser una gran ayuda para comprender como funciona la computación cuántica. Veremos que nos encontramos dentro del IDE. Personalmente, la forma en la que IBM lo ha plasmado en su entorno online, es bastante didáctica.
  • Por supuesto, los clásicos, Intellisense, autocompletado, y más. Estamos hablando de un nuevo dominio especifico traducido en un lenguaje de programación. Todo lo que podamos aprovechar del IDE, será bienvenido.
  • Y finalmente, un simulador. El mismo nos permitirá probar nuestros algoritmos sin la necesidad de tener un Quantum Computer a mano. Por lo que comentan, tendremos 2 modos para utilizar el mismo
    • Modo local donde podremos simular 30 Qubits y necesitaremos unos agradables 32GB de RAM.
    • Y también en modo cloud, donde podremos subir la configuración hasta 40Qubits.

Lo importante aquí es que, el salto de 30 Qubits a 40 Qubits no es algo trivial, conviene recordar que la capacidad de manejar estados con Qubits crece de manera exponencial. Y 40 Qubits es mucho más que “solo 10 Qubits más”

Pues bien, os recomiendo ver el KeyNote de Ignite y darle un vistazo a las referencias.

Saludos @ Toronto

El Bruno

References