Notas de versão do Qiskit 0.15

0.15.0

Terra 0.12.0

Prelúdio

A versão 0.12.0 inclui vários novos recursos e correções de bugs. A maior mudança desta versão é a adição de suporte para pulsos paramétricos ao site OpenPulse. Esses são comandos de pulso que usam parâmetros em vez de pontos de amostragem para descrever um pulso. 0.12.0 é também a primeira versão a incluir suporte para Python 3.8. Isso também marca o início da descontinuidade do suporte a Python 3.5, que será removido quando a comunidade upstream deixar de oferecer suporte a ele.

Novos Recurso

O passe qiskit.transpiler.passes.CSPLayout foi ampliado com dois novos parâmetros: call_limit e time_limit. Essas opções permitem limitar o tempo de execução do passe. A opção call_limit limita o número de vezes que a função recursiva no solucionador de backtracking pode ser chamada. Da mesma forma, time_limit limita o tempo (em segundos) de execução do solucionador. Os padrões são 1000 calls e 10 seconds, respectivamente.

qiskit.pulse.Acquire pode agora ser aplicado a um único qubit. Isso torna a programação de pulsos mais consistente e mais fácil de entender, pois agora todas as operações se aplicam a um único canal. Por exemplo:

acquire = Acquire(duration=10)
schedule = Schedule()
schedule.insert(60, acquire(AcquireChannel(0), MemorySlot(0), RegisterSlot(0)))
schedule.insert(60, acquire(AcquireChannel(1), MemorySlot(1), RegisterSlot(1)))

Um novo método qiskit.transpiler.CouplingMap.draw() foi adicionado ao qiskit.transpiler.CouplingMap para gerar uma imagem graphviz a partir do gráfico do mapa de acoplamento. Por exemplo:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap(
    [[0, 1], [1, 0], [1, 2], [1, 3], [2, 1], [3, 1], [3, 4], [4, 3]])
coupling_map.draw()
```
Pulsos paramétricos foram adicionados ao site OpenPulse. Esses são comandos de pulso que são parametrizados e compreendidos pelo backend. Formas de pulso arbitrárias ainda são compatíveis com o comando SamplePulse. As novas classes de pulso suportadas são:
- qiskit.pulse.ConstantPulse
- qiskit.pulse.Drag
- qiskit.pulse.Gaussian
- qiskit.pulse.GaussianSquare
Eles podem ser usados como qualquer outro comando do Pulse. Um exemplo:
```
from qiskit.pulse import (Schedule, Gaussian, Drag, ConstantPulse,
                          GaussianSquare)

sched = Schedule(name='parametric_demo')
sched += Gaussian(duration=25, sigma=4, amp=0.5j)(DriveChannel(0))
sched += Drag(duration=25, amp=0.1, sigma=5, beta=4)(DriveChannel(1))
sched += ConstantPulse(duration=25, amp=0.3+0.1j)(DriveChannel(1))
sched += GaussianSquare(duration=1500, amp=0.2, sigma=8,
                        width=140)(MeasureChannel(0)) << sched.duration
