SparseObservable

__new__(data, /, num_qubits=None)

의 기본 생성자 SparseObservable.

이는 data 인수의 유형에 따라 명시적 변환 생성자 메서드 중 하나에 위임합니다. num_qubits 이 제공되고 data 유형이 암시하는 생성자가 숫자를 허용하지 않는 경우, 주어진 정수는 입력과 일치해야 합니다.

매개변수

• 데이터 - 입력의 데이터 유형입니다. 이것은 다른 SparseObservable일 수 있으며, 이 경우 입력이 복사되거나 Pauli 또는 SparsePauliOp또는 from_pauli() 또는 from_sparse_pauli_op() 가 적절하게 호출되거나, 유효한 형식의 목록일 수 있습니다 from_list() 또는 from_sparse_list().
• num_qubits (int|None) – 연산자의 선택적 큐비트 수입니다. 대부분의 데이터 입력은 추론이 가능하므로 전달할 필요가 없습니다. 빈 목록 또는 희소 목록 형식에만 필요합니다. 불필요하게 주어진 경우 입력된 데이터와 일치해야 합니다.

단일 큐비트 용어의 평면 목록입니다. 이것은 더 자연스럽게 목록의 목록이지만 메모리 사용량과 지역성을 위해 평평하게 저장되며 하위 목록은 경계로 표시됩니다.

파티션을 분할하는 인덱스 bit_terms 및 indices 를 합계의 각 개별 용어에 대한 하위 목록으로 분할하는 인덱스입니다. boundaries[0] : boundaries[1] 는 인덱스의 범위를 bit_terms 과 indices 의 합의 첫 번째 항에 해당합니다. 지정되지 않은 모든 큐비트 인덱스는 암시적으로 아이덴티티입니다. 보다 한 항목 더 깁니다 coeffs보다 한 항목 더 긴데, boundaries[0] 은 항상 명시적으로 0이기 때문입니다(알고리즘의 편의를 위해).

각 추상 용어의 계수를 합한 값입니다. 여기에는 합계의 용어 수만큼 많은 요소가 있습니다.

의 해당 항목이 작동하는 큐비트 인덱스의 평면 목록 bit_terms 에 해당하는 쿼비트 인덱스의 플랫 목록입니다. 이 목록은 항상 용어별로 정렬되어야 하며, 용어는 하위 목록으로 boundaries.

오퍼레이터가 작동하는 큐비트 수입니다.

ID는 명시적으로 저장되지 않으므로 다른 모양이나 값으로 유추할 수 없습니다.

이 연산자가 추적 중인 합계 내 용어 수입니다.

adjoint()

이 옵저버블의 부속물을 계산합니다.

이것은 추상적인 수학적 의미로 잘 정의되어 있습니다. 단일 큐비트 알파벳의 모든 용어는 자기접합이므로 이 연산 결과는 계수가 모두 복잡한 공액이라는 점을 제외하면 동일하게 관찰할 수 있습니다.

예제

>>> left = SparseObservable.from_list([("XY+-", 1j)])
>>> right = SparseObservable.from_list([("XY+-", -1j)])
>>> assert left.adjoint() == right

apply_layout(layout, num_qubits=None)

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

일반적으로 상태를 준비하는 데 사용할 회로의 가상 큐비트 측면에서 관찰 가능 항목을 정의합니다. 변환 후 가상 큐비트는 디바이스의 특정 물리적 큐비트에 매핑되며, 이는 회로보다 더 넓을 수 있습니다. 이 매핑은 회로가 진행되는 동안 변경될 수도 있습니다. 이 방법은 가상 큐비트에서 관측 가능한 입력을 완전히 트랜스파일된 물리적 회로 직후에 적용하기에 적합한 관측 가능한 값으로 변환합니다.

매개변수

• layout (TranspileLayout |list[int] | None) – 적용할 레이아웃. 이 함수를 사용할 때는 대부분 하드웨어용으로 트랜스파일링된 회로의 필드를 QuantumCircuit.layout 전달해야 합니다. 또한, 새로운 큐비트 인덱스 목록을 전달할 수도 있습니다. None명시적으로 지정된 경우, 재매핑은 적용되지 않습니다(하지만 여전히 를 num_qubits 사용하여 관측 가능 객체를 확장할 수는 있습니다).
• num_qubits (int | None) – 관측 가능 영역을 확장할 큐비트 수입니다. 제공되지 않으면 출력은 주어진 너비만큼( TranspileLayout또는 layout 이 다른 형식으로 지정된 경우 입력과 같은 너비가 됩니다.

리턴

새로운 SparseObservable 에 제공된 레이아웃을 적용합니다.

as_paulis()

각 프로젝터를 파울리 항의 합으로 작성하여 관측 가능한 것을 파울리 항으로만 표현합니다.

결과 폴리 용어의 순서가 보장되지 않는다는 점에 유의하세요. 사용 SparseObservable.simplify() 를 사용하여 정식 표현을 얻을 수 있습니다.

리턴

관찰 가능성은 동일하지만 폴리 용어로만 표현됩니다.

예제

프로젝터 측면에서 옵저버블을 폴리 연산자로 다시 작성합니다:

>>> obs = SparseObservable("+")
>>> obs.as_paulis()
<SparseObservable with 2 terms on 1 qubit: (0.5+0j)() + (0.5+0j)(X_0)>
>>> direct = SparseObservable.from_list([("I", 0.5), ("Z", 0.5)])
>>> assert direct.simplify() == obs.as_paulis().simplify()

소규모 운영자의 경우 다음과 함께 사용할 수 있습니다 simplify() 를 고유한 표준 형식으로 사용할 수 있습니다:

>>> left = SparseObservable.from_list([("+", 0.5), ("-", 0.5)])
>>> right = SparseObservable.from_list([("r", 0.5), ("l", 0.5)])
>>> assert left.as_paulis().simplify() == right.as_paulis().simplify()

clear()

이 연산자에서 모든 항을 지우고 다시 0 연산자와 동일하게 만듭니다.

이는 내부 할당 용량을 변경하지 않으므로, 이후의 덧셈이나 뺄셈 연산 시 재할당이 필요하지 않을 수 있습니다.

예제

>>> obs = SparseObservable.from_list([("IX+-rl", 2.0), ("01YZII", -1j)])
>>> obs.clear()
>>> assert obs == SparseObservable.zero(obs.py_num_qubits())

commutes(other, tol=1e-12)

관측 가능한 것이 다른 것과 교환법칙을 만족하는지 확인하십시오.

매개변수

• other (SparseObservable) – 교환성을 확인하기 위한 다른 관측량.
• tol (float) – 자기와 타인의 곱셈 계수가 허용 오차(절대값 기준) 미만일 경우, 해당 항은 무시된다.

리턴

True 용어가 교환 가능하다면, 허용 오차 범위 내에서, False 그렇지 않으면.

인상

TypeError – 만약 other 가 로 강제될 수 SparseObservable 없다면.

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

여기에 다른 SparseObservable 를 추가합니다.

연산자 대수학의 관점에서, 구성은 왼쪽 곱셈에 해당합니다: c = a.compose(b) 는 $C = B A$에 해당합니다. 즉, a.compose(b) 은 " a 을 수행한 다음 결과에 b 을 수행하는" 연산자를 반환합니다. 대신 front=True 인수를 사용하면 올바른 곱셈이 됩니다.

self 와 other 는 같은 크기여야 하며, qargs 이 지정되지 않은 경우 other 는 self 보다 작을 수 있습니다( other 의 큐비트 수와 qargs 의 길이가 일치하는 경우). qargs 에 존재하지 않는 큐비트의 중복이나 인덱스는 절대 포함할 수 없습니다 self.

이 함수를 사용하면 관찰 가능 항목의 메모리 사용량이 기하급수적으로 폭발적으로 증가할 수 있다는 점에 유의하세요 SparseObservable 의 알파벳은 구성에서 닫히지 않으며, 두 개의 단일 비트 항의 구성은 총 항의 수를 곱하는 합이 될 수 있습니다. 이 메모리 사용량은 결과 관측값에 _필연적으로_ 내재되어 있는 것은 아니지만, 합계의 효율적인 재분해 방법을 찾는 것은 일반적으로 계산적으로 똑같이 어렵습니다. 사후에 용어를 단순화하려고 하는 것보다 관찰 대상에 대한 도메인 지식을 사용하여 존재하는 용어의 수를 최소화하는 것이 좋습니다.

매개변수

• 기타 - 왼쪽 곱하기( self)에 사용되는 관찰 가능 항목입니다.

• qargs -

  가 주어진 경우 self 의 큐비트를 other 의 큐비트와 연결합니다. 다시 말해, 이것이 주어지면 다음과 같이 더 효율적으로 구현하는 것과 비슷합니다:

  self.compose(other.apply_layout(qargs, self.num_qubits))

  의 적용된 레이아웃 형태를 저장하기 위한 임시 옵저버블이 생성되지 않으므로 other.

• 앞 - True 인 경우 왼쪽 곱하기 대신 other 을 오른쪽 곱합니다(기본값 False). qargs 은 여전히 other 에 적용됩니다. qargs 이 설정된 경우 가장 유용하며, other 이 강제로 SparseObservable.

conjugate()

이 관측 가능 데이터의 복합 활용을 계산합니다.

이 연산은 키스킷의 표준 행렬 규칙에 따라 정의되며, 행렬 형식이 $Z$ 계산 기준으로 간주됩니다. X$ 및 $Z$ 관련 알파벳 용어는 복합 활용의 영향을 받지 않지만, $Y$ 관련 용어는 해당 알파벳 용어를 수정합니다. 맞습니다:

• $Y$ 에 접속사 $-Y$
• $\lvert r\rangle\langle r\rvert$ 에 활용 $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ 에 활용 $\lvert r\rangle\langle r\rvert$

또한 모든 계수는 공액형입니다.

예제

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.conjugate() == SparseObservable([("III", -1j), ("Ylr", -0.5)])

copy()

이 관찰 가능 항목의 사본을 받으세요.

예제

>>> obs = SparseObservable.from_list([("IXZ+lr01", 2.5), ("ZXI-rl10", 0.5j)])
>>> assert obs == obs.copy()
>>> assert obs is not obs.copy()

evolve(other, /, qargs=None)

이 관측량을 파울리 항으로 변환하라.

관측 가능한 $O$ 의 파울리 $P$ 에 의한 진화는 $P^\dagger O P$ 에 해당한다.

두 개의 완전한 합성을 통해 문자 그대로 구현하는 방식과 달리, 이 방법은 고정된 조회 테이블을 사용하여 단일 큐비트 수준에서 직접 공액 연산을 수행합니다. 이렇게 하면 중간 결과를 구체화할 SparseObservable 필요가 없으며, 항들을 한 번만 순회하는 것으로 진화된 관측량을 계산할 수 있습니다. self 그리고 와 other 큐비트 수가 같아야 하며, 가 주어지지 않은 qargs 경우를 제외하고는, 와 other 의 큐비트 수가 같고 other 의 길이가 qargs 일치한다면 가 self보다 작을 수 있다. qargs 는 의 어떤 큐비트가 self 에 의해 진화되는지를 other 명시한다.

현재 이 방법은 단일 항 연산자에 의한 진화만 지원하므로, 는 로 표현되는 other 파울리 Pauli연산자여야 합니다.

매개변수

• 기타 – 공액 연산에 self사용되는 파울리 연산자.
• qargs – 지정된 경우, 에 있는 큐비트를 self 에 의해 other진화시킵니다. 길이는 의 큐비트 수와 other일치해야 합니다.

리턴

응용된 활용형이 포함된 새로운 SparseObservable 형태.

인상

• TypeError – 만약 other 가 타입이 Pauli아니라면.
• ValueError – 만약 self 와 의 큐비트 수가 서로 다르고 other (또한 qargs 가 주어지지 않은 경우).
• ValueError – 길이가 큐비트 수와 qargs``other 일치하지 않는 경우.
• ValueError – 중복 항목이나 범위를 벗어난 인덱스가 포함된 qargs 경우.
• ValueError – 만약 other 에 하나 이상의 항이 포함되어 있다면.

expand(other, /)

텐서 곱 역순.

이는 other.tensor(self) 과 동일하지만 other 이 이미 존재하지 않는 경우 먼저 다음과 같이 형 변환됩니다 SparseObservable 로 타입 변환된다는 점만 다릅니다(기본 생성자를 호출하여).

매개변수

기타 - 텐서 곱의 왼쪽에 놓을 관찰 가능 항목입니다.

예제

이는 다음과 같습니다 tensor() 와 같지만 인자의 순서가 뒤바뀝니다:

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == right.expand(left)

static from_label(label, /)

밀도가 높은 문자열 레이블에서 단일 기간 관측값을 구성합니다.

결과 연산자의 계수는 1이 됩니다. 레이블은 알파벳 시퀀스여야 합니다 'IXYZ+-rl01'. 레이블은 비트 문자열과 유사하게 해석됩니다. 즉, 가장 오른쪽에 있는 문자는 큐비트 0과 연관되어 있습니다. 이것은 Pauli 및 SparsePauliOp.

매개변수

label (str) – 밀도가 높은 레이블입니다.

예제

>>> SparseObservable.from_label("IIII+ZI")
<SparseObservable with 1 term on 7 qubits: (1+0j)(+_2 Z_1)>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

static from_list(iter, /, *, num_qubits=None)

밀도가 높은 레이블과 계수 목록에서 관측값을 구성합니다.

와 유사하지만 SparsePauliOp.from_list()와 유사하지만 확장 알파벳인 SparseObservable. 이 밀도 높은 양식에서는 각 레이블에 모든 ID를 명시적으로 제공해야 합니다.

레이블은 알파벳 시퀀스여야 합니다 'IXYZ+-rl01'. 레이블은 비트 문자열과 유사하게 해석됩니다. 즉, 가장 오른쪽에 있는 문자는 큐비트 0과 연관되어 있습니다. 이것은 Pauli 및 SparsePauliOp.

매개변수

• iter (list[tuple[str, complex]]) – 합산할 레이블 쌍과 관련 계수입니다. 레이블은 다음과 같은 방식으로 해석됩니다 from_label().
• num_qubits (int | None) – iter 이 빈 시퀀스가 아닌 것이 확실하다면 레이블 길이를 통해 유추할 수 있으므로 이를 지정할 필요가 없습니다. iter 가 비어 있을 수 있는 경우, 이 인수를 지정하여 관찰 가능한 큐비트 수를 명확히 해야 합니다. 이 값이 주어지고 iter 이 비어 있지 않은 경우, 이 값은 레이블 길이와 일치해야 합니다.

예제

같은 길이의 레이블 목록에서 관찰 가능한 항목을 만듭니다:

>>> SparseObservable.from_list([
...     ("III++", 1.0),
...     ("II--I", 1.0j),
...     ("I++II", -0.5),
...     ("--III", -0.25j),
... ])
<SparseObservable with 4 terms on 5 qubits:
    (1+0j)(+_1 +_0) + (0+1j)(-_2 -_1) + (-0.5+0j)(+_3 +_2) + (-0-0.25j)(-_4 -_3)>

num_qubits 을 사용하여 잠재적으로 비어 있을 수 있는 입력을 명확하게 구분하세요:

>>> SparseObservable.from_list([], num_qubits=10)
<SparseObservable with 0 terms on 10 qubits: 0.0>

이 메서드는 명시적 쿼비트 인자 필드를 감소하는 정수로 설정한 from_sparse_list() 에 대한 호출과 동일하며, 명시적 쿼비트 인자 필드가 감소하는 정수로 설정됩니다:

>>> labels = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_pauli(pauli, /)

를 구성합니다 SparseObservable 인스턴스를 Pauli 인스턴스를 생성합니다.

관측 가능한 출력은 위상에 따라 단일 계수를 갖는 단일 항을 갖습니다.

매개변수

pauli (Pauli) – 단일 폴리를 변환할 수 있습니다.

예제

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> SparseObservable.from_pauli(pauli)
<SparseObservable with 1 term on 5 qubits: (1+0j)(Y_3 X_2 Z_1)>
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

static from_raw_parts(num_qubits, coeffs, bit_terms, indices, boundaries, check=True)

를 구성합니다 SparseObservable 를 클래스 수준 문서에 설명된 필수 데이터 표현과 일치하는 원시 Numpy 배열로 구성합니다.

각 배열의 데이터는 새롭고 확장 가능한 Rust 공간 할당으로 복사됩니다.

매개변수

• 숫자_큐비트 - 관측 가능한 큐비트 수입니다.

• coeffs - 관측 가능한 각 항의 복소 계수입니다. 이것은 dtype이 포함된 Numpy 배열이어야 합니다 complex128.

• bit_terms - 모든 완전한 용어로 구성된 단일 큐비트 용어의 평활화된 목록입니다. 이것은 dtype이 있는 Numpy 배열이어야 합니다 uint8 (와 호환되는 BitTerm).

• 인덱스 - 각 단일 큐비트 용어에 해당하는 큐비트를 용어별로 정렬한 평평한 목록입니다. 이것은 dtype이 포함된 Numpy 배열이어야 합니다 uint32.

• 경계 - bit_terms 및 indices 용어를 분할하는 인덱스입니다. 이것은 dtype이 포함된 Numpy 배열이어야 합니다 uintp.

• 확인 -

  (기본값인 True )인 경우 데이터가 모든 일관성 보증을 충족하는지 확인합니다. False, 확인이 수행되지 않습니다.

  경고

  만약에 check=False, 그 bit_terms 반드시 모든 값이 유효 해야 합니다. SparseObservable.BitTerm. 그렇지 않은 경우 Rust 공간에서 정의되지 않은 동작이 발생하여 프로그램 실행이 완전히 무효화될 수 있습니다.

예제

각 개별 큐비트에 $Z$ 의 합계를 구성합니다:

>>> num_qubits = 100
>>> terms = np.full((num_qubits,), SparseObservable.BitTerm.Z, dtype=np.uint8)
>>> indices = np.arange(num_qubits, dtype=np.uint32)
>>> coeffs = np.ones((num_qubits,), dtype=complex)
>>> boundaries = np.arange(num_qubits + 1, dtype=np.uintp)
>>> SparseObservable.from_raw_parts(num_qubits, coeffs, terms, indices, boundaries)
<SparseObservable with 100 terms on 100 qubits: (1+0j)(Z_0) + ... + (1+0j)(Z_99)>

static from_sparse_list(iter, /, num_qubits)

레이블 목록, 각 항목이 적용되는 큐비트, 전체 용어의 계수에서 관찰 가능 항목을 구성합니다.

와 유사하지만 SparsePauliOp.from_sparse_list()와 유사하지만 확장 알파벳인 SparseObservable.

삼각형의 '레이블' 및 '인덱스' 필드는 함께 압축하여 연결합니다. 예를 들어, 이것은 from_list() 호출은 각 트리플의 "인덱스" 필드를 (num_qubits-1, ..., 1, 0) 로 설정하여 이 메서드에서 사용하는 형식으로 변환할 수 있습니다.

매개변수

• iter (list[tuple[str, Sequence[int], complex]]) – 레이블의 트리플, 각 단일 큐비트 항이 적용되는 큐비트, 전체 항의 계수입니다.
• num_qubits (int) – 연산자의 큐비트 수입니다.

예제

간단한 연산자를 구축합니다:

>>> SparseObservable.from_sparse_list(
...     [("ZX", (1, 4), 1.0), ("YY", (0, 3), 2j)],
...     num_qubits=5,
... )
<SparseObservable with 2 terms on 5 qubits: (1+0j)(X_4 Z_1) + (0+2j)(Y_3 Y_0)>

관찰 가능한 아이덴티티를 구성합니다(실제로는 그냥 identity()):

>>> SparseObservable.from_sparse_list([("", (), 1.0)], num_qubits=100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

이 메서드는 다음과 같은 동작을 복제할 수 있습니다 from_list()의 동작을 복제할 수 있습니다(트리플의 큐비트 인자 필드가 감소하는 정수로 설정된 경우):

>>> labels = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_sparse_pauli_op(op, /)

를 SparseObservable 인스턴스를 SparsePauliOp 인스턴스를 생성합니다.

이것은 거의 직접 번역한 것입니다 SparsePauliOp특히, 유사 항의 즉석 합산이나 폴리 항의 합을 동등한 투영 연산자로 리팩터화하려는 시도가 없습니다.

매개변수

op (SparsePauliOp) – 연산자에게 변환을 요청합니다.

예제

>>> spo = SparsePauliOp.from_list([("III", 1.0), ("IIZ", 0.5), ("IZI", 0.5)])
>>> SparseObservable.from_sparse_pauli_op(spo)
<SparseObservable with 3 terms on 3 qubits: (1+0j)() + (0.5+0j)(Z_0) + (0.5+0j)(Z_1)>

static from_terms(obj, /, num_qubits=None)

구성 SparseObservable 를 구성합니다.

모든 용어는 동일한 수의 큐비트를 가져야 합니다. 제공된 경우 num_qubits 인수는 조건과 일치해야 합니다.

관찰 가능한 생성의 일부로 단순화는 수행되지 않습니다.

매개변수

• obj (Iterable[Term]) – 개별 용어의 이터러블을 사용하여 관찰 가능한 데이터를 구축할 수 있습니다.
• num_qubits (int | None) – 옵저버블이 작동해야 하는 큐비트 수입니다. 이는 일반적으로 입력에서 추론되지만, 빈 이터러블의 경우를 처리하기 위해 명시적으로 지정할 수 있습니다.

리턴

해당 관찰 가능 항목입니다.

static identity(num_qubits)

주어진 큐비트 수에 대한 ID 연산자를 구합니다.

예제

100큐비트에 대한 ID 연산자를 가져옵니다:

>>> SparseObservable.identity(100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

pauli_bases()

객체를 가져옵니다 PauliList 객체를 가져와서 이 옵저버블의 각 용어에 필요한 측정 기준(순서대로)을 나타냅니다.

예를 들어, 프로젝터 0l+ 는 폴리 ZXY 를 반환합니다. 그 결과 Pauli 는 명시적인 ID가 저장된다는 점에서 밀도가 높습니다. 폴리 출력의 신원 확인에는 구체적인 측정이 필요하지 않습니다.

이렇게 하면 합계의 모든 학기에 대한 폴리 목록의 항목이 반환됩니다.

리턴

필요한 측정 기준을 나타내는 폴리 연산자 목록입니다.

리턴 유형

PauliList

simplify(tol=1e-08)

이 연산자의 모든 유사 항을 합산하여 결과 복소수 계수가 허용 오차 범위 내에서 절대값을 갖는 경우 제거합니다.

부작용으로 연산자를 표준 순서대로 정렬합니다.

매개변수

tol (float) – 와 같은 항을 합산한 후 절대값이 주어진 절대 허용 오차보다 작은 계수는 출력에서 제외됩니다.

예제

를 사용하여 simplify() 를 사용하여 동일한 관측값을 나타내지만 기본적으로 구조적 테스트로 인해 동일하지 않은 두 연산자를 비교할 수 있습니다:

>>> base = SparseObservable.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("+-", (3, 1), 2j),
...     ("+-", (3, 1), 2j),     # can be combined with the above
...     ("01", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = SparseObservable.from_list([("I0I1I", 0.5), ("I+I-I", 4j)])
>>> assert base != expected  # non-canonical comparison
>>> assert base.simplify() == expected.simplify()

위의 예에서는 모든 부동소수점 계산이 정확하고 중간 반올림이나 연관성 문제가 없도록 계수를 선택했습니다. 이것이 보장되지 않는다면 더 안전한 형태가 있습니다:

>>> left = SparseObservable.from_list([("XYZ", 1.0/3.0)] * 3)   # sums to 1.0
>>> right = SparseObservable.from_list([("XYZ", 1.0/7.0)] * 7)  # doesn't sum to 1.0
>>> assert left.simplify() != right.simplify()
>>> assert (left - right).simplify() == SparseObservable.zero(left.num_qubits)

tensor(other, /)

두 관측값의 텐서 곱입니다.

other비트 순서는 인수의 큐비트 인덱스가 그대로 유지되고, 의 self 인덱스가 에 포함된 큐비트 수만큼 오프셋되도록 정의됩니다. 이는 Qiskit의 quantum_info 다른 연산자들도 사용하는 것과 동일한 규칙입니다.

이 함수는 ^ 연산자에 사용됩니다. 이 연산자를 사용하는 경우 Python 의 연산자 우선 순위 규칙에 따라 평가 순서가 예상과 달라질 수 있습니다. 특히 * 이 + 보다 더 단단히 바인딩되는 것처럼 + 연산자는 ^ 보다 더 단단히 바인딩됩니다. 필요한 경우 괄호를 사용하여 평가 순서를 수정합니다.

인수는 기본 생성자를 사용하여 SparseObservable 로 캐스팅됩니다(아직 올바른 형식이 아닌 경우 기본 생성자를 사용).

매개변수

기타 - 텐서 곱의 오른쪽에 놓을 관찰 가능 항목입니다.

예제

비트 순서는 단일 레이블로 만든 두 관측값의 텐서 곱이 두 문자열을 연결하여 만든 관측값과 "비슷하게" 보이도록 합니다:

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == SparseObservable.from_label("XYZ+-IIrl")

텐서 곱에 인픽스 ^ 연산자를 사용할 수도 있는데, 이 연산자는 연산이 아직 없는 경우 마찬가지로 오른쪽을 SparseObservable:

>>> assert SparseObservable("rl") ^ Pauli("XYZ") == SparseObservable("rlXYZ")

to_sparse_list()

관찰 가능 항목을 스파스 목록 형식으로 표현합니다.

의 반대 동작으로 볼 수 있습니다 SparseObservable.from_sparse_list()의 역연산으로 볼 수 있지만, 희소 목록으로 왕복한 후 다시 돌아올 때 용어의 순서가 동일하다고 보장되지는 않습니다.

예제

>>> obs = SparseObservable.from_list([("IIXIZ", 2j), ("IIZIX", 2j)])
>>> reconstructed = SparseObservable.from_sparse_list(obs.to_sparse_list(), obs.num_qubits)

transpose()

이 관측 가능 데이터의 행렬 전치를 계산합니다.

이 연산은 키스킷의 표준 행렬 규칙에 따라 정의되며, 행렬 형식이 $Z$ 계산 기준으로 간주됩니다. X$ 및 $Z$ 관련 알파벳 용어는 전치의 영향을 받지 않지만, $Y$ 관련 용어는 해당 알파벳 용어를 수정합니다. 맞습니다:

• $Y$ 로 전치 $-Y$
• $\lvert r\rangle\langle r\rvert$ 로 전치 $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ 로 전치 $\lvert r\rangle\langle r\rvert$

예제

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.transpose() == SparseObservable([("III", 1j), ("Ylr", -0.5)])

static zero(num_qubits)

주어진 큐비트 수에 대한 영점 연산자를 구합니다.

제로 연산자는 모든 양자 상태에 대해 기대값이 0인 연산자입니다. 조건이 없습니다. 두 개의 인스턴스를 더하기 위한 동일성 요소입니다 SparseObservable 인스턴스를 더하는 식별 요소이며, 0 연산자에 추가된 모든 것은 그 자체와 동일합니다.

프로젝터를 모두 0 상태로 설정하려면 다음을 사용합니다:

>>> num_qubits = 10
>>> all_zeros = SparseObservable.from_label("0" * num_qubits)

예제

100큐비트에 대한 영점 연산자를 구합니다:

>>> SparseObservable.zero(100)
<SparseObservable with 0 terms on 100 qubits: 0.0>