PauliLindbladMap

class qiskit.quantum_info.PauliLindbladMap(data, /, num_qubits=None)

베이스: object

쿼비트 스파스 형식으로 저장된 폴리 린드블래드 맵입니다.

수학

폴리-린드블라드 맵은 $n$ -큐비트 형식의 밀도 행렬에 따라 작동하는 선형 맵입니다:

\Lambda\bigl[\circ\bigr] = \exp\left(\sum_{P \in K} \lambda_P (P \circ P - \circ)\right)

여기서 $K$ 는 $n$ 의 1-큐비트 파울리 연산자 집합의 부분집합이며, 속도 또는 계수 $\lambda_P$ 는 실수이다. $\lambda_P$ 의 모든 계수가 비음수일 때, 이는 완전히 양의 값을 가지며 트레이스를 보존하는 매핑에 해당한다. 지수함수 내의 합을 생성자라고 하며, 각 항을 생성항이라고 한다. 이 문서의 나머지 부분에서 표기법을 간소화하기 위해, $L(P)\bigl[\circ\bigr] = P \circ P - \circ$ 로 표기합니다.

준확률 표현

$\Lambda$ 지도를 상품으로 작성할 수 있습니다:

\Lambda\bigl[\circ\bigr] = \prod_{P \in K}\exp\left(\lambda_P(P \circ P - \circ)\right).

$P$ , 각각에 대해 다음을 보유합니다

\exp\left(\lambda_P(P \circ P - \circ)\right) = \omega(\lambda_P) \circ + (1 - \omega(\lambda_P)) P \circ P,

여기서 $\omega(x) = \frac{1}{2}(1 + e^{-2 x})$ . $\lambda_P \geq 0$ , $\omega(\lambda_P) \in (\frac{1}{2}, 1]$ , 이 용어는 완전히 긍정적이고 추적을 보존하는 맵입니다. 그러나 $\lambda_P < 0$ , $\omega(\lambda_P) > 1$ 및 지도가 완전히 긍정적이거나 흔적을 보존하지 않는 경우. $\gamma_P = \omega(\lambda_P) + |1 - \omega(\lambda_P)|$ , $p_P = \omega(\lambda_P) / \gamma_P$ 및 $b_P \in \{0, 1\}$ 을 $\lambda_P < 0$ 인 경우 $1$ 으로, 그렇지 않으면 $0$ 으로 맵을 다시 작성합니다:

\omega(\lambda_P) \circ + (1 - \omega(\lambda_P)) P \circ P = \gamma_P \left(p_P \circ + (-1)^{b_P}(1 - p_P) P \circ P\right).

$\lambda_P \geq 0$ , $\gamma_P = 1$ 이고 표현식이 아이덴티티 맵과 활용의 표준 혼합으로 축소되는 경우 $P$ 입니다. $\lambda_P < 0$ , $\gamma_P > 1$ , 그리고 맵이 아이덴티티 맵과 활용의 스케일링된 차이에 확률 가중치(따라서 "준확률")가 있는 $P$ 로 축소된 경우. 이는 문헌과 약간 다른 표기법이지만, 이 표기법을 사용하면 음수가 아닌 비율과 음수가 아닌 비율을 동시에 처리할 수 있습니다. 채널의 전체 $\gamma$ 는 $\gamma = \prod_{P \in K} \gamma_P$ 제품입니다.

이 지도의 샘플링 절차는 PauliLindbladMap.sample() 메서드를 참조하세요.

표현

제너레이터의 각 개별 폴리 연산자는 $A^{(n)}_i \in \{I, X, Y, Z\}$ 의 경우 $P = \bigotimes_n A^{(n)}_i$ 형식의 단일 큐비트 폴리 연산자의 텐서 곱입니다. 의 내부 표현은 PauliLindbladMap 의 내부 표현은 비아이디 단일 큐비트 폴리 연산자만 저장합니다. 따라서 $\sum_{n\in \text{qubits}} c_n L(Z^{(n)})$ 과 같은 제너레이터를 표현하는 것이 훨씬 더 효율적입니다 PauliLindbladMap 는 총 큐비트 수에 선형적인 메모리 양을 필요로 합니다.

