Notas de versão do Qiskit SDK 1.2

1.2.4

Prelúdio

O Qiskit 1.2.4 é uma versão de correção que corrige um problema do QPY introduzido na versão de correção de bugs 1.2.3. Em 1.2.3, era gerado um erro ao carregar um arquivo QPY gerado com uma versão do symengine diferente da versão instalada durante o carregamento.

Correções de bugs

Foi corrigido um problema introduzido na versão de correção de bugs 1.2.3 , que causava uma exceção com a mensagem de erro "Qiskit doesn't support loading a symengine payload generated with symengine >= 1.0 " a ser levantada sempre que se carregava um arquivo QPY que foi gerado com uma versão de symengine diferente da versão instalada ao carregar. Esse problema só pode ocorrer em 1.2.3.

1.2.3

Prelúdio

O Qiskit 1.2.3 é uma versão de correção que corrige um problema no QPY que pode fazer com que os arquivos gerados por um ambiente Python não sejam carregados em um ambiente Python diferente, apesar de o formato supostamente ser transferível. Isso está relacionado a diferenças na versão da biblioteca symengine, contra a qual o QPY deveria ter se protegido.

Problemas Conhecidos

As versões do Qiskit anteriores a 1.2.4 não poderão carregar arquivos QPY despejados usando qpy.dump()mesmo com version configurado adequadamente, se:
- há objetos não vinculados ParameterExpression no arquivo QPY,
- o sinalizador use_symengine=True foi definido (que é o padrão no Qiskit >= 1.0.0 ) em qpy.dump()e
- a versão do symengine instalada nos ambientes de geração e carregamento não está na mesma versão secundária.
Isso se aplica independentemente da versão do Qiskit usada na geração (pelo menos até o Qiskit 1.2.4 inclusive).

Se você quiser maximizar a compatibilidade com as versões do Qiskit < 1.2.3, you should set use_symengine=False. Versions of Qiskit > = 1.2.3 não deve exigir isso.
Os arquivos QPY da série Qiskit 0.45 podem, em um conjunto de circunstâncias muito específico e improvável, deixar de ser carregados com qualquer versão mais recente do Qiskit, incluindo o Qiskit 1.2.4. Os critérios são:
- o QuantumCircuit ou ScheduleBlock a ser descartado continha objetos ParameterExpression objetos,
- a versão instalada do symengine estava na série 0.9 (que foi a versão mais recente durante a janela de suporte do Qiskit 0.45 ), e
- o sinalizador use_symengine=True foi definido (o que não era o padrão).
As versões posteriores do Qiskit usadas durante a geração não são afetadas, pois exigiam versões mais recentes do que symengine 0.9.

Nesse caso, você pode recuperar o arquivo QPY recarregando-o em um ambiente com o Qiskit 0.45.3 e symengine 0.9.2 instalados. Em seguida, use qpy.dump() com use_symengine=False para reexportar o arquivo. Isso poderá ser lido por qualquer versão mais recente do Qiskit.

Notas da Atualização

As versões compatíveis do symengine foram limitadas preventivamente a < 0.14.0 (que deverá ser a próxima versão secundária, a partir desta versão do Qiskit). Isso foi feito para proteger contra uma possível incompatibilidade em qpy ao serializar objetos ParameterExpression objetos. A serialização usada no formato QPY versões 10, 11 e 12 para objetos ParameterExpression está vinculada à versão do symengine usada para gerá-la, e existe a possibilidade de uma versão futura do symengine não ser compatível. Esse limite superior de versão é para evitar que uma versão futura do symengine cause incompatibilidades ao tentar carregar arquivos QPY usando o qpy.load().

Correções de bugs

Foi corrigido um problema com qpy.load() ao carregar um arquivo QPY contendo um ParameterExpressionse as versões do symengine instaladas nos ambientes de geração e carregamento não fossem as mesmas. Por exemplo, se um arquivo QPY contendo objetos ParameterExpression for gerado usando o Qiskit 1.2.2 com symengine==0.11.0 instalado, o Qiskit 1.2.2 com symengine==0.13.0 instalado não conseguirá carregá-lo.

Anteriormente, um erro era gerado pelo site symengine em relação a essa incompatibilidade de versão. Isso foi contornado para symengine 0.11 e 0.13 (não havia 0.12 ). No entanto, se estiver tentando usar versões diferentes do symengine e houver uma incompatibilidade, essa versão do Qiskit poderá não funcionar.

1.2.2

Prelúdio

O Qiskit 1.2.2 é uma versão menor de correção de bugs para a série 1.2.

Correções de bugs