```
O cronograma resultante será semelhante a um cronograma do SamplePulse criado com o uso do qiskit.pulse.pulse_lib, mas a amostragem da forma de onda será realizada pelo backend. O método qiskit.pulse.Schedule.draw() ainda pode ser usado como de costume. No entanto, o comando será convertido em um SamplePulse com o método qiskit.pulse.ParametricPulse.get_sample_pulse() , de modo que o pulso mostrado pode não amostrar a função contínua da mesma forma que o backend.

Esse recurso pode ser usado para criar programas de pulso para qualquer backend, mas os pulsos serão convertidos em objetos SamplePulse se o backend não for compatível com pulsos paramétricos. Os backends que os suportam terão o novo atributo a seguir:
```
backend.configuration().parametric_pulses: List[str]
# e.g. ['gaussian', 'drag', 'constant']
```
Observe que o backend não precisa ser compatível com todos os pulsos paramétricos definidos no Qiskit.

Quando o backend oferece suporte a pulsos paramétricos e a programação de pulsos é criada com eles, o Qobj montado é significativamente menor. O tamanho de um PulseQobj construído inteiramente com pulsos paramétricos depende apenas do número de instruções, enquanto o tamanho de um PulseQobj construído de outra forma crescerá com a duração das instruções (já que cada amostra deve ser especificada com um valor).

Adição de funções utilitárias, qiskit.scheduler.measure() e qiskit.scheduler.measure_all() ao módulo qiskit.scheduler. Essas funções retornam um objeto qiskit.pulse.Schedule objeto que mede os qubits usando OpenPulse. Por exemplo:

from qiskit.scheduler import measure, measure_all

measure_q0_schedule = measure(qubits=[0], backend=backend)
measure_all_schedule = measure_all(backend)
measure_custom_schedule = measure(qubits=[0],
                                  inst_map=backend.defaults().instruction_schedule_map,
                                  meas_map=[[0]],
                                  qubit_mem_slots={0: 1})

Pulso qiskit.pulse.Schedule agora têm representações melhores que, para programações simples, devem ser expressões Python válidas.
Os qiskit.circuit.QuantumCircuit métodos qiskit.circuit.QuantumCircuit.measure_active(), qiskit.circuit.QuantumCircuit.measure_all(), e qiskit.circuit.QuantumCircuit.remove_final_measurements() agora têm um kwarg adicional inplace. Quando inplace estiver definido como False , a função retornará uma cópia modificada do circuito. Isso é diferente do comportamento padrão, que modificará o objeto do circuito no local e não retornará nada.
Vários novos métodos de construção foram adicionados à classe qiskit.transpiler.CouplingMap para construir objetos com gráficos básicos de acoplamento de qubit. Os novos métodos do construtor são:
Por exemplo, para usar os novos construtores para obter um mapa de acoplamento de 5 qubits conectados em uma cadeia linear, agora é possível executar:
```
from qiskit.transpiler import CouplingMap

coupling_map = CouplingMap.from_line(5)
coupling_map.draw()
```
Introduziu um novo passe qiskit.transpiler.passes.CrosstalkAdaptiveSchedule. Essa passagem visa a reduzir o impacto do ruído de diafonia em um programa. Ele usa dados de caracterização de diafonia do backend para programar portas. Quando um par de portas tem alta interferência, elas são serializadas usando uma barreira. A serialização ingênua é prejudicial porque incorre em erros de decoerência. Portanto, essa passagem usa uma abordagem de otimização SMT para calcular um cronograma que minimiza o impacto da diafonia e dos erros de decoerência.

A passagem recebe como entrada um circuito que já foi transpilado para o backend, ou seja, o circuito é expresso em termos de qubits físicos e as portas de troca foram inseridas e decompostas em CNOTs, se necessário. Usando esse circuito e os dados de caracterização de diafonia, uma otimização do Z3 é usada para construir um novo circuito programado como saída.

Para usar a passagem em um circuito:
```
dag = circuit_to_dag(circ)
pass_ = CrosstalkAdaptiveSchedule(backend_prop, crosstalk_prop)
scheduled_dag = pass_.run(dag)
scheduled_circ = dag_to_circuit(scheduled_dag)
```
backend_prop é um objeto qiskit.providers.models.BackendProperties para o backend de destino. crosstalk_prop é um dit que especifica as taxas de erro condicional. Para duas portas g1 e g2, crosstalk_prop[g1][g2] especifica a taxa de erro condicional de g1 quando g1 e g2 são executados simultaneamente. Um método para gerar crosstalk_prop será adicionado em uma versão futura do qiskit-ignis. Até lá, você terá que conhecer as propriedades de diafonia do seu dispositivo ou escrever manualmente seus próprios experimentos de caracterização de dispositivos.
No gerenciador de passagens predefinidas para o nível de otimização 1, qiskit.transpiler.preset_passmanagers.level_1_pass_manager() se a qiskit.transpiler.passes.TrivialLayout não for uma combinação perfeita para um circuito específico, então qiskit.transpiler.passes.DenseLayout será usada a passagem de layout.
Adicionado um novo método abstrato qiskit.quantum_info.Operator.dot() à classe abstrata BaseOperator , para que ele seja incluído em todas as implementações dessa classe abstrata, inclusive qiskit.quantum_info.Operator e QuantumChannel (por exemplo, qiskit.quantum_info.Choi). Esse método retorna o operador de multiplicação correto a.dot(b) $= a \cdot b$ . Isso é equivalente a chamar o método operator qiskit.quantum_info.Operator.compose() com o kwarg front definido como True.
Adicionado qiskit.quantum_info.average_gate_fidelity() e qiskit.quantum_info.gate_error() ao módulo qiskit.quantum_info para trabalhar com qiskit.quantum_info.Operator e QuantumChannel (por exemplo, qiskit.quantum_info.Choi) objetos.

Adicionada a função qiskit.quantum_info.partial_trace() à função qiskit.quantum_info que funciona com qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix classes de estado quântico. Por exemplo:

from qiskit.quantum_info.states import Statevector
from qiskit.quantum_info.states import DensityMatrix
from qiskit.quantum_info.states import partial_trace

psi = Statevector.from_label('10+')
partial_trace(psi, [0, 1])
rho = DensityMatrix.from_label('10+')
partial_trace(rho, [0, 1])

Quando qiskit.circuit.QuantumCircuit.draw() ou qiskit.visualization.circuit_drawer() é chamado com o kwarg with_layout definido como True (o padrão), a visualização de saída agora exibirá os qubits físicos como inteiros para distingui-los claramente dos qubits virtuais.

Por exemplo:
```
from qiskit import QuantumCircuit
from qiskit import transpile
from qiskit.test.mock import FakeVigo

qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
transpiled_qc = transpile(qc, FakeVigo())
transpiled_qc.draw(output='mpl')
```
Foram adicionadas novas funções de medida de estado ao módulo qiskit.quantum_info módulo: qiskit.quantum_info.entropy(), qiskit.quantum_info.mutual_information(), qiskit.quantum_info.concurrence(), e qiskit.quantum_info.entanglement_of_formation(). Essas funções funcionam com as funções qiskit.quantum_info.Statevector e qiskit.quantum_info.DensityMatrix classes.
Os métodos de decomposição para portas de um único qubit em qiskit.quantum_info.synthesis.one_qubit_decompose.OneQubitEulerDecomposer foram ampliados para incluir agora também a base 'ZXZ' , caracterizada por três rotações em torno do eixo Z, X, Z. Isso significa que um operador 2x2 geral pode ser decomposto nas seguintes bases: U3, U1X, ZYZ, ZXZ, XYX, ZXZ.

Problemas Conhecidos

Executar funções que usam qiskit.tools.parallel_map() (por exemplo, qiskit.execute.execute(), qiskit.compiler.transpile(), e qiskit.transpiler.PassManager.run()) podem não funcionar quando chamadas de um script executado fora de um bloco if __name__ == '__main__': ao usar Python 3.8 em MacOS. Outros ambientes não são afetados por esse problema. Isso se deve a mudanças na forma como os processos paralelos são iniciados por Python 3.8 em MacOS. Se RuntimeError ou AttributeError forem acionados por scripts que estejam chamando diretamente parallel_map() ou ao chamar uma função que o utilize internamente com Python 3.8 em MacOS, a incorporação das chamadas de script em if __name__ == '__main__': deverá solucionar o problema. Por exemplo:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

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], BasicAer.get_backend('qasm_simulator'))

Deve ser mudada para:

from qiskit import QuantumCircuit, QiskitError
from qiskit import execute, BasicAer

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], BasicAer.get_backend('qasm_simulator'))

if __name__ == '__main__':
    main()

se forem encontrados erros com Python 3.8 em MacOS.

Notas da Atualização

O valor do parâmetro rep_time do objeto de configuração do backend do Pulse agora está em unidades de segundos, não em microssegundos. Na primeira vez em que um objeto PulseBackendConfiguration for inicializado, ele emitirá um único aviso ao usuário para indicar isso.
O argumento rep_time para qiskit.compiler.assemble() agora recebe um valor em unidades de segundos, não em microssegundos. Isso foi feito para produzir as unidades com todo o resto no pulso. Se você estava passando um valor para rep_time , certifique-se de atualizar o valor para levar em conta essa alteração.
O valor da propriedade base_gate dos objetos qiskit.circuit.ControlledGate foi alterado da classe do portão de base para uma instância da classe do portão de base.

A propriedade base_gate_name de qiskit.circuit.ControlledGate foi removida; você pode obter o nome do gate de base acessando base_gate.name no objeto. Por exemplo:

from qiskit import QuantumCircuit
from qiskit.extensions import HGate

qc = QuantumCircuit(3)
cch_gate = HGate().control(2)
base_gate_name = cch_gate.base_gate.name

Alterado qiskit.quantum_info.Operator métodos mágicos para que __mul__ (que é executado pela operação de multiplicação do python, se o lado esquerdo da operação tiver sido definido) implemente a multiplicação da matriz direita (ou seja qiskit.quantum_info.Operator.dot()), e __rmul__ (que é executado pela operação de multiplicação do python a partir do lado direito da operação se o lado esquerdo não tiver __mul__ definido) implementa a multiplicação escalar (ou seja, qiskit.quantum_info.Operator.multiply()). Anteriormente, ambos os métodos implementavam a multiplicação escalar.
O segundo argumento da função qiskit.quantum_info.process_fidelity()target , agora é opcional. Se uma unidade de destino não for especificada, a fidelidade do processo do canal de entrada com o operador de identidade será retornada.
qiskit.compiler.assemble() agora respeitará o valor max_shots configurado para um backend. Se for especificado um valor para o kwarg shots que exceda os disparos máximos definidos na configuração de back-end, a função agora gerará uma exceção QiskitError . Além disso, se nenhum argumento de disparo for fornecido, o valor padrão será 1024 (o comportamento anterior) ou max_shots do backend, o que for menor.

Notas de descontinuação

Os métodos para adicionar portas a um qiskit.circuit.QuantumCircuit com argumentos de palavra-chave abreviados (por exemplo, ctl, tgt) tiveram seus argumentos de palavra-chave renomeados para serem mais descritivos (por exemplo, control_qubit, target_qubit). Os nomes antigos foram descontinuados. Uma tabela com as assinaturas de chamada antigas e novas para os métodos do site QuantumCircuit está incluída abaixo.

Tipo de instrução	Assinatura anterior	Nova Assinatura
`qiskit.extensions.HGate`	`qc.h(q)`	`qc.h(qubit)`
`qiskit.extensions.CHGate`	`qc.ch(ctl, tgt)`	`qc.ch((control_qubit, target_qubit))`
`qiskit.extensions.IdGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.iden(q)`	`qc.iden(qubit)`
`qiskit.extensions.RGate`	`qc.r(theta, phi, q)`	`qc.r(theta, phi, qubit)`
`qiskit.extensions.RXGate`	`qc.rx(theta, q)`	`qc.rx(theta, qubit)`
`qiskit.extensions.CrxGate`	`qc.crx(theta, ctl, tgt)`	`qc.crx(theta, control_qubit, target_qubit)`
`qiskit.extensions.RYGate`	`qc.ry(theta, q)`	`qc.ry(theta, qubit)`
`qiskit.extensions.CryGate`	`qc.cry(theta, ctl, tgt)`	`qc.cry(theta, control_qubit, target_qubit)`
`qiskit.extensions.RZGate`	`qc.rz(phi, q)`	`qc.rz(phi, qubit)`
`qiskit.extensions.CrzGate`	`qc.crz(theta, ctl, tgt)`	`qc.crz(theta, control_qubit, target_qubit)`
`qiskit.extensions.SGate`	`qc.s(q)`	`qc.s(qubit)`
`qiskit.extensions.SdgGate`	`qc.sdg(q)`	`qc.sdg(qubit)`
`qiskit.extensions.FredkinGate`	`qc.cswap(ctl, tgt1, tgt2)`	`qc.cswap(control_qubit, target_qubit1, target_qubit2)`
`qiskit.extensions.TGate`	`qc.t(q)`	`qc.t(qubit)`
`qiskit.extensions.TdgGate`	`qc.tdg(q)`	`qc.tdg(qubit)`
`qiskit.extensions.U1Gate`	`qc.u1(theta, q)`	`qc.u1(theta, qubit)`
`qiskit.extensions.Cu1Gate`	`qc.cu1(theta, ctl, tgt)`	`qc.cu1(theta, control_qubit, target_qubit)`
`qiskit.extensions.U2Gate`	`qc.u2(phi, lam, q)`	`qc.u2(phi, lam, qubit)`
`qiskit.extensions.U3Gate`	`qc.u3(theta, phi, lam, q)`	`qc.u3(theta, phi, lam, qubit)`
`qiskit.extensions.Cu3Gate`	`qc.cu3(theta, phi, lam, ctl, tgt)`	`qc.cu3(theta, phi, lam, control_qubit, target_qubit)`
`qiskit.extensions.XGate`	`qc.x(q)`	`qc.x(qubit)`
`qiskit.extensions.CnotGate`	`qc.cx(ctl, tgt)`	`qc.cx(control_qubit, target_qubit)`
`qiskit.extensions.ToffoliGate`	`qc.ccx(ctl1, ctl2, tgt)`	`qc.ccx(control_qubit1, control_qubit2, target_qubit)`
`qiskit.extensions.YGate`	`qc.y(q)`	`qc.y(qubit)`
`qiskit.extensions.CyGate`	`qc.cy(ctl, tgt)`	`qc.cy(control_qubit, target_qubit)`
`qiskit.extensions.ZGate`	`qc.z(q)`	`qc.z(qubit)`
`qiskit.extensions.CzGate`	`qc.cz(ctl, tgt)`	`qc.cz(control_qubit, target_qubit)`

A execução do qiskit.pulse.Acquire em vários qubits foi preterida e será removida em uma versão futura. Além disso, os parâmetros qiskit.pulse.AcquireInstruction mem_slots e reg_slots foram preteridos. Em vez disso, reg_slot e mem_slot devem ser usados.
O atributo da classe qiskit.providers.models.PulseDefaults da classe circuit_instruction_map foi preterido e será removido em uma versão futura. Em vez disso, você deve usar o novo atributo instruction_schedule_map. Isso foi feito para corresponder ao tipo do valor do atributo, que é um InstructionScheduleMap.

O comando qiskit.pulse.PersistentValue está obsoleto e será removido em uma versão futura. Funcionalidade semelhante pode ser obtida com o comando qiskit.pulse.ConstantPulse (um dos novos pulsos paramétricos). Compare o seguinte:

from qiskit.pulse import Schedule, PersistentValue, ConstantPulse, \
                         DriveChannel

# deprecated implementation
sched_w_pv = Schedule()
sched_w_pv += PersistentValue(value=0.5)(DriveChannel(0))
sched_w_pv += PersistentValue(value=0)(DriveChannel(0)) << 10

# preferred implementation
sched_w_const = Schedule()
sched_w_const += ConstantPulse(duration=10, amp=0.5)(DriveChannel(0))

Python 3.5 no qiskit-terra está obsoleto. O suporte será removido na primeira versão após a data de fim de vida da comunidade Python upstream para a versão, que é 13/09/2020.
O kwarg require_cptp da função qiskit.quantum_info.process_fidelity() foi preterido e será removido em uma versão futura. Ele é substituído por dois kwargs separados: require_cp e require_tp.
Configuração do parâmetro scale para qiskit.circuit.QuantumCircuit.draw() e qiskit.visualization.circuit_drawer() como o primeiro argumento posicional está obsoleta e será removida em uma versão futura. Em vez disso, você deve usar scale como argumento de palavra-chave.

O módulo qiskit.tools.qi.qi está obsoleto e será removido em uma versão futura. As funções legadas no módulo foram todas substituídas por funções e classes no módulo qiskit.quantum_info módulo. Uma tabela com as funções obsoletas e sua substituição está abaixo:

Descontinuado	Substituição
`qiskit.tools.partial_trace()`	`qiskit.quantum_info.partial_trace()`
`qiskit.tools.choi_to_pauli()`	`qiskit.quantum_info.Choi` e `quantum_info.PTM`
`qiskit.tools.chop()`	`numpy.round`
`qiskit.tools.qi.qi.outer`	`numpy.outer`
`qiskit.tools.concurrence()`	`qiskit.quantum_info.concurrence()`
`qiskit.tools.shannon_entropy()`	`qiskit.quantum_info.shannon_entropy()`
`qiskit.tools.entropy()`	`qiskit.quantum_info.entropy()`
`qiskit.tools.mutual_information()`	`qiskit.quantum_info.mutual_information()`
`qiskit.tools.entanglement_of_formation()`	`qiskit.quantum_info.entanglement_of_formation()`
`qiskit.tools.is_pos_def()`	`quantum_info.operators.predicates.is_positive_semidefinite_matrix`

O módulo qiskit.quantum_info.states.states está obsoleto e será removido em uma versão futura. As funções legadas no módulo foram todas substituídas por funções e classes no módulo qiskit.quantum_info módulo.

Descontinuado
Substituição
qiskit.quantum_info.states.states.basis_state qiskit.quantum_info.Statevector.from_label()
qiskit.quantum_info.states.states.projector qiskit.quantum_info.DensityMatrix
O parâmetro scaling do método draw() para os objetos Schedule e Pulse foi preterido e será removido em uma versão futura. Em vez disso, o novo parâmetro scale deve ser usado. Isso foi feito para que houvesse um argumento consistente entre os desenhos de pulso e de circuito. Por exemplo:
```
#The consistency in parameters is seen below
#For circuits
circuit = QuantumCircuit()
circuit.draw(scale=0.2)
#For pulses
pulse = SamplePulse()
pulse.draw(scale=0.2)
#For schedules
schedule = Schedule()
schedule.draw(scale=0.2)
```

Descontinuado	Substituição
`qiskit.quantum_info.states.states.basis_state`	`qiskit.quantum_info.Statevector.from_label()`
`qiskit.quantum_info.states.states.projector`	`qiskit.quantum_info.DensityMatrix`

Correções de bugs

Anteriormente, chamar qiskit.circuit.QuantumCircuit.bind_parameters() antes de decompor um circuito fazia com que os valores vinculados não fossem substituídos corretamente nas portas decompostas. Isso foi resolvido de forma que a ligação e a decomposição podem ocorrer em qualquer ordem. Corrige o problema nº 2482 e o problema nº 3509
O Collect2qBlocks pass não havia considerado as condições clássicas ao determinar a inclusão de um portão em um bloco existente. Em alguns casos, isso resultou na perda de condições clássicas ao transpilar com optimization_level=3. Isso foi resolvido para que as portas condicionadas classicamente nunca sejam incluídas em um bloco. Corrige o problema nº 3215
Todos os tipos de saída para as gavetas do circuito em qiskit.circuit.QuantumCircuit.draw() e qiskit.visualization.circuit_drawer() têm suporte fixo e/ou aprimorado para portas personalizadas controladas por desenho. Corrige os problemas nº 3546, nº 3763 e nº 3764
Foram adicionados explicações e exemplos à documentação dos qiskit.circuit.QuantumCircuit métodos para adicionar gates: qiskit.circuit.QuantumCircuit.ccx(), qiskit.circuit.QuantumCircuit.ch(), qiskit.circuit.QuantumCircuit.crz(), qiskit.circuit.QuantumCircuit.cswap(), qiskit.circuit.QuantumCircuit.cu1(), qiskit.circuit.QuantumCircuit.cu3(), qiskit.circuit.QuantumCircuit.cx(), qiskit.circuit.QuantumCircuit.cy(), qiskit.circuit.QuantumCircuit.cz(), qiskit.circuit.QuantumCircuit.h(), qiskit.circuit.QuantumCircuit.iden(), qiskit.circuit.QuantumCircuit.rx(), qiskit.circuit.QuantumCircuit.ry(), qiskit.circuit.QuantumCircuit.rz(), qiskit.circuit.QuantumCircuit.s(), qiskit.circuit.QuantumCircuit.sdg(), qiskit.circuit.QuantumCircuit.swap(), qiskit.circuit.QuantumCircuit.t(), qiskit.circuit.QuantumCircuit.tdg(), qiskit.circuit.QuantumCircuit.u1(), qiskit.circuit.QuantumCircuit.u2(), qiskit.circuit.QuantumCircuit.u3(), qiskit.circuit.QuantumCircuit.x(), qiskit.circuit.QuantumCircuit.y(), qiskit.circuit.QuantumCircuit.z(). Corrige o problema nº 3400
Correções para o manuseio do parâmetro de número complexo na visualização do circuito. Corrige o problema nº 3640

Outras observações

Os passes do transpilador no diretório qiskit.transpiler.passes foram organizados em subdiretórios para melhor categorizá-los por funcionalidade. Todos eles ainda podem ser acessados no espaço de nome qiskit.transpiler.passes .

Aer 0.4.0

Incluído

Adicionado o site NoiseModel.from_backend para criar um modelo básico de ruído de dispositivo para um back-end do IBMQ (nº 569)

Foram adicionados métodos de simulação habilitados para várias GPUs aos sites QasmSimulator, StatevectorSimulator e UnitarySimulator. O simulador qasm tem a versão gpu da matriz de densidade e dos métodos de vetor de estado e pode ser acessado usando "method": "density_matrix_gpu" ou "method": "statevector_gpu" em backend_options. O método gpu do simulador de vetor de estado pode ser acessado usando "method": "statevector_gpu". O método de GPU do simulador unitário pode ser acessado usando "method": "unitary_gpu". Esses back-ends usam CUDA e exigem uma GPU NVidia.(#544)

Adição do backend PulseSimulator (nº 542)

Adição das classes PulseSystemModel e HamiltonianModel para representar modelos a serem usados em PulseSimulator (nº 496, nº 493)

Adicionado duffing_model_generators para gerar objetos PulseSystemModel a partir de uma lista de parâmetros (#516)

Migração do solucionador de função ODE para C++ (nº 442, nº 350)

Adição de testes de simulador de pulso de alto nível (#379)

Sinalizador CMake BLAS_LIB_PATH para definir o caminho para procurar a biblioteca BLAS (#543)

Alterado

Alterou a estrutura do diretório src para organizar o código-fonte do simulador. Os cabeçalhos do controlador do simulador foram movidos para src/controllers e os cabeçalhos do estado do método do simulador estão em src/simulators (nº 544)

Mudança do local de várias funções (#568): * Movido o conteúdo de qiskit.provider.aer.noise.errors para o módulo qiskit.providers.noise * Movido o conteúdo de qiskit.provider.aer.noise.utils para o módulo qiskit.provider.aer.utils .

Otimização ativada para agregar portas consecutivas em um circuito (fusão) por padrão (nº 579).

Descontinuado

Funções obsoletas do utils.qobj_utils (#568)

Depreciado qiskit.providers.aer.noise.device.basic_device_noise_model. Ele foi substituído pelo método NoiseModel.from_backend (nº 569)

Removido

Removidos os métodos NoiseModel.as_dict, QuantumError.as_dict, ReadoutError.as_dict e QuantumError.kron que foram preteridos em 0.3 (nº 568).

Ignis 0.2

Nenhuma mudança

Aqua 0.6

Nenhuma mudança

IBM 0.4.6

Incluído

Vários novos métodos foram adicionados ao site IBMQBackend:
- wait_for_final_state() blocos até que o trabalho seja concluído. Ele usa uma função de retorno de chamada que será invocada após cada consulta para fornecer feedback.
- active_jobs() retorna os trabalhos enviados a um backend que estão atualmente em um status inacabado.
- job_limit() retorna o limite de trabalho para um backend.
- remaining_jobs_count() retorna o número de trabalhos que você pode enviar ao backend antes que o limite de trabalhos seja atingido.
QueueInfo agora tem um novo método format() que retorna uma string formatada das informações da fila.
IBMQJob agora tem três novos métodos: done(), running(), e cancelled() que são usados para indicar o status do trabalho.
qiskit.providers.ibmq.ibmqbackend.IBMQBackend.run() agora aceita um parâmetro opcional job_tags. Se especificado, as job_tags são atribuídas ao trabalho, que pode ser usado posteriormente como um filtro em qiskit.providers.ibmq.ibmqbackend.IBMQBackend.jobs().
IBMQJobManager agora tem um novo método retrieve_job_set() que permite que você recupere um conjunto de tarefas enviado anteriormente usando o ID do conjunto de tarefas.

Alterado

A hierarquia do Exception foi refinada com classes mais especializadas. No entanto, você pode continuar a capturar suas exceções principais (como IBMQAccountError). Além disso, a classe de exceção IBMQApiUrlError foi substituída por IBMQAccountCredentialsInvalidUrl e IBMQAccountCredentialsInvalidToken.

Descontinuado

O uso de URLs de proxy sem um protocolo (por exemplo, http://) está obsoleto devido às recentes alterações no site Python.

Esta página foi útil?

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