Notas de versão do Qiskit 0.25

0.25.4

Terra 0.17.2

Prelúdio

Esta é uma versão de correção de bugs que corrige vários problemas da versão 0.17.1. Mais importante ainda, essa versão corrige a compatibilidade da classe QuantumInstance quando executada em backends baseados na classe BackendV1 classe abstrata. Isso corrige todos os algoritmos e aplicativos criados em qiskit.algorithms ou qiskit.opflow quando executados em backends mais recentes.

Correções de bugs

Foi corrigido um problema com a passagem do BasisTranslator que, em alguns casos, traduzia portas que já estavam na base de destino. Isso poderia resultar em um tempo de execução mais longo e em resultados menos otimizados. Corrigido #6085
Foi corrigido um problema no site SPSA quando o otimizador era inicializado com uma função de retorno de chamada por meio do kwarg callback , o que poderia causar um erro.
Foi corrigido um problema em que o kwarg qiskit.quantum_info.Statevector.expectation_value() e qiskit.quantum_info.DensityMatrix.expectation_value`methods where the ``qargs`() kwarg eram ignorados se o operador fosse um Pauli ou SparsePauliOp objeto operador. Corrigido #6303
Foi corrigido um problema no método qiskit.quantum_info.Pauli.evolve() que poderia ter resultado no retorno do Pauli incorreto quando evoluído por um CZGate, CYGate, ou um SwapGate portão.
Foi corrigido um problema no método qiskit.opflow.SparseVectorStateFn.to_dict_fn() , que anteriormente tinha no máximo uma entrada para o estado totalmente zero devido a um erro de índice.
Foi corrigido um problema no método qiskit.opflow.SparseVectorStateFn.equals() para que ele retorne corretamente True ou False em vez de uma comparação de vetor esparso dos elementos individuais.
Corrige um problema no Statevector e DensityMatrix métodos de probabilidade qiskit.quantum_info.Statevector.probabilities(), qiskit.quantum_info.Statevector.probabilities_dict(), qiskit.quantum_info.DensityMatrix.probabilities(), qiskit.quantum_info.DensityMatrix.probabilities_dict() em que as probabilidades retornadas podem ter ordenação incorreta para determinados valores do qargs kwarg. Corrigido #6320
Foi corrigido um problema em que a classe TaperedPauliSumOp não suportava a multiplicação com o objeto ParameterExpression e também não tinha um método assign_parameters() necessário para trabalhar com objetos ParameterExpression objetos. Corrigido #6127
Corrigida a compatibilidade da classe QuantumInstance quando executada em backends baseados na classe abstrata BackendV1 classe abstrata. Corrigido #6280

Aer 0.8.2

Nenhuma mudança

Ignis 0.6.0

Nenhuma mudança

Aqua 0.9.1

Nenhuma mudança

IBM 0.12.3

Nenhuma mudança

0.25.3

Terra 0.17.1

Nenhuma mudança

Aer 0.8.2

Problemas Conhecidos

Os sites SaveExpectationValue e SaveExpectationValueVariance foram desativados para o método extended_stabilizer dos sites QasmSimulator e AerSimulator devido ao fato de retornarem o valor incorreto para determinados componentes do operador Pauli. Consulte #1227 <https://github.com/Qiskit/qiskit-aer/issues/1227> para obter mais informações e exemplos.

Correções de bugs

Corrige o problema de desempenho com a forma como o atributo de configuração basis_gates foi definido. Anteriormente, havia efeitos colaterais não intencionais na classe de back-end que podiam fazer com que o tempo de execução de simulações repetidas aumentasse gradativamente. Consulte #1229 <https://github.com/Qiskit/qiskit-aer/issues/1229> para obter mais informações e exemplos.
Corrige um erro na instrução do simulador "multiplexer" em que a ordem dos qubits de destino e de controle era invertida em relação à ordem da instrução Qiskit.
Corrige um bug introduzido em 0.8.0, no qual as simulações de GPU alocavam memória de host desnecessária, além da memória da GPU.
Corrige um erro no método do simulador stabilizer dos sites QasmSimulator e AerSimulator , no qual o valor de expectativa para os sites save_expectation_value e snapshot_expectation_value poderia ter o sinal errado para determinados Pauli's do Y .

Ignis 0.6.0

Nenhuma mudança

Aqua 0.9.1

Nenhuma mudança

IBM 0.12.3

Nenhuma mudança

0.25.2

Terra 0.17.1

Nenhuma mudança

Aer 0.8.1

Nenhuma mudança

Ignis 0.6.0

Nenhuma mudança

Aqua 0.9.1

Nenhuma mudança

IBM 0.12.3

Outras observações

O atributo qiskit.providers.ibmq.experiment.analysis_result.AnalysisResult fit agora é opcional.

0.25.1

Terra 0.17.1

Prelúdio

Esta é uma versão de correção de bugs que corrige vários problemas da versão 0.17.0. O mais importante é que essa versão corrige o pacote sdist construído incorretamente para a versão 0.17.0, que não era realmente compilável e estava bloqueando a instalação em plataformas sem binários pré-compilados disponíveis.

Correções de bugs

Foi corrigido um problema em que o atributo global_phase não era preservado no objeto de saída QuantumCircuit quando o método qiskit.circuit.QuantumCircuit.reverse_bits() era chamado. Por exemplo:

import math
from qiskit import QuantumCircuit

qc = QuantumCircuit(3, 2, global_phase=math.pi)
qc.h(0)
qc.s(1)
qc.cx(0, 1)
qc.measure(0, 1)
qc.x(0)
qc.y(1)

reversed = qc.reverse_bits()
print(reversed.global_phase)

agora imprimirá corretamente $\pi$ .

Foi corrigido um problema em que a passagem do transpilador Unroller não preservava a fase global no caso de instruções aninhadas com uma regra em sua definição. Corrigido #6134
Foi corrigido um problema em que o atributo parameter de um objeto ControlledGate criado a partir de um objeto UnitaryGate não estava sendo definido como a matriz unitária do objeto UnitaryGate . Anteriormente, control() estava criando uma matriz ControlledGate com o atributo parameter definido como a versão controlada da matriz UnitaryGate . Isso levaria a uma modificação do parameter do objeto base UnitaryGate e as chamadas subsequentes para inverse() estava criando o inverso de um UnitaryGate com controle duplo. Corrigido #5750
Correção de um problema com os gerenciadores de passes predefinidos level_0_pass_manager e level_1_pass_manager (que correspondem a optimization_level 0 e 1 para transpile()) onde, em alguns casos, eles produziam circuitos que não estavam na base solicitada.
Correção de um bug em que o uso do SPSA com calibração automática da taxa de aprendizado e perturbação (ou seja learning_rate e perturbation são None no inicializador), armazena a calibração para todas as otimizações futuras. Em vez disso, a calibração deve ser feita para cada nova função objetiva.

Aer 0.8.1

Correções de bugs

Foi corrigido um problema com o uso do método matrix_product_state dos simuladores AerSimulator e QasmSimulator ao executar uma simulação com ruído e erros de Kraus. Anteriormente, o método de simulação do estado do produto da matriz não propagava as alterações para os qubits vizinhos após a aplicação da matriz Kraus. Isso foi corrigido para que o resultado da simulação esteja correto. Corrigido #1184 e #1205
Foi corrigido um problema em que a instrução qiskit.extensions.Initialize desativava a otimização da amostragem de medição para os métodos de simulação statevector e matrix_product_state dos simuladores AerSimulator e QasmSimulator , mesmo quando era a primeira instrução de circuito ou aplicada a todos os qubits e, portanto, determinística. Corrigido #1210
Corrigir um problema com as instruções SaveStatevector e SnapshotStatevector quando usadas com o método de simulação extended_stabilizer dos simuladores AerSimulator e QasmSimulator , em que ele retornava um vetor de estado não normalizado. Corrigido #1196
O método de simulação matrix_product_state agora tem suporte para a instrução de estado definido que não existia anteriormente, qiskit.providers.aer.library.SetMatrixProductState, que permite definir o estado de uma simulação em um circuito.

Ignis 0.6.0

Nenhuma mudança

Aqua 0.9.1

IBM 0.12.2

Nenhuma mudança

0.25.0

