Qiskit SDK 2.3 notas de lançamento

2.3.1

Prelúdio

O Qiskit v2.3.1 corrige vários bugs identificados desde o lançamento do Qiskit v2.3.0.

Correções de bugs

O plug-in de permutation.kms síntese integrado qiskit.synthesis agora processa corretamente as permutações de comprimento zero. Corrigido #15550.
Fixo synth_clifford_depth_lnn() para Cliffords de um único qubit. Veja o n.º 15780.
Corrigimos um erro na etapa HighLevelSynthesis do transpiler em que os estados dos qubits não eram atualizados corretamente após a síntese recursiva de uma operação. Em certos casos, isso pode resultar na geração de circuitos incorretos pela passagem.
Corrigimos um problema na função qs_decomposition() em que possíveis erros de tolerância nas rotinas internas de álgebra linear provocavam um erro grave, fazendo com que o programa travasse. Isso foi corrigido para que, nessas situações, seja lançada uma exceção apropriada QiskitError ou uma subclasse dela.

Corrigido #15610.
A síntese padrão de uma UnitaryGate porta de acesso UnitaryGate.definition e de chamada UnitaryGate.control() para portas que envolvem mais de dois qubits se baseará internamente na qs_decomposition() função. Em algumas situações, devido à tolerância de ponto flutuante inerente às rotinas de álgebra linear envolvidas na decomposição iterativa de Quantum-Shannon, o cálculo pode nem sempre ser bem-sucedido. Para evitar que esses atributos ou métodos apresentem falhas, nessas situações utiliza-se, em vez disso, Isometry a decomposição de. Embora isso resulte em uma decomposição menos eficiente, qs_decomposition() funcionará como alternativa quando qs_decomposition() falhar.
Corrigimos um bug no ParameterExpression.sympify() qual operações aritméticas assimétricas (como ** ou -) podiam ter os operandos invertidos com certas combinações de Parameter, ParameterExpression e valores numéricos. Veja o nº 15642.
Corrigido qk_obs_term() ao acessar um termo observável de identidade. Veja o nº 15536.
Corrigimos um artefato de visualização em plot_state_qsphere() que estados entrelaçados simétricos (como os estados de Bell) eram girados arbitrariamente devido ao ruído de ponto flutuante.
Corrigido QuantumCircuit.repeat() para circuitos com portas parametrizadas.

Veja o n.º 15645.
Corrige um erro que causava qpy.load() a falha do programa em circuitos criados usando QuantumCircuit.ensure_physical() o quando havia um registro criado pelo usuário chamado “ancilla”.
Corrigimos o BreakLoopOp problema em que e ContinueLoopOp eram erroneamente considerados operações de fluxo de controle em determinadas etapas do transpiler, o que poderia resultar na geração de AttributeError uma exceção. Veja o n.º 15579.
Corrige um erro que causava qpy.load() a falha do programa em circuitos criados usando SabreLayout o quando havia um registro criado pelo usuário chamado “ancilla”.
A versão mínima exigida do NumPy agora está corretamente indicada como 1.21 (em vez de 1.17 ). Essa restrição já está em vigor há várias versões devido ao uso de numpy.typing.NDArray, que foi introduzido em NumPy 1.21, de modo que o Qiskit não conseguiria ser importado com versões mais antigas do NumPy.
O exportador do OpenQASM 3 (qasm3.dumps() e dump()) agora escapará corretamente os caracteres Unicode de “números” que não sejam dígitos ASCII, quando utilizados em identificadores. Anteriormente, caracteres como os sobrescritos permaneciam na saída, o que não é válido no OpenQASM 3.
O exportador do OpenQASM 3 (qasm3.dumps() e dump()) agora escapará corretamente os identificadores cujo nome comece com um dígito ASCII.

Os métodos SparsePauliOp.from_list() e SparsePauliOp.from_sparse_list() agora inferem automaticamente o tipo de dados do coeficiente, caso o dtype argumento não seja especificado.

Por exemplo:

from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit import Parameter

theta = Parameter("theta")

# Previously required manually setting dtype=object
op_list = SparsePauliOp.from_list([("X", theta)])
op_sparse = SparsePauliOp.from_sparse_list([("X", [0], theta)], num_qubits=1)

2.3.0

Prelúdio

O Qiskit v2.3.0 é uma nova versão do Qiskit SDK.

Esta nova versão amplia significativamente a API C para transpilagem, tornando mais elementos do Target (QkTarget) disponíveis para inspeção a partir do C e permitindo que o DAGCircuit (QkDag) seja criado e manipulado. Isso permite escrever etapas de transpilador personalizadas ao compilar com o objeto libqiskit independente. Existem funções específicas para cada etapa da transpilagem na API C (por exemplo, qk_transpile_stage_layout()), para facilitar a inserção de lógica personalizada na transpilagem sem a necessidade de recriar manualmente todo o pipeline.