내부적으로, PauliLindbladMap 는 속도 배열과 대응하는 스파스 파울리 연산자를 포함하는 QubitSparsePauliList 를 저장한다. 또한, 방법을 gamma() 통해 전체 채널 확률 분포 함수( $\gamma$ )를 계산할 PauliLindbladMap 수 있으며, 방법을 probabilities() 통해 해당 확률( $p_P$ )도 계산할 수 있습니다.

색인화

PauliLindbladMap 은 Python 시퀀스 (확장된 형식이 아닌 표준 형식인 collections.abc.Sequence). 맵의 제너레이터는 정수로 색인화할 수 있으며, 이를 반복하여 개별 제너레이터 용어를 생성할 수 있습니다.

각 제너레이터 용어는 인스턴스로서 독립된 클래스로 나타납니다. 개별 용어는 기본 맵에서 복사되며, 용어에 대한 변경은 색인이 생성되는 원본 맵에는 영향을 미치지 않습니다.

GeneratorTerm

class GeneratorTerm(rate, qubit_sparse_pauli)

GitHub

베이스: object

전체 용어의 단일 용어 PauliLindbladMap.

이들은 일반적으로 인덱싱하거나 PauliLindbladMap.

copy

copy()

이 학기 사본을 받아보세요.

indices

각 비식별 단일 큐비트 용어의 인덱스에 대한 읽기 전용 보기입니다.

인덱스는 항상 정렬된 순서로 표시됩니다.

num_qubits

용어가 정의된 큐비트 수입니다.

pauli_labels

pauli_labels()

용어의 파울리 레이블을 문자열로 반환합니다.

폴리 레이블은 문자열의 i 번째 문자가 쿼비트 인덱스에 적용되도록 GeneratorTerm.indices의 순서와 일치하므로 문자열의 i 번째 문자가 term.indices[i] 의 큐비트 인덱스에 적용됩니다. E.g. 연산자 X 가 쿼비트 0에 작용하고 Y 가 쿼비트 3 에 작용하는 용어는 term.indices == np.array([0, 3]) 와 term.pauli_labels == "XY" 를 갖습니다.

리턴

연결된 문자열로서의 비식별 비트 용어입니다.

paulis

개별 단일 큐비트 용어에 대한 읽기 전용 보기.

배열에서 유효한 값은 Pauli 에 해당하는 값뿐입니다.

qubit_sparse_pauli

용어는 쿼비트_스파스_폴리입니다.

rate

해당 기간의 요율입니다.

to_pauli_lindblad_map

to_pauli_lindblad_map()

이 용어를 완전한 PauliLindbladMap.

생성

PauliLindbladMap 는 여러 생성자를 정의합니다. 기본 생성자는 입력 유형에 따라 보다 구체적인 생성자 중 하나에 위임을 시도합니다. 언제든지 특정 생성자를 사용하여 구성을 더 잘 제어할 수 있습니다.

방법	요약
`from_list()`	밀도가 높은 문자열 레이블의 튜플 목록과 관련 비율로 제공되는 생성기입니다.
`from_sparse_list()`	희소 문자열 레이블의 튜플 목록으로 제공되는 제너레이터, 적용되는 큐비트 및 그 비율입니다.
`from_terms()`	명시적 단일 `GeneratorTerm` 인스턴스를 합산합니다.
`from_components()`	다양한 요금 배열과 `QubitSparsePauliList` 인스턴스

new

__new__(data, /, num_qubits=None)

의 기본 생성자 PauliLindbladMap.

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

매개변수

데이터 - 입력의 데이터 유형입니다. 이것은 다른 PauliLindbladMap일 수도 있고, 입력이 복사되는 경우 유효한 형식의 목록일 수도 있습니다 from_list() 또는 from_sparse_list().
num_qubits (int|None) – 지도의 큐비트 수(선택 사항)입니다. 대부분의 데이터 입력은 추론이 가능하므로 전달할 필요가 없습니다. 빈 목록 또는 희소 목록 형식에만 필요합니다. 불필요하게 주어진 경우 입력된 데이터와 일치해야 합니다.

변환 기반 생성자 외에도 특별한 형태의 맵을 생성하는 헬퍼 메서드도 있습니다.

방법	요약
`identity()`	주어진 수의 큐비트에 대한 아이덴티티 맵입니다.

변환

기존 PauliLindbladMap 을 다른 형식으로 변환할 수 있습니다.