Corrigido um erro na passagem do transpilador ElidePermutations em que o mapeamento de qubit não era atualizado corretamente na presença de PermutationGates.
Corrigiu uma possível fonte de não-determinismo em DenseLayout (e, por extensão SabreLayout) ao direcionar um CouplingMap ou Target que tem mais de um subgrafo com o mesmo grau de conectividade. Nesses casos, o layout de saída exato da passagem poderia flutuar anteriormente com base no número de CPUs locais e na velocidade de execução do thread.
A passagem do HighLevelSynthesis não gera mais uma exceção ao encontrar uma porta personalizada chamada "qft", mas que não é uma instância de QFTGate. Em vez disso, os plug-ins de síntese para portas QFT ignoram essa porta, e a definição da porta é usada (se fornecida).
Foi corrigido um bug nas gavetas de circuitos, que podiam falhar ou omitir fios se idle_wires=False. Correção de #13128 e #13146.
Foi corrigido um problema ao chamar transpile() ou o método StagedPassManager.run() de um gerenciador de passes gerado por generate_preset_pass_manager()usando optimization_level 2 ou 3 quando o argumento routing_method é definido como "none" para desativar explicitamente o roteamento. Anteriormente, nessas condições, o transpilador executava a passagem ElidePermutations como parte do estágio de inicialização, já que, em condições normais, essa é uma otimização útil para remover SwapGate e PermutationGate do circuito. No entanto, em routing_method="none" essa otimização não era esperada, pois ela altera o circuito de maneira semelhante ao roteamento, o que não deveria ser feito em routing_method="none". Isso foi corrigido pelo fato de não mais executar o ElidePermutations se routing_method="none" estiver definido. Corrigido #13144.
O exportador OpenQASM 3 restaurou seu comportamento de aceitar arquivos de inclusão de biblioteca não padrão no argumento includes para qasm3.dump(), dumps(), e Exporter. Eles inserirão uma instrução include adequada na saída, como antes, e o exportador não terá conhecimento das portas pretendidas nesse arquivo de inclusão; você deve passar as portas que espera que ele defina no argumento basis_gates para as mesmas funções.

Esperamos melhorar o mecanismo de exportação contra arquivos de inclusão não padrão em uma versão futura do Qiskit.

1.2.1

Prelúdio

O Qiskit 1.2.1 é uma versão menor de correção de bugs para a série 1.2.

Correções de bugs

Foi corrigido um problema com as visualizações de alguns backends/mapas de acoplamento que apareciam dobrados por conta própria. A configuração padrão ``neato` <https://graphviz.org/docs/layouts/neato/> `_ funciona bem na maioria dos casos. No entanto, o prism overlap retorna um layout mais regular para outros cenários.
As portas de biblioteca padrão controladas parametricamente (como CRXGate) agora serão extraídas corretamente para uma porta padrão do espaço Rust ao usar QuantumCircuit.append() e o objeto gate. Anteriormente, havia uma discrepância em que o uso do método QuantumCircuit.crx() causava uma extração correta no espaço Rust, mas o formulário append() não. Em geral, o bug não deve ter causado nenhuma falha no site Python.
Corrigido um bug no TwoQubitBasisDecomposer em que o código baseado em Rust entrava em pânico se o portão KAK fornecido não fosse uma versão padrão dos portões padrão (por exemplo, usando CXGate(ctrl_state=0)). Corrigido #12998.
Foi corrigido um bug em que o InstructionDurations.from_backend() não funcionava para backends BackendV2 backends. Corrigido #12760.
Corrigida a definição da matriz CUGate no espaço Rust. Embora isso não fosse perceptível ao lidar com o CUGate puramente no lado Python, isso teve efeitos indiretos quando as passagens do transpiler estavam usando a representação do Rust, como poderia acontecer em Consolidate2qBlocks. Corrigido #13118.
Foi corrigido um erro no HoareOptimizer em que um portão controlado era simplificado com a remoção de seus controles, mas o novo portão não era tratado corretamente. Corrigido #13079.
generate_preset_pass_manager() agora levanta corretamente uma exceção se seed_transpiler for definido com um valor inválido (ou seja, não for um número inteiro não negativo). Corrigido #12938.
Corrigido um caso extremo em SabreLayoutem que, em casos raros, em dispositivos grandes e circuitos desafiadores, o roteamento falhava. Isso se deveu ao fato de a válvula de liberação tornar roteável mais de uma porta de dois qubits, onde se esperava apenas uma. Corrigido #13081.
Corrigido um bug no Split2QUnitaries em que ele falhava ao ser executado em circuitos com objetos Gate personalizados que não implementavam __array__. Consulte #12970.
Corrigido um bug no StatePreparation em que o argumento normalize era ignorado para matrizes de entrada. Corrigido #12984.
Correção de um bug em que vários métodos de síntese criavam circuitos sem registros quânticos ou clássicos. Isso também afetou as funções que usavam internamente os métodos de síntese, como Clifford.to_circuit(). Embora os circuitos fossem válidos, isso poderia causar problemas ao comparar circuitos com registros. Corrigido #13041.
Foi corrigido um erro que fazia com que o método Initialize.gates_to_uncompute() falhar. Corrigido #12969.
Corrigido um caso extremo ao transpilar um circuito com optimization_level 2 ou 3 com um conjunto incompleto de portas de base de 1 qubit em um circuito contendo portas de 2 qubit, que pode ser implementado como um produto de portas de um único qubit. Esse erro é resolvido ao restringir Split2QUnitaries para considerar apenas objetos UnitaryGate objetos. Corrigido #12970.

1.2.0

Prelúdio

A versão do Qiskit 1.2.0 concentra-se principalmente no aprimoramento do desempenho e da qualidade do compilador. Além disso, é a última versão compatível com Python 3.8. No Qiskit 1.3.0, a versão mínima necessária do Python será 3.9. Entre uma ampla gama de novos recursos, aprimoramentos e correções, os destaques da versão são:

A infraestrutura do circuito, incluindo portões e operações, é transferida para a Rust. Isso permite uma série de acelerações na construção e manipulação de circuitos.

Aproveitando o ponto acima, partes da biblioteca de síntese agora estão construindo circuitos em Rust. Isso produz um aumento de velocidade significativo ao sintetizar operações como Cliffords, permutações ou funções lineares. Por exemplo, a decomposição de Cliffords de mais de 50 qubits se beneficia de uma aceleração de aproximadamente 1.000 vezes no tempo de execução.

A qualidade dos circuitos compilados é aprimorada pela otimização com uma otimização de peephole unitário no estágio inicial do fluxo de trabalho de transpilação (no nível de otimização >1) e pelo uso de um layout denso como um teste de layout do Sabre (no nível de otimização >0).

Novos Recurso

Adicionada uma nova classe QFTGate para representar nativamente as transformações quânticas de Fourier (QFTs). A maneira mais antiga de representar QFTs por meio de circuitos quânticos, veja QFTpermanece para compatibilidade com versões anteriores. A nova maneira de representar um QFT por meio de uma porta evita a síntese de seu circuito de definição quando a porta é declarada, atrasando a síntese real para o transpilador. Ele também permite escolher facilmente entre vários algoritmos diferentes para sintetizar QFTs, que estão disponíveis como plug-ins de síntese de alto nível.
Adicionado um método de síntese synth_qft_full() para construir um circuito QFT assumindo uma arquitetura totalmente conectada.
Foram adicionados dois plug-ins de síntese de alto nível para sintetizar um QFTGate. A classe QFTSynthesisFull é baseada em synth_qft_full() e sintetiza uma porta QFT assumindo uma conectividade total. A classe QFTSynthesisLine é baseada em synth_qft_line() e sintetiza uma porta QFT assumindo uma conectividade linear de vizinho mais próximo.
Foram adicionados dois parâmetros ao GenericBackendV2 para excluir o erro (noise_info) e as informações do canal de pulso (pulse_channels) da construção do backend. Esses parâmetros são True por padrão, replicando o comportamento padrão inicial do construtor. Um usuário sensível à memória pode definir essas opções como False para reduzir a sobrecarga de memória em 40x ao transpilar em grande escala GenericBackendV2.
A classe StabilizerState agora tem um novo método StabilizerState.probabilities_dict_from_bitstring() que permite ao usuário passar uma única cadeia de bits para medir um resultado. Anteriormente, o StabilizerState.probabilities_dict() seria utilizado e, na pior das hipóteses, calcularia ( $2^n$ ) o número de cálculos de probabilidade (dependendo do estado), mesmo que o usuário quisesse um único resultado. Com esse novo método, o usuário pode calcular apenas o valor de bitstring de resultado único que o usuário passa para medir a probabilidade. À medida que o número de qubits aumenta, mais evidente pode ser o aprimoramento do desempenho (dependendo do estado), pois apenas o resultado de 1 bitstring é medido.
Implementação da classe UniformSuperpositionGate , que permite a criação de um estado de superposição uniforme usando o algoritmo Shukla-Vedula. Esse recurso facilita a criação de circuitos quânticos que produzem um estado de superposição uniforme $\frac{1}{\sqrt{M}} \sum_{j=0}^{M-1} |j\rangle$ , em que $M$ é um número inteiro positivo que representa o número de estados de base computacional com uma amplitude de $\frac{1}{\sqrt{M}}$ . Essa implementação dá suporte à criação eficiente de estados de superposição uniforme, exigindo apenas $O(\log_2 (M))$ qubits e $O(\log_2 (M))$ gates. Exemplo de uso:
```
from qiskit import QuantumCircuit 
from qiskit.circuit.library.data_preparation import UniformSuperpositionGate

M = 5
num_qubits = 3
usp_gate = UniformSuperpositionGate(M, num_qubits)
qc = QuantumCircuit(num_qubits)
qc.append(usp_gate, list(range(num_qubits)))

qc.draw()
```

Recursos dos circuitos

Adicionada uma nova função random_clifford_circuit() para qiskit.circuitque permite gerar um circuito Clifford pseudo-aleatório com portas da biblioteca padrão. Exemplo de uso:
```
from qiskit.circuit.random import random_clifford_circuit

circ = random_clifford_circuit(num_qubits=2, num_gates=6)
circ.draw(output='mpl')
```
Adicionado suporte para AnnotatedOperation.params e AnnotatedOperation.validate_parameter()que permitem o tratamento de parâmetros em nível de circuito (como parâmetros de ligação) para operações anotadas.
CircuitInstruction e DAGOpNode têm novos métodos para consultar várias propriedades de seus arquivos internos Operationinterno, sem necessariamente precisar acessá-lo. Esses métodos são:
Se aplicável, usar qualquer um desses métodos é significativamente mais rápido do que consultar CircuitInstruction.operation ou DAGOpNode.op diretamente, especialmente se a instrução ou o nó representar uma porta padrão do Qiskit. Isso ocorre porque as portas padrão são armazenadas nativamente no Rust, e sua representação no site Python só é criada quando solicitada.
Foi adicionada uma representação rust nativa da biblioteca de portas padrão do Qiskit. Quando uma porta padrão é adicionada a uma porta QuantumCircuit ou DAGCircuit ele agora é representado de maneira mais eficiente diretamente no Rust. O acesso a esse objeto de porta de um circuito ou DAG retornará um novo objeto Python que representa a porta padrão. Isso resulta em transpilação e manipulação mais rápidas e eficientes de circuitos para funcionalidade escrita em Rust.
A função random_circuit() tem um novo recurso em que os usuários podem especificar uma distribuição num_operand_distribution (um dict) que especifica a proporção de portas de 1 qubit, 2 qubit, 3 qubit e 4 qubit no circuito aleatório. Por exemplo, se num_operand_distribution = {1: 0.25, 2: 0.25, 3: 0.25, 4: 0.25} for passado para a função, o circuito gerado terá aproximadamente 25% de portas de 1 qubit, 2 qubit, 3 qubit e 4 qubit. Além disso, deve-se observar que, se num_operand_distribution não for especificado, max_operands terá como padrão 4 e será gerado um circuito aleatório com uma distribuição aleatória de portas. Se num_operand_distribution e max_operands forem especificados ao mesmo tempo, num_operand_distribution será usado para gerar o circuito aleatório.

