Notas de versão do Qiskit 0.23

0.23.6

Terra 0.16.4

Nenhuma mudança

Aer 0.7.5

Prelúdio

Esta versão é uma versão de correção de bugs que corrige a compatibilidade dos pacotes binários pré-compilados do wheel com as versões do numpy < 1.20.0. A versão anterior 0.7.4 estava construindo os binários de uma forma que exigiria o numpy 1.20.0, o que foi resolvido agora, de modo que os pacotes binários pré-compilados do wheel funcionarão com qualquer versão compatível do numpy.

Ignis 0.5.2

Nenhuma mudança

Aqua 0.8.2

Nenhuma mudança

IBM 0.11.1

Nenhuma mudança

0.23.5

Terra 0.16.4

Prelúdio

Esta versão é uma versão de correção de bugs que corrige principalmente a compatibilidade com o numpy 1.20.0. Essa versão do numpy descontinuou seus aliases locais para os tipos numéricos do Python (np.int -> int, np.float -> float, etc.) e o uso desses aliases no Qiskit resultou na emissão de um grande número de avisos de depreciação. Esta versão corrige esse problema para que você possa executar o Qiskit com o numpy 1.20.0 sem esses avisos de depreciação.

Aer 0.7.4

Correções de bugs

Corrige a compatibilidade com o numpy 1.20.0. Essa versão do numpy descontinuou seus aliases locais para os tipos numéricos do Python (np.int -> int, np.float -> float, etc.) e o uso desses aliases no Qiskit Aer resultou na emissão de um grande número de avisos de depreciação. Esta versão corrige isso para que você possa executar o Qiskit Aer com o numpy 1.20.0 sem esses avisos de depreciação.

Ignis 0.5.2

Prelúdio

Esta versão é uma versão de correção de bugs que corrige principalmente a compatibilidade com o numpy 1.20.0. É também a primeira versão a incluir suporte para Python 3.9. As versões anteriores (incluindo 0.5.0 e 0.5.1 ) funcionavam com Python 3.9, mas não indicavam isso nos metadados do pacote, e não havia testes upstream para essas versões. Esta versão corrige esse problema e foi testada em Python 3.9 (além de 3.6, 3.7 e 3.8 ).

Correções de bugs

o networkx está explicitamente listado como uma dependência agora. Anteriormente, ele era uma dependência implícita, pois era necessário para o módulo qiskit.ignis.verification.topological_codes , mas não estava listado corretamente como uma dependência, pois o qiskit-terra também requer o networkx e também é uma dependência do ignis, de modo que sempre seria instalado na prática. No entanto, é necessário listá-lo como um requisito para futuras versões do qiskit-terra que não exigirão o networkx. Também é importante listar corretamente as dependências do ignis, caso haja uma incompatibilidade futura entre os requisitos da versão.

Aqua 0.8.2

IBM 0.11.1

Nenhuma mudança

0.23.4

Terra 0.16.3

Correções de bugs

Foi corrigido um problema introduzido em 0.16.2 que causava erros ao ser executado transpile() em um circuito com uma série de portas de 1 qubit e uma instrução sem porta que opera somente em um qubit (por exemplo, Reset). Correções #5736

Aer 0.7.3

Nenhuma mudança

Ignis 0.5.1

Nenhuma mudança

Aqua 0.8.1

Nenhuma mudança

IBM 0.11.1

Nenhuma mudança

0.23.3

Terra 0.16.2

Novos Recurso

Python 3.9 foi adicionado a esta versão. Agora você pode executar o Qiskit Terra usando Python 3.9.

Notas da Atualização

A classe MCXGrayCode agora criará um C3XGate se num_ctrl_qubits for 3 e um C4XGate se num_ctrl_qubits for 4. Isso é um acréscimo à funcionalidade anterior em que, para qualquer um dos modos da :class:' qiskit.library.standard_gates.x.MCXGate\ , se num_ctrl_bitsfor 1, será criado umCXGatee, se for 2, será criado umCCXGate` .

Correções de bugs

Pulso Delay agora são montadas explicitamente como objetos PulseQobjInstruction incluídos na PulseQobj saída de assemble().

Anteriormente, podíamos ignorar as instruções Delay em um arquivo Schedule como parte de assemble() já que o tempo estava explícito nos objetos PulseQobj objetos. Mas, agora, com as portas de pulso, há situações em que podemos programar APENAS um atraso, e a não inclusão do atraso em si removeria o atraso.
Os circuitos com calibrações de porta personalizadas agora podem ser programados com o transpilador sem fornecer explicitamente as durações de cada calibração de circuito.
O BasisTranslator e Unroller em alguns casos, não estavam preservando a fase global do circuito sob transpilação. Isso foi corrigido.
Um erro em qiskit.pulse.builder.frequency_offset() em que, quando compensate_phase era definido, um fator de $2\pi$ estava faltando na fase anexada.
Fixa a fase global da saída do método QuantumCircuit método repeat(). Se um circuito com fase global for anexado a outro circuito, a fase global não será propagada no momento. Os simuladores dependem disso, pois a fase é aplicada várias vezes. Isso define a fase global de repeat() para 0 antes de anexar o circuito repetido, em vez de multiplicar a fase existente pelo número de repetições.
Corrige o bug em SparsePauliOp em que a multiplicação por determinados tipos escalares não Python incorporados do Numpy retornava valores incorretos. Correções #5408
A definição da fidelidade Hellinger de foi corrigida da definição anterior de $1-H(P,Q)$ para $[1-H(P,Q)^2]^2$ , de modo que seja igual à fidelidade do estado quântico de P, Q como matrizes de densidade diagonal.
Reduzir o número de portas CX na decomposição da porta X com 3 controles, C3XGate. Compilado e otimizado na base U CX, agora são usadas apenas 14 portas CX e 16 portas U, em vez de 20 e 22, respectivamente.
Corrige o problema em que o uso do widget de backend do Jupyter ou qiskit.tools.backend_monitor() falharia se as portas de base do backend não incluíssem os tradicionais u1, u2 e u3.
Ao executar qiskit.compiler.transpile() em uma lista de circuitos com um único elemento, a função costumava retornar um circuito em vez de uma lista. Agora, quando o qiskit.compiler.transpile() for chamado com uma lista, ele retornará uma lista, mesmo que essa lista tenha um único elemento. Consulte #5260.
```
from qiskit import *

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

transpiled = transpile([qc])
print(type(transpiled), len(transpiled))
```
```
<class 'list'> 1
```

Aer 0.7.3

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.

Correções de bugs

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.
Corrige um erro que fazia com que o c_if não funcionasse quando a largura do registro condicional era maior que 64. Consulte #1077.
Corrige o erro em from_backend() e from_backend() , onde basis_gates era definido incorretamente para dispositivos IBMQ com o conjunto de porta 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 erro ao aplicar o truncamento no método de estado do produto da matriz do site QasmSimulator.

Ignis 0.5.1

Nenhuma mudança

Aqua 0.8.1

Nenhuma mudança

IBM 0.11.1

Nenhuma mudança

0.23.2

Terra 0.16.1

Nenhuma mudança

Aer 0.7.2

Novos Recurso

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.

Correções de bugs

Corrige um bug com o sinalizador OpenMP aninhado que estava sendo definido como verdadeiro quando não deveria.

Ignis 0.5.1

Nenhuma mudança

Aqua 0.8.1

Nenhuma mudança

IBM 0.11.1

Nenhuma mudança

0.23.1

Terra 0.16.1

Correções de bugs

Foi corrigido um problema em que um erro era lançado na execução de circuitos válidos criados com atrasos.
A definição QASM de ‘c4x’ em qelib1.inc foi corrigida para corresponder à definição da biblioteca padrão para C4XGate.
Corrige um bug na subtração para canais quânticos $A - B$ em que $B$ era um Operator objeto. A negação estava sendo aplicada à matriz na representação do operador, o que não é equivalente à negação na representação do canal quântico.
Altera a maneira como o _evolve_instruction() acessa os qubits para lidar com o caso de uma instrução com vários registros.

Aer 0.7.1

Notas da Atualização

A versão mínima do cmake para compilar o qiskit-aer aumentou de 3.6 para 3.8. Essa alteração foi necessária para permitir a correção de compilações de versões de GPU que suportam a execução em CPUs x86_64 sem instruções AVX2.

Correções de bugs