O desempenho e o conjunto de recursos da transpilagem para alvos tolerantes a falhas em fase inicial também foram aprimorados. Com a nova PauliProductMeasurement instrução, que representa uma transformação projetiva para uma base de produto de Pauli, o Qiskit agora oferece suporte total à transpilagem de circuitos para uma base de computação baseada em Pauli utilizando a etapa LitinskiTransformation existente. O novo método de síntese unitária, RossSelingerSynthesis, que pode ser configurado no transpiler usando unitary_synthesis_method="gridsynth", permite utilizar o algoritmo de Ross-Selinger, assintoticamente ótimo, para a síntese de Clifford+T de um único qubit. Outras melhorias incluem, por exemplo, um pass OptimizeCliffordT melhor ou o CommutativeOptimization pass, que leva em conta otimizações comutativas de circuitos baseados em Pauli.

Internamente, a representação dos ControlFlowOp objetos passou a ser nativa do Rust. Essa transformação ainda não está concluída; você poderá observar alguma queda no desempenho no Qiskit 2.3 em relação às operações de fluxo de controle. As versões futuras do Qiskit devem aprofundar ainda mais essa questão, resolvendo problemas de desempenho e de API de longa data relacionados às operações de fluxo de controle.

Observe que, a partir desta versão, o Python 3.9 não será mais suportado devido ao fim de sua vida útil em outubro de 2025, e o macOS em processadores Intel foi rebaixado para suporte de plataforma de nível 2 devido ao início do fim de vida útil da plataforma pela Apple. Todas as versões do CPython a partir do 3.10 são suportadas. Consulte Suporte ao sistema operacional para conhecer os níveis de suporte atuais das diferentes plataformas.

Haverá novos lançamentos de recursos do Qiskit na série 2.x; não esperamos lançar o Qiskit 3.0 até muito mais tarde em 2026, pois atualmente não há necessidade de mudanças significativas.

Recursos da API C

Foi adicionada a função qk_target_instruction_supported() para verificar a compatibilidade de qualquer porta ou instrução com a instância de QkTarget. Essa verificação é realizada com base no nome da instrução fornecida, nos qargs e nos parâmetros.
Foi adicionada a função qk_target_entry_set_name() para definir o nome de uma entrada de destino existente.
Foi adicionada uma nova função qk_circuit_library_quantum_volume() para gerar um circuito de modelo de volume quântico.

Adicionadas formas de iterar e verificar o mapa de portas de um QkTarget. Os seguintes métodos foram adicionados:

E a seguinte representação foi adicionada:

QkInstructionProperties: para representar o InstructionProperties.

Exemplo:

// Create Target with a mix of global and non-global gates.
QkTarget *target = qk_target_new(2);

// Create a CX entry
QkTargetEntry *cx_entry = qk_target_entry_new(QkGate_CX);
uint32_t qarg_samples[2][2] = {
    {0, 1}, {1, 0},
};
double props[2][2] = {
    {2.7022e-11, 0.00713}, {3.0577e-11, 0.00713}
};
for (int i = 0; i < 2; i++) {
    qk_target_entry_add_property(cx_entry, qarg_samples[i], 2, props[i][0], props[i][1]);
}
qk_target_add_instruction(target, cx_entry);

// Create an SX entry
QkTargetEntry *sx_entry = qk_target_entry_new(QkGate_SX);
for (int i = 0; i < 2; i++) {
    uint32_t qargs[1] = {i};
    qk_target_entry_add_property(sx_entry, qargs, 1, 35.5e-9, 0.);
}
qk_target_add_instruction(target, sx_entry);

// Create an H entry
qk_target_add_instruction(target, qk_target_entry_new(QkGate_H));

// Get the size of the 
size_t target_length = qk_target_num_instructions(target);

for (size_t op_idx = 0; op_idx < target_length; op_idx++) {
  // Allocate space for qargs and props
  uint32_t *qargs;
  uint32_t qargs_len;
  QkInstructionProperties props;

  // Retrieve the operation's name
  char *name = qk_target_op_name(target, op_idx);
  size_t num_props = qk_target_op_num_properties(target, op_idx);
  for (size_t props_idx = 0; props_idx < num_props; props_idx++) {
    // Populate qargs
    qk_target_op_qargs(target, op_idx, props_idx, &qargs, &qargs_len);
    // Populate properties
    qk_target_op_props(target, op_idx, props_idx, &props);
  }
  // Free the name string
  qk_str_free(name);
}

QkTarget agora oferece aos seus usuários a capacidade de recuperar operações diretamente dele. Os seguintes métodos foram adicionados:
E a seguinte representação foi adicionada:
- QkTargetOp: Para representar uma operação no QkTarget.

A API C agora expõe QkParam para representar parâmetros de porta, incluindo símbolos e expressões parametrizadas. A QkParam interface em si suporta cálculos simbólicos, incluindo operações aritméticas padrão e funções trigonométricas. Por exemplo:

QkParam *x = qk_symbol_new("x"); // a symbol called "x"
QkParam *y = qk_symbol_new("y"); // a symbol called "y"
QkParam *val = qk_symbol_from_double(2.0); // the value 2.0
QkParam *out = qk_symbol_zero(); // to store the final expression

// build 2 sin(x + y)
qk_param_add(out, x, y); // out = x + y
qk_param_sin(out, out); // out = sin(out)
qk_param_mul(out, out, val); // out = out * 2

qk_param_free(x);
qk_param_free(y);
qk_param_free(val);
qk_param_free(out);