Exemplo de uso:
```
from qiskit.circuit.random import random_circuit

circ = random_circuit(
  num_qubits=6, depth=5, num_operand_distribution={1: 0.25, 2: 0.25, 3: 0.25, 4: 0.25}
)
circ.draw(output="mpl")
```
Melhorou o desempenho do método DAGCircuit.quantum_causal_cone() por não examinar o mesmo nó não diretivo várias vezes quando acessado por caminhos diferentes.
Foi adicionado o argumento da palavra-chave insert_barriers ao método QuantumCircuit.repeat() método. Configurá-lo para True inserirá barreiras entre as repetições do circuito.
Substituindo o algoritmo de síntese interna de StatePreparation e Initialize de Shende et al. pelo algoritmo dado em Isometry de Iten et al. O novo algoritmo reduz o número de portas CX e a profundidade do circuito em um fator de 2.
ParameterExpression agora suporta o operador unário + .

Recursos primitivos

Adicionado um novo método BitArray.postselect() que retorna todas as fotos que contêm valores de bits especificados. Exemplo de uso:

from qiskit.primitives.containers import BitArray

ba = BitArray.from_counts({'110': 2, '100': 4, '000': 3})
print(ba.postselect([0,2], [0,1]).get_counts())
# {'110': 2, '100': 4}

Os metadados das implementações do Primitives V2, ou seja, os metadados do Primitives, StatevectorSampler, StatevectorEstimator, BackendSamplerV2 e BackendEstimatorV2foram atualizados para corresponder aos dos dispositivos quânticos do site IBM.
- version e circuit_metadata são adicionados para todas as implementações de V2
- shots é adicionado para BackendSamplerV2 e BackendEstimatorV2
- precision é renomeado com target_precision para StatevectorEstimator
Observe que os metadados de StatevectorEstimator não têm shots porque a classe calcula os valores de expectativa com Statevector e as fotos não são usadas.

OpenQASM Características

A tabela de símbolos internos do exportador OpenQASM 3 (qiskit.qasm3) foi reescrita, o que deve resultar em saídas mais limpas ao usar portas da biblioteca padrão do Qiskit que não estão nos cabeçalhos da biblioteca padrão do OpenQASM 3 e saídas mais determinísticas. Por exemplo, o uso de vários RZXGates agora resultará em apenas uma única definição paramétrica e, quando ocorrerem colisões de nomes, a tabela de símbolos atribuirá um contador determinístico para tornar os nomes exclusivos, em vez de um número inteiro não determinístico (anteriormente, a identidade do objeto era usada).
A versão vendida da biblioteca padrão OpenQASM 3.0 foi atualizada para corresponder ao estado do commit 4ca1d79383. Em geral, isso não deve afetar seu uso do Qiskit, a menos que você esteja recuperando nosso arquivo vendido para seu próprio uso.

Recursos de síntese