o qiskit-aer com suporte a GPU agora funcionará em sistemas com CPUs x86_64 sem instruções AVX2. Anteriormente, o pacote da GPU só era executado se as instruções AVX2 estivessem disponíveis. Correções #1023
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.
Correção do erro em que a porta "sx"` SXGate não era listado como uma porta compatível 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.
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.

Ignis 0.5.1

Correções de bugs

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, com frequência, 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() funções.

Aqua 0.8.1

0.8.1

Novos Recurso

Um novo algoritmo foi adicionado: a superfície de energia potencial Born Openheimer para o cálculo da superfície de energia potencial ao longo de diferentes graus de liberdade da molécula. O algoritmo é chamado de BOPESSampler. Além disso, ele oferece funcionalidades de ajuste da superfície de energia potencial a uma função analítica de detalhes predefinidos do potentials.some.

Problemas críticos

Esteja ciente de que o parâmetro initial_state em QAOA tem agora uma implementação diferente como resultado de uma correção de bug. A implementação anterior misturou erroneamente o initial_state fornecido pelo usuário com as portas Hadamard. O problema foi corrigido agora. Não é necessário prestar atenção se o seu código não fizer uso do parâmetro initial_state fornecido pelo usuário.

Correções de bugs

o método optimize_svm do qp_solver às vezes falhava, resultando em um erro como este ValueError: cannot reshape array of size 1 into shape (200,1) Isso resolve o problema adicionando um parâmetro de norma L2, lambda2, cujo padrão é 0.001, mas pode ser alterado por meio do algoritmo QSVM, conforme necessário, para facilitar a convergência.
Um método one_letter_symbol foi removido do VarType na última versão do DOCplex, tornando o Aqua incompatível com essa versão. Portanto, em vez de usar esse método, uma verificação explícita dos tipos de variáveis foi introduzida no módulo de otimização Aqua.
:meth`~qiskit.aqua.operators.state_fns.DictStateFn.sample()` só podia manipular amplitudes reais, mas foi corrigido para manipular amplitudes complexas. #1311 <https://github.com/qiskit-community/qiskit-aqua/issues/1311> para obter mais detalhes.
A classe Trotter não usou o argumento reps no construtor. #1317 <https://github.com/qiskit-community/qiskit-aqua/issues/1317> para obter mais detalhes.
Envie um e-mail para AquaError se :class`qiskit.aqua.operators.converters.CircuitSampler` mostrar um operador vazio. #1321 <https://github.com/qiskit-community/qiskit-aqua/issues/1321> para obter mais detalhes.
to_opflow() retorna um operador correto quando os coeficientes são números complexos. #1381 <https://github.com/qiskit-community/qiskit-aqua/issues/1381> para obter mais detalhes.
Permita que os simuladores de back-end validem o suporte a NoiseModel em vez de restringir a Aer somente em QuantumInstance.
Trate corretamente PassManager no método QuantumInstance transpile chamando seu método run , se ele existir.
Foi corrigido um erro que misturava initial_state personalizado em QAOA com portas Hadamard. Isso não altera a funcionalidade do QAOA se nenhum initial_state for fornecido pelo usuário. É preciso ter atenção se a sua implementação usar o QAOA com o parâmetro cusom initial_state , pois os resultados da otimização podem ser diferentes.
Anteriormente, a configuração do site seed_simulator=0 no QuantumInstance não definia nenhuma semente. Isso estava afetando apenas o valor 0. Isso foi corrigido.

IBM 0.11.1

Novos Recurso

qiskit.providers.ibmq.experiment.Experiment agora tem três atributos adicionais, hub, group e project, que identificam o provedor usado para criar o experimento.
Os métodos qiskit.providers.ibmq.experiment.ExperimentService.experiments() e qiskit.providers.ibmq.experiment.ExperimentService.analysis_results() agora suportam um parâmetro limit que permite limitar o número de experimentos e resultados de análise retornados.

Notas da Atualização

Um novo parâmetro, limit , é agora o primeiro parâmetro dos métodos qiskit.providers.ibmq.experiment.ExperimentService.experiments() e qiskit.providers.ibmq.experiment.ExperimentService.analysis_results() . Esse limit tem um valor padrão de 10, o que significa que, por padrão, apenas 10 experimentos e resultados de análise serão retornados.

Correções de bugs

Corrige o problema em que um trabalho poderia ser deixado no estado CREATING se o envio do trabalho falhasse no meio do caminho.
Corrige o loop infinito gerado ao passar uma instância do IBMQRandomService para um processo filho.

0.23.0

Terra 0.16.0

Prelúdio

A versão 0.16.0 inclui vários novos recursos e correções de bugs. Os principais recursos dessa versão são os seguintes:

Introdução de circuitos programados, em que os atrasos podem ser usados para controlar o tempo e o alinhamento das operações no circuito.
Compilação de circuitos quânticos a partir de funções clássicas, como oráculos.
Capacidade de compilar e otimizar rotações de qubit único em diferentes bases de Euler, bem como a base de fase + raiz quadrada (X) (ou seja, ['p', 'sx']), que substituirá a antiga base IBM Quantum de ['u1', 'u2', 'u3'].
Rastreamento de global_phase() na classe QuantumCircuit foi estendido por meio da classe transpiler, quantum_info, e assembler bem como dos simuladores BasicAer e Aer. As simulações de vetores unitários e de estado agora retornarão matrizes unitárias e vetores de estado com correção de fase global.

Também de particular importância para esta versão é o fato de que o site Python 3.5 não é mais suportado. Se estiver usando o Qiskit Terra com Python 3.5, a versão 0.15.2 é a última versão que funcionará.

Novos Recurso

Os portões R globais foram adicionados a qiskit.circuit.library. Isso inclui a porta R global (GR), Rx global (GRX) e Ry global (GRY), que são derivadas da porta GR e a porta global Rz ( GRZ), que é definido de forma semelhante às portas GR portas. As portas R globais são definidas em um número de qubits simultaneamente e atuam como uma soma direta de portas R em cada qubit.

Por exemplo:
```
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np

num_qubits = 3
qr = QuantumRegister(num_qubits)
qc = QuantumCircuit(qr)

qc.compose(GR(num_qubits, theta=np.pi/3, phi=2*np.pi/3), inplace=True)
```
criará um QuantumCircuit em um QuantumRegister de 3 qubits e executará um RGate de um ângulo $\theta = \frac{\pi}{3}$ em torno de um eixo no plano xy das esferas de Bloch que faz um ângulo de $\phi = \frac{2\pi}{3}$ com o eixo x em cada qubit.
Um novo esquema de cores, iqx, foi adicionado ao backend mpl para a gaveta de circuitos qiskit.visualization.circuit_drawer() e qiskit.circuit.QuantumCircuit.draw(). Ele usa o mesmo esquema de cores do Circuit Composer no site IBM Quantum Experience. Agora há três esquemas de cores disponíveis: default, iqx e bw.

Há duas maneiras de selecionar um esquema de cores. A primeira é usar um arquivo de configuração do usuário, por padrão no diretório ~/.qiskit , no arquivo settings.conf , sob o título [Default] , um usuário pode inserir circuit_mpl_style = iqx para selecionar o esquema de cores iqx .

A segunda maneira é adicionar {'name': 'iqx'} ao kwarg style ao método QuantumCircuit.draw ou à função circuit_drawer . A segunda maneira substituirá a configuração no arquivo settings.conf. Por exemplo:
```
from qiskit.circuit import QuantumCircuit

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure_all()
circuit.draw('mpl', style={'name': 'iqx'})
```
No site style kwarg para a gaveta do circuito qiskit.visualization.circuit_drawer() e qiskit.circuit.QuantumCircuit.draw() o campo displaycolor com o backend mpl agora permite inserir a cor da porta e a cor do texto para cada tipo de porta no formulário (gate_color, text_color). Isso permite o uso de cores claras e escuras no portão com cores de texto contrastantes. Os usuários ainda podem definir apenas a cor do portão e, nesse caso, o campo gatetextcolor será usado. As cores dos portões podem ser definidas no ditado style para qualquer número de tipos de portões, de um a todo o ditado displaycolor . Por exemplo:
```
from qiskit.circuit import QuantumCircuit

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

style_dict = {'displaycolor': {'h': ('#FA74A6', '#000000')}}
circuit.draw('mpl', style=style_dict)
```
ou
```
style_dict = {'displaycolor': {'h': '#FA74A6'}}
circuit.draw('mpl', style=style_dict)
```
Dois contextos de alinhamento são adicionados ao construtor de pulsos (qiskit.pulse.builder) para facilitar a gravação de uma sequência de pulsos repetidos com atrasos.
- qiskit.pulse.builder.align_equispaced() insere atrasos com comprimento equivalente entre as programações de pulso dentro do contexto.
- qiskit.pulse.builder.align_func() oferece um controle mais avançado da posição do pulso. Esse contexto recebe uma chamada que calcula uma coordenada fracionária do i-ésimo pulso e alinha os pulsos dentro do contexto. Isso facilita a codificação do desacoplamento dinâmico.
Um parâmetro rep_delay foi adicionado à classe QasmQobj na configuração de execução, QasmQobjConfig. Esse parâmetro é usado para indicar o tempo entre as execuções do programa. Ele deve ser escolhido entre o intervalo de back-end fornecido pelo método BackendConfiguration método rep_delay_range(). Se um valor não for fornecido, será usado um padrão de backend, qiskit.providers.models.BackendConfiguration.default_rep_delay. rep_delay só funcionará em backends que permitam o tempo de repetição dinâmico. Isso pode ser verificado com a propriedade BackendConfiguration propriedade dynamic_reprate_enabled.
O arquivo qobj_schema.json JSON Schema em qiskit.schemas foi atualizado para incluir o rep_delay como uma propriedade de configuração opcional para QASM Qobjs.
O arquivo backend_configuration_schema.json JSON Schema em qiskit.schemas foi atualizado para incluir dynamic_reprate_enabled, rep_delay_range e default_rep_delay como propriedades opcionais para uma carga de configuração de back-end QASM.
Um novo passe de otimização, qiskit.transpiler.passes.TemplateOptimization foi adicionada ao transpilador. Essa passagem aplica um algoritmo de correspondência de modelos descrito em arXiv:1909.05270 que substitui todas as correspondências máximas compatíveis no circuito.

Para implementar essa nova passagem de transpilador, um novo módulo, template_circuits, foi adicionado à biblioteca de circuitos (qiskit.circuit.library). Esse novo módulo contém todos os modelos de circuito de Toffoli usados na biblioteca de circuitos TemplateOptimization.

Esse novo passe não está incluído atualmente nos gerenciadores de passes predefinidos (qiskit.transpiler.preset_passmanagers); para usá-lo, você precisará criar um passe personalizado PassManager.
Uma nova versão da interface de provedores foi adicionada. Essa nova interface, que pode ser encontrada em qiskit.providersfornece um novo mecanismo de controle de versão que permitirá que as alterações na interface ocorram de forma compatível ao longo do tempo. A nova interface deve ser simples de migrar os provedores existentes, pois é praticamente idêntica, exceto pelo controle de versão explícito.

Além de ter classes abstratas com versão explícita, as principais mudanças na nova interface são que o método BackendV1 método run() agora pode receber um objeto QuantumCircuit ou Schedule como entradas em vez de objetos Qobj . Além disso, as opções agora fazem parte de uma classe de back-end, para que os usuários possam configurar as opções de tempo de execução ao executar um circuito. A última alteração é que o qiskit.providers.JobV1 agora pode ser síncrono ou assíncrono. A configuração exata e o método para configurar isso ficam a cargo do provedor, mas há pontos de conexão de interface para explicitar em qual modelo de execução um trabalho está sendo executado na classe abstrata JobV1 .
Um novo kwarg, inplace, foi adicionado à função qiskit.result.marginal_counts(). Esse kwarg é usado para controlar se o conteúdo é marginalizado no local ou se uma nova cópia é retornada, para Result entrada de objeto. Esse parâmetro não tem nenhum efeito para uma entrada dict ou Counts objeto.
Uma versão inicial de um compilador de funções clássico, qiskit.circuit.classicalfunctionfoi adicionada. Isso permite compilar funções python tipadas (operando apenas em bits do tipo Int1 no momento) em QuantumCircuit objetos. Por exemplo:
```
from qiskit.circuit import classical_function, Int1

@classical_function
def grover_oracle(a: Int1, b: Int1, c: Int1, d: Int1) -> Int1:
     x = not a and b
     y = d and not c
     z = not x or y
     return z