A API C agora pode representar e manipular DAGCircuit como o tipo opaco QkDag. Foram adicionadas as seguintes funções relacionadas ao DAG:
Foi adicionada a QkDagNodeType enumeração para distinguir o tipo de um nó DAG. Este é o tipo de retorno de qk_dag_node_type().
Foi adicionada a QkOperationKind enumeração para distinguir os diferentes tipos de operações nativas. Este é o tipo de retorno de qk_dag_op_node_kind().
Adicionado qk_circuit_copy_empty_like() para criar uma cópia do circuito especificado, como um espelho do QuantumCircuit.copy_empty_like().
Adicionadas novas enumerações para uso com algumas funções de circuito e API DAG para especificar modos de cópia:
- QkVarsMode
- QkBlocksMode
Adicionou-se a QkDagNeighbors estrutura, que é o tipo de retorno de qk_dag_successors() e qk_dag_predecessors(), e sua função de liberação qk_dag_neighbors_clear() associada.
É adicionada uma nova estrutura, QkNeighbors, que representa o gráfico de acoplamento de dois qubits implícito em um Target. É inicializado pela função new qk_neighbors_from_target(), zerado com qk_neighbors_clear() clear e possui uma função auxiliar qk_neighbors_is_all_to_all().
Foram adicionadas as funções qk_dag_to_circuit()qk_circuit_to_dag() e para permitir a conversão de DAG para circuito e de circuito para DAG, respectivamente.
As funções qk_transpiler_pass_standalone_unitary_synthesis()qk_transpile() e agora permitem sintetizar objetos com 3 ou UnitaryGate mais qubits em um circuito. No Qiskit 2.2, isso não era compatível, pois o algoritmo de síntese qs_decomposition() subjacente usado para a síntese unitária de 3 ou mais qubits havia sido escrito anteriormente em Python; mas agora que foi portado para Rust, essa funcionalidade está disponível a partir de C.

Adicionadas novas funções para executar etapas do transpiler à API C. Essas funções são:

função C	Estágio do transpilador
`qk_transpile_stage_init()`	Fase de inicialização
`qk_transpile_stage_layout()`	Fase de diagramação
`qk_transpile_stage_routing()`	Etapa de roteamento
`qk_transpile_stage_translation()`	Fase de tradução
`qk_transpile_stage_optimization()`	Fase de otimização

Essas funções são usadas para executar essas etapas a partir do gerenciador de passagens predefinido em um QkDag objeto. O objetivo dessas funções é permitir fluxos de trabalho de transpilagem composíveis a partir de C quando combinadas com passagens de transpilador personalizadas.

Foi adicionada uma nova função qk_transpile_layout_generate_from_mapping() que serve para gerar um layout personalizado QkTranspileLayout com um layout inicial definido a partir de uma matriz de mapeamento. O objetivo desta função é permitir a criação de um objeto de layout para passagens personalizadas do transpiler de layout.
As duas formas de seleção de layout “perfeito” por meio do algoritmo de isomorfismo de subgrafo VF2 agora estão disponíveis como passagens de transpilador independentes na API C. Essas funções são:
- qk_transpiler_pass_standalone_vf2_layout_average()
- qk_transpiler_pass_standalone_vf2_layout_exact()
Eles diferem na forma como a direcionalidade e os conjuntos de portas das interações são tratados; exact requer que as correspondências suportem diretamente todas as portas de forma nativa, enquanto average espera que novas passagens do transpilador decomponham as portas no conjunto suportado de um determinado qubit ou link.

Essas funções utilizam uma versão encapsulada da configuração VF2 (QkVF2LayoutConfiguration), que possui métodos setter para cada uma das opções. Isso inclui permitir o acesso à nova forma de dois limites do call_limit argumento.

Recursos dos circuitos

Foi adicionada uma nova classe de instrução, PauliProductMeasurement, que representa uma medição projetiva conjunta em múltiplos qubits, em que a observável medida é um produto tensorial de operadores de Pauli. O resultado dessa medição é um único valor próprio, seja $+1$ ou $-1$ , indicando o estado próprio do produto de Pauli.

Para obter mais informações, consulte A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery, de Daniel Litinski.

Um PauliProductMeasurement pode ser instanciado a partir de um Pauli, em que o Pauli pode incluir uma fase de $-1$ , mas não de $i$ ou $-i$ . A instrução possui o mesmo número de qubits que o Pauli e um único bit clássico.

Como um exemplo:
```
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import Pauli
from qiskit.circuit.library import PauliProductMeasurement

ppm = PauliProductMeasurement(Pauli("XZ"))

qc = QuantumCircuit(6, 2)
qc.append(ppm, [4, 1], [1])
```
Um novo QuantumCircuit.to_dag() método oferece agora uma forma prática de utilizar circuit_to_dag().
ParameterExpression agora possui um num_parameters atributo que é igual ao tamanho do seu parameters conjunto, mas calculado com menor sobrecarga.

OpenQASM Características

O exportador OpenQASM 2(qasm2.dumps()) agora suporta a geração de blocos simples de IfElseOp uma única instrução, caso a condição seja um teste simples de igualdade entre um registro e um inteiro. Isso corresponde ao que a linguagem de 2- OpenQASM s é capaz de representar.

Recursos do QPY

