Notas de versão do Qiskit 0.44

---

Histórico de versões

Esta é a versão final em que o qiskit era um "meta-pacote", que continha vários "elementos" diferentes. O que é chamado de "Qiskit Terra" nesta nota de versão (e nas anteriores) é principalmente o que agora é chamado apenas de "Qiskit".

Essa tabela rastreia as versões do meta-pacote e a versão de cada elemento legado do Qiskit instalado:

---

0.44.1

Terra 0.25.1

Prelúdio

O Qiskit Terra 0.25.1 é uma versão de correção de bugs, que aborda alguns problemas identificados desde a versão 0.25.1.

Correções de bugs

• Foi corrigido um erro na serialização do QPY (qiskit.qpy) em que várias portas personalizadas controladas em um circuito podiam resultar em um arquivo QPY inválido que não podia ser analisado. Corrigido #9746.

• Corrigido o número 9363. rotulando a síntese sem registro na ordem em que o Tweedledum retorna. Por exemplo, compare este exemplo antes e depois da correção:

  from qiskit.circuit import QuantumCircuit
  from qiskit.circuit.classicalfunction import BooleanExpression
  
  boolean_exp = BooleanExpression.from_dimacs_file("simple_v3_c2.cnf")
  circuit = QuantumCircuit(boolean_exp.num_qubits)
  circuit.append(boolean_exp, range(boolean_exp.num_qubits))
  circuit.draw("text")
  
  from qiskit.circuit.classicalfunction import classical_function
  from qiskit.circuit.classicalfunction.types import Int1
  
  @classical_function
  def grover_oracle(a: Int1, b: Int1, c: Int1) -> Int1:
      return (a and b and not c)
  
  quantum_circuit = grover_oracle.synth(registerless=False)
  print(quantum_circuit.draw())

  O que imprimiria

       Before             After
  
       c: ──■──           a: ──■──
            │                  │
       b: ──■──           b: ──■──
            │                  │
       a: ──o──           c: ──o──
          ┌─┴─┐              ┌─┴─┐
  return: ┤ X ├      return: ┤ X ├
          └───┘              └───┘

• Corrigido plot_state_paulivec(), que anteriormente amortecia os coeficientes de estado por um fator de $2^n$, em que $n$ é o número de qubits. Agora, o gráfico de barras exibe corretamente os coeficientes como $\mathrm{Tr}(\sigma\rho)$, em que $\rho$ é o estado a ser plotado e $\sigma$ itera sobre todos os possíveis produtos tensoriais de Paulis de um único qubit.

• Os ângulos no exportador OpenQASM 2 (QuantumCircuit.qasm()) agora sempre incluirão um ponto decimal, por exemplo, no caso de 1.e-5. Isso é exigido por uma interpretação rigorosa da especificação do ponto flutuante-literal em OpenQASM 2. O analisador OpenQASM 2 do Qiskit (qasm2.load() e loads()) é mais permissivo por padrão e permitirá 1e-5 sem o ponto decimal, a menos que esteja no modo strict .

• O setter para SparsePauliOp.paulis agora rejeitará corretamente as tentativas de definir o atributo com dados de formato incorreto, em vez de permitir silenciosamente a criação de um objeto inválido. Consulte #10384.

• Correção de uma regressão de desempenho no SabreLayout e SabreSwap passagens do transpilador. Corrigido #10650

---

0.44.0

Esta versão marca oficialmente o fim do suporte ao pacote Qiskit IBMQ Provider e a remoção do Qiskit Aer do metapacote Qiskit. Após esta versão, o metapacote contém apenas o Qiskit Terra, portanto, esta é a versão final em que nos referiremos ao metapacote do Qiskit e ao Qiskit Terra como coisas separadas. A partir da próxima versão do Qiskit 0.45.0, o pacote Qiskit será apenas o que era anteriormente o Qiskit Terra e não haverá mais uma separação entre eles.

Se você ainda estiver usando o pacote qiskit-ibmq-provider , ele foi retirado e não tem mais suporte. Você deve seguir os links para os guias de migração no LEIAME do pacote sobre como mudar para os novos pacotes de substituição qiskit-ibm-provider, qiskit-ibm-runtime e qiskit-ibm-experiment:

https://github.com/Qiskit/qiskit-ibmq-provider#migration-guides

O projeto Qiskit Aer ainda está ativo e será mantido no futuro, mas não está mais incluído como parte do pacote qiskit . Para continuar usando o qiskit-aer , você precisará instalar explicitamente o qiskit-aer e importar o pacote do qiskit_aer.

Como esta é a versão final do metapacote do Qiskit, os seguintes extras do setuptools usados para instalar dependências opcionais não funcionarão mais na próxima versão do Qiskit 0.45.0:

• nature
• machine-learning
• finance
• optimization
• experiments

Se você estiver usando os extras para instalar algum pacote, deverá migrar para usar os pacotes diretamente em vez dos extras. Por exemplo, se você estava usando pip install qiskit[experiments] anteriormente, deve mudar para pip install qiskit qiskit-experiments para instalar os dois pacotes. Da mesma forma, o extra all (que é instalado via pip install "qiskit[all]") não incluirá mais esses pacotes no Qiskit 0.45.0.

Terra 0.25.0

Prelúdio

Os destaques da versão do Qiskit Terra 0.25.0 são:

• As operações de fluxo de controle agora são compatíveis com o transpilador em todos os níveis de otimização, incluindo os níveis 2 e 3 (por exemplo, chamar transpile() ou generate_preset_pass_manager() com argumento de palavra-chave optimization_level especificado como 2 ou 3 agora é compatível).