quantum_circuit = grover_oracle.synth()
quantum_circuit.draw()
```
O parâmetro registerless=False no método qiskit.circuit.classicalfunction.ClassicalFunction método synth() cria um circuito com registros referentes aos nomes dos parâmetros. Por exemplo:
```
quantum_circuit = grover_oracle.synth(registerless=False)
quantum_circuit.draw()
```
Uma função clássica decorada pode ser usada da mesma forma que qualquer outra porta quântica ao ser anexada a um circuito.
```
circuit = QuantumCircuit(5)
circuit.append(grover_oracle, range(5))
circuit.draw()
```
A porta GROVER_ORACLE é sintetizada quando sua decomposição é necessária.
```
circuit.decompose().draw()
```
O recurso requer tweedledum, uma biblioteca para sintetizar circuitos quânticos, que pode ser instalada via pip com pip install tweedledum.
Uma nova classe qiskit.circuit.Delay para representar uma instrução de atraso em um circuito foi adicionada. Um novo método delay() agora está disponível para acrescentar atrasos aos circuitos com facilidade. Isso possibilita a descrição de experimentos sensíveis ao tempo (por exemplo, o experimento T1/T2 ) no nível do circuito.
```
from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.delay(500, 0, unit='ns')
qc.measure(0, 0)

qc.draw()
```
Um novo argumento scheduling_method para qiskit.compiler.transpile() foi adicionado. É necessário ao transpilar circuitos com atrasos. Se scheduling_method for especificado, o transpilador retornará um circuito programado de forma que todos os tempos ociosos nele sejam preenchidos com atrasos (ou seja, a hora de início de cada instrução é determinada de forma exclusiva). Isso permite ver a aparência das instruções programadas (portas) no nível do circuito.
```
from qiskit import QuantumCircuit, transpile
from qiskit.test.mock.backends import FakeAthens

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

scheduled_circuit = transpile(qc, backend=FakeAthens(), scheduling_method="alap")
print("Duration in dt:", scheduled_circuit.duration)
scheduled_circuit.draw(idle_wires=False)
```
Consulte também timeline_drawer() para obter a melhor visualização dos circuitos programados.
Uma nova função qiskit.compiler.sequence() também foi adicionada para que possamos converter um circuito programado em um circuito Schedule para torná-lo executável em um backend habilitado para pulso.
```
from qiskit.compiler import sequence

sched = sequence(scheduled_circuit, pulse_enabled_backend)
```

O schedule() foi atualizado para que possa programar circuitos com atrasos. Agora há dois caminhos para programar um circuito com atraso:

qc = QuantumCircuit(1, 1)
qc.h(0)
qc.delay(500, 0, unit='ns')
qc.h(0)
qc.measure(0, 0)

sched_path1 = schedule(qc.decompose(), backend)
sched_path2 = sequence(transpile(qc, backend, scheduling_method='alap'), backend)
assert pad(sched_path1) == sched_path2

Consulte as notas de versão e a documentação de transpile() e sequence() para obter detalhes sobre o outro caminho.

Adicionado o GroverOperator à biblioteca de circuitos (qiskit.circuit.library) para construir o operador de Grover usado no algoritmo de pesquisa de Grover e na Amplificação/Estimação de Amplitude Quântica. Com um oráculo na forma de um circuito, o site GroverOperator cria o operador Grover de livro-texto. Para generalizar isso para amplificação de amplitude e usar um operador genérico em vez de portas Hadamard como preparação de estado, o argumento state_in pode ser usado.
Os InstructionScheduleMap métodos get() e pop() agora aceitam instâncias ParameterExpression além de valores numéricos para os parâmetros do gerador de agendamento. Se o gerador for uma função, as expressões poderão ser vinculadas antes ou dentro da chamada da função. Se o gerador for um ParametrizedSchedule, as expressões deverão ser vinculadas antes que a própria programação seja vinculada/chamada.
Uma nova classe LinearAmplitudeFunction foi adicionada à biblioteca de circuitos (qiskit.circuit.library) para mapear funções lineares (por partes) em amplitudes de qubit,

F|x\rangle |0\rangle = \sqrt{1 - f(x)}|x\rangle |0\rangle + \sqrt{f(x)}|x\rangle |1\rangle

O mapeamento é baseado em rotações Pauli Y controladas e em uma aproximação de Taylor, conforme descrito em https://arxiv.org/abs/1806.06893. Esse circuito pode ser usado para computar valores de expectativa de funções lineares usando o algoritmo de estimativa de amplitude quântica.

A nova mágica do jupyter monospaced_output foi adicionada ao módulo qiskit.tools.jupyter módulo. Essa mágica define a fonte de saída do notebook Jupyter como "Courier New", quando possível. Quando usada, essa fonte retorna desenhos de circuitos de texto mais bem alinhados.
```
import qiskit.tools.jupyter
%monospaced_output
```
Um novo passe de transpilador, Optimize1qGatesDecompositionfoi adicionada. Essa passagem do transpilador é uma alternativa à passagem existente do Optimize1qGates existente que usa a classe OneQubitEulerDecomposer para decompor e simplificar uma cadeia de portas de qubit único. Esse método é compatível com qualquer conjunto de bases, enquanto Optimize1qGates funciona apenas para u1, u2 e u3. Os gerenciadores de passes padrão para optimization_level 1, 2 e 3 foram atualizados para usar esse novo passe se o conjunto de base não incluir u1, u2, ou u3.
O OneQubitEulerDecomposer agora suporta duas novas bases, 'PSX' e 'U'. Eles podem ser especificados com o kwarg basis no construtor. Isso decomporá a matriz em um circuito usando PGate e SXGate para 'PSX', e UGate para 'U'.

Um novo método remove() foi adicionado à classe qiskit.transpiler.PassManager classe. Esse método permite remover um passe de uma instância PassManager instância. Ele funciona em índices, semelhante ao replace(). Por exemplo, para remover o passe RemoveResetInZeroState do gerenciador de passes usado no nível de otimização 1:

from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
from qiskit.transpiler.passmanager_config import PassManagerConfig

pm = level_1_pass_manager(PassManagerConfig())
pm.draw()

[0] FlowLinear: UnrollCustomDefinitions, BasisTranslator
[1] FlowLinear: RemoveResetInZeroState
[2] DoWhile: Depth, FixedPoint, Optimize1qGates, CXCancellation

O palco [1] com RemoveResetInZeroState pode ser removido da seguinte forma:

pass_manager.remove(1)
pass_manager.draw()

[0] FlowLinear: UnrollCustomDefinitions, BasisTranslator
[1] DoWhile: Depth, FixedPoint, Optimize1qGates, CXCancellation

Várias classes para carregar distribuições de probabilidade em amplitudes de qubit; UniformDistribution, NormalDistribution e LogNormalDistribution foram adicionadas à biblioteca de circuitos (qiskit.circuit.library). As distribuições normal e log-normal suportam distribuições univariadas e multivariadas. Esses circuitos são fundamentais para aplicações em finanças em que a estimativa de amplitude quântica é usada.
O suporte a portas de pulso foi adicionado à classe QuantumCircuit classe. Isso permite que um QuantumCircuit substitua (para portas básicas) ou especifique (para portas padrão e personalizadas) uma definição de uma Gate em termos de sinais ordenados por tempo nos canais de hardware. Em outras palavras, ele permite a opção de fornecer calibrações de porta personalizadas em nível de pulso.

Os circuitos são construídos exatamente como antes. Por exemplo:
```
from qiskit import pulse
from qiskit.circuit import QuantumCircuit, Gate

class RxGate(Gate):
    def __init__(self, theta):
        super().__init__('rxtheta', 1, [theta])

circ = QuantumCircuit(1)
circ.h(0)
circ.append(RxGate(3.14), [0])
```
Em seguida, a calibração da porta pode ser registrada usando o QuantumCircuit método add_calibration() que recebe uma Schedule bem como os qubits e os parâmetros para os quais ela foi definida:
```
# Define the gate implementation as a schedule
with pulse.build() as custom_h_schedule:
    pulse.play(pulse.library.Drag(...), pulse.DriveChannel(0))

with pulse.build() as q1_x180:
    pulse.play(pulse.library.Gaussian(...), pulse.DriveChannel(1))

# Register the schedule to the gate
circ.add_calibration('h', [0], custom_h_schedule)  # or gate.name string to register
circ.add_calibration(RxGate(3.14), [0], q1_x180)   # Can accept gate
```
Anteriormente, essa funcionalidade só podia ser usada por meio de programações de pulso completas. Além disso, os circuitos agora podem ser enviados aos back-ends com suas definições personalizadas (dependendo do suporte do back-end).

Os circuitos com portas de pulso ainda podem ser reduzidos para um Schedule usando a função schedule() função.

A porta calibrada também pode ser transpilada usando o processo regular de transpilação:
```
transpiled_circuit = transpile(circ, backend)
```
O circuito transpilado deixará as portas calibradas no mesmo qubit que o circuito original e não as desenrolará para as portas de base.

O suporte para desmontagem de objetos PulseQobj foi adicionado à função qiskit.assembler.disassemble() função. Por exemplo:

from qiskit import pulse
from qiskit.assembler.disassemble import disassemble
from qiskit.compiler.assemble import assemble
from qiskit.test.mock import FakeOpenPulse2Q

backend = FakeOpenPulse2Q()

d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build(backend) as sched:
    with pulse.align_right():
        pulse.play(pulse.library.Constant(10, 1.0), d0)
        pulse.shift_phase(3.11, d0)
        pulse.measure_all()

qobj = assemble(sched, backend=backend, shots=512)
scheds, run_config, header = disassemble(qobj)

Um novo kwarg, coord_type , foi adicionado ao qiskit.visualization.plot_bloch_vector(). Esse kwarg permite alterar o sistema de coordenadas usado para o parâmetro de entrada que descreve o posicionamento do vetor na esfera de Bloch na visualização gerada. Há dois valores compatíveis com esse novo kwarg, 'cartesian' (o valor padrão) e 'spherical'. Se o kwarg coord_type for definido como 'spherical' , a lista de parâmetros recebidos terá o formato [r, theta, phi] , em que r é o raio, theta é a inclinação da direção +z e phi é o azimute da direção +x. Por exemplo:
```
from numpy import pi

from qiskit.visualization import plot_bloch_vector