방법	요약
`to_sparse_list()`	요소를 사용하여 희소 목록 형식으로 맵을 표현 `(paulis, indices, rate)`.

속성

num_qubits

맵이 작동하는 큐비트 수입니다.

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

num_terms

이 맵의 지수에 포함된 제너레이터 항의 수입니다.

rates

지도의 요금입니다.

메소드

apply_layout

apply_layout(layout, num_qubits=None)

이 폴리 린드블라드 맵에 트랜스파일러 레이아웃을 적용합니다.

이를 통해 예를 들어 맵이 가상 큐비트 레이블로 정의된 경우 큐비트 인덱스의 리매핑이 가능합니다.

매개변수

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

리턴

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

clear

clear()

이 맵에서 모든 제너레이터 용어를 지우고 다시 아이덴티티 맵과 동일하게 만듭니다.

이는 내부 할당 용량을 변경하지 않으므로, 조합으로 인해 발생하는 후속 덧셈 또는 뺄셈 연산 시 재할당이 필요하지 않을 수 있습니다.

예제

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXXXYY", 2.0), ("ZZYZII", -1)])
>>> pauli_lindblad_map.clear()
>>> assert pauli_lindblad_map == PauliLindbladMap.identity(pauli_lindblad_map.py_num_qubits())

compose

compose(other)

다른 사람과 함께 작성 PauliLindbladMap.

이렇게 하면 self와 other의 내부 배열이 추가되므로 열거된 용어가 self의 용어 다음에 other의 용어가 있는 맵이 생성됩니다.

매개변수

other (PauliLindbladMap) – 폴리 린드블래드 지도를 사용하여 작성할 수 있습니다.

copy

copy()

폴리 린드블래드 지도를 다운로드하세요.

예제

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXZXYYZZ", 2.5), ("ZXIXYYZZ", 0.5)])
>>> assert pauli_lindblad_map == pauli_lindblad_map.copy()
>>> assert pauli_lindblad_map is not pauli_lindblad_map.copy()

drop_paulis

drop_paulis(indices)

폴리 린드블라드 맵에서 폴리스를 삭제합니다.

주어진 인덱스에 모든 폴리를 드롭하여 효과적으로 아이덴티티로 대체합니다.

결과 맵에 중복이 포함될 수 있으며, 이러한 중복은 PauliLindbladMap.simplify() 메서드를 사용하여 제거할 수 있습니다.

매개변수

indices (Sequence[int]) – 폴리스를 삭제해야 하는 인덱스입니다.

리턴

주어진 인덱스의 모든 폴리가 삭제된 새로운 폴리 린드블래드 맵입니다.

예제

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

drop_qubits

drop_qubits(indices)

이 폴리 린드블래드 맵에서 큐비트를 드롭하여 효과적으로 추적 작업을 수행합니다.

결과 맵에 중복이 포함될 수 있으며, 이러한 중복은 PauliLindbladMap.simplify() 메서드를 사용하여 제거할 수 있습니다.

매개변수

indices (Sequence[int]) – 추적할 큐비트의 인덱스입니다.

리턴

주어진 인덱스의 모든 폴리를 추적할 수 있는 새로운 폴리 린드블래드 맵입니다.