• Os campos IfElseOp.condition, WhileLoopOp.condition e SwitchCaseOp.target agora podem ser instâncias do novo tipo de expressão clássica em tempo de execução expr.Expr. Isso é diferente de ParameterExpression porque é avaliado em tempo de execução para backends que oferecem suporte a essas operações.

  Essas novas expressões têm muito mais poder do que a antiga forma de duas tuplas de fornecimento de condições clássicas. Por exemplo, agora é possível representar restrições de igualdade entre dois registros clássicos diferentes ou a lógica "ou" de dois bits clássicos. Esses dois exemplos seriam semelhantes:

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
  from qiskit.circuit.classical import expr
  
  qr = QuantumRegister(4)
  cr1 = ClassicalRegister(2)
  cr2 = ClassicalRegister(2)
  qc = QuantumCircuit(qr, cr1, cr2)
  qc.h(0)
  qc.cx(0, 1)
  qc.h(2)
  qc.cx(2, 3)
  qc.measure([0, 1, 2, 3], [0, 1, 2, 3])
  
  # If the two registers are equal to each other.
  with qc.if_test(expr.equal(cr1, cr2)):
    qc.x(0)
  
  # While either of two bits are set.
  with qc.while_loop(expr.logic_or(cr1[0], cr1[1])):
    qc.reset(0)
    qc.reset(1)
    qc.measure([0, 1], cr1)

  Para obter mais exemplos, consulte a documentação do qiskit.circuit.classical.

  Esse recurso é novo tanto para o Qiskit quanto para o hardware quântico disponível com o qual o Qiskit trabalha. Como os recursos ainda estão sendo desenvolvidos, é provável que haja lugares onde existam casos inesperados que precisarão de algum tempo para serem resolvidos. Se você encontrar algum problema relacionado ao suporte ou uso da expressão clássica, abra um problema com o Qiskit ou com o fornecedor do hardware.

  Nesta versão inicial, o Qiskit adicionou as operações:

  • bit_not()
  • logic_not()
  • bit_and()
  • bit_or()
  • bit_xor()
  • logic_and()
  • logic_or()
  • equal()
  • not_equal()
  • less()
  • less_equal()
  • greater()
  • greater_equal()

  Eles podem atuar em Python literais inteiros e booleanos, ou em ClassicalRegister e Clbit instâncias.

  Todas essas expressões clássicas são totalmente compatíveis com a pilha do transpilador Qiskit, com a serialização QPY (qiskit.qpy) e para exportação para OpenQASM 3 (qiskit.qasm3). A importação de OpenQASM 3 é atualmente gerenciada por um pacote separado (que é reexposto via qiskit.qasm3), que esperamos que seja estendido para corresponder aos novos recursos do Qiskit.

• O módulo qiskit.algorithms foi descontinuado e será removido em uma versão futura. Ela foi substituída por uma nova biblioteca autônoma qiskit-algorithms , que pode ser encontrada em PyPi ou no Github aqui:

  https://github.com/qiskit-community/qiskit-algorithms

  O módulo qiskit.algorithms continuará a funcionar como antes e serão feitas correções de bugs até sua remoção futura, mas o desenvolvimento ativo de novos recursos foi transferido para o novo pacote. Se estiver confiando em qiskit.algorithms deverá atualizar seus requisitos de Python para incluir também qiskit-algorithms e atualizar as importações de qiskit.algorithms para qiskit_algorithms. Observe que esse novo pacote não inclui o código de algoritmos já obsoletos, inclusive os algoritmos baseados em opflow e QuantumInstance. Se você ainda não tiver migrado de algoritmos baseados em QuantumInstance para algoritmos baseados em primitivos, deverá seguir as diretrizes de migração em https://qisk.it/algo _migration. A decisão de migrar o módulo algorithms para um pacote separado foi tomada para esclarecer a finalidade do Qiskit e fazer uma distinção entre as ferramentas e as bibliotecas construídas sobre ele.

O Qiskit Terra 0.25 abandonou o suporte para Python 3.7 após os avisos de depreciação iniciados no Qiskit Terra 0.23. Isso é consistente com o fim da vida útil do Python 3.7’s em 27 de junho de 2023. Para continuar usando o Qiskit, você deve atualizar para uma versão mais recente do Python.

Novos Recurso

• Os seguintes recursos foram adicionados a esta versão.

Recursos do Transpiler

• Foram adicionadas duas novas opções ao site BlockCollector.

  A primeira nova opção, split_layers , permite que os blocos coletados sejam divididos em sub-blocos sobre subconjuntos de qubits disjuntos, ou seja, em sub-blocos depth-1.

  A segunda nova opção collect_from_back permite que os blocos sejam coletados com avidez a partir das saídas do circuito. Isso é importante em combinação com as passagens de agendamento ALAP, em que podemos preferir colocar os portões nos blocos posteriores em vez dos anteriores.

• Foram adicionadas novas opções split_layers e collect_from_back a CollectLinearFunctions e CollectCliffords passagens do transpilador.

  Quando split_layers é True (verdadeiro), os blocos coletados são divididos em sub-blocos sobre subconjuntos de qubits disjuntos, ou seja, em sub-blocos depth-1. Considere o exemplo a seguir:

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  circuit = QuantumCircuit(5)
  circuit.cx(0, 2)
  circuit.cx(1, 4)
  circuit.cx(2, 0)
  circuit.cx(0, 3)
  circuit.swap(3, 2)
  circuit.swap(4, 1)
  
  # Collect all linear gates, without splitting into layers
  qct = CollectLinearFunctions(split_blocks=False, min_block_size=1, split_layers=False)(circuit)
  assert qct.count_ops()["linear_function"] == 1
  
  # Collect all linear gates, with splitting into layers
  qct = CollectLinearFunctions(split_blocks=False, min_block_size=1, split_layers=True)(circuit)
  assert qct.count_ops()["linear_function"] == 4

  O circuito original é linear. Ao coletar portas lineares sem dividi-las em camadas, devemos obter uma única função linear. No entanto, ao coletar portas lineares e dividi-las em camadas, devemos terminar com 4 funções lineares.

  Quando collect_from_back é verdadeiro, os blocos são coletados com avidez das saídas para as entradas do circuito. Considere o exemplo a seguir:

  from qiskit.circuit import QuantumCircuit
  from qiskit.transpiler.passes import CollectLinearFunctions
  
  circuit = QuantumCircuit(3)
  circuit.cx(1, 2)
  circuit.cx(1, 0)
  circuit.h(2)
  circuit.swap(1, 2)
  
  # This combines the CX(1, 2) and CX(1, 0) gates into a single linear function
  qct = CollectLinearFunctions(collect_from_back=False)(circuit)
  
  # This combines the CX(1, 0) and SWAP(1, 2) gates into a single linear function
  qct = CollectLinearFunctions(collect_from_back=True)(circuit)

  O circuito original contém uma porta Hadamard, de modo que a porta CX(1, 0) pode ser combinada com CX(1, 2) ou com SWAP(1, 2), mas não com ambas. Quando collect_from_back é False, os blocos lineares são coletados com avidez desde o início do circuito e, portanto, CX(1, 0) é combinado com CX(1, 2). Quando collect_from_back é True, os blocos lineares são coletados avidamente da extremidade do circuito e, portanto, CX(1, 0) é combinado com SWAP(1, 2).