x = 0
y = 0
z = 1
r = 1
theta = pi
phi = 0


# Cartesian coordinates, where (x,y,z) are cartesian coordinates
# for bloch vector
plot_bloch_vector([x,y,z])
```
```
plot_bloch_vector([x,y,z], coord_type="cartesian")  # Same as line above
```
```
# Spherical coordinates, where (r,theta,phi) are spherical coordinates
# for bloch vector
plot_bloch_vector([r, theta, phi], coord_type="spherical")
```

Pulse Schedule agora suportam o uso de objetos ParameterExpression para parâmetros.

Por exemplo:

from qiskit.circuit import Parameter
from qiskit import pulse

alpha = Parameter('⍺')
phi = Parameter('ϕ')
qubit = Parameter('q')
amp = Parameter('amp')

schedule = pulse.Schedule()
schedule += SetFrequency(alpha, DriveChannel(qubit))
schedule += ShiftPhase(phi, DriveChannel(qubit))
schedule += Play(Gaussian(duration=128, sigma=4, amp=amp),
                 DriveChannel(qubit))
schedule += ShiftPhase(-phi, DriveChannel(qubit))

A atribuição de parâmetros é feita por meio do método assign_parameters() método:

schedule.assign_parameters({alpha: 4.5e9, phi: 1.57,
                            qubit: 0, amp: 0.2})

Expressões e atribuições parciais também funcionam, como, por exemplo:

beta = Parameter('b')
schedule += SetFrequency(alpha + beta, DriveChannel(0))
schedule.assign_parameters({alpha: 4.5e9})
schedule.assign_parameters({beta: phi / 6.28})

Uma nova função de visualização timeline_drawer() foi adicionada ao módulo qiskit.visualization módulo.

Por exemplo:

from qiskit.visualization import timeline_drawer
from qiskit import QuantumCircuit, transpile
from qiskit.test.mock import FakeAthens

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
timeline_drawer(transpile(qc, FakeAthens(), scheduling_method='alap'))

Notas da Atualização

A verificação de tipo para o kwarg params do construtor da classe Gate e suas subclasses foi alterada. Anteriormente, todos os Gate tinham que estar em um conjunto de tipos permitidos definidos na classe Instruction classe. Agora, um novo método, validate_parameter() é usado para determinar se um tipo de parâmetro é válido ou não. A definição desse método em uma subclasse terá prioridade sobre sua classe principal. Por exemplo, UnitaryGate aceita um parâmetro do tipo numpy.ndarray e define um método validate_parameter() personalizado que retorna o parâmetro se ele for um numpy.ndarray. Isso tem prioridade sobre a função definida em sua classe principal Gate. Se o site UnitaryGate fosse usado como pai de uma nova classe, esse método validate_parameter seria usado, a menos que a nova classe filha definisse seu próprio método.
Os métodos, argumentos e propriedades anteriormente obsoletos denominados n_qubits e numberofqubits foram removidos. Eles foram descontinuados na versão 0.13.0. O conjunto completo de alterações é o seguinte:

Classe
Antigo
Novo
QuantumCircuit n_qubits num_qubits
Pauli numberofqubits num_qubits

Função
Argumento antigo
Novo argumento
qiskit.circuit.random.random_circuit() n_qubits num_qubits
qiskit.circuit.library.MSGate n_qubits num_qubits
Inserção de uma instância Gate parametrizada em um QuantumCircuit agora cria uma cópia dessa porta que é usada no circuito. Se forem feitas alterações na instância inserida no circuito, elas não serão mais refletidas na porta do circuito. Essa alteração foi feita para corrigir um problema ao inserir um único objeto parametrizado Gate em vários circuitos.
A função qiskit.result.marginal_counts() agora, por padrão, não modifica o parâmetro qiskit.result.Result parâmetro de instância. Anteriormente, o objeto Result era sempre modificado no local. Um novo kwarg inplace foi adicionado marginal_counts() que permite usar o comportamento anterior quando inplace=True está definido.
A definição U3Gate foi alterada para ser em termos da classe UGate classe. A classe UGate não tem definição. Portanto, não é mais possível desenrolar todos os circuitos em termos de U3 e CX. Em vez disso, U e CX podem ser usados para cada circuito.
O suporte obsoleto para a execução do Qiskit Terra com Python 3.5 foi removido. Para usar o Qiskit Terra a partir desta versão, agora você precisará usar pelo menos Python 3.6. Se você estiver usando Python 3.5, a última versão que funcionará é o Qiskit Terra 0.15.2.
Nos atributos PulseBackendConfiguration nos atributos hamiltonian , o campo vars agora é retornado em uma unidade de Hz em vez do GHz usado anteriormente. Essa alteração foi feita para ser consistente com as unidades usadas com os outros atributos da classe.
O suporte anteriormente obsoleto para a passagem de um dicionário como o primeiro argumento posicional para o DAGNode foi removido. O uso de um dictonário para o primeiro argumento posicional foi preterido na versão 0.13.0. Para criar um objeto DAGNode agora você deve passar diretamente os atributos como kwargs no construtor.
Os argumentos de palavra-chave para os métodos de porta de circuito (por exemplo: qiskit.circuit.QuantumCircuit.cx) q, ctl* e tgt*, que foram descontinuados na versão 0.12.0, foram removidos. Em vez disso, somente qubit, control_qubit* e target_qubit* podem ser usados como argumentos nomeados para esses métodos.
O módulo qiskit.extensions.standard , anteriormente obsoleto, foi removido. Esse módulo foi descontinuado desde a versão 0.14.0. O qiskit.circuit.library pode ser usado em seu lugar. Além disso, todas as classes de porta anteriormente em qiskit.extensions.standard ainda podem ser importadas do qiskit.extensions.
As portas anteriormente obsoletas no módulo qiskit.extensions.quantum_initializer: DiagGate, UCG`, UCPauliRotGate, UCRot, UCRXGate, UCX, UCRYGate, UCY, UCRZGate, UCZ foram removidas. Todos eles foram descontinuados na versão 0.14.0 e têm alternativas disponíveis na biblioteca de circuitos (qiskit.circuit.library).
O método qiskit.circuit.QuantumCircuitiden() foi removido. Isso foi descontinuado na versão 0.13.0 e o i() ou id() pode ser usado em seu lugar.

Classe	Antigo	Novo
`QuantumCircuit`	`n_qubits`	`num_qubits`
`Pauli`	`numberofqubits`	`num_qubits`

Função	Argumento antigo	Novo argumento
`qiskit.circuit.random.random_circuit()`	`n_qubits`	`num_qubits`
`qiskit.circuit.library.MSGate`	`n_qubits`	`num_qubits`

Notas de descontinuação

O uso de um numpy.ndarray para um parâmetro no kwarg params para o construtor da classe Gate e subclasses foi preterido e será removido em versões futuras. Isso foi feito como parte da refatoração de como a verificação do tipo parms é tratada para a classe Gate classe. Se você tiver uma classe de porta personalizada que seja uma subclasse de Gate diretamente (ou por meio de um pai diferente na hierarquia) que aceita um parâmetro ndarray , você deverá definir um método validate_parameter() personalizado para sua classe que retornará o tipo de parâmetro permitido. Por exemplo:
```
def validate_parameter(self, parameter):
    """Custom gate parameter has to be an ndarray."""
    if isinstance(parameter, numpy.ndarray):
        return parameter
    else:
        raise CircuitError("invalid param type {0} in gate "
                           "{1}".format(type(parameter), self.name))
```
A propriedade num_ancilla_qubits da propriedade PiecewiseLinearPauliRotations e PolynomialPauliRotations foi descontinuada e será removida em uma versão futura. Em vez disso, a propriedade num_ancillas deve ser usada em seu lugar. Isso foi feito para torná-lo consistente com o método QuantumCircuit método num_ancillas().
A classe qiskit.circuit.library.MSGate foi descontinuada, mas permanecerá em vigor para permitir o carregamento de trabalhos antigos. Ela foi substituída pela classe qiskit.circuit.library.GMS que deve ser usada em seu lugar.
A passagem do transpilador MSBasisDecomposer foi preterida e será removida em uma versão futura. O passe qiskit.transpiler.passes.BasisTranslator pode ser usado em seu lugar.
Os métodos QuantumCircuitu1 , u2 e u3 estão obsoletos. Em vez disso, as seguintes substituições podem ser usadas.
```
u1(theta) = p(theta) = u(0, 0, theta)
u2(phi, lam) = u(pi/2, phi, lam) = p(pi/2 + phi) sx p(pi/2 lam)
u3(theta, phi, lam) = u(theta, phi, lam) = p(phi + pi) sx p(theta + pi) sx p(lam)
```
As próprias classes de portais, U1Gate, U2Gate e U3Gate permanecem, para permitir o carregamento de trabalhos antigos.

Correções de bugs

Os métodos da classe Result métodos da classe data(), get_memory(), get_counts(), get_unitary(), e get_statevector ` will now emit a warning when the ``experiment`() kwarg é especificado para tentar buscar resultados usando um QuantumCircuit ou Schedule quando mais de uma entrada correspondente ao nome da instância estiver presente no objeto Result . Observe que somente a primeira entrada correspondente a esse nome será retornada. Correções #3207
O método qiskit.circuit.QuantumCircuit método append() agora pode ser usado para inserir uma instância de porta parametrizada em vários circuitos. Isso corrige um problema anterior em que a inserção de um único objeto parametrizado Gate em vários circuitos causava falhas quando um circuito tinha um parâmetro atribuído. Correções #4697
Anteriormente, a função qiskit.execute.execute() não permitia, incorretamente, que os kwargs backend e pass_manager fossem especificados ao mesmo tempo. Isso foi corrigido para que tanto backend quanto pass_manager possam ser usados juntos em chamadas para execute(). Correções #5037
O método QuantumCircuit method unitary() foi corrigido para aceitar um único número inteiro para o argumento qarg (ao adicionar uma unidade de 1 qubit). Os tipos permitidos para o argumento qargs agora são int, Qubit, ou uma lista de números inteiros. Correções #4944
Anteriormente, chamar inverse() em um objeto BlueprintCircuit poderia falhar se sua propriedade de dados internos ainda não estivesse preenchida. Isso foi corrigido para que a chamada para inverse() preencha os dados internos antes de gerar o inverso do circuito. Correções #5140
Foi corrigido um problema ao criar um objeto qiskit.result.Counts a partir de um dicionário de dados vazio. Agora, isso criará um objeto Counts vazio. O método most_frequent() também foi atualizado para gerar uma exceção mais descritiva quando o objeto estiver vazio. Correções #5017
Corrige um bug em que a configuração ctrl_state de um UnitaryGate era aplicada duas vezes; uma vez na criação da matriz para o unitário controlado e novamente ao chamar o método definition() da classe qiskit.circuit.ControlledGate classe. Isso daria a impressão de que a configuração ctrl_state não teve efeito.
Anteriormente, o método ControlledGate method inverse() não preservava o parâmetro ctrl_state em alguns casos. Isso foi corrigido para que chamar inverse() preservará o valor ctrl_state em sua saída.
Correção de um bug no backend de saída mpl da gaveta de circuitos qiskit.circuit.QuantumCircuit.draw() e qiskit.visualization.circuit_drawer() que fazia com que a gaveta falhasse se o style kwarg fosse definido como uma string. O comportamento correto seria tratar essa cadeia de caracteres como um caminho para um arquivo JSON que contém a folha de estilo para a visualização. Isso foi corrigido, e serão emitidos avisos se o arquivo JSON da folha de estilo não puder ser carregado.
Foi corrigido um erro ao carregar um arquivo QASM via from_qasm_file() ou from_qasm_str() falhava se um portão u, phase(p), sx ou sxdg estivesse presente no arquivo QASM. Correções #5156
Foi corrigido um bug que poderia fazer com que os registros fossem mal mapeados ao desenrolar/decompor uma porta definida com apenas uma operação de 2 qubit.

