{ "cells": [ { "cell_type": "markdown", "id": "116af785-a9b7-4eaf-8a86-b1eeb235da18", "metadata": {}, "source": [ "---\n", "title: \"Portas fracionárias\"\n", "description: \"Use portas fracionárias para executar rotações de um e dois qubits\"\n", "---\n", "\n", "\n", "\n", "# Portas fracionárias\n", "\n" ] }, { "cell_type": "markdown", "id": "5d679872", "metadata": { "tags": [ "version-info" ] }, "source": [ "{/*\n", " DO NOT EDIT THIS CELL!!!\n", " This cell's content is generated automatically by a script. Anything you add\n", " here will be removed next time the notebook is run. To add new content, create\n", " a new cell before or after this one.\n", " */}\n", "\n", "\n", " \n", " O código desta página foi desenvolvido usando os seguintes requisitos.\n", " Recomendamos o uso dessas versões ou de versões mais recentes.\n", "\n", " ```\n", " qiskit[all]~=2.3.1\n", " qiskit-ibm-runtime~=0.45.1\n", " ```\n", " \n", "\n", "\n" ] }, { "cell_type": "markdown", "id": "f0d7fa16", "metadata": {}, "source": [ "Esta página apresenta dois novos tipos de portas compatíveis com a frota de QPUs IBM Quantum®. Essas portas *fracionárias* são compatíveis com [as QPUs Heron](/docs/guides/processor-types#heron) na forma de:\n", "\n", "* $R_{ZZ}(\\theta)$ para $0 \\lt \\theta \\leq \\pi/2$\n", "* $R_X(\\theta)$ para qualquer $\\theta$\n", "\n", "Esta página discute os casos de uso em que a implementação de portas fracionárias pode melhorar a eficiência de seus fluxos de trabalho, bem como a forma de usar essas portas em IBM Quantum QPUs.\n", "\n" ] }, { "cell_type": "markdown", "id": "ee241e99-d095-4cb5-9506-da3d92c32e1c", "metadata": {}, "source": [ "\n", "\n", "## Como usar portas fracionárias\n", "\n", "Internamente, esses portões fracionários funcionam executando diretamente uma rotação $R_{ZZ}(\\theta)$ e $R_X(\\theta)$ para um ângulo arbitrário. O uso do portão $R_X(\\theta)$ pode reduzir a duração e o erro para rotações de qubit único de ângulo arbitrário em até um fator de dois. A execução direta da rotação do portão $R_{ZZ}(\\theta)$ evita a decomposição em múltiplos `CZGate` objetos, reduzindo de forma semelhante a duração e o erro de um circuito. Isso é especialmente útil para circuitos que contêm muitas rotações de um e dois qubits, como ao simular a dinâmica de um sistema quântico ou ao usar uma abordagem variacional com muitos parâmetros.\n", "\n", "Embora esses tipos de portas façam parte do [conjunto padrão de portas](/docs/guides/circuit-library) que um `QuantumCircuit` pode possuir, elas só podem ser usadas em QPUs específicas do IBM Quantum, e devem ser carregadas com o sinalizador `use_fractional_gates` definido como `True` (conforme mostrado abaixo). Este sinalizador garantirá que os portões fracionários sejam incluídos no backend `Target` do transpilador.\n", "\n", "```python\n", "service = QiskitRuntimeService()\n", "backend = service.backend('ibm_torino', use_fractional_gates=True)\n", "```\n", "\n", "Esse exemplo de código demonstra como usar portas fracionárias no contexto de um fluxo de trabalho que simula a dinâmica de uma cadeia de Ising usando portas fracionárias. A duração do circuito é então comparada com um backend que não usa portas fracionárias.\n", "\n", "\n", " O valor do erro informado no site `Target` de um backend com portas fracionárias ativadas é apenas uma cópia da contraparte da porta não fracionária (que pode não ser a mesma). Isso ocorre porque ainda não há suporte para o relatório de taxas de erro nas portas fracionárias.\n", "\n", " No entanto, como o tempo de porta de portas fracionárias e não fracionárias é o mesmo, é razoável supor que suas taxas de erro sejam comparáveis, especialmente quando a fonte dominante de erro em um circuito se deve ao relaxamento.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "9cb7f696-dec0-4393-9320-fe945326c893", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.circuit import Parameter\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "from qiskit.visualization.timeline import draw as draw_timeline, IQXSimple\n", "\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "\n", "num_qubits = 5\n", "num_time_steps = 3\n", "rx_angle = 0.1\n", "rzz_angle = 0.1\n", "\n", "ising_circuit = QuantumCircuit(num_qubits)\n", "for i in range(num_time_steps):\n", " # rx layer\n", " for q in range(num_qubits):\n", " ising_circuit.rx(rx_angle, q)\n", " for q in range(1, num_qubits - 1, 2):\n", " ising_circuit.rzz(rzz_angle, q, q + 1)\n", " # 2nd rzz layer\n", " for q in range(0, num_qubits - 1, 2):\n", " ising_circuit.rzz(rzz_angle, q, q + 1)\n", " ising_circuit.barrier()\n", "ising_circuit.draw(\"mpl\")" ] }, { "cell_type": "markdown", "id": "983bbe11-fa20-4043-a146-66af18cae054", "metadata": {}, "source": [ "Especifique dois objetos de backend: um com portas fracionárias ativadas e outro com elas desativadas e, em seguida, transpile os dois.\n", "\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "09ef3ed0-7126-45a2-a876-35a4f540c949", "metadata": {}, "outputs": [], "source": [ "service = QiskitRuntimeService()\n", "backend_fractional = service.backend(\"ibm_torino\", use_fractional_gates=True)\n", "backend_conventional = service.backend(\n", " \"ibm_torino\", use_fractional_gates=False\n", ")\n", "\n", "pm_fractional = generate_preset_pass_manager(\n", " optimization_level=3, backend=backend_fractional, scheduling_method=\"alap\"\n", ")\n", "pm_conventional = generate_preset_pass_manager(\n", " optimization_level=3,\n", " backend=backend_conventional,\n", " scheduling_method=\"alap\",\n", ")\n", "\n", "ising_circuit_fractional = pm_fractional.run(ising_circuit)\n", "ising_circuit_conventional = pm_conventional.run(ising_circuit)" ] }, { "cell_type": "markdown", "id": "cf108858-b8ee-44a8-b252-3e7748b691f8", "metadata": {}, "source": [ "Exiba a linha do tempo do circuito usando os dois tipos de portas.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "0013f5fa-4072-4aa4-94fe-7e195435f828", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Draw timeline of circuit with conventional gates\n", "draw_timeline(\n", " ising_circuit_conventional,\n", " idle_wires=False,\n", " target=backend_conventional.target,\n", " time_range=(0, 500),\n", " style=IQXSimple(),\n", ")" ] }, { "cell_type": "code", "execution_count": 4, "id": "08dd1cdf-8b34-47c2-8324-f3538c9d1ab6", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Draw timeline of circuit with fractional gates\n", "draw_timeline(\n", " ising_circuit_fractional,\n", " idle_wires=False,\n", " target=backend_fractional.target,\n", " time_range=(0, 500),\n", " style=IQXSimple(),\n", ")" ] }, { "cell_type": "markdown", "id": "76f9f94e-f402-4519-b991-708b74a4f88c", "metadata": {}, "source": [ "\n", "\n", "### Restrições de ângulo\n", "\n", "Para a porta $R_{ZZ}(\\theta)$ de dois qubits, somente os ângulos entre $0$ e $\\pi/2$ podem ser executados no hardware IBM Quantum. Se um circuito contiver qualquer porta $R_{ZZ}(\\theta)$ com um ângulo fora desse intervalo, o pipeline de transpilação padrão geralmente corrigirá isso com uma transformação de circuito apropriada (por meio da [`FoldRzzAngle`](../api/qiskit-ibm-runtime/transpiler-passes-fold-rzz-angle) passagem). Entretanto, para qualquer porta $R_{ZZ}(\\theta)$ que contenha um ou mais [`Parameter`](../api/qiskit/qiskit.circuit.Parameter)s, o transpilador assumirá que esses parâmetros receberão ângulos dentro desse intervalo no tempo de execução. O trabalho falhará se algum dos valores de parâmetro especificados no PUB enviado para Qiskit Runtime estiver fora desse intervalo.\n", "\n" ] }, { "cell_type": "markdown", "id": "48bad5e6-3c7a-4bd0-b050-e440c3257be2", "metadata": {}, "source": [ "\n", "\n", "## Onde usar portas fracionárias\n", "\n", "Historicamente, as portas de base disponíveis em IBM Quantum QPUs têm sido **`CZ`**, **`X`**, **`RZ`**, **`SX`**, e **`ID`**$\\pi / 2$ por exemplo, uma porta $R_X(\\theta)$, quando transpilada, deve se decompor em uma série de portas $RZ$ e $\\sqrt{X}$, o que cria um circuito com duas portas de duração finita em vez de uma.\n", "\n", "Da mesma forma, quando as rotações de dois qubits, como uma porta $R_{ZZ}(\\theta)$, são transpiladas, a decomposição requer duas portas e várias portas de um qubit, o que aumenta a profundidade do circuito **`CZ`** portas e várias portas de um único qubit, o que aumenta a profundidade do circuito. Essas decomposições são mostradas no código a seguir.\n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "11b003ee-aa8e-4794-a84a-b6870d15fa11", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "qc = QuantumCircuit(1)\n", "param = Parameter(\"θ\")\n", "qc.rx(param, 0)\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "code", "execution_count": 6, "id": "5da9bba4-9a3b-4569-9997-c5b9ccf87b6a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Decomposition of an RX(θ) gate using the IBM Quantum QPU basis\n", "service = QiskitRuntimeService()\n", "backend = service.backend(\"ibm_torino\")\n", "optimization_level = 3\n", "pm = generate_preset_pass_manager(optimization_level, backend=backend)\n", "transpiled_circuit = pm.run(qc)\n", "transpiled_circuit.draw(\"mpl\", idle_wires=False)" ] }, { "cell_type": "code", "execution_count": 7, "id": "6b256201-0237-4f63-91ff-fde1bb884804", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from qiskit import QuantumCircuit\n", "from qiskit.circuit import Parameter\n", "from qiskit.transpiler import generate_preset_pass_manager\n", "\n", "from qiskit_ibm_runtime import QiskitRuntimeService\n", "\n", "qc = QuantumCircuit(2)\n", "param = Parameter(\"θ\")\n", "qc.rzz(param, 0, 1)\n", "qc.draw(\"mpl\")" ] }, { "cell_type": "code", "execution_count": 8, "id": "f07217b9-a6f0-4adf-b341-6da447535c33", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"Output" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Decomposition of an RZZ(θ) gate using the IBM Quantum QPU basis\n", "service = QiskitRuntimeService()\n", "backend = service.backend(\"ibm_torino\")\n", "optimization_level = 3\n", "pm = generate_preset_pass_manager(optimization_level, backend=backend)\n", "transpiled_circuit = pm.run(qc)\n", "transpiled_circuit.draw(\"mpl\", idle_wires=False)" ] }, { "cell_type": "markdown", "id": "5bc4f276-80e4-49af-bd5c-d9dceedc9aa3", "metadata": {}, "source": [ "Para fluxos de trabalho que exigem muitas rotações de um único qubit $R_X(\\theta)$ ou de dois qubits (como em um ansatz variacional ou ao simular a evolução temporal de sistemas quânticos), essa restrição faz com que a profundidade do circuito aumente rapidamente. Entretanto, as portas fracionárias eliminam esse requisito, pois as rotações de um e dois qubits são executadas diretamente e criam um circuito quântico mais eficiente (e, portanto, com supressão de erros).\n", "\n" ] }, { "cell_type": "markdown", "id": "c601cc20-be04-45b6-9917-e8fe2925d36b", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "\n", "\n", "## Quando *não* usar portas fracionárias\n", "\n", "É importante observar que as portas fracionárias são um recurso *experimental* e o comportamento do sinalizador `use_fractional_gates` pode mudar no futuro. Consulte as [notas de versão](/docs/api/qiskit-ibm-runtime/release-notes) das novas versões do site Qiskit Runtime para obter mais informações. Consulte também a documentação de referência da API para [QiskitRuntimeService.backend](/docs/api/qiskit-ibm-runtime/qiskit-runtime-service#backend), que descreve `use_fractional_gates`.\n", "\n", "Além disso, o transpilador do Qiskit tem capacidade limitada para usar o $R_{ZZ}(\\theta)$ em suas passagens de otimização. Isso exige que você tenha mais cuidado ao criar e otimizar os circuitos que contêm essas instruções.\n", "\n", "Por fim, não há suporte para o uso de portas fracionárias:\n", "\n", "* [Giro de Pauli](/docs/guides/error-mitigation-and-suppression-techniques#pauli-twirling) - no entanto, *há* suporte para o [giro de medição com o TREX](/docs/guides/error-mitigation-and-suppression-techniques#twirled-readout-error-extinction-trex).\n", "* [Cancelamento de erro probabilístico](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-cancellation-pec)\n", "* [Extrapolação de ruído zero (usando amplificação de erro probabilístico)](/docs/guides/error-mitigation-and-suppression-techniques#probabilistic-error-amplification-pea)\n", "\n", "Leia o guia sobre [opções primitivas](/docs/guides/runtime-options-overview) para saber mais sobre como personalizar as técnicas de atenuação e supressão de erros para uma determinada carga de trabalho quântica.\n", "\n" ] }, { "cell_type": "markdown", "id": "58fba520-5d6e-4647-8cb7-2c8790eb8127", "metadata": {}, "source": [ "\n", "\n", "## Quais backends suportam portas fracionárias?\n", "\n", "Nem todos os back-ends oferecem suporte a portas fracionárias. Corra `service.backends(use_fractional_gates=True)` para encontrar aqueles que o fazem. Um backend falso só suporta portas fracionárias se o backend “real” correspondente também as suportar.\n", "\n", "Observe que os backends falsos não oferecem suporte a portas fracionárias por padrão, uma vez que essas portas estão desativadas por padrão. Para habilitar portas fracionárias em um backend simulado que as suporte, atualize sua configuração.\n", "\n", "Exemplo:\n", "\n", "```python\n", "service = QiskitRuntimeService()\n", "fake_backend = FakeBoston()\n", "fake_backend.refresh(service=service, use_fractional_gates=True)\n", "```\n", "\n" ] }, { "cell_type": "markdown", "id": "bf0a38a6-60d1-4848-bbde-df19bb496510", "metadata": {}, "source": [ "\n", "\n", "## Próximas etapas\n", "\n", "\n", " * Para saber mais sobre transpilação, consulte a página de [introdução à transpilação](/docs/guides/transpile).\n", " * Leia sobre como [escrever uma passagem de transpilador personalizada](/docs/guides/custom-transpiler-pass).\n", " * Entenda como [configurar a atenuação de erros](/docs/guides/configure-error-mitigation) para Qiskit Runtime.\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "id": "a1b8767d", "source": "© IBM Corp., 2017-2026" } ], "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" } }, "nbformat": 4, "nbformat_minor": 2 }