MCXRecursive com $k$ qubits de controle e um único qubit auxiliar limpo agora requer no máximo $16k-8$ CX gates.
MCXVChain tem dois novos parâmetros booleanos relative_phase e action_only. Se action_only for True , o circuito não limpará os qubits sujos. Se relative_phase for True , a porta será implementada até uma fase global. Ambos os parâmetros são usados para otimizar a decomposição de MCXVChain.
MCXVChain com controles $k$ e qubits auxiliares sujos $k-2$ agora requer $8k-6$ CX gates.
Port synth_permutation_acg()usada para sintetizar permutações de qubit, para Rust. Isso produz uma melhoria de desempenho aproximada de 3x em circuitos de 1.000 qubits.
Port synth_permutation_basic()usada para sintetizar permutações de qubit, para Rust.
Port synth_cnot_count_full_pmh()usado para sintetizar uma função linear em uma rede CX, para o Rust. Isso produz um aumento de velocidade de aproximadamente 44x, conforme medido em circuitos de 100 qubits.
A função synth_cnot_count_full_pmh() agora permite escolher o melhor (heuristicamente) section_size definindo-o como None. Em seguida, é escolhido um valor que tenta minimizar o limite superior do número de portas CX, ou seja, $\alpha \log_2(n)$ , em que $n$ é o número de qubits e $\alpha \approx 0.56$ .
A função synth_clifford_bm() foi portada para o Rust. Lembre-se de que essa função sintetiza de forma ideal Clifford operadores em 1, 2 ou 3 qubits com relação ao número de CX-gates. Isso leva a um aumento significativo no desempenho. Para Cliffords com mais de 3 qubits, o aumento de velocidade é da ordem de 80 vezes.
A função synth_clifford_greedy() que sintetiza os operadores Clifford foi portada para o Rust, levando a um aumento significativo no desempenho para todos os números de qubits. Para Cliffords com mais de 50 qubits, o aumento de velocidade é da ordem de 1.000 vezes.
Foi adicionado o argumento da palavra-chave wrap às classes ProductFormula que (quando ativado) envolve termos individuais de evolução de Pauli. Isso pode ser útil na visualização de circuitos.
O argumento atomic_evolution para ProductFormula (e suas subclasses) tem uma nova assinatura de função. Em vez de pegar um operador Pauli e um coeficiente de tempo e retornar o circuito de evolução, a nova função pega um circuito existente e deve anexar a esse circuito a evolução do Pauli fornecido e o tempo dado. Essa nova implementação se beneficia de um desempenho significativamente melhor.
Melhorou o desempenho do synth_permutation_depth_lnn_kms()usado para sintetizar permutações para conectividade linear, portando-o para o Rust.

Recursos do Transpiler

Adicionada uma nova opção de caminho de importação para generate_preset_pass_manager()para que agora possa ser importado como:
```
from qiskit import generate_preset_pass_manager
```
em vez de ter que digitar o caminho completo:
```
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
```
A função também pode ser importada do módulo qiskit.transpiler módulo como:
```
from qiskit.transpiler import generate_preset_pass_manager
```
Adicionada uma nova opção de arquivo de configuração do usuário sabre_all_threads e uma variável de ambiente correspondente QISKIT_SABRE_ALL_THREADS. Quando esse sinalizador for definido, os gerenciadores de passagem predefinidos executarão o SabreLayout e SabreSwap usando todas as CPUs disponíveis no sistema local. O uso dessa opção é uma troca entre o determinismo da saída entre computadores diferentes e uma saída potencialmente melhor com menos SwapGates.

Essas passagens do transpilador executam várias tentativas aleatórias em paralelo e escolhem a saída que resulta no menor número de SwapGates. Como regra geral, se você executar mais tentativas, isso dará ao algoritmo mais oportunidades de encontrar um resultado melhor. Por padrão, os gerenciadores de passes predefinidos usam um número fixo de tentativas, nesta versão 5 tentativas para os níveis 0 e 1 e 20 tentativas para os níveis 2 e 3, mas esses números podem mudar em versões futuras (e eram diferentes em versões históricas). O uso de um número fixo de tentativas resulta em resultados determinísticos, independentemente do sistema local, porque, mesmo com uma semente fixa, se você tivesse como padrão o número de CPUs locais disponíveis, os resultados seriam diferentes quando executados em computadores diferentes.

Se o número padrão de tentativas para um determinado nível de otimização for maior do que o número de CPUs locais, ele usará o nível de otimização padrão que for maior.
Adicionada uma nova passagem Split2QUnitaries que itera sobre todos os portões ou unitários de dois qubits em um circuito e os substitui por dois unitários de um único qubit, se possível sem introduzir erros, ou seja, o portão/unitário de dois qubits é, na verdade, um produto tensorial de unitários de um único qubit.
Os passes Collect2qBlocks, ConsolidateBlocks e Split2QUnitaries foram adicionados ao estágio init dos gerenciadores de passes predefinidos com nível de otimização 2 e nível de otimização 3. A modificação do estágio init deve permitir um roteamento mais eficiente para circuitos quânticos que:
- contêm unitários/portas de dois qubits que são, na verdade, um produto de portas de um único qubit, ou
- contêm vários portões de dois qubits em um bloco contínuo de portões de dois qubits.
No primeiro caso, o roteamento da porta de dois qubits pode ser simplesmente ignorado, pois não ocorre nenhuma interação real entre um par de qubits. No último caso, o espaço de lookahead dos algoritmos de roteamento não é "poluído" por portas de dois qubits supérfluas, ou seja, para o roteamento, basta considerar apenas uma única porta de dois qubits por bloco contínuo de portas de dois qubits. Essas passagens não são executadas se os gerentes de passagem tiverem como alvo um Target que tenha um conjunto de portas de base discreta, ou seja, todas as portas de base não são parametrizadas.
O desempenho do StarPreRoutingusado para encontrar um subcircuito de conectividade de gráfico em estrela, é aprimorado com a execução do trabalho pesado no espaço Rust.
A passagem do SabreLayout a passagem do transpilador foi atualizada para sempre executar uma tentativa adicional usando o mesmo algoritmo que o Sabre DenseLayout para escolher um ponto de partida para o algoritmo de layout do Sabre. O ponto de partida usado pelo algoritmo de layout pode ter uma grande influência na qualidade dos resultados. Por padrão SabreLayout ainda começa com layout_trials tentativas aleatórias, mas, além disso, haverá uma única tentativa que usa o subgráfico mais denso do gráfico de conectividade como ponto de partida. Isso pode gerar melhores resultados em alguns casos, especialmente em casos com circuitos menores para mapas de acoplamento maiores.
Um novo argumento dt foi adicionado a generate_preset_pass_manager() para corresponder ao conjunto de argumentos de transpile(). Isso permitirá a conversão interna das restrições de transpilação em uma Target representação.

