diff --git a/grover.ipynb b/grover.ipynb new file mode 100644 index 0000000..25abc74 --- /dev/null +++ b/grover.ipynb @@ -0,0 +1,749 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "# Importing standard Qiskit libraries and configuring account\n", + "import numpy as np\n", + "from qiskit import QuantumRegister, ClassicalRegister\n", + "from qiskit import QuantumCircuit, execute, Aer, IBMQ\n", + "from qiskit.compiler import transpile, assemble\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "# Loading your IBM Q account(s)\n", + "#provider = IBMQ.load_account()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Algoritmo de Grover\n", + "- Introdução\n", + "- Preparação dos estados\n", + "- Aplicando Oracle\n", + "- Inversão sobre a média\n", + "- Circuito Quântico\n", + "- Exercícios" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Observações dos autores\n", + "\n", + "- Recomendamos que antes de prosseguir para o algoritmo de Grover, o leitor esteja bem familiarizado com os algoritmos de Deutsch e a sua extensão Deutsch-Jozsa. Pois muitos dos conceitos já vistos lá são reutilizados neste módulo.\n", + " \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introdução \n", + "\n", + " Dado um conjunto desestruturado de elementos de tamanho $N$, como fazer para achar um elemento específico dentro do conjunto? A solução mais simples que não envolve a ordenação do conjunto implica a verificação de cada elemento do array até que o elemento desejado seja encontrado. No pior caso, seria necessário fazer $N$ requisições. O algoritmo proposto por Luv Grover tem a capacidade de fazê-lo em aproximadamente $\\sigma(\\sqrt{N/M})$ iterações, onde M é quantidade de soluções buscadas. \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preparação dos estados\n", + " Considere o operador unitário $U_f$ que implementa a função (ou oracle) $f\\{0,1\\}^n \\mapsto \\{0,1\\}$. Seja $\\tilde{x}$ a cadeia binária a qual deseja-se achar. Onde $f(x) = 1$ se $x = \\tilde{x}$ e $f(x) = 0$ se $ x \\neq \\tilde{x}$. A ação de $U_f$ nos estados dos qubits ocorreria da seguinte forma:\n", + " $$\n", + " U_f |x\\rangle |y\\rangle = |x\\rangle |y \\oplus f(x) \\rangle \n", + " $$\n", + " \n", + " O algoritmo em si faz uso de dois registradores quânticos, o primeiro trata-se de um registrador de $n$ qubits o qual é a entrada one será feita a busca, o segundo registrador quântico trata-se do qubit auxiliar (ou ancilla).\n", + " Mas antes de entrar nos detalhes do algoritmo é necessário fazer algumas observações, relaciondas a um passo importante na evolução do sistema chamado de _inversão de fase_.\n", + " \n", + " \n", + " Considere uma entrada qualquer $|x\\rangle$. O estado inicial do sistema se encontraria como a seguir:\n", + " $$\n", + " |x\\rangle\\left( \\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}} \\right)\n", + " $$\n", + " \n", + " Distribuindo e aplicando $U_f$\n", + " \n", + " $$\n", + " \\frac{1}{\\sqrt{2}}\\left(|x\\rangle|0\\rangle - |x\\rangle|1\\rangle\\right) = U_f\\left[ \\frac{1}{\\sqrt{2}}\\left(|x\\rangle|0\\rangle - |x\\rangle|1\\rangle\\right) \\right]\n", + " $$\n", + " $$\n", + " \\frac{1}{\\sqrt{2}}\\left(|x\\rangle|0\\oplus f(x) \\rangle - |x\\rangle|1\\oplus f(x)\\rangle\\right) \n", + " $$\n", + " \n", + " Sabendo que $\\oplus$ o qual trata-se de uma soma módulo 2, opera como um $XOR$ nos estados dos qubits. É possivel verificar que a operação $|1 \\oplus f(x)\\rangle$ trata-se da negação de $f(x)$. \n", + " Ou seja:\n", + " $$\n", + " |x\\rangle \\left(\\frac{| f(x) \\rangle - | \\bar{f(x)}\\rangle }{\\sqrt{2}}\\right)\n", + " $$\n", + " Levando este resultado em consideração, então a fase do sistema (ou sinal da equação) é determinada pelo resultado da função, matematicamente falando:\n", + " $$\n", + " (-1)^{f(x)}|x\\rangle \\left(\\frac{| 0 \\rangle - | 1\\rangle }{\\sqrt{2}}\\right)\n", + " $$\n", + " \n", + " Por simplicidade, vamos considerar que a entrada é uma superposição de todos os estados possíveis. Como se aplicássemos portas Hadamard do tipo $H^{\\otimes n}$ a um registrador $|0\\rangle^{\\otimes n}$ . E que o estado inicial da ancilla enconta-se como em $\\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}}$.\n", + " \n", + " Para um sistema cuja entrada tem três qubits, o estado se encontraria como a seguir:\n", + " $$\n", + " \\frac{1}{2}\\left(|00\\rangle + |01\\rangle + |10\\rangle + |11\\rangle\\right)\\left(\\frac{| 0 \\rangle - | 1\\rangle }{\\sqrt{2}}\\right)\n", + " $$ \n", + " Utilizando a API _Qiskit_ disponibilizada pela IBM a preparação do estado ficaria da seguinte forma:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
        ┌───┐     \n",