• Adicionado DAGCircuit.classical_predecessors() e DAGCircuit.classical_successors()uma alternativa à seleção de fios clássicos que não exige o acesso direto ao gráfico interno de um nó DAG. O exemplo a seguir ilustra a nova funcionalidade:

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  from qiskit.converters import circuit_to_dag
  from qiskit.circuit.library import RZGate
  
  q = QuantumRegister(3, 'q')
  c = ClassicalRegister(3, 'c')
  circ = QuantumCircuit(q, c)
  circ.h(q[0])
  circ.cx(q[0], q[1])
  circ.measure(q[0], c[0])
  circ.rz(0.5, q[1]).c_if(c, 2)
  circ.measure(q[1], c[0])
  dag = circuit_to_dag(circ)
  
  rz_node = dag.op_nodes(RZGate)[0]
  # Contains the "measure" on clbit 0, and the "wire start" nodes for clbits 1 and 2.
  classical_predecessors = list(dag.classical_predecessors(rz_node))
  # Contains the "measure" on clbit 0, and the "wire end" nodes for clbits 1 and 2.
  classical_successors = list(dag.classical_successors(rz_node))

• Suporte habilitado para ControlFlowOp operações na CommutativeCancellation passe. Anteriormente, os blocos nas operações de fluxo de controle eram ignorados por essa passagem.

• Suporte habilitado para ControlFlowOp operações na ConsolidateBlocks passe.

• Adicionado DAGCircuit.quantum_causal_cone() para obter o cone causal de um qubit em um DAGCircuit. O exemplo a seguir mostra seu uso correto:

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  from qiskit.circuit.library import CXGate, CZGate
  from qiskit.dagcircuit import DAGCircuit
  
  # Build a DAGCircuit
  dag = DAGCircuit()
  qreg = QuantumRegister(5)
  creg = ClassicalRegister(5)
  dag.add_qreg(qreg)
  dag.add_creg(creg)
  dag.apply_operation_back(CXGate(), qreg[[1, 2]], [])
  dag.apply_operation_back(CXGate(), qreg[[0, 3]], [])
  dag.apply_operation_back(CZGate(), qreg[[1, 4]], [])
  dag.apply_operation_back(CZGate(), qreg[[2, 4]], [])
  dag.apply_operation_back(CXGate(), qreg[[3, 4]], [])
  
  # Get the causal cone of qubit at index 0
  result = dag.quantum_causal_cone(qreg[0])

• Um novo método find_bit() foi adicionado à classe DAGCircuit que retorna as localizações de bits de um determinado valor de Qubit ou Clbit como uma tupla do índice posicional do bit dentro do circuito e uma lista de tuplas que localizam o bit nos registros do circuito.

• O transpilador embutido EquivalenceLibrary (qiskit.circuit.equivalence_library.SessionEquivalenceLibrary) do transpilador aprendeu as relações circulares de Pauli $X = iYZ$, $Y = iZX$ e $Z = iXY$. Isso deve tornar a transpilação para conjuntos de bases restritas e potencialmente incompletas mais confiável. Consulte #10293 para obter mais detalhes.

• As operações de fluxo de controle agora são compatíveis com o transpilador em todos os níveis de otimização, incluindo os níveis 2 e 3 (por exemplo, chamar transpile() ou generate_preset_pass_manager() com argumento de palavra-chave optimization_level=3).

• DAGCircuit.substitute_node() ganhou um argumento de palavra-chave propagate_condition que é análogo ao mesmo argumento em substitute_node_with_dag(). Definir isso como False elimina o comportamento herdado de copiar uma condição do node para o novo op que o está substituindo.

  Essa opção é ignorada para operações gerais de fluxo de controle, que nunca propagarão sua condição nem aceitarão uma condição de outro nó.

• Introduziu um novo método, DAGCircuit.separable_circuits()que retorna uma lista de objetos DAGCircuit uma para cada conjunto de qubits conectados que não têm portas conectando-os a outro conjunto.

  Cada DAGCircuit a instância retornada por esse método conterá o mesmo número de clbits que self. Esse método não retornará instâncias DAGCircuit instâncias que consistam apenas de clbits.

• Adicionado o atributo Target.concurrent_measurements que representa uma restrição de hardware de qubits medidos simultaneamente. Essa restrição é fornecida em uma forma de lista aninhada, na qual cada elemento representa um grupo de qubit a ser medido em conjunto. Em um exemplo abaixo:

  [[0, 1], [2, 3, 4]]

  os qubits 0 e 1, e 2, 3 e 4 são medidos juntos no dispositivo. Essa restrição não bloqueia a medição de um qubit individual, mas talvez seja necessário considerar o alinhamento das operações de medição para esses qubits ao trabalhar com o agendador do Qiskit Pulse e ao criar novas passagens do transpilador que sejam sensíveis ao tempo (ou seja, passagens que realizam agendamento).

• A passagem do transpilador SetLayout pode agora ser construído com uma lista de inteiros que representam os qubits físicos nos quais o circuito quântico será mapeado. Ou seja, o primeiro qubit no circuito será alocado para o qubit físico na posição zero da lista, e assim por diante.

• O transpilador incorporado EquivalenceLibrary ensinou mais equivalências de rotação de Pauli entre as portas de um qubit $R_X$, $R_Y$ e $R_Z$ e entre as portas de dois qubits $R_{XX}$, $R_{YY}$ e $R_{ZZ}$. Isso deve tornar as traduções de bases simples mais confiáveis, especialmente os circuitos que usam rotações $Y$. Consulte #7332.

• As operações de fluxo de controle agora são compatíveis com a família Sabre de passagens de transpiladores, ou seja, passagem de layout SabreLayout e passagem de roteamento SabreSwap. Função transpile() os argumentos da palavra-chave layout_method e routing_method agora aceitam a opção "sabre" para circuitos com fluxo de controle, que não era suportada anteriormente.

Recursos dos circuitos