Esta versão descontinua oficialmente o projeto Qiskit Aqua. Dessa forma, em uma versão futura, o pacote qiskit-aqua será removido do metapacote do Qiskit, o que significa que, nessa versão futura, o pip install qiskit não incluirá mais o qiskit-aqua. Os módulos de aplicativos que são fornecidos pelo qiskit-aqua foram divididos em vários novos pacotes: qiskit-optimization, qiskit-nature, qiskit-machine-learning, e qiskit-finance. Esses pacotes podem ser instalados sozinhos (por meio do comando padrão pip install, por exemplo, pip install qiskit-nature) ou com o restante do metapacote do Qiskit como extras opcionais (por exemplo pip install 'qiskit[finance,optimization]' ou pip install 'qiskit[all]' Os algoritmos principais e o fluxo do operador agora existem como parte do qiskit-terra em qiskit.algorithms e qiskit.opflow. Dependendo do seu uso atual do Aqua, você deve usar os pacotes de aplicativos ou os novos módulos no Qiskit Terra. Para obter mais detalhes sobre como migrar do Qiskit Aqua, você pode consultar o guia de migração.

Terra 0.17.0

Prelúdio

O Qiskit Terra 0.17.0 inclui muitos recursos novos e correções de bugs. O principal recurso novo dessa versão é a introdução das funções qiskit.algorithms e qiskit.opflow que foram migrados e adaptados do projeto qiskit.aqua .

Novos Recurso

A função qiskit.pulse.call() agora pode receber um objeto Parameter juntamente com uma sub-rotina parametrizada. Isso permite atribuir valores diferentes aos Parameter objetos para cada chamada de subrotina.

Por exemplo,

from qiskit.circuit import Parameter
from qiskit import pulse

amp = Parameter('amp')

with pulse.build() as subroutine:
    pulse.play(pulse.Gaussian(160, amp, 40), DriveChannel(0))

with pulse.build() as main_prog:
    pulse.call(subroutine, amp=0.1)
    pulse.call(subroutine, amp=0.3)

O qiskit.providers.models.QasmBackendConfiguration tem um novo campo processor_type que pode ser usado opcionalmente para fornecer informações sobre o processador de um backend no formato: {"family": <str>, "revision": <str>, segment: <str>}. Por exemplo:{"family": "Canary", "revision": "1.0", segment: "A"}

As classes qiskit.pulse.Scheduleqiskit.pulse.Instruction, e qiskit.pulse.Channel agora têm uma propriedade parameter que retornará todos os Parameter usados no objeto e um método is_parameterized() que retornará True se algum parâmetro for usado no objeto.

Por exemplo:

from qiskit.circuit import Parameter
from qiskit import pulse

shift = Parameter('alpha')

schedule = pulse.Schedule()
schedule += pulse.SetFrequency(shift, pulse.DriveChannel(0))

assert schedule.is_parameterized() == True
print(schedule.parameters)

Adicionado um PiecewiseChebyshev ao qiskit.circuit.library para implementar uma aproximação Chebyshev por partes de uma função de entrada. Para uma determinada função $f(x)$ e grau $d$ , essa classe implementa uma aproximação de Chebyshev polinomial por partes em $n$ qubits para $f(x)$ nos intervalos fornecidos. Todos os polinômios na aproximação são de grau $d$ .

Por exemplo:

import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library.arithmetic.piecewise_chebyshev import PiecewiseChebyshev
f_x, degree, breakpoints, num_state_qubits = lambda x: np.arcsin(1 / x), 2, [2, 4], 2
pw_approximation = PiecewiseChebyshev(f_x, degree, breakpoints, num_state_qubits)
pw_approximation._build()
qc = QuantumCircuit(pw_approximation.num_qubits)
qc.h(list(range(num_state_qubits)))
qc.append(pw_approximation.to_instruction(), qc.qubits)
qc.draw(output='mpl')

A classe BackendProperties agora tem um método readout_length() que retorna o comprimento de leitura [sec] do qubit fornecido.
Uma nova classe, ScheduleBlockfoi adicionada ao módulo qiskit.pulse módulo. Essa classe fornece uma nova representação de um programa de pulso. Essa representação é mais adequada para a sintaxe do construtor de pulsos e baseia-se na ordenação relativa de instruções.

Essa representação usa alignment_context em vez de especificar o horário de início t0 para cada instrução. A hora de início da instrução é alocada implicitamente com a transformação especificada e a posição relativa das instruções.

O ScheduleBlock permite o agendamento de instruções preguiçosas, o que significa que podemos atribuir parâmetros arbitrários à duração das instruções.

Por exemplo:
```
from qiskit.pulse import ScheduleBlock, DriveChannel, Gaussian
from qiskit.pulse.instructions import Play, Call
from qiskit.pulse.transforms import AlignRight
from qiskit.circuit import Parameter

dur = Parameter('rabi_duration')

block = ScheduleBlock(alignment_context=AlignRight())
block += Play(Gaussian(dur, 0.1, dur/4), DriveChannel(0))
block += Call(measure_sched)  # subroutine defined elsewhere
```
esse código define um experimento de varredura da duração de um pulso gaussiano seguido de uma medição measure_sched, ou seja, um experimento Rabi. Você pode reutilizar o objeto block para cada duração digitalizada atribuindo um valor de duração de destino.

Adicionada uma nova função array_to_latex() ao módulo qiskit.visualization que pode ser usada para representar e visualizar vetores e matrizes com LaTeX.

from qiskit.visualization import array_to_latex
from numpy import sqrt, exp, pi
mat = [[0, exp(pi*.75j)],
       [1/sqrt(8), 0.875]]
array_to_latex(mat)

O Statevector e DensityMatrix agora têm métodos draw() que permitem que os objetos sejam desenhados como matrizes de texto, objetos IPython Latex, fonte Latex, esferas Q, esferas Bloch e gráficos Hinton. Por padrão, o tipo de saída é a saída equivalente de __repr__ , mas esse padrão pode ser alterado em um arquivo de configuração do usuário definindo a opção state_drawer . Por exemplo:
```
from qiskit.quantum_info import DensityMatrix
dm = DensityMatrix.from_label('r0')
dm.draw('latex')
```
```
from qiskit.quantum_info import Statevector
sv = Statevector.from_label('+r')
sv.draw('qsphere')
```
Além disso, o método draw() agora é usado para a exibição ipython dessas classes, portanto, se você alterar o tipo de saída padrão em um arquivo de configuração do usuário, quando um Statevector ou um objeto DensityMatrix forem exibidos em um notebook jupyter, esse tipo de saída será usado para o objeto.
Pulso qiskit.pulse.Instruction objetos e objetos de pulso paramétrico (por exemplo Gaussian agora suportam o uso de Parameter e ParameterExpression para o parâmetro duration . Por exemplo:
```
from qiskit.circuit import Parameter
from qiskit.pulse import Gaussian

dur = Parameter('x_pulse_duration')
double_dur = dur * 2
rx_pulse = Gaussian(dur, 0.1, dur/4)
double_rx_pulse = Gaussian(double_dir, 0.1, dur/4)
```
Observe que, embora possamos criar uma instrução com um parâmetro duration , adicionar uma instrução com um parâmetro não vinculado duration a uma programação é compatível apenas com a representação recém-introduzida ScheduleBlock. Consulte a seção de notas de versão de problemas conhecidos para obter mais detalhes.

O run() para o método QasmSimulatorPy, StatevectorSimulatorPy, e UnitarySimulatorPy agora recebe um QuantumCircuit (ou uma lista de objetos QuantumCircuit objetos) como entrada. O objeto QasmQobj ainda é suportado por enquanto, mas será descontinuado em uma versão futura.

Para obter um exemplo de como usar isso, consulte:

from qiskit import transpile, QuantumCircuit

from qiskit.providers.basicaer import BasicAer

backend = BasicAer.get_backend('qasm_simulator')

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()

tqc = transpile(circuit, backend)
result = backend.run(tqc, shots=4096).result()

A passagem do CommutativeCancellation tem um novo kwarg opcional no construtor basis_gates, que recebe uma lista dos nomes das portas de base para o backend de destino. Quando especificado, o passe usará apenas portões no basis_gates kwarg. Anteriormente, o passe substituía automaticamente os portões consecutivos que se deslocam com ZGate com o U1Gate incondicionalmente. O kwarg basis_gates permite que você especifique quais portas de rotação z estão presentes na base de destino para evitar isso.
Os construtores da classe Bit e das subclasses, Qubit, Clbit, e AncillaQubitforam atualizados de forma que seus dois parâmetros, register e index , agora são opcionais. Isso permite a criação de objetos de bits que são independentes de um registro.

Uma nova classe, BooleanExpressionfoi adicionada ao módulo qiskit.circuit.classicalfunction módulo. Essa classe permite a criação de um oráculo a partir de uma expressão booleana Python. Por exemplo:

from qiskit.circuit import BooleanExpression, QuantumCircuit

expression = BooleanExpression('~x & (y | z)')
circuit = QuantumCircuit(4)
circuit.append(expression, [0, 1, 2, 3])
circuit.draw('mpl')

circuit.decompose().draw('mpl')

O BooleanExpression também inclui um método, from_dimacs_file()que permite carregar fórmulas descritas no formato DIMACS-CNF. Por exemplo:

from qiskit.circuit import BooleanExpression, QuantumCircuit

boolean_exp = BooleanExpression.from_dimacs_file("simple_v3_c2.cnf")
circuit = QuantumCircuit(boolean_exp.num_qubits)
circuit.append(boolean_exp, range(boolean_exp.num_qubits))
circuit.draw('text')

     ┌───────────────────┐
q_0: ┤0                  ├
     │                   │
q_1: ┤1                  ├
     │  SIMPLE_V3_C2.CNF │
q_2: ┤2                  ├
     │                   │
q_3: ┤3                  ├
     └───────────────────┘

circuit.decompose().draw('text')

q_0: ──o────o────────────
       │    │
q_1: ──■────o────■───────
       │    │    │
q_2: ──■────┼────o────■──
     ┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_3: ┤ X ├┤ X ├┤ X ├┤ X ├
     └───┘└───┘└───┘└───┘

Adicionada uma nova classe, PhaseOraclefoi adicionada ao módulo qiskit.circuit.library módulo. Essa classe permite a construção de circuitos de oráculo de fase a partir de Python expressões booleanas.

from qiskit.circuit.library.phase_oracle import PhaseOracle

oracle = PhaseOracle('x1 & x2 & (not x3)')
oracle.draw('mpl')

Esses oráculos de fase podem ser usados como parte de um algoritmo maior, por exemplo, com qiskit.algorithms.AmplificationProblem:

from qiskit.algorithms import AmplificationProblem, Grover
from qiskit import BasicAer

backend = BasicAer.get_backend('qasm_simulator')

problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
grover = Grover(quantum_instance=backend)
result = grover.amplify(problem)
result.top_measurement

A classe PhaseOracle também inclui um método from_dimacs_file() que permite a construção de um oráculo de fase a partir de um arquivo que descreve uma fórmula no formato DIMACS-CNF.

from qiskit.circuit.library.phase_oracle import PhaseOracle

oracle = PhaseOracle.from_dimacs_file("simple_v3_c2.cnf")
oracle.draw('text')

state_0: ─o───────o──────────────
          │ ┌───┐ │ ┌───┐
state_1: ─■─┤ X ├─■─┤ X ├─■──────
          │ └───┘   └───┘ │ ┌───┐
state_2: ─■───────────────o─┤ Z ├
                            └───┘

Todas as passagens do transpilador (ou seja, quaisquer instâncias de BasePass) agora podem ser chamadas diretamente. A chamada de uma passagem fornece uma interface conveniente para executar a passagem em um objeto QuantumCircuit objeto.

Por exemplo, a execução de uma única passagem de transformação, como BasisTranslatorpode ser feita com:

from qiskit import QuantumCircuit
from qiskit.transpiler.passes import BasisTranslator
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel

circuit = QuantumCircuit(1)
circuit.h(0)

pass_instance = BasisTranslator(sel, ['rx', 'rz', 'cx'])
result = pass_instance(circuit)
result.draw(output='mpl')

Ao executar uma passagem de análise, um conjunto de propriedades (como dict ou PropertySet) precisa ser adicionado como parâmetro e pode ser modificado "no local". Por exemplo:

from qiskit import QuantumCircuit
from qiskit.transpiler.passes import Depth

circuit = QuantumCircuit(1)
circuit.h(0)

property_set = {}
pass_instance = Depth()
pass_instance(circuit, property_set)
print(property_set)

A classe QasmQobjConfig agora tem um kwarg opcional para meas_level e meas_return. Esses campos podem ser usados para permitir a geração de QasmQobj cargas de trabalho que suportam meas_level=1 (dados kernelizados) para trabalhos de circuito (anteriormente, isso era exposto apenas para PulseQobj objetos). A função assemble() foi atualizada para definir esse campo para os objetos QasmQobj objetos que ela gera.
Um novo método tensor() foi adicionado à classe QuantumCircuit classe. Esse método permite tensionar outro circuito com um circuito existente. Esse método funciona de forma análoga ao qiskit.quantum_info.Operator.tensor() e é consistente com a convenção little-endian do Qiskit.

Por exemplo:
```
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
bottom.tensor(top).draw(output='mpl')
```
A classe qiskit.circuit.QuantumCircuit agora suporta metadados arbitrários de forma livre com o atributo metadata atributo. Um usuário (ou programa criado com base no QuantumCircuit) pode anexar metadados a um circuito para uso no rastreamento do circuito. Por exemplo:
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2, user_metadata_field_1='my_metadata',
                    user_metadata_field_2='my_other_value')
```
ou:
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
qc.metadata = {'user_metadata_field_1': 'my_metadata',
               'user_metadata_field_2': 'my_other_value'}
```
Esses metadados não serão usados para influenciar a execução do circuito, mas apenas para rastrear o circuito durante a vida útil do objeto. O atributo metadata persistirá entre quaisquer transformações de circuito, incluindo transpile() e assemble(). A expectativa é que os provedores associem os metadados ao resultado que retornam, para que os usuários possam filtrar os resultados com base nos metadados do circuito, da mesma forma que podem fazer atualmente com QuantumCircuit.name.
Adicionar uma nova classe de operador CNOTDihedral foi adicionada ao módulo qiskit.quantum_info módulo. Essa classe é usada para representar o grupo CNOT-Dihedral, que é gerado pelas portas quânticas CXGate, TGate, e XGate.
Adiciona um operador binário & (__and__) às subclasses BaseOperator (por exemplo qiskit.quantum_info.Operator) no módulo qiskit.quantum_info módulo. Isso é uma forma abreviada de chamar o método classes compose() (ou seja, A & B == A.compose(B)).

Por exemplo:
```
import qiskit.quantum_info as qi

qi.Pauli('X') & qi.Pauli('Y')
```
Adiciona um operador binário & (__and__) a qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix classes. Isso é uma forma abreviada de chamar o método classes evolve() (ou seja, psi & U == psi.evolve(U)).

Por exemplo:
```
import qiskit.quantum_info as qi

qi.Statevector.from_label('0') & qi.Pauli('X')
```
Uma nova porta de 2 qubits, ECRGatea ressonância cruzada de eco (ECR), foi adicionada ao módulo qiskit.circuit.library juntamente com um método correspondente, ecr() para a QuantumCircuit classe. A porta ECR é composta por dois pulsos $CR(\frac{π}{4})$ com um XGate entre eles para o eco. Essa porta é localmente equivalente a um CXGate (pode ser convertida em um CNOT com pré ou pós-rotação local). É a porta nativa no hardware atual do IBM e a compilação para ele permite que as pré/pós-rotações sejam mescladas com o restante do circuito.
Um novo kwarg approximation_degree foi adicionado à função transpile() para permitir a compilação aproximada. Os valores válidos variam de 0 a 1, e um valor mais alto significa menos aproximação. Esse é um mostrador heurístico para experimentar aproximações de circuitos. A interpretação concreta desse número é deixada para cada passe, que pode usá-lo para realizar alguma versão aproximada do passe. Exemplos específicos incluem o UnitarySynthesis pass ou os tradutores or para conjuntos de portas discretas. Se uma passagem não for compatível com essa opção, ela implica a transformação exata.
Duas novas passagens de transpiladores, GateDirection e qiskit.transpiler.passes.CheckGateDirectionforam adicionadas ao módulo qiskit.transpiler.passes módulo. Esses novos passes têm a intenção de ser substitutos mais gerais para CXDirection e CheckCXDirection (que agora estão obsoletos, consulte as notas de obsoletos para obter mais detalhes) que executam a mesma função, mas funcionam com outras portas além de apenas CXGate.
Ao executar no Windows, a execução paralela com a função parallel_map() agora pode ser ativada (ela ainda está desativada por padrão). Para fazer isso, você pode definir parallel = True em um arquivo de configuração do usuário ou definir a variável de ambiente QISKIT_PARALLEL como TRUE (isso também afetará transpile() e assemble() que usam parallel_map() internamente). É importante observar que, ao ativar o paralelismo no Windows, há limitações quanto à forma como o Python inicia processos para o Windows. Consulte a seção Problemas conhecidos abaixo para obter mais detalhes sobre as limitações da execução paralela no Windows.
Uma nova função, hellinger_distance()para calcular a distância de Hellinger entre duas distribuições de contagem foi adicionada ao módulo qiskit.quantum_info módulo.
A função decompose_clifford() no módulo qiskit.quantum_info (que é usada internamente pelo método qiskit.quantum_info.Clifford.to_circuit() ) tem um novo kwarg method que permite selecionar o método de síntese usado, definindo-o como 'AG' ou 'greedy'. Por padrão, para mais de três qubits, ele é definido como 'greedy' , que usa uma rotina de compilação gulosa não otimizada para a síntese de elementos de Clifford, por Bravyi et al. al, que normalmente produz um melhor custo de CX em comparação com o método Aaronson-Gottesman usado anteriormente (para mais de dois qubits). Você pode usar o kwarg method para reverter para o método Aaronson-Gottesman padrão anterior, definindo method='AG'.
A classe Initialize no módulo qiskit.extensions agora pode ser construída usando um número inteiro. Os bits '1' do inteiro inserirão um Reset e um XGate no circuito do qubit correspondente. Isso será feito usando a convenção padrão little-endian do qiskit, ou seja, o bit mais à direita do inteiro definirá o qubit 0. Por exemplo, a configuração do parâmetro em Initialize igual a 5 definirá os qubits 0 e 2 com o valor 1.
```
from qiskit.extensions import Initialize

initialize = Initialize(13)
initialize.definition.draw('mpl')
```
A classe Initialize no módulo qiskit.extensions agora suporta a construção direta de um rótulo Pauli (análogo ao método qiskit.quantum_info.Statevector.from_label() método). O rótulo de Pauli se refere aos estados básicos dos estados próprios de Pauli Z, X, Y. Esses rótulos usam a notação little-endian padrão do Qiskit; por exemplo, um rótulo de '01' inicializaria o qubit 0 em $|1\rangle$ e o qubit 1 em $|0\rangle$ .
```
from qiskit.extensions import Initialize

initialize = Initialize("10+-lr")
initialize.definition.draw('mpl')
```
O kwarg, template_list, para o construtor da passagem qiskit.transpiler.passes.TemplateOptimization agora suporta o recebimento de uma lista de ambos QuantumCircuit e DAGDependency objetos. Anteriormente, apenas QuantumCircuit eram aceitos (que eram internamente convertidos em objetos DAGDependency ) na lista de entrada.
Um novo transpiler pass, qiskit.transpiler.passes.RZXCalibrationBuildercapaz de gerar calibrações e adicioná-las a um circuito quântico, foi introduzida. Essa passagem usa objetos calibrados CXGate e cria as calibrações para objetos qiskit.circuit.library.RZXGate objetos com um ângulo de rotação arbitrário. As programações são criadas esticando e comprimindo os pulsos GaussianSquare das portas de ressonância cruzada com eco.
Novos circuitos de modelo para usar qiskit.circuit.library.RZXGate são adicionados ao módulo qiskit.circuit.library (por exemplo rzx_yz). Isso permite o emparelhamento do TemplateOptimization com a qiskit.transpiler.passes.RZXCalibrationBuilder para encontrar e substituir automaticamente sequências de portas, como CNOT - P(theta) - CNOT, por circuitos mais eficientes baseados em qiskit.circuit.library.RZXGate com uma calibração.
O tipo de saída do matplotlib para o circuit_drawer() e o método draw() para a classe QuantumCircuit agora suporta arquivos de configuração para definir o estilo de visualização. Nas versões anteriores, havia uma funcionalidade básica que permitia que os usuários passassem um kwarg style que recebia um dict para personalizar as cores e outros recursos de exibição da gaveta mpl . Isso agora foi expandido para que esses dicionários possam ser carregados diretamente de arquivos JSON sem a necessidade de passar um dicionário. Isso permite que os usuários criem novos arquivos de estilo e usem esse estilo para visualizações, passando o nome do arquivo de estilo como uma string para o kwarg style .

Para aproveitar esse recurso, é necessário definir a opção circuit_mpl_style_path em um arquivo de configuração do usuário. Essa opção deve ser definida como o caminho que você deseja que o qiskit procure por arquivos JSON de estilo. Se estiver especificando várias entradas de caminho, elas devem ser separadas por :. Por exemplo, a definição de circuit_mpl_style_path = ~/.qiskit:~/user_styles em um arquivo de configuração do usuário procurará arquivos JSON em ~/.qiskit e ~/user_styles.

Um novo kwarg, format_marginal , foi adicionado à função marginal_counts() que, quando definido como True , formata a saída de contagens de acordo com o cregs no circuito e os índices ausentes são representados com um _. Por exemplo:

from qiskit import QuantumCircuit, execute, BasicAer, result
from qiskit.result.utils import marginal_counts
qc = QuantumCircuit(5, 5)
qc.x(0)
qc.measure(0, 0)

result = execute(qc, BasicAer.get_backend('qasm_simulator')).result()
print(marginal_counts(result.get_counts(), [0, 2, 4], format_marginal=True))

Melhorou o desempenho de qiskit.quantum_info.Statevector.expectation_value() e qiskit.quantum_info.DensityMatrix.expectation_value() quando o operador de argumento é um operador Pauli ou SparsePauliOp operador.
O arquivo de configuração do usuário tem duas novas opções de configuração, num_processes e parallel, que são usadas para controlar o comportamento padrão do parallel_map(). A opção parallel é um booleano usado para determinar se parallel_map() será executado em vários processos ou não. Se for definido como False , as chamadas para parallel_map() serão executadas em série, enquanto que se for definido como True , a execução paralela será ativada. A opção num_processes recebe um número inteiro que define quantas CPUs devem ser usadas na execução em paralelo. Por padrão, ele usará o número de núcleos de CPU em um sistema.
Há duas novas variáveis de ambiente, QISKIT_PARALLEL e QISKIT_NUM_PROCS, que podem ser usadas para controlar o comportamento padrão do parallel_map(). A opção QISKIT_PARALLEL pode ser definida como TRUE (qualquer capitalização) para definir o padrão para execução em vários processos quando parallel_map() for chamado. Se for definido com qualquer outro valor, o parallel_map() será executado em série. QISKIT_NUM_PROCS recebe um número inteiro (por exemplo, QISKIT_NUM_PROCS=5) que será usado como o número padrão de processos a serem executados. Ambas terão precedência sobre a opção equivalente definida no arquivo de configuração do usuário.
Um novo método, gradient()foi adicionado à classe ParameterExpression classe. Esse método é usado para avaliar o gradiente de um objeto ParameterExpression objeto.
O método __eq__ (ou seja, o que é chamado quando o operador == é usado) para o operador ParameterExpression agora permite a comparação com um valor numérico. Anteriormente, só era possível comparar duas instâncias de ParameterExpression com ==. Por exemplo:
```
from qiskit.circuit import Parameter

x = Parameter("x")
y = x + 2
y = y.assign(x, -1)

assert y == 1
```
A classe PauliFeatureMap no módulo qiskit.circuit.library agora suporta o ajuste do fator rotacional, $\alpha$ , por meio da configuração usando o kwarg alpha no construtor ou definindo o atributo alpha após a criação. Anteriormente, esse valor era fixado em 2.0. O ajuste desse atributo permite um melhor controle dos limites de decisão e oferece flexibilidade adicional no manuseio dos recursos de entrada sem a necessidade de dimensioná-los explicitamente no conjunto de dados.
Uma nova Gate classe, PauliGatefoi adicionada ao módulo qiskit.circuit.library e o método correspondente, pauli()foi adicionado à classe QuantumCircuit classe. Essa nova classe de porta permite aplicar várias portas pauli individuais a diferentes qubits ao mesmo tempo. Isso é útil principalmente para simuladores que podem usar essa nova porta para implementar com mais eficiência várias portas Pauli simultâneas.
Aprimore o qiskit.quantum_info.Pauli operador. Essa classe agora representa um elemento do grupo Pauli de N-qubit completo, incluindo coeficientes complexos. Ele agora é compatível com os métodos da API do operador, incluindo compose(), dot(), tensor() etc., em que compose e dot são definidos com relação ao grupo Pauli completo.

Essa classe também permite a conversão de e para a representação de string de Pauli por conveniência.

Por exemplo:
```
from qiskit.quantum_info import Pauli

P1 = Pauli('XYZ')
P2 = Pauli('YZX')
P1.dot(P2)
```
Os Pauli's também podem ser anexados diretamente aos QuantumCircuit objetos
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli

circ = QuantumCircuit(3)
circ.append(Pauli('XYZ'), [0, 1, 2])
circ.draw(output='mpl')
```
Métodos adicionais permitem calcular quando dois Pauli's comutam (usando o método commutes() ) ou anticomutação (usando o método anticommutes() ), e calcular o Pauli resultante da conjugação de Clifford $P^\prime = C.P.C^\dagger$ usando o método evolve() método.

Consulte a documentação da API da classe Pauli para obter informações adicionais.
Uma nova função, random_pauli()para gerar um elemento aleatório do grupo N-qubit Pauli foi adicionada ao módulo qiskit.quantum_info módulo.
Uma nova classe, PiecewisePolynomialPauliRotationsfoi adicionada ao módulo qiskit.circuit.library módulo. Esse elemento da biblioteca de circuitos é usado para mapear uma função polinomial por partes, $f(x)$ , que é definida por meio de pontos de interrupção e coeficientes, em amplitudes de qubit. Os pontos de interrupção $(x_0, ..., x_J)$ são um subconjunto de $[0, 2^n-1]$ , em que $n$ é o número de qubits de estado. Os coeficientes correspondentes $[a_{j,1},...,a_{j,d}]$ , onde $d$ é o grau mais alto entre todos os polinômios. Então, $f(x)$ é definido como:

\begin{split}f(x) = \begin{cases} 0, x < x_0 \\ \sum_{i=0}^{i=d}a_{j,i} x^i, x_j \leq x < x_{j+1} \end{cases}\end{split}

onde assumimos implicitamente $x_{J+1} = 2^n$ . E o mapeamento aplicado às amplitudes é dado por

F|x\rangle |0\rangle = \cos(p_j(x))|x\rangle |0\rangle + \sin(p_j(x))|x\rangle |1\rangle

Esse mapeamento é baseado em rotações Y de Pauli controladas e construído usando o PolynomialPauliRotations.

Um novo módulo qiskit.algorithms foi introduzido. Esse módulo contém funcionalidade equivalente ao que foi fornecido anteriormente pelo módulo qiskit.aqua.algorithms (que agora está obsoleto) e fornece os blocos de construção para a construção de algoritmos quânticos. Para obter detalhes sobre a migração de qiskit-aqua para esse novo módulo, consulte o guia de migração.
Um novo módulo qiskit.opflow foi introduzido. Esse módulo contém funcionalidade equivalente ao que foi fornecido anteriormente pelo módulo qiskit.aqua.operators (que agora está obsoleto) e fornece os operadores e as funções de estado que são usados para criar algoritmos quânticos. Para obter detalhes sobre a migração de qiskit-aqua para esse novo módulo, consulte o guia de migração.
Esta é a primeira versão que inclui rodas binárias pré-compiladas para os sistemas Linux aarch64. Se você estiver executando um sistema manylinux2014 compatível com aarch64 Linux, agora há rodas pré-compiladas disponíveis em PyPI,. Não é mais necessário compilar a partir do código-fonte para instalar o qiskit-terra.
A função qiskit.quantum_info.process_fidelity() agora pode ser usada com um canal de destino não unitário. Nesse caso, o valor retornado é equivalente ao valor qiskit.quantum_info.state_fidelity() das matrizes qiskit.quantum_info.Choi normalizadas para os canais.

Observe que os qiskit.quantum_info.average_gate_fidelity() e qiskit.quantum_info.gate_error() ainda exigem que o canal de destino seja unitário e gerarão uma exceção se não for.

Foi adicionada uma nova função de criação de pulsos, qiskit.pulse.macro(). Isso permite que as funções normais do Python sejam decoradas como macros. Isso permite que as funções do construtor de pulsos sejam usadas dentro da função decorada. A macro do construtor pode então ser chamada em um contexto de construção de pulso, permitindo a reutilização do código.

Por exemplo:

from qiskit import pulse

@pulse.macro
def measure(qubit: int):
    pulse.play(pulse.GaussianSquare(16384, 256, 15872),
               pulse.MeasureChannel(qubit))
    mem_slot = pulse.MemorySlot(0)
    pulse.acquire(16384, pulse.AcquireChannel(0), mem_slot)
    return mem_slot

with pulse.build(backend=backend) as sched:
    mem_slot = measure(0)
    print(f"Qubit measured into {mem_slot}")

sched.draw()

Uma nova classe, PauliTwoDesignfoi adicionada ao qiskit.circuit.library que implementa uma forma particular de um circuito de 2 projetos de https://arxiv.org/pdf/1803.11173.pdf Por exemplo, esse circuito pode se parecer com:
```
from qiskit.circuit.library import PauliTwoDesign
circuit = PauliTwoDesign(4, reps=2, seed=5, insert_barriers=True)
circuit.decompose().draw(output='mpl')
```
Uma nova gaveta de pulsos qiskit.visualization.pulse_v2.draw() (cujo pseudônimo é qiskit.visualization.pulse_drawer_v2) já está disponível. Essa nova gaveta de pulso oferece suporte a vários recursos novos que não estão presentes na gaveta de pulso original (pulse_drawer()).
- Truncamento de instruções de pulso longo.
- Visualização de pulsos paramétricos.
- Novas folhas de estilo IQXStandard, IQXSimple, IQXDebugging.
- Visualização das informações do sistema (frequência do canal, etc.) especificando qiskit.providers.Backend objetos para visualização.
- Especificação de objetos axis para plotagem, a fim de permitir uma extensão adicional das plotagens geradas, ou seja, para manipulações de publicação.
As novas folhas de estilo podem usar funções de retorno de chamada que modificam dinamicamente a aparência da imagem de saída, por exemplo, remontando uma coleção de canais, mostrando detalhes de instruções, atualizando a aparência de envelopes de pulso etc Você pode criar funções de retorno de chamada personalizadas e alimentá-las em uma instância de folha de estilo para modificar a aparência da figura sem modificar o código do drawer. Consulte a documentação do módulo de gaveta de pulso para obter detalhes.

Observe que o salvamento de arquivos agora é delegado a Matplotlib. Para salvar arquivos de imagem, você precisa chamar o método savefig com o objeto Figure retornado.
Adiciona um método reverse_qargs() ao método qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix classes. Esse método inverte a ordem dos subsistemas nos estados e é equivalente ao método qiskit.circuit.QuantumCircuit.reverse_bits() para estados de N-qubit. Por exemplo:
```
from qiskit.circuit.library import QFT
from qiskit.quantum_info import Statevector

circ = QFT(3)

state1 = Statevector.from_instruction(circ)
state2 = Statevector.from_instruction(circ.reverse_bits())

state1.reverse_qargs() == state2
```
Adiciona um método reverse_qargs() à classe qiskit.quantum_info.Operator classe. Esse método inverte a ordem dos subsistemas no operador e é equivalente ao método qiskit.circuit.QuantumCircuit.reverse_bits() para operadores de N-qubit. Por exemplo:
```
from qiskit.circuit.library import QFT
from qiskit.quantum_info import Operator

circ = QFT(3)

op1 = Operator(circ)
op2 = Operator(circ.reverse_bits())

op1.reverse_qargs() == op2
```
O método de saída latex para a função qiskit.visualization.circuit_drawer() e o método draw() agora usarão um rótulo definido pelo usuário nos portões da visualização de saída. Por exemplo:
```
import math

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
qc.h(0)
qc.rx(math.pi/2, 0, label='My Special Rotation')

qc.draw(output='latex')
```
O kwarg routing_method para a função transpile() agora aceita uma nova opção, 'none'. Em routing_method='none' , nenhuma passagem de roteamento será executada como parte da transpilação. Se o circuito não se encaixar no mapa de acoplamento, uma TranspilerError será gerada uma exceção.
Uma nova classe de portão, RVGatefoi adicionada ao módulo qiskit.circuit.library juntamente com o método QuantumCircuit método rv(). O RVGate é uma porta de rotação geral, semelhante à porta UGatemas, em vez de especificar os ângulos de Euler, são especificados os três componentes de um vetor de rotação, em que a direção do vetor especifica o eixo de rotação e a magnitude especifica o ângulo de rotação sobre o eixo em radianos. Por exemplo:
```
import math

import np

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
theta = math.pi / 5
phi = math.pi / 3
# RGate axis:
axis = np.array([math.cos(phi), math.sin(phi)])
rotation_vector = theta * axis
qc.rv(*rotation_vector, 0)
```
Não vinculados Parameter usados em um objeto QuantumCircuit agora serão classificados por nome. Isso entrará em vigor para os parâmetros retornados pelo atributo parameters atributo. Além disso, o qiskit.circuit.QuantumCircuit.bind_parameters() e qiskit.circuit.QuantumCircuit.assign_parameters() agora podem receber uma lista de valores a que os vincularão/atribuirão aos parâmetros em ordem ordenada por nome. Anteriormente, esses métodos recebiam apenas um dicionário de parâmetros e valores. Por exemplo:
```
from qiskit.circuit import QuantumCircuit, Parameter

circuit = QuantumCircuit(1)
circuit.rx(Parameter('x'), 0)
circuit.ry(Parameter('y'), 0)

print(circuit.parameters)

bound = circuit.bind_parameters([1, 2])
bound.draw(output='mpl')
```
Os construtores para os arquivos qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix agora podem receber um objeto QuantumCircuit para construir um objeto Statevector e DensityMatrix a partir desse circuito, supondo que os qubits sejam inicializados em $|0\rangle$ . Por exemplo:
```
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

statevector = Statevector(qc)
statevector.draw(output='latex')
```
Novas classes de backend falsas estão disponíveis em qiskit.test.mock. Isso incluiu versões simuladas de ibmq_casablanca, ibmq_sydney, ibmq_mumbai, ibmq_lima, ibmq_belem, ibmq_quito. Como nos outros backends falsos, eles incluem instantâneos de dados de calibração (ou seja, backend.defaults()) e dados de erro (ou seja, backend.properties()) retirados do sistema real e podem ser usados para testes locais, compilação e simulação.

Problemas Conhecidos

Tentativa de adicionar um objeto qiskit.pulse.Instruction com um duration parametrizado (ou seja, o valor de duration é um objeto não vinculado Parameter ou ParameterExpression ) a um objeto qiskit.pulse.Schedule não é compatível. A tentativa de fazer isso resultará em UnassignedDurationError PulseError seja acionado. Essa é uma limitação de como as restrições de sobreposição do Instruction são avaliadas atualmente. Isso é suportado por ScheduleBlockno qual as restrições de sobreposição são avaliadas imediatamente antes da execução.

Nos sistemas Windows, quando a execução paralela está ativada para parallel_map() o paralelismo pode não funcionar quando chamado de um script executado fora de um bloco if __name__ == '__main__': . Isso se deve ao fato de o Python iniciar processos paralelos no Windows. Se um RuntimeError ou AttributeError for gerado por scripts que chamam parallel_map() (incluindo o uso de funções que usam parallel_map() internamente, como transpile()) com o Windows e o paralelismo ativados, você pode tentar incorporar as chamadas de script em if __name__ == '__main__': para contornar o problema. Por exemplo:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, Aer

qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure([0,1], [0,1])
# making another circuit: superpositions
qc2 = QuantumCircuit(2, 2)
qc2.h([0,1])
qc2.measure([0,1], [0,1])
execute([qc1, qc2], Aer.get_backend('qasm_simulator'))

Deve ser mudada para:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, Aer

def main():
    qc1 = QuantumCircuit(2, 2)
    qc1.h(0)
    qc1.cx(0, 1)
    qc1.measure([0,1], [0,1])
    # making another circuit: superpositions
    qc2 = QuantumCircuit(2, 2)
    qc2.h([0,1])
    qc2.measure([0,1], [0,1])
    execute([qc1, qc2], Aer.get_backend('qasm_simulator'))

if __name__ == '__main__':
    main()

se algum erro for encontrado com o paralelismo no Windows.

Notas da Atualização

Os gerentes de passagem predefinidos level_1_pass_manager, level_2_pass_manager, e level_3_pass_manager (que são usados para optimization_level 1, 2 e 3 nos arquivos transpile() e execute() ) agora usam incondicionalmente a passagem Optimize1qGatesDecomposition para otimização da porta de 1 qubit. Anteriormente, esses gerenciadores de passe usavam o passe Optimize1qGates se os portões da base contivessem u1, u2, ou u3. Se você ainda quiser usar o antigo Optimize1qGates antigo, será necessário criar um PassManager personalizado com o passe.
Após a transpilação de um parâmetro QuantumCircuitparametrizado, o atributo global_phase do circuito de saída não poderá mais ser retornado em uma forma simplificada, se a fase global for um ParameterExpression.

Por exemplo:
```
qc = QuantumCircuit(1)
theta = Parameter('theta')

qc.rz(theta, 0)
qc.rz(-theta, 0)

print(transpile(qc, basis_gates=['p']).global_phase)
```
anteriormente retornava 0, mas agora retornará -0.5*theta + 0.5*theta. Essa alteração foi necessária para evitar uma grande penalidade de desempenho no tempo de execução, pois a simplificação de expressões simbólicas pode ser bastante lenta, especialmente se houver muitos objetos em um circuito ParameterExpression objetos em um circuito.
Os BasicAerJob os objetos de trabalho retornados dos back-ends BasicAer agora são instâncias síncronas de JobV1. Isso significa que as chamadas para o run() serão bloqueadas até que a simulação termine de ser executada. Se você quiser restaurar o comportamento assíncrono anterior, precisará envolver o run() com algo que será executado em um thread ou processo separado, como futures.ThreadPoolExecutor ou futures.ProcessPoolExecutor.
A opção allow_sample_measuring para o simulador BasicAer QasmSimulatorPy foi alterada de um padrão de False para True. Isso foi feito para refletir melhor o comportamento padrão real do simulador, que usaria a medição de amostras se o circuito de entrada fosse compatível com isso (mesmo que não estivesse ativado). Se estiver executando um circuito que não seja compatível com a medição de amostras (ou seja, ele tem operações Reset ou se houver operações após uma medição em um qubit), certifique-se de definir explicitamente essa opção como False ao chamar run().
A passagem do CommutativeCancellation agora está ciente das portas da base de destino, o que significa que usará apenas as portas na base especificada. Anteriormente, o passe substituía incondicionalmente os portões consecutivos que comutam com ZGate com o U1Gate. No entanto, agora que a passagem é sensível à base e tem um kwarg, basis_gates, para especificar a base de destino, há uma possível mudança de comportamento se o kwarg não for definido. Quando o kwarg basis_gates não for usado e não houver portas de rotação z variáveis no circuito, não ocorrerá nenhum cancelamento comutativo.
Register (que é a classe principal da QuantumRegister e ClassicalRegister e Bit (que é a classe pai de Qubit e Clbit) agora são imutáveis. Nas versões anteriores, era possível ajustar o valor de um size ou name de um objeto Register e os atributos index ou register de um objeto Bit depois que ele foi criado inicialmente. No entanto, isso levaria a um comportamento inadequado que corromperia a estrutura do contêiner que depende de um hash (como um dict), pois esses atributos são tratados como propriedades imutáveis de um registro ou bit (consulte o número 4705 para obter mais detalhes). Para evitar esse comportamento inadequado, os atributos de um Register e Bit não podem mais ser definidos após a criação inicial. Se você já estava ajustando os objetos em tempo de execução, agora precisará criar um novo objeto Register ou Bit com os novos valores.
O método DAGCircuit.__eq__ (que é usado pelo operador == ), que é usado para verificar a igualdade estrutural de DAGCircuit e QuantumCircuit agora incluirá as instâncias global_phase e calibrations nos campos verificados quanto à igualdade. Isso significa que os circuitos que teriam sido avaliados como iguais em versões anteriores podem não ser mais se o site global_phase ou calibrations diferir entre os circuitos. Por exemplo, em versões anteriores, isso retornaria True:
```
import math

from qiskit import QuantumCircuit

qc1 = QuantumCircuit(1)
qc1.x(0)

qc2 = QuantumCircuit(1, global_phase=math.pi)
qc2.x(0)

print(qc2 == qc1)
```
No entanto, agora, como o atributo global_phase dos circuitos é diferente, o retorno será False.
Os métodos anteriormente obsoletos qubits() e clbits() da classe DAGCircuit que foram descontinuados na versão 0.15.0 Terra, foram removidos. Em vez disso, você deve usar os atributos qubits e clbits da classe DAGCircuit classe. Por exemplo, se você estivesse executando:
```
from qiskit.dagcircuit import DAGCircuit

dag = DAGCircuit()
qubits = dag.qubits()
```
Isso seria substituído por:
```
from qiskit.dagcircuit import DAGCircuit

dag = DAGCircuit()
qubits = dag.qubits
```
Os PulseDefaults retornados pelos backends de pulso falso qiskit.test.mock.FakeOpenPulse2Q e qiskit.test.mock.FakeOpenPulse3Q foram atualizados para ter definições de sequência de pulso mais realistas. Se você estiver usando essas classes de back-end falsas, talvez seja necessário atualizar seu uso devido a essas alterações.
O método de síntese padrão usado pela função decompose_clifford() no módulo quantum_info (que é usada internamente pelo método qiskit.quantum_info.Clifford.to_circuit() ) para mais de 3 qubits agora usa uma rotina de compilação gulosa não otimizada para síntese de elementos de Clifford, por Bravyi et. al. al, que normalmente gera um melhor custo de CX em comparação com o padrão antigo. Se você precisar reverter para o método Aaronson-Gottesman anterior, isso pode ser feito definindo method='AG'.

O módulo qiskit.visualization.interactive, que foi descontinuado na versão 0.15.0, foi removido. Em vez disso, você deve usar as visualizações baseadas no matplotlib:

Função interativa removida	Função matplotlib equivalente
`iplot_bloch_multivector`	`qiskit.visualization.plot_bloch_multivector()`
`iplot_state_city`	`qiskit.visualization.plot_state_city()`
`iplot_state_qsphere`	`qiskit.visualization.plot_state_qsphere()`
`iplot_state_hinton`	`qiskit.visualization.plot_state_hinton()`
`iplot_histogram`	`qiskit.visualization.plot_histogram()`
`iplot_state_paulivec`	`qiskit.visualization.plot_state_paulivec()`

Os atributos de nível superior qiskit.Aer e qiskit.IBMQ agora são carregados lentamente. Isso significa que os objetos sempre existirão e os avisos não serão mais emitidos na importação se qiskit-aer ou qiskit-ibmq-provider não estiverem instalados (ou não puderem ser encontrados por Python ). Se você estava verificando a presença de qiskit-aer ou qiskit-ibmq-provider usando esses atributos de módulo e comparando explicitamente com None ou procurando a ausência do atributo, isso não funcionará mais porque agora eles são sempre definidos como um objeto. Em outras palavras, executar algo como:
```
try:
    from qiskit import Aer
except ImportError:
    print("Aer not available")

or::

try:
    from qiskit import IBMQ
except ImportError:
    print("IBMQ not available")
```
não funcionará mais. Em vez disso, para determinar se esses provedores estão presentes, você pode usar explicitamente qiskit.providers.aer.Aer e qiskit.providers.ibmq.IBMQ:
```
try:
    from qiskit.providers.aer import Aer
except ImportError:
    print("Aer not available")

try:
    from qiskit.providers.ibmq import IBMQ
except ImportError:
    print("IBMQ not available")
```
ou, em vez disso, verifique bool(qiskit.Aer) e bool(qiskit.IBMQ) , por exemplo:
```
import qiskit

if not qiskit.Aer:
    print("Aer not available")
if not qiskit.IBMQ:
    print("IBMQ not available")
```
Essa alteração foi necessária para evitar possíveis problemas de ciclo de importação entre os pacotes qiskit e também para melhorar o tempo de importação quando o Aer ou o IBMQ não estiverem sendo usados.
A opção do arquivo de configuração do usuário suppress_packaging_warnings no arquivo de configuração do usuário e a variável de ambiente QISKIT_SUPPRESS_PACKAGING_WARNINGS não têm mais efeito e serão silenciosamente ignoradas. Os avisos que essa opção controlava foram removidos e não serão mais emitidos no momento da importação do módulo qiskit .
O kwarg condition anteriormente obsoleto para qiskit.dagcircuit.DAGNode foi removido. Ele foi descontinuado na versão 0.15.0. Em vez disso, agora você deve definir a condição clássica no objeto Instruction passado para o construtor DAGNode ao criar um novo nó op .
Ao criar uma nova classe Register (que é a classe pai de QuantumRegister e ClassicalRegister) ou QuantumCircuit com um número de bits (por exemplo, QuantumCircuit(2)), agora é necessário que o número de bits seja especificado como um número inteiro ou outro tipo que possa ser convertido em números inteiros não ambíguos (por exemplo, 2.0). Os valores não inteiros agora geram um erro, pois a intenção nesses casos não era clara (você não pode ter bits fracionários). Para obter mais informações sobre por que isso foi alterado, consulte: #4855
o networkx não é mais um requisito para o qiskit-terra. Todo o uso do networkx no qiskit-terra foi removido, com exceção de três métodos:
- qiskit.dagcircuit.DAGCircuit.to_networkx
- qiskit.dagcircuit.DAGCircuit.from_networkx
- qiskit.dagcircuit.DAGDependency.to_networkx
Se estiver usando qualquer um desses métodos, será necessário instalar manualmente o networkx em seu ambiente para continuar a usá-los.
Por padrão, em macOS com Python >= 3.8 parallel_map() não será mais executado em vários processos. Essa é uma mudança em relação às versões anteriores, em que o comportamento padrão era que o parallel_map() iniciava vários processos. Essa alteração foi feita porque, nas versões mais recentes de macOS com Python 3.8 e 3.9, o multiprocessamento não é confiável ou adiciona uma sobrecarga significativa devido à alteração em Python 3.8 para iniciar novos processos com spawn em vez de fork. Para reativar a execução paralela em macOS com Python >= 3.8, você pode usar a opção do arquivo de configuração do usuário parallel ou definir a variável de ambiente QISKIT_PARALLEL para True.

O kwarg callback , anteriormente obsoleto, no construtor da classe PassManager foi removido. Esse kwarg foi descontinuado desde a versão 0.13.0 (9 de abril de 2020). Em vez disso, você pode passar o kwarg callback para o método qiskit.transpiler.PassManager.run() diretamente. Por exemplo, se você estivesse usando:

from qiskit.circuit.random import random_circuit
from qiskit.transpiler import PassManager

qc = random_circuit(2, 2)

def callback(**kwargs)
  print(kwargs['pass_'])

pm = PassManager(callback=callback)
pm.run(qc)

isso pode ser substituído por:

from qiskit.circuit.random import random_circuit
from qiskit.transpiler import PassManager

qc = random_circuit(2, 2)

def callback(**kwargs)
  print(kwargs['pass_'])

pm = PassManager()
pm.run(qc, callback=callback)

Agora não é mais possível instanciar um canal básico sem um prefixo, como qiskit.pulse.Channel ou qiskit.pulse.PulseChannel. Essas classes são projetadas para classificar tipos de diferentes classes de canais voltados para o usuário, como qiskit.pulse.DriveChannel, mas não têm uma definição como recurso de destino. Se você estava instanciando diretamente qiskit.pulse.Channel ou qiskit.pulse.PulseChannel, isso não é mais permitido. Use a subclasse apropriada.
Quando os kwargs require_cp e/ou require_tp de qiskit.quantum_info.process_fidelity(), qiskit.quantum_info.average_gate_fidelity(), qiskit.quantum_info.gate_error() são True, eles agora registrarão apenas um aviso em vez do comportamento anterior de gerar uma QiskitError se o canal de entrada for não-CP ou não-TP, respectivamente.
A classe QFT no módulo qiskit.circuit.library agora calcula a transformada de Fourier usando uma representação little-endian de tensores, ou seja, o estado $|1\rangle$ mapeia para $|0\rangle - |1\rangle + |2\rangle - ..$ assumindo que a base computacional corresponda à ordenação de bits little-endian dos inteiros. $|0\rangle = |000\rangle, |1\rangle = |001\rangle$ etc. Isso foi feito para torná-lo mais consistente com o restante do Qiskit, que usa uma convenção little-endian para a ordem dos bits. Se você estava dependendo da ordem de bits anterior, pode usar o método reverse_bits() para reverter para o comportamento anterior. Por exemplo:
```
from qiskit.circuit.library import QFT

qft = QFT(5).reverse_bits()
```
O atributo do módulo qiskit.__qiskit_version__ , que antes era um dict , agora retornará um objeto Mapping personalizado somente leitura que verifica a versão dos elementos do qiskit no tempo de execução, em vez de no tempo de importação. Isso foi feito para acelerar o caminho de importação do qiskit e eliminar um possível ciclo de importação, importando apenas os pacotes de elementos em tempo de execução se a versão for necessária do pacote. Isso deve ser totalmente compatível com o dict retornado anteriormente e, na maioria dos casos de uso normal, não haverá diferença. No entanto, se alguns aplicativos dependiam da mutação do conteúdo ou da verificação explícita do tipo, pode ser necessário fazer atualizações para se adaptar a essa mudança.
O módulo qiskit.execute foi renomeado para qiskit.execute_function. Isso foi necessário para evitar um conflito de nome potencial entre a função execute() que é reexportada como qiskit.execute. qiskit.execute a função em algumas situações poderia entrar em conflito com qiskit.execute o módulo, o que levaria a um erro enigmático porque Python estava tratando qiskit.execute como o módulo quando a intenção era a função ou vice-versa. A renomeação do módulo foi necessária para evitar esse conflito. Se você estiver importando qiskit.execute para obter o módulo (o uso típico era from qiskit.execute import execute), será necessário atualizar isso para usar qiskit.execute_function . qiskit.execute agora sempre resolverá para a função.
Os módulos qiskit.compiler.transpile, qiskit.compiler.assemble, qiskit.compiler.schedule e qiskit.compiler.sequence foram renomeados para qiskit.compiler.transpiler, qiskit.compiler.assembler, qiskit.compiler.scheduler e qiskit.compiler.sequence , respectivamente. Isso foi necessário para evitar um conflito potencial de nomes entre os módulos e os caminhos de função reexportados qiskit.compiler.transpile(), qiskit.compiler.assemble(), qiskit.compiler.schedule(), e qiskit.compiler.sequence(). Em algumas situações, esse conflito de nomes entre o caminho do módulo e o caminho da função reexportada levaria a um erro enigmático porque o Python estava tratando uma importação como o módulo quando a intenção era usar a função ou vice-versa. A renomeação do módulo foi necessária para evitar esse conflito. Se você estava usando as importações para obter os módulos antes (o uso típico seria como``from qiskit.compiler.transpile import transpile``), será necessário atualizar isso para usar os novos caminhos de módulo. qiskit.compiler.transpile(), qiskit.compiler.assemble(), qiskit.compiler.schedule(),, e qiskit.compiler.sequence() agora sempre serão resolvidos para as funções.
A classe qiskit.quantum_info.Quaternion foi movida do submódulo qiskit.quantum_info.operator para o submódulo qiskit.quantum_info.synthesis para refletir melhor sua finalidade. Nenhuma alteração será necessária se você estiver importando-o do módulo raiz qiskit.quantum_info mas, se estiver importando de qiskit.quantum_info.operator , será necessário atualizar o caminho de importação.
Removido o método QuantumCircuit.mcmt , que está obsoleto desde o lançamento do Qiskit Terra 0.14.0 em abril de 2020. Em vez de usar o método, use a classe MCMT para construir um portão de vários controles e vários alvos e use o método qiskit.circuit.QuantumCircuit.append() ou qiskit.circuit.QuantumCircuit.compose() para adicioná-la a um circuito.

Por exemplo, você pode substituir:
```
circuit.mcmt(ZGate(), [0, 1, 2], [3, 4])
```
com:
```
from qiskit.circuit.library import MCMT
mcmt = MCMT(ZGate(), 3, 2)
circuit.compose(mcmt, range(5))
```
Removido o método QuantumCircuit.diag_gate que foi descontinuado desde o lançamento do Qiskit Terra 0.14.0 em abril de 2020. Em vez disso, use o método diagonal() método de QuantumCircuit.
Removido o método QuantumCircuit.ucy que foi descontinuado desde o lançamento do Qiskit Terra 0.14.0 em abril de 2020. Em vez disso, use o método ucry() método de QuantumCircuit.
O método mirror() , anteriormente obsoleto, para qiskit.circuit.QuantumCircuit foi removido. Ele foi descontinuado na versão 0.15.0. O método qiskit.circuit.QuantumCircuit.reverse_ops() deve ser usado, pois o espelhamento pode ser confundido com a troca dos qubits de saída do circuito. O método reverse_ops() apenas inverte a ordem das portas que são aplicadas em vez de espelhar.
O suporte anteriormente obsoleto à passagem de um float (para o scale kwarg como o primeiro argumento posicional para o qiskit.circuit.QuantumCircuit.draw() foi removido. Ele foi descontinuado na versão 0.12.0. O primeiro argumento posicional do método qiskit.circuit.QuantumCircuit.draw() é agora o output kwarg, que não aceita um float. Em vez disso, você deve usar scale como um kwarg nomeado em vez de usá-lo de forma posicional.

Por exemplo, se você estava ligando anteriormente para draw com:
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.draw(0.75, output='mpl')
```
isso agora precisaria ser:
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.draw(output='mpl', scale=0.75)
```
ou:
```
qc.draw('mpl', scale=0.75)
```

Os recursos do Qiskit Pulse (qiskit.pulse) que foram descontinuados na versão 0.15.0 (agosto de 2020) foram removidos. O conjunto completo de alterações é o seguinte:

Módulo	Antigo	Novo
`qiskit.pulse.library`	`SamplePulse`	`Waveform`
`qiskit.pulse.library`	`ConstantPulse`	`Constant`
(renomeação do módulo)	`pulse.pulse_lib` Módulo	`qiskit.pulse.library`

Classe	Método antigo	Novo método
`ParametricPulse`	`get_sample_pulse`	`get_waveform`
`Instruction`	`command`	N/A. Os comandos e as instruções foram unificados. Use `operands()` para obter informações sobre os dados da instrução.
`Acquire`	`acquires`, `mem_slots`, `reg_slots`	`acquire()`, `mem_slot()`, `reg_slot()`. (A instrução `Acquire` não transmite mais por vários qubits)

O dicionário anteriormente mantido nas DAGCircuit bordas foi removido. Em vez disso, as bordas agora contêm a instância Bit que havia sido incluída anteriormente no dicionário como seu campo 'wire' . Observe que o gráfico NetworkX retornado por to_networkx() ainda terá um dicionário para seus atributos de borda, mas o campo 'name' não será mais preenchido.
O atributo parameters da classe QuantumCircuit não está mais retornando um set. Em vez disso, ele retorna um objeto ParameterView que implementa todos os métodos que o set oferece (embora obsoletos). Isso foi feito para dar suporte a um modelo que preserva os parâmetros classificados por nome. Ele deve ser totalmente compatível com qualquer uso anterior do set retornado pelo atributo parameters exceto nos casos em que foi feita a verificação explícita do tipo de um conjunto.
Ao executar transpile() em um QuantumCircuit com instruções delay() as unidades serão convertidas para dt se o valor de dt (tempo de amostragem) for conhecido por transpile()explicitamente por meio do kwarg dt ou por meio do kwarg BackendConfiguration para um objeto Backend passado por meio do kwarg backend .
A interpretação de meas_map (que é um atributo de um PulseBackendConfiguration ou como o kwarg meas_map correspondente no objeto schedule(), assemble(), sequence(), ou execute() ) foi atualizada para corresponder melhor às restrições reais do hardware. O formato desses dados é uma lista de listas, em que os itens da lista interna são números inteiros que especificam rótulos de qubit. Por exemplo:
```
[[A, B, C], [D, E, F, G]]
```
Anteriormente, a restrição meas_map era interpretada de forma que, se um qubit fosse adquirido (por exemplo, A), todos os outros qubits que compartilham um subgrupo com esse qubit (B e C) teriam que ser adquiridos ao mesmo tempo e com a mesma duração. Essa restrição foi relaxada. Uma aquisição não requer mais aquisições. (Se A for adquirido, B e C não precisarão ser adquiridos) Em vez disso, os qubits no mesmo grupo de medição não podem ser adquiridos de forma parcialmente sobreposta - pense no meas_map como uma especificação de um recurso de aquisição compartilhado (se adquirirmos A de t=1000 para t=2000, não poderemos adquirir B a partir de 1000<t<2000). Por exemplo:
```
# Good
meas_map = [[0, 1]]
# Acquire a subset of [0, 1]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))

# Acquire 0 and 1 together (same start time, same duration)
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1))