Aer 0.7.0

Prelúdio

Esta versão 0.7.0 inclui várias melhorias de desempenho e aprimoramentos significativos na interface do simulador, além de eliminar o suporte para Python 3.5. As principais alterações na interface são os backends configuráveis do simulador e a construção de simuladores pré-configurados a partir dos backends do IBMQ. O suporte ao modelo de ruído e ao portão de base também foi ampliado para a maioria dos portões padrão da biblioteca de circuitos Qiskit, incluindo um novo suporte para portões de rotação de 1 e 2 qubit. Os aprimoramentos de desempenho incluem a adição de suporte a SIMD aos métodos de simulação unitária e de matriz de densidade, reduzindo a memória usada e melhorando o desempenho dos circuitos que usam instantâneos de matriz de densidade e de vetor de estado, além de adicionar suporte a instruções Kraus à otimização do circuito de fusão de portas para melhorar consideravelmente o desempenho das simulações de vetor de estado com ruído.

Novos Recurso

Adiciona suporte à porta de base para a instrução qiskit.circuit.Delay aos sites StatevectorSimulator, UnitarySimulator e QasmSimulator. Observe que essa porta é tratada como uma porta de identidade durante a simulação e o parâmetro de comprimento do atraso é ignorado.
Adiciona suporte à porta de base para a porta de um único qubit qiskit.circuit.library.UGate aos métodos StatevectorSimulator, UnitarySimulator e "statevector", "density_matrix", "matrix_product_state" e "extended_stabilizer" do QasmSimulator.
Adiciona suporte à porta de base para a porta de fase qiskit.circuit.library.PhaseGate aos métodos StatevectorSimulator, StatevectorSimulator, UnitarySimulator, e "statevector", "density_matrix", "matrix_product_state", e "extended_stabilizer" do QasmSimulator.
Adiciona suporte à porta de base para a porta de fase controlada qiskit.circuit.library.CPhaseGate aos métodos StatevectorSimulator, StatevectorSimulator, UnitarySimulator e "statevector", "density_matrix" e "matrix_product_state" do QasmSimulator.
Adiciona suporte à porta de fase multicontrolada qiskit.circuit.library.MCPhaseGate aos sites StatevectorSimulator, UnitarySimulator e ao método "statevector" do site QasmSimulator.
Adiciona suporte para a porta $\sqrt(X)$ qiskit.circuit.library.SXGate aos sites StatevectorSimulator, UnitarySimulator e QasmSimulator.
Adiciona suporte para portas de rotação da biblioteca de circuitos Qiskit de 1 e 2 qubit RXGate, RYGate, RZGate, RGate, RXXGate, RYYGate, RZZGate, RZXGate para os métodos StatevectorSimulator, UnitarySimulator, e "statevector" e "density_matrix" do QasmSimulator.
Adiciona suporte para portas de rotação multicontroladas "mcr", "mcrx", "mcry", "mcrz" aos métodos StatevectorSimulator, UnitarySimulator e "statevector" do QasmSimulator.
Tornar configuráveis os backends do simulador. Isso permite definir opções persistentes, como o método de simulação e o modelo de ruído para cada objeto de backend do simulador.