+       "q_0: |0>┤ H ├─────\n",
+       "        ├───┤     \n",
+       "q_1: |0>┤ H ├─────\n",
+       "        ├───┤┌───┐\n",
+       "q_2: |0>┤ X ├┤ H ├\n",
+       "        └───┘└───┘\n",
+       " c_0: 0 ══════════\n",
+       "                  \n",
+       " c_1: 0 ══════════\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qub = QuantumRegister(3,'q')\n", + "cb = ClassicalRegister(2,'c')\n", + "qc = QuantumCircuit(qub,cb)\n", + "qc.h(qub[0])\n", + "qc.h(qub[1])\n", + "#Preparando a ancila\n", + "qc.x(qub[2])\n", + "qc.h(qub[2])\n", + "#Drawing circuits\n", + "qc.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Aplicando o Oracle\n", + " Agora seja $f$ uma função que \"busca\" pela cadeia $11$, então ao aplicar a inversão de fase o estado resultante ficaria da seguinte forma:\n", + " \n", + " $$\n", + " \\frac{1}{2}\\left(|00\\rangle + |01\\rangle + |10\\rangle - |11\\rangle\\right)\\left(\\frac{| 0 \\rangle - | 1\\rangle }{\\sqrt{2}}\\right)\n", + " $$\n", + " \n", + " Explicando de forma simplificada, é como se o estado $11$ estivesse sendo marcado para que a busca pudesse ser efetuada.\n", + " Um operador que já implementa esta função é o operador $Toffoli$ o qual já se encontra implementado na API do _Qiskit_." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
        ┌───┐          \n",
+       "q_0: |0>┤ H ├───────■──\n",
+       "        ├───┤       │  \n",
+       "q_1: |0>┤ H ├───────■──\n",
+       "        ├───┤┌───┐┌─┴─┐\n",
+       "q_2: |0>┤ X ├┤ H ├┤ X ├\n",
+       "        └───┘└───┘└───┘\n",
+       " c_0: 0 ═══════════════\n",
+       "                       \n",
+       " c_1: 0 ═══════════════\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc.ccx(qub[0], qub[1], qub[2])\n", + "qc.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Para fins de demonstração efetuaremos uma medição nos qubits para verificar as probabilidades do sistema somente com a inversão de fase." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
        ┌───┐          ┌─┐   \n",