• Os campos IfElseOp.condition, WhileLoopOp.condition e SwitchCaseOp.target agora podem ser instâncias do novo tipo de expressão clássica em tempo de execução expr.Expr. Isso é diferente de ParameterExpression porque é avaliado em tempo de execução para backends que oferecem suporte a essas operações.

  Essas novas expressões têm muito mais poder do que a antiga forma de duas tuplas de fornecimento de condições clássicas. Por exemplo, agora é possível representar restrições de igualdade entre dois registros clássicos diferentes ou a lógica "ou" de dois bits clássicos. Esses dois exemplos seriam semelhantes:

  from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
  from qiskit.circuit.classical import expr
  
  qr = QuantumRegister(4)
  cr1 = ClassicalRegister(2)
  cr2 = ClassicalRegister(2)
  qc = QuantumCircuit(qr, cr1, cr2)
  qc.h(0)
  qc.cx(0, 1)
  qc.h(2)
  qc.cx(2, 3)
  qc.measure([0, 1, 2, 3], [0, 1, 2, 3])
  
  # If the two registers are equal to each other.
  with qc.if_test(expr.equal(cr1, cr2)):
    qc.x(0)
  
  # While either of two bits are set.
  with qc.while_loop(expr.logic_or(cr1[0], cr1[1])):
    qc.reset(0)
    qc.reset(1)
    qc.measure([0, 1], cr1)

  Para obter mais exemplos, consulte a documentação do qiskit.circuit.classical.

  Esse recurso é novo tanto para o Qiskit quanto para o hardware quântico disponível com o qual o Qiskit trabalha. Como os recursos ainda estão sendo desenvolvidos, é provável que haja lugares onde existam casos inesperados que precisarão de algum tempo para serem resolvidos. Se você encontrar algum problema relacionado ao suporte ou uso da expressão clássica, abra um problema com o Qiskit ou com o fornecedor do hardware.

  Nesta versão inicial, o Qiskit adicionou as operações:

  • bit_not()
  • logic_not()
  • bit_and()
  • bit_or()
  • bit_xor()
  • logic_and()
  • logic_or()
  • equal()
  • not_equal()
  • less()
  • less_equal()
  • greater()
  • greater_equal()

  Eles podem atuar em Python literais inteiros e booleanos, ou em ClassicalRegister e Clbit instâncias.

  Todas essas expressões clássicas são totalmente compatíveis com a pilha do transpilador Qiskit, com a serialização QPY (qiskit.qpy) e para exportação para OpenQASM 3 (qiskit.qasm3). A importação de OpenQASM 3 é atualmente gerenciada por um pacote separado (que é reexposto via qiskit.qasm3), que esperamos que seja estendido para corresponder aos novos recursos do Qiskit.

• Foram adicionadas ferramentas para trabalhar com as novas representações de expressões clássicas de tempo de execução. Uma subclasse geral ExprVisitor geral é fornecida para que os consumidores dessas expressões possam fazer uma subclasse. Dois utilitários baseados nessa estrutura, iter_vars() e structurally_equivalent()também são fornecidos, os quais produzem, respectivamente, um iterador através dos nós Var e verificam se duas instâncias de Expr são estruturalmente iguais, até algum mapeamento dos Var nós contidos.

• Função adicionada lift_legacy_condition() que pode ser usada para converter condições de estilo antigo em nós de estilo novo Expr novos. Observe que esses nós de expressão não são permitidos em campos de estilo antigo Instruction.condition que devem ser substituídos por um tratamento clássico mais avançado, como IfElseOp.

• Foi adicionado suporte para a obtenção de valores absolutos de ParameterExpressions. Por exemplo, agora é possível fazer o seguinte:

  from qiskit.circuit import QuantumCircuit, Parameter
  
  x = Parameter("x")
  circuit = QuantumCircuit(1)
  circuit.rx(abs(x), 0)
  
  bound = circuit.bind_parameters({x: -1})

• O desempenho de QuantumCircuit.assign_parameters() e bind_parameters() aumentou significativamente em circuitos grandes com estruturas típicas de aplicativos usados. Isso inclui a maioria dos circuitos baseados na NLocal estrutura, como EfficientSU2. Consulte #10282 para obter mais detalhes.

• O método QuantumCircuit.assign_parameters() ganhou dois novos argumentos de palavras-chave: flat_input e strict. Essas são opções avançadas que podem ser usadas para acelerar o método ao passar as associações de parâmetros como um dicionário; flat_input=True é uma garantia de que as chaves do dicionário contêm apenas Parameter instâncias (não ParameterVectors), e strict=False permite que o dicionário contenha parâmetros que não estão presentes no circuito. O uso dessas duas opções pode reduzir a sobrecarga da normalização de entrada nessa função.

• Adição de um novo argumento de palavra-chave flatten ao construtor das seguintes classes:

  • EfficientSU2
  • ExcitationPreserving
  • NLocal
  • RealAmplitudes
  • TwoLocal
  • EvolvedOperatorAnsatz
  • QAOAAnsatz

  Se esse argumento for definido como True , a QuantumCircuit gerada não envolverá a implementação em Gate ou Instruction objetos. Embora isso não seja ideal para a visualização, normalmente resulta em um desempenho de tempo de execução muito melhor, especialmente com QuantumCircuit.bind_parameters() e QuantumCircuit.assign_parameters() que pode apresentar uma melhoria de tempo de execução subestacial com uma saída achatada em comparação com a saída padrão agrupada.

• Foi adicionado suporte para a construção de LinearFunctions a partir de circuitos quânticos mais gerais, que podem conter:

  • Barreiras (do tipo Barrier) e atrasos (Delay), que são simplesmente ignorados
  • Permutações (do tipo PermutationGate)
  • Outras funções lineares
  • Cliffords (do tipo Clifford), quando o Clifford representa uma função linear (e uma exceção CircuitError é levantada se não for)
  • Circuitos quânticos aninhados dessa forma

• Adicionado o método LinearFunction.__eq__() . Dois objetos do tipo LinearFunction são considerados iguais quando suas representações como matrizes binárias invertíveis são iguais.

• Adicionado LinearFunction.extend_with_identity() que permite estender uma função linear sobre k qubits para uma função linear sobre n >= k qubits, especificando as novas posições dos qubits originais e preenchendo com identidades nos qubits restantes.

• Foram adicionados dois métodos para impressão bonita de objetos LinearFunction objetos: LinearFunction.mat_str()o método de impressão bonita, que retorna a representação em string da função linear vista como uma matriz com entradas 0/1, e o método de impressão bonita, que retorna a representação em string da função linear vista como uma transformação linear LinearFunction.function_str()que retorna a representação em string da função linear vista como uma transformação linear.