A versão 17 do QPY agora inclui formatos de serialização para SparseObservable objetos quando utilizados como parâmetros de objetos. Em particular, isso permite serializar PauliEvolutionGate objetos que utilizam internamente esse operador, e a carga útil do portão de evolução é atualizada.

Recursos de informação quântica

Adicionado Statevector.from_circuit() como um espelho de Operator.from_circuit(). Isso permite instanciar diretamente um Statevector no espaço dos qubits virtuais, mesmo para circuitos que foram transpilados para um espaço de qubits físicos.
Melhorou-se o desempenho de Clifford.dot() e de Clifford.compose() quando chamados com front=True e um QuantumCircuit contendo apenas portas de Clifford. Anteriormente, o circuito era primeiro totalmente incorporado a um Clifford objeto e, em seguida, os dois objetos eram combinados. Agora, a base Clifford é atualizada iterativamente, o que é significativamente mais rápido para circuitos pequenos.
Adicionado o PauliLindbladMap.parity_sample() método. Este método é muito semelhante ao método já PauliLindbladMap.signed_sample() existente; no entanto, ele utiliza uma convenção de sinal mais consistente com o restante do Qiskit e, por isso, é o método preferencial a ser utilizado daqui em diante. Ele possui argumentos opcionais adicionais para aplicar escalonamentos às taxas durante a amostragem, sem modificar a instância.
Várias das funções de quantum_info “predicados”, como is_identity_matrix(), foram otimizadas para evitar alocações desnecessárias de matrizes.

Recursos de síntese

Adicionado gridsynth_rz(), que constrói um circuito quântico de um único qubit que aproxima uma rotação RZ com um ângulo especificado. O algoritmo é descrito no artigo “Optimal ancilla-free Clifford+T approximation of z-rotations”, de Neil J. Ross e Peter Selinger, e está implementado em https://github.com/qiskit-community/rsgridsynth.
Adicionado gridsynth_unitary(), que constrói um circuito quântico de um único qubit que aproxima uma determinada matriz unitária de um único qubit. O algoritmo funciona decompondo a matriz unitária em uma rotação RZ, uma rotação RX e outra rotação RZ, e aplicando o algoritmo de Ross-Selinger a cada uma dessas três rotações.
O algoritmo geral de qs_decomposition() síntese unitária foi reescrito em Rust, melhorando significativamente o desempenho em tempo de execução da função.

Recursos do Transpiler

Foi adicionada uma nova etapa do transpiler, CommutativeOptimization, que realiza o cancelamento e a fusão de portas, aproveitando as relações de comutatividade. O passe unifica e amplia as funcionalidades tanto de quanto CommutativeCancellation de CommutativeInverseCancellation.

Especificamente, o passe:
- Cancela pares de portas inversas, incluindo pares que são inversos até uma fase global (ajustando a fase global, se necessário).
- Tenta mesclar portas consecutivas quando possível, por exemplo, sequências de portas RZ, portas RX, rotações de Pauli e assim por diante.
Foi adicionada uma nova opção, fallback_on_default, à etapa do UnitarySynthesis transpiler. Essa opção se aplica quando a passagem é chamada com um plug-in de síntese diferente do padrão, especificado por meio do argumento method.

Por padrão, o plug-in especificado é usado para sintetizar cada operação unária no circuito (desde que o plug-in seja aplicável; por exemplo, ele não será executado se não suportar o número de qubits sobre os quais a operação unária está definida). Se o plug-in não conseguir sintetizar o operador unitário e retornar None, o operador unitário original permanece inalterado no circuito. Quando fallback_on_default é definido como True, o pass invocará DefaultUnitarySynthesis o plugin sempre que o método especificado falhar.

Esse recurso é particularmente útil quando plug-ins personalizados se destinam a lidar apenas com um subconjunto de todas as unidades: os usuários podem confiar em sua lógica personalizada quando ela se aplica e usar a síntese padrão quando não se aplica.
Foi adicionado um novo plug-in de síntese unitária, RossSelingerSynthesis, que sintetiza portas unitárias de um único qubit utilizando o algoritmo de Ross-Selinger e produz um circuito quântico de um único qubit composto por portas de Clifford, $T$ e $T^\dagger$ .

O plug-in é chamado pela etapa do UnitarySynthesis transpiler quando o parâmetro method é definido como "gridsynth".
Ao transpilá-lo para a base Clifford+T, a etapa UnitarySynthesis do transpiler agora utiliza, por padrão, um algoritmo de síntese Clifford+T para aproximar operadores unitários de um único qubit.