+       "q_0: |0>┤ H ├───────■──┤M├───\n",
+       "        ├───┤       │  └╥┘┌─┐\n",
+       "q_1: |0>┤ H ├───────■───╫─┤M├\n",
+       "        ├───┤┌───┐┌─┴─┐ ║ └╥┘\n",
+       "q_2: |0>┤ X ├┤ H ├┤ X ├─╫──╫─\n",
+       "        └───┘└───┘└───┘ ║  ║ \n",
+       " c_0: 0 ════════════════╩══╬═\n",
+       "                           ║ \n",
+       " c_1: 0 ═══════════════════╩═\n",
+       "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc.measure(qub[0],cb[0])\n", + "qc.measure(qub[1],cb[1])\n", + "qc.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Considerando este reusltado podemos fazer as seguintes observações: Se aplicarmos uma medição nos qubits superiores qualquer um dos estados poderia ser retornado com mesma probabilidade dado que $\\left| \\frac{1}{2} \\right|^2 = \\left| - \\frac{1}{2} \\right|^2 $ o que não é muito interessante para quem faz a busca.\n", + " Por isso que o algoritmo de Grover faz uso de um passo muito importante para resolver este problema chamado de _inversão sobre a média_. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Select the QasmSimulator from the Aer provider\n", + "simulator = Aer.get_backend('qasm_simulator')\n", + "\n", + "# Execute and get counts\n", + "result = execute(qc, simulator).result()\n", + "counts = result.get_counts(qc)\n", + "plot_histogram(counts, title='O indíce procurado')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inversão sobre a média\n", + "\n", + " Considere a o seguinte vetor de tamanho $5$ com os seguintes valores : $\\left[4,5,10,3,3\\right]$. Sabendo que média desses números é $5$, como inverter seus valores em relação à média? Primeiramente deve-se calcular a distância entre o valor e a média, matemáticamente isto é feito subtraindo a média $m$ e o valor $v$: $m-v$ . Em seguinda pegamos o resultado e o somamos à média mais uma vez: $m - v + m$ ou $ -v + 2m$. \n", + " \n", + " Agora considere que ao invés de calcular a inversão sobre a média de cada valor individualmente, queiramos calcular a inversão sobre a média dos valores no vetor utilizando operações matriciais. Como fazê-lo?\n", + " \n", + " Sabendo que para calcular a média soma-se todos os valores e o resultado é dividido pelo número de valores somados. Ou seja $\\frac{1}{n}\\sum_{i=1}^{n} x_i$ , para $n$ o número de valores somados e $x_i$ o $i$-ésimo valor. Agora considere o coeficiente $\\frac{1}{n}$. Retomando o uso do vetor $\\left[4,5,10,3,3\\right]$ podemos calcular a média desse vetor aplicando a seguinte operação: \n", + " $$\\left[\\begin{array}{ccccc}\n", + " \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} \\\\\n", + " \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} \\\\\n", + " \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} \\\\\n", + " \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} \\\\\n", + " \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} & \\frac{1}{5} \\\\\n", + " \\end{array}\\right]\n", + " \\left[\\begin{array}{c}\n", + " 4 \\\\\n", + " 5 \\\\\n", + " 10\\\\\n", + " 3 \\\\\n", + " 3 \\\\\n", + " \\end{array}\\right] \n", + " = \n", + " \\left[\\begin{array}{c}\n", + " 5 \\\\\n", + " 5 \\\\\n", + " 5\\\\\n", + " 5 \\\\\n", + " 5 \\\\\n", + " \\end{array}\\right]$$\n", + " \n", + " As células da primeira matriz estão todas com valor $\\frac{1}{5}$ pois trata-se do coeficiente utilizado no somatório da média. Por simplicidade chamaremos a matriz cujas todas células estão com valor $\\frac{1}{5}$ de $A$. \n", + " \n", + " Desse modo, matricialmente falando. A operação de inversão sobre a média de um vetor $V$ ocorre da seguinte forma:\n", + " $$\n", + " \\bar{V} = -V + 2AV \n", + " $$\n", + " Evidenciando o vetor $V$ obtemos: $(-I + 2A)V$. Desse modo, o operador de inversão sobre a média é obtido a partir da operação matricial: \n", + " $$\n", + " -I + 2A\n", + " $$\n", + " \n", + " ### Implementando inversão sobre a média\n", + " \n", + " Sob a perspectiva de computação quântica este operador pode ser obtido a partir da seguinte fórmula: \n", + " \n", + " $$\n", + " H^{\\otimes n}\\left(2|0\\rangle\\langle0| - I \\right)H^{\\otimes n}\n", + " $$\n", + " \n", + " Considerando a entrada do sistema $|\\psi\\rangle$, a qual será efetuada a busca, como de uma superposição de todos os estados possíveis. Ou seja : $H^{\\otimes n} | 0 \\rangle^{\\otimes n} = |\\psi\\rangle$.\n", + " E Considerando tanto $|0\\rangle$ como $\\langle 0|$ como vetores de dimensão $n$ obtemos:\n", + " \n", + " $$\n", + " 2|\\psi\\rangle\\langle\\psi | - I\n", + " $$\n", + " \n", + "\n", + " Do ponto de vista de implementação o passo a passo para aplicar a inversão sobre a média no sistema seria da seguinte forma: \n", + " 1. Aplicar transformações de Hadamard $H^{\\otimes n}$\n", + " 2. Aplicar mudança de fase condicional nos estados, com toda a base computacional recebendo -1 exceto o estado $|0\\rangle^{\\otimes n}$
\n", + "$|x\\rangle \\rightarrow -(-1)^{\\delta_x0}|x\\rangle$
\n", + " 3. Reaplicar transformações de Hadamard $H^{\\otimes n}$\n", + " \n", + " A aplicação do operador $U_f$(ou oracle)junto com os três passos $1,2$ e $3$ compõe a interação de Grover ou _Grover's interation_.\n", + " O algoritmo tem que ser executado aproximadamente $\\sigma\\left(\\sqrt{N/M}\\right)$ vezes, mais especificamente a aplicação da interação de Grover no sistema. \n", + " \n", + " \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Circuito Quântico" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nós iremos realizar nossa busca em um vetor com 4 elementos com índices 00, 01, 10, 11.
\n", + "O elemento escolhido para busca é o úlitmo cujo o índice é 11.
\n", + "\n", + "**Antes de Comerçarmos:**
\n", + "Para implementarmos o circuito que irá encontra-lo nós incializamos os nossos qubits,
\n", + "os dois primeiros em $|00\\rangle$ e o último o anclilla qubits em $|1\\rangle$. Após isso
\n", + "aplicaremos a transformação de hadamard a todos os estados." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Inicialização dos estados\n", + "qub = QuantumRegister(3,'q')\n", + "cb = ClassicalRegister(2,'c')\n", + "qc = QuantumCircuit(qub,cb)\n", + "\n", + "#Preparando a ancila\n", + "qc.x(qub[2])\n", + "\n", + "#Hadarmad \n", + "\n", + "qc.barrier()\n", + "\n", + "qc.h(qub)\n", + "qc.barrier()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Antes de irmos em frente:**\n", + "\n", + "Agora faremos a iteração de grover apenas uma vez. Isso acontece porque de forma precisa a
\n", + "quantidade vezes que iremos rodar o procedimento de Grover é cálculada pela seguinte equação:
\n", + "\n", + "$$\n", + "R = CI\\left(\\frac{arccos\\sqrt(M/N)}{\\theta}\\right)\n", + "$$\n", + "\n", + "Onde CI(x) é o valor inteiro mais próximo de x (se o valor for por exemplo 1.5 arredondamos para baixo ficando com 1)
\n", + "e $\\theta$ é dado pela equação:\n", + "\n", + "$$\n", + "sin\\theta = \\frac{2\\sqrt(M(N -M))}{N}\n", + "$$\n", + "\n", + "\n", + "Nós podemos resumir tudo isso na seguinte expressão: $ R \\leq \\lceil \\pi/2\\theta \\rceil$.
\n", + "No nosso caso valor the $\\theta$ será de $\\pi/3$ o que nós daria um valor proximado de 0.5
\n", + "e arredondado de 1.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Seguindo em frente**\n", + "\n", + "1. Aplicar a função Oracle que irá marcar o índice buscado $O$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Oracle\n", + "qc.ccx(qub[0], qub[1], qub[2])\n", + "qc.barrier()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Aplicaremos agora a transformação de Hadamard aos dois primeiros qubits" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#---Hadamard\n", + "qc.h(qub[0])\n", + "qc.h(qub[1])\n", + "\n", + "qc.barrier()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Aplicar mudança de fase condicional nos estados, com toda a base computacional recebendo -1 exceto o estado $|0\\rangle^{\\otimes n}$
\n", + "$|x\\rangle \\rightarrow -(-1)^{\\delta_x0}|x\\rangle$" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#----Troca de fase\n", + "qc.x(qub[0])\n", + "qc.x(qub[1])\n", + "\n", + "qc.h(qub[1])\n", + "\n", + "qc.cx(qub[0], qub[1])\n", + "\n", + "\n", + "qc.h(qub[1])\n", + "\n", + "qc.x(qub[0])\n", + "qc.x(qub[1]) \n", + "qc.barrier()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#--- Hadarmard\n", + "qc.h(qub)\n", + "\n", + "qc.draw(output='mpl')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Após a última aplicação podemos efetuar a medição dos qubits da entrada, ou seja efetuar a medição nos qubits $0$ e $1$. \n", + "O circuito quântico resultante ficaria então da seguinte forma:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc.measure(qub[0],cb[0])\n", + "qc.measure(qub[1],cb[1])\n", + "\n", + "qc.draw(output='mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Select the QasmSimulator from the Aer provider\n", + "simulator = Aer.get_backend('qasm_simulator')\n", + "\n", + "# Execute and get counts\n", + "result = execute(qc, simulator).result()\n", + "counts = result.get_counts(qc)\n", + "plot_histogram(counts, title='Índice Buscado')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Execução em uma máquina real\n", + "\n", + "Para execultar em uma máquina real apenas insira seu API_TOKEN da IBM abaixo:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Informe seu API_TOKEN: ········\n" + ] + } + ], + "source": [ + "import getpass\n", + "\n", + "MY_API_TOKEN = getpass.getpass(\"Informe seu API_TOKEN: \")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Máquinas disponíveis" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "IBMQ.enable_account(MY_API_TOKEN)\n", + "AccountProvider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n", + "AccountProvider.backends(operational=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Escolhendo uma máquina e rodando o algoritmo" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Error checking job status using websocket, retrying using HTTP.\n" + ] + } + ], + "source": [ + "backend = AccountProvider.get_backend('ibmqx4')\n", + "\n", + "job_sim = execute(qc, backend)\n", + "sim_result = job_sim.result()\n", + "\n", + "counts = sim_result.get_counts(deutsch)\n", + "plot_histogram(counts, title='Índice Buscado')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fonte e mais informações: \n", + "\n", + "[IBMQ website](https://quantum-computing.ibm.com/support/guides/quantum-algorithms)
\n", + "[Quantum Computation and Quantum Information](https://books.google.com.br/books/about/Quantum_Computation_and_Quantum_Informat.html?id=-s4DEy7o-a0C&printsec=frontcover&source=kp_read_button&redir_esc=y#v=onepage&q&f=false)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercício\n", + "\n", + " 1. Calcule os valores invertidos sobre a média de cada valor do vetor $\\left[4,5,10,3,3\\right]$\n", + " \n", + " 2. Mostre que $A^2 = A$\n", + " \n", + " 3. Mostre que $-I + 2A$ é um operador unitário, ou seja que $(-I + 2A)(-I + 2A)^{\\dagger} = I$. \n", + " \n", + " 4. O que acontece se repetirmos o exemplo porém aplicarmos _inversão de fase_ e inversão sobre a média quatro vezes?\n", + " \n", + " 5. Fazer o exemplo para uma entrada de três qubits onde $f$ \"escolhe\" a cadeia 001\n", + " 6. Crie um circuito quântico utilizando um oracle diferente. Dica:Verifique a ação de $U_f$ sobre os estados da base ( incluindo a ancila )" + ] + } + ], + "metadata": { + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}