• As instruções StatePreparation e Initialize, e seus métodos de circuito associados QuantumCircuit.prepare_state() e initialize()ganharam um argumento de palavra-chave normalize, que pode ser definido como True para normalizar automaticamente um alvo de matriz. Por padrão, é False, que mantém o comportamento atual de levantar uma exceção quando recebe uma entrada não normalizada.

Recursos dos algoritmos

• Foi adicionada a opção de passar um retorno de chamada para o UMDA que permite manter o controle do número de avaliações de funções, dos parâmetros atuais e do melhor valor de função alcançado.

OpenQASM Características

• Os OpenQASM 3 exportadores (qasm3.dump(), dumps() e Exporter) têm um novo argumento allow_aliasing , que eventualmente substituirá o argumento alias_classical_registers . Isso controla se o aliasing é permitido para bits clássicos ou qubits, em vez de a opção estar disponível apenas para bits clássicos.

Recursos de informação quântica

• Adição de uma nova função negativity() que calcula a medida de emaranhamento da negatividade de um estado quântico. O exemplo de uso da função acima é dado abaixo:

  from qiskit.quantum_info.states.densitymatrix import DensityMatrix
  from qiskit.quantum_info.states.statevector import Statevector
  from qiskit.quantum_info import negativity
  import numpy as np
  
  # Constructing a two-qubit bell state vector
  state = np.array([0, 1/np.sqrt(2), -1/np.sqrt(2), 0])
  # Calculating negativity of statevector
  negv = negativity(Statevector(state), [1])
  
  # Creating the Density Matrix (DM)
  rho = DensityMatrix.from_label("10+")
  # Calculating negativity of DM
  negv2 = negativity(rho, [0, 1])

• Adicionada a função schmidt_decomposition(). Essa função funciona com o Statevector e DensityMatrix para estados puros bipartidos.

• Adiciona suporte para multiplicação de objetos SparsePauliOp objetos com Parameter objetos usando o operador *, por exemplo:

  from qiskit.circuit import Parameter
  from qiskit.quantum_info import SparsePauliOp
  
  param = Parameter("a")
  op = SparsePauliOp("X")
  param * op

Recursos do Pulse

• A SymbolicPulse a biblioteca foi ampliada. As novas funções de pulso na biblioteca são:

  • GaussianDeriv()
  • Sech()
  • SechDeriv()
  • Square()

  As novas funções retornam uma instância ScalableSymbolicPulse e correspondem à funcionalidade das funções correspondentes na biblioteca de pulsos discretos, com exceção de Square() para a qual uma fase de $2\pi$ se desloca por um ciclo completo (ao contrário da função discreta square() em que essa mudança foi induzida por uma fase de $\pi$ ).

• O método filter() é ativado na classe ScheduleBlock classe. Esse método permite que os usuários retenham apenas Instruction objetos que passam por todos os filtros fornecidos. Como condições de filtro incorporadas, a instância da subclasse Channel instância da subclasse e Instruction tipo de subclasse podem ser especificados. Os retornos de chamada definidos pelo usuário que tomam Instruction também podem ser adicionadas aos filtros.

• O método exclude() é ativado na classe ScheduleBlock classe. Esse método permite que os usuários retenham apenas Instruction os objetos que não forem aprovados em pelo menos um de todos os filtros fornecidos. Como condições de filtro incorporadas, a instância da subclasse Channel instância da subclasse e Instruction tipo de subclasse podem ser especificados. Os retornos de chamada definidos pelo usuário que tomam Instruction também podem ser adicionadas aos filtros. Esse método é o complemento de filter(), de modo que a seguinte condição é sempre satisfeita: block.filter(*filters) + block.exclude(*filters) == block em termos de instruções incluídas, em que block é uma ScheduleBlock instância.

• Adicionada uma nova função gaussian_square_echo() à biblioteca de pulsos. O pulso retornado é composto de três GaussianSquare pulsos. Os dois primeiros são pulsos de eco com duração de metade da duração total e implementam tons rotativos. O terceiro pulso é um tom de cancelamento que dura toda a duração do pulso e implementa a correção de rotações de qubit único.

• O QPY é compatível com os objetos Discriminator e Kernel . Esse recurso permite que os usuários serializem e desserializem as Acquire instruções com esses objetos usando o QPY.

Recursos de síntese

• Adicionada uma nova função de síntese synth_cx_cz_depth_line_my() que produz a forma de circuito de um circuito CX seguido por um circuito CZ para conectividade linear do vizinho mais próximo (LNN) em profundidade de 2 qubits de no máximo 5n, usando CX e portas de fase (S, Sdg ou Z). O algoritmo de síntese é baseado no artigo de Maslov e Yang, arXiv:2210.16195.

  O algoritmo aceita uma matriz inversível binária mat_x representando o circuito CX, uma matriz simétrica binária mat_z representando o circuito CZ e retorna um circuito quântico com profundidade de 2 qubits de no máximo 5n computando a composição dos circuitos CX e CZ. O exemplo a seguir ilustra a nova funcionalidade:

  import numpy as np
  from qiskit.synthesis.linear_phase import synth_cx_cz_depth_line_my
  mat_x = np.array([[0, 1], [1, 1]])
  mat_z = np.array([[0, 1], [1, 0]])
  qc = synth_cx_cz_depth_line_my(mat_x, mat_z)

  Essa função agora é usada por padrão no algoritmo de síntese de Clifford synth_clifford_depth_lnn() que otimiza a profundidade de 2 qubits para a conectividade LNN, melhorando a profundidade de 2 qubits de 9n+4 para 7n+2. O algoritmo de síntese de clifford pode ser usado da seguinte forma:

  from qiskit.quantum_info import random_clifford
  from qiskit.synthesis import synth_clifford_depth_lnn
  
  cliff = random_clifford(3)
  qc = synth_clifford_depth_lnn(cliff)

  A síntese acima pode ser aprimorada ainda mais, conforme descrito no artigo de Maslov e Yang, usando a otimização local entre as camadas de 2 qubit. Esse aprimoramento é deixado para o trabalho de acompanhamento.

Recursos de visualização

• QuantumCircuit.draw() e função circuit_drawer() ao usar a opção output='mpl' agora suportam o desenho de blocos de circuitos aninhados de ControlFlowOp operações, incluindo if, else, while, for e switch/case. Os blocos de circuitos são envolvidos por caixas para delinear os circuitos.

