SparsePauliOp

기본값: 1e-08

폴리 계수를 반환합니다.

튜플(입력_셰이프, 출력_셰이프)을 반환합니다.

N-큐비트 연산자인 경우 큐비트 수를 반환하고, 그렇지 않으면 None을 반환합니다.

계수에서 무료 Parameter를 반환합니다.

PauliList 을 반환합니다.

연산자에 대한 qarg를 반환합니다.

기본값: 1e-05

설정을 반환합니다.

연산자의 파울리 항의 파울리 수입니다.

adjoint()

연산자의 부속자를 반환합니다.

apply_layout(layout, num_qubits=None)

여기에 트랜스파일러 레이아웃 적용 SparsePauliOp

매개변수

• layout (TranspileLayout |list[int] | None) – a TranspileLayout, 정수 목록 또는 None 중 하나입니다. layout과 num_qubits가 모두 none인 경우, 연산자의 복사본이 반환됩니다.
• num_qubits (int | None) – 연산자를 확장할 큐비트 수입니다. 제공되지 않은 경우 layout 가 TranspileLayout 이면 기본적으로 트랜스파일러 출력 회로 큐비트 수가 사용됩니다. layout 이 정수의 목록인 경우 지정된 순열은 확장 없이 적용됩니다. 레이아웃이 없음인 경우 연산자는 지정된 큐비트 수만큼 확장됩니다.

리턴

새로운 SparsePauliOp 제공된 레이아웃이 적용된

리턴 유형

SparsePauliOp

argsort(weight=False)

테이블의 행을 정렬하기 위한 인덱스를 반환합니다.

계수를 기준으로 정렬하고 폴리를 기준으로 정렬하는 순서로 순열의 구성을 반환합니다. 가중치 kwarg를 사용하면 폴리에 있는 비동일성 용어의 수에 따라 출력을 추가로 정렬할 수 있으며, 여기서 주어진 가중치를 가진 모든 폴리의 집합은 여전히 사전적 순서에 따라 정렬됩니다.

예제

다음은 SparsePauliOp argsort를 사용하는 방법의 예입니다.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.argsort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.argsort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.argsort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Weight sorted
[4 7 3 0 1 2 6 5]

매개변수