Da mesma forma, o DefaultUnitarySynthesis plugin agora utiliza o mesmo algoritmo de síntese Clifford+T para aproximar operadores unitários de um único qubit.
Um novo DAGCircuit.to_circuit() método oferece agora uma forma prática de utilizar dag_to_circuit().
Foi adicionada uma nova etapa de SubstitutePi4Rotationstranspilador que converte portas de RYGate rotação de RXGate um único qubit RZGate, cujos ângulos são múltiplos inteiros de $\pi/4$ , em conjuntos discretos de portas TdgGate de TGate Clifford. Observe que os múltiplos ímpares de $\pi/4$ requerem um único TGate e TdgGate, bem como algumas portas de Clifford, enquanto os múltiplos pares de $\pi/4$ , ou, de forma equivalente, os múltiplos inteiros de $\pi/2$ , podem ser escritos utilizando apenas portas de Clifford.
A etapa do LitinskiTransformation transpiler foi ampliada para lidar com medições. Assim, a transformação agora se aplica a um circuito que contém portas de rotação RZ de um único qubit de Clifford (incluindo $T$ e $T^\dagger$ ) e medições Z padrão, e move as portas de Clifford para o final do circuito. Nesse processo, ele transforma as rotações RZ em rotações de Pauli de produto (implementadas como PauliEvolutionGate portas) e transforma as medições Z em medições de Pauli de produto (implementadas por meio de PauliProductMeasurement instruções).
A etapa de otimização do OptimizeCliffordT transpiler foi significativamente aprimorada e reimplementada em Rust.

Esta passagem realiza uma otimização de peephole em circuitos expressos usando o conjunto de portas Clifford+T. Mais precisamente, ele colapsa todas as cadeias de portas de qubit único contendo Clifford+T em um uso mínimo de $T$ (ou $T^\dagger$ ). A passagem é executada em uma cadeia em tempo proporcional ao número de portas na cadeia.
Adicionado WrapAngles.DEFAULT_REGISTRY contendo o registro padrão para WrapAngles. Este novo atributo substitui o anterior WRAP_ANGLE_REGISTRY, e recomendamos que os usuários finais adotem o novo formato o mais rápido possível.
Os DAGCircuit.topological_op_nodes() métodos DAGCircuit.topological_nodes() e agora aceitam um argumento reverse booleano. Quando configurados para True, os métodos geram nós em ordem topológica inversa, partindo das saídas do circuito em direção às entradas. Isso oferece uma maneira direta e eficiente de percorrer um DAG de trás para frente sem a sobrecarga de reverter explicitamente a lista de nós retornada pelas funções, criando um novo DAG com a estrutura invertida usando DAGCircuit.reverse_ops().
O CommutationChecker agora permite verificações eficientes de comutação entre as portas baseadas PauliGateem Pauli, PauliEvolutionGate e PauliProductMeasurement verificando se os operadores de Pauli geradores comutam. Isso permite otimizações, em particular para circuitos no formato de computação baseado em Pauli, expressos em termos de evoluções de Pauli e medições de produtos de Pauli. Observe que as comutações entre essas portas baseadas em Pauli e outras portas padrão ainda não são tratadas com a mesma eficiência.
Foi adicionado um novo argumento, matrix_max_num_qubits, a CommutationChecker.commute(). Isso permite limitar o tamanho das instruções para as quais o verificador de comutação pode calcular a representação matricial, cujo custo computacional é exponencialmente elevado. Este novo argumento permite distinguir entre o limite de tamanho das instruções a serem processadas (definido por meio max_num_qubits de, que agora é None o padrão, o que significa que não há limite) e o limite de tamanho da matriz.
As funções generate_preset_pass_manager() e transpile() agora levam em unitary_synthesis_method conta o argumento ao compilar para o conjunto de bases Clifford+T, permitindo assim a invocação de plug-ins personalizados de síntese unitária.
VF2Layout e VF2PostLayout agora rastreia pontuações parciais de layouts candidatos durante a correspondência de isomorfismos de subgrafos. Isso não tem efeito significativo quando não há um layout perfeito a ser encontrado, mas pode reduzir drasticamente o custo da avaliação de layouts para escolher o melhor candidato em casos de alta simetria.
O call_limit argumento de VF2Layout e agora VF2PostLayout pode ser uma tupla de dois elementos, em que o primeiro elemento é usado antes de se encontrar a primeira correspondência e, em seguida, o limite passa a ser o segundo elemento. Este é um limitador de tempo de execução mais confiável do que o max_trials argumento, agora que os layouts são avaliados dinamicamente com uma poda mais agressiva.

Recursos diversos

Foi adicionada a capacidade de calcular o valor esperado de a SparseObservable a partir de cadeias de bits amostradas na base Z, utilizando a sampled_expectation_value() função.

Notas da Atualização

ConsolidateBlocks agora lê uma PropertySet chave ConsolidateBlocks_qubit_map ao entrar. Essa chave e seu valor não são públicos e não devem ser lidos ou modificados por outras senhas.

Notas sobre a atualização da API C

qk_target_entry_new_fixed() possui um parâmetro name adicional para definir o nome da entrada de destino. As entradas de ângulo fixo quase sempre exigem que o nome da porta padrão seja substituído para funcionar corretamente.

Notas sobre atualização de circuitos

Os nomes dos circuitos produzidos como definições de portas da biblioteca de circuitos padrão agora estão definidos como None. Anteriormente, esses circuitos tinham o mesmo nome do portão, tornando muito fácil construir portões opacos com nomes correspondentes a um portão padrão. Isso viola uma suposição comum no Qiskit, onde os nomes padrão dos portões devem ser únicos.
A representação interna de ControlFlowOps mudou quando foram adicionados a a QuantumCircuit ou DAGCircuit. O objeto armazenado no circuito e retornado em um acesso futuro não será necessariamente a mesma instância adicionada ao circuito. Os usuários não devem tentar alterar nenhum objeto in-place depois que ele tiver sido adicionado a um circuito. Isso provavelmente corromperá o circuito, seja ele um fluxo de controle ou outro objeto.