# Acquire 0 and 1 disjointly
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 10

# Acquisitions overlap, but 0 and 1 aren't in the same measurement
# grouping
meas_map = [[0], [1]]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 1

# Bad: 0 and 1 are in the same grouping, but acquisitions
# partially overlap
meas_map = [[0, 1]]
sched = pulse.Schedule()
sched = sched.append(pulse.Acquire(10, acq_q0))
sched = sched.append(pulse.Acquire(10, acq_q1)) << 1
```

Notas de descontinuação

Dois novos argumentos foram adicionados a qiskit.dagcircuit.DAGNode.semantic_eq()bit_indices1 e bit_indices2, que devem mapear as instâncias de Bit instâncias em cada DAGNode para seu índice na lista qubits ou clbits de suas respectivas listas DAGCircuit. Durante o período de depreciação, esses argumentos são opcionais e, quando não forem especificados, os mapeamentos serão construídos automaticamente com base nas propriedades register e index de cada Bit instância. No entanto, em uma versão futura, eles serão argumentos obrigatórios e o mapeamento precisará ser fornecido pelo usuário.
As pulse funções do construtor:
- qiskit.pulse.call_circuit()
- qiskit.pulse.call_schedule()
são obsoletos e serão removidos em uma versão futura. Essas funções são unificadas em qiskit.pulse.call() , que deve ser usado em seu lugar.
O método qiskit.pulse.Schedule método qiskit.pulse.Schedule.flatten() está obsoleto e será removido em uma versão futura. Em vez disso, você pode usar a função qiskit.pulse.transforms.flatten() que executará a mesma operação.
O site assign_parameters() para as seguintes classes:
- qiskit.pulse.channels.Channel,
- qiskit.pulse.library.Pulse,
- qiskit.pulse.instructions.Instruction,
e todas as suas subclasses estão obsoletas e serão removidas em uma versão futura. Essa funcionalidade foi incorporada ScheduleBlock que é a direção futura para a construção de programas de pulso parametrizados.
O atributo parameters para as seguintes classes:
- Channel
- Instruction.
está obsoleto e será removido em uma versão futura. Essa funcionalidade foi incorporada ScheduleBlock que é a direção futura para a construção de programas de pulso parametrizados.
Python 3.6 foi preterido e será removido em uma versão futura. Quando o suporte for removido, será necessário atualizar a versão Python que você está usando para Python 3.7 ou superior.

Dois QuantumCircuitcombine() e extend() juntamente com seus operadores correspondentes Python + e += estão obsoletos e serão removidos em uma versão futura. Em vez disso, o método QuantumCircuit método compose() deve ser usado. O método compose() permite mais flexibilidade na composição de dois circuitos que não têm registros correspondentes. Entretanto, ele não adiciona automaticamente qubits/clbits, ao contrário dos métodos obsoletos. Para adicionar um circuito em novos qubits/clbits, o método qiskit.circuit.QuantumCircuit.tensor() pode ser usado. Por exemplo:

from qiskit.circuit import QuantumRegister, QuantumCircuit

a = QuantumRegister(2, 'a')
circuit_a = QuantumCircuit(a)
circuit_a.cx(0, 1)

b = QuantumRegister(2, 'b')
circuit_b = QuantumCircuit(b)
circuit_b.cz(0, 1)

# same as circuit_a + circuit_b (or combine)
added_with_different_regs = circuit_b.tensor(circuit_a)

# same as circuit_a + circuit_a (or combine)
added_with_same_regs = circuit_a.compose(circuit_a)

# same as circuit_a += circuit_b (or extend)
circuit_a = circuit_b.tensor(circuit_a)

# same as circuit_a += circuit_a (or extend)
circuit_a.compose(circuit_a, inplace=True)

Suporte para passar instâncias Qubit para o kwarg qubits do método qiskit.transpiler.InstructionDurations.get() foi preterido e será removido em uma versão futura. Em vez disso, você deve chamar o método get() com os índices inteiros dos qubits desejados.
O uso de @ (__matmul__) para invocar o método compose das subclasses de BaseOperator (por exemplo Operator) está obsoleto e será removido em uma versão futura. O método qiskit.quantum_info.Operator.compose() pode ser usado diretamente ou também invocado usando o operador & (__and__).
Usar * (__mul__) para chamar o método dot() das subclasses de BaseOperator (por exemplo qiskit.quantum_info.Operator) está obsoleto e será removido em uma versão futura. Em vez disso, você pode simplesmente chamar o dot() diretamente.
Usando @ (__matmul__) para invocar o método evolve() dos métodos qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix está obsoleto e será removido em uma versão futura. O método evolve pode ser usado diretamente ou também invocado usando o operador & (__and__).

A classe qiskit.pulse.schedule.ParameterizedSchedule foi preterida e será removida em uma versão futura. Em vez disso, você pode parametrizar diretamente os objetos de pulso Schedule com um objeto Parameter por exemplo:

from qiskit.circuit import Parameter
from qiskit.pulse import Schedule
from qiskit.pulse import ShiftPhase, DriveChannel

theta = Parameter('theta')
target_schedule = Schedule()
target_schedule.insert(0, ShiftPhase(theta, DriveChannel(0)), inplace=True)

A classe qiskit.pulse.ScheduleComponent no módulo qiskit.pulse foi preterida e será removida em uma versão futura. Seu uso deve ser substituído por um qiskit.pulse.Schedule ou qiskit.pulse.Instruction diretamente. Além disso, o objetivo principal da classe ScheduleComponent era ser uma classe de base comum para as classes Schedule e Instruction para qualquer lugar que estivesse explicitamente verificando o tipo ou documentando a aceitação de uma entrada ScheduleComponent deveria ser atualizado para aceitar Instruction ou Schedule.
Os arquivos de esquema JSON e o uso das cargas úteis da API do IBMQ estão obsoletos e serão removidos em uma versão futura. Isso inclui tudo no módulo qiskit.schemas e no módulo qiskit.validation . Isso também inclui o validate kwargs para qiskit.qobj.QasmQobj.to_dict() e qiskit.qobj.QasmQobj.to_dict() juntamente com os validadores fastjsonschema em nível de módulo em qiskit.qobj (que não geram um aviso de depreciação). Os arquivos de esquema foram movidos para o repositório Qiskit/ibmq-schemas e devem ser tratados como as versões canônicas dos esquemas da API. No futuro, somente esses esquemas receberão atualizações e serão usados como fonte de verdade para os esquemas. Se você estava contando com os esquemas incluídos no qiskit-terra, deve atualizar para usar esse repositório.
O módulo qiskit.util foi descontinuado e será removido em uma versão futura. Ele foi substituído pelo qiskit.utils que oferece a mesma funcionalidade e será expandido no futuro. Observe que nenhum DeprecationWarning será emitido com relação a essa descontinuidade, uma vez que ela não era viável em Python 3.6.
A passagem do transpilador CXDirection no módulo qiskit.transpiler.passes foi preterida e será removida em uma versão futura. Em vez disso, o GateDirection deve ser usado. Ele se comporta de forma idêntica ao CXDirection , exceto pelo fato de que agora ele também suporta a transformação de um circuito com ECRGate além de portas CXGate portas.
A passagem do transpilador CheckCXDirection no módulo qiskit.transpiler.passes foi preterida e será removida em uma versão futura. Em vez disso, o passe CheckGateDirection deve ser usado. Ele se comporta de forma idêntica ao CheckCXDirection , exceto pelo fato de que agora também suporta a verificação da direção de todos os portões de 2 qubit, não apenas dos portões CXGate gates.
O método WeightedAddernum_ancilla_qubits() está obsoleto e será removido em uma versão futura. Ele foi substituído pelo atributo qiskit.circuit.library.WeightedAdder.num_ancillas que é consistente com as APIs de outras bibliotecas de circuitos.
Os seguintes métodos legados da classe qiskit.quantum_info.Pauli foram descontinuados. Consulte a documentação do método para obter o uso de substituição na classe Pauli atualizada.
- from_label()
- sgn_prod()
- to_spmatrix()
- kron()
- update_z()
- update_x()
- insert_paulis()
- append_paulis()
- delete_qubits()
- pauli_single()
- random()
Usando um list ou numpy.ndarray como o argumento channel ou target para o comando qiskit.quantum_info.process_fidelity(), qiskit.quantum_info.average_gate_fidelity(), qiskit.quantum_info.gate_error(), e qiskit.quantum_info.diamond_norm() foi preterido e não terá suporte em uma versão futura. Em vez disso, as entradas devem ser um objeto Gate ou um objeto da subclasse BaseOperator (por exemplo. Operator, Choi, etc.)
Acessando referências de Qubit e Clbit para os registros que as contêm por meio de register ou index foi preterido e será removido em uma versão futura. Em vez disso, Register podem ser consultados para encontrar os objetos Bit objetos que eles contêm.
A funcionalidade atual da função qiskit.visualization.pulse_drawer() está obsoleta e será substituída por qiskit.visualization.pulse_drawer_v2() (que não é compatível com versões anteriores) em uma versão futura.
O uso de métodos herdados do tipo set na saída do atributo parameters (que costumava ser um set) da classe QuantumCircuit está obsoleto e será removido em uma versão futura. Isso inclui os métodos dos sites add(), difference(), difference_update(), discard(), intersection(), intersection_update(), issubset(), issuperset(), symmetric_difference(), symmetric_difference_update(), union(), update(), __isub__() (que é o operador -= ) e __ixor__() (que é o operador ^= ).
O nome do primeiro (e único) argumento posicional do método qiskit.circuit.QuantumCircuit.bind_parameters() foi alterado de value_dict para values. A passagem de um argumento com o nome values_dict está obsoleta e será removida em uma versão futura. Por exemplo, se você estava chamando anteriormente bind_parameters() com uma chamada do tipo: bind_parameters(values_dict={}) , isso está obsoleto e deve ser substituído por bind_parameters(values={}) ou, melhor ainda, basta passar o argumento de forma posicional bind_parameters({}).
O nome do primeiro (e único) argumento posicional do método qiskit.circuit.QuantumCircuit.assign_parameters() foi alterado de param_dict para parameters. A passagem de um argumento com o nome param_dict está obsoleta e será removida em uma versão futura. Por exemplo, se você estava chamando anteriormente assign_parameters() com uma chamada do tipo: assign_parameters(param_dict={}) , isso está obsoleto e deve ser substituído por assign_parameters(values={}) ou, melhor ainda, basta passar o argumento de forma posicional assign_parameters({}).

Correções de bugs

Foi corrigido um problema em que a função execute() levantava a QiskitError exceção quando um objeto ParameterVector era passado para o kwarg parameter_bind . . Por exemplo, agora é possível chamar algo como:
```
execute(circuit, backend, parameter_binds=[{pv1: [...], pv2: [...]}])
```
em que pv1 e pv2 são ParameterVector objetos. Corrigido #5467
Foi corrigido um problema em que os rótulos dos pulsos paramétricos na classe PulseQobjInstruction não estavam sendo definidos corretamente, como acontece com os pulsos amostrados. Isso também significa que os nomes de pulsos que são importados do PulseDefaults retornados por um Backendcomo x90, x90m, etc., serão definidos corretamente. Corrigido #5363
Foi corrigido um problema em que os parâmetros não vinculados só ocorriam no atributo global_phase de um objeto QuantumCircuit não eram exibidos no atributo parameters e não podiam ser vinculados. Corrigido #5806
O atributo calibrations dos objetos QuantumCircuit agora são preservados quando o += (ou seja, o método extend() ) e o + (ou seja, o método combine() ) são usados. Corrigidos os números 5930 e 5908
O método name setter da classe Register (que é a classe pai de QuantumRegister e ClassicalRegister) anteriormente não verificava se a string atribuída era um nome de registro válido de acordo com a especificação OpenQASM. Essa verificação era realizada anteriormente apenas quando o nome era especificado no construtor. Agora, isso foi corrigido para que a configuração do atributo name diretamente com um valor inválido também gere uma exceção. Corrigido #5461
Foi corrigido um problema com a função qiskit.visualization.circuit_drawer() função e qiskit.circuit.QuantumCircuit.draw() ao visualizar um QuantumCircuit com um Gate que tem uma condição clássica após um Measure que usou o mesmo ClassicalRegisterera possível que a condicional Gate fosse exibida à esquerda do Measure. Corrigido #5387
Na passagem do transpilador qiskit.transpiler.passes.CSPLayout foi possível observar uma tendência em direção aos qubits com números mais baixos. Esse viés indesejável foi corrigido embaralhando os candidatos para randomizar os resultados. Além disso, o uso do CSPLayout no campo preset_passmanagers (para os níveis 2 e 3) foi ajustado para usar uma semente configurada se o seed_transpiler kwarg estiver definido quando o transpile() for chamado. Corrigido #5990
Corrige um bug em que o campo channels de um objeto PulseBackendConfiguration não estava sendo incluído na saída do método qiskit.providers.models.PulseBackendConfiguration.to_dict método. Corrigido #5579
Corrigido o emaranhamento 'circular' na classe qiskit.circuit.library.NLocal para o caso extremo em que o circuito tem o mesmo tamanho que o bloco de emaranhamento (por exemplo, um circuito de dois qubits e portas de emaranhamento CZ). Nesse caso, deveria haver apenas uma porta de emaranhamento, mas foi adicionada acidentalmente uma segunda porta na direção inversa da primeira. Fixo qiskit-community/qiskit-aqua#1452
Foi corrigido o tratamento de pontos de interrupção na classe PiecewisePolynomialPauliRotations na classe qiskit.circuit.library. Agora, para intervalos de n , são permitidos pontos de interrupção de n+1 . Isso permite especificar outro intervalo final diferente de $2^\text{num qubits}$ . Isso é importante porque, do final do último intervalo até $2^\text{num qubits}$ , a função é a identidade.
Foi corrigido um problema na classe qiskit.circuit.library.Permutation em que algumas permutações não eram geradas corretamente. Esse problema também poderia afetar o qiskit.circuit.library.QuantumVolume se ele fosse chamado com classical_permutation=False`. Corrigido #5812
Foi corrigido um problema em que a geração de saída QASM com o método qasm() para um objeto QuantumCircuit que tem um controle ControlledGate com um controle aberto, a saída seria como se todos os controles estivessem fechados, independentemente do estado de controle especificado. Isso resultaria em um circuito diferente sendo criado a partir de from_qasm_str() se o QASM gerado fosse analisado.

