Nota

This page was generated from tutorials/circuits/01_circuit_basics.ipynb.

Run interactively in the IBM Quantum lab.

Básico sobre Circuito¶

Aqui, fornecemos uma visão geral sobre como trabalhar com o Qiskit. O Qiskit fornece os blocos de construção básicos necessários para programar computadores quânticos. A sua unidade fundamental é o quantum circuit. Um fluxo de trabalho básico usando Qiskit consiste de dois estágios: Construir e Executar. Construir permite que você crie diferentes circuitos quânticos que representam o problema que você está resolvendo, e Executar permite que você os execute em diferentes backends. Após a execução dos trabalhos, os dados são coletados e processados dependendo do resultado desejado.

[1]:

import numpy as np
from qiskit import QuantumCircuit

%matplotlib inline

Construindo o circuito¶

O elemento básico necessário para seu primeiro programa é o QuantumCircuit. Começamos por criar um QuantumCircuit composto de três qubits.

[2]:

# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)

After you create the circuit with its registers, you can add gates (“operations”) to manipulate the registers. As you proceed through the tutorials you will find more gates and circuits; below is an example of a quantum circuit that makes a three-qubit GHZ state

\[|\psi\rangle = \left(|000\rangle+|111\rangle\right)/\sqrt{2}.\]

Para criar tal estado, começamos com um registro quântico de três qubits. Por padrão, cada qubit no registro é inicializado como $|0\rangle$. Para criar o estado GHZ, aplicamos as seguintes portas: - Uma porta Hadamard $H$ no qubit 0, que o coloco no estado de superposição $\left(|0\rangle+|1\rangle\right)/\sqrt{2}$. - Uma operação controlada Not ($C_{X}$) entre os qubits 0 e 1. - Uma operação controlada Not entre os qubits 0 e 2.

Em um computador quântico ideal, o estado produzido pela execução deste circuito seria o estado GHZ acima.

No Qiskit, as operações podem ser adicionadas ao circuito uma a uma, como mostrado abaixo.

[3]:

# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)

[3]:

<qiskit.circuit.instructionset.InstructionSet at 0x7fbfb0bd5400>

Visualizar Circuito¶

Você pode visualizar seu circuito usando Qiskit QuantumCircuit.draw(), que desenha o circuito na forma encontrada em muitos livros didáticos.

[4]:

circ.draw('mpl')

[4]:

../../_images/tutorials_circuits_01_circuit_basics_7_0.png

Neste circuito, os qubits são colocados em ordem, com o qubit zero na parte superior e o qubit dois na parte inferior. O circuito é lido da esquerda para a direita (as portas aplicadas antes no circuito aparecem mais para a esquerda).

Ao representar o estado de um sistema multi-qubit, a ordem tensorial utilizada no Qiskit é diferente daquela empregada na maioria dos livros de física. Suponha que existam $n$ qubits, e o qubit $j$ é rotulado como $Q_{j}$. O Qiskit usa uma ordem na qual o qubit $n^{\mathrm{th}}$ está do lado esquerdo do produto tensorial, de forma que os vetores de base são rotulados como $Q_{n-1}\otimes \cdots \otimes Q_1\otimes Q_0$.

Por exemplo, se o qubit zero estiver no estado 0, o qubit 1 no estado 0 e o qubit 2 no estado 1, o Qiskit representaria este estado como $|100\rangle$, enquanto que muitos livros sobre física o representariam como $|001\rangle$.

Essa diferença de rotulagem afeta a forma como as operações multi-qubit são representadas como matrizes. Por exemplo, o Qiskit representa uma operação X-controlada ($C_{X}$) com o qubit 0 sendo o controle e o qubit 1 sendo o alvo como

\[\begin{split}C_X = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\\end{pmatrix}.\end{split}\]

Simulando circuitos¶

Para simular um circuito usamos o módulo quant-info no Qiskit. Tal simulador retorna o estado quântico, que é um vetor complexo de dimensões $2^n$, onde $n$ é o número de qubits (portanto, tenha cuidado ao usá-lo pois ele rapidamente se tornará grande demais para rodar em sua máquina).

There are two stages to the simulator. The fist is to set the input state and the second to evolve the state by the quantum circuit.

[5]:

from qiskit.quantum_info import Statevector

# Set the intial state of the simulator to the ground state using from_int
state = Statevector.from_int(0, 2**3)

# Evolve the state by the quantum circuit
state = state.evolve(circ)

#draw using latex
state.draw('latex')

[5]:

$$ \begin{bmatrix} \tfrac{1}{\sqrt{2}} & 0 & 0 & 0 & 0 & 0 & 0 & \tfrac{1}{\sqrt{2}} \\ \end{bmatrix} $$

Qiskit also provides a visualization toolbox to allow you to view the state.

Below, we use the visualization function to plot the qsphere and a hinton representing the real and imaginary components of the state density matrix $\rho$.

[6]:

state.draw('qsphere')

[6]:

../../_images/tutorials_circuits_01_circuit_basics_13_0.png

[7]:

state.draw('hinton')