• weight (bool) – 선택적으로 가중치를 기준으로 정렬합니다(기본값: False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

리턴

테이블 정렬을 위한 인덱스입니다.

리턴 유형

배열

assign_parameters(parameters, inplace=False)

계수의 무료 Parameter를 제공된 값에 바인딩합니다.

매개변수

• parameters (Mapping[Parameter, complex |ParameterExpression] | Sequence[complex |ParameterExpression]) – 매개변수를 바인딩할 값들.
• inplace (bool) – False 이면 바인딩된 매개변수가 있는 연산자의 복사본이 반환됩니다. True 경우 운영자 자체가 수정됩니다.

리턴

바인딩된 매개변수가 있는 연산자의 사본( inplace 이면 False, 그렇지 않으면 None).

리턴 유형

SparsePauliOp | 없음

chop(tol=1e-14)

계수의 실수 부분과 허수 부분을 0으로 설정합니다(크기가 < tol 인 경우).

예를 들어 1e-17 보다 큰 허용 오차를 가진 1+1e-17j X + 1e-17 Y 을 나타내는 연산자는 1 X 로 축소되는 반면 SparsePauliOp.simplify() 는 1+1e-17j X 를 반환합니다.

쪼개기 연산 후 계수의 실수부와 허수부가 모두 0이면, 해당 파울리 연산자는 연산자에서 제거된다.

매개변수

tol (float) – 실수 또는 허수 부분을 확인하기 위한 절대 허용 오차를 0으로 설정해야 합니다.

리턴

잘게 잘린 계수가 있는 연산자입니다.

리턴 유형

SparsePauliOp

compose(other, qargs=None, front=False)

연산자 구성을 다른 SparsePauliOp 으로 반환합니다.

매개변수

• other (SparsePauliOp) – SparsePauliOp 객체입니다.
• qargs (list or None) – 다른 작업을 적용할 하위 시스템 위치 목록 모든 하위 시스템에 None이 적용되는 경우 (기본값: None).
• front (bool) – True이면 왼쪽 곱셈 대신 오른쪽 연산자 곱셈을 사용하여 구성합니다. [기본값: False].

리턴

작성된 SparsePauliOp.

리턴 유형

SparsePauliOp

레이즈

QiskitError – 다른 항이 연산자로 변환될 수 없거나, 지정된 하위 시스템에 대해 차원이 호환되지 않는 경우.

conjugate()

SparsePauliOp 의 활용형을 반환합니다.

copy()

현재 운영자의 딥 카피를 만듭니다.

dot(other, qargs=None)

오른쪽 곱하기 연산자 self * other를 반환합니다.

매개변수

• other (Operator) – 연산자 객체입니다.
• qargs (list or None) – 다른 작업을 적용할 하위 시스템 위치 목록 모든 하위 시스템에 None이 적용되는 경우 (기본값: None).

리턴

오른쪽 행렬 곱하기 연산자.

리턴 유형

운영자

equiv(other, atol=None)

두 개의 SparsePauliOp 연산자가 동일한지 확인합니다.

매개변수

• other (SparsePauliOp) – 연산자 객체입니다.
• atol (float | None) – 동등성 확인을 위한 절대 수치 허용 오차.

리턴

연산자가 self 와 같으면 참입니다.

리턴 유형

부울

expand(other)

역순 텐서 곱을 다른 SparsePauliOp 으로 반환합니다.

매개변수

other (SparsePauliOp) – SparsePauliOp 객체입니다.

리턴

텐서 곱 $b \otimes a$, 여기서 $a$

는 현재 SparsePauliOp,, $b$ 은 다른 SparsePauliOp 입니다.

리턴 유형

SparsePauliOp

static from_list(obj, dtype=None, *, num_qubits=None)

폴리 문자열 및 계수 목록에서 구성합니다.

예를 들어, 5-큐비트 해밀턴은

는 다음과 같이 구성할 수 있습니다

from qiskit.quantum_info import SparsePauliOp

# via tuples and the full Pauli string
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

매개변수

• obj (Iterable[Tuple[str, complex]]) – 폴리 용어를 지정하는 2-튜플 목록입니다.
• dtype (type | None) – 계수의 데이터 유형. (기본값) None 인 경우, dtype이 자동으로 추론됩니다.
• num_qubits (int) – 연산자의 큐비트 수입니다(기본값: 없음).

리턴

폴리 약관의 SparsePauliOp 표현.

리턴 유형

SparsePauliOp

레이즈

• QiskitError – 빈 리스트가 전달되고 num_qubits가 None인 경우.
• QiskitError – num_qubits와 입력 목록에 있는 객체들이 일치하지 않는 경우.

static from_operator(obj, atol=None, rtol=None)

Operator 객체를 기반으로 생성합니다.

분해에서 가능한 폴리 항의 수는 큐비트 수에서 기하급수적이기 때문에 이 구성의 비용은 일반적으로 기하급수적이라는 점에 유의하세요.

내부적으로는 Hantzko, Binkowski, Gupta(2023) 에서 제시된 "텐서화된 폴리 분해"의 구현을 사용합니다.

매개변수

• obj (Operator) – n-쿼비트 연산자입니다.
• atol (float) – 선택 사항입니다. 계수가 0인지 확인하기 위한 절대 허용 오차(기본값: 1e-8 ). 비교 대상이 0이므로 실제로 사용된 허용 오차는 atol 과 rtol 의 최대값입니다.
• rtol (float) – 선택 사항입니다. 계수가 0인지 확인하기 위한 상대 허용 오차(기본값: 1e-5 )를 설정합니다. 비교 대상이 0이므로 실제로 사용된 허용 오차는 atol 과 rtol 의 최대값입니다.

리턴

운영자의 SparsePauliOp 대표입니다.

리턴 유형

SparsePauliOp

레이즈

QiskitError – 입력 연산자가 N-큐비트 연산자가 아닌 경우.

static from_sparse_list(obj, num_qubits, do_checks=True, dtype=None)

로컬 폴리 문자열 및 계수 목록에서 구성합니다.

각 목록 요소는 로컬 폴리 문자열, 적용 위치 인덱스, 계수의 3-튜플입니다.

예를 들어, 5-큐비트 해밀턴은

는 다음과 같이 구성할 수 있습니다

from qiskit.quantum_info import SparsePauliOp

# via triples and local Paulis with indices
op = SparsePauliOp.from_sparse_list([("ZX", [1, 4], 1), ("YY", [0, 3], 2)], num_qubits=5)

# equals the following construction from "dense" Paulis
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

매개변수

• obj (Iterable[tuple[str, list[int], complex]]) – 폴리를 지정하는 3-튜플 목록입니다.
• num_qubits (int) – 연산자의 큐비트 수입니다.
• do_checks (bool) – 입력 인덱스에 대해 유효성 검사를 수행할지 여부.
• dtype (type | None) – 계수의 데이터 유형. (기본값) None 인 경우, dtype이 자동으로 추론됩니다.

리턴

폴리 약관의 SparsePauliOp 표현.

리턴 유형

SparsePauliOp

레이즈

• QiskitError – 큐비트의 개수가 파울리 항의 지수와 호환되지 않는 경우.
• QiskitError – 지정된 큐비트가 이미 할당된 경우.

static from_sparse_observable(obs)

에서 초기화 SparseObservable.

매개변수

obs (SparseObservable) – 를 SparseObservable 를 변환합니다.

리턴

A SparsePauliOp 버전의 관찰 가능 항목입니다.

리턴 유형

SparsePauliOp

group_commuting(qubit_wise=False)

SparsePauliOp 을 통근용 폴리 문자열 집합으로 분할합니다.

매개변수

qubit_wise (bool) –

연산자 전체에 정류 규칙을 적용할지, 아니면 큐비트 단위로 적용할지 여부를 설정합니다. 예를 들어,

>>> from qiskit.quantum_info import SparsePauliOp
>>> op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])
>>> op.group_commuting()
[SparsePauliOp(["IZ", "ZZ"], coeffs=[0.+2.j, 0.+1j]),
 SparsePauliOp(["XX", "YY"], coeffs=[2.+0.j, 1.+0.j])]