O QasmSimulator e o PulseSimulator também podem ser configurados a partir de um objeto de backend IBMQBackend usando o método :meth:`~qiskit.providers.aer.QasmSimulator.from_backend. Para o site QasmSimulator , isso configurará o mapa de acoplamento, as portas de base e o modelo básico de ruído do dispositivo com base na configuração e nas propriedades do backend. Para o site PulseSimulator , o modelo e os padrões do sistema serão configurados automaticamente a partir da configuração, das propriedades e dos padrões do backend.

Por exemplo, um backend de simulador de matriz de densidade com ruído pode ser construído como QasmSimulator(method='density_matrix', noise_model=noise_model), ou um simulador de estado de produto de matriz ideal como QasmSimulator(method='matrix_product_state').

Uma vantagem é que uma instância do PulseSimulator configurada a partir de um backend funciona melhor como um substituto para o backend original, facilitando a troca entre um simulador e um backend real, por exemplo, ao testar o código em um simulador antes de usar um backend real. Por exemplo, no bloco de código a seguir, o PulseSimulator é instanciado a partir do backend FakeArmonk() . Todos os dados de configuração e padrão são copiados para a instância do simulador e, portanto, quando são passados como argumento para assemble, ele se comporta como se o backend original tivesse sido fornecido (por exemplo, os padrões de FakeArmonk estarão presentes e serão usados por assemble).
```
armonk_sim = qiskit.providers.aer.PulseSimulator.from_backend(FakeArmonk())
pulse_qobj = assemble(schedules, backend=armonk_sim)
armonk_sim.run(pulse_qobj)
```
Embora o exemplo acima seja pequeno, o comportamento demonstrado de "substituição por drop-in" deve melhorar muito a usabilidade em fluxos de trabalho mais complicados, por exemplo, quando os experimentos de calibração são construídos usando atributos de back-end.
Adiciona suporte para a fase global do qobj aos métodos StatevectorSimulator, UnitarySimulator e statevector do QasmSimulator.
Melhora o desempenho geral da simulação de vetor de estado com ruído adicionando um método Kraus à otimização do circuito de fusão de porta que permite aplicar a fusão de porta a simulações de vetor de estado com ruído com ruído Kraus geral.
Use a semântica de movimentação para instantâneos de vetor de estado e matriz de densidade para os métodos "statevector" e "density_matrix" do site QasmSimulator se eles forem a instrução final em um circuito. Isso reduz o uso de memória do simulador e melhora o desempenho, evitando a cópia de uma matriz grande nos resultados.
Adiciona suporte para erros gerais da porta Kraus QauntumError no método NoiseModel para o método "matrix_product_state" do QasmSimulator.
Adiciona suporte à instrução de instantâneo de matriz de densidade qiskit.providers.aer.extensions.SnapshotDensityMatrix ao método "matrix_product_state" do QasmSimulator.
Amplia a vetorização SIMD do método de simulação de vetor de estado para os métodos de simulação de matriz unitária, matriz de superoperador e matriz de densidade. Isso proporciona um aumento de desempenho de aproximadamente 2x simulação geral usando o UnitarySimulator, o método "density_matrix" do QasmSimulator, fusão de portas e simulação de ruído.
Adiciona uma classe vetorial personalizada ao código C++ que tem melhor integração com Pybind11. Isso reduz o requisito de memória do site StatevectorSimulator , evitando uma cópia de memória durante a vinculação Python do estado final do simulador.

Notas da Atualização

O AER agora usa o Lapack para realizar alguns cálculos relacionados à matriz. Ele usa a biblioteca Lapack incluída no pacote OpenBlas (já disponível nas distribuições Linux e OpenBlas típicas do Macos; a versão para Windows é distribuída com o AER) ou com a estrutura do accelerate em MacOS.
O suporte obsoleto para a execução do qiskit-aer com Python 3.5 foi removido. Para usar o qiskit-aer >= 0.7.0, agora você precisará de pelo menos Python 3.6. Se você estiver usando Python 3.5, a última versão que funcionará é qiskit-aer 0.6.x.
Atualiza os limites padrão da fusão de portas para que a fusão de portas seja aplicada a circuitos com mais de 14 qubits para simulações de vetores de estado em StatevectorSimulator e QasmSimulator.

Para o método "density_matrix" do QasmSimulator e para o UnitarySimulator , a fusão de portas será aplicada a circuitos com mais de 7 qubits.

Os valores de limite de qubit personalizados podem ser definidos usando a opção de backend fusion_threshold , ou seja backend.set_options(fusion_threshold=10)
Altera a opção de backend fusion_threshold para aplicar a fusão quando o número de qubits estiver acima do limite, não igual ou acima do limite, para corresponder ao comportamento do parâmetro de limite de qubit OpenMP.

Notas de descontinuação

qiskit.providers.aer.noise.NoiseModel.set_x90_single_qubit_gates() foi descontinuado, pois o desenrolamento para portas de base personalizadas foi adicionado ao transpilador do qiskit. A maneira correta de usar um modelo de ruído baseado em X90 é definir o ruído no portão Sqrt(X) "sx" ou "rx" e um dos portões de fase de qubit único "u1", "rx" ou "p" no modelo de ruído.
O kwarg variance das instruções do Snapshot foi preterido. Essa função calculou a variância da amostra no instantâneo devido à amostragem do modelo de ruído, e não a variância devido às estatísticas de medição, por isso estava sendo usada incorretamente com frequência. Se a variância da modelagem de ruído for necessária, devem ser usados instantâneos de uma única foto para que a variância possa ser calculada manualmente no pós-processamento.

Correções de bugs

Corrige um bug no site StatevectorSimulator que fazia com que ele sempre fosse executado como CPU com precisão dupla sem o suporte do site SIMD/AVX2, mesmo em sistemas com AVX2 ou quando a precisão única ou o método de GPU era especificado nas opções de back-end.
Corrige alguns for-loops no código C++ que estavam iterando sobre cópias em vez de referências de elementos do contêiner.
Corrige um bug em que os dados do instantâneo eram sempre copiados do C++ para Python em vez de serem movidos, sempre que possível. Isso reduzirá pela metade o uso da memória e melhorará o tempo de simulação ao usar instantâneos grandes de vetores de estado ou matrizes de densidade.
Corrigir State::snapshot_pauli_expval para retornar o valor de expectativa Y correto no simulador de estabilizador. Consulte #895 <https://github.com/Qiskit/qiskit-aer/issues/895> para obter mais detalhes.
Os wrappers controller_execute foram ajustados para serem funtores (objetos) em vez de funções livres. Entre outras coisas, isso permite que eles sejam usados em chamadas para multiprocessing.pool.map.
Adicione verificações de falta de memória disponível para StatevectorSimulator e UnitarySimulator. Isso gera uma exceção se a memória necessária para simular o número de qubits em um circuito exceder a memória disponível do sistema.

Ignis 0.5.0

Prelúdio

Essa versão inclui um novo módulo para mitigação de erros de medição de valores de expectativa, funcionalidade aprimorada de plotagem para experimentos de volume quântico, várias correções de bugs e suporte a drops para Python 3.5.

Novos Recurso

A função qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() permite uma entrada opcional de objetos de porta como interleaved_elem. Além disso, a classe CNOT-Dihedral qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral tem um novo método to_instruction, e o método from_circuit existente tem uma entrada opcional de uma instrução (além de QuantumCircuit ).
O site qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral agora contém os seguintes novos recursos. Inicialização de vários tipos de objetos: CNOTDihedral, ScalarOp, QuantumCircuit, Instruction e Pauli. Conversão em uma matriz usando to_matrix e em um operador usando to_operator. Métodos de produto tensorial tensor e expansão. Cálculo do adjunto, conjugado e transposição usando os métodos de conjugado, adjunto e transposição. Verifique se um elemento é CNOTDihedral usando o método is_cnotdihedral. O método de decomposição to_circuit de um elemento CNOTDihedral em um circuito foi ampliado para permitir qualquer número de qubits, com base na função decompose_cnotdihedral_general.

Adiciona mitigação de erro de medição de valor de expectativa ao módulo de mitigação. Isso permite o uso da matriz de atribuição de N qubit completa, da matriz de atribuição com tensão de qubit único ou da mitigação de erro de medição do processo de Markov em tempo contínuo (CTMP) [1] ao calcular os valores de expectativa dos operadores diagonais dos dicionários de contagens. Os valores de expectativa são calculados usando a função qiskit.ignis.mitigation.expectation_value() .

Os circuitos de calibração para calibrar um atenuador de erro de medição são gerados usando a função qiskit.ignis.mitigation.expval_meas_mitigator_circuits() e o resultado é ajustado usando a classe qiskit.ignis.mitigation.ExpvalMeasMitigatorFitter . O ajustador retorna um objeto mitigador que pode ser fornecido como um argumento para a função expectation_value() para aplicar a mitigação.

[1] S Bravyi, S Sheldon, A Kandala, DC Mckay, JM Gambetta,

Mitigando erros de medição em experimentos multiqubit, arXiv:2006.14044 [quant-ph].

Exemplo:

O exemplo a seguir mostra a calibração de um atenuador de erro de medição de valor de expectativa de 5 qubits usando o método 'tensored' .

from qiskit import execute
from qiskit.test.mock import FakeVigo
import qiskit.ignis.mitigation as mit

backend = FakeVigo()
num_qubits = backend.configuration().num_qubits

# Generate calibration circuits
circuits, metadata = mit.expval_meas_mitigator_circuits(
    num_qubits, method='tensored')
result = execute(circuits, backend, shots=8192).result()

# Fit mitigator
mitigator = mit.ExpvalMeasMitigatorFitter(result, metadata).fit()

# Plot fitted N-qubit assignment matrix
mitigator.plot_assignment_matrix()

A seguir, mostramos como usar o atenuador acima para aplicar a atenuação do erro de medição aos cálculos do valor de expectativa

from qiskit import QuantumCircuit

# Test Circuit with expectation value -1.
qc = QuantumCircuit(num_qubits)
qc.x(range(num_qubits))
qc.measure_all()

# Execute
shots = 8192
seed_simulator = 1999
result = execute(qc, backend, shots=8192, seed_simulator=1999).result()
counts = result.get_counts(0)

# Expectation value of Z^N without mitigation
expval_nomit, error_nomit = mit.expectation_value(counts)
print('Expval (no mitigation): {:.2f} \u00B1 {:.2f}'.format(
    expval_nomit, error_nomit))

# Expectation value of Z^N with mitigation
expval_mit, error_mit = mit.expectation_value(counts,
    meas_mitigator=mitigator)
print('Expval (with mitigation): {:.2f} \u00B1 {:.2f}'.format(
    expval_mit, error_mit))

Adiciona o Numba como uma dependência opcional. O Numba é usado para aumentar significativamente o desempenho da classe qiskit.ignis.mitigation.CTMPExpvalMeasMitigator usada para a atenuação do erro de medição do valor esperado com o método CTMP.
Adicione dois métodos ao site qiskit.ignis.verification.quantum_volume.QVFitter.
- qiskit.ignis.verification.quantum_volume.QVFitter.calc_z_value() para calcular o valor z na distribuição normal padrão usando a média e o desvio padrão sigma. Se sigma = 0, ele emite um aviso e atribui um valor pequeno ( 1e-10 ) para sigma para que o código ainda seja executado.
- qiskit.ignis.verification.quantum_volume.QVFitter.calc_confidence_level() para calcular o nível de confiança usando o valor z.
Armazene o nível de confiança mesmo quando hmean < 2/3 em qiskit.ignis.verification.quantum_volume.QVFitter.qv_success().
Adicione explicações sobre como calcular estatísticas com base na distribuição binomial em qiskit.ignis.verification.quantum_volume.QVFitter.calc_statistics().
O método qiskit.ignis.verification.QVFitter plot_qv_data() foi atualizado para retornar um objeto matplotlib.Figure . Anteriormente, ele não retornava nada. Ao retornar uma figura, fica mais fácil integrar as visualizações em um fluxo de trabalho matplotlib maior.
As barras de erro na figura produzida pelo método qiskit.ignis.verification.QVFitter qiskit.ignis.verification.QVFitter.plot_qv_data() foram atualizadas para representar intervalos de confiança de dois sigmas. Anteriormente, as barras de erro representavam intervalos de confiança de um sigma. O critério de sucesso do benchmarking do Quantum Volume requer uma probabilidade de saída pesada > 2/3 com confiança unilateral de dois sigmas ( ~97.7 %). A alteração das barras de erro para representar intervalos de confiança de dois sigmas permite identificar facilmente o sucesso na figura.
Um novo kwarg, figsize , foi adicionado ao método qiskit.ignis.verification.QVFitter qiskit.ignis.verification.QVFitter.plot_qv_data(). Esse kwarg recebe uma tupla no formato (x, y) , em que x e y são as dimensões em polegadas para fazer o gráfico gerado.
O método qiskit.ignis.verification.quantum_volume.QVFitter.plot_hop_accumulative() foi adicionado para representar a probabilidade de saída pesada (HOP) versus o número de tentativas, semelhante à Figura 2a do artigo do Quantum Volume 64 ( arXiv:2008.08571 ). A HOP de tentativas individuais é plotada como dispersão e a HOP cumulativa é plotada em linha vermelha. Os intervalos de confiança de dois sigmas são plotados como área sombreada e o limite de sucesso de 2/3 é plotado como linha tracejada.
O método qiskit.ignis.verification.quantum_volume.QVFitter.plot_qv_trial() foi adicionado para plotar testes individuais, aproveitando o método qiskit.visualization.plot_histogram() do Qiskit Terra. As contagens de bitstring são plotadas como histogramas sobrepostos para valores ideais (vazados) e experimentais (preenchidos). A probabilidade de saída pesada experimental é mostrada na legenda. A probabilidade mediana é representada por uma linha tracejada vermelha.

Notas da Atualização

O suporte obsoleto para a execução do qiskit-ignis com Python 3.5 foi removido. Para usar o qiskit-ignis >= 0.5.0, agora você precisará de pelo menos Python 3.6. Se você estiver usando Python 3.5, a última versão que funcionará é qiskit-ignis 0.4.x.

Correções de bugs

Correção de um bug na classe qiskit.ignis.verification.randomized_benchmarking.CNOTDihedral para elementos com mais de 5 desistências.
Fixe o limite do nível de confiança para qiskit.ignis.verification.quantum_volume.QVFitter.qv_success() em 0.977 correspondente a z = 2, conforme definido pelo Algoritmo 1 do documento QV.
Correção de um erro em qiskit.ignis.verification.randomized_benchmarking.randomized_benchmarking_seq() que fazia com que todos os subsistemas com o mesmo tamanho no rb_pattern fornecido tivessem as mesmas portas quando um parâmetro 'rand_seed' era fornecido à função.

Aqua 0.8.0

Prelúdio

Esta versão apresenta uma interface para executar os métodos disponíveis para problemas bósnicos. Em particular, introduzimos uma interface completa para executar cálculos de estrutura vibrônica.

Esta versão apresenta uma interface para cálculos de estados excitados. Agora é mais fácil para o usuário criar um cálculo geral de estados excitados. Esse cálculo é baseado em um Driver que fornece as informações relevantes sobre a molécula, uma Transformação que fornece as informações sobre o mapeamento do problema em um qubit Hamiltoniano e, por fim, um Solver. O Solver é a maneira específica pela qual o cálculo dos estados excitados é feito (o algoritmo). Essa estrutura segue a dos cálculos do estado fundamental. Os resultados são modificados para receber listas de valores de expectativa em vez de um único. O QEOM e o site NumpyEigensolver estão adaptados à nova estrutura. Uma fábrica é introduzida para executar um eigensolver numpy com um filtro específico (para atingir estados de simetrias específicas).

O cálculo de expectativa de VQE com o Aer qasm_simulator agora tem como padrão um cálculo que tem o comportamento esperado de ruído de disparo.

Novos Recurso

Introduziu uma opção warm_start que deve ser usada quando o ajuste de outras opções não ajudar. Quando essa opção está ativada, um problema relaxado (todas as variáveis são contínuas) é resolvido primeiro e a solução é usada para inicializar o estado do otimizador antes de iniciar o processo iterativo no método de solução.

Os algoritmos de estimativa de amplitude agora usam objetos QuantumCircuit como entradas para especificar os operadores A- e Q. Essa mudança acompanha a introdução do GroverOperator na biblioteca de circuitos, que permite uma construção intuitiva e rápida de diferentes operadores Q. Por exemplo, um experimento Bernoulli pode agora ser construído como

import numpy as np
from qiskit import QuantumCircuit
from qiskit.aqua.algorithms import AmplitudeEstimation

probability = 0.5
angle = 2 * np.sqrt(np.arcsin(probability))
a_operator = QuantumCircuit(1)
a_operator.ry(angle, 0)

# construct directly
q_operator = QuantumCircuit(1)
q_operator.ry(2 * angle, 0)

# construct via Grover operator
from qiskit.circuit.library import GroverOperator
oracle = QuantumCircuit(1)
oracle.z(0)  # good state = the qubit is in state |1>
q_operator = GroverOperator(oracle, state_preparation=a_operator)

# use default construction in QAE
q_operator = None

ae = AmplitudeEstimation(a_operator, q_operator)

Adicione a possibilidade de calcular os valores de expectativa do valor condicional em risco ( CVaR ).

Dado um observável diagonal H, geralmente correspondente à função objetiva de um problema de otimização, muitas vezes não estamos tão interessados em minimizar a energia média de nossas medições observadas. Nesse contexto, ficaremos satisfeitos se pelo menos algumas de nossas medições atingirem baixa energia. (Observe que esse não é o caso dos problemas de química).

Para isso, pode-se considerar o uso da melhor amostra observada como uma função de custo durante a otimização variacional. O problema aqui é que isso pode resultar em uma superfície de otimização não suave. Para resolver esse problema, podemos suavizar a superfície de otimização usando não apenas a melhor amostra observada, mas, em vez disso, a média de alguma fração das melhores amostras observadas. É exatamente isso que o estimador CVaR faz [1].

Deixe $\alpha$ ser um número real em $[0,1]$ que especifica a fração das melhores amostras observadas que são usadas para calcular a função objetiva. Observe que, se $\alpha = 1$ , CVaR é equivalente a um valor de expectativa padrão. Da mesma forma, se $\alpha = 0$ , então CVaR corresponde ao uso da melhor amostra observada. Valores intermediários de $\alpha$ interpolam entre essas duas funções objetivas.

A funcionalidade para usar o CVaR está incluída no fluxo do operador por meio de uma nova subclasse do OperatorStateFn chamada CVaRMeasurement. Esse novo objeto StateFn é instanciado da mesma forma que um OperatorMeasurement, com a exceção de que ele também aceita um parâmetro alfa e que automaticamente impõe que o atributo is_measurement seja True. Observe que não está claro o que um CVaRStateFn representaria se não fosse uma medida.

Exemplos:
```
qc = QuantumCircuit(1)
qc.h(0)
op = CVaRMeasurement(Z, alpha=0.5) @ CircuitStateFn(primitive=qc, coeff=1.0)
result = op.eval()
```
Da mesma forma, um operador correspondente a um valor de expectativa padrão pode ser convertido em uma expectativa CVaR usando o conversor CVaRExpectation.

Exemplos:
```
qc = QuantumCircuit(1)
qc.h(0)
op = ~StateFn(Z) @ CircuitStateFn(primitive=qc, coeff=1.0)
cvar_expecation = CVaRExpectation(alpha=0.1).convert(op)
result = cvar_expecation.eval()
```
Consulte [1] para obter mais detalhes sobre essa técnica e seu desempenho empírico.

Referências

[1] : Barkoutsos, P. K., Nannicini, G., Robert, A., Tavernelli, I., e Woerner, S.,

"Aprimoramento da otimização quântica variacional usando CVaR” arXiv:1907.04769
Nova interface Eigensolver para algoritmos do Eigensolver.
Uma interface para cálculo de estados excitados foi adicionada ao módulo de química. Agora é mais fácil para o usuário criar um cálculo geral de estados excitados. Esse cálculo é baseado em um Driver que fornece as informações relevantes sobre a molécula, um Transformation que fornece as informações sobre o mapeamento do problema em um qubit Hamiltoniano e, finalmente, um Solver. O Solver é a maneira específica pela qual o cálculo dos estados excitados é feito (o algoritmo). Essa estrutura segue a dos cálculos do estado fundamental. Os resultados são modificados para receber listas de valores de expectativa em vez de um único. Os sites QEOM e NumpyEigensolver estão adaptados à nova estrutura. Uma fábrica é introduzida para executar um eigensolver numpy com um filtro específico (para atingir estados de simetrias específicas).
Além dos fluxos de trabalho para a solução de problemas fermiônicos, foram adicionadas interfaces para o cálculo de estados bósnicos terrestres e excitados. Em particular, introduzimos uma interface completa para executar cálculos de estrutura vibrônica.
O OrbitalOptimizationVQE foi adicionado como novo solucionador de estado fundamental no módulo de química. Esse solucionador permite a otimização simultânea dos parâmetros variacionais e dos orbitais da molécula. O algoritmo é apresentado em Sokolov et al, The Journal of Chemical Physics 152 (12).
Um novo algoritmo foi adicionado: a superfície de energia potencial Born Openheimer para o cálculo da superfície de energia potencial ao longo de diferentes graus de liberdade da molécula. O algoritmo é chamado de BOPESSampler. Além disso, ele oferece funcionalidades de ajuste da superfície de energia potencial a uma função analítica de potenciais predefinidos.
Uma verificação de viabilidade da solução obtida foi adicionada a todos os otimizadores na pilha de otimização. Isso foi implementado com a adição de dois novos métodos ao site QuadraticProgram: * get_feasibility_info(self, x: Union[List[float], np.ndarray]) aceita uma matriz e retorna se essa solução é viável e uma lista de variáveis violadas (limites violados) e uma lista de restrições violadas. * is_feasible(self, x: Union[List[float], np.ndarray]) aceita uma matriz e retorna se essa solução é viável ou não.
Adicione versões baseadas em circuitos de FixedIncomeExpectedValue, EuropeanCallDelta, GaussianConditionalIndependenceModel e EuropeanCallExpectedValue a qiskit.finance.applications.
Estrutura de gradiente. qiskit.operators.gradients Dado um operador que representa um estado quântico resp. um valor de expectativa, a estrutura de gradiente permite a avaliação de gradientes, gradientes naturais, Hessianos, bem como a Informação Quântica de Fisher.

Suponha um estado quântico parametrizado |ψ(θ)〉 = V(θ)|ψ〉 com estado de entrada |ψ〉 e Ansatz parametrizado V(θ) e um Operador O(ω).

Gradientes: Queremos computar $d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω$ resp. $d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$ resp. $d⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ$ .

O último caso corresponde ao gradiente w.r.t. as probabilidades de amostragem de |ψ(θ). Esses gradientes podem ser calculados com diferentes métodos, ou seja, uma mudança de parâmetro, uma combinação linear de unidades e um método de diferença finita.

Exemplos:
```
x = Parameter('x')
ham = x * X
a = Parameter('a')

q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.p(params[0], q[0])
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)

value_dict = {x: 0.1, a: np.pi / 4}

ham_grad = Gradient(grad_method='param_shift').convert(operator=op, params=[x])
ham_grad.assign_parameters(value_dict).eval()

state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=[a])
state_grad.assign_parameters(value_dict).eval()

prob_grad = Gradient(grad_method='fin_diff').convert(operator=CircuitStateFn(primitive=qc, coeff=1.),
                                                     params=[a])
prob_grad.assign_parameters(value_dict).eval()
```
Hessianas: Queremos computar $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dω^2$ resp. $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ^2$ resp. $d^2⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθdω$ resp. $d^2⟨ψ(θ)|i〉⟨i|ψ(θ)〉/ dθ^2$ .

O último caso corresponde ao Hessiano w.r.t. as probabilidades de amostragem de |ψ(θ). Assim como os gradientes de primeira ordem, os Hessianos podem ser avaliados com diferentes métodos, ou seja, uma mudança de parâmetro, uma combinação linear de unitários e um método de diferença finita. Dada uma tupla de parâmetros, Hessian().convert(op, param_tuple) retorna o valor da derivada de segunda ordem. Se for fornecida uma lista de parâmetros, Hessian().convert(op, param_list) retornará o Hessiano completo para todos os parâmetros fornecidos, de acordo com a ordem de parâmetros fornecida.

QFI: A informação quântica de Fisher QFI é um tensor métrico que representa a capacidade de representação de um estado quântico parametrizado |ψ(θ)〉 = V(θ)|ψ〉 gerado por um estado de entrada |ψ〉 e um Ansatz parametrizado V(θ). As entradas do QFI para um estado puro são $[QFI]kl= Re[〈∂kψ|∂lψ〉−〈∂kψ|ψ〉〈ψ|∂lψ〉] * 4$ .

Assim como para os tipos de derivadas anteriores, o QFI pode ser calculado usando diferentes métodos: uma representação completa baseada em uma combinação linear da implementação de unidades, uma representação diagonal de blocos e uma representação diagonal baseada em um método de sobreposição.

Exemplos:
```
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.p(params[0], q[0])
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)