예제

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.drop_qubits([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

from_components

static from_components(rates, qubit_sparse_pauli_list)

from_list

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

밀집된 발전기 레이블과 요금 목록에서 폴리 린드블래드 지도를 작성합니다.

이것은 SparsePauliOp.from_list(). 이 밀도 높은 양식에서는 각 레이블에 모든 ID를 명시적으로 제공해야 합니다.

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

매개변수

iter (list[tuple[str, float]]) – 생성기의 레이블 쌍과 관련 요율을 합산합니다.
num_qubits (int | None) – iter 이 빈 시퀀스가 아닌 것이 확실하다면 레이블 길이를 통해 유추할 수 있으므로 이를 지정할 필요가 없습니다. iter 이 비어 있을 수 있는 경우, 이 인수를 지정하여 맵이 작동하는 큐비트 수를 명확히 해야 합니다. 이 값이 주어지고 iter 이 비어 있지 않은 경우, 이 값은 레이블 길이와 일치해야 합니다.

예제

레이블 목록에서 폴리 린드블래드 맵을 작성합니다:

>>> PauliLindbladMap.from_list([
...     ("IIIXX", 1.0),
...     ("IIYYI", 1.0),
...     ("IXXII", -0.5),
...     ("ZZIII", -0.25),
... ])
<PauliLindbladMap with 4 terms on 5 qubits:
    (1)L(X_1 X_0) + (1)L(Y_2 Y_1) + (-0.5)L(X_3 X_2) + (-0.25)L(Z_4 Z_3)>

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

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

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

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

from_sparse_list

static from_sparse_list(iter, /, num_qubits)

레이블 목록, 각 항목에 적용되는 큐비트, 전체 용어의 비율로 폴리 린드블래드 맵을 구성합니다.

이것은 SparsePauliOp.from_sparse_list().

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

매개변수

iter (list[tuple[str, Sequence[int], float]]) – 레이블의 세 배, 각 단일 큐비트 용어가 적용되는 큐비트, 전체 용어의 비율로 구성됩니다.
num_qubits (int) – 맵이 작동하는 큐비트 수입니다.

예제

간단한 지도를 만듭니다:

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

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

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

from_terms

static from_terms(obj, /, num_qubits=None)

구성 PauliLindbladMap 를 구성합니다.

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

지도 생성 시 단순화 작업은 수행되지 않습니다.

매개변수

obj (Iterable[Term]) – 지도 생성기를 구축할 개별 용어의 반복 가능 항목입니다.
num_qubits (int | None) – 맵이 작동해야 하는 큐비트 수입니다. 이는 일반적으로 입력에서 추론되지만, 빈 이터러블의 경우를 처리하기 위해 명시적으로 지정할 수 있습니다.

리턴

해당 지도입니다.

gamma

gamma()

지도의 $\gamma$ 을 계산합니다.

generators

generators()

지도의 생성기를 가져옵니다.

이는 의 get_qubit_sparse_pauli_list_copy()별칭으로, Aer 및 Runtime에서 유사한 클래스에 적용되는 명명 규칙에 부합하는 더 편리한 이름을 제공합니다.

리턴

지도 생성기 이용 약관의 사본.

리턴 유형

QubitSparsePauliList

get_qubit_sparse_pauli_list_copy

get_qubit_sparse_pauli_list_copy()

지도의 쿼비트 스파스 폴리 목록 사본을 가져옵니다.

identity

static identity(num_qubits)

주어진 큐비트 수에 대한 ID 맵을 가져옵니다.

아이덴티티 맵은 생성자 용어를 포함하지 않으며, 두 인스턴스의 구성을 위한 아이덴티티 요소입니다 PauliLindbladMap 인스턴스를 구성하는 아이덴티티 요소이며, 아이덴티티 맵으로 구성된 모든 것은 그 자체와 동일합니다.

예제

100개의 큐비트에서 ID 맵을 가져옵니다:

>>> PauliLindbladMap.identity(100)
<PauliLindbladMap with 0 terms on 100 qubits: 0.0>

inverse

inverse()

새로운 PauliLindbladMap 를 반환하는데, 이는 자기의 수학적 역수입니다.

keep_paulis

keep_paulis(indices)

모든 폴리는 주어진 인덱스에 유지하고 다른 모든 폴리는 삭제합니다.

이는 보완 인덱스 집합에서 PauliLindbladMap.drop_paulis() 를 사용하는 것과 같습니다.

매개변수

indices (Sequence[int]) – 폴리스를 유지해야 하는 인덱스입니다.

리턴

주어진 인덱스의 모든 폴리는 유지되고 다른 모든 폴리는 삭제된 새로운 폴리 린드블래드 맵입니다.

예제

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

keep_qubits

keep_qubits(indices)

주어진 인덱스의 모든 큐비트를 유지하고 다른 모든 큐비트를 추적합니다.

이는 보완 인덱스 집합에서 PauliLindbladMap.drop_qubits() 를 사용하는 것과 같습니다.

매개변수

indices (Sequence[int]) – 큐비트를 보관해야 하는 인덱스입니다.

리턴

주어진 인덱스의 모든 큐비트가 유지되고 다른 모든 큐비트가 추적된 새로운 폴리 린드블래드 맵입니다.

예제

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_qubits([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

parity_sample

parity_sample(num_samples, seed=None, scale=None, local_scale=None)

지도의 샘플 부호와 폴리 연산자 쌍을 살펴봅니다.

각 기호는 부울 값으로 표현되며, 는 를 True 나타내고 -1, 는 를 False 나타낸다 +1.

클래스 수준 문서에 주어진 준확률 표현이 주어지면 각 샘플은 다음 프로세스를 통해 추출됩니다:

부호 부울을 초기화하고, ID 연산자에게 QubitSparsePauli 인스턴스를 초기화합니다.
지도의 각 폴리를 반복합니다. 각 연산자와 관련된 의사 확률을 사용하여 연산자를 적용할지 여부를 무작위로 선택합니다.
연산자가 적용된 경우 :class`QubitSparsePauli` 에 폴리를 곱하여 업데이트합니다. 폴리와 관련된 비율이 음수이면 부호 부울을 뒤집습니다.

결과는 부울의 1d 배열로 반환되며, 해당 샘플링된 큐비트 스파스 폴리스는 QubitSparsePauliList.

인수 scale 와 는 현재 인스턴스를 수정하거나 새 인스턴스를 생성할 필요 없이 local_scale 샘플링 프로세스에 사용되는 기본 비율을 변경하는 데 사용할 수 있습니다. 해당 scale 인수는 모든 비율을 고정된 부동 소수점으로 조정하며, 각 항별로 local_scale 비율을 조정합니다.

매개변수

num_samples (int) – 추첨할 샘플 수입니다.
seed (int) – 무작위 시드.
scale (float) – 모든 요율에 적용할 규모.
local_scale (list[float]) – 학기별로 적용할 지역 규모.

리턴

부호의 부울 배열과 큐비트 스파스 폴리 목록입니다.

리턴 유형

부호, 쿼비트_스파스_폴리_리스트

parity_sample_with_history

parity_sample_with_history(num_samples, seed=None, scale=None, local_scale=None)

맵에서 샘플 사인과 파울리 연산자 쌍을 추출하되, 샘플링된 생성자는 그대로 유지합니다.

이 방법은 최종 파울리 연산자와 부호를 도출하기 위해 실제로 표본 추출된 정보를 generators() 추가로 반환한다는 점을 제외하면 와 parity_sample() 동일합니다.

매개변수

num_samples (int) – 추첨할 샘플 수입니다.
seed (int) – 무작위 시드.
scale (float) – 모든 요율에 적용할 규모.
local_scale (list[float]) – 학기별로 적용할 지역 규모.

리턴

다음과 같은 부울 배열

부호, 큐비트 스파스 파울리 행렬 목록, 어떤 큐비트가 generators() 샘플링되었는지를 나타내는 2차원 부울 배열, 그리고 해당 큐비트의 부호를 나타내는 2차원 부울 배열.

리턴 유형

signs, qubit_sparse_pauli_list, pauli_history, signs_history

pauli_fidelity

pauli_fidelity(qubit_sparse_pauli)

큐비트 희소 폴리에 대한 이 맵의 폴리 충실도를 계산합니다.

폴리 $Q$ 의 경우, 폴리 린드블라드 지도 $\Lambda$ 에 대한 충실도는 실수 $f(Q)$ 이며, $\Lambda(Q) = f(Q) Q$ . I.e. 모든 폴리는 선형 맵 $\Lambda$ 의 고유 벡터이며, 충실도는 해당 고유값입니다. 제너레이터 세트 $K$ 와 비율 함수 $\lambda : K \rightarrow \mathbb{R}$ 를 사용하는 폴리 린드블래드 맵의 경우 수학적으로 폴리 충실도는 다음과 같습니다

f(Q) = \exp\left(-2 \sum_{P \in K} \lambda(P) \langle P, Q\rangle_{sp}\right),

여기서 $\langle P, Q\rangle_{sp}$ 은 $P$ , $Q$ 출퇴근하는 경우 $0$ , 출퇴근 반대인 경우 $1$ 입니다.

인수: 쿼비트_스파스_폴리 ( QubitSparsePauli ): 폴리를 계산할 쿼비트 스파스 폴리입니다

충실도.

probabilities

probabilities()

지도에 대한 확률 $p_P$ 을 계산하십시오. 이는 각 생성자가 적용되지 않을 확률로 해석될 수 있으며, 각 린드블라드 비율의 부호와 독립적으로 정의된다.

sample

sample(num_samples, seed=None)

순수하게 비음수 비율을 갖는 경우에 PauliLindbladMap 대해, 매핑으로부터 파울리 연산자를 추출한다. 지도에 음수 비율이 있는 경우 를 사용하십시오 PauliLindbladMap.parity_sample().

클래스 수준 문서에 주어진 준확률 표현이 주어지면 각 샘플은 다음 프로세스를 통해 추출됩니다:

:class`~.QubitSparsePauli` 인스턴스를 ID 연산자에게 초기화합니다.
지도의 각 폴리를 반복합니다. 각 연산자와 관련된 의사 확률을 사용하여 연산자를 적용할지 여부를 무작위로 선택합니다.
연산자가 적용된 경우 :class`QubitSparsePauli` 에 폴리를 곱하여 업데이트합니다.

샘플링된 큐비트 스파 스 폴리는 QubitSparsePauliList.

매개변수

num_samples (int) – 추첨할 샘플 수입니다.
seed (int) – 무작위 시드. 기본값은 None 입니다.

리턴

쿼비트 스파스 폴리스 목록입니다.

리턴 유형

쿼비트_스파스_폴리_리스트

레이즈

ValueError - 지도의 요금이 음수인 경우.

scale_rates

scale_rates(scale_factor)

새 PauliLindbladMap 를 반환하며, 비율은 scale_factor에 따라 조정됩니다.

매개변수

scale_factor (float) – 스케일링 계수입니다.

signed_sample

signed_sample(num_samples, seed=None)

지도에서 추출한 사인 함수와 파울리 연산자 쌍 이 메서드에서 부울 부호 규칙은 비표준임을 유의하십시오. 이러한 종류의 샘플링에 선호되는 방법은 [이 방법]이며 PauliLindbladMap.parity_sample(), 또한 더 많은 기능을 제공합니다.

각 기호는 부울로 표시되며 True 은 +1 을 나타내고 False 은 -1 을 나타냅니다.

클래스 수준 문서에 주어진 준확률 표현이 주어지면 각 샘플은 다음 프로세스를 통해 추출됩니다:

부호 부울을 초기화하고, ID 연산자에게 QubitSparsePauli 인스턴스를 초기화합니다.
지도의 각 폴리를 반복합니다. 각 연산자와 관련된 의사 확률을 사용하여 연산자를 적용할지 여부를 무작위로 선택합니다.
연산자가 적용된 경우 :class`QubitSparsePauli` 에 폴리를 곱하여 업데이트합니다. 폴리와 관련된 비율이 음수이면 부호 부울을 뒤집습니다.

결과는 부울의 1d 배열로 반환되며, 해당 샘플링된 큐비트 스파스 폴리스는 QubitSparsePauliList.

매개변수

num_samples (int) – 추첨할 샘플 수입니다.
seed (int) – 무작위 시드.

리턴

부호의 부울 배열과 큐비트 스파스 폴리 목록입니다.

리턴 유형

부호, 쿼비트_스파스_폴리_리스트

simplify

simplify(tol=1e-08)

생성자 내의 같은 항들을 합산하고, 그 결과로 나온 비율이 0의 허용 오차 범위 내에 있는 경우 해당 항들을 제거한다. 또한 이는 파울리 연산자가 항등 연산자와 비례하는 항들을 제거하는데, 이는 해당 생성자가 실제로는 영 매핑이기 때문이다.

부작용으로 생성기가 고정된 표준 순서로 정렬됩니다.

참고

이것을 등가 비교에 사용할 때는, 부동소수점 반올림과 부동소수점 덧셈의 비결합성으로 인해 합계 항의 계수가 0이 아닐 경우 서로 다르게 비교될 수 있다는 점에 유의하십시오. 두 관측량을 허용 오차 범위 내에서 비교하려면, 두 관측량의 정규화된 차이를 0과 비교하는 것이 가장 안전한 방법이다.

매개변수

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

예제

를 사용하여 simplify() 를 사용하여 동일한 맵을 나타내는 두 연산자를 비교하지만 기본적으로 구조적 테스트로 인해 동일하지 않게 비교됩니다:

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

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

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

to_sparse_list

to_sparse_list()

맵을 희소 목록 형식으로 표현합니다.

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

예제

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IIXIZ", 2), ("IIZIX", 3)])
>>> reconstructed = PauliLindbladMap.from_sparse_list(pauli_lindblad_map.to_sparse_list(), pauli_lindblad_map.num_qubits)