• Algumas restrições ao uso do wire_order nas gavetas de circuitos foram relaxadas. Agora, o wire_order pode listar apenas os qubits e, nesse caso, pode ser usado com o cregbundle=True, pois não afetará os bits clássicos.

  from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
  
  qr = QuantumRegister(4, "q")
  cr = ClassicalRegister(4, "c")
  cr2 = ClassicalRegister(2, "ca")
  circuit = QuantumCircuit(qr, cr, cr2)
  circuit.h(0)
  circuit.h(3)
  circuit.x(1)
  circuit.x(3).c_if(cr, 10)
  circuit.draw('text', wire_order=[2, 3, 0, 1], cregbundle=True)

   q_2: ────────────
        ┌───┐ ┌───┐
   q_3: ┤ H ├─┤ X ├─
        ├───┤ └─╥─┘
   q_0: ┤ H ├───╫───
        ├───┤   ║
   q_1: ┤ X ├───╫───
        └───┘┌──╨──┐
   c: 4/═════╡ 0xa ╞
             └─────┘
  ca: 2/════════════

Páginas Recursos

• Um novo testador de importação preguiçosa, HAS_PYGMENTSestá disponível para testar a presença da biblioteca de realce de sintaxe Pygments.

• A mágica %qiskit_version_table de qiskit.tools.jupyter agora inclui todos os módulos importados com qiskit em seus nomes.

Notas da Atualização

• O Qiskit Terra 0.25 abandonou o suporte para Python 3.7 após os avisos de depreciação iniciados no Qiskit Terra 0.23. Isso é consistente com o fim da vida útil do Python 3.7’s em 27 de junho de 2023. Para continuar usando o Qiskit, você deve atualizar para uma versão mais recente do Python.

• O Qiskit Terra 0.25 agora requer a versão 0.13.0 de rustworkx.

• Por padrão, o Qiskit constrói suas extensões compiladas usando a Python Stable ABI com suporte à versão mais antiga da Python suportada pelo Qiskit (atualmente 3.8 ). Isso significa que, no futuro, haverá uma única roda pré-compilada que será enviada no lançamento e funcionará com todas as versões do Qiskit compatíveis com o site Python. Não há nenhuma diferença esperada no desempenho do tempo de execução usando a API limitada, portanto, ela está ativada por padrão em todas as compilações agora. Anteriormente, as extensões compiladas eram criadas usando a API específica da versão e só funcionavam com uma única versão do site Python. Essa alteração foi feita para reduzir o número de arquivos de pacotes que precisamos criar e publicar em cada versão. Ao compilar o Qiskit a partir do código-fonte, não deve haver alterações necessárias no processo de compilação, exceto pelo fato de que as tags padrão nos nomes dos arquivos de saída serão diferentes para refletir o uso da API limitada.

Notas sobre a atualização do Transpiler

• O suporte à passagem de listas de valores de argumentos para a função transpile() é removido. Essa funcionalidade foi descontinuada como parte da versão 0.23.0. Você ainda pode passar uma lista de objetos QuantumCircuit para o primeiro argumento posicional. O que foi removido é a transmissão de listagem dos outros argumentos para cada circuito nessa lista de entrada. A remoção dessa funcionalidade foi necessária para reduzir consideravelmente a sobrecarga da execução paralela para transpilar vários circuitos de uma só vez. Se você estiver usando essa funcionalidade atualmente, poderá chamar transpile() várias vezes em vez disso. Por exemplo, se você estava fazendo algo como:

  from qiskit.transpiler import CouplingMap
  from qiskit import QuantumCircuit
  from qiskit import transpile
  
  qc = QuantumCircuit(2)
  qc.h(0)
  qc.cx(0, 1)
  qc.measure_all()
  
  cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
  results = transpile([qc] * 6, coupling_map=cmaps)

  em vez disso, você deve executar algo como:

  from qiskit.transpiler import CouplingMap
  from qiskit import QuantumCircuit
  from qiskit import transpile
  
  qc = QuantumCircuit(2)
  qc.h(0)
  qc.cx(0, 1)
  qc.measure_all()
  
  cmaps = [CouplingMap.from_heavy_hex(d) for d in range(3, 15, 2)]
  results = [transpile(qc, coupling_map=cm) for cm in cmap]

  Você também pode aproveitar parallel_map() ou multiprocessing da biblioteca padrão Python se quiser executar isso em paralelo.

• A família Sabre de passagens de transpiladores (a saber SabreLayout e SabreSwap) agora são usados por padrão para todos os circuitos ao invocar o transpilador no nível de otimização 1 (por exemplo, chamando transpile() ou generate_preset_pass_manager() com argumento de palavra-chave optimization_level=1). Anteriormente, os circuitos com operações de fluxo de controle usavam DenseLayout e StochasticSwap com esse perfil.

Notas sobre atualização de circuitos

• Os métodos do construtor OpenQASM 2 em QuantumCircuit (from_qasm_str() e from_qasm_file()) foram alterados para usar o analisador baseado em Rust adicionado no Qiskit Terra 0.24. Isso deve resultar em tempos de análise significativamente mais rápidos (10 vezes ou mais, o que não é incomum) e em uma redução enorme do uso da memória intermediária.

  Os métodos QuantumCircuit são mantidos com a mesma interface para fins de continuidade; a maneira preferida de acessar o importador OpenQASM 2 é usar qasm2.load() e qasm2.loads()que oferecem uma interface expandida para controlar a análise e a construção.

• O argumento obsoleto circuit_cregs do construtor da classe InstructionSet foi removido. Ele foi descontinuado na versão 0.19.0. Se você estiver usando esse argumento e construindo manualmente um objeto InstructionSet (o que deve ser bastante incomum, pois ele é usado principalmente internamente), você deve passar um callable para o argumento da palavra-chave resource_requester . Por exemplo:

  from qiskit.circuit import Clbit, ClassicalRegister, InstructionSet
  from qiskit.circuit.exceptions import CircuitError
  
  def my_requester(bits, registers):
      bits_set = set(bits)
      bits_flat = tuple(bits)
      registers_set = set(registers)
  
      def requester(specifier):
          if isinstance(specifer, Clbit) and specifier in bits_set:
              return specifier
          if isinstance(specifer, ClassicalRegster) and specifier in register_set:
              return specifier
          if isinstance(specifier, int) and 0 <= specifier < len(bits_flat):
              return bits_flat[specifier]
          raise CircuitError(f"Unknown resource: {specifier}")
  
      return requester
  
  my_bits = [Clbit() for _ in [None]*5]
  my_registers = [ClassicalRegister(n) for n in range(3)]
  
  InstructionSet(resource_requester=my_requester(my_bits, my_registers))