Recursos de visualização

O arquivo de configuração do usuário tem uma nova opção circuit_idle_wires, que assume um valor booleano. Isso permite que os usuários definam o comportamento padrão preferido da opção idle_wires das gavetas de circuito QuantumCircuit.draw() e circuit_drawer(). Por exemplo, adicionar uma seção a ~/.qiskit/settings.conf com:
```
[default]
circuit_idle_wires = false
```
alterará o padrão para não exibir fios ociosos.

Páginas Recursos

Foi adicionada uma nova variável de ambiente de tempo de compilação QISKIT_NO_CACHE_GATES que, quando definida para um valor de 1 (ou seja, QISKIT_NO_CACHE_GATES=1) diminui a sobrecarga de memória de um CircuitInstruction e DAGOpNode ao custo do aumento do tempo de execução em vários acessos a CircuitInstruction.operation e DAGOpNode.op. Se essa variável de ambiente for definida ao compilar o pacote Qiskit Python a partir da fonte, o armazenamento em cache do retorno desses atributos será desativado.

Notas sobre atualização de circuitos

O argumento annotated do método Gate.control() agora é None por padrão, o que permite que o Qiskit escolha se deseja anotar uma operação controlada. Se a implementação concreta (annotated=False) estiver disponível, ela será retornada por padrão. Caso contrário, a implementação anotada será retornada (annotated=True). Isso permite, por exemplo, adiar a síntese de portas controladas e parametrizadas.
As Operation instâncias de DAGOpNode.op sendo retornadas não necessariamente compartilharão uma referência comum ao objeto subjacente. Nunca foi garantido que esse fosse o caso, e alterar o DAGOpNode.op diretamente por referência não era sólido e sempre poderia corromper o rastreamento do estado interno do DAG. Devido à refatoração interna do QuantumCircuit e DAGCircuit para armazenar portas padrão em Rust, o objeto de saída de DAGOpNode.op agora provavelmente será uma cópia em vez de uma instância compartilhada. Se você precisar alterar um elemento, certifique-se de fazê-lo:
```
op = dag_node.op
op.params[0] = 3.14159
dag.substitute_node(dag_node, op)
```
em vez de fazer algo como:
```
dag_node.op.params[0] = 3.14159
```
que não funcionará para nenhuma porta padrão nesta versão. Provavelmente teria funcionado por acaso em uma versão anterior, mas nunca foi uma garantia da API.
As Operation instâncias de CircuitInstruction.operation sendo retornadas não necessariamente compartilharão uma referência comum ao objeto subjacente. Nunca foi garantido que esse seria o caso, e alterar o CircuitInstruction.operation diretamente por referência não era sólido e sempre poderia corromper o circuito, especialmente quando os parâmetros estavam em uso. Devido à refatoração interna do QuantumCircuit para armazenar portas padrão em Rust, o objeto de saída de CircuitInstruction.operation agora provavelmente será uma cópia em vez de uma instância compartilhada. Se você precisar alterar um elemento no circuito (o que não é recomendado, pois é ineficiente e propenso a erros), certifique-se de que isso seja feito:
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
qc.p(0)

op = qc.data[0].operation
op.params[0] = 3.14

qc.data[0] = qc.data[0].replace(operation=op)
```
em vez de fazer algo como:
```
from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(1)
qc.p(0)