value_dict = {x: 0.1, a: np.pi / 4}
qfi = QFI('lin_comb_full').convert(operator=CircuitStateFn(primitive=qc, coeff=1.), params=[a])
qfi.assign_parameters(value_dict).eval()
```
A combinação do QFI e do gradiente leva a uma forma especial de gradiente, a saber

NaturalGradients: O gradiente natural é um método de gradiente especial que redimensiona um gradiente w.r.t. um parâmetro de estado com o inverso da Informação Quântica de Fisher (QFI) correspondente $QFI^-1 d⟨ψ(θ)|O(ω)|ψ(θ)〉/ dθ$ . Dessa forma, podemos escolher um gradiente, bem como um método QFI e um método de regularização que é usado junto com um solucionador de mínimos quadrados em vez da inversão exata do QFI:

Exemplos:
```
op = ~StateFn(ham) @ CircuitStateFn(primitive=qc, coeff=1.)
nat_grad = NaturalGradient(grad_method='lin_comb, qfi_method='lin_comb_full', \
                           regularization='ridge').convert(operator=op, params=params)
```
A estrutura de gradiente também é compatível com os otimizadores do site qiskit.aqua.components.optimizers. As classes derivadas vêm com uma função gradient_wrapper() que retorna o chamável correspondente.
Apresenta o site transformations para a transformação fermiônica e bosônica de uma instância de problema. Transforma o operador fermiônico em operador de qubit. A respectiva classe para a transformação é fermionic_transformation Introduz nos algoritmos ground_state_solvers para o cálculo das propriedades do estado fundamental. O cálculo pode ser feito usando um MinimumEigensolver ou AdaptVQE Introduz chemistry/results , onde o resultado do eigenstate_result e o resultado do electronic_structure_result também são usados para os algoritmos. Introduz o Minimum Eigensolver factories minimum_eigensolver_factories , onde os minimum eigensolvers específicos da química podem ser inicializados Introduz o orbital optimization vqe oovqe como um solucionador de estado fundamental para aplicações químicas
Novas classes de resultados do algoritmo:

Grover o método _run() retorna a classe GroverResult. AmplitudeEstimation o método _run() retorna a classe AmplitudeEstimationResult. IterativeAmplitudeEstimation o método _run() retorna a classe IterativeAmplitudeEstimationResult. MaximumLikelihoodAmplitudeEstimation o método _run() retorna a classe MaximumLikelihoodAmplitudeEstimationResult.

Todas as novas classes de resultados são compatíveis com as versões anteriores do dicionário de resultados.
Novas classes de resultados do Linear Solver:

HHL o método _run() retorna a classe HHLResult. NumPyLSsolver o método _run() retorna a classe NumPyLSsolverResult.

Todas as novas classes de resultados são compatíveis com as versões anteriores do dicionário de resultados.
MinimumEigenOptimizationResult agora expõe as propriedades: samples e eigensolver_result. O último é obtido do algoritmo subjacente usado pelo otimizador e é específico do algoritmo. RecursiveMinimumEigenOptimizer agora retorna uma instância da classe de resultado RecursiveMinimumEigenOptimizationResult que, por sua vez, pode conter resultados intermediários obtidos dos algoritmos subjacentes. A classe de resultado dedicada expõe as propriedades replacements e history que são específicas desse otimizador. A profundidade do histórico é gerenciada pelo parâmetro history do otimizador.
GroverOptimizer agora retorna uma instância de GroverOptimizationResult e essa classe de resultado expõe as propriedades operation_counts, n_input_qubits e n_output_qubits diretamente. Essas propriedades não estão mais disponíveis no dicionário raw_results .
SlsqpOptimizer agora retorna uma instância de SlsqpOptimizationResult e essa classe de resultado expõe propriedades adicionais específicas da implementação do SLSQP.
Suporte à passagem de objetos QuantumCircuit como circuitos geradores para o QuantumGenerator.
Remove a restrição a vetores de entrada reais em CircuitStateFn.from_vector. O método chama extensions.Initialize. O último suporta explicitamente (na API e na documentação) vetores de entrada complexos. Portanto, essa restrição parece desnecessária.
Simplificado AbelianGrouper usando um algoritmo de coloração de gráfico do retworkx. Ele é mais rápido do que o algoritmo de coloração baseado em numpy.
Permite chamar eval em objetos de função de estado sem nenhum argumento, o que retorna a representação VectorStateFn da função de estado. Esse comportamento é consistente com OperatorBase.eval, que retorna a representação MatrixOp , se nenhum argumento for passado.
Adiciona max_iterations à classe VQEAdapt para permitir a limitação do número máximo de iterações realizadas pelo algoritmo.
O cálculo de expectativa de VQE com o Aer qasm_simulator agora tem como padrão um cálculo que tem o comportamento esperado de ruído de disparo. O cálculo especial baseado em instantâneos do Aer, que é muito mais rápido, com o resultado ideal semelhante ao simulador de vetor de estado, ainda pode ser escolhido, mas, como antes, o Aqua 0.7 não é mais o padrão, mas pode ser escolhido.

Notas da Atualização

Extensão do otimizador clássico anterior Analytic Quantum Gradient Descent (AQGD) com o AQGD with Epochs. Agora, o AQGD executa a otimização de descida de gradiente com um termo de momento, gradientes analíticos e uma programação de comprimento de etapa personalizada adicionada para portas quânticas parametrizadas. Os gradientes são calculados "analiticamente" usando o circuito quântico ao avaliar a função objetiva.
O suporte obsoleto para a execução do qiskit-aqua com Python 3.5 foi removido. Para usar o qiskit-aqua >= 0.8.0, agora você precisará de pelo menos Python 3.6. Se você estiver usando Python 3.5, a última versão que funcionará é qiskit-aqua 0.7.x.
Adicionado o retworkx como uma nova dependência.

Notas de descontinuação

O argumento i_objective dos algoritmos de estimativa de amplitude foi renomeado para objective_qubits.
TransformationType
QubitMappingType

Preterir os tipos CircuitFactory e derivados. O CircuitFactory foi introduzido como classe temporária quando o QuantumCircuit não tinha alguns recursos necessários para aplicações no Aqua. Agora que o circuito tem todas as funcionalidades necessárias, a fábrica de circuitos pode ser removida. As substituições são mostradas na tabela a seguir.

Circuit factory class               | Replacement
------------------------------------+-----------------------------------------------
CircuitFactory                      | use QuantumCircuit
                                    |
UncertaintyModel                    | -
UnivariateDistribution              | -
MultivariateDistribution            | -
NormalDistribution                  | qiskit.circuit.library.NormalDistribution
MultivariateNormalDistribution      | qiskit.circuit.library.NormalDistribution
LogNormalDistribution               | qiskit.circuit.library.LogNormalDistribution
MultivariateLogNormalDistribution   | qiskit.circuit.library.LogNormalDistribution
UniformDistribution                 | qiskit.circuit.library.UniformDistribution
MultivariateUniformDistribution     | qiskit.circuit.library.UniformDistribution
UnivariateVariationalDistribution   | use parameterized QuantumCircuit
MultivariateVariationalDistribution | use parameterized QuantumCircuit
                                    |
UncertaintyProblem                  | -
UnivariateProblem                   | -
MultivariateProblem                 | -
UnivariatePiecewiseLinearObjective  | qiskit.circuit.library.LinearAmplitudeFunction

As classes de conversão de ising qiskit.optimization.converters.QuadraticProgramToIsing e qiskit.optimization.converters.IsingToQuadraticProgram foram preteridas e serão removidas em uma versão futura. Em vez disso, os métodos qiskit.optimization.QuadraticProgram to_ising() e from_ising() devem ser usados.
Descontinuar o WeightedSumOperator que foi portado para a biblioteca de circuitos como WeightedAdder em qiskit.circuit.library.
Core Hamiltonian está obsoleta em favor da classe FermionicTransformation Chemistry Operator está obsoleta em favor da classe tranformations minimum_eigen_solvers/vqe_adapt também está obsoleta e foi movida como uma implementação da interface ground_state_solver applications/molecular_ground_state_energy está obsoleta em favor de ground_state_solver
Optimizer.SupportLevel enum aninhado é substituído por OptimizerSupportLevel e Optimizer.SupportLevel foi removido. Use, por exemplo, OptimizerSupportLevel.required em vez de Optimizer.SupportLevel.required.
Descontinuar o UnivariateVariationalDistribution e o MultivariateVariationalDistribution como entrada para o QuantumGenerator. Em vez disso, podem ser usados objetos QuantumCircuit simples.
As opções ignoradas fast e use_nx de AbelianGrouper.group_subops serão removidas na versão futura.
A classe do otimizador GSLS descontinuou o parâmetro __init__ max_iter em favor de maxiter. A classe do otimizador SPSA descontinuou o parâmetro __init__ max_trials em favor de maxiter. a função optimize_svm descontinuou o parâmetro max_iters em favor de maxiter. A classe ADMMParameters descontinuou o parâmetro __init__ max_iter em favor de maxiter.

Correções de bugs

A lista de excitações do UCCSD, que inclui excitações simples e duplas, não estava sendo gerada corretamente quando um espaço ativo era explicitamente fornecido ao UCSSD por meio dos parâmetros active_(un)occupied.
Para os algoritmos de estimativa de amplitude, definimos o número de consultas ao oráculo como o número de vezes que o operador Q/operador Grover é aplicado. Isso inclui o número de disparos. Esse fator foi incluído no MLAE e no IQAE, mas não foi incluído no QAE "padrão".
Corrija o CircuitSampler.convert, para que a propriedade is_measurement seja propagada para o StateFns convertido.
Correção do cálculo duplo de coeficientes em :meth`~qiskit.aqua.operators.VectorStateFn.to_circuit_op`.
Ao chamar PauliTrotterEvolution.convert em um operador que inclui um termo que é um múltiplo escalar da identidade, foi gerado um circuito incorreto, que ignorou o coeficiente escalar. Essa correção inclui o efeito do coeficiente na propriedade global_phase do circuito.
Fazer com que o ListOp.num_qubits verifique se todos os operadores da lista têm o mesmo num_qubits Anteriormente, o número de qubits no primeiro operador do ListOp era retornado. Com essa alteração, é feita uma verificação adicional de que todos os outros operadores também têm o mesmo número de qubits.
Faça com que o PauliOp.exp_i() gere a matriz correta com as seguintes alterações. 1) Havia anteriormente um erro na fase de um fator de 2. 2) A fase global foi ignorada ao converter o circuito em uma matriz. Agora usamos qiskit.quantum_info.Operator, que geralmente é útil para converter um circuito em uma matriz unitária, quando possível.
Corrige a detecção de ciclicidade, conforme relatado como um erro no https://github.com/qiskit-community/qiskit-aqua/issues/1184.

IBM 0.11.0

Notas da Atualização

O suporte obsoleto para a execução do qiskit-ibmq-provider com Python 3.5 foi removido. Para usar o qiskit-ibmq-provider >= 0.11.0, agora você precisará de pelo menos Python 3.6. Se você estiver usando Python 3.5, a última versão que funcionará é qiskit-ibmq-provider 0.10.x.
Antes desta versão, websockets 7.0 era usado para Python 3.6. Com esta versão, o site websockets 8.0 ou superior é necessário para todas as versões do Python. Os requisitos do pacote foram atualizados para refletir isso.

Esta página foi útil?

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