OpenQASM Notas sobre a atualização

• Os métodos do construtor OpenQASM 2 em QuantumCircuit (from_qasm_str() e from_qasm_file()) foram alterados para usar o analisador baseado em Rust adicionado no Qiskit Terra 0.24. Isso deve resultar em tempos de análise significativamente mais rápidos (10 vezes ou mais, o que não é incomum) e em uma redução enorme do uso da memória intermediária.

  Os métodos QuantumCircuit são mantidos com a mesma interface para fins de continuidade; a maneira preferida de acessar o importador OpenQASM 2 é usar qasm2.load() e qasm2.loads()que oferecem uma interface expandida para controlar a análise e a construção.

• Os OpenQASM 3 exportadores (qasm3.dump(), dumps() e Exporter) agora usarão menos definições de "alias de registro" em sua saída. O circuito descrito não mudará, mas agora ele exportará preferencialmente em termos dos tipos diretos bit, qubit e qubit[n] em vez de produzir um registro _loose_bits e fazer alias com mais registros a partir dele. Isso é feito para minimizar o número de recursos avançados do OpenQASM 3 em uso e para evitar a introdução de estrutura de matriz desnecessária em programas que não precisam dela.

Notas sobre a atualização das informações quânticas

• Clifford.from_circuit() não tentará mais resolver instruções cujos campos definition são mutuamente recursivos com algum outro objeto. Essas definições recursivas já são uma violação da ordenação estritamente hierárquica que o campo definition exige, e o código não deve contar com essa possibilidade. Se você quiser definir equivalências que possam ter ciclos (mútuos), use um EquivalenceLibrary.

Notas sobre a atualização da visualização

• No objeto interno ~qiskit.visualization.circuit.matplotlib.MatplotlibDrawer , os argumentos layout, global_phase, qregs e cregs foram removidos. Eles foram originalmente descontinuados no Qiskit Terra 0.20. Esses objetos são simplesmente inferidos a partir do circuit fornecido agora.

  Essa é uma classe de trabalho interna das rotinas de visualização. É improvável que você precise alterar qualquer parte do seu código.

Páginas Notas da Atualização

• O local de importação qiskit.util foi removido, pois estava obsoleto desde o Qiskit Terra 0.17. Os usuários devem usar o novo local de importação, qiskit.utils.

Notas de descontinuação

• As extensões dos namespaces qiskit e qiskit.providers por pacotes externos estão obsoletas e os pontos de conexão que permitem isso serão removidos em uma versão futura. No passado, o projeto Qiskit era composto de elementos que estendiam um namespace compartilhado e esses pontos de conexão permitiam fazer isso. No entanto, não foi planejado que essas interfaces fossem usadas por outros pacotes. Agora que o pacote geral do Qiskit não está mais usando esse modelo de empacotamento, deixar a possibilidade dessas extensões traz mais riscos do que benefícios e, portanto, está sendo preterido para remoção futura. Se estiver mantendo um pacote que estende o namespace do Qiskit (ou seja, seus usuários importam de qiskit.x ou qiskit.providers.y), você deve fazer a transição para usar um namespace Python independente para o seu pacote. Nenhum aviso será gerado como parte disso porque não há nenhum método para injetar um aviso no nível do pacote que seria necessário para avisar os pacotes externos sobre essa alteração.

• O dicionário qiskit.__qiskit_version__ está obsoleto, pois o Qiskit é definido com um único pacote (qiskit-terra). No futuro, qiskit.__version__ será o único ponto para consultar a versão do Qiskit, como uma cadeia de caracteres padrão.

Depreciações do Transpiler

• A função get_vf2_call_limit disponível por meio do módulo qiskit.transpiler.preset_passmanagers.common foi descontinuada. Isso provavelmente afetará muito poucos usuários, pois essa função não foi explicitamente exportada nem documentada. Sua funcionalidade foi substituída e ampliada por uma função no mesmo módulo.

Circuitos obsoletos

• O método qasm() e todos os métodos de substituição de subclasses de :class:~qiskit.circuit.Instruction estão obsoletos. Não há substituto para a geração de uma string OpenQASM2 para uma instrução isolada, pois normalmente um único objeto de instrução não tem contexto suficiente para gerar completamente uma string OpenQASM2 válida. Se você estiver usando esse método atualmente, terá de usar o exportador OpenQASM2 : QuantumCircuit.qasm() para gerar o OpenQASM2 para um objeto de circuito inteiro.

Algoritmos obsoletos

• O módulo qiskit.algorithms foi descontinuado e será removido em uma versão futura. Ela foi substituída por uma nova biblioteca autônoma qiskit-algorithms , que pode ser encontrada em PyPi ou no Github aqui:

  https://github.com/qiskit-community/qiskit-algorithms

  O módulo qiskit.algorithms continuará a funcionar como antes e serão feitas correções de bugs até sua remoção futura, mas o desenvolvimento ativo de novos recursos foi transferido para o novo pacote. Se estiver confiando em qiskit.algorithms deverá atualizar seus requisitos de Python para incluir também qiskit-algorithms e atualizar as importações de qiskit.algorithms para qiskit_algorithms. Observe que esse novo pacote não inclui o código de algoritmos já obsoletos, inclusive os algoritmos baseados em opflow e QuantumInstance. Se você ainda não tiver migrado de algoritmos baseados em QuantumInstance para algoritmos baseados em primitivos, deverá seguir as diretrizes de migração em https://qisk.it/algo _migration. A decisão de migrar o módulo algorithms para um pacote separado foi tomada para esclarecer a finalidade do Qiskit e fazer uma distinção entre as ferramentas e as bibliotecas construídas sobre ele.

Depreciações de pulso

• Inicialização de um ScalableSymbolicPulse com valor complexo para amp. Essa alteração também afeta os seguintes pulsos da biblioteca:

  • Gaussian
  • GaussianSquare
  • Drag
  • Constant

  A inicialização do site amp para esses itens com um valor complexo também está obsoleta.

  Em vez disso, use dois valores flutuantes ao especificar os parâmetros amp e angle , em que amp representa a magnitude da amplitude complexa e ângulo representa o ângulo da amplitude complexa. ou seja, a amplitude complexa é dada por $\texttt{amp} \times \exp(i \times \texttt{angle})$.

• A instrução Call foi preterida e será removida em uma versão futura. Em vez disso, use a função call() do módulo qiskit.pulse.builder em um contexto de construção ativo.

Páginas Obsoletos

• A mágica do Jupyter %circuit_library_info e os objetos em qiskit.tools.jupyter.library que ele chama, por sua vez:

  • circuit_data_table
  • properties_widget
  • qasm_widget
  • circuit_digram_widget
  • circuit_library_widget

  são obsoletos e serão removidos em uma versão futura. Esses objetos foram planejados apenas para uso na construção da documentação. Eles não são mais usados lá, portanto, não são mais suportados ou mantidos.

Problemas Conhecidos

• Os circuitos que contêm expressões clássicas feitas com o módulo expr ainda não são compatíveis com os visualizadores de circuitos.

Correções de bugs

• Corrigido um bug no Channel em que a validação do índice era feita incorretamente e só gerava um erro quando o índice era não-inteiro e negativo, em vez de um dos dois.

• Foi corrigido um problema com a função transpile() e todos os gerentes de passagem predefinidos gerados por meio da função generate_preset_pass_manager() onde a saída QuantumCircuit do objeto layout do objeto de saída tinha um atributo TranspileLayout.final_layout inválido. Isso ocorreria em cenários em que a VF2PostLayout pass seria executado e encontraria um layout inicial alternativo com taxas de erro relatadas mais baixas. Ao alterar o layout inicial, o atributo final_layout nunca foi atualizado para refletir essa alteração. Isso foi corrigido para que o site final_layout esteja sempre refletindo corretamente a permutação de saída causada pelo estágio de roteamento. Corrigido #10457

• O analisador OpenQASM 2 (qasm2.load() e loads()) executado no modo strict agora emitirá corretamente um erro se uma instrução barrier não tiver argumentos. Ao ser executada no modo mais permissivo (padrão), uma instrução barrier sem argumentos continuará a causar uma barreira em todos os qubits atualmente no escopo (os qubits que uma definição de porta afeta ou todos os qubits definidos por um programa, se a instrução estiver em um corpo de porta ou no escopo global, respectivamente).

• O exportador do OpenQASM 2 (QuantumCircuit.qasm()) agora não tentará mais produzir declarações barrier que atuam em nenhum qubits. Essa declaração de barreira também não tem efeito no Qiskit, mas é inválida OpenQASM 2.

• O Qiskit pode representar instruções personalizadas que atuam em zero qubits ou em um número diferente de zero de bits clássicos. Eles não podem ser exportados para OpenQASM 2, mas anteriormente QuantumCircuit.qasm() tentava e gerava um resultado inválido OpenQASM 2. Em vez disso, um QASM2ExportError agora será levantada corretamente. Consulte #7351 e #10435.

• Foi corrigido um problema com o uso do Targets sem acoplar mapas com a passagem FullAncillaAllocation transpiler pass. Nesse caso, FullAncillaAllocation agora adicionará qubits de ancilla para que o número de qubits no DAGCircuit seja igual ao de Target.num_qubits.

• DAGCircuit.substitute_node() não mais sobrescreverá silenciosamente uma condição existente na substituição fornecida op. Se propagate_condition estiver definido como True (o padrão), um DAGCircuitError será gerado em seu lugar.

• Um circuito parametrizado que contém uma porta personalizada cuja definição tem uma fase global parametrizada agora pode vincular com êxito o parâmetro na fase global interna. Consulte #10283 para obter mais detalhes.

• Construção de um Statevector a partir de um QuantumCircuit contendo operações de zero qubit não gerará mais um erro. Essas operações conferem uma fase global ao vetor de estado resultante.

• A interface do construtor de fluxo de controle agora incluirá corretamente ClassicalRegister de instruções de switch aninhadas em seus escopos de circuito. Consulte #10398.

• Foi corrigido um problema em QuantumCircuit.decompose() em que passar um nome de circuito para a função que correspondia a um nome de porta composta não decompunha a porta se ela também tivesse um rótulo atribuído a ela. Corrigido #9136

• Foi corrigido um problema com o qiskit.visualization.plot_histogram() em que a legenda relativa não era exibida quando o conjunto de dados fornecido tinha um valor zero na primeira posição. Consulte #10158 para obter mais detalhes.

• Foi corrigida uma falha no método Target.update_from_instruction_schedule_map() acionado pelo inst_map fornecido contendo um Schedule com durações não atribuídas.

• Quando o parâmetro conditional=True for especificado em random_circuit()as operações condicionais no circuito resultante serão agora precedidas por uma medição completa no meio do circuito. Correções #9016

• Aprimoradas as anotações de tipo no método QuantumCircuit.assign_parameters() para refletir a mudança no tipo de retorno, dependendo do argumento inplace .

• Os métodos de construção de circuitos do OpenQASM 2 (QuantumCircuit.from_qasm_str() e from_qasm_file()) não apresentarão mais erros quando encontrarem uma definição gate que contenha instruções U ou CX . Consulte #5536.

• Redução da sobrecarga da passagem ConsolidateBlocks ao executar operações de matriz em todos os blocos de dois qubits em vez de criar uma instância de QuantumCircuit e passá-la para um bloco Operator. O aumento de velocidade só será aplicável na consolidação de blocos de dois qubits. Qualquer coisa maior que isso ainda será tratada pela classe Operator classe. Verifique o número 8779 para obter detalhes.

• O exportador OpenQASM 3 (qiskit.qasm3) não emitirá mais OpenQASM 3 inválido para instâncias não unitárias de Instruction não unitárias, mas, em vez disso, exibirá uma mensagem QASM3ExporterError explicando que elas ainda não são compatíveis. Esse recurso está programado para uma versão posterior do Qiskit, quando houver mais recursos de processamento clássico em toda a biblioteca.

• Corrige o problema nº 10185.

• Foi corrigido um problema com a função state_to_latex(). Anteriormente, ele produzia LaTeX inválido com arredondamento de coeficiente não intencional, o que resultava em erros ao chamar state_drawer(). Corrigido #9297.