{ "cells": [ { "cell_type": "markdown", "id": "f767af9e-cdd6-41f4-9279-9e92fa2dde06", "metadata": {}, "source": [ "---\n", "title: \"Explorando a incerteza com o Qiskit\"\n", "description: \"Aprenda quais medições físicas afetam umas às outras e explore a incerteza fundamental na mecânica quântica usando um computador quântico real\"\n", "---\n", "\n", "{/* cspell:ignore prodxz delx delz dely prodxy uparrow downarrow */}\n", "\n", "\n", "\n", "# Explorando a incerteza\n", "\n" ] }, { "cell_type": "markdown", "id": "132cdf03-164e-4334-aab6-206aacacc25b", "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 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 8 minutos de tempo de QPU. Essa é apenas uma estimativa. Seu uso real pode variar. Dois cálculos demorados são marcados como tal nos comentários do cabeçalho e podem ser realizados em simuladores se os alunos estiverem com pouco tempo de QPU. Com eles removidos, o módulo requer apenas \\~30 segundos de tempo de QPU.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "dbda80f2-62c5-4f25-95cf-c5495bc171b1", "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": "4283087e-cc02-467d-b02c-c1c131ad15f3", "metadata": {}, "source": [ "Assista ao passo a passo do módulo pela Dra. Katie McCormick abaixo, ou clique [aqui](https://www.youtube.com/watch?v=3h3pwrECbb8\\&list=PLOFEBzvs-Vvrs2fuvsuT039ariYPsua3d\\&index=5) para assisti-lo em YouTube.\n", "\n", "***\n", "\n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "be385aa2-9080-4c39-aba0-bc35087ced78", "metadata": {}, "source": [ "\n", "\n", "## Introdução\n", "\n", "Você provavelmente já ouviu falar do princípio da incerteza, mesmo fora de seus cursos de física. Uma reafirmação coloquial comum da incerteza é: \"Ao olhar para algo, você o influencia\" Isso é certamente verdade. Mas uma maneira mais física de descrever a incerteza é que há certos observáveis físicos que têm uma incompatibilidade que impede que ambos sejam conhecidos simultaneamente com precisão arbitrária. Muitos alunos encontram pela primeira vez o par de variáveis incompatíveis $x$ e $p_x$, ou seja, a posição ao longo de um eixo chamado eixo $x$ e o momento linear ao longo dessa direção, respectivamente. Para essas variáveis, a restrição de incerteza é escrita $\\Delta x \\Delta p_x \\geq \\frac{\\hbar}{2}.$ Aqui, $\\Delta x$ é chamado de \"incerteza em $x$ \", que tem a mesma definição que o desvio padrão em estatística e pode ser definido como $\\Delta x = \\sqrt{\\langle x^2 \\rangle - \\langle x \\rangle^2}.$ $\\Delta p_x$ é definido da mesma forma.\n", "Aqui, não vamos derivar essa relação de incerteza; vamos salientar que ela é consistente com nosso entendimento das ondas clássicas. Ou seja, uma onda com uma frequência verdadeiramente perfeita $f$ e comprimento de onda $\\lambda$ continuaria indefinidamente como uma senoide perfeita. Em termos de mecânica quântica, isso corresponderia a conhecer perfeitamente o momento de acordo com a hipótese de De Broglie: $\\lambda = h/p$. Mas para saber $where$ onde uma partícula semelhante a uma onda está localizada, a onda que a descreve deve ter um pico mais acentuado no espaço, como um gaussiano muito estreito, por exemplo. Sabemos que podemos expressar qualquer função contínua, inclusive essas funções de onda com picos acentuados, como uma série de Fourier de funções senoidais com diferentes comprimentos de onda. Mas, à medida que a função de onda atinge um pico mais acentuado (e a posição é mais conhecida), precisaremos de mais termos na série de Fourier, o que significa uma mistura de mais comprimentos de onda (e, portanto, mecanicamente quântica, mais valores de momento).\n", "\n", "Em termos mais simples: um estado com um momento bem definido (uma sinusoide perfeita no espaço) tem uma posição muito incerta. Um estado com uma posição bem definida (como uma distribuição delta de Dirac) tem um momento muito incerto.\n", "\n", "Há outras variáveis que apresentam essa incompatibilidade. Por exemplo, o spin de uma partícula pode ter uma projeção bem definida ao longo de um eixo, mas não sabemos nada sobre a projeção em um eixo ortogonal. Por exemplo, o estado $|0\\rangle \\sim |\\uparrow\\rangle$ (para um qubit ou partícula spin-1/2 ) tem uma projeção definida ao longo do eixo $z$ (de 1 no contexto de um qubit e de $\\hbar/2$ no contexto de uma partícula spin-1/2 ). Mas esse estado pode ser escrito como uma superposição de dois estados, cada um dos quais com uma projeção bem definida no eixo $x$ : $|0\\rangle = \\frac{1}{\\sqrt{2}}(|+\\rangle_x+|-\\rangle_x)$ ou, de forma equivalente $\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix} = \\frac{1}{\\sqrt{2}}\\left[\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1\\end{pmatrix}+\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ -1\\end{pmatrix}\\right].$ $|+\\rangle_x$ tem uma projeção bem definida em $x$, assim como $|-\\rangle_x$. Portanto, se especificarmos a projeção de um estado ao longo do eixo $x$, não saberemos a projeção ao longo do eixo $z$. E se especificarmos a projeção no eixo $z$, não saberemos a projeção ao longo de $x$. Há pequenas diferenças quando se discute isso no contexto de spin e em qubits. Mas, de modo geral, os estados próprios das matrizes de Pauli têm uma relação interessante que podemos explorar.\n", "Ao longo desta lição, verificaremos experimentalmente nossa intuição sobre a incerteza nessas variáveis incompatíveis e verificaremos se as relações de incerteza se mantêm nos computadores quânticos IBM®.\n", "\n" ] }, { "cell_type": "markdown", "id": "eb8c7a0c-c962-4efd-ab82-905ba7415284", "metadata": {}, "source": [ "\n", "\n", "## Verificação simples da intuição\n", "\n", "Neste primeiro experimento e em todo o módulo, usaremos uma estrutura para computação quântica conhecida como \"padrões Qiskit\", que divide os fluxos de trabalho nas seguintes etapas:\n", "\n", "* Etapa 1: mapear entradas clássicas para um problema quântico\n", "* Etapa 2: otimizar o problema para a execução quântica\n", "* Etapa 3: Executar usando Qiskit Runtime Primitives\n", "* Etapa 4: Pós-processamento e análise clássica\n", "\n", "Em geral, seguiremos essas etapas, embora nem sempre possamos rotulá-las explicitamente.\n", "\n", "Vamos começar carregando alguns pacotes necessários, incluindo as primitivas de tempo de execução. Também selecionaremos o computador quântico menos ocupado disponível para nós.\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/initialize-account) 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": "c26c8f6f-1ed7-4079-ba21-4747d318996f", "metadata": {}, "outputs": [], "source": [ "from numpy import pi\n", "\n", "# Load the Qiskit Runtime service\n", "from qiskit_ibm_runtime import QiskitRuntimeService\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()" ] }, { "cell_type": "code", "execution_count": 2, "id": "7d34071a-6fb1-4a0a-9e66-c9ee40c3767b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ibm_sherbrooke\n" ] } ], "source": [ "# Load the Runtime primitive and session\n", "from qiskit_ibm_runtime import (\n", " Batch,\n", " SamplerV2 as Sampler,\n", " EstimatorV2 as Estimator,\n", ")\n", "\n", "# Use the least busy backend\n", "backend = service.least_busy(min_num_qubits=127)\n", "print(backend.name)" ] }, { "cell_type": "markdown", "id": "fcbf932e-45b7-4a50-90e1-59dcb7577dfc", "metadata": {}, "source": [ "Se um aluno esgotar seu tempo disponível de computação quântica durante a aula, as linhas abaixo podem ser descomentadas e usadas para configurar um simulador que imite parcialmente o comportamento de ruído do computador quântico selecionado acima.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "7265c432-19eb-41ba-940d-a80541fe0218", "metadata": {}, "outputs": [], "source": [ "# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)\n", "from qiskit_aer.primitives import SamplerV2, EstimatorV2\n", "from qiskit_aer.noise import NoiseModel\n", "\n", "# Generate the noise model from the backend properties\n", "noise_model = NoiseModel.from_backend(backend)\n", "\n", "noisy_sampler = SamplerV2(options={\"backend_options\": {\"noise_model\": noise_model}})\n", "noisy_estimator = EstimatorV2(options={\"backend_options\": {\"noise_model\": noise_model}})" ] }, { "cell_type": "markdown", "id": "5f072c75-efb7-4596-8bc6-ccae553684df", "metadata": {}, "source": [ "Você deve se lembrar que um estado próprio de um operador, Z, não é um estado próprio de outro operador X. Vamos observar isso agora, experimentalmente, fazendo medições ao longo dos eixos $x$ e $z$. Para a medição ao longo de $z$, simplesmente usamos ` qc.measure ()`, pois os computadores quânticos IBM são estruturados para medir ao longo de $z$. Mas para medir ao longo de $x$, precisamos girar o sistema para mover efetivamente o eixo $x$ até a orientação ao longo da qual medimos. Isso é feito com uma porta Hadamard. Há uma etapa semelhante necessária para medições ao longo de $y$. As etapas necessárias estão reunidas aqui por conveniência:\n", "\n", "* Para medir ao longo de $z$ : `qc.measure()`\n", "* Para medir ao longo de $x$ : `qc.h()` então `qc.measure()`\n", "* Para medir ao longo de $y$ : `qc.sdg()`, `qc.h()`, `qc.s`então `qc.measure()`\n", "\n", "\n", "\n", "### Passo 1: Mapear entradas clássicas para um problema quântico\n", "\n", "Nesse caso, a etapa de mapeamento é simplesmente expressar as medições e rotações descritas acima em um circuito quântico:\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "8baef7f9-78bf-48c8-8359-efd65f943d96", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Step 1: Map\n", "\n", "# Import some general packages\n", "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n", "\n", "# Define registers\n", "qr = QuantumRegister(1, \"q\")\n", "cr = ClassicalRegister(2, \"c\")\n", "qc = QuantumCircuit(qr, cr)\n", "\n", "# Add a first measurement\n", "qc.measure(qr, cr[0])\n", "qc.barrier()\n", "\n", "# Change basis so that measurements made on quantum computer which normally tell us about z,\n", "# now tell us about x.\n", "qc.h(qr)\n", "\n", "# Add a second measurement\n", "qc.measure(qr, cr[1])\n", "\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "4d931ec8-6f8f-405f-a9ce-41724435f3a1", "metadata": {}, "source": [ "\n", "\n", "### Etapa 2: Otimizar o problema para execução quântica\n", "\n", "Essa etapa pega as operações que queremos realizar e as expressa em termos da funcionalidade de um computador quântico específico. Ele também mapeia nosso problema no layout do computador quântico.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "d613ac18-61ff-4e91-9f7d-73887bd2306a", "metadata": {}, "outputs": [], "source": [ "# 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", "\n", "qc_isa = pm.run(qc)" ] }, { "cell_type": "markdown", "id": "2f31c2b1-08be-43c7-8af3-5d9ee8a4dab0", "metadata": {}, "source": [ "\n", "\n", "### Etapa 3: Executar usando primitivas de Qiskit Runtime\n", "\n", "Podemos usar o sampler para coletar estatísticas sobre as medições. Vamos construir a primitiva Sampler para ser executada em um computador quântico real usando `mode = backend`. Existem outros modos para outros fluxos de trabalho, e vamos usar um deles a seguir. O Sampler será utilizado chamando seu método run() com uma lista de \"pubs\" (Blocos Primitivos Unificados). Cada pub contém até três valores que, juntos, definem uma unidade de trabalho de cálculo a ser concluída pelo estimador: circuitos, observáveis e parâmetros. Você também pode fornecer uma lista de circuitos, uma lista de observáveis e uma lista de parâmetros. Para obter mais informações, leia a [Visão geral dos PUBs.](/docs/guides/primitive-input-output#pubs)\n", "\n", "Queremos executar em um computador quântico real, de modo que estejamos realizando um experimento de física quântica real. Se você esgotar o tempo alocado em computadores quânticos reais, poderá comentar o código abaixo para o computador quântico e descomentar o código para execução em um simulador.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "8996bcf0-1848-4eda-b5a1-47190fede630", "metadata": {}, "outputs": [], "source": [ "# Step 3: Run the job on a real quantum computer\n", "\n", "\n", "sampler = Sampler(mode=backend)\n", "pubs = [qc_isa]\n", "job = sampler.run(pubs)\n", "res = job.result()\n", "\n", "counts = res[0].data.c.get_counts()\n", "\n", "# Run the job on the Aer simulator with noise model from real backend\n", "\n", "# job = noisy_sampler.run([qc_isa])\n", "# res=job.result()\n", "# counts=res[0].data.c.get_counts()" ] }, { "cell_type": "markdown", "id": "01dedf77-2ea7-45f4-9a84-8cd1caa26c14", "metadata": {}, "source": [ "\n", "\n", "### Etapa 4: Pós-processamento\n", "\n", "Esse é um caso especialmente simples de pós-processamento, no qual simplesmente visualizamos as contagens.\n", "\n", "Observe que o Qiskit ordena qubits, medidas e outros itens listando o item de menor número por último / à direita, uma convenção conhecida como \"little-endian\". Isso significa que a coluna abaixo rotulada como \"10\" refere-se a contagens em que a primeira medição produziu um \"0\" e a segunda medição produziu um \"1\".\n", "\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "7cfeafbf-6a40-4829-9e1d-6c8dbdab9f23", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Step 4: Post-process\n", "\n", "from qiskit.visualization import plot_histogram\n", "\n", "plot_histogram(counts)" ] }, { "cell_type": "markdown", "id": "2d21379b-b27f-4448-adb5-91f55e79b0e2", "metadata": {}, "source": [ "Se essa convenção não lhe agradar, você pode usar o site `marginal_counts` para visualizar os resultados de cada medição separadamente:\n", "\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "8c94042b-0e52-41f3-8231-ede9fab3ee51", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit.result import marginal_counts\n", "\n", "plot_histogram(\n", " marginal_counts(counts, indices=[0]), title=\"Counts after first measurement\"\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "id": "d0ad384b-c2f1-4bc6-8730-ec8a4b593a50", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot_histogram(\n", " marginal_counts(counts, indices=[1]), title=\"Counts after second measurement\"\n", ")" ] }, { "cell_type": "markdown", "id": "258d66a0-ddfc-4c69-8943-37efb7c09b40", "metadata": {}, "source": [ "Por padrão, os estados no Qiskit são inicializados para o estado $|0\\rangle$. Portanto, não é de surpreender que quase todas as primeiras medições tenham resultado em $|0\\rangle$. Observe, entretanto, que houve quase uma divisão uniforme na segunda medição (a que fornece informações sobre projeções do estado em $x$ ). Parece que esse estado que nos dá um resultado muito previsível de medições ao longo de $z$ nos dá um conjunto muito imprevisível de resultados para medições ao longo de $x$. Vamos explorar isso.\n", "\n", "O que acontecerá se as medições forem feitas na ordem oposta? Poderíamos começar usando a porta Hadamard para obter estatísticas sobre a probabilidade de $|0\\rangle$ ser medido em $|\\pm\\rangle_x$. Em seguida, para a segunda medição, mudaremos de volta para a base $z$ usando uma segunda porta Hadamard.\n", "\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "4029873f-1260-4fc3-bfd2-e5a3f579a09c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Step 1:\n", "\n", "# Define registers\n", "qr = QuantumRegister(1, \"q\")\n", "cr = ClassicalRegister(2, \"c\")\n", "qc = QuantumCircuit(qr, cr)\n", "\n", "# Change basis to measure along x.\n", "qc.h(qr)\n", "qc.measure(qr, cr[0])\n", "qc.barrier()\n", "\n", "# Change our basis back to z and make a second measurement\n", "qc.h(qr)\n", "qc.measure(qr, cr[1])\n", "\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "code", "execution_count": 11, "id": "c56d1649-de18-4417-8033-2be2a04a2582", "metadata": {}, "outputs": [], "source": [ "# Step 2: Transpile the circuit for running on a quantum computer\n", "\n", "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", "qc_isa = pm.run(qc)" ] }, { "cell_type": "code", "execution_count": null, "id": "782f01c9-f9c2-4e5e-8638-7c9ba3347bfb", "metadata": {}, "outputs": [], "source": [ "# Step 3: Run the job on a real quantum computer\n", "\n", "sampler = Sampler(mode=backend)\n", "pubs = [qc_isa]\n", "job = sampler.run(pubs)\n", "res = job.result()\n", "counts = res[0].data.c.get_counts()\n", "\n", "# Run the job on the Aer simulator with noise model from real backend\n", "# job = noisy_sampler.run([qc_isa])\n", "# res=job.result()\n", "# counts=res[0].data.c.get_counts()" ] }, { "cell_type": "code", "execution_count": 13, "id": "ce3fb0fd-a859-4c91-b2e5-c09343a397c2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Step 4: Post-process\n", "from qiskit.visualization import plot_histogram\n", "\n", "plot_histogram(counts)" ] }, { "cell_type": "markdown", "id": "d7862ea1-a9fd-4b23-9198-cfbfb05cf3dc", "metadata": {}, "source": [ "Aqui, parece que temos ainda menos previsibilidade! Anteriormente, pelo menos sabíamos qual seria o resultado da primeira medição; agora temos uma distribuição razoavelmente uniforme em todos os estados possíveis. Não é muito difícil entender por que isso aconteceu. Começamos em $|0\\rangle$, que é uma mistura de 50-50 de $|+\\rangle_x$ e $|-\\rangle_x$, de acordo com $|0\\rangle=\\frac{1}{\\sqrt{2}}(|+\\rangle_x+|-\\rangle_x)$ Portanto, é evidente que deve haver a mesma probabilidade de obter o estado + ou - (mapeado como 0 e 1 no gráfico) para a primeira medição. A medição ao longo de $x$ colapsa o estado em um estado próprio $|+\\rangle_x$ ou no estado próprio $|-\\rangle_x$. Cada um desses estados é uma mistura 50-50 de $|0\\rangle$ e $|1\\rangle$, de acordo com $|+\\rangle_x = \\frac{1}{\\sqrt{2}}(|0\\rangle+|1\\rangle)$ $|-\\rangle_x = \\frac{1}{\\sqrt{2}}(|0\\rangle-|1\\rangle)$ Assim, quando o sistema estiver em um estado próprio de $x$, é evidente que as medições ao longo de $z$ produzirão tanto $|0\\rangle$ quanto $|1\\rangle$, e o farão com probabilidade aproximadamente igual.\n", "Portanto, nosso primeiro exemplo nos mostrou que alguns estados terão resultados muito previsíveis em algumas medições, mas resultados imprevisíveis em outras medições. O exemplo atual nos mostra que podemos fazer pior do que isso. Há estados que podem nos dar resultados imprevisíveis para ambas as medições, mesmo se tudo o que fizermos for trocar a ordem das medições. Vamos investigar o grau de certeza ou incerteza de uma quantidade em um determinado estado.\n", "\n" ] }, { "cell_type": "markdown", "id": "292b878f-1792-4f55-8991-49e37c7db58b", "metadata": {}, "source": [ "\n", "\n", "## Cálculo da incerteza\n", "\n", "Podemos quantificar isso usando a incerteza ou a variação. A \"incerteza\" é geralmente definida como a raiz quadrada da \"variância\" de uma distribuição. Ou seja, a incerteza de algum observável $S$ é denotada $\\Delta S$ e é dada por\n", "\n", "$$\n", "\\begin{aligned}\n", "(\\Delta S)^2 & \\equiv \\langle (S - \\langle S \\rangle)^2 \\rangle\\\\\n", "\n", "(\\Delta S)^2 & = \\langle S^2 - 2 S \\langle S \\rangle +\\langle S \\rangle^2 \\rangle\\\\\n", "\n", "(\\Delta S)^2 & = \\langle S^2 \\rangle - \\langle S \\rangle^2\n", "\\end{aligned}\n", "$$\n", "\n", "No caso das matrizes de Pauli, para as quais $S^2 = I$, isso se torna\n", "\n", "$$\n", "(\\Delta S)^2 = 1 - \\langle S \\rangle^2\n", "$$\n", "\n", "Vamos aplicar isso a um exemplo concreto. Vamos começar com o estado $|\\psi\\rangle = |+\\rangle_y = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ i \\end{pmatrix},$ e vamos determinar a incerteza do observável $X$ nesse estado.\n", "\n", "\n", "\n", "#### Verifique sua compreensão\n", "\n", "Calcule a incerteza de $X$ no estado $|+\\rangle_y = |+i\\rangle$, manualmente.\n", "\n", "\n", " \n", " $$\n", " \\Delta X =\\sqrt{\\langle+i| X^2 |+i\\rangle - \\langle+i| X |+i\\rangle^2}\n", " $$\n", "\n", " No estado em questão, isso resulta:\n", "\n", " $$\n", " \\begin{aligned}\n", " \\Delta X & =\\sqrt{\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} \\frac{1}{\\sqrt{2}}\\begin{pmatrix}1 \\\\ i\\end{pmatrix}\\right)^2}\\\\\n", "\n", " \\Delta X & =\\sqrt{\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}1 & 0 \\\\ 0 & 1\\end{pmatrix} \\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}i \\\\ 1\\end{pmatrix}\\right)^2}\\\\\n", "\n", " \\Delta X & =\\sqrt{\\frac{1}{2}\\begin{pmatrix}1 & -i\\end{pmatrix} \\begin{pmatrix}1 \\\\ i\\end{pmatrix} - \\left(\\frac{1}{2}(0))\\right)^2}\\\\\n", "\n", " \\Delta X & =\\sqrt{\\frac{1}{2}(2)} = 1\n", " \\end{aligned}\n", " $$\n", " \n", "\n", "\n", "Podemos criar um estado inicial arbitrário usando `qc.initialize()`. Observe que a sintaxe da unidade imaginária aqui é $1j$.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "bf16b90b-d77a-477b-b432-963f8b81feed", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-0.02408454165642664\n" ] } ], "source": [ "# Step 1: Map the problem into a quantum circuit\n", "\n", "from qiskit.quantum_info import SparsePauliOp\n", "import numpy as np\n", "\n", "obs = SparsePauliOp(\"X\")\n", "\n", "# Define registers\n", "qr = QuantumRegister(1, \"q\")\n", "cr = ClassicalRegister(1, \"c\")\n", "qc = QuantumCircuit(qr, cr)\n", "\n", "# Initialize the state\n", "qc.initialize([1, 1j] / np.sqrt(2))\n", "\n", "# Step 2: Transpile the circuit\n", "\n", "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", "qc_isa = pm.run(qc)\n", "obs_isa = obs.apply_layout(layout=qc_isa.layout)\n", "\n", "# Step 3: Run the circuit on a real quantum computer\n", "\n", "\n", "estimator = Estimator(mode=backend)\n", "pubs = [(qc_isa, obs_isa)]\n", "job = estimator.run([[qc_isa, obs_isa]])\n", "res = job.result()\n", "\n", "# Run the job on the Aer simulator with noise model from real backend\n", "# job = noisy_estimator.run([[qc_isa,obs_isa]])\n", "# res=job.result()\n", "\n", "# Step 4: Return the result in classical form, and analyze.\n", "\n", "print(res[0].data.evs)" ] }, { "cell_type": "markdown", "id": "e162abde-f346-4f2c-8358-d95c818a1021", "metadata": {}, "source": [ "De acordo com nossa equação acima, $(\\Delta X)^2 = 1 - \\langle X \\rangle^2 = 1-(0.0015...)^2 \\rightarrow \\Delta X = 0.999...$ Vamos continuar com esse mesmo estado, mas encontrar o valor esperado de $Z$, agora:\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "c1918196-a26e-4419-8a25-488a3d1d4cc1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.04958271968581247\n" ] } ], "source": [ "# Step 1: Map the problem into a quantum circuit\n", "\n", "obs = SparsePauliOp(\"Z\")\n", "\n", "# Define registers\n", "qr = QuantumRegister(1, \"q\")\n", "cr = ClassicalRegister(1, \"c\")\n", "qc = QuantumCircuit(qr, cr)\n", "\n", "# Initialize the state to |+>_y\n", "qc.initialize([1, 1j] / np.sqrt(2))\n", "\n", "\n", "# Step 2: Transpile the circuit\n", "\n", "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", "qc_isa = pm.run(qc)\n", "obs_isa = obs.apply_layout(layout=qc_isa.layout)\n", "\n", "# Step 3: Run the circuit on a real quantum computer\n", "\n", "estimator = Estimator(mode=backend)\n", "pubs = [(qc_isa, obs_isa)]\n", "job = estimator.run(pubs)\n", "res = job.result()\n", "\n", "# Run the job on the Aer simulator with noise model from real backend\n", "# job = noisy_estimator.run([[qc_isa,obs_isa]])\n", "# res=job.result()\n", "\n", "# Step 4: Return the result in classical form, and analyze.\n", "\n", "print(res[0].data.evs)" ] }, { "cell_type": "markdown", "id": "8ba18eed-5982-45ca-b0ed-5708b7d4aa17", "metadata": {}, "source": [ "Poderíamos fazer os mesmos cálculos de antes, mas veríamos que a variação está novamente muito próxima de 1.0. Poderíamos concluir que $\\Delta X \\Delta Z \\approx 1.0$. De fato, isso é aproximadamente correto para o estado que escolhemos. Mas será que podemos fazer melhor? Ou pior?\n", "\n", "Lembre-se de que há uma relação de incerteza entre a posição em uma direção, $x,$ e o momento na mesma direção, $p_x.$. Para essas variáveis, a forma mais conhecida é provavelmente $\\Delta x \\Delta p_x \\geq \\hbar/2$ Se isso é tudo o que lembramos, podemos nos sentir tentados a pensar que $\\Delta X$ e $\\Delta Z$ também poderiam ter esse limite fundamental de incerteza. Talvez seja impossível que o produto $\\Delta X \\Delta Z$ chegue a zero? Vamos tentar em outro estado e ver se isso se mantém. Desta vez, usaremos $|\\psi\\rangle = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}.$. Vamos ver o que acontece. Observe que, no código abaixo, o estimador pode aceitar dois conjuntos de circuitos e observáveis no mesmo envio de trabalho.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "ef107fd6-03c2-42f2-a51d-e52957cfb82e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The expectation value of the first observable is: 1.0011036174126302\n", "The expectation value of the second observable is: 0.0029429797670141016\n" ] } ], "source": [ "# Step 1: Map the problem into a quantum circuit\n", "\n", "obs1 = SparsePauliOp(\"X\")\n", "obs2 = SparsePauliOp(\"Z\")\n", "\n", "# Define registers\n", "\n", "qr = QuantumRegister(1, \"q\")\n", "cr = ClassicalRegister(1, \"c\")\n", "qc = QuantumCircuit(qr, cr)\n", "\n", "# Initialize the state\n", "qc.initialize([1, 1] / np.sqrt(2))\n", "\n", "# Step 2: Transpile the circuit\n", "\n", "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", "qc_isa = pm.run(qc)\n", "obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n", "obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n", "\n", "# Step 3: Run the circuit on a real quantum computer\n", "\n", "with Batch(backend=backend) as batch:\n", " estimator = Estimator(mode=batch)\n", " pubs = [(qc_isa, obs1_isa), (qc_isa, obs2_isa)]\n", " job = estimator.run(pubs)\n", " res = job.result()\n", "batch.close()\n", "\n", "# Run the job on the Aer simulator with noise model from real backend\n", "\n", "# job = noisy_estimator.run([[qc,obs1],[qc,obs2]])\n", "# res=job.result()\n", "\n", "# Step 4: Return the result in classical form, and analyze.\n", "\n", "print(\"The expectation value of the first observable is: \", res[0].data.evs)\n", "print(\"The expectation value of the second observable is: \", res[1].data.evs)" ] }, { "cell_type": "markdown", "id": "489472e8-eefc-4740-aa7e-eba8e71d0d72", "metadata": {}, "source": [ "O valor esperado de $X$ deve estar próximo de 1.0, mas não deve exceder 1.0. Não se preocupe se ele exceder 1.0 em uma quantidade muito pequena. Isso pode ser atribuído a fatores como ruído e/ou erro de leitura. Embora esse seja um tópico muito importante, podemos ignorá-lo por enquanto.\n", "\n", "Obtivemos um valor de expectativa de $X$ que é muito próximo de 1.0 (correspondendo a uma variação muito baixa para $X$ ). Isso faz com que o produto das duas variações seja bastante baixo:\n", "\n", "$$\n", "\\Delta X \\Delta Z = \\sqrt{1-(0.9853)^2} \\times \\sqrt{1-(-0.00195)^2} = 0.171.\n", "$$\n", "\n", "Embora não seja exatamente zero, esse valor está ficando pequeno em comparação com os valores próprios dos operadores de Pauli ( $\\pm 1$ ). Bem, você deve se lembrar que a relação de incerteza entre a posição linear e o momento pode ser escrita de forma diferente, usando explicitamente a relação de comutação entre os operadores $x$ e $p_x$ :\n", "\n", "$$\n", "\\Delta x \\Delta p_x \\geq \\frac{1}{2}|\\langle [x,p_x] \\rangle|\n", "$$\n", "\n", "em que\n", "\n", "$$\n", "[x,p_x] = xp_x-p_xx\n", "$$\n", "\n", "é o comutador de $x$ e $p_x$.\n", "\n", "Essa é a forma que pode ser estendida mais facilmente para os operadores de Pauli. Em geral, para dois operadores $A$ e $B$,\n", "\n", "$$\n", "\\Delta A \\Delta B \\geq \\frac{1}{2}|\\langle [A,B] \\rangle|.\n", "$$\n", "\n", "E no caso das matrizes de Pauli $X$ e $Z$, precisamos de $[X,Z]$ para calcular\n", "\n", "$$\n", "\\Delta X \\Delta Z \\geq \\frac{1}{2}|\\langle [X,Z] \\rangle|.\n", "$$\n", "\n", "Mostramos isso aqui e deixamos cálculos semelhantes para o leitor como um exercício:\n", "\n", "$$\n", "[X,Z] = XZ-ZX = \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}-\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}\\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\n", "$$\n", "\n", "$$\n", "[X,Z] = \\begin{pmatrix}0 & -1 \\\\ 1 & 0\\end{pmatrix}-\\begin{pmatrix}0 & 1 \\\\ -1 & 0\\end{pmatrix} = 2\\begin{pmatrix}0 & -1 \\\\ 1 & 0\\end{pmatrix}\n", "$$\n", "\n", "Essa é uma resposta perfeitamente aceitável, mas com mais uma etapa, vemos\n", "\n", "$$\n", "[X,Z] = -2i\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}=-2iY\n", "$$\n", "\n", "Assim, nossa relação de incerteza se torna\n", "\n", "$$\n", "\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|.\n", "$$\n", "\n", "\n", "\n", "#### Verifique sua compreensão\n", "\n", "Determine $[X,Y]$ e $[Y,Z]$. Use isso para escrever as relações de incerteza entre $X$ & $Y$, e $Y$ & $Z$.\n", "\n", "\n", " \n", " $$\n", " [X,Y] = XY-YX = \\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}-\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\begin{pmatrix}0 & 1 \\\\ 1 & 0\\end{pmatrix} = 2 \\begin{pmatrix}i & 0 \\\\ 0 & -i\\end{pmatrix}=2iZ\n", " $$\n", "\n", " $$\n", " [Y,Z] = YZ-ZY = \\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}-\\begin{pmatrix}1 & 0 \\\\ 0 & -1\\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix} = 2 \\begin{pmatrix}0 & i \\\\ i & 0\\end{pmatrix}=2iX\n", " $$\n", "\n", " Combinando com a relação geral de incerteza, temos\n", "\n", " $$\n", " \\Delta X \\Delta Y \\geq |\\langle Z \\rangle|,\n", " $$\n", "\n", " $$\n", " \\Delta Y \\Delta Z \\geq |\\langle X \\rangle|.\n", " $$\n", " \n", "\n", "\n", "\n", "\n", "### Verifique a consistência\n", "\n", "Antes de prosseguir, vamos verificar se isso é consistente com nossa descoberta anterior. Usamos o estado $|\\psi\\rangle = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}.$ E descobrimos que $\\Delta X \\Delta Z = 0.171.$ Agora sabemos que esse produto deve ser maior ou igual a\n", "\n", "$$\n", "|\\langle Y \\rangle|=\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 & 1 \\end{pmatrix}\\begin{pmatrix}0 & -i \\\\ i & 0\\end{pmatrix}\\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}\n", "$$\n", "\n", "$$\n", "|\\langle Y \\rangle| = \\frac{1}{2}\\begin{pmatrix} 1 & 1 \\end{pmatrix}\\begin{pmatrix} -i \\\\ i \\end{pmatrix} = \\frac{1}{2}(-i+i) = 0.\n", "$$\n", "\n", "De fato, $\\Delta X \\Delta Z = 0.171 \\geq |\\langle Y \\rangle|=0$\n", "\n" ] }, { "cell_type": "markdown", "id": "0ea50490-36e9-4ab6-b9e1-6840f6dedfec", "metadata": {}, "source": [ "Use as perguntas abaixo para criar alguma intuição para essas descobertas:\n", "\n", "\n", "\n", "#### Verifique sua compreensão\n", "\n", "Responda os itens a seguir em um conjunto:\n", "\n", "(a) Que estados você esperaria que tivessem incerteza zero em $X$?\n", "\n", "(b) Que estados você esperaria que tivessem incerteza zero em $Z$?\n", "\n", "(c) Em que estados você obteria um valor de expectativa zero $\\langle Y \\rangle$?\n", "\n", "(d) As respostas às perguntas acima são consistentes com o caso $\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|$?\n", "\n", "(e) Escreva um código para verificar explicitamente isso usando o estimador.\n", "\n", "\n", " \n", " (a) Poderíamos esperar que os estados próprios do operador $X$ produzissem incerteza zero em $X$. De fato, usando $|\\psi\\rangle = |+\\rangle_x,$, temos $\\Delta X = \\sqrt{1-\\langle X \\rangle^2} = \\sqrt{1-1^2} = 0.$\n", "\n", " (b) Podemos esperar que os estados próprios do operador $Z$ produzam incerteza zero em $Z$. De fato, usando $|\\psi\\rangle = |1\\rangle,$ temos $\\Delta Z = \\sqrt{1-\\langle Z \\rangle^2} = \\sqrt{1-(-1)^2} = 0.$\n", "\n", " (c) Esperamos encontrar $\\langle Y \\rangle=0$ para quaisquer estados que, quando medidos, produzam uma projeção positiva no eixo $y$ com a mesma frequência que uma projeção negativa. Isso inclui os estados próprios de $X$ e $Z$.\n", "\n", " (d) Sim. Seria de se esperar um valor muito pequeno para o produto de incertezas $\\Delta X \\Delta Z $ para estados próprios de $X$ ou $Z$ : $\\Delta X \\Delta Z \\approx 0.$ Isso pode se manter porque também esperamos $\\langle Y \\rangle=0$ para esses mesmos estados. Portanto, a relação de incerteza pode ser satisfeita.\n", "\n", " (e) Um código como o seguinte verificaria isso:\n", "\n", " ```python\n", " obs1 = SparsePauliOp.from_list(\n", " [(\"X\", 1.000)]\n", " )\n", " obs2 = SparsePauliOp.from_list(\n", " [(\"Y\", 1.000)]\n", " )\n", " obs3 = SparsePauliOp.from_list(\n", " [(\"Z\", 1.000)]\n", " )\n", " qc = QuantumCircuit(1,1)\n", " qc.ry(pi/2,0)\n", "\n", " job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)\n", " res=job.result()\n", " ```\n", "\n", " Onde os resultados retornam todos os valores de expectativa. Para recuperar todos os valores de expectativa e calcular as incertezas, podemos usar:\n", "\n", " ```python\n", " xs=res[0].data.evs[0]\n", " ys=abs(res[0].data.evs[1])\n", " zs=res[0].data.evs[2]\n", "\n", " import math\n", " prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5\n", "\n", " ```\n", " \n", "\n", "\n", "Responda os itens a seguir em um conjunto:\n", "\n", "(a) Você consegue pensar em um estado no qual você teria um grande valor de expectativa $\\langle Y \\rangle$?\n", "\n", "(b) Você esperaria que esse mesmo estado tivesse uma incerteza grande ou pequena em $X$?\n", "\n", "(c) Você esperaria que esse mesmo estado tivesse uma incerteza grande ou pequena em $Z$?\n", "\n", "(d) As respostas às perguntas acima são consistentes com o caso $\\Delta X \\Delta Z \\geq |\\langle Y \\rangle|$?\n", "\n", "(e) Escreva um código para verificar explicitamente isso usando o estimador.\n", "\n", "\n", " \n", " (a) Esperamos encontrar $\\langle Y \\rangle\\approx 1$ para o estado próprio de $Y$ : $|+\\rangle_y$.\n", "\n", " (b) Podemos esperar que $X$ tenha uma grande incerteza no estado $|+\\rangle_y,$, pois a medição de $X$ nesse estado produziria um resultado positivo e negativo com a mesma frequência/probabilidade.\n", "\n", " (c) Podemos esperar que $Z$ tenha uma grande incerteza no estado $|+\\rangle_y,$, pois a medição de $Z$ nesse estado produziria um resultado positivo e negativo com a mesma frequência/probabilidade.\n", "\n", " (d) Sim. Seria de se esperar um grande valor para o produto das incertezas $\\Delta X \\Delta Z $ para os estados próprios de $Y,$ e para $|+\\rangle_y,$ especificamente. Também esperamos $\\langle Y \\rangle\\approx 1$ para esse mesmo estado. Portanto, tanto $\\langle Y \\rangle$ quanto $\\Delta X \\Delta Z $ são razoavelmente grandes nesse estado, e é plausível que a relação de incerteza possa ser satisfeita novamente.\n", "\n", " (e) Um código como o seguinte verificaria isso:\n", "\n", " ```python\n", " obs1 = SparsePauliOp.from_list(\n", " [(\"X\", 1.000)]\n", " )\n", " obs2 = SparsePauliOp.from_list(\n", " [(\"Y\", 1.000)]\n", " )\n", " obs3 = SparsePauliOp.from_list(\n", " [(\"Z\", 1.000)]\n", " )\n", " qc = QuantumCircuit(1,1)\n", " qc.rx(-pi/2,0)\n", "\n", " job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)\n", " res=job.result()\n", " ```\n", "\n", " Onde os resultados retornam todos os valores de expectativa. Para recuperar todos os valores de expectativa e calcular as incertezas, podemos usar:\n", "\n", " ```python\n", " xs=res[0].data.evs[0]\n", " ys=abs(res[0].data.evs[1])\n", " zs=res[0].data.evs[2]\n", "\n", " import math\n", " prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5\n", "\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "26f11700-d6be-4ce1-9f97-b2d47ea933ec", "metadata": {}, "source": [ "\n", "\n", "## Testando relações de incerteza\n", "\n", "O teste acima demonstrou apenas a validade da relação de incerteza para uma única escolha de vetor de estado $|\\psi\\rangle = |+\\rangle_x$. Para nos convencermos de que isso é geralmente consistente com o experimento, devemos realizar cálculos semelhantes usando o estimador para muitas opções do vetor de estado. Vamos começar girando nosso vetor de estado para longe do eixo $z$, usando uma porta `RY` para produzir diferentes estados iniciais usando um parâmetro $\\theta$.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "c434a14d-c0ce-40bd-8f5e-7d35722e97bb", "metadata": {}, "outputs": [], "source": [ "# The calculation below uses approximately 3-4 minutes of QPU time.\n", "# Step 1: Map the problem into a quantum circuit\n", "\n", "from qiskit.circuit import Parameter\n", "import numpy as np\n", "\n", "# Specify observables\n", "obs1 = SparsePauliOp(\"X\")\n", "obs2 = SparsePauliOp(\"Y\")\n", "obs3 = SparsePauliOp(\"Z\")\n", "\n", "# Define registers\n", "qr = QuantumRegister(1, \"q\")\n", "cr = ClassicalRegister(1, \"c\")\n", "qc = QuantumCircuit(qr, cr)\n", "\n", "# Rotate away from |0>\n", "theta = Parameter(\"θ\")\n", "qc.ry(theta, 0)\n", "\n", "params = np.linspace(0, 2, num=21)\n", "\n", "# Step 2: Transpile the circuit\n", "\n", "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", "qc_isa = pm.run(qc)\n", "obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n", "obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n", "obs3_isa = obs3.apply_layout(layout=qc_isa.layout)\n", "\n", "# Step 3: Run the circuit on a real quantum computer\n", "\n", "with Batch(backend=backend) as batch:\n", " estimator = Estimator(mode=batch)\n", " pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]\n", " job = estimator.run(pubs, precision=0.01)\n", " res = job.result()\n", "\n", "batch.close()\n", "\n", "# Run the job on the Aer simulator with noise model from real backend\n", "\n", "# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])\n", "# res=job.result()" ] }, { "cell_type": "code", "execution_count": 18, "id": "41d974bb-da9e-459e-8145-294f71cab4c7", "metadata": {}, "outputs": [], "source": [ "# Step 4: Post-processing and classical analysis.\n", "xs = res[0].data.evs[0]\n", "ys = abs(res[0].data.evs[1])\n", "zs = res[0].data.evs[2]\n", "\n", "# Calculate uncertainties\n", "\n", "delx = []\n", "delz = []\n", "prodxz = []\n", "for i in range(len(xs)):\n", " delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)\n", " delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)\n", " prodxz.append(delx[i] * delz[i])" ] }, { "cell_type": "code", "execution_count": 19, "id": "1599d4df-38f8-4171-95ae-6c3c61409201", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Here we can plot the results from this simulation.\n", "import matplotlib.pyplot as plt\n", "\n", "plt.plot(params, delx, label=r\"$\\Delta$ X\")\n", "plt.plot(params, ys, label=r\"$\\langle$ Y $\\rangle$\")\n", "plt.plot(params, delz, label=r\"$\\Delta$ Z\")\n", "plt.plot(params, prodxz, label=r\"$\\Delta$X $\\Delta$Z\")\n", "plt.xlabel(r\"$\\theta$\")\n", "plt.ylabel(\"Expectation/Uncertainty Values\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "1694ab4f-b5e2-46be-b453-2599f73c582d", "metadata": {}, "source": [ "Observe que a curva vermelha $(\\Delta X \\Delta Z)$ é sempre maior do que a curva laranja $\\langle Y \\rangle.$. Às vezes, o produto da incerteza diminui e fica um pouco próximo do limite, outras vezes ele aumenta e fica mais distante do limite, mas sempre obedece à relação de incerteza.\n", "\n", "É claro que esse pode não ser o melhor teste da relação de incerteza, pois nosso limite $\\langle Y \\rangle$ é sempre muito próximo de zero. Vamos usar um estado quântico que tenha uma projeção maior nos estados próprios de $Y$. Especificamente, ainda vamos girar $|0\\rangle$ para baixo a partir do eixo $z$ em ângulos variados, mas agora também vamos girar esse estado resultante em torno de $z$ em algum ângulo, talvez $\\pi/4$, e ver o que acontece.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "id": "c9700dd1-d116-4f94-8c81-70383ce38671", "metadata": {}, "outputs": [], "source": [ "# The calculation below uses approximately 3-4 minutes of QPU time.\n", "from qiskit.circuit import Parameter\n", "import numpy as np\n", "\n", "# Step 1: Map the problem to a quantum circuit\n", "\n", "# Specify observables\n", "obs1 = SparsePauliOp(\"X\")\n", "obs2 = SparsePauliOp(\"Y\")\n", "obs3 = SparsePauliOp(\"Z\")\n", "\n", "# Define registers\n", "qr = QuantumRegister(1, \"q\")\n", "cr = ClassicalRegister(1, \"c\")\n", "qc = QuantumCircuit(qr, cr)\n", "\n", "# Rotate away from |0> along one plane, and then along a transverse direction.\n", "theta = Parameter(\"θ\")\n", "qc.ry(theta, 0)\n", "qc.rz(pi / 4, 0)\n", "\n", "params = np.linspace(0, 2, num=21)\n", "\n", "# Step 2: Transpile the circuit\n", "\n", "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n", "qc_isa = pm.run(qc)\n", "\n", "obs1_isa = obs1.apply_layout(layout=qc_isa.layout)\n", "obs2_isa = obs2.apply_layout(layout=qc_isa.layout)\n", "obs3_isa = obs3.apply_layout(layout=qc_isa.layout)\n", "\n", "# Step 3: Run the circuit on a real quantum computer\n", "\n", "with Batch(backend=backend) as batch:\n", " estimator = Estimator(mode=batch)\n", " pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]\n", " job = estimator.run(pubs, precision=0.01)\n", " res = job.result()\n", "\n", "batch.close()\n", "\n", "# Run the job on the Aer simulator with noise model from real backend\n", "\n", "# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])\n", "# res=job.result()" ] }, { "cell_type": "code", "execution_count": 21, "id": "7e85e759-33a7-4539-80f7-05c769c46144", "metadata": {}, "outputs": [], "source": [ "# Step 4: Post-processing and classical analysis.\n", "xs = res[0].data.evs[0]\n", "ys = abs(res[0].data.evs[1])\n", "zs = res[0].data.evs[2]\n", "\n", "# Calculate uncertainties\n", "\n", "delx = []\n", "delz = []\n", "prodxz = []\n", "for i in range(len(xs)):\n", " delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)\n", " delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)\n", " prodxz.append(delx[i] * delz[i])" ] }, { "cell_type": "code", "execution_count": 22, "id": "6f129a2d-e029-45b7-bb77-bfa83babd8c9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Here we can plot the results from this simulation.\n", "import matplotlib.pyplot as plt\n", "\n", "plt.plot(params, delx, label=r\"$\\Delta$ X\")\n", "plt.plot(params, ys, label=r\"$\\langle$ Y $\\rangle$\")\n", "plt.plot(params, delz, label=r\"$\\Delta$ Z\")\n", "plt.plot(params, prodxz, label=r\"$\\Delta$X $\\Delta$Z\")\n", "plt.xlabel(r\"$\\theta$\")\n", "plt.ylabel(\"Expectation/Uncertainty Values\")\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "7b90bcd5-f561-4f7f-a5a3-7882b3ddb464", "metadata": {}, "source": [ "Agora vemos que o limite da incerteza $(\\Delta X \\Delta Z)$ está sendo posto à prova! A curva vermelha aproxima-se muito mais da curva laranja do que antes. De fato, na ausência de ruído, a relação de incerteza seria exatamente saturada ( $(\\Delta X \\Delta Z) = \\langle Y \\rangle$ ) em um ponto. Na presença de ruído e erro de leitura, não deve ser surpreendente se uma execução ocasionalmente produzir $(\\Delta X \\Delta Z)$ um resultado ligeiramente maior do que $\\langle Y \\rangle.$ isso. Isso não é uma verdadeira violação da incerteza; é apenas um artefato de erro diferente de zero.\n", "\n", "\n", "\n", "#### Verifique sua compreensão\n", "\n", "Explique como você levaria isso ao limite absoluto, tornando $\\langle Y \\rangle$ o maior possível.\n", "\n", "\n", " \n", " Atualmente, o código tem linhas que giram o estado inicial padrão $|0\\rangle$, para baixo a partir do eixo $z$ por algum ângulo parametrizado $\\theta$ e, em seguida, também em torno do eixo $z$ por um ângulo $\\pi/4,$ que gira o vetor de estado em parte do caminho até o eixo $y$.\n", "\n", " `qc.ry(theta,0)`\n", "\n", " `qc.rz(pi/4,0)`\n", "\n", " Poderíamos alterar a rotação em torno de $z$ de $\\pi/4$ para $\\pi/2$, girando até um estado próprio de $Y$ :\n", "\n", " `qc.ry(theta,0)`\n", "\n", " `qc.rz(pi/2,0)`\n", "\n", " Nenhuma outra alteração seria necessária.\n", " \n", "\n", "\n", "Altere o código ou copie-o e implemente essa verificação da relação de incerteza com o valor de expectativa de Y maximizado. A relação de incerteza se mantém?\n", "\n", "\n", " \n", " Usaríamos exatamente o código do exemplo acima, com\n", "\n", " `qc.rz(pi/2,0)`\n", "\n", " trocado para substituir\n", "\n", " `qc.rz(pi/4,0).`\n", "\n", " A figura resultante deve se parecer com a figura abaixo e, sim, o princípio da incerteza ainda deve ser válido.\n", "\n", " ![Um gráfico que compara a incerteza com o valor de expectativa máxima do operador Y.](https://quantum.cloud.ibm.com/learning/images/modules/quantum-mechanics/exploring-uncertainty-with-qiskit/checkin.avif)\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "6dd8c749-00d6-4a08-8d3c-2f5b5f3a0902", "metadata": {}, "source": [ "Modifique o código acima para criar uma imagem semelhante, demonstrando que, a partir de medições no computador quântico, o produto $\\Delta X \\Delta Y$ se comporta como deveria. Escolha qualquer conjunto de estados que desejar.\n", "\n", "\n", " \n", " Usaríamos exatamente o código do exemplo acima e, de cara, poderíamos usar os mesmos resultados acima, apenas usando os valores de expectativa para calcular incertezas diferentes. Por exemplo, poderíamos usar\n", "\n", " ```python\n", " xs=res[0].data.evs[0]\n", " ys=res[0].data.evs[1]\n", " zs=abs(res[0].data.evs[2])\n", " import math\n", " delx = []\n", " dely = []\n", " prodxy=[]\n", " for i in range(len(xs)):\n", " delx.append((1-xs[i]*xs[i])**0.5)\n", " dely.append((1-ys[i]*ys[i])**0.5)\n", " prodxy.append(((1-xs[i]*xs[i])**0.5)*(1-ys[i]*ys[i])**0.5)\n", " ```\n", "\n", " e poderíamos traçar\n", "\n", " ```python\n", " import matplotlib.pyplot as plt\n", " plt.plot(params, delx, label=r'$\\Delta$ X')\n", " plt.plot(params, dely, label=r'$\\langle$ Y $\\rangle$')\n", " plt.plot(params, zs, label=r'$\\Delta$ Z')\n", " plt.plot(params, prodxy, label=r'$\\Delta$X $\\Delta$Z')\n", " plt.xlabel(r'$\\theta$')\n", " plt.ylabel('Expectation/Uncertainty Values')\n", " plt.legend()\n", " plt.show()\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "571a0120-a9d3-44c5-9dce-1b021090f9d1", "metadata": {}, "source": [ "Desafio: Escreva um código para analisar vários valores de $\\phi$, da mesma forma que analisamos vários valores de $\\theta$, e faça um gráfico em 3D mostrando que a relação de incerteza nunca é violada. Escolha os observáveis de sua preferência.\n", "\n" ] }, { "cell_type": "markdown", "id": "b89eaae3-6ea9-486c-b93c-55431839d5f1", "metadata": {}, "source": [ "\n", "\n", "## Perguntas\n", "\n", "Os instrutores podem solicitar versões desses cadernos com chaves de resposta e orientação sobre a colocação em currículos comuns preenchendo esta [pesquisa rápida](https://ibm.biz/classrooms_instructor_key_request) sobre como os cadernos estão sendo usados.\n", "\n", "\n", "\n", "### Conceitos críticos:\n", "\n", "* Existem relações de incerteza entre muitos conjuntos de observáveis físicos, incluindo posição e momento linear, e componentes de spin.\n", "* As matrizes de Pauli não são comutáveis. Esse é um reflexo matemático do fato de que nem todos os componentes do spin podem ser conhecidos/determinados simultaneamente.\n", "* A computação quântica faz uso intenso dos operadores/matrizes de Pauli, portanto, é útil conhecer a relação de incerteza dos operadores de Pauli, bem como dos operadores de spin intimamente relacionados.\n", "* Uma fórmula geral para a incerteza de dois operadores $A$ e $B$ é $\\Delta A \\Delta B \\geq \\frac{1}{2}|\\langle [A,B] \\rangle|.$\n", "* Um estado próprio $|a\\rangle$ de um determinado operador $A$ resulta em incerteza nula na observável física associada a esse operador. Mesmo em termos experimentais, $\\Delta A \\approx 0.$\n", "* Um estado próprio $|a\\rangle$ de algum operador $A$ produzirá uma incerteza maior para um operador $B$ que não comuta com $A$.\n", "* Os resultados experimentais usando um computador quântico real confirmam a intuição que obtemos das representações matriciais de operadores físicos.\n", "\n", "\n", "\n", "### Questões de verdadeiro ou falso:\n", "\n", "1. T/F É possível medir simultaneamente $X$ e $Y$, mas não $Z$.\n", "2. T/F É possível medir simultaneamente $X$ e $Z$, mas não $Y$.\n", "3. T/F Os operadores de posição linear e momento linear não são comutáveis.\n", "4. T/F IBM computadores quânticos medem ao longo de $Z$ por padrão, portanto, é necessário realizar uma rotação para medir em qualquer outra direção.\n", "5. T/F O circuito abaixo mede efetivamente $Z$ e, em seguida, $X$.\n", "\n", "![Um diagrama de circuito mostrando uma medição, uma porta Hadamard e, em seguida, outra medição.](https://quantum.cloud.ibm.com/learning/images/modules/quantum-mechanics/exploring-uncertainty-with-qiskit/tf-q5.avif)\n", "\n", "\n", "\n", "### Perguntas do MC:\n", "\n", "1. O diagrama abaixo demonstra qual das seguintes relações de incerteza?\n", "\n", " * a. $\\Delta X \\Delta Y \\geq |\\langle Z \\rangle|$\n", " * b. $\\Delta Y \\Delta Z \\geq |\\langle X \\rangle|$\n", " * c. $\\Delta Z \\Delta X \\geq |\\langle Y \\rangle|$\n", " * d. Nenhuma das opções acima\n", "\n", "![Um gráfico que compara a incerteza com o valor de expectativa máxima do operador Y.](https://quantum.cloud.ibm.com/learning/images/modules/quantum-mechanics/exploring-uncertainty-with-qiskit/checkin.avif)\n", "\n", "2. Qual das seguintes opções é a sequência padrão para realizar uma medição em $x$?\n", " * a. Somente `qc.measure()`\n", " * b. `qc.h()` então `qc.measure()`\n", " * c. `qc.h()`, `qc.h()` então `qc.measure()`\n", " * d. `qc.h()`, `qc.s`, `qc.h()`então `qc.measure()`\n", " * e. `qc.sdg()`, `qc.h()`, `qc.s` then `qc.measure()`\n", " * f. `qc.sdg()`, `qc.h()`, `qc.s`, `qc.h()` then `qc.measure()`\n", "\n", "3. Qual dos seguintes estados produz o maior valor de expectativa $\\langle X \\rangle$?\n", " * a. $|+\\rangle_x$\n", " * b. $|-\\rangle_x$\n", " * c. $|+\\rangle_y$ também chamado de $|+i\\rangle$\n", " * d. $|-\\rangle_y$ também chamado de $|-i\\rangle$\n", " * e. $|0\\rangle$ também chamado de $|\\uparrow\\rangle$\n", " * f. $|1\\rangle$ também chamado de $|\\downarrow\\rangle$\n", "\n", "4. Qual dos seguintes estados produz a maior incerteza $\\Delta X$?\n", " * a. $|+\\rangle_x$\n", " * b. $|+\\rangle_y$ também chamado de $|+i\\rangle$\n", " * c. $|0\\rangle$ também chamado de $|\\uparrow\\rangle$\n", " * d. a e b estão empatados\n", " * e. b e c estão empatados\n", " * f. a, b e c estão empatados\n", "\n", "\n", "\n", "### Questões para discussão:\n", "\n", "1. Esse conceito de incerteza entra em conflito de alguma forma com a noção de spin como uma seta vetorial no espaço cartesiano? Que tal na esfera de Bloch?\n", "\n", "2. Suponha que você oriente um dispositivo de medição ao longo de uma direção a meio caminho entre os eixos $x$ e $y$. O que acontece? Você pode fazer uma medição nessa direção? Como isso se relaciona com a incerteza em $X$ e $Y$?\n", "\n", "3. Que experimentos adicionais você gostaria de fazer para se convencer dos resultados obtidos aqui?\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": 4 }