>>> op.group_commuting(qubit_wise=True)
[SparsePauliOp(['XX'], coeffs=[2.+0.j]),
 SparsePauliOp(['YY'], coeffs=[1.+0.j]),
 SparsePauliOp(['IZ', 'ZZ'], coeffs=[0.+2.j, 0.+1.j])]

리턴

SparsePauliOp 목록에서 각 SparsePauliOp 포함

출퇴근하는 폴리 운영자.

리턴 유형

목록 [ SparsePauliOp ]

input_dims(qargs=None)

지정된 하위 시스템에 대한 입력 차원의 튜플을 반환합니다.

is_unitary(atol=None, rtol=None)

연산자가 단일 행렬이면 True를 반환합니다.

이 메서드는 인접 연산자와 함께 구성된 연산자가 주어진 허용 오차 범위까지 동일성을 갖는지 확인합니다. 허용 오차는 구성된 연산자를 단순화하고 결과가 동일성인지 확인할 때 사용됩니다.

매개변수

• atol (float) – 선택 사항입니다. 계수가 0인지 확인하기 위한 절대 허용 오차(기본값: 1e-8 ).
• rtol (float) – 선택 사항입니다. 계수가 0인지 확인하기 위한 상대 허용 오차(기본값: 1e-5 ).

리턴

연산자가 단일이면 참, 그렇지 않으면 거짓입니다.

리턴 유형

부울

label_iter()

라벨 표현 이터레이터를 반환합니다.

이것은 SparsePauliOp 의 각 용어를 튜플(레이블, 코에프)로 변환하는 지연 반복기입니다. 전체 테이블을 레이블로 변환하려면 to_labels() 메서드를 사용합니다.

리턴

레이블 반복기 객체를 SparsePauliOp.

리턴 유형

LabelIterator

matrix_iter(sparse=False)

행렬 표현 이터레이터를 반환합니다.

이것은 SparsePauliOp 의 각 용어가 사용될 때 행렬로 변환하는 지연 반복기입니다. 단일 행렬로 변환하려면 to_matrix() 메서드를 사용합니다.

매개변수

sparse (bool) – True인 경우 스파스 CSR 행렬을 반환하고, 그렇지 않으면 NumPy 배열 행렬을 반환합니다(기본값: False)

리턴

행렬 이터레이터 객체를 PauliList.

리턴 유형

MatrixIterator

noncommutation_graph(qubit_wise)

이것의 비교차 그래프를 만듭니다 SparsePauliOp.

이렇게 하면 측정 연산자 그룹화 문제가 그래프 색칠 문제로 변환됩니다. 구성된 그래프에는 각 폴리에 대해 하나의 노드가 포함됩니다. 노드는 _not_ 통근하는 두 개의 폴리 항에 대해 연결됩니다.

매개변수

qubit_wise (bool) – 연산자 전체에 정류 규칙을 적용할지, 아니면 큐비트 단위로 적용할지 여부를 설정합니다.

리턴

각 폴리와 에지에 대한 노드가 있는 비교차 그래프입니다

는 정류 관계가 아닌 관계를 나타냅니다. 각 노드는 해당 데이터에 해당하는 폴리 용어의 인덱스를 보유하게 됩니다. 그래프의 가장자리에는 데이터가 없습니다.

리턴 유형

rustworkx.PyGraph

output_dims(qargs=None)

지정된 하위 시스템에 대한 출력 차원의 튜플을 반환합니다.

power(n)

연산자를 n번 자기 자신과 합성한 결과를 반환합니다.

매개변수

n (int) – 셀프 작성 횟수 ( n>0 ).

리턴

n-회 구성 연산자입니다.

리턴 유형

클리퍼드

레이즈

QiskitError – 연산자의 입력 및 출력 차원이 같지 않거나, 지수가 양의 정수가 아닌 경우.

reshape(input_dims=None, output_dims=None, num_qubits=None)

입력 및 출력 하위 시스템 치수가 재구성된 얕은 복사본을 반환합니다.

매개변수

• input_dims (None or tuple) – 새로운 하위 시스템 입력 차원. None인 경우 원래 입력이 희미하게 유지됩니다. [기본값: None].
• output_dims (None or tuple) – 새로운 하위 시스템 출력 차원. None인 경우 원래 출력이 흐려집니다. [기본값: None].
• num_qubits (None or int) – n-큐비트 연산자로 재형성 [기본값입니다: 없음].

리턴

는 입력 및 출력 치수가 재형성된 자기를 반환합니다.

리턴 유형

BaseOperator

레이즈

QiskitError – 모든 하위 시스템의 입력 차원 또는 출력 차원의 합이 일정하지 않은 경우.

simplify(atol=None, rtol=None)

중복을 결합하고 0을 제거하여 PauliList 을 단순화합니다.

매개변수

• atol (float) – 선택 사항입니다. 계수가 0인지 확인하기 위한 절대 허용 오차(기본값: 1e-8 ).
• rtol (float) – 선택 사항입니다. 계수가 0인지 확인하기 위한 상대 허용 오차(기본값: 1e-5 )를 설정합니다.

