Exercício - Crie diferentes estados de superposição com Q#
Nas unidades anteriores, você aprendeu sobre sobreposição e notação Dirac. Isso é teoria suficiente por enquanto! Vamos explorar a superposição em Q# escrevendo algum código.
Nesta unidade, você criará superposição quântica e mergulhará em probabilidades com Q# usando a DumpMachine
função. A DumpMachine
função despeja informações sobre o status atual do sistema quântico no ponto em que é chamada.
Criar um novo arquivo Q#
- Abra o Visual Studio Code.
- No Visual Studio Code, selecione Arquivo > Novo Arquivo de Texto e salve o arquivo como Main.qs.
- Selecione Exibir -> Paleta de Comandos e digite Q#: Definir o perfil de destino do Azure Quantum QIR. Prima Enter.
- Selecione Q#: Sem restrições.
Introdução à sobreposição
Vamos começar com um programa simples que gera um bit aleatório usando um qubit em superposição. Você usará a DumpMachine
função para ver o estado do qubit em diferentes pontos do programa.
Adicione o seguinte código ao arquivo Main.qs :
import Microsoft.Quantum.Diagnostics.*; operation Main() : Result { use q = Qubit(); Message("Initialized qubit:"); DumpMachine(); // First dump Message(" "); H(q); Message("Qubit after applying H:"); DumpMachine(); // Second dump Message(" "); let randomBit = M(q); Message("Qubit after the measurement:"); DumpMachine(); // Third dump Message(" "); Reset(q); Message("Qubit after resetting:"); DumpMachine(); // Fourth dump Message(" "); return randomBit; }
Aqui, chama
DumpMachine
quatro vezes:- Depois de o qubit ser alocado.
- Depois de colocar o qubit em superposição.
- Depois de medir o estado do qubit.
- Depois de redefinir o qubit.
A operação
MResetZ
é dividida em duas operações,M
eReset
. Fá-lo porque deseja inspecionar o estado após a medição.Para executar o programa no simulador integrado, clique em Executar acima da
Main
operação ou pressione Ctrl+F5. Sua saída aparecerá no console de depuração.A função
DumpMachine
cria uma tabela de informações que descrevem o estado do registo de qubit. Especificamente, indica a amplitude de probabilidade, a probabilidade e a fase em radianos para cada estado de base.No final do programa, obtém um resultado de
Zero
ouOne
. Vamos examinar cada passo.Qubit inicializado: cada qubit alocado com a
use
instrução começa no estado $|0\rangle$. Assim,DumpMachine
produz as informações que correspondem a um registo de qubit único no estado $|0\rangle$.Initialized qubit: DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |0⟩ | 1.0000+0.0000𝑖 | 100.0000% | 0.0000
Qubit depois de aplicar H: Depois de aplicar
H
, preparamos o qubit no estado de superposição $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.Qubit after applying H: DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |0⟩ | 0.7071+0.0000𝑖 | 50.0000% | 0.0000 |1⟩ | 0.7071+0.0000𝑖 | 50.0000% | 0.0000
Qubit após a medição: Depois medimos e armazenamos o resultado, que pode ser um
Zero
ouOne
. Por exemplo, se o estado resultante forOne
, o estado dos registradores colapsa para $|1\rangle$ e não está mais em superposição.Qubit after the measurement: DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |1⟩ | 1.0000+0.0000𝑖 | 100.0000% | 0.0000
Qubit após redefinição: A operação
Reset
redefine o qubit para o estado $|0\rangle$. Lembre-se de que, para qualquer operação Q#, tem sempre de deixar os qubits utilizados no estado $|0\rangle$, para que possam ser utilizados por outras operações.Qubit after resetting: DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |0⟩ | 1.0000+0.0000𝑖 | 100.0000% | 0.0000
Nota
Suas saídas podem diferir porque o gerador de números aleatórios é probabilístico. As probabilidades dos resultados não são deterministas.
Explore outros tipos de estados de superposição
Agora que você sabe como inspecionar o estado de um registro, você pode ver mais operações que modificam o estado de seus qubits e os colocam em uma superposição.
O gerador de números aleatórios atual produz Zero
ou One
com uma probabilidade de 50%. Vejamos um segundo exemplo que gera números aleatórios com uma probabilidade diferente.
Gerador de bits aleatórios distorcido
Suponha que você queira criar um gerador de bits aleatório que esteja enviesado, ou seja, a probabilidade de obter Zero
é diferente da probabilidade de obter One
.
Por exemplo, você quer o resultado Zero
com probabilidade $P$ e o resultado One
com probabilidade $1-P$. Aqui está um estado de qubit válido que produz um gerador de bits aleatório:
$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1-P}|1\rangle$$
Aqui, $\alpha=\sqrt{P}$ e $\beta=\sqrt{1-P}$ são as amplitudes dos estados base $|0\rangle$ e $|1\rangle$, respectivamente.
Esse estado pode ser obtido aplicando sequencialmente o operador $R_y(2\arccos\sqrt{P})$ a um qubit no estado $|0\rangle.$ Você pode obter esse resultado em Q# usando a operação Ry na biblioteca Standard.
Gorjeta
Para saber mais sobre a matemática por trás das operações de qubit único, confira o tutorial Single-Qubit Gates no Quantum Katas.
Modifique Main.qs como o exemplo a seguir e salve o arquivo. Este exemplo escolhe $\alpha$ para ser cerca de $\frac13$.
import Microsoft.Quantum.Diagnostics.*; import Microsoft.Quantum.Math.*; operation Main() : Result { use q = Qubit(); let P = 0.333333; // P is 1/3 Ry(2.0 * ArcCos(Sqrt(P)), q); Message("The qubit is in the desired state."); Message(""); DumpMachine(); // Dump the state of the qubit Message(""); Message("Your skewed random bit is:"); let skewedrandomBit = M(q); Reset(q); return skewedrandomBit; }
Para executar o programa no simulador integrado, clique em Executar acima da
Main
operação ou pressione Ctrl+F5. Sua saída aparecerá no console de depuração.Pode ver como
DumpMachine
mostra o estado esperado depois de aplicar as operações e apresenta as probabilidades associadas. Observe que a probabilidade de obterZero
é de cerca de 33,33% e a probabilidade de obterOne
é de cerca de 66,67%. Assim, o gerador de bits aleatório é enviesado.The qubit is in the desired state. DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |0⟩ | 0.5773+0.0000𝑖 | 33.3333% | 0.0000 |1⟩ | 0.8165+0.0000𝑖 | 66.6667% | 0.0000 Your skewed random bit is: Result: "One"
Nota
Sua saída pode diferir porque o gerador de números aleatórios é probabilístico. As probabilidades dos resultados não são deterministas.
Sobreposição de vários qubits
Agora, vamos explorar as sobreposições de um registo que inclui muitos qubits. Por exemplo se o seu registo consistir em três qubits, tem oito estados de base.
$$|000\rangle,|001\rangle,|010\rangle,|011\rangle,|100\rangle,|101\rangle, |110\rangle,|111\rangle $$
Por isso, pode expressar um estado de três qubits arbitrário como:
$$|\psi\rangle=\alpha_0|000\rangle+\alpha_1|001\rangle+\alpha_2|010\rangle+\alpha_3|011\rangle+\alpha_4|100\rangle+\alpha_5|101\rangle+\alpha_6 |110\rangle+\alpha_7|111\rangle$$
Aqui, $\alpha_i$ são números complexos que satisfazem $\sum|\alpha_i|^2=1$.
Por exemplo, você pode colocar qubits em uma superposição uniforme aplicando H
a cada qubit. Pode utilizar esta sobreposição uniforme para criar uma versão diferente do gerador quântico de números aleatórios que gera números de três bits ao medir três qubits na sobreposição em vez de medir um qubit três vezes.
Base | Número |
---|---|
$\ket{000}$ | 0 |
$\ket{001}$ | 1 |
$\ket{010}$ | 2 |
$\ket{011}$ | 3 |
$\ket{100}$ | 4 |
$\ket{101}$ | 5 |
$\ket{110}$ | 6 |
$\ket{111}$ | 7 |
Modifique Main.qs como o exemplo a seguir e salve o arquivo.
import Microsoft.Quantum.Diagnostics.*; import Microsoft.Quantum.Math.*; import Microsoft.Quantum.Convert.*; import Microsoft.Quantum.Arrays.*; operation Main() : Int { use qubits = Qubit[3]; ApplyToEach(H, qubits); Message("The qubit register in a uniform superposition: "); DumpMachine(); let result = ForEach(M, qubits); Message("Measuring the qubits collapses the superposition to a basis state."); DumpMachine(); ResetAll(qubits); return BoolArrayAsInt(ResultArrayAsBoolArray(result)); }
Aqui, você vê três conceitos:
- A variável
qubits
representa, agora, uma matriz deQubit
com um comprimento de três. - As operações
ApplyToEach
eForEach
são úteis para medir e agir em vários qubits, e eles usam menos código. As bibliotecas de Q# oferecem muitos tipos de operações e funções diferentes que tornam a escrita de programas quânticos mais eficiente. - As
BoolArrayAsInt
funções eResultArrayAsBoolArray
da biblioteca transformam aMicrosoft.Quantum.Convert
matriz bináriaResult
que é retornada porForEach(M, qubits)
em um inteiro.
- A variável
Para executar o programa, clique em Executar acima da
Main
operação ou pressione Ctrl+F5. Sua saída aparecerá no console de depuração.Ao utilizar
DumpMachine
, pode ver como o ato de medir os três qubits colapsa o estado do registo para um dos oito estados de base possíveis. Por exemplo, se você obtiver o resultado3
, isso significa que o estado do registro caiu para $|110\rangle$.The qubit register in a uniform superposition: DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |000⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |001⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |010⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |011⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |100⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |101⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |110⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |111⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 Measuring the qubits collapses the superposition to a basis state. DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |110⟩ | 1.0000+0.0000𝑖 | 100.0000% | 0.0000 Result: "3"
Nota
Sua saída pode diferir porque o gerador de números aleatórios é probabilístico. As probabilidades dos resultados não são deterministas.
A operação
ForEach(M, qubit)
mede um qubit de cada vez, colapsando gradualmente o estado. Você também pode despejar os estados intermediários após cada medição. Para fazer isso, modifique Main.qs como o exemplo a seguir e, em seguida, salve o arquivo.import Microsoft.Quantum.Diagnostics.*; import Microsoft.Quantum.Measurement.*; import Microsoft.Quantum.Math.*; import Microsoft.Quantum.Convert.*; operation Main() : Int { use qubits = Qubit[3]; ApplyToEach(H, qubits); Message("The qubit register in a uniform superposition: "); DumpMachine(); mutable results = []; for q in qubits { Message(" "); set results += [M(q)]; DumpMachine(); } Message(" "); Message("Your random number is: "); ResetAll(qubits); return BoolArrayAsInt(ResultArrayAsBoolArray(results)); }
Aqui, utiliza um ciclo
for
para atuar em cada qubit sequencialmente. O Q# tem recursos clássicos de controle de fluxo, comofor
loops eif
instruções, que você pode usar para controlar o fluxo do seu programa.Para executar o programa, clique em Executar na lista de comandos acima da
Main
operação ou pressione Ctrl+F5.Pode ver como cada medição consecutiva altera o estado quântico e, como tal, as probabilidades de obter cada resultado. Por exemplo, se o resultado for o número cinco, você obterá a seguinte saída. Vamos examinar brevemente cada passo:
Preparação do Estado: Depois de aplicar
H
a cada qubit do registo, obtém-se uma sobreposição uniforme.The qubit register in a uniform superposition: DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |000⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |001⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |010⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |011⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |100⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |101⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |110⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000 |111⟩ | 0.3536+0.0000𝑖 | 12.5000% | 0.0000
Primeira medição: Na primeira medição, o resultado foi
One
. Portanto, todas as amplitudes dos estados cujo qubit mais à direita éZero
já não estão presentes. As amplitudes são $|0\rangle=|000\rangle, |2\rangle=|010\rangle, |4\rangle=|100\rangle$ e $|6\rangle= |110\rangle$. O resto das amplitudes aumenta para atender à condição de normalização.DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |001⟩ | 0.5000+0.0000𝑖 | 25.0000% | 0.0000 |011⟩ | 0.5000+0.0000𝑖 | 25.0000% | 0.0000 |101⟩ | 0.5000+0.0000𝑖 | 25.0000% | 0.0000 |111⟩ | 0.5000+0.0000𝑖 | 25.0000% | 0.0000
Segunda medição: Na segunda medição, o resultado foi
Zero
. Portanto, todas as amplitudes dos estados cujo segundo qubit mais à direita (meio) éOne
desaparecem. As amplitudes são $|3\rangle=|011\rangle$ e $|7\rangle=|111\rangle$. O resto das amplitudes aumenta para atender à condição de normalização.DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |001⟩ | 0.7071+0.0000𝑖 | 50.0000% | 0.0000 |101⟩ | 0.7071+0.0000𝑖 | 50.0000% | 0.0000
Terceira medição: Na terceira medição, o resultado foi
One
. Portanto, todas as amplitudes dos estados cujo qubit mais à esquerda estáZero
claro. O único estado compatível é $|5\rangle=|101\rangle$. Este estado obtém uma probabilidade de amplitude de $1$.DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |101⟩ | 1.0000+0.0000𝑖 | 100.0000% | 0.0000 Your random number is: Result: "5"
Nota
Sua saída pode diferir porque o gerador de números aleatórios é probabilístico. As probabilidades dos resultados não são deterministas.