qc.data[0].operation.params[0] = 3.14
```
que não funcionará para nenhuma porta padrão nesta versão. Provavelmente teria funcionado por acaso em uma versão anterior, mas nunca foi uma garantia da API.

Notas sobre a atualização dos primitivos

BitArray.slice_bits() e BitArray.slice_shots() agora exibirão IndexError quando os índices estiverem fora dos limites. Eles costumavam levantar ValueError no caso.
BitArray.__getitem__() agora exibirá IndexError quando os índices estiverem fora dos limites ou quando o número de dimensões dos índices não corresponder ao de BitArray. Eles costumavam levantar ValueError no caso.

Notas sobre a atualização da síntese

LieTrotter e SuzukiTrotter não mais envolver os termos de Pauli desenvolvidos individualmente em definições de porta. Se você depender de um determinado nível de decomposição do seu circuito, será necessário remover um nível de QuantumCircuit.decompose() ou adicionar o argumento da palavra-chave wrap=True ao seu objeto de síntese.

Notas sobre a atualização do Transpiler

Os níveis de otimização 2 e 3 agora empregam adicionalmente a otimização peephole antes do estágio de tradução/síntese (anteriormente, isso era feito apenas no estágio de otimização). Os efeitos da otimização do olho mágico incluem a remoção de portas que estão muito próximas da identidade, por exemplo, portas de fase controlada com um ângulo de rotação menor que $2\pi \otimes 2^{-25}$ .
A passagem de roteamento padrão usada pelo nível de otimização 0 para generate_preset_pass_manager() e transpile() foi alterada de StochasticSwap para SabreSwap. A passagem SabreSwap executa exatamente a mesma função, mas tem melhor desempenho tanto no tempo de execução quanto na qualidade da saída (em número de portas de troca e profundidade) em comparação com StochasticSwap. Para o site optimization_level=0 , isso não deve ser importante, pois não se espera que ele execute o roteamento no caso de uso típico do nível 0.

Se, por algum motivo, você estiver confiando no algoritmo de roteamento padrão anterior, poderá usar o argumento routing_method para transpile() e generate_preset_pass_manager() para "stochastic" para usar o StochasticSwap pass.
A função generate_preset_pass_manager() foi atualizada para, quando possível, converter internamente as restrições do transpilador em uma Target instância. Se uma entrada de backend do tipo BackendV1 for fornecida, ela será convertida em BackendV2 para expor seu Target. Essa alteração não exige nenhuma ação do usuário.

Páginas Notas da Atualização

A versão mínima do rustworkx necessária para executar esta versão foi aumentada de 0.14.0 para 0.15.0. Isso é necessário porque o Qiskit agora está usando a nova funcionalidade adicionada na versão rustworkx 0.15.0, que melhora o desempenho.

Circuitos obsoletos

Os seguintes métodos de circuito não foram planejados para uso público, mas foram acidentalmente deixados documentados na API pública durante a versão 1.0. Eles agora estão obsoletos no Qiskit 1.2 e serão removidos no Qiskit 2.0:

O tratamento de CircuitInstruction como um iterável do tipo tupla está obsoleto, e esse caminho legado será removido no Qiskit 2.0. Você deve usar os campos attribute-access CircuitInstruction.operation, CircuitInstruction.qubits, e CircuitInstruction.clbits em vez disso. Por exemplo:

from qiskit.circuit import QuantumCircuit

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

# Deprecated.
for op, qubits, clbits in qc.data:
    pass
# New style.
for instruction in qc.data:
    op = instruction.operation
    qubits = instruction.qubits
    clbits = instruction.clbits

Descontinuidade de primitivas

As implementações primitivas do V1 e os aliases de tipo não versionados do V1-exclusive agora estão obsoletos em favor de suas contrapartes do V2. A descontinuidade é estendida às seguintes classes que implementam as interfaces V1 :
- Estimatorem favor do equivalente em V2, StatevectorEstimator
- Samplerem favor do equivalente em V2, StatevectorSampler
- BackendEstimatorem favor do equivalente em V2, BackendEstimatorV2
- BackendSamplerem favor do equivalente em V2, BackendSamplerV2
Assim como os seguintes aliases de tipo não versionados:
- BaseEstimator, pseudônimo de BaseEstimatorV1
- BaseSampler, pseudônimo de BaseSamplerV1
Essa descontinuidade não afeta as versões explícitas de BaseEstimatorV1 e BaseSamplerV1 definições de interface abstratas e explicitamente versionadas ou classes de resultado e trabalho relacionadas.

Descontinuidade de provedores

A classe BackendV1 está obsoleta e será removida não antes da próxima versão principal, 2.0.0. Consulte o guia de migração para obter detalhes sobre como atualizar para o BackendV2.
A estrutura Qobj e as classes relacionadas (consulte qiskit.qobj) agora estão obsoletas. Eles foram introduzidos como parte do BackendV1 e não são mais necessários para interagir com BackendV2 backends. QuantumCircuit a serialização deve ser feita via QPY (consulte qiskit.qpy) ou OpenQASM (consulte qiskit.qasm2 e qiskit.qasm3).

Depreciações do Transpiler

A função assemble() está obsoleta e será removida na versão 2.0. A função foi usada principalmente para criar um Qobj, que não é mais necessário em BackendV2-fluxos de trabalho baseados em dados. Ele também foi usado para parâmetros de ligação, uma funcionalidade totalmente coberta pelo QuantumCircuit.assign_parameters().

Descontinuidade da visualização

O argumento justify de circuit_drawer() ou QuantumCircuit.draw()não será mais compatível com valores inválidos (alterando-os anteriormente para o padrão) e, em uma versão futura, eles apresentarão erros. Os valores de justificativa válidos são "left", "right" ou "none".
A função visualize_transition() foi descontinuada e será removida na versão 2.0.0. Essa função tinha várias limitações que limitavam sua utilidade apenas a casos de uso muito específicos e não se encaixava no restante do módulo de visualização do Qiskit.

Correções de bugs

Correção de uma série de problemas no controle de portas padrão parametrizadas. A versão controlada de alguns portões (por exemplo RXXGate ou RYGate para mais de 1 controle) não poderão ser sintetizados se contiverem parâmetros não vinculados. Anteriormente, a chamada para .control() nesse caso falhava, mas agora criamos um AnnotatedOperation como espaço reservado. Isso permite inserir a porta controlada em um circuito, vincular os parâmetros em um estágio posterior e, em seguida, sintetizar a operação. Correções #10311, #10697 e #12135.
O SGate e SdgGate agora retornam corretamente a CSGate, resp. CSdgGate, se eles forem controlados em um único qubit de controle.
Corrija o cálculo do desvio padrão em BackendEstimatorV2levando em conta a co-variância de Paulis não comutável. Fixo Qiskit/qiskit-ibm-runtime#1751.
Foi corrigido um problema em que circuit_drawer() ou o método QuantumCircuit.draw() não emitia um aviso quando um valor inválido era passado para o argumento justify , antes de alterá-lo para o padrão. Agora, ele emitirá um aviso se um valor inválido for passado. Os valores de justificativa válidos são "left", "right" ou "none". Consulte #12089 para obter mais detalhes.
Fixo SparsePauliOp.apply_layout() e Pauli.apply_layout() para gerar QiskitError se índices duplicados ou índices negativos forem fornecidos como parte de um layout.
Foi corrigido um erro na passagem do ConsolidateBlocks quando o circuito de entrada contém uma porta opaca personalizada e as opções basis_gates ou target não estão definidas, a passagem gerava um erro QiskitError e falhava. Isso foi corrigido para que, nessas situações, a passagem do transpilador não consolide o bloco identificado que contém uma porta personalizada em vez de falhar.
Foi corrigido um bug no PadDynamicalDecouplingque anteriormente não exibia corretamente a mensagem de erro de que um atraso não estava alinhado ao pulso, se o nó anterior ou seguinte fosse um nó de entrada/saída. Agora, a mensagem de erro é exibida corretamente.
O argumento da palavra-chave order da função BitArray.from_bool_array() deve ser "little" ou "big". Adicionadas verificações para gerar erro se um valor inválido for inserido.
Aprimore a decomposição da porta gerada por QuantumCircuit.mcx() sem usar qubits de ancilla, de modo que o número de CXGates cresça quadraticamente com o número de qubits, como esperado, e não exponencialmente.
Corrigido SparsePauliOp.apply_layout() para funcionar corretamente com operadores de zero qubit. Por exemplo, se você criou anteriormente um qubit 0 e aplicou um layout como:
```
op = SparsePauliOp("")
op.apply_layout(None, 3)
```
isso teria gerado um erro anteriormente. Agora, isso retornará corretamente um operador no formato: SparsePauliOp(['III'], coeffs=[1.+0.j])
Corrigido um bug do StatevectorSampler que ignorava as portas com c_if. Isso gerará um erro porque Statevector não pode lidar com c_if.
Foi corrigido um descuido na passagem do Commuting2qGateRouter em que as permutações de registro quântico não eram adicionadas ao conjunto de propriedades da passagem, de modo que precisavam ser rastreadas manualmente pelo usuário. Agora é possível acessar a permutação por meio da propriedade layout do circuito de saída e conectar a passagem em qualquer pipeline de transpilação sem perda de informações.
Correção de uma imprecisão de ponto flutuante ao dimensionar determinadas unidades de pulso entre segundos e nanossegundos. Se o pulso fosse definido simbolicamente, um erro desnecessário de ponto flutuante poderia ser introduzido pelo escalonamento de determinadas construções do site symengine, o que poderia se manifestar em resultados inesperados quando os símbolos estivessem totalmente vinculados. Corrigido #12392.
Corrigido um erro em synth_cnot_count_full_pmh() em que fornecer um section_size que não dividisse o número de qubits sem resto poderia levar a resultados errados. Agora, qualquer section_size (no máximo igual ao número de qubits) sintetiza o circuito correto. Para obter um valor ideal (heurístico), defina section_size=None.
PassManager.run() não perderá mais tempo serializando a si mesmo quando receber várias entradas se for trabalhar apenas em série.
Corrigido um bug no plot_coupling_map() que fazia com que as bordas do mapa de acoplamento fossem coloridas incorretamente. Corrigido #12354.
O analisador OpenQASM 2.0 (qasm2.load() e qasm2.loads()) agora pode avaliar expressões de gate-angle incluindo operandos inteiros que transbordariam o inteiro de tamanho do sistema. Eles serão avaliados em um contexto de ponto flutuante de precisão dupla, assim como o restante da expressão sempre foi. Atenção: um número inteiro arbitrariamente grande não será necessariamente representável com exatidão em ponto flutuante de precisão dupla, portanto, há uma chance de que, independentemente do modo como o circuito foi gerado, ele já tenha perdido toda a precisão numérica no módulo $2\pi$ .
O exportador do OpenQASM 3 (consulte qiskit.qasm3) agora apresentará um erro correto quando solicitado a usar uma palavra-chave ou outro identificador inválido como uma "porta de base", pois ele não tem como gerar a saída correta nesses casos.
O exportador do OpenQASM 3 (qiskit.qasm3) agora exportará corretamente várias instâncias de PauliEvolutionGate de um circuito. Anteriormente, apenas uma única instância era exportada, e todas as outras instâncias usavam silenciosamente a mesma versão (incorreta).
O exportador do OpenQASM 3 (qiskit.qasm3) agora escapará corretamente dos nomes dos portões. Anteriormente, uma porta cujo nome era um identificador OpenQASM 3 inválido fazia com que OpenQASM 3 inválido fosse gerado.
Uma série de inconsistências no tratamento de entrada entre transpile() e generate_preset_pass_manager() foram corrigidas. Essas inconsistências levariam a resultados de transpilação diferentes para os mesmos inputs, ou generate_preset_pass_manager() falha para determinadas combinações de entrada aceitas pelo transpile().

Esta página foi útil?

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