[7]:

../../_images/tutorials_circuits_01_circuit_basics_14_0.png

Representação unitária de um circuito¶

Qiskit’s quant_info module also has an operator method which can be used to make a unitary operator for the circuit. This calculates the $2^n \times 2^n$ matrix representing the quantum circuit.

[8]:

from qiskit.quantum_info import Operator

U = Operator(circ)

# Show the results
U.data

[8]:

array([[ 0.70710678+0.j,  0.70710678+0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.70710678+0.j, -0.70710678+0.j],
       [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j,
         0.70710678+0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.70710678+0.j, -0.70710678+0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.70710678+0.j,  0.70710678+0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.70710678+0.j,
        -0.70710678+0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j],
       [ 0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.70710678+0.j,  0.70710678+0.j],
       [ 0.70710678+0.j, -0.70710678+0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j,  0.        +0.j,
         0.        +0.j,  0.        +0.j]])

Backend OpenQASM¶

The simulators above are useful because they provide information about the state output by the ideal circuit and the matrix representation of the circuit. However, a real experiment terminates by measuring each qubit (usually in the computational $|0\rangle, |1\rangle$ basis). Without measurement, we cannot gain information about the state. Measurements cause the quantum system to collapse into classical bits.

For example, suppose we make independent measurements on each qubit of the three-qubit GHZ state

\[|\psi\rangle = (|000\rangle +|111\rangle)/\sqrt{2},\]

and let $xyz$ denote the bitstring that results. Recall that, under the qubit labeling used by Qiskit, $x$ would correspond to the outcome on qubit 2, $y$ to the outcome on qubit 1, and $z$ to the outcome on qubit 0.

Note: This representation of the bitstring puts the most significant bit (MSB) on the left, and the least significant bit (LSB) on the right. This is the standard ordering of binary bitstrings. We order the qubits in the same way (qubit representing the MSB has index 0), which is why Qiskit uses a non-standard tensor product order.

Recall the probability of obtaining outcome $xyz$ is given by

\[\mathrm{Pr}(xyz) = |\langle xyz | \psi \rangle |^{2}\]

and as such for the GHZ state probability of obtaining 000 or 111 are both 1/2.

To simulate a circuit that includes measurement, we need to add measurements to the original circuit above, and use a different Aer backend.

[9]:

# Create a Quantum Circuit
meas = QuantumCircuit(3, 3)
meas.barrier(range(3))
# map the quantum measurement to the classical bits
meas.measure(range(3), range(3))

# The Qiskit circuit object supports composition.
# Here the meas has to be first and front=True (putting it before)
# as compose must put a smaller circuit into a larger one.
qc = meas.compose(circ, range(3), front=True)

#drawing the circuit
qc.draw('mpl')

[9]:

../../_images/tutorials_circuits_01_circuit_basics_20_0.png

This circuit adds a classical register, and three measurements that are used to map the outcome of qubits to the classical bits.

To simulate this circuit, we use the qasm_simulator in Qiskit Aer. Each run of this circuit will yield either the bitstring 000 or 111. To build up statistics about the distribution of the bitstrings (to, e.g., estimate $\mathrm{Pr}(000)$), we need to repeat the circuit many times. The number of times the circuit is repeated can be specified in the execute function, via the shots keyword.

[10]:

# Adding the transpiler to reduce the circuit to QASM instructions
# supported by the backend
from qiskit import transpile

# Use Aer's qasm_simulator
from qiskit.providers.aer import QasmSimulator

backend = QasmSimulator()

# First we have to transpile the quantum circuit
# to the low-level QASM instructions used by the
# backend
qc_compiled = transpile(qc, backend)

# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = backend.run(qc_compiled, shots=1024)

# Grab the results from the job.
result_sim = job_sim.result()

Once you have a result object, you can access the counts via the function get_counts(circuit). This gives you the aggregated binary outcomes of the circuit you submitted.

[11]:

counts = result_sim.get_counts(qc_compiled)
print(counts)

{'000': 505, '111': 519}

Approximately 50 percent of the time, the output bitstring is 000. Qiskit also provides a function plot_histogram, which allows you to view the outcomes.

[12]:

from qiskit.visualization import plot_histogram
plot_histogram(counts)

[12]:

../../_images/tutorials_circuits_01_circuit_basics_26_0.png

As probabilidades estimadas do resultado $\mathrm{Pr}(000)$ e $\mathrm{Pr}(111)$ são computadas dividindo as contagens agregadas pelo número de shots (vezes que o circuito foi repetido). Tente alterar a palavra-chave shots na função execute e veja como as probabilidades estimadas mudam.

[13]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.25.0
Terra	0.17.0
Aer	0.8.0
Ignis	0.6.0
Aqua	0.9.0
IBM Q Provider	0.12.2
System information
Python	3.8.8 (default, Feb 24 2021, 13:46:16) [Clang 10.0.0 ]
OS	Darwin
CPUs	4
Memory (Gb)	32.0
Tue Apr 06 21:48:52 2021 EDT

This code is a part of Qiskit

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

[ ]: