MajoranaOperator

class MajoranaOperator(coeffs, modes, boundaries)

베이스: object

마조라나 페르미온 연산자.

정의

이 연산자는 마조라나 연산자들의 곱의 선형 결합으로 정의되며, [1] 이는 표준 페르미온 2차 양자화 생성 및 소멸 연산자를 통해 정의될 수 있다(참조 FermionOperator):

\gamma = a^\dagger + a ~~\text{and}~~ \gamma' = i(a^\dagger - a)

마요라나 페르미온이 그 자체의 반입자인이라는 핵심적 특성이 즉시 드러납니다:

\gamma_i = \gamma_i^\dagger ~~\text{and}~~ \gamma_i^2 = (\gamma_i^\dagger)^2 = 1

이로 인해 $2n$ 마요라나 페르미온에 대해 다음과 같은 반교환 관계가 성립합니다:

\left\{\gamma_i,\gamma_j\right\} = 2\delta_{ij}

이로써 연산자 전체의 정의는 다음과 같습니다:

\text{\texttt{MajoranaOperator}} = \sum_i c_i \bigotimes_j \hat{\gamma_j} \, ,

여기서 $c_i$ 는 $\gamma_j$ 의 곱들의 선형 조합을 구성하는 (복소수) 계수이다. 지수 $j$ 는 0부터 연산자가 작용하는 마요라나 페르미온 모드의 개수에서 1을 뺀 값 사이의 임의의 값을 가질 수 있다.

구현

이 클래스는 희소 행렬에 흔히 사용되는 압축 희소 행 (compressed sparse row) 형식과 유사하게, 항과 계수를 여러 개의 희소 벡터에 저장합니다. 좀 더 구체적으로 말하자면, 하나의 연산자에는 4개의 배열이 포함되어 있습니다:


`coeffs`	두 개의 64비트 부동소수점 숫자로 구성된 복소수 계수 벡터.
`modes`	작용을 받은 마조라나 모드 인덱스를 저장하는 32비트 정수 벡터입니다.
`boundaries`	. 내의 경계를 나타내는 정수 벡터 `modes`.

