{
"cells": [
{
"cell_type": "markdown",
"id": "4046fd82",
"metadata": {},
"source": [
"---\n",
"title: \"Comece a usar o Qiskit em sala de aula\"\n",
"description: \"Aprenda os conceitos básicos da computação quântica e como executar seu primeiro circuito quântico com o Qiskit.\"\n",
"---\n",
"\n",
"{/* cspell:ignore checkmark ccnot */}\n",
"\n",
"\n",
"\n",
"# Comece a usar o Qiskit em sala de aula\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a84d2a96-7885-4f6c-b34a-f2d386d4e120",
"metadata": {},
"source": [
"Para este módulo do Qiskit in Classrooms, os alunos devem ter um ambiente Python em funcionamento com os seguintes pacotes instalados:\n",
"\n",
"* `qiskit` v2.1.0 ou mais recente\n",
"* `qiskit-ibm-runtime` v0.40.1 ou mais recente\n",
"* `qiskit-aer` v0.17.0 ou mais recente\n",
"* `qiskit.visualization`\n",
"* `numpy`\n",
"* `pylatexenc`\n",
"\n",
"Para configurar e instalar os pacotes acima, consulte o guia [Instalar o Qiskit](/docs/guides/install-qiskit).\n",
"Para executar trabalhos em computadores quânticos reais, os alunos precisarão configurar uma conta no site IBM Quantum® seguindo as etapas do guia [Configurar sua conta IBM Cloud®](/docs/guides/cloud-setup).\n",
"\n",
"Esse módulo foi testado e usou 2 segundos de tempo de QPU em um processador Heron v2. Essa é apenas uma estimativa. Seu uso real pode variar.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d611274c-5988-45b7-98bf-01c57edc0b02",
"metadata": {},
"outputs": [],
"source": [
"# Uncomment and modify this line as needed to install dependencies\n",
"#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'"
]
},
{
"cell_type": "markdown",
"id": "9a7cc00a-e11d-46e7-9737-1ec7a3fa9951",
"metadata": {},
"source": [
"\n",
"\n",
"## Introdução\n",
"\n",
"Nos módulos Qiskit in the Classroom, você terá a oportunidade de usar um computador quântico para explorar vários conceitos em campos adjacentes à computação quântica, como mecânica quântica, ciência da computação, química e muito mais. Este módulo serve como pré-requisito para os outros: ele apresenta os fundamentos da computação quântica e como usar o Qiskit para executar circuitos quânticos.\n",
"\n",
"Primeiro, apresentaremos uma breve visão geral de como funciona um computador clássico e, em seguida, mostraremos como esses conceitos são adaptados para se adequarem ao paradigma da computação quântica. Por fim, mostraremos como reunir esses conceitos para construir e executar seu primeiro circuito quântico.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "742678ad-9e14-4691-bc6f-5900c7f45f9b",
"metadata": {},
"source": [
"\n",
"\n",
"## Computadores clássicos\n",
"\n",
"É provável que você conheça os princípios básicos do funcionamento dos computadores clássicos, mas aqui destacaremos alguns dos principais recursos para que possamos fazer uma comparação com os computadores quânticos.\n",
"\n",
"\n",
"\n",
"### As unidades básicas de informação: bits\n",
"\n",
"Os computadores clássicos processam informações clássicas, e a unidade fundamental das informações clássicas é o *bit*. Um único bit pode armazenar a resposta a uma pergunta do tipo \"sim/não\". Normalmente, representamos os dois estados binários de um bit como \"0\" e \"1\".\n",
"\n",
"\n",
"\n",
"#### Revisão dos números binários\n",
"\n",
"A combinação de bits permite que você armazene mais informações. Por exemplo, se você quiser armazenar um número de 0 a 15, poderá fazê-lo com quatro bits da seguinte forma:\n",
"\n",
"| | | | |\n",
"| :------- | :------: | :-------: | --------: |\n",
"| 0 = 0000 | 4 = 0100 | 8 = 1000 | 12 = 1100 |\n",
"| 1 = 0001 | 5 = 0101 | 9 = 1001 | 13 = 1101 |\n",
"| 2 = 0010 | 6 = 0110 | 10 = 1010 | 14 = 1110 |\n",
"| 3 = 0011 | 7 = 0111 | 11 = 1011 | 15 = 1111 |\n",
"\n",
"Em geral, para converter de um número binário de $N$ bits para um número familiar, base-10, você multiplica o bit menos significativo (mais à direita) por $2^0 = 1$, o próximo bit à esquerda por $2^1 = 2$, depois o próximo por $2^2 = 4$, e assim por diante, até chegar ao mais significativo (bit mais à esquerda), que você multiplica $2^{N-1}$.\n",
"\n",
"Portanto, isso significa que $N$ bits podem estar em um dos $2^N$ diferentes estados possíveis.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"De quantos bits você precisaria para representar o número 86? Escreva o bitstring que codifica esse número em binário.\n",
"\n",
"\n",
" \n",
" Lembre-se de que $N$ bits permite que você represente os números $0$ a $2^N - 1$, portanto, usando seis bits, chegaríamos a $2^6 - 1 = 63$. Isso não é suficiente. Adicionamos mais um bit para chegar a $2^7 - 1 = 127$. Agora vamos dividir 86 em potências de 2:\n",
"\n",
" $$\n",
" \\begin{aligned}\n",
" 86 &= 64 + 16 + 4 + 2 \\\\\n",
" &= 2^6 \\times 1 + 2^5 \\times 0 + 2^4 \\times 1 + 2^3 \\times 0 + 2^2 \\times 1 + 2^1 \\times 1 + 2^0 \\times 0 \\\\\n",
" &= 1010110\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"### Operações fundamentais: portas\n",
"\n",
"Agora, um computador precisa ser capaz de *fazer* algo com os bits para, bem, computar. As portas binárias são as operações que formam os blocos de construção fundamentais de todos os algoritmos e códigos mais complicados.\n",
"\n",
"\n",
"\n",
"### Porta de bit único:\n",
"\n",
"\n",
"\n",
"#### NÃO\n",
"\n",
"Quando você tem apenas um bit, só há uma maneira de transformar seu estado: inverter o estado de 0 para 1 ou de 1 para 0. Chamamos isso de porta \"NOT\". O efeito dessa porta - e o restante das portas que discutiremos a seguir - pode ser representado em uma chamada \"tabela verdade\", com colunas para os estados de entrada e saída dos qubits. A tabela verdade para a porta NOT é:\n",
"\n",
"| Entrada | Saída |\n",
"| :------ | ----: |\n",
"| 0 | 1 |\n",
"| 1 | 0 |\n",
"\n",
"\n",
"\n",
"### Portas multibits:\n",
"\n",
"\n",
"\n",
"#### E\n",
"\n",
"AND é uma porta de dois bits que recebe dois bits de entrada e gera um único bit de saída. Ele produz 1 se ambos os bits de entrada forem 1 e 0 caso contrário:\n",
"\n",
"| Entrada | Saída |\n",
"| :------ | ----: |\n",
"| 00 | 0 |\n",
"| 01 | 0 |\n",
"| 22 | 0 |\n",
"| 11 | 1 |\n",
"\n",
"\n",
"\n",
"#### OU\n",
"\n",
"OR é outra porta de dois bits com um único bit de saída. Ele produz 1 se *qualquer um dos* bits for 1:\n",
"\n",
"| Entrada | Saída |\n",
"| :------ | ----: |\n",
"| 00 | 0 |\n",
"| 01 | 1 |\n",
"| 22 | 1 |\n",
"| 11 | 1 |\n",
"\n",
"\n",
"\n",
"#### XOR\n",
"\n",
"XOR significa \"exclusive OR\" (OU exclusivo) e é como a porta OR, mas produz 1 se *apenas um* dos bits de entrada for 1. O resultado será 0 se ambos forem 1 ou 0:\n",
"\n",
"| Entrada | Saída |\n",
"| :------ | ----: |\n",
"| 00 | 0 |\n",
"| 01 | 1 |\n",
"| 22 | 1 |\n",
"| 11 | 0 |\n",
"\n",
"\n",
"\n",
"### Medidas:\n",
"\n",
"Normalmente, ao aprender sobre computação clássica, não se dá muita atenção ao processo de leitura do estado dos bits. Isso ocorre porque ele não é muito complexo do ponto de vista conceitual. Você pode medir os bits a qualquer momento antes, durante ou depois de um cálculo, e isso não afeta o resultado. Esse não é o caso da computação quântica, como discutiremos a seguir.\n",
"\n",
"\n",
"\n",
"### Circuitos:\n",
"\n",
"Ao combinar as portas acima, você pode fazer qualquer tipo de operação que desejar em um computador. Vamos dar um exemplo simples: Usando as portas AND e XOR, você pode construir o circuito de meio-somador, que calcula a soma de dois bits. Isso é representado em um diagrama de circuito lógico, em que os fios representam os bits e as portas que operam nos bits são mostradas como símbolos nos fios correspondentes:\n",
"\n",
"\n",
"\n",
"Assim, os dois bits são copiados e alimentados por uma porta AND e uma porta XOR. O resultado da porta XOR é o \"bit de soma\" (S), que permanece no lugar das unidades do número binário, e o resultado da porta AND é o \"bit de transporte\" (C), que é o valor do próximo dígito mais significativo do número binário. Aqui está a tabela de verdade:\n",
"\n",
"| $A$ | $B$ | Soma ( $A \\oplus B$ ) | Carry ( $A \\wedge B$ ) |\n",
"| --- | --- | --------------------- | ---------------------- |\n",
"| 0 | 0 | 0 | 0 |\n",
"| 0 | 1 | 1 | 0 |\n",
"| 1 | 0 | 1 | 0 |\n",
"| 1 | 1 | 0 | 1 |\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"Verifique se a tabela verdade acima produz a solução correta para um circuito somador. Ou seja, para cada uma das quatro opções de A e B, verifique se $A+B=S+2 \\times C$.\n",
"\n",
"\n",
" \n",
" $$\n",
" \\begin{aligned}\n",
" 0+0 &= 0+0 = 0 ~\\checkmark \\\\\n",
" 0+1 &= 1+0 = 1 ~\\checkmark \\\\\n",
" 1+0 &= 1+0 = 1 ~\\checkmark \\\\\n",
" 1+1 &= 0+2 = 2 ~\\checkmark \\\\\n",
" \\end{aligned}\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a324a959-5edc-4aaf-91ad-6bef9ab7c435",
"metadata": {},
"source": [
"\n",
"\n",
"## Computadores quânticos\n",
"\n",
"\n",
"\n",
"### Bits $\\rightarrow$ qubits\n",
"\n",
"Assim como os bits são as unidades fundamentais da informação clássica, os bits *quânticos*, ou \"qubits\", são as unidades fundamentais da informação quântica. Assim como o bit clássico, o estado de um qubit pode ser 0 ou 1, que normalmente denotamos como $\\vert 0\\rangle$ e $\\vert 1\\rangle$. Mas, diferentemente do bit clássico, um bit quântico também pode estar em uma *superposição* do estado $\\vert 0\\rangle$ e do estado $\\vert 1\\rangle$ ao mesmo tempo. Em geral, um qubit pode estar em qualquer estado $\\vert \\psi\\rangle$ da forma:\n",
"\n",
"$$\n",
"\\vert \\psi\\rangle = c_0 \\vert 0\\rangle + c_1 \\vert 1\\rangle\n",
"$$\n",
"\n",
"em que $c_0$ e $c_1$ são amplitudes complexas com $\\vert c_0 \\vert ^2+\\vert c_1\\vert ^2=1$.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "11563bfb-93d4-4a6a-9bd9-b52665ab4517",
"metadata": {},
"source": [
"\n",
"\n",
"#### A fase quântica\n",
"\n",
"Como $c_0$ e $c_1$ são complexos, cada um deles pode ser escrito como $c_i = \\vert c_i\\vert e^{i\\phi_i}$, onde $\\phi_i$ é chamado de *fase*. Se multiplicarmos todo o estado pelo mesmo fator de fase geral, nada muda fisicamente - isso é chamado de fase global e não tem consequências observáveis.\n",
"\n",
"Por esse motivo, é convencional \"fatorar\" $e^{i\\phi_0}$, dando:\n",
"\n",
"$\\vert \\psi\\rangle = \\vert c_0\\vert \\vert 0\\rangle + \\vert c_1\\vert e^{i\\phi}\\vert 1\\rangle$\n",
"\n",
"em que $\\phi = \\phi_1-\\phi_0$ é a fase *relativa* do estado quântico, que *tem* consequências observáveis.\n",
"\n",
"Essa fase desempenha um papel muito importante na computação quântica, e você explorará suas várias consequências nos módulos subsequentes do Qiskit in the Classroom.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "c35a8265-2d19-4743-99ac-39192e46f59a",
"metadata": {},
"source": [
"\n",
"\n",
"#### Vários qubits\n",
"\n",
"Embora o estado de vários bits possa ser expresso simplesmente como uma cadeia de 0s e 1s, o estado de vários qubits é um pouco mais complicado devido aos princípios de *superposição* e *emaranhamento*.\n",
"\n",
"Lembre-se de que $N$ bits podem estar em um dos $2^N$ estados possíveis, variando dos números binários 000...000 a 111...111. Mas agora, devido ao princípio da superposição, *os qubits* $N$ podem estar em uma superposição de *todos* esses estados ao mesmo tempo!\n",
"\n",
"Isso pode ser expresso como\n",
"\n",
"$$\n",
"\\psi_N = \\sum_{i=0}^{2^N-1} c_i \\vert i\\rangle\n",
"$$\n",
"\n",
"onde, como no caso clássico, o estado $\\vert i\\rangle$ corresponde ao estado em que cada qubit está na combinação certa de 0s e 1s para produzir o número binário $i$. Esses são conhecidos como \"estados da base computacional\" do sistema quântico. Por exemplo, um estado de três qubits pode ser escrito como uma superposição de seus oito estados de base computacional:\n",
"\n",
"$$\n",
"\\psi_3 = c_0 \\vert 000\\rangle + c_1 \\vert 001\\rangle + c_2 \\vert 010\\rangle + c_3 \\vert 011\\rangle + c_4 \\vert 100\\rangle + c_5 \\vert 101\\rangle + c_6 \\vert 110\\rangle + c_7 \\vert 111\\rangle\n",
"$$\n",
"\n",
"Cada qubit no sistema é denotado com um índice $0$ a $N-1$. A convenção é ler os estados dos qubits da direita para a esquerda, de modo que o estado do qubit $0$ seja o estado mais à direita e o estado do qubit $N-1$ seja o mais à esquerda. Isso é conhecido como notação \"little-endian\" e, a princípio, pode parecer contraintuitivo, pois estamos acostumados a ler da esquerda para a direita.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"À primeira vista, pode parecer contraintuitivo ordenar os qubits da direita para a esquerda, como na notação little-endian, mas, na verdade, é algo muito lógico de se fazer! Explique por quê. (Lembre-se de nossa discussão acima sobre a conversão de números binários para base-10 )\n",
"\n",
"\n",
" \n",
" Se ordenarmos os qubits da direita para a esquerda, de modo que o qubit 0 seja o mais à direita e o qubit N-1 seja o mais à esquerda, é lógico associar o qubit $0$ ao bit menos significativo, que é multiplicado por $2^0$ e o qubit $N-1$ ao bit mais significativo, que é multiplicado por $2^{N-1}$.\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"#### Emaranhamento\n",
"\n",
"Como mencionamos anteriormente, outro recurso importante dos qubits é que eles podem ser *emaranhados* uns com os outros. Vejamos um exemplo de um estado de dois qubits, em que $c_0 = c_3 = \\frac{1}{\\sqrt{2}}$ e $c_1 = c_2 = 0$ :\n",
"\n",
"$\\vert \\psi\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 00\\rangle + \\vert 11\\rangle)$\n",
"\n",
"Portanto, o estado do qubit 0 pode ser $\\vert 0\\rangle$ ou $\\vert 1\\rangle$ com a mesma probabilidade, e o mesmo ocorre com o estado do qubit 1. Mas essas probabilidades não são mais independentes umas das outras. Se descobrirmos que o estado do qubit 0 é $\\vert 0\\rangle$, *saberemos* que o qubit 1 também estará em $\\vert 0\\rangle$. Isso é verdade independentemente da distância entre eles, e é por isso que o ato de medir um estado emaranhado é às vezes chamado de \"ação assustadora à distância\"\n",
"\n",
"O entrelaçamento também pode assumir outras formas. Por exemplo, o estado\n",
"\n",
"$\\vert \\psi\\rangle = \\frac{1}{\\sqrt{2}}(\\vert 01\\rangle + \\vert 10\\rangle)$\n",
"\n",
"produz resultados opostos todas as vezes: se um qubit for medido $\\vert 0\\rangle$, é garantido que o outro será encontrado no estado $\\vert 1\\rangle$.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"O estado $\\vert \\psi\\rangle = \\vert 11\\rangle$ está emaranhado? Por que ou por que não?\n",
"\n",
"\n",
" \n",
" Ele não está emaranhado. Embora os resultados sejam sempre os mesmos quando você mede os dois qubits, isso ocorre apenas porque cada qubit está sempre fixo no estado $\\vert 1\\rangle$. O resultado da medição de um qubit não depende de fato do outro - ambos estão sempre $\\vert 1\\rangle$.\n",
"\n",
" Em geral, se você puder descrever o estado de cada qubit separadamente e depois multiplicá-los dessa forma:\n",
"\n",
" $\\vert \\psi\\rangle = \\vert \\psi_1\\rangle \\vert \\psi_0\\rangle $\n",
"\n",
" Nesse caso, ele é conhecido como um \"estado de produto\" e *não* está emaranhado.\n",
" \n",
"\n",
"\n",
"\n",
"\n",
"#### Notação vetorial\n",
"\n",
"Muitas vezes, é útil usar vetores e matrizes para ver como o estado quântico se transforma em diferentes operações. Nessa representação, nossos estados quânticos serão vetores, e nossas portas quânticas (discutidas na próxima seção) serão matrizes que transformam os vetores.\n",
"\n",
"Para um único qubit, a forma vetorial dos estados é escolhida para ser: $\\vert 0\\rangle = \\begin{pmatrix}1 \\\\ 0\\end{pmatrix}$ $\\vert 1\\rangle = \\begin{pmatrix}0 \\\\ 1\\end{pmatrix}$ Dessa forma, um estado arbitrário $\\vert \\psi\\rangle = a\\vert 0\\rangle+b\\vert 1\\rangle$ pode ser escrito como $\\vert \\psi\\rangle =\\begin{pmatrix}a \\\\ b\\end{pmatrix}$\n",
"\n",
"Para um estado geral de $n$ -qubit, precisaremos de um vetor $2^n$ -dimensional, com estados de base ordenados, como seria de se esperar, em valor binário crescente:\n",
"\n",
"$$\n",
"\\vert 0 \\dots 000\\rangle = \\begin{pmatrix}1 \\\\ 0 \\\\ 0 \\\\ \\vdots \\\\ 0\\end{pmatrix}, \\vert 0 \\dots 001 \\rangle = \\vert 1 \\dots 110\\rangle = \\begin{pmatrix}0 \\\\ \\vdots \\\\ 0 \\\\ 1 \\\\ 0\\end{pmatrix}, \\vert 1 \\dots 111 \\rangle = \\begin{pmatrix}0 \\\\ \\vdots \\\\ 0 \\\\ 0\\\\ 1\\end{pmatrix}\n",
"$$\n",
"\n",
"Com essa escolha de notação vetorial em mente, podemos apresentar nossas portas quânticas necessárias, seus efeitos sobre os estados quânticos e suas formas de matriz.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"Há quatro estados de base computacional para um sistema de dois qubits. Escreva cada um deles nas notações de ket e vetor.\n",
"\n",
"\n",
" \n",
" $$\n",
" \\vert 00\\rangle = \\begin{pmatrix}1 \\\\ 0 \\\\ 0 \\\\ 0\\end{pmatrix}, \\vert 01 \\rangle = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0\\end{pmatrix}, \\dots, \\vert 10\\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 1 \\\\ 0\\end{pmatrix}, \\vert 11 \\rangle = \\begin{pmatrix}0 \\\\ 0 \\\\ 0\\\\ 1\\end{pmatrix}\n",
" $$\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "52f971a7-4a5e-4571-927b-23a642fae997",
"metadata": {},
"source": [
"\n",
"\n",
"## Portas $\\rightarrow$ portas quânticas\n",
"\n",
"Assim como as portas clássicas, como NOT, AND, OR e XOR, podem ser combinadas para criar circuitos clássicos arbitrários, as portas quânticas desempenham o mesmo papel na computação quântica. Como os qubits têm recursos mecânicos quânticos adicionais, as portas quânticas são correspondentemente mais ricas. Embora ainda possamos descrever sua ação com base nos estados $|0\\rangle$ e $|1\\rangle$ com uma tabela de verdade, isso não capta todo o quadro. Para portas quânticas, geralmente é mais natural usar uma representação matricial, pois elas também atuam em superposições de estados básicos.\n",
"\n",
"A seguir, apresentaremos as portas quânticas mais comuns e como elas transformam os qubits com os quais interagem. Quando aplicável, nós os conectaremos de volta aos portões clássicos conhecidos.\n",
"\n",
"\n",
"\n",
"### Portas de qubit único\n",
"\n",
"**$X$ porta** : Esse é o equivalente quântico de uma operação NOT. Sua tabela verdade se parece exatamente com a porta NOT clássica:\n",
"\n",
"| Entrada | Saída |\n",
"| :--------------- | ---------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 1\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $\\vert 0\\rangle$ |\n",
"\n",
"E a representação da matriz:\n",
"\n",
"$X=\\begin{pmatrix} 0 & 1 \\\\ 1 & 0 \\end{pmatrix}$\n",
"\n",
"No Qiskit, a criação de um circuito com uma porta $X$ tem a seguinte aparência:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "6c215e46-26cb-4e10-a1d7-2eecd2c18294",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(1)\n",
"qc.x(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "3a59abe3-5e75-4ff1-9f5e-9b24fd5c5ea0",
"metadata": {},
"source": [
"Nesse diagrama de circuito muito simples, o qubit é representado por um fio, a linha horizontal preta, e a porta aparece como uma caixa nesse fio.\n",
"\n",
"**Porta Hadamard:** Cria um estado de superposição. Tabela verdade:\n",
"\n",
"| Entrada | Saída |\n",
"| :--------------- | -------------------------------------------------------------: |\n",
"| $\\vert 0\\rangle$ | $\\frac{1}{\\sqrt{2}}\\left(\\vert 0\\rangle+\\vert 1\\rangle\\right)$ |\n",
"| $\\vert 1\\rangle$ | $\\frac{1}{\\sqrt{2}}\\left(\\vert 0\\rangle-\\vert 1\\rangle\\right)$ |\n",
"\n",
"Representação matricial: $H=\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 & 1 \\\\ 1 & -1 \\end{pmatrix}$\n",
"\n",
"Um circuito com uma porta Hadamard é feito da seguinte forma:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "1a009015-4ced-47e4-a18d-d0685e4cab47",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(1)\n",
"qc.h(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "9de7658f-e456-4788-81bb-6900c12ef054",
"metadata": {},
"source": [
"**$Z$ portão** : Adiciona uma mudança de fase de $\\Delta \\phi = \\pi$ ao estado $|1\\rangle$ :\n",
"\n",
"| Entrada | Saída |\n",
"| :--------------- | ----------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 0\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $-\\vert 1\\rangle$ |\n",
"\n",
"$Z=\\begin{pmatrix} 1 & 0 \\\\ 0 & -1 \\end{pmatrix}$\n",
"\n",
"No Qiskit, a criação de um circuito com uma porta $Z$ tem a seguinte aparência:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "7bca3c98-884b-4709-bbe8-a9e16cc45698",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.z(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "c9ee10a5-5f69-4db4-87e9-bc1d3cd051eb",
"metadata": {},
"source": [
"**$T$ portão** : Adiciona uma mudança de fase de $\\Delta \\phi = \\pi/4$ ao estado $|1\\rangle$ :\n",
"\n",
"| Entrada | Saída |\n",
"| :--------------- | -------------------------: |\n",
"| $\\vert 0\\rangle$ | $\\vert 0\\rangle$ |\n",
"| $\\vert 1\\rangle$ | $e^{i\\pi/4}\\vert 1\\rangle$ |\n",
"\n",
"$T=\\begin{pmatrix} 1 & 0 \\\\ 0 & e^{i\\pi/4} \\end{pmatrix}$\n",
"\n",
"No Qiskit, a criação de um circuito com uma porta $T$ tem a seguinte aparência:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "ac699059-6be5-4a1a-89cb-97b7af412ab8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(1)\n",
"qc.t(0)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "52b43ac8-be21-4652-a139-7093fe27fd69",
"metadata": {},
"source": [
"\n",
"\n",
"### Portas multi-qubit\n",
"\n",
"As portas de dois qubits podem se assemelhar às portas clássicas de dois bits, mas com uma ressalva importante: todas as portas quânticas devem ser reversíveis. Em termos de álgebra linear, isso significa que eles são representados por matrizes unitárias. Assim, dois qubits de entrada sempre são mapeados para dois qubits de saída, e a operação pode, em princípio, ser desfeita. Isso contrasta com as portas clássicas que vimos acima, como AND ou OR, que perdem informações e são irreversíveis - dada uma saída, não é possível determinar com exclusividade a entrada.\n",
"\n",
"**Porta CNOT (Controlled-NOT):** Os dois qubits de entrada são chamados de qubits de \"controle\" e \"alvo\". O qubit de controle permanece inalterado, mas seu estado determina o que acontece com o qubit de destino. Se o qubit de controle estiver no estado $\\vert 1\\rangle$, uma porta $X$ será aplicada a esse alvo; se o estado do qubit de controle for $\\vert 0\\rangle$, nenhuma alteração será feita. Na notação abaixo, suponha que o qubit $A$ (qubit mais à direita) seja o controle e o qubit $B$ (o qubit mais à esquerda) seja o alvo. Abaixo, a notação usada é $CNOT(q_{control},q_{target})\\vert BA\\rangle.$\n",
"\n",
"$CNOT(A,B)\\vert BA\\rangle_{input} = \\vert BA\\rangle_{output}$\n",
"\n",
"| Entrada | Saída |\n",
"| :---------------- | ----------------: |\n",
"| $\\vert 00\\rangle$ | $\\vert 00\\rangle$ |\n",
"| $\\vert 01\\rangle$ | $\\vert 11\\rangle$ |\n",
"| $\\vert 10\\rangle$ | $\\vert 10\\rangle$ |\n",
"| $\\vert 11\\rangle$ | $\\vert 01\\rangle$ |\n",
"\n",
"Portanto, a matriz que representa essa ação é:\n",
"\n",
"$CNOT=\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "1c4dc48d-3d2b-4b4b-b405-c93504815ba9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.cx(0, 1)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "be45af7b-a148-4b46-8379-3ac9658f50a9",
"metadata": {},
"source": [
"Esse é o primeiro diagrama de circuito que vemos com dois qubits, que são representados pelos dois fios. A porta CNOT é implementada entre os dois qubits, com $q_0$ como controle e $q_1$ como alvo.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"A maioria dos portões tem a mesma forma de matriz no Qiskit e em qualquer outro lugar. Mas a porta CNOT atua em dois qubits e, de repente, as convenções de ordenação dos qubits se tornam um problema. Textos que ordenam qubits $\\vert q_0,q_1,...\\rangle$ mostrarão uma forma de matriz diferente para suas portas CNOT. Verifique, por meio da multiplicação explícita de matrizes, se a matriz CNOT acima tem a ação correta sobre o estado $\\vert 01\\rangle.$\n",
"\n",
"\n",
" \n",
" $CNOT\\vert 01\\rangle =\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix}\\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\0\\end{pmatrix} = \\begin{pmatrix}0 \\\\ 0 \\\\ 0 \\\\1\\end{pmatrix} = \\vert 11\\rangle$\n",
" \n",
"\n",
"\n",
"**Porta SWAP:** Essa porta troca os estados de dois qubits. Tabela verdade:\n",
"\n",
"| Entrada | Saída |\n",
"| :---------------- | ----------------: |\n",
"| $\\vert 00\\rangle$ | $\\vert 00\\rangle$ |\n",
"| $\\vert 01\\rangle$ | $\\vert 10\\rangle$ |\n",
"| $\\vert 10\\rangle$ | $\\vert 01\\rangle$ |\n",
"| $\\vert 11\\rangle$ | $\\vert 11\\rangle$ |\n",
"\n",
"Portanto, a matriz que representa essa ação é:\n",
"\n",
"$SWAP=\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1\\end{pmatrix}$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "118da691-4208-4248-a21f-a5e22815dc2c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.swap(0, 1)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "78199ae4-93e4-49a2-948a-f41a22187bae",
"metadata": {},
"source": [
"A porta SWAP pode, na verdade, ser construída a partir de três CNOTs. Para ver como, podemos `decompose()` o portão com o Qiskit:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "5efa09b9-b3e4-43fb-81f3-c33283a992d2",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(2)\n",
"qc.swap(0, 1)\n",
"qc.decompose().draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "330362e5-f040-426f-a6d9-d730c917c7f2",
"metadata": {},
"source": [
"Aqui vemos pela primeira vez como várias portas são mostradas em um diagrama de circuito. Nós o lemos da esquerda para a direita, de modo que a porta mais à esquerda é aplicada primeiro.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"Verifique se a combinação de CNOTs acima resulta em uma porta SWAP. Você pode fazer isso com a multiplicação de matrizes ou qualquer outro método.\n",
"\n",
"\n",
" \n",
" Com multiplicação de matriz:\n",
"\n",
" $\\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix} \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0\\end{pmatrix} \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0\\end{pmatrix} = \\begin{pmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1\\end{pmatrix} = SWAP ~\\checkmark$\n",
"\n",
" Usar uma tabela verdade para ver como os estados mudam com cada CNOT. Na última coluna, os estados devem ser equivalentes à coluna \"saída\" da tabela verdade SWAP:\n",
"\n",
" | Entrada | CNOT(A,B) | CNOT(B,A) | CNOT(A,B) |\n",
" | :---------------- | :---------------: | :---------------: | ---------------------------: |\n",
" | $\\vert 00\\rangle$ | $\\vert 00\\rangle$ | $\\vert 00\\rangle$ | $\\vert 00\\rangle \\checkmark$ |\n",
" | $\\vert 01\\rangle$ | $\\vert 11\\rangle$ | $\\vert 10\\rangle$ | $\\vert 10\\rangle \\checkmark$ |\n",
" | $\\vert 10\\rangle$ | $\\vert 10\\rangle$ | $\\vert 11\\rangle$ | $\\vert 01\\rangle \\checkmark$ |\n",
" | $\\vert 11\\rangle$ | $\\vert 01\\rangle$ | $\\vert 01\\rangle$ | $\\vert 11\\rangle \\checkmark$ |\n",
" \n",
"\n",
"\n",
"**Porta Toffoli (ou \"controlado-controlado-NOT\" (CCNOT)):** Essa é uma porta *de três qubits*. O nome \"controlled-controlled-NOT\" talvez já diga como ele funciona: há dois qubits de controle e um qubit de destino, e o estado do qubit de destino é invertido somente se *ambos os* qubits de controle estiverem no estado $\\vert 1\\rangle$. Mantemos a convenção de ordenação que usamos com o CNOT:\n",
"\n",
"$$\n",
"CCNOT(Control A, Control B, Target C)\\vert CBA\\rangle\n",
"$$\n",
"\n",
"Portanto, a tabela de verdade é:\n",
"\n",
"| Entrada | Saída |\n",
"| :----------------- | -----------------: |\n",
"| $\\vert 000\\rangle$ | $\\vert 000\\rangle$ |\n",
"| $\\vert 001\\rangle$ | $\\vert 001\\rangle$ |\n",
"| $\\vert 010\\rangle$ | $\\vert 010\\rangle$ |\n",
"| $\\vert 011\\rangle$ | $\\vert 111\\rangle$ |\n",
"| $\\vert 100\\rangle$ | $\\vert 100\\rangle$ |\n",
"| $\\vert 101\\rangle$ | $\\vert 101\\rangle$ |\n",
"| $\\vert 110\\rangle$ | $\\vert 110\\rangle$ |\n",
"| $\\vert 111\\rangle$ | $\\vert 011\\rangle$ |\n",
"\n",
"E a matriz que representa essa ação é:\n",
"\n",
"$$\n",
"CCNOT=\\begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\end{pmatrix}\n",
"$$\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "d1829257-b7a4-49d9-8ac2-3d6230165427",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(3)\n",
"qc.ccx(0, 1, 2)\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "aa2e83e5-1197-473c-9f16-4c264b08aca0",
"metadata": {},
"source": [
"O portão de Toffoli também pode ser decomposto em CNOTs, juntamente com alguns outros portões. No entanto, ela é significativamente mais complicada do que a decomposição da porta SWAP, portanto, será deixada como um exercício opcional no final do módulo para explorar e verificar essa decomposição.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "970302ee-eccc-48eb-b255-4a2d7bc8fbbc",
"metadata": {},
"source": [
"\n",
"\n",
"## Medições\n",
"\n",
"As medições desempenham um papel especial na computação quântica, que não tem um análogo na computação clássica. Enquanto na computação clássica é possível verificar os bits a qualquer momento durante um algoritmo, na computação quântica é preciso ser muito seletivo quanto ao momento de verificar os qubits, pois a medição colapsa o estado deles e destrói a superposição que dá aos qubits sua complexidade computacional.\n",
"\n",
"Em particular, dado um estado quântico de $N$ -bit $\\vert \\psi\\rangle = \\sum_{i=0}^{2^N-1} c_i \\vert i\\rangle$, uma medição colapsará o estado para uma das funções de base $\\vert i\\rangle$ com uma probabilidade igual a $\\vert c_i\\vert ^2$.\n",
"\n",
"Mas esse efeito destrutivo de uma medição nem sempre é um obstáculo. De fato, é um recurso fundamental em determinados algoritmos e protocolos, como o [teletransporte quântico](/learning/modules/computer-science/quantum-teleportation) e [a distribuição de chaves quânticas](/learning/modules/computer-science/quantum-key-distribution).\n",
"\n",
"No Qiskit, quando uma medição é feita, ela é enviada para um registro clássico, onde é armazenada como um bit clássico. A criação de um circuito com uma medição tem a seguinte aparência:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "56dfec5d-556b-486d-9cbf-0700582ec25c",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = QuantumCircuit(\n",
" 1, 1\n",
") # the second number is the number of classical bits in the circuit\n",
"qc.measure(0, 0)\n",
"qc.draw(\"mpl\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "45a53043-fdc8-4df2-b2c8-8b12ded1f400",
"metadata": {},
"source": [
"\n",
"\n",
"## Circuitos\n",
"\n",
"Agora que sabemos como funcionam os qubits, as portas e as medições, vamos criar e executar nosso próprio circuito quântico! Para isso, precisaremos apresentar a você um fluxo de trabalho útil chamado Qiskit patterns.\n",
"\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "a5adf2d9-4de5-4978-b509-05fb7381f238",
"metadata": {},
"source": [
"\n",
"\n",
"### Estrutura de padrões Qiskit\n",
"\n",
"A estrutura de padrões Qiskit é um procedimento geral para abordar e resolver problemas com um computador quântico. Ele consiste em quatro etapas:\n",
"\n",
"1. **Mapeamento de** nosso problema para circuitos e operadores quânticos\n",
"2. **Otimização** do circuito para o hardware de destino\n",
"3. **Execução** no hardware de destino\n",
"4. **Pós-processamento de** nossos resultados\n",
"\n",
"Para ilustrar essas etapas, implementaremos uma versão *quântica* do circuito meio-somador discutido acima.\n",
"\n",
"\n",
"\n",
"#### 1. Mapeamento\n",
"\n",
"O circuito somador clássico usa uma porta XOR e uma porta AND para calcular a soma e os bits de transporte, respectivamente. Podemos adaptar essas portas ao contexto quântico para criar o meio somador quântico. Primeiro, lembrando que as portas quânticas são *reversíveis*, não podemos simplesmente sobrescrever as entradas. Em vez disso, introduzimos dois qubits auxiliares inicializados em $\\vert 0\\rangle$ para armazenar as saídas de soma e transporte. Portanto, nosso estado quântico completo consistirá em qubits $A$ e $B$, e os qubits de soma e transporte, que rotularemos como $S$ e $C$ :\n",
"\n",
"$\\vert \\psi\\rangle = \\vert C S B A\\rangle$\n",
"\n",
"Agora, precisamos de portas quânticas que realizem o que as portas XOR e AND fizeram no circuito clássico.\n",
"\n",
"**Soma:**\n",
"\n",
"Para o XOR, aplicamos dois CNOTs, cada um com qubits de controle $A$ e $B$ e qubit de destino $S$ para ambos. Se $A$ e $B$ forem diferentes, uma das portas CNOT inverterá $S$ para o estado $\\vert 1\\rangle$. Se $A$ e $B$ forem ambos $\\vert 0\\rangle$, então nada acontecerá com $S$ e ele permanecerá no estado $\\vert 0\\rangle$. Se $A$ e $B$ forem ambos $\\vert 1\\rangle$, o estado de $S$ será invertido duas vezes, levando-o de volta ao estado $\\vert 0\\rangle$.\n",
"\n",
"**Transportar:**\n",
"\n",
"Para o bit de transporte, precisamos de algo que funcione como a porta AND clássica.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"Dê uma olhada nas portas que discutimos para ver se você consegue adivinhar qual porta quântica usaremos no lugar da porta AND clássica:\n",
"\n",
"\n",
" \n",
" É o portão Toffoli! Lembre-se de que a porta Toffoli, ou controlada-controlada-NÃO, inverte o estado de destino se e somente se o qubit de controle 0 E o qubit de controle 1 forem ambos $\\vert 1\\rangle$. Portanto, se o qubit de destino começar no estado $\\vert 0\\rangle$, ele terá a mesma ação que a porta AND.\n",
" \n",
"\n",
"\n",
"Portanto, agora temos todos os ingredientes necessários para fazer o circuito quântico:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "0bf14732-29fb-41c7-a4b3-94bd276ebc33",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# qubits: a, b, sum, carry\n",
"qc = QuantumCircuit(4)\n",
"\n",
"# Choose values for A and B:\n",
"a = 0\n",
"b = 0\n",
"\n",
"# Prepare A and B qubits according to selected values:\n",
"if a:\n",
" qc.x(0)\n",
"if b:\n",
" qc.x(1)\n",
"\n",
"# XOR (sum) into qubit 2\n",
"qc.cx(0, 2)\n",
"qc.cx(1, 2)\n",
"\n",
"# AND (carry) into qubit 3\n",
"qc.ccx(0, 1, 3) # a AND b\n",
"\n",
"# measure\n",
"qc.measure_all()\n",
"\n",
"\n",
"qc.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "cd129de5-0b73-44db-97ea-f819184e3661",
"metadata": {},
"source": [
"Acima está o diagrama do circuito quântico de meio-somador. Conforme mencionado anteriormente, os fios representam os qubits $0$ a $3$ ordenados de cima para baixo, e o registro de bits clássico é o fio de linha dupla inferior. Em seguida, lendo da esquerda para a direita, vemos como as portas são aplicadas a cada qubit, observando onde as caixas aparecem nos fios correspondentes. Por fim, as medições são mostradas no final. As medições colapsam os estados do qubit em valores definidos $0$ ou $1$, e os resultados são enviados para um registro clássico.\n",
"\n",
"Uma sutileza: embora o diagrama do circuito esteja desenhado da esquerda para a direita, ao escrever a expressão da matriz correspondente, devemos lê-la da direita para a esquerda. Isso ocorre porque, na multiplicação de matrizes, o operador mais próximo do vetor de estado atua primeiro. Assim, por exemplo, o circuito acima (ignorando as medições) seria escrito como:\n",
"\n",
"$$\n",
"CCNOT(q_0,q_1,q_3)CNOT(q_1, q_2)CNOT(q_0,q_2)\\vert q_3 q_2 q_1 q_0\\rangle\n",
"$$\n",
"\n",
"\n",
"\n",
"#### 2. Otimização:\n",
"\n",
"Em seguida, precisamos otimizar o circuito para ser executado no hardware quântico. Essa otimização é realizada por meio do transpilador, que traduz o circuito abstrato mostrado acima em instruções que o computador quântico entenderá. Ele atribui os qubits lógicos acima a qubits reais e físicos no processador e reescreve as portas em termos de seu próprio conjunto nativo de portas que foram otimizadas para serem executadas no computador quântico. Por fim, o transpilador também implementa algo chamado \"supressão e atenuação de erros\" para tentar minimizar o efeito dos erros no resultado. Isso não é tão importante para o nosso circuito muito simples, mas se você continuar em sua jornada de computação quântica para executar circuitos mais complicados, logo verá o valor da supressão e atenuação de erros. Se você quiser saber mais sobre isso, consulte o curso de Olivia Lane, [Quantum Computing in Practice (Computação quântica na prática](/learning/courses/quantum-computing-in-practice/introduction) ).\n",
"\n",
"Primeiro, carregamos os pacotes necessários para nos comunicarmos com os computadores quânticos do IBM® e selecionamos um backend para execução. Podemos escolher o backend menos ocupado ou selecionar um backend específico cujas propriedades conhecemos.\n",
"\n",
"Há um código abaixo para salvar suas credenciais na primeira utilização. Certifique-se de excluir essas informações do notebook depois de salvá-lo em seu ambiente, para que suas credenciais não sejam compartilhadas acidentalmente quando você compartilhar o notebook. Consulte [Configurar sua conta IBM Cloud](/docs/guides/cloud-setup) e [Inicializar o serviço em um ambiente não confiável](/docs/guides/cloud-setup-untrusted) para obter mais orientações.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bdc5e025-8bf4-4fbc-af80-4404e2577511",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ibm_fez\n"
]
}
],
"source": [
"# Load the Qiskit Runtime service\n",
"from qiskit_ibm_runtime import QiskitRuntimeService\n",
"\n",
"# Load the Qiskit Runtime service\n",
"\n",
"# Syntax for first saving your token. Delete these lines after saving your credentials.\n",
"# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',\n",
"# instance = '', token='', overwrite=True, set_as_default=True)\n",
"# service = QiskitRuntimeService(channel='ibm_quantum_platform')\n",
"\n",
"# Load saved credentials\n",
"service = QiskitRuntimeService()\n",
"\n",
"# Use the least busy backend, or uncomment the loading of a specific backend like \"ibm_brisbane\".\n",
"backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)\n",
"# backend = service.backend(\"ibm_brisbane\")\n",
"print(backend.name)"
]
},
{
"cell_type": "markdown",
"id": "4b4fb4cb-7e4a-47f4-a5d5-803b2d513a61",
"metadata": {},
"source": [
"Agora, usamos o transpilador para otimizar o circuito. Podemos escolher o nível de otimização de 0 (sem otimização) a 3 (otimização máxima). Para ver o que cada nível implica, visite o guia de [níveis de otimização do transpilador Set](/docs/guides/set-optimization). O circuito resultante terá uma aparência significativamente diferente do circuito lógico que criamos em nossa etapa de mapeamento.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "ad106853-7416-4fb9-b8e3-c43bb81c9059",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Transpile the circuit and optimize for running on the quantum computer selected\n",
"# Step 2: Transpile\n",
"from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
"\n",
"target = backend.target\n",
"pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
"qc_isa = pm.run(qc)\n",
"\n",
"qc_isa.draw(\"mpl\")"
]
},
{
"cell_type": "markdown",
"id": "d9c345cf-9a25-4b6f-a5ec-62a6cefe3f27",
"metadata": {},
"source": [
"Um \"amostrador\" é um primitivo projetado para amostrar possíveis estados resultantes de um circuito quântico e coletar estatísticas sobre quais estados podem ser medidos e com qual probabilidade. Importamos o Qiskit Runtime Sampler para cá:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "13a3faee-256d-4038-b0bf-ef1100139a96",
"metadata": {},
"outputs": [],
"source": [
"# Load the Runtime primitive and session\n",
"from qiskit_ibm_runtime import SamplerV2 as Sampler\n",
"\n",
"sampler = Sampler(mode=backend)"
]
},
{
"cell_type": "markdown",
"id": "3d392a16-51ae-4367-8b75-4abf520f6474",
"metadata": {},
"source": [
"Se você tiver esgotado o tempo alocado em computadores quânticos reais ou se não tiver conexão com a Internet, talvez prefira usar um simulador. Para fazer isso, execute a célula abaixo e descomente a linha associada na etapa \"Execute\" (Executar).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "bcc1cab6-73db-4c8e-96b6-af7137ab6bd1",
"metadata": {},
"outputs": [],
"source": [
"# Load the backend sampler\n",
"from qiskit.primitives import BackendSamplerV2\n",
"\n",
"# Load the Aer simulator and generate a noise model based on the currently-selected backend.\n",
"from qiskit_aer import AerSimulator\n",
"from qiskit_aer.noise import NoiseModel\n",
"\n",
"noise_model = NoiseModel.from_backend(backend)\n",
"\n",
"# Define a simulator using Aer, and use it in Sampler.\n",
"backend_sim = AerSimulator(noise_model=noise_model)\n",
"sampler_sim = BackendSamplerV2(backend=backend_sim)\n",
"\n",
"# Alternatively, load a fake backend with generic properties and define a simulator.\n",
"# backend_gen = GenericBackendV2(num_qubits=18)\n",
"# sampler_gen = BackendSamplerV2(backend=backend_gen)"
]
},
{
"cell_type": "markdown",
"id": "6112fb67-3f51-4532-bb30-331b687cb43d",
"metadata": {},
"source": [
"\n",
"\n",
"#### 3. Execução\n",
"\n",
"Depois de preparar o circuito, agora podemos executá-lo no computador quântico!\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "0609b820-bb46-4a00-b33b-813ce8843ae1",
"metadata": {},
"outputs": [],
"source": [
"job = sampler.run([qc_isa], shots=100)\n",
"# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator\n",
"res = job.result()\n",
"counts = res[0].data.meas.get_counts()"
]
},
{
"cell_type": "markdown",
"id": "fea26bd9-84c9-402f-bd7e-785754993af9",
"metadata": {},
"source": [
"\n",
"\n",
"#### 4. Pós-processamento\n",
"\n",
"Agora estamos prontos para ver nossos resultados! Exibiremos um histograma das 100 amostras do circuito.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "a4efc93d-ed2e-406f-b335-deeaa661c55b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"counts = {'0000': 90, '0100': 4, '1100': 3, '0010': 3}\n"
]
},
{
"data": {
"text/plain": [
""
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.visualization import plot_histogram\n",
"\n",
"print(\"counts = \", counts)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"id": "c228359b-7022-426a-ae7f-3599efb2231e",
"metadata": {},
"source": [
"O histograma acima mostra os resultados da medição de todos os quatro qubits no final do circuito. Um computador quântico ideal com ruído zero teria medido os qubits para ter sempre os mesmos valores, mas, na realidade, o ruído fará com que algumas das execuções produzam erros.\n",
"\n",
"\n",
"\n",
"#### Verifique sua compreensão\n",
"\n",
"Usando o bitstring com o maior número de contagens como seus valores para $A$, $B$, $S$ e $C$, verifique se o circuito de somador quântico funcionou.\n",
"\n",
"\n",
" \n",
" Precisamos verificar se $A+B = S+2 \\times C$. Lembre-se de que a ordem da cadeia de bits segue a notação little-endian, portanto, é lida `CSBA`.\n",
"\n",
" No histograma acima, vemos que o bitstring `0000` é o dominante.\n",
"\n",
" $0 + 0 = 0 + 0 \\times 2 = 0 ~\\checkmark$\n",
" \n",
"\n",
"\n",
"Volte e altere os valores de $A$ e $B$ para $A=1$ e $B=1$ e siga novamente as etapas dos padrões do Qiskit para executar novamente o circuito. Verifique se o circuito somador funcionou novamente.\n",
"\n",
"\n",
" \n",
" Você deverá obter um histograma com o bitstring dominante sendo `1011`:\n",
"\n",
" $1 + 1 = 0 + 1 \\times 2 = 2 ~\\checkmark$\n",
" \n",
"\n",
"\n",
"Um dos recursos adicionais do meio-somador *quântico* em relação ao meio-somador clássico é que ele pode ser executado com entradas *quânticas*. Ou seja, ele pode \"adicionar\" os qubits $A$ e $B$ mesmo que eles estejam em estados de superposição. Na seção Perguntas de desafio abaixo, será solicitado que você prepare os qubits em superposições e veja o que acontece!\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "ca1d1257-d741-4f46-908b-73cef6bc8fc7",
"metadata": {},
"source": [
"\n",
"\n",
"## Conclusão\n",
"\n",
"Este módulo foi projetado para lhe dar uma sólida compreensão dos princípios básicos por trás da computação quântica, comparando-a com a computação clássica. Examinamos o circuito clássico de meio-somador e, em seguida, mostramos como adaptar o circuito para ser executado com qubits em um computador quântico. Agora você está pronto para explorar os outros módulos do Qiskit in the Classroom!\n",
"\n",
"\n",
"\n",
"### Conceitos críticos:\n",
"\n",
"* Em contraste com os bits clássicos, que só podem assumir os valores 0 e 1, os qubits também podem estar em estados de **superposição** de 0 e 1.\n",
"* Vários qubits podem estar em uma superposição sobre as cadeias de bits classicamente permitidas, chamadas de **estados de base computacional**.\n",
"* Vários qubits podem ser **emaranhados** de modo que o estado de um dependa do estado do outro.\n",
"* A convenção do Qiskit é usar a **notação little-endian**, que coloca o qubit menos significativo, $q_0$, na posição mais à direita e o qubit mais significativo, $q_N$, na mais à esquerda.\n",
"* **As portas quânticas** são operações reversíveis representadas por matrizes unitárias que atuam nos vetores de estado quântico. Nessa notação, a matriz mais próxima do vetor (que está mais à direita) age primeiro.\n",
"* **As medições** colapsam um estado de superposição quântica em um de seus estados classicamente permitidos, com probabilidade igual ao quadrado da amplitude do estado da base computacional correspondente na superposição.\n",
"* Os circuitos quânticos são frequentemente representados por meio de **diagramas de circuitos quânticos**, em que os qubits são representados como fios horizontais e as portas quânticas aparecem ao longo desses fios, da esquerda para a direita.\n",
"* Para executar um circuito quântico, usamos as quatro etapas do fluxo de trabalho **dos padrões Qiskit** : **Mapear**, **otimizar**, **executar** e **pós-processar**.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "34ccee8d-e9cc-45eb-ab30-8e8160ec9a5b",
"metadata": {},
"source": [
"\n",
"\n",
"## Perguntas\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "37265ba8-dc01-4aae-941f-6e051c62d7cc",
"metadata": {},
"source": [
"\n",
"\n",
"### Questões de verdadeiro/falso\n",
"\n",
"1. Um único bit em um computador clássico só pode conter o valor 0 ou 1.\n",
"\n",
"2. O entrelaçamento significa que o estado de um qubit é independente do estado de outro.\n",
"\n",
"3. As portas quânticas geralmente são operações irreversíveis.\n",
"\n",
"4. A convenção Qiskit coloca o qubit menos significativo, $q_0$, na posição mais à esquerda.\n",
"\n",
"5. A medição de um estado quântico sempre apresenta exatamente o mesmo resultado se for repetida várias vezes.\n",
"\n",
"6. A porta Hadamard cria uma superposição em um único qubit.\n",
"\n",
"7. Os circuitos quânticos podem incluir operações de medição que colapsam o estado de superposição em um dos estados classicamente permitidos.\n",
"\n",
"8. O número de estados clássicos possíveis para $N$ bits é $2N$.\n",
"\n",
"9. As probabilidades de resultado das medições quânticas são dadas pelas amplitudes ao quadrado dos estados básicos classicamente mensuráveis.\n",
"\n",
"\n",
"\n",
"### Perguntas de resposta curta\n",
"\n",
"1. Quais são as principais diferenças entre um bit e um qubit?\n",
"\n",
"2. O que acontece com um estado quântico quando ele é medido?\n",
"\n",
"3. Por que usamos a notação little-endian no Qiskit?\n",
"\n",
"4. Quais são as quatro etapas do fluxo de trabalho dos padrões do Qiskit?\n",
"\n",
"\n",
"\n",
"### Perguntas desafiadoras:\n",
"\n",
"1. No módulo, usamos apenas o somador para adicionar estados classicamente permitidos para $A$ e $B$. Mas também podemos preparar $A$ e $B$ em superposições! Altere o código para preparar cada qubit em uma sobreposição igual de 0 e 1, depois execute o novo circuito e obtenha um novo histograma. O que você está vendo? Explique o que está acontecendo.\n",
"\n",
"2. Decomposição da porta Toffoli. Use o site `decompose()` para mostrar como a porta Toffoli é decomposta em portas de um e dois qubits e, em seguida, verifique essa construção com a multiplicação de matrizes. Lembre-se de que, embora os diagramas de circuito sejam lidos da esquerda para a direita, as matrizes são aplicadas aos estados quânticos da direita para a esquerda!\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"in_page_toc_max_heading_level": 2,
"in_page_toc_min_heading_level": 2,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 5
}