Limites

compute_forward_bounds(circuit, noise_model_paulis, /, observable, *, evolution_max_terms=1000000, eigval_max_qubits=14, atol=1e-08, atol_simplify=1e-08, atol_eigenvalue=1e-08, **kwargs)

Calcule os limites do comutador de tempos desiguais obtidos por evolução direta.

Começando pelo final do circuito, calcule os limites do comutador de tempo desigual, obtidos por evolução direta, para todos os termos de erro de Pauli de cada camada sujeita a ruído no circuito alvo.

Ou seja, calcule-se $\| \left[ E_F, A_F \right] \|_2$ para todos os termos de erro, $E_F$, onde $A_F$ é a variável-alvo observable a ser medida em circuit.

Os termos de erro, $E_I$, são determinados por noise_model_paulis. Este dicionário mapeia identificadores de modelos de ruído (samplomatic.InjectNoise.ref) para uma lista de termos de erro de Pauli. Os termos correspondentes serão utilizados sempre que for encontrado um BoxOp com uma InjectNoise anotação correspondente durante a iteração sobre circuit.

Parâmetros

• circuit (QuantumCircuit) – o circuito de destino.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – os termos de erro de Pauli a serem considerados para cada modelo de ruído.
• observable (Pauli |PauliList |SparseObservable |SparsePauliOp) – a grandeza observável alvo a ser medida no final do circuito.
• evolution_max_terms (int) – o número máximo de termos do operador a serem acompanhados durante a evolução.
• eigval_max_qubits (int) – o número máximo de qubits de um comutador para o qual ainda se tentará calcular o autovalor. Quando esse valor é excedido, o limite é aproximado por meio de uma desigualdade triangular mais simples e menos restritiva.
• atol (float) –** OBsoleto —** use e atol_simplify em atol_eigenvalue vez disso!
• atol_simplify (float) – a tolerância absoluta utilizada para eliminar termos do comutador. Aumentar essa tolerância resultará em um maior truncamento dos termos do comutador, tornando o cálculo de seu valor próprio mais rápido, mas menos preciso.
• atol_eigenvalue (float) – a tolerância absoluta utilizada para detectar a convergência do valor próprio do comutador. Aumentar essa tolerância resultará em um valor próprio menos preciso, conforme calculado pelo solucionador iterativo de valores próprios de Davidson.
• kwargs – quaisquer argumentos-chave adicionais serão encaminhados para compute_bounds().

Retorna

O limite do comutador de tempo desigual.

Aumentos

NotImplementedError – quando a expressão contém observable mais de um termo de Pauli. Se você se deparar com essa situação, precisará chamar essa função separadamente para cada alvo Pauli.

Tipo de retorno

dict [ str, PauliLindbladMap ]

tighten_with_speed_limit(bounds, circuit, noise_model_paulis, /, observable)

Restrinja os limites fornecidos por meio de restrições à velocidade de propagação da informação.

Inspirada nas ideias subjacentes aos limites de Lieb-Robinson, essa função aproveita os limites da velocidade de propagação da informação para aprimorar os limites do comutador de tempos desiguais, calculados previamente por evolução direta (ver também compute_forward_bounds()).

Parâmetros

• bounds (dict[str, PauliLindbladMap]) – os limites do comutador de tempo desigual, calculados anteriormente por evolução para a frente.
• circuit (QuantumCircuit) – o circuito de destino.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – os termos de erro de Pauli a serem considerados para cada modelo de ruído.
• observable (Pauli |PauliList |SparseObservable |SparsePauliOp) – a grandeza observável alvo a ser medida no final do circuito.

Retorna

Uma versão mais rigorosa dos limites do comutador em tempo desigual.

Aumentos

• NotImplementedError – quando a expressão contém observable mais de um termo de Pauli. Se você se deparar com essa situação, precisará chamar essa função separadamente para cada alvo Pauli.
• ValueError – ao se deparar com um portão que atua sobre mais de 2 qubits.

Tipo de retorno

dict [ str, PauliLindbladMap ]

compute_backward_bounds(circuit, noise_model_paulis, /, *, evolution_max_terms=1000000, **kwargs)

Calcule os limites do comutador em tempos desiguais, obtidos por evolução retroativa.

Começando pelo início do circuito, calcule os limites do comutador de tempo desigual, obtidos por evolução para trás, para todos os termos de erro de Pauli de cada camada com ruído no circuito alvo.

Ou seja, calcule $\| \left[ E_I, \rho_I \right] \|_1$ (utilizando a norma 1 de Schatten, também conhecida como norma nuclear) para todos os termos de erro, $E_I$, onde $\rho_I$ é considerado o estado totalmente nulo, $\ket{0 \ldots 0}$, em todos os qubits ativos em circuit.

Os termos de erro, $E_I$, são determinados por noise_model_paulis. Este dicionário mapeia identificadores de modelos de ruído (samplomatic.InjectNoise.ref) para uma lista de termos de erro de Pauli. Os termos correspondentes serão utilizados sempre que for encontrado um BoxOp com uma InjectNoise anotação correspondente durante a iteração sobre circuit.

Parâmetros

• circuit (QuantumCircuit) – o circuito de destino.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – os termos de erro de Pauli a serem considerados para cada modelo de ruído.
• evolution_max_terms (int) – o número máximo de termos do operador a serem acompanhados durante a evolução. (Se o operador exceder esse tamanho, os termos menores serão truncados).
• kwargs – quaisquer argumentos-chave adicionais serão encaminhados para compute_bounds().

Retorna