Assim como acontece com todas as mutações in-place em objetos Python armazenados em um QuantumCircuit ou DAGCircuit, é necessário reatribuir a instrução ao circuito para que o espaço Rust reconheça as modificações. Por exemplo, ao adicionar anotações a um BoxOp objeto que já está em um circuito, uma passagem do transpiler deve garantir o uso de update DAGCircuit.substitute_node() para atualizar o objeto no espaço Rust:
```
from qiskit.circuit import QuantumCircuit, Annotation

class MyAnnotation(Annotation):
    namespace = "my"

qc = QuantumCircuit(2)
with qc.box():
    qc.cx(0, 1)
dag = qc.to_dag()

# Modifications to the box's annotations in-place require
# writing back the information to Rust space.
box_node = next(dag.topological_op_nodes())
box_node.op.annotations.append(MyAnnotation())

# Write back the operation.
dag.substitute_node(box_node, box_node.op)
```
Espera-se que o desempenho do transpiler na presença de ControlFlowOp instruções, incluindo BoxOp, seja temporariamente inferior no Qiskit 2.3, à medida que fazemos a transição da representação interna do fluxo de controle de sua versão anterior, centrada em Python, para uma versão nativa do Rust. Esperamos que o desempenho melhore novamente em uma versão futura do Qiskit e que isso nos permita resolver deficiências de longa data na API relacionadas às passagens do transpiler que atuam sobre operações de fluxo de controle.
Os blocos de ControlFlowOp instâncias não rastrearão mais name os metadata campos. Esses elementos já não podiam ser definidos por meio da interface do construtor de fluxo de controle, e sua existência era um detalhe de implementação não intencional, e não uma API planejada.
O método Gate.control() não retorna mais um AnnotatedOperation quando o argumento annotated é definido como True e há uma classe nativa de porta controlada disponível. Essa alteração está em consonância com a forma como o argumento annotated é utilizado na biblioteca de circuitos padrão e permite decomposições mais eficientes das portas com anotações de controle. Os portões afetados são:
- Portas controladas individualmente H``CZ , S, Sdg U3, Y, Z, SX, RX, RY,, RZ, Swap e;
- Porta com Z controle duplo;
- portas controladas MCMT arbitrariamente Phase, CPhase, MCPhase, U1 CU1,, MCU1 e.
O valor padrão do argumento annotated em agora QuantumCircuit.control() é None em vez de False. Isso não afeta os circuitos propriamente ditos, mas está de acordo com o valor padrão utilizado em toda a biblioteca annotated de circuitos.

Notas de atualização do QPY

A versão padrão do QPY (QPY_VERSION) usada no agora qpy.dump() é a 17.

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

Melhorou-se o desempenho dos Statevector.expectation_value() operadores de Pauli de identidade total, utilizando a implementação otimizada para o caso geral em vez de um atalho específico que apresentava baixo desempenho à medida que o número de qubits aumentava.

Notas sobre a atualização do Transpiler

Os limites máximos de chamadas e tentativas para a execução com correspondência exata de VF2PostLayout em optimization_level=3 foram reduzidos para evitar tempos de execução excessivos em casos de circuitos de tentativa altamente simétricos mapeados para mapas de acoplamento de grande dimensão.
O local padrão para o registro padrão da etapa do WrapAngles transpiler agora é WrapAngles.DEFAULT_REGISTRY. O caminho anterior, com várias WRAP_ANGLE_REGISTRY camadas de aninhamento, continuará funcionando por motivos de compatibilidade com versões anteriores, mas recomendamos que os pacotes derivados utilizem o novo local. O caminho anterior era um descuido no Qiskit 2.2 e percorre módulos que nunca foram destinados a fazer parte da API pública.
Embora a interface para VF2Layout e VF2PostLayout continue logicamente a mesma, o max_trials argumento agora tem muito menos efeito como limitador de tempo de execução, exceto quando definido com o valor 1. Isso ocorre porque, com o novo algoritmo de pontuação e poda em tempo real utilizado internamente pela classe, layouts “completos” são encontrados com muito menos frequência, e a contagem de “tentativas” só aumenta quando é encontrado um novo layout com uma taxa de erro melhor do que a do anterior. Em vez disso, você deve usar call_limit como limitador determinístico de tempo de execução; onde max_trials mede os layouts completos encontrados, call_limit mede as extensões de layouts parciais.

Notas diversas sobre atualizações

A versão mínima suportada do Python agora é 3.10, após o fim da vida útil do Python 3.9 em outubro de 2025 e avisos de descontinuação no Qiskit desde a versão 2.1.
O suporte para macOS x86-64 (Intel) foi rebaixado do nível 1 para o nível 2. O Qiskit continuará fornecendo rodas testadas e pré-compiladas para essa plataforma, mas os testes serão realizados apenas no momento do lançamento, e não a cada alteração. Isso pode causar atrasos no lançamento das rodas para esta plataforma.

Essa mudança foi feita porque a Apple começou a descontinuar a plataforma, e a equipe do Qiskit não tem mais os recursos de desenvolvedores ou CI necessários para continuar com o suporte de nível 1. Só podemos oferecer suporte ao macOS x86-64 enquanto o GitHub continuar a fornecer executores para ele, e esperamos que esse suporte seja removido no segundo semestre de 2027.

Descontinuidades da API C

A função qk_transpiler_pass_standalone_vf2_layout() está obsoleta, pois os usuários devem agora usar qk_transpiler_pass_standalone_vf2_layout_average(). O novo nome da função descreve melhor a heurística de pontuação, e a API permite o acesso encapsulado a todo o novo objeto de configuração, incluindo a forma de dois limites de call_limit.

Essa descontinuação não é totalmente necessária para os usuários, mas com a API C ainda explicitamente instável, estamos usando isso como um teste para gerenciar descontinuações e avisos específicos do compilador na API C, antes de alcançarmos garantias de estabilidade.

Circuitos obsoletos

Desde o Qiskit 1.0, os métodos Gate.control() e QuantumCircuit.control() aceitam o argumento, annotated que pode ser, True``False ou None. Atualmente, um portão controlado é representado por meio de uma classe dedicada a portões controlados, quando ela existe, independentemente do valor de annotated; por exemplo, uma versão com dois portões controlados de um XGate é um CCXGate. Se não existir uma classe dedicada para portas controladas, a porta controlada é representada como um ControlledGate quando annotated=False e como um AnnotatedOperation quando annotated=True. O valor padrão annotated=None é tratado exatamente da mesma forma que False.

No Qiskit 3.0, não permitiremos mais a configuração annotated=None e, em vez disso, alteraremos a configuração padrão para annotated=True. Isso é recomendado, pois adia a construção do circuito controlado da construção do circuito para o transpiler e permite otimizações adicionais do portão controlado, geralmente levando a circuitos de maior qualidade (especialmente para circuitos hierárquicos).

No entanto, você ainda poderá definir annotated=False explicitamente para preservar o comportamento anterior.

Depreciações do Transpiler

O formato de serialização legado usado em SolovayKitaevDecomposition, que se baseava na conversão das aproximações básicas para o formato Pythondict, foi descontinuado. O processo de carregamento representa uma potencial vulnerabilidade de segurança e só deve ser utilizado com arquivos confiáveis. O novo formato de serialização evita essa vulnerabilidade. As funções para gerar o formato antigo, generate_basic_approximations(), e carregá-lo, SolovayKitaevDecomposition.load_basic_approximations() e no inicializador de SolovayKitaevDecomposition, foram descontinuadas. Em vez disso, use SolovayKitaevDecomposition.save_basic_approximations() para gerar um formato que possa ser carregado com segurança no inicializador da classe.

Alterações no sistema de compilação

Ao compilar ou empacotar o Qiskit a partir do código-fonte, a versão necessária do setuptools agora é, no mínimo, a versão 77.0 (lançada em março de 2025). Isso serve para dar suporte às novas especificações de metadados de licença do PEP 639. Essa dependência está especificada nos requisitos de compilação, portanto, nenhuma ação manual deve ser necessária.

Correções de bugs