리턴

단순화된 SparsePauliOp 연산자입니다.

리턴 유형

SparsePauliOp

sort(weight=False)

표의 행을 정렬합니다.

Numpy의 argsort를 사용하여 계수를 정렬한 후 Pauli로 정렬합니다. 폴리 정렬이 우선합니다. 폴리가 같으면 계수별로 정렬됩니다. 가중치 kwarg를 사용하면 폴리에 있는 비동일성 용어의 수에 따라 출력을 추가로 정렬할 수 있으며, 여기서 주어진 가중치를 가진 모든 폴리의 집합은 여전히 사전적 순서에 따라 정렬됩니다.

예제

다음은 SparsePauliOp sort를 사용하는 방법의 예입니다.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.sort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.sort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.sort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Weight sorted
SparsePauliOp(['II', 'XI', 'YI', 'XX', 'XX', 'XX', 'XY', 'XZ'],
              coeffs=[4.+0.j, 7.+0.j, 3.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j])

매개변수

• weight (bool) – 선택적으로 가중치를 기준으로 정렬합니다(기본값: False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

리턴

원본 테이블의 정렬된 사본입니다.

리턴 유형

SparsePauliOp

static sum(ops)

의 합계 SparsePauliOps.

이것은 sum 함수를 SparsePauliOp 용으로 특화하여 오버헤드를 줄인 버전입니다.

매개변수

ops (list[SparsePauliOp]) – 의 목록 SparsePauliOps.

리턴

입력 목록의 합계를 나타내는 SparsePauliOp.

리턴 유형

SparsePauliOp

레이즈

• QiskitError – 입력 목록이 비어 있는 경우.
• QiskitError – 입력 목록에 SparsePauliOp가 아닌 객체가 포함된 경우.
• QiskitError – 입력 목록에 있는 객체들의 큐비트 수가 일치하지 않는 경우.

tensor(other)

텐서 곱을 다른 SparsePauliOp 로 반환합니다.

매개변수

other (SparsePauliOp) – SparsePauliOp 객체입니다.

리턴

텐서 곱 $a \otimes b$, 여기서 $a$

는 현재 SparsePauliOp,, $b$ 은 다른 SparsePauliOp 입니다.

리턴 유형

SparsePauliOp

to_list(array=False)

폴리 문자열 레이블과 계수를 목록으로 변환합니다.

용어가 많은 오퍼레이터의 경우 array=True kwarg를 사용하여 변환하는 것이 전체 Numpy 레이블 배열에 대한 메모리를 미리 할당하므로 더 효율적입니다.

매개변수

array (bool) – true이면 Numpy 배열을 반환하고, 그렇지 않으면 목록을 반환합니다(기본값: False).

리턴

의 행에 대한 쌍(레이블, 코오프) 목록( PauliList.

리턴 유형

목록 또는 배열

to_matrix(sparse=False, force_serial=False)

밀도 또는 희소 행렬로 변환합니다.

매개변수

• sparse (bool) – True 이면 희소 CSR 행렬을 반환하고, 그렇지 않으면 고밀도 Numpy 배열(기본값)을 반환합니다.
• force_serial (bool) – 이 True 인 경우, 키스킷 스레딩 제어 환경 변수의 상태와 관계없이 언스레드 구현을 사용합니다. 기본적으로 사용 가능한 CPU를 통해 스레드 병렬 처리를 사용합니다.

리턴

스파스=False이면 밀도가 높은 행렬입니다. csr_matrix: 스파스 = True인 경우 CSR 형식의 스파스 행렬입니다.

리턴 유형

배열

to_operator()

행렬 연산자 객체로 변환

리턴 유형

운영자

to_sparse_list()

요소(폴리, 큐비트, 계수)를 사용하여 스파스 폴리 목록 형식으로 변환합니다.

transpose()

SparsePauliOp 의 조옮김을 반환합니다.