Os limites do comutador de tempo desigual obtidos por evolução reversa.

Tipo de retorno

dict [ str, PauliLindbladMap ]

merge_bounds(circuit, forward_bounds, backward_bounds, /, noise_rates=None, *, is_clifford_circuit=False)

Mesclar os limites anterior e posterior.

A camada na qual ocorre a transição do uso de limites traseiros para o uso de limites dianteiros será a mesma para todos os qubits. Isso é determinado levando-se em conta o conhecimento fornecido noise_rates. Caso esses dados não sejam fornecidos, presume-se que as taxas de ruído sejam uniformes. Embora essa seja uma suposição irrealista, visualizar os limites resultantes da fusão ainda pode ser útil.

Parâmetros

• circuit (QuantumCircuit) – o circuito de destino.
• forward_bounds (dict[str, PauliLindbladMap] | None) – os limites para a frente (ver também compute_forward_bounds()).
• backward_bounds (dict[str, PauliLindbladMap] | None) – os limites inferiores (ver também compute_backward_bounds()).
• noise_rates (dict[str, PauliLindbladMap | None] | None) – as taxas de ruído aprendidas no backend de destino.
• is_clifford_circuit (bool) – se o circuito-alvo é totalmente de Clifford.

Retorna

Os limites combinados.

Aumentos

• ValueError – quando os dois limites fornecidos são None.
• KeyError – quando o bounds contém uma chave InjectNoise.modifier_ref que não aparece no de destino ou circuit cujo não InjectNoise.ref é encontrado.
• ValueError – se os termos de Pauli do modelo de ruído, cujos limites são calculados para um determinado, InjectNoise.modifier_ref não coincidirem entre o forward_bounds e o backward_bounds.
• NotImplementedError – quando é is_clifford_circuit True.

Tipo de retorno

dict [ str, PauliLindbladMap ] | None

compute_local_scales(circuit, bounds, /, noise_rates, *, sampling_cost_budget=inf, bias_tolerance=0.0)

Calcula o argumento local_scales de um Samplex.

Esse argumento local_scales é usado para especificar quais termos de erro específicos devem ser atenuados.

É bias_tolerance necessário especificar sampling_cost_budget ou. O primeiro estabelece um limite máximo para o custo da amostragem, enquanto o segundo estabelece um limite máximo para o viés remanescente que pode ser tolerado.

Parâmetros

• circuit (QuantumCircuit) – o circuito de destino.
• bounds (dict[str, PauliLindbladMap]) – os limites do cone de luz sombreados.
• noise_rates (dict[str, PauliLindbladMap | None]) – as taxas do modelo de ruído treinado.
• sampling_cost_budget (float) – o custo máximo de amostragem permitido.
• bias_tolerance (float) – o desvio máximo que pode ser tolerado.

Retorna

• o dicionário local_scales a ser fornecido como entrada direta para o samplomatic.samplex.Samplex.inputs().
• o custo de amostragem ( $\gamma^2$ ) necessário para realizar a amostragem de local_scales.
• o viés remanescente nos valores esperados calculados com esses limites.

Tipo de retorno

Uma tupla de comprimento 3, cujos elementos são

Aumentos

• ValueError – se forem fornecidos valores diferentes dos padrão para ambos, o e sampling_cost_budget o bias_tolerance.
• KeyError – se não noise_rates tiver uma entrada para qualquer identificador de modelo de ruído (InjectNoise.ref) encontrado em circuit.

compute_bounds(circuit, noise_model_paulis, light_cone, norm_fn, *, backwards, max_num_boxes=None, num_processes=1, timeout=None)

Calcula os limites do comutador de tempo desigual.

Dado um circuito com BoxOp instruções com InjectNoise anotações e um mapeamento de identificadores de modelos de ruído (InjectNoise.ref) para uma lista de termos de erro de Pauli (noise_model_paulis), esta função calcula os limites do comutador de tempo desigual (cujos detalhes são implementados por norm_fn). Ao fazer isso, considera-se apenas os portais que se encontram dentro do cone de luz do observável (inicializado por light_cone). Esses limites calculados constituem a base do cone de luz sombreado.

Como essa função realiza um cálculo demorado, ela lida adequadamente com exceções KeyboardInterrupt , permitindo que o usuário interrompa o cálculo em qualquer momento e ainda assim obtenha os resultados calculados até aquele ponto.

Parâmetros

• circuit (QuantumCircuit) – o circuito de destino.
• noise_model_paulis (dict[str, QubitSparsePauliList]) – os termos de erro de Pauli a serem considerados para cada modelo de ruído.
• light_cone (LightCone) – o LightCone rastreador inicializado e com estado.
• norm_fn (Callable[[Pauli, RotationGates], CommutatorBounds]) – a função que implementa o comutador de tempo desigual específico.
• backwards (bool) – se deve percorrer os elementos na circuit ordem inversa.
• max_num_boxes (int | None) – o número máximo de caixas para as quais se deve calcular os limites. Os limites para quaisquer caixas adicionais receberão o valor trivial de limite superior de $2.0$.
• num_processes (int) – o número de processos paralelos a serem utilizados.
• timeout (float | None) – um tempo limite opcional (em segundos), após o qual todas as camadas restantes são preenchidas com limites numéricos triviais de 2.0. Observe que esse não é um tempo limite estrito e que a camada que estiver sendo processada no momento em que esse tempo limite for atingido será concluída normalmente.

Retorna

Os limites calculados do comutador de tempo desigual.

Tipo de retorno

dict [ str, PauliLindbladMap ]