정수 modes 인덱스는 마요라나 모드( $j$ )를 나타냅니다 gamma(). 편의 함수 를 사용할 때는 $\gamma$ ( $\gamma'$ )에 대해 짝수(홀수) 인덱스가 사용됩니다.

참고

이러한 내부 배열의 읽기 전용 복사본은 각각의 메서드인 get_coeffs(), get_modes(), 및 을 통해 액세스할 수 있습니다 get_boundaries().

이 데이터 구조를 사용하면 연산자를 매우 효율적으로 생성하고 조작할 수 있습니다. 그러나 이는 연산자에 언제든지 중복된 용어가 포함될 수 있음을 의미합니다. 이러한 문제는 다음을 사용하여 수동으로 해결해야 합니다 simplify().

건설

위에서 설명한 배열을 제공함으로써 연산자를 직접 생성할 수 있습니다:

>>> from qiskit_fermions.operators import MajoranaOperator
>>> coeffs = [1.0, -2.0, 3.0j, -0.5j]
>>> modes = [0, 1, 0, 2, 0, 1, 2, 3]
>>> boundaries = [0, 0, 2, 4, 8]
>>> op = MajoranaOperator(coeffs, modes, boundaries)
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -2.000000e0 +0.000000e0j * (γ0 γ'0)
 -0.000000e0-5.000000e-1j * (γ0 γ'0 γ1 γ'1)
  0.000000e0 +3.000000e0j * (γ0 γ1)

편의를 위해, 다음과 같이 Python 사전에서 연산자를 생성할 수 있습니다:

>>> from qiskit_fermions.operators import gamma
>>> op = MajoranaOperator.from_dict(
...     {
...         (): 1.0,
...         (gamma(0, False), gamma(0, True)): -2.0,
...         (gamma(0, False), gamma(1, False)): 3.0j,
...         (gamma(0, False), gamma(0, True), gamma(1, False), gamma(1, True)): -0.5j,
...     }
... )
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -2.000000e0 +0.000000e0j * (γ0 γ'0)
 -0.000000e0-5.000000e-1j * (γ0 γ'0 γ1 γ'1)
  0.000000e0 +3.000000e0j * (γ0 γ1)

이 예제에서는 마요라나 연산자를 생성하기 위해 gamma() 를 활용했습니다.

또한, 다음과 같은 생성자 및 간편 헬퍼 메서드를 사용할 수 있습니다:


`zero`()	가법 항등 연산자를 생성합니다.
`one`()	곱셈 항등 연산자를 생성합니다.
`from_terms`(용어)	항의 반복자에서 새로운 연산자를 생성합니다(참조 `iter_terms()`).
`from_terms_with_groups`(용어)	그룹이 포함된 항의 반복자에서 새로운 연산자를 생성합니다(참조 `iter_terms_with_groups()`).

형식화

위의 예제에서, 생성된 연산자들은 의 출력 결과를 사용하여 표시되었으며 format(), 그 결과 사람이 읽기 쉬운 형태의 연산자가 생성되었습니다.

>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -2.000000e0 +0.000000e0j * (γ0 γ'0)
 -0.000000e0-5.000000e-1j * (γ0 γ'0 γ1 γ'1)
  0.000000e0 +3.000000e0j * (γ0 γ1)

참고

의 출력 순서는 출력되기 전에 명시적으로 정렬됩니다 format(op) . 따라서 연산자 내부의 항들의 순서를 반영하지 않습니다.

이 함수를 repr() 통해 대체 형식을 얻을 수 있으며, 그 결과로 Python 에서 해석 가능한 표현이 생성됩니다. 다시 말해, 이 출력 결과를 Python 셸에 바로 복사하여 붙여넣을 수 있습니다:

>>> print(repr(op))
MajoranaOperator.from_dict({...})

마지막으로, 대규모 운영자의 경우 이 두 가지 출력 모두 길이가 너무 길어 바람직하지 않을 수 있습니다. 그러면 이 함수를 str() 통해 최소한의 정보만 포함된 매우 간단한 양식을 얻을 수 있습니다:

>>> print(str(op))
<MajoranaOperator with 4 terms>

반복

기본 데이터 구조는 Rust로 구현되어 있고 레이아웃이 복잡하기 때문에, 이를 직접 반복 처리할 수는 없습니다:

>>> list(iter(op))
Traceback (most recent call last):
  ...
TypeError: 'qiskit_fermions.operators.majorana_operator.MajoranaOperator' object is not iterable

대신, 이 클래스는 이러한 목적을 달성하기 위해 사용자 정의 반복자를 제공합니다:

>>> list(sorted(op.iter_terms()))
[([], (1+0j)), ([0, 1], (-2+0j)), ([0, 1, 2, 3], (-0-0.5j)), ([0, 2], 3j)]

관련 참조

iter_terms()

더 자세한 구현 내용에 대해서는 다음을 참조하십시오.

아래 표에는 사용 가능한 모든 반복자가 나열되어 있습니다:


`iter_terms`()	연산자의 항들을 순회하는 이터레이터.
`iter_terms_with_groups`()	연산자의 항들을 순회하며, 각 항에 연관된 군 인덱스를 함께 포함하는 반복자.

산술

다음과 같은 산술 연산이 지원됩니다:

더하기/빼기

>>> op = MajoranaOperator.one()
>>> (op + op).simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> (op - op).simplify()
MajoranaOperator.from_dict({})
>>> op += op
>>> op.simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> op -= op
>>> op.simplify()
MajoranaOperator.from_dict({})

스칼라 곱셈/나눗셈

>>> op = MajoranaOperator.one()
>>> (2 * op).simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> (op / 2).simplify()
MajoranaOperator.from_dict({(): 0.5+0j})
>>> op *= 2
>>> op.simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> op /= 2
>>> op.simplify()
MajoranaOperator.from_dict({(): 1+0j})

연산자 결합법칙

참고

연산자의 합성은 왼쪽 곱셈에 해당합니다: 는 $C = B A$ 에 해당합니다 c = a & b . 다시 말해, 두 연산자의 합성은 “먼저 a 를 수행한 다음 ”을 수행하는 결과 연산자를 반환합니다. b

>>> op1 = MajoranaOperator.from_dict({(): 2.0, (gamma(0, False),): 3.0})
>>> op2 = MajoranaOperator.from_dict({(): 1.5, (gamma(0, True),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (γ0)
  8.000000e0 +0.000000e0j * (γ'0)
  1.200000e1 +0.000000e0j * (γ'0 γ0)
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (γ0)
  1.200000e1 +0.000000e0j * (γ0 γ'0)
  8.000000e0 +0.000000e0j * (γ'0)
>>> squared = (op1 ** 2).simplify()
>>> print(format(squared))
  4.000000e0 +0.000000e0j * ()
  1.200000e1 +0.000000e0j * (γ0)
  9.000000e0 +0.000000e0j * (γ0 γ0)

참고

편의상, 우측 곱셈은 로 구현되며, 이 경우 ( $C = A B$ c = a @ b )와 같은 결과가 나옵니다.

>>> (op1 @ op2).equiv(op2 & op1)
True

기타 조작

위에서 설명한 산술 연산에 해당하는 매직 메서드 외에도 다음과 같은 메서드를 사용할 수 있습니다:


`adjoint`()	이 연산자의 헤르미트 공액(또는 부연산자)을 반환합니다.
`ichop`( [아톨] )	지정된 임계값보다 작은 계수 크기를 가진 항을 제거합니다.
`simplify`( [아톨] )	동등하지만 단순화된 연산자를 반환합니다.
`normal_ordered`( [오름차순, 줄이기] )	일반 순서를 가진 항을 갖는 등가 연산자를 반환합니다.
`relabel_modes`(순열)	모드 이름이 변경된 새로운 연산자를 반환합니다.

특성

마지막으로, 연산자의 특정 성질을 확인하기 위한 다양한 방법이 존재합니다:


`is_hermitian`( [아톨] )	이 연산자가 헤르미트 연산자인지 여부를 반환합니다.
`max_rank`()	이 연산자에 포함된 항들의 최대 차수를 반환합니다.
`is_even`()	이 연산자가 짝수인지 여부를 반환합니다.

[ 1 ]

https://en.wikipedia.org/wiki/Majorana _fermion

속성

groups

각 항에 대한 그룹 인덱스의 선택적 벡터.

자세한 내용은 해당 grouping 모듈을 참조하십시오.

메소드

adjoint

adjoint()

이 연산자의 헤르미트 공액(또는 부연산자)을 반환합니다.

이는 항과 계수에 다음과 같은 영향을 미칩니다:

각 항의 연산 순서가 반대로 바뀝니다
계수들은 복소공액이다

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): -1.0j, (gamma(0, False), gamma(0, True)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (γ'0 γ0)

equiv

equiv(other, atol=1e-08)

이 연산자가 다른 연산자와 동등한지 확인합니다.

이 맥락에서 ‘등가성’이란 지정된 절대 허용오차 범위 내에서 대략적으로 같음을 의미합니다. 더 정확하게 말하면, 이 함수는 차분 식에 포함된 계수들의 절댓값이 모두 지정된 임계값보다 작을 other - self 때 True를 반환합니다 atol.

참고

이것이 바로 여러분이 거의 항상 원하게 되는 수학적 비교입니다. 이는 저장된 항들(계수, 모드 및 내부 항 경계)의 정확한 등가성을 오차 허용 범위나 단순화 없이 검사하는 연산자와는 == 다릅니다. 따라서 수학적으로 동일한 두 연산자는 저장 방식이 다르면 == 에서 서로 다른 값으로 비교될 수 있습니다. 예를 들어, 단순화되지 않은 a + a 와 2 * a, 또는 순서가 다른 항들이 이에 해당합니다. 수치적 허용 오차 범위 내에서 연산자를 비교하려면 equiv 를 사용하십시오.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-7})
>>> zero = MajoranaOperator.zero()
>>> op.equiv(zero)
False
>>> op.equiv(zero, 1e-6)
True
>>> op.equiv(zero, 1e-9)
False

매개변수

기타 – 비교 대상인 다른 연산자.
atol – 비교를 위한 절대 허용 오차. 이 값의 기본값은 1e-8.입니다.

from_dict

classmethod from_dict(data)

사전으로부터 새로운 연산자를 생성합니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (): 1.0-1.0j,
...         (0, 1): 2.0,
...     }
... )
>>> print(format(op))
  1.000000e0 -1.000000e0j * ()
  2.000000e0 +0.000000e0j * (γ0 γ'0)

매개변수

data – 용어 튜플을 복소수 계수에 매핑하는 사전. 각 키는 마요라나 모드를 인덱싱하는 정수 튜플입니다. $\gamma$ 와 $\gamma'$ 에 짝수 및 홀수 인덱스를 할당하는 과정을 간소화하려면 gamma() 를 사용할 수 있습니다.

리턴

새로운 사업자.

from_terms

classmethod from_terms(terms)

항의 반복자에서 새로운 연산자를 생성합니다(참조 iter_terms()).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> op.equiv(MajoranaOperator.from_terms(op.iter_terms()))
True

매개변수

항 – 에 의해 생성된 항의 반복자 iter_terms().

리턴

새로운 사업자.

from_terms_with_groups

classmethod from_terms_with_groups(terms)

그룹이 포함된 항의 반복자에서 새로운 연산자를 생성합니다(참조 iter_terms_with_groups()).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = MajoranaOperator.from_terms_with_groups(op.iter_terms_with_groups())
>>> op.equiv(reconstructed) and op.groups == reconstructed.groups
True

매개변수

항 – 에 의해 생성된 항의 반복자 iter_terms_with_groups().

리턴

새로운 사업자.

get_boundaries

get_boundaries()

연산자 항들 사이의 경계를 나타내는 인덱스로 구성된 읽기 전용 목록을 반환합니다.

참고

이 메서드는 내부 데이터의 복사본 을 반환합니다.

관련 참조

내부 데이터 구조에 대한 설명은 여기에서 확인할 수 있습니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_boundaries()
[0, 0, 2]

리턴

해당 사업자의 이용 약관 범위 목록.

get_coeffs

get_coeffs()

연산자의 계수들로 구성된 읽기 전용 목록을 반환합니다.

참고

이 메서드는 내부 데이터의 복사본 을 반환합니다.

관련 참조

내부 데이터 구조에 대한 설명은 여기에서 확인할 수 있습니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += -1j * MajoranaOperator.one()
>>> op.get_coeffs()
[(1+0j), -1j]

리턴

연산자의 계수 목록.

get_modes

get_modes()

연산자의 적용 대상 모드 인덱스로 구성된 읽기 전용 목록을 반환합니다.

참고

이 메서드는 내부 데이터의 복사본 을 반환합니다.

관련 참조

내부 데이터 구조에 대한 설명은 여기에서 확인할 수 있습니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_modes()
[0, 1]

리턴

이 연산자의 모드 목록입니다.

get_support

get_support()

이 연산자가 적용되는 모드 인덱스 집합을 반환합니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (0, 4): 1,
...         (1, 3, 4, 7): 1,
...     }
... )
>>> assert op.get_support() == {0, 1, 3, 4, 7}

리턴

이 연산자가 작용하는 모드 지수의 집합.

group_weights

group_weights()

각 그룹의 평균 절대 계수 크기를 반환합니다.

i-번째 항은 그룹 내 항들에 대한 abs(coeff) 의 합을 i, 해당 그룹의 항의 개수로 나눈 값이다. 가 일 groups 경우 None, 이 함수는 또한 를 반환합니다 None.

이는 개별 항이 아닌 전체 집단을 추출하는 무작위 제품 공식(예: qDRIFT )의 표본 가중치입니다. NumPy, 에서 groups 와 get_coeffs() 를 축소하는 것보다 네이티브 방식으로 계산하는 것이 훨씬 효율적입니다. 왜냐하면 그 두 액세서리는 그룹화되지 않은 항마다 연산자에서 값을 하나씩 복사한 다음, 이를 다시 그룹당 하나의 값으로 집계해야 하는 반면, 이 방법은 단순히 축소된 num_groups() 값들만을 반환하기 때문입니다.

참고

어떤 항도 포함하지 않는 그룹 인덱스는 의 가중치를 가지며 0.0, 이로 인해 표본에서 제외됩니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.group_weights())
None
>>> op.groups = [0, 1, 0, 1]
>>> op.group_weights()
[1.0, 2.0]

리턴

각 그룹 지수의 평균 절대 계수 크기.

has_groups

has_groups()

이 연산자가 그룹 인덱스를 추적하는지 여부를 반환합니다.

이는 를 확인하는 것과 동일하지만(다만 비용이 더 적게 듭니다) op.groups is not None, 그룹 인덱스를 검사하기 위해 연산자에서 해당 인덱스를 복사해 오지 않기 때문입니다.

참고

이는 groups 가 빈 리스트일 True 때조차 반환되는데, 이는 항을 포함하지 않는 그룹화된 연산자의 상태입니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.has_groups()
False
>>> op.groups = [0, 1, 0, 1]
>>> op.has_groups()
True

리턴

이 연산자에 대해 설정되어 있는지 groups 여부.

ichop

ichop(atol=1e-08)

지정된 임계값보다 작은 계수 크기를 가진 항을 제거합니다.

이 메서드는 연산자를 제자리에서 수정하고 를 반환합니다 None.

주의

이 방법은 계수를 탐욕적으로 잘라냅니다! 작동 대상 연산자에 중복된 항에 대한 별도의 계수가 포함될 수 있다면, 대신 simplify() 를 호출하는 것을 고려해 보세요!

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-4, (0,): 1e-6, (1,): 1e-10})
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
 1.000000e-10 +0.000000e0j * (γ'0)
>>> op.ichop()
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
>>> op.ichop(1e-5)
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()

매개변수

atol – 컷오프에 대한 절대 허용 오차. 이 값의 기본값은 1e-8.입니다.

is_even

is_even()

이 연산자가 짝수인지 여부를 반환합니다.

참고

연산자의 모든 항에 짝수 개의 동작이 포함되어 있는 경우에도 해당 연산자는 짝수 연산자로 간주됩니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1): 1})
>>> op.is_even()
True
>>> op = MajoranaOperator.from_dict({(0,): 1})
>>> op.is_even()
False

리턴

이 연산자가 짝수인지 여부.

is_hermitian

is_hermitian(atol=1e-08)

이 연산자가 헤르미트 연산자인지 여부를 반환합니다.

참고

이 검사는 self 와 그 adjoint() 및 의 normal_ordered() 차이에 대해 equiv() 를 사용하여 구현됩니다 zero().

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1, 2, 3): 1.00001j,
...     (3, 2, 1, 0): -1j,
... })
>>> op.is_hermitian()
False
>>> op.is_hermitian(1e-4)
True

매개변수

atol – 계수들이 서로 같다고 간주되는 수치적 정확도. 이 값의 기본값은 1e-8.입니다.

리턴

이 연산자가 헤르미트 연산자인지 여부.

iter_terms

iter_terms()

연산자의 항들을 순회하는 이터레이터입니다.

경고

반복 항목의 값을 변경해도 기본이 되는 연산자 데이터에는 영향을 미치지 않습니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> list(sorted(op.iter_terms()))
[([], (2+0j)), ([0], (1+0j)), ([1], (-0-1j))]

iter_terms_with_groups

iter_terms_with_groups()

연산자의 항들과 이에 연관된 군 인덱스를 포함하는 이터레이터.

경고

반복 항목의 값을 변경해도 기본이 되는 연산자 데이터에는 영향을 미치지 않습니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> list(op.iter_terms_with_groups())
[([], (2+0j), 0), ([0], (1+0j), 1), ([1], (-0-1j), 1)]

max_rank

max_rank()

이 연산자에 포함된 항들의 최대 차수를 반환합니다.

참고

가장 긴 항의 길이는 연산자의 형태에 따라 달라질 수 있으며, 이는 (예를 들어) 연산자 단순화나 정규 순서 정렬에 따라 최대 랭크가 달라질 수 있음을 의미합니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1, 2, 3): 1})
>>> op.max_rank()
4