Isso foi corrigido com a atualização da saída QASM de qasm() definindo uma porta composta que usa XGate para implementar os controles de abertura. A porta composta é nomeada como <original_gate_name>_o<ctrl_state> , em que o significa controle aberto e ctrl_state é o valor inteiro do estado de controle. Corrigido #5443
Foi corrigido um problema em que a vinculação de objetos Parameter em um objeto QuantumCircuit com o endereço parameter_binds na função execute fazia com que todos os objetos QuantumCircuit tivessem o mesmo name, o que significava que os nomes dos resultados também não eram exclusivos. Essa correção faz com que o bind_parameters() e assign_parameters() atribuam um nome de circuito exclusivo quando inplace=False as:
```
<base name>-<class instance no.>[-<pid name>]
```
em que <base name> é o nome fornecido pelo kwarg "name"; caso contrário, o padrão é "circuit". O número da instância da classe é incrementado toda vez que uma instância da classe é gerada. <pid name> é anexado se for chamado fora do processo principal. Corrigido #5185
Foi corrigido um problema com a função scheduler() , que gerava uma exceção se um circuito de entrada contivesse um objeto QuantumCircuit não vinculado. Corrigido #5304
Foi corrigido um problema nas passagens do qiskit.transpiler.passes.TemplateOptimization passagens do transpilador em que os circuitos de modelo que continham objetos não vinculados Parameter não vinculados travavam em alguns cenários se os parâmetros não pudessem ser vinculados durante a correspondência de modelos. Agora, se os Parameter não puderem ser vinculados, os modelos com Parameter serão descartados e ignorados pelo TemplateOptimization pass. Corrigido #5533
Foi corrigido um problema com a função qiskit.visualization.timeline_drawer() em que os bits clássicos eram tratados de forma inadequada. Corrigido #5361
Foi corrigido um problema na função qiskit.visualization.circuit_drawer() e no método qiskit.circuit.QuantumCircuit.draw() método em que as Delay instruções em um objeto QuantumCircuit não estavam sendo tratadas corretamente como tempo ocioso. Portanto, quando o kwarg do idle_wires foi definido como False , os fios com os Delay ainda seriam exibidos. Isso foi corrigido para que os fios ociosos sejam removidos da visualização se houver apenas Delay objetos em um fio.
Anteriormente, quando a opção layout_method kwarg era fornecida para a função transpile() e o optimization_level kwarg era definido como >= 2 para que a passagem qiskit.transpiler.passes.CSPLayout fosse executado, se CSPLayout encontrasse uma solução, o método em layout_method não era executado. Isso foi corrigido para que, se especificado, o layout_method seja sempre respeitado. Corrigido #5409
Quando o argumento coupling_map=None (definido explicitamente, definido implicitamente como o valor padrão ou por meio do kwarg backend ), o processo de transpilação não estava "incorporando" o circuito. Ou seja, mesmo quando um initial_layout foi especificado, os qubits virtuais não foram atribuídos a qubits físicos. Isso foi corrigido, de modo que agora a função qiskit.compiler.transpile() honre o argumento initial_layout ao incorporar o circuito:
```
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, name='qr')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])

transpile(circ, initial_layout=[1, 0]).draw(output='mpl')
```
Se o site initial_layout se referir a mais qubits do que no circuito, o processo de transpilação estenderá o circuito com ancillas.
```
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile

qr = QuantumRegister(2, name='qr')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])

transpile(circ, initial_layout=[4, 2], coupling_map=None).draw()
```
Corrigido #5345
Um novo kwarg, user_cost_dict , foi adicionado ao construtor para a qiskit.transpiler.passes.TemplateOptimization transpiler pass. Isso permite que os usuários forneçam um dicionário de custos personalizado para as portas do algoritmo de correspondência de modelos subjacente. Por exemplo:
```
from qiskit.transpiler.passes import TemplateOptimization

cost_dict = {'id': 0, 'x': 1, 'y': 1, 'z': 1, 'h': 1, 't': 1}
pass = TemplateOptimization(user_cost_dict=cost_dict)
```
Um problema ao passar o objeto Counts retornado por get_counts() para marginal_counts() produzia um objeto Counts com determinadas entradas foi corrigido. Correções #5424
Aprimorou a alocação de qubits auxiliares em PolynomialPauliRotations e PiecewiseLinearPauliRotations o que torna a implementação desses circuitos mais eficiente. Corrigido #5320 e #5322
Corrigir o uso dos qubits auxiliares alocados no MCXGate na classe WeightedAdder classe. Eles foram alocados anteriormente, mas não foram usados antes dessa correção. Corrigido #5321
Em vários casos, o método de saída latex para a função qiskit.visualization.circuit_drawer() e o método draw() não exibiam o nome da porta corretamente e, em outros casos, não incluíam os parâmetros da porta onde deveriam estar. Agora, os nomes das portas serão exibidos da mesma forma que são exibidos com o método de saída mpl , e os parâmetros serão exibidos para todas as portas que os tiverem. Além disso, alguns dos portões não eram exibidos na forma correta, e isso foi corrigido. Correções #5605, #4938 e #3765
Foi corrigido um problema em que, se o método qiskit.circuit.Instruction.to_instruction() fosse usado em um subcircuito que contivesse registros clássicos e esse objeto Instruction era então adicionado a um objeto QuantumCircuit então a saída da função qiskit.visualization.circuit_drawer() e do método qiskit.circuit.QuantumCircuit.draw() exibia, em alguns casos, o subcircuito à esquerda de uma medida, quando deveria ser exibido à direita. Corrigido #5947
Foi corrigido um problema com Delay em um objeto QuantumCircuit onde qiskit.compiler.transpile() não convertiam as unidades do objeto Delay para as unidades do Backendse o kwarg backend estivesse definido em transpile(). Isso pode resultar em um comportamento incorreto devido a uma incompatibilidade de unidades, por exemplo, em execução:
```
from qiskit import transpile, execute
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
qc.delay(100, [0], unit='us')

qc = transpile(qc, backend)
job = execute(qc, backend)
```
teria resultado anteriormente no atraso do backend de 100 intervalos de tempo (cada um com duração dt) em vez dos intervalos de tempo esperados ( 100e-6 / dt). Isso foi corrigido para que a função qiskit.compiler.transpile() converta corretamente as unidades.