Corrige a implementação de __deepcopy__() em QuantumCircuit que não realizava uma cópia profunda dos parâmetros do circuito. Consequentemente, a alteração de um elemento BoxOp em um circuito copiado não afeta mais o circuito original.
DAGCircuit.apply_operation_back(), apply_operation_back() e agora circuit_to_dag() irá adicionar novas arestas em uma ordem determinística. Esse comportamento anterior poderia fazer com que certas etapas do transpiler (como SabreSwap) percorressem o DAG em ordens não determinísticas.
DAGCircuit.apply_operation_front() não é mais possível inserir loops recursivos inválidos ao lidar com nós que incluem condições clássicas.
Corrigimos um problema que ocorria Optimize1qGatesDecomposition quando o passe era inicializado com um Target que contivesse portas do tipo 1q com parâmetros de ângulo fixos. Anteriormente, a passagem poderia gerar portas fora do destino, pois não verificava se a porta no destino suportava valores de parâmetros arbitrários. Corrigido #14743.
Corrigimos um comportamento incorreto na BasisTranslator passagem em que uma porta de múltiplos qubits dentro de um ControlFlowOp bloco utilizava os índices locais dos qubits em vez de usar os índices absolutos do circuito de origem.
Corrigida a reutilização da mesma ConsolidateBlocks instância em vários circuitos, incluindo chamadas com transpile() mais de um circuito e sem paralelização baseada em processos. Um bug introduzido no Qiskit 2.2.2 fazia com que o pass entrasse em pânico ou gerasse uma saída inválida se a mesma instância fosse reutilizada em circuitos diferentes.
A etapa do ConsolidateBlocks transpiler agora avaliará corretamente se uma determinada porta é suportada pelo hardware durante a recursão nas operações de fluxo de controle.
qpy.dump() agora é capaz de gravar em .gz arquivos abertos usando o módulo da gzip biblioteca padrão com versões do QPY 16 ou superiores. Consulte o n.º 15157 para obter mais detalhes.
Corrigimos os métodos MCPhaseGate.inverse() e MCU1Gate.inverse() para preservar os estados de controle das portas de controle aberto ao calcular suas inversas.
ConsolidateBlocks agora retornará uma exceção do tipo " Python " em vez de entrar em pânico ao detectar uma análise inválida ou desatualizada nas chaves legacy run_list``block_listPropertySet ou
Optimize1qGatesDecomposition agora gerará um TranspilerError em vez de um panic de espaço em Rust ao tentar ser executado em um circuito que seja grande demais para o Target.
Corrigimos um problema com pickle o suporte ao, SabreSwap no qual uma SabreSwap instância apresentava um erro ao ser serializada após a execução do SabreSwap.run() método. Corrigido #15071.
Os passos de programação e ALAPScheduleAnalysis agora ASAPScheduleAnalysis processarão corretamente os circuitos que não contêm operações. Antes, eles exibiam uma mensagem de erro TranspilerError afirmando erroneamente que “Não foram fornecidas durações”. Corrigido #15145.
Corrigimos um problema em que is_unitary() não respeitava adequadamente os valores de tolerância de entrada ao verificar se um operador é unitário. O método agora utiliza corretamente os parâmetros rtol e atol fornecidos ao simplificar o operador e verificar se ele é igual à identidade. Isso corrige o #14107.
Corrigido um erro na etapa UnitarySynthesis do transpiler, quando ele é chamado com um plugin de síntese não padrão (especificado via method) que suporta basis_gates mas não target. Agora, o passagem transmite corretamente os gate de base do target para o plugin.
Corrigimos uma falha na janela de texto do circuito, que podia ocorrer quando blocos de circuito dentro de operações de fluxo de controle eram definidos em registros diferentes dos do circuito externo. Essa situação poderia ocorrer, por exemplo, ao anexar ControlFlowOp operações diretamente ou em circuitos após a transpilagem.
Corrigida a compatibilidade com a serialização PauliEvolutionGate usando operadores do tipo SparseObservable, ao utilizar a versão 17 do QPY.
Corrigimos uma incompatibilidade em QkTargetOp que o tamanho da matriz armazenada em QkTargetOp.params não correspondia ao número exposto por QkTargetOp.num_params. Os parâmetros curinga agora são representados por NAN, e o comprimento da matriz será sempre QkTargetOp.num_params. Esse bug só estava presente no 2.3.0rc1.
Corrigimos uma regressão na representação clássica de Value expressões do tipo Uint com largura superior a 64 bits. Anteriormente, o valor das expressões com esses tipos era involuntariamente convertido internamente para um valor de ponto flutuante do tipo double, resultando em perda de precisão.
Agora, a HighLevelSynthesis instrução selecionará corretamente a métrica de otimização de acordo com o conjunto de bases: contagem de portas de dois qubits para bases contínuas e contagem de T para bases Clifford+T. Anteriormente, essas informações não eram transmitidas corretamente, resultando em contagens de T inferiores às esperadas.
Corrigimos a caixa de texto do circuito para que as instruções do circuito com fios clássicos sejam desenhadas em camadas separadas.
A multiplicação de matrizes (@) entre Operator e Statevector aplicará agora o operador ao estado e retornará o resultado Statevector.
Corrigimos um erro na etapa ElidePermutations do transpiler que causava uma falha ao processar permutações de um único qubit.
Corrigimos um possível problema de impasse ao executar passagens de layout, como SabreLayout com conectividade desarticulada no Target e em um contexto de multiprocessamento, ao executar PassManager.run() ou transpile() com mais de um circuito. No Linux, esse é o comportamento padrão ao executar PassManager.run() ou transpile() com mais de um circuito; em todas as outras plataformas, é necessário ativar manualmente o uso de um contexto de multiprocessamento.

Isso ocorreu devido a um problema subjacente no CPython rastreado ao python/cpython#84559 misturar multiprocessamento e multithreading. Normalmente, o Qiskit protege contra a mistura dos dois métodos de paralelismo, mas no caso do tratamento de gráficos de conectividade disjuntos, essa proteção estava faltando em torno do código Rust multithreaded.
O método Statevector.to_dict() passará a respeitar seu argumento decimals de palavra-chave, que antes era ignorado.
Corrigimos um problema na função timeline_drawer() de visualização que causava um erro ao visualizar um circuito programado a partir de um destino que possuísse portas parametrizadas com duração definida.
Geração de rótulos fixos para operadores PauliEvolutionGate SparseObservable com. Agora, as etiquetas exibem os operadores de Pauli com índices de qubits (por exemplo, "X0 X2") em vez do formato de sequência concatenada (por exemplo, "XX"), o que melhora a clareza na distinção entre diferentes operadores.
Pauli.evolve() agora lida corretamente com circuitos quânticos que contêm certas portas de rotação parametrizadas, quando o ângulo é um múltiplo de $\pi/2$ , por exemplo: RZGate(math.pi/2) ou RZZGate(math.pi/2). Anteriormente, elas não eram reconhecidas como portas de Clifford, o que gerava um erro.
BasePassManager não substitui mais os resultados falsos, mas válidos, das passagens pelo programa de entrada original. Um retorno de " 0pass", False ou outro valor falso, agora será mantido, e apenas "failure None " indicará falha.
QuantumCircuit.compose() agora remapeará corretamente quaisquer variáveis e intervalos usados nas Delay instruções quando o var_remap argumento for especificado.

Esta página foi útil?

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