리턴

이 연산자의 최대 순위.

normal_ordered

normal_ordered(ascending=False, reduce=True)

일반 순서를 가진 항을 갖는 등가 연산자를 반환합니다.

연산자 항의 정상 순서는 모든 동작이 사전적 순서대로 정렬되도록 정의된다. 상승할지 하강할지는 ascending 매개변수의 값에 따라 달라집니다. $\gamma$ ( $\gamma'$ )를 짝수(홀수) 인덱스에 배치하도록 gamma() 정해진 관례에 따라, 다음 예시(기본값인 경우 ascending=False)가 도출됩니다: [\gamma(1, True), \gamma(1, False), \gamma(0, True), \gamma(0, False)] = [3, 2, 1, 0].

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(gamma(0, False), gamma(0, True), gamma(0, False)): 1})
>>> print(format(op.normal_ordered(reduce=False)))
 -1.000000e0 +0.000000e0j * (γ'0 γ0 γ0)
>>> print(format(op.normal_ordered(reduce=True)))
 -1.000000e0 +0.000000e0j * (γ'0)

매개변수

오름차순 – 지수가 오름차순으로 정렬될지 내림차순으로 정렬될지 여부.
축소 – 항의 제곱이 항등식과 같아지는 항을 제거하여 각 항을 최소 형태로 축소할지 여부. 위의 예시도 참고하십시오.

리턴

동등하지만 정상 순서를 갖는 연산자.

num_groups

num_groups()

그룹의 개수를 반환합니다.

가 일 groups 경우 None, 이 함수는 또한 를 반환합니다 None. 그렇지 않으면, 가장 큰 그룹 인덱스에 1을 더한 값(따라서 다음 그룹의 인덱스로 사용될 수 있음)으로 정의된 그룹 수를 반환합니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.groups = [0, 1, 0, 1]
>>> op.num_groups()
2

리턴

[가장 큰 그룹 지수]가 1 포인트 groups 상승했다.

one

classmethod one()

곱셈 항등 연산자를 생성합니다.

이 방법으로 생성된 연산자를 다른 연산자와 결합해도 아무런 효과가 없습니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> one = MajoranaOperator.one()
>>> op & one == op
True

relabel_modes

relabel_modes(permutation)

모드 이름이 변경된 새로운 연산자를 반환합니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1): 1,
...     (0, 1, 2, 3): 1,
... })
>>> permutation = [5, 6, 4, 3]
>>> relabeled = op.relabel_modes(permutation)
>>> print(format(relabeled))
  1.000000e0 +0.000000e0j * (γ'2 γ3)
  1.000000e0 +0.000000e0j * (γ'2 γ3 γ2 γ'1)

매개변수

순열 – 인덱스 순열 목록. 'Mode'는 로 재명명되므로 i``permutation[i] , 이 목록에는 중복 항목이 포함되어서는 안 되며, 연산자가 작용하는 모든 모드를 인덱싱할 수 있을 만큼 충분히 길어야 합니다(목록의 길이는 연산자의 최대 모드 인덱스를 초과해야 합니다).

리턴

모드 이름이 변경된 새로운 연산자.

인상

ValueError – 만약 에 중복 항목이 포함되어 permutation 있거나, 연산자가 적용되는 모드를 재지정하기에는 길이가 너무 짧을 경우.

simplify

simplify(atol=1e-08)

동등하지만 단순화된 연산자를 반환합니다.

단순화 과정에서는 먼저 동일한 항에 속하는 모든 계수를 합산한 다음, 총 계수가 지정된 허용 오차를 초과하는 계수만 남깁니다 (와 마찬가지로 ichop()).

연산자가 산술적으로 변형되거나, 고유한 항을 보장하지 않는 방식으로 구성된 경우, 정보 손실을 방지하기 위해 수치적으로 작은 계수를 걸러내는 어떤 메서드를 적용하기 전에 이 메서드를 호출해야 합니다. 아래 예시를 보면, 가 절단되어서는 안 되는 총 계수 크기를 합산하는 항들을 어떻게 절단할 ichop() 수 있는지 확인할 수 있습니다:

>>> from qiskit_fermions.operators import MajoranaOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = MajoranaOperator(coeffs, [], boundaries)
>>> canon = op.simplify(1e-4)
>>> assert canon.equiv(op.one(), 1e-6)
>>> op.ichop(1e-4)
>>> assert op.equiv(op.zero(), 1e-6)

매개변수

atol – 컷오프에 대한 절대 허용 오차. 이 값의 기본값은 1e-8.입니다.

리턴

동등하지만 단순화된 연산자.

split_out_groups

split_out_groups(group_indices=None)

이 연산자를 에 따라 선택적인 새 연산자 목록으로 분할합니다 groups.

가 일 groups 경우 None, 이 함수는 또한 를 반환합니다 None. 그렇지 않은 경우, group_indices 가 None (기본값)이면, 내의 각 그룹 인덱스에 대해 인덱스 순서대로 하나의 새로운 연산자로 구성된 groups 목록을 반환합니다. group_indices 가 주어지면, 요청된 인덱스들만 주어진 순서대로 생성됩니다. 이를 통해 절대 사용되지 않는 그룹에 대한 연산자를 생성하는 데 드는 비용을 피할 수 있으며, 이는 전체 그룹 중 극히 일부만 필요한 경우, 예를 들어 무작위 곱 공식(randomized product formula)을 위해 그룹을 부분 표본 추출할 때 특히 유용합니다. 에 있는 중복 인덱스는 발생 횟수만큼 한 번씩 반환됩니다 group_indices .

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0, 1]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([0, 1], (1+0j)), ([1, 0], (-1+0j))]
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]

매개변수

group_indices – 연산자를 생성할 그룹 인덱스로, 원하는 출력 순서대로 지정합니다. 생략할 경우, 모든 그룹이 인덱스 순서대로 생성됩니다.

리턴

요청된 각 그룹 인덱스에 대해 하나의 새로운 연산자로 구성된 선택적 벡터.

zero

classmethod zero()

가법 항등 연산자를 생성합니다.

이 방법으로 생성된 연산자를 다른 연산자에 더해도 아무런 효과가 없습니다.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> zero = MajoranaOperator.zero()
>>> op + zero == op
True

프로토콜 방법

_anti_commutator_

static _anti_commutator_(op_a, op_b)

_commutator_

static _commutator_(op_a, op_b)

_double_commutator_

static _double_commutator_(op_a, op_b, op_c, sign)

_fermion_operator_

_fermion_operator_()

이 연산자를 FermionOperator.로 변환합니다.

이는 에 위임함으로써 SupportsFermionOperator 프로토콜을 구현합니다 majorana_to_fermion().

이 페이지가 도움이 되었습니까?

GitHub에서 버그, 오타를 보고하거나 컨텐츠를 요청하십시오.