Outras observações

Os snapshots de todos os backends falsos/mock em qiskit.test.mock foram atualizados para refletir as alterações recentes nos dispositivos. Isso inclui uma alteração no atributo basis_gates para o atributo BackendConfiguration para ['cx', 'rz', 'sx', 'x', 'id'], a adição de uma propriedade readout_length às propriedades do qubit no BackendPropertiese a atualização do PulseDefaults para que todos os backends de simulação suportem instâncias baseadas em pulso paramétrico InstructionScheduleMap instâncias.

Aer 0.8.0

Prelúdio

A versão 0.8 inclui vários novos recursos e correções de bugs. Os destaques desta versão são: a introdução de um backend unificado do AerSimulator para executar simulações de circuitos usando qualquer um dos métodos de simulação suportados; uma biblioteca de instruções do simulador (qiskit.providers.aer.library) que inclui instruções personalizadas para salvar vários tipos de dados do simulador; suporte a MPI para executar grandes simulações em um ambiente de computação distribuída.

Novos Recurso

Python 3.9 foi adicionado a esta versão. Agora você pode executar o Qiskit Aer usando Python 3.9 sem construir a partir da fonte.
Adicione o sinalizador do CMake DISABLE_CONAN (padrão=``OFF```)s. Ao instalar a partir do código-fonte, definir isso como ON permite ignorar o gerenciador de pacotes Conan para encontrar bibliotecas que já estejam instaladas em seu sistema. Isso também está disponível como uma variável de ambiente DISABLE_CONAN, que tem precedência sobre o sinalizador do CMake. Esse não é o procedimento oficial para criar o AER. Portanto, o usuário é responsável por fornecer todas as bibliotecas necessárias e os arquivos correspondentes para que possam ser encontrados pelo CMake.
Essa versão inclui suporte para a criação do qiskit-aer com suporte a MPI para executar grandes simulações em um ambiente de computação distribuída. Consulte o guia de contribuição para obter instruções sobre a criação e a execução em um ambiente MPI.
Agora é possível criar o qiskit-aer com o CUDA ativado no Windows. Consulte o guia de contribuição para obter instruções sobre a compilação a partir do código-fonte com suporte a GPU.
Ao compilar a extensão qiskit-aer Python a partir da fonte, várias dependências de compilação precisam ser pré-instaladas para permitir a compilação do C++. Para conveniência do usuário, ao criar a extensão, qualquer uma dessas dependências de compilação que estivesse faltando seria instalada automaticamente usando pip antes das etapas normais de instalação do setuptools . No entanto, anteriormente não era possível evitar essa instalação automática. Para resolver esse problema, uma nova variável de ambiente DISABLE_DEPENDENCY_INSTALL foi adicionada. Se estiver definido como 1 ou ON ao compilar a extensão python a partir da fonte, isso desativará a instalação automática dessas dependências de compilação ausentes.
Adiciona suporte para a porta Pauli de N-qubit otimizada ( qiskit.circuit.library.PauliGate) aos sites StatevectorSimulator, UnitarySimulator, e aos métodos de matriz de densidade e vetor de estado dos sites QasmSimulator e AerSimulator.
O método run() para os backends AerSimulator, QasmSimulator, StatevectorSimulator e UnitarySimulator agora aceita um QuantumCircuit (ou uma lista de objetos QuantumCircuit objetos) como entrada. O objeto QasmQobj ainda é suportado por enquanto, mas será descontinuado em uma versão futura.

Para obter um exemplo de como usar isso, consulte:
```
from qiskit import transpile, QuantumCircuit

from qiskit.providers.aer import Aer

backend = Aer.get_backend('aer_simulator')

circuit = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

tqc = transpile(circuit, backend)
result = backend.run(tqc, shots=4096).result()
```
O método run() para o backend PulseSimulator agora aceita um Schedule (ou uma lista de objetos Schedule objetos) como entrada. O objeto PulseQobj ainda é suportado por enquanto, mas será descontinuado em uma versão futura.
Adiciona o novo back-end do simulador AerSimulator com suporte aos seguintes métodos de simulação
- automatic
- statevector
- stabilizer
- density_matrix
- matrix_product_state
- unitary
- superop
O método automático padrão escolherá automaticamente um método de simulação separadamente para cada circuito de execução com base nas instruções do circuito e no modelo de ruído (se houver). A inicialização de um simulador com um método específico pode ser feita usando a opção de método.

A simulação de GPU para os métodos de vetor de estado, matriz de densidade e unitário pode ser ativada com a configuração da opção de backend device='GPU' .

Observe que os métodos unitary e superop não são compatíveis com a medição, pois simulam a matriz unitária ou a matriz de superoperador do circuito de execução; portanto, uma das novas instruções save_unitary(), save_superop() ou save_state() deve ser usada para salvar o estado do simulador nos resultados retornados. Da mesma forma, o estado dos outros métodos de simulação pode ser salvo usando as instruções apropriadas. Consulte os documentos da API qiskit.providers.aer.library para obter mais detalhes.

Observe que o simulador AerSimulator substitui os backends QasmSimulator, StatevectorSimulator e UnitarySimulator , que serão descontinuados em uma versão futura.
Atualiza a classe AerProvider para incluir vários backends AerSimulator pré-configurados para todos os métodos de simulação e dispositivos de simulação disponíveis. Os novos back-ends podem ser acessados por meio da interface do provedor usando os nomes
- "aer_simulator"
- "aer_simulator_statevector"
- "aer_simulator_stabilizer"
- "aer_simulator_density_matrix"
- "aer_simulator_matrix_product_state"
- "aer_simulator_extended_stabilizer"
- "aer_simulator_unitary"
- "aer_simulator_superop"
Além disso, se o Aer tiver sido instalado com suporte a GPU em um sistema compatível, os seguintes back-ends de GPU também estarão disponíveis
- "aer_simulator_statevector_gpu"
- "aer_simulator_density_matrix_gpu"
- "aer_simulator_unitary_gpu"
Por exemplo:
```
from qiskit import Aer

# Get the GPU statevector simulator backend
backend = Aer.get_backend('aer_simulator_statevector_gpu')
```
Adição de um novo método norm estimation para realizar medições ao usar o método de simulação "extended_stabilizer" . Esse método de estimativa de norma pode ser usado passando as seguintes opções para os backends AerSimulator e QasmSimulator
```
simulator = QasmSimulator(
    method='extended_stabilizer',
    extended_stabilizer_sampling_method='norm_estimation')
```
O método de estimativa de norma é mais lento do que as opções alternativas metropolis ou resampled_metropolis , mas oferece melhor desempenho em circuitos com distribuições de saída esparsas. Consulte a documentação do site QasmSimulator para obter mais informações.
Adiciona instruções para salvar o estado do simulador em vários formatos. Essas instruções são
- qiskit.providers.aer.library.SaveDensityMatrix
- qiskit.providers.aer.library.SaveMatrixProductState
- qiskit.providers.aer.library.SaveStabilizer
- qiskit.providers.aer.library.SaveState
- qiskit.providers.aer.library.SaveStatevector
- qiskit.providers.aer.library.SaveStatevectorDict
- qiskit.providers.aer.library.SaveUnitary
Essas instruções podem ser anexadas a um circuito quântico usando os métodos de circuito save_density_matrix, save_matrix_product_state, save_stabilizer, save_state, save_statevector, save_statevector_dict, save_unitary que são adicionados a QuantumCircuit ao importar o Aer.

Consulte a documentação da API qiskit.providers.aer.library para obter detalhes sobre a compatibilidade de métodos para cada instrução.

Observe que as instruções de snapshot SnapshotStatevector, SnapshotDensityMatrix, SnapshotStabilizer ainda são compatíveis, mas serão preteridas em uma versão futura.
Adiciona as instruções de circuito quântico qiskit.providers.aer.library.SaveExpectationValue e qiskit.providers.aer.library.SaveExpectationValueVariance para salvar o valor de expectativa $\langle H\rangle = Tr[H\rho]$ , ou o valor de expectativa e a variação $Var(H) = \langle H^2\rangle - \langle H\rangle^2$ , de um operador hermitiano $H$ para o estado do simulador $\rho$ . Essas instruções podem ser anexadas a um circuito quântico usando os métodos de circuito save_expectation_value e save_expectation_value_variance que são adicionados a QuantumCircuit ao importar Aer.

Observe que a instrução de instantâneo SnapshotExpectationValue, ainda é compatível, mas será preterida em uma versão futura.
Adiciona as instruções de circuito quântico qiskit.providers.aer.library.SaveProbabilities e qiskit.providers.aer.library.SaveProbabilitiesDict para salvar todas as probabilidades de resultados de medição para medições de base Z do estado do simulador. Essas instruções podem ser anexadas a um circuito quântico usando os métodos de circuito save_probabilities e save_probabilities_dict , que são adicionados a QuantumCircuit ao importar o Aer.

Observe que a instrução de instantâneo SnapshotProbabilities, ainda é compatível, mas será preterida em uma versão futura.
Adiciona as instruções de circuito qiskit.providers.aer.library.SaveAmplitudes e qiskit.providers.aer.library.SaveAmplitudesSquared para salvar amplitudes de vetores de estado complexos selecionados ou selecionar probabilidades (amplitudes ao quadrado) para métodos de simulação compatíveis. Essas instruções podem ser anexadas a um circuito quântico usando os métodos de circuito save_amplitudes e save_amplitudes_squared , que são adicionados a QuantumCircuit ao importar o Aer.
Adiciona instruções para definir o estado dos simuladores. Essas instruções devem ser definidas no número total de qubits do circuito. Eles podem ser aplicados em qualquer ponto de um circuito e substituirão o estado do simulador pelo especificado. As instruções adicionadas são
- qiskit.providers.aer.library.SetDensityMatrix
- qiskit.providers.aer.library.SetStabilizer
- qiskit.providers.aer.library.SetStatevector
- qiskit.providers.aer.library.SetUnitary
Essas instruções podem ser anexadas a um circuito quântico usando os métodos de circuito set_density_matrix, set_stabilizer, set_statevector, set_unitary que são adicionados a QuantumCircuit ao importar o Aer.

Consulte a documentação da API qiskit.providers.aer.library para obter detalhes sobre a compatibilidade de métodos para cada instrução.
Foi adicionado suporte a portas diagonais ao método de simulação "matrix_product_state" .
Foi adicionado suporte à instrução initialize ao método de simulação "matrix_product_state" .

Problemas Conhecidos

Há um problema conhecido em que a simulação de determinados circuitos com um modelo de ruído Kraus usando o método de simulação "matrix_product_state" pode causar o travamento do simulador. Consulte o item 306 para obter mais informações.

Notas da Atualização

A versão mínima do Conan foi aumentada para 1.31.2. Isso foi necessário para corrigir um problema de compatibilidade com versões mais recentes do urllib3 (que é uma dependência do Conan). Ele também adiciona suporte nativo para AppleClang 12, o que é útil para usuários com novos computadores Apple.
pybind11 a versão mínima necessária é 2.6 em vez de 2.4. Isso é necessário para dar suporte à compilação habilitada para CUDA no Windows.
O Cython foi removido como uma dependência de compilação.
Removida a decomposição do portão x90 dos modelos de ruído que estavam obsoletos no qiskit-aer 0.7. Essa decomposição agora é feita com o uso de portas de base de modelo de ruído regular e o transpilador qiskit.
As seguintes opções do método de simulação "extended_stabilizer" foram alteradas.
- extended_stabilizer_measure_sampling: Essa opção foi substituída pelas opções extended_stabilizer_sampling_method, que controla como simulamos a medição de qubit.
- extended_stabilizer_mixing_time: Essa opção foi renomeada como extended_stabilizer_metropolis_mixing_time para esclarecer que só se aplica aos métodos de amostragem metropolis e resampled_metropolis .
- extended_stabilizer_norm_estimation_samples: Essa opção foi renomeada para extended_stabilizer_norm_estimation_default_samples.
Foi acrescentada uma opção adicional, extended_stabilizer_norm_estimation_repetitions , que controla parte do comportamento do método de amostragem de estimativa de norma.

Notas de descontinuação

Python 3.6 foi preterido e será removido em uma versão futura. Quando o suporte for removido, será necessário atualizar a versão Python que você está usando para Python 3.7 ou superior.

Correções de bugs

Corrige o bug com AerProvider , em que as opções definidas nos backends retornados usando set_options() eram armazenadas no provedor e persistiam nas chamadas subsequentes para get_backend() para o mesmo backend nomeado. Agora, cada chamada para backends() retorna uma nova instância do backend do simulador que pode ser configurado.
Corrige o bug na mensagem de erro retornada quando um circuito contém instruções de simulador não suportadas. Anteriormente, algumas instruções com suporte também estavam sendo listadas na mensagem de erro junto com as instruções sem suporte.
Corrige o problema com a configuração de QasmSimulator basis gates ao usar as opções "method" e "noise_model" juntas e ao usá-las com um simulador construído usando from_backend(). Agora, os portões básicos listados serão a interseção dos portões suportados pela configuração de back-end, pelo método de simulação e pelos portões básicos do modelo de ruído. Se a interseção das portas de base do modelo de ruído e das portas de base do simulador estiver vazia, um aviso será registrado.
Correção do erro em que a porta "sx"` SXGate não era listada como uma porta suportada no código C++, em StateOpSet de matrix_product_state.hp.
Corrigir o erro em que "csx", "cu2", "cu3" estavam incorretamente listados como portas de base compatíveis com o método "density_matrix" do QasmSimulator.
Correção do bug em que os parâmetros eram passados incorretamente entre as funções em matrix_product_state_internal.cpp, causando simulação incorreta e atingindo estados inválidos, o que, por sua vez, causava um loop infinito.
Corrige um bug que fazia com que o c_if não funcionasse quando a largura do registro condicional era maior que 64. Consulte #1077.
Corrige um bug (nº 1153 ) em que o ruído em portas condicionais estava sempre sendo aplicado, independentemente de a porta condicional ter sido realmente aplicada com base no valor do registro clássico. Agora, o ruído em uma porta condicional só será aplicado no caso em que a porta condicional for aplicada.
Corrige um bug com o sinalizador OpenMP aninhado que estava sendo definido como verdadeiro quando não deveria.
Corrige um erro ao aplicar o truncamento no método de estado do produto da matriz do site QasmSimulator.
Corrigido o problema nº 1126 : erro ao relatar a medição de um único qubit. O erro ocorria ao copiar o valor medido para a estrutura de dados de saída.
No MPS, o apply_kraus estava operando diretamente nos bits de entrada nos qubits de parâmetro, em vez de nos qubits internos. No algoritmo MPS, os qubits estão em constante movimento, portanto, todas as operações devem ser aplicadas aos qubits internos.
Ao invocar MPS::sample_measure, precisamos primeiro classificar os qubits de acordo com a ordenação padrão, pois essa é a suposição em qasm_controller.This. Isso é feito invocando o método move_all_qubits_to_sorted_ordering. Ele estava correto em sample_measure_using_apply_measure, mas ausente em sample_measure_using_probabilities.
Corrige o erro no método from_backend() do QasmSimulator que definia o atributo local da configuração como o valor de backend em vez de sempre ser definido como True.
Corrige um erro em from_backend() e from_backend() , em que basis_gates era definido incorretamente para dispositivos IBMQ com o conjunto de portas de base ['id', 'rz', 'sx', 'x', 'cx']. Agora, o modelo de ruído sempre terá as mesmas portas de base que as portas de base de backend, independentemente de essas instruções terem erros no modelo de ruído ou não.
Corrige um problema em que o método de simulação estendido "extended_stabilizer" apresentava resultados incorretos em circuitos quânticos com distribuições de saída esparsas. Consulte o item 306 para obter mais informações e exemplos.

Ignis 0.6.0

Novos Recurso

A função qiskit.ignis.mitigation.expval_meas_mitigator_circuits() foi aprimorada para que o número de circuitos gerados pela função usada para calibração pelo método CTMP seja reduzido de $O(n)$ para $O(\log{n})$ (em que $n$ é o número de qubits).

Notas da Atualização

A função qiskit.ignis.verification.randomized_benchmarking_seq() agora está usando a classe CNOTDihedral atualizada, qiskit.ignis.verification.CNOTDihedral, que permite realizar o CNOT-Dihedral Randomized Benchmarking em mais de dois qubits.
O pacote python retworkx agora é um requisito para a instalação do qiskit-ignis. Ele substitui o uso anterior do networkx (que não é mais um requisito) para obter melhor desempenho.
A dependência scikit-learn não é mais necessária e agora é um requisito opcional. Se estiver usando os discriminadores de medição de QI (IQDiscriminationFitter, LinearIQDiscriminationFitter, QuadraticIQDiscriminationFitter, ou SklearnIQDiscriminator), você precisará instalar manualmente o scikit-learn, executando pip install scikit-learn ou quando também estiver instalando o qiskit-ignis com pip install qiskit-ignis[iq].

Correções de bugs

Foi corrigido um problema no método de valor de expectativa expectation_value(), para as classes de atenuação de erros TensoredExpvalMeasMitigator e CTMPExpvalMeasMitigator , se o kwarg qubits não fosse especificado, ele usaria incorretamente o número total de qubits do atenuador, em vez do número de bits clássicos no dicionário de contagem, o que reduziria muito o desempenho. Corrigido #561
Corrija o método "auto" dos sites TomographyFitter, StateTomographyFitter e ProcessTomographyFitter para usar apenas o "cvx" se o CVXPY estiver instalado e um solver SDP de terceiros que não seja o SCS estiver disponível. Isso ocorre porque o solucionador SCS tem uma precisão menor do que outros métodos de solucionador e, muitas vezes, retorna uma matriz de densidade ou matriz Choi que não é completamente positiva e falha na validação quando usada com o método qiskit.quantum_info.state_fidelity() ou qiskit.quantum_info.process_fidelity() .

Aqua 0.9.0

Esta versão descontinua oficialmente o projeto Qiskit Aqua. No futuro (não antes de 3 meses a partir desta versão), o projeto Aqua terá sua versão final e será arquivado. Todas as funcionalidades que o qiskit-aqua oferece foram migradas para novos pacotes ou para outros pacotes do qiskit. Os módulos de aplicativos que são fornecidos pelo qiskit-aqua foram divididos em vários novos pacotes: qiskit-optimization, qiskit-nature, qiskit-machine-learning, e qiskit-finance. Esses pacotes podem ser instalados sozinhos (por meio do comando pip install padrão, ou seja, pip install qiskit-nature) ou com o restante do metapacote do Qiskit como extras opcionais (ou seja, pip install 'qiskit[finance,optimization]' ou pip install 'qiskit[all]'. Os principais blocos de construção de algoritmos e o fluxo do operador agora existem como parte do qiskit-terra em qiskit.algorithms e qiskit.opflow. Dependendo do seu uso atual do Aqua, você deve usar os pacotes de aplicativos ou os novos módulos no Qiskit Terra.

Para obter mais detalhes sobre como migrar do uso do Qiskit Aqua, consulte o guia de migração.

IBM 0.12.2

Nenhuma mudança

Esta página foi útil?

Relate um bug, erro de digitação ou solicite conteúdo no GitHub.