FermionOperator

class FermionOperator(coeffs, actions, modes, boundaries)

베이스: object

스핀이 없는 페르미온 연산자.

정의

이 연산자는 스핀이 없는 페르미온 모드에 작용하는 페르미온 생성 및 소멸 연산자의 곱들의 선형 조합으로 정의된다. 즉, 각 항은 다음과 같은 반교환 관계를 만족한다: [1]

\left\{a^\dagger_i, a^\dagger_j\right\} = \left\{a_i, a_j\right\} = 0,~~\text{and}~~ \left\{a_i, a^\dagger_j\right\} = \delta_{ij} \, ,

여기서 $i$ 와 $j$ 는 이들이 지수를 부여하는 페르미온 모드의 스핀 종류를 구분하지 않는다.

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

\text{\texttt{FermionOperator}} = \sum_i c_i \bigotimes_j \hat{A_j} \, ,

여기서 $\hat{A_j} \in \{ a_j, a^\dagger_j \}$ 이며, $c_i$ 는 곱의 선형 조합을 구성하는 (복소수) 계수이다. $j$ 의 지수는 0부터 연산자가 작용하는 페르미온 모드의 개수에서 1을 뺀 값 사이의 임의의 값을 가질 수 있다.

구현

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

칼럼 1	칼럼 2
`coeffs`	두 개의 64비트 부동소수점 숫자로 구성된 복소수 계수 벡터입니다.
`actions`	2차 양자화 작업의 특성을 저장하는 부울 값 벡터.
`modes`	작동이 적용된 페르미온 모드 인덱스를 저장하는 32비트 정수 벡터.
`boundaries`	와 `actions` 에서 경계를 나타내는 정수 벡터 `modes`.

()로 표시된 항목은 True (False)에 의한 생성(소멸) 연산자를 나타냅니다 actions . 로 인덱싱된 페르미온 모드는 스핀이 없는 것으로 간주됩니다 modes .

참고

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

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

건설

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

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

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

>>> from qiskit_fermions.operators import cre, ann
>>> op = FermionOperator.from_dict(
...     {
...         (): 1.0,
...         (cre(0),): 2.0,
...         (ann(0),): -3.0,
...         (ann(0), cre(1)): 4.0j,
...         (cre(0), cre(1), ann(2), ann(3)): -0.5j,
...     }
... )
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -3.000000e0 +0.000000e0j * (-0)
  0.000000e0 +4.000000e0j * (-0 +1)
  2.000000e0 +0.000000e0j * (+0)
 -0.000000e0-5.000000e-1j * (+0 +1 -2 -3)

이 예제에서는 지정된 모드에서 생성 및 소멸 연산자를 생성하기 위해 ann() cre() 와 를 활용했습니다.

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

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

형식화

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

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

참고

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

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

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

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

>>> print(str(op))
<FermionOperator with 5 terms>

반복

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

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

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

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

관련 참조

iter_terms()

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

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

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

산술

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

더하기/빼기

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

스칼라 곱셈/나눗셈

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

연산자 결합 규칙

참고

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

>>> op1 = FermionOperator.from_dict({(): 2.0, (cre(0),): 3.0})
>>> op2 = FermionOperator.from_dict({(): 1.5, (ann(1),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  8.000000e0 +0.000000e0j * (-1)
  1.200000e1 +0.000000e0j * (-1 +0)
  4.500000e0 +0.000000e0j * (+0)
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  8.000000e0 +0.000000e0j * (-1)
  4.500000e0 +0.000000e0j * (+0)
  1.200000e1 +0.000000e0j * (+0 -1)
>>> 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

기타 조작

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

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

특성

마지막으로, 연산자의 특정 성질을 확인하기 위한 여러 가지 방법이 있습니다:

칼럼 1	칼럼 2
`is_hermitian`( [아톨] )	이 연산자가 헤르미트 연산자인지 여부를 반환합니다.
`get_support`()	이 연산자가 적용되는 모드 인덱스 집합을 반환합니다.
`max_rank`()	이 연산자에 포함된 항들의 최대 차수를 반환합니다.
`min_num_modes`()	이 연산자를 수용할 수 있는 모드 중 가장 적은 개수를 반환합니다.
`conserves_particle_number`()	이 연산자가 입자 수 보존성을 갖는지 여부를 반환합니다.
`conserves_sector`(블록_크기)	각 모드 블록 내에서 모든 항이 입자 수를 보존하는지 여부를 반환합니다.

[ 1 ]

https://en.wikipedia.org/wiki/Second _quantization#페르미온 생성 및 소멸 연산자

속성

groups

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

자세한 내용은 그룹 연산자 설명서를 참조하십시오. 연산자 구조 가이드를 활용하십시오.

메소드

adjoint

adjoint()

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

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

각 항에서 일어나는 작용들은 순서가 바뀌며, 생성と소멸 사이를 오간다
계수들은 복소공액이다

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

conserves_particle_number

conserves_particle_number()

이 연산자가 입자 수 보존성을 갖는지 여부를 반환합니다.

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

리턴

이 연산자가 입자 수 보존성을 갖는지 여부.

conserves_sector

conserves_sector(block_sizes)

각 모드 블록 내에서 모든 항이 입자 수를 보존하는지 여부를 반환합니다.

block_sizes 모드 범위를 연속적이고 중복되지 않는 블록들로 분할합니다. 각 블록은 모드 부터 까지를 포함하며 b , 여기서 [start_b, start_b + block_sizes[b]) start_b 는 이전 블록 크기의 합입니다. 어떤 항이 섹터를 보존하는 것은, 모든 블록에서 그 항의 생성 연산자 개수가 소멸 연산자 개수와 같을 때에만 성립한다. 최종 블록을 넘어서는 모드에 작용하는 항은 섹터를 보존하지 않는다.

빈 값은 모든 모드를 하나의 블록으로 block_sizes 취급하므로, 이는 와 동일합니다 conserves_particle_number(). 단일 블록은 스핀이 없는 FCI 부문의 보존 조건을 검증하는 [norb] 반면, 두 개의 동일한 블록은 알파 [0, norb) 모드와 베타 모드가 각각 보존되는지 [norb, 2 * norb) , 즉 입자 수와 스핀의 z 성분이 모두 보존되는지를 검증한다 [norb, norb] .

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({((True, 0), (False, 2)): 1})
>>> op.conserves_sector([4])  # one spinless block of 4 orbitals
True
>>> op.conserves_sector([2, 2])  # moves a particle from the alpha block to the beta block
False

매개변수

block_sizes – 각각 보존되어야 하는 연속 모드 블록의 크기.

리턴

각 모드 블록 내에서 모든 항이 입자 수를 보존하는지 여부.

equiv

equiv(other, atol=1e-08)

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

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

참고

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

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

매개변수

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

from_1body_tril_spin

classmethod from_1body_tril_spin(one_body_a, one_body_b, norb)

별개의 스핀 종에 대한 삼각형 1체 적분들을 바탕으로 연산자를 구성한다.

결과적으로 얻어진 연산자는 다음과 같이 정의된다

\sum_i c^\alpha_{ii} a^\dagger_i a_i + c^\beta_{ii} a^\dagger_{i+n} a_{i+n} + \sum_{i \lt j} c^\alpha_{ij} (a^\dagger_i a_j + a^\dagger_j a_i) + c^\beta_{ij} (a^\dagger_{i+n} a_{j+n} + a^\dagger_{j+n} a_{i+n})

여기서 $c^\alpha$ ( $c^\beta$ )는 각각 ( one_body_a``one_body_b , resp.)에 저장된 적분 계수이며, $i$ 와 $j$ 는 배열을 참조하는 삼각 지수 $ij$ 에서 확장된 지수이고, $n$ 는 궤도의 개수이다 norb.

결과적으로 얻어진 연산자는 블록 스핀 배열을 따르는 $2n$ 개의 스핀이 없는 페르미온 모드에 작용한다: 모드 $0, \dots, n-1$ 는 $\alpha$ -스핀 궤도이며, 모드 $n, \dots, 2n-1$ 는 $\beta$ -스핀 궤도이다(따라서 $\beta$ -스핀 종의 궤도 $i$ 는 모드 $i+n$ 에 해당한다).

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> one_body_a = np.array([1.0, 2.0, 3.0])
>>> one_body_b = np.array([-1.0, -2.0, -3.0])
>>> op = FermionOperator.from_1body_tril_spin(one_body_a, one_body_b, norb=2)
>>> print(format(op))
  1.000000e0 +0.000000e0j * (+0 -0)
  2.000000e0 +0.000000e0j * (+0 -1)
  2.000000e0 +0.000000e0j * (+1 -0)
  3.000000e0 +0.000000e0j * (+1 -1)
 -1.000000e0 +0.000000e0j * (+2 -2)
 -2.000000e0 +0.000000e0j * (+2 -3)
 -2.000000e0 +0.000000e0j * (+3 -2)
 -3.000000e0 +0.000000e0j * (+3 -3)

매개변수

one_body_a – 길이가 $n * (n + 1) / 2$ 인 1차원 배열로, $\alpha$ -스핀 종의 1체 전자 적분 계수를 평평하게 펼친 삼각 행렬 형태로 저장합니다.
one_body_b – 길이 $n * (n + 1) / 2$ 인 1차원 배열로, $\beta$ -스핀 종의 1체 전자 적분 계수를 평평하게 펼친 삼각 행렬 형태로 저장한다.
norb – 궤도 수, $n$ .

리턴

위에서 정의한 전자 구조 해밀토니안의 1-체 성분.

from_1body_tril_spin_sym

classmethod from_1body_tril_spin_sym(one_body_a, norb)

스핀 대칭 삼각형 1체 적분으로부터 연산자를 구성한다.

결과적으로 얻어진 연산자는 다음과 같이 정의된다

\sum_i c^\alpha_{ii} (a^\dagger_i a_i + a^\dagger_{i+n} a_{i+n}) + \sum_{i \lt j} c^\alpha_{ij} (a^\dagger_i a_j + a^\dagger_j a_i + a^\dagger_{i+n} a_{j+n} + a^\dagger_{j+n} a_{i+n})

여기서 $c^\alpha$ 는 에 저장된 적분 계수이며 one_body_a, $i$ 와 $j$ 는 배열에 대한 인덱스 역할을 하는 삼각 인덱스 $ij$ 에서 전개된 인덱스이고, $n$ 는 궤도의 개수이다 norb.

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> one_body_a = np.array([1.0, 2.0, 3.0])
>>> op = FermionOperator.from_1body_tril_spin_sym(one_body_a, norb=2)
>>> print(format(op))
  1.000000e0 +0.000000e0j * (+0 -0)
  2.000000e0 +0.000000e0j * (+0 -1)
  2.000000e0 +0.000000e0j * (+1 -0)
  3.000000e0 +0.000000e0j * (+1 -1)
  1.000000e0 +0.000000e0j * (+2 -2)
  2.000000e0 +0.000000e0j * (+2 -3)
  2.000000e0 +0.000000e0j * (+3 -2)
  3.000000e0 +0.000000e0j * (+3 -3)

매개변수

one_body_a – 길이가 $n * (n + 1) / 2$ 인 1차원 배열로, $\alpha$ -스핀 종의 1체 전자 적분 계수를 평평하게 펼친 삼각 행렬 형태로 저장합니다.
norb – 궤도 수, $n$ .

리턴

위에서 정의한 전자 구조 해밀토니안의 1-체 성분.

from_2body_tril_spin

classmethod from_2body_tril_spin(two_body_aa, two_body_ab, two_body_bb, norb)

별개의 스핀 종에 대한 삼각형 2체 적분들을 바탕으로 연산자를 구성한다.

결과적으로 얻어진 연산자는 다음과 같이 정의된다

\sum_{ijkl} \frac{1}{2} \sum_{(i,j,k,l) \in \mathcal{P}(ijkl)} c^{\alpha\alpha}_{ijkl} a^\dagger_i a^\dagger_k a_l a_j + c^{\beta\beta}_{ijkl} a^\dagger_{i+n} a^\dagger_{k+n} a_{l+n} a_{j+n} + \sum_{ijkl} \frac{1}{2} \sum_{(i,j,k,l) \in \mathcal{P'}(ijkl)} c^{\alpha\beta}_{ijkl} a^\dagger_{i+n} a^\dagger_k a_l a_{j+n} + c^{\alpha\beta}_{ijkl} a^\dagger_i a^\dagger_{k+n} a_{l+n} a_j +

여기서 $c^{\alpha\alpha}$ ( $c^{\alpha\beta}$ , $c^{\beta\beta}$ )는 각각 ( two_body_aa``two_body_ab``two_body_bb , )에 저장된 적분 계수이며, $ijkl$ 는 배열의 누적 인덱스이고, $\mathcal{P}$ ( $\mathcal{P'}$ )는 4차원 인덱스 $(i,j,k,l)$ (아래 참조)의 고유한 순열을 생성하며, $n$ 는 궤도의 개수이다 norb.

이중체 계수들은 화학자 표기법( $(ij|kl)$ )에 따라 예상되며, 즉 두 지수 쌍 $(i,j)$ 와 $(k,l)$ 는 각각 전하 밀도를 나타냅니다. $\frac{1}{2}$ 의 계수는 일반적인 2체 전계수입니다.

참고

two_body_aa 그리고 는 two_body_bb S8-fold 대칭 배열입니다. 즉, 이들은 모양이 인 행렬의 평평하게 편평화된 하부 삼각 행렬 데이터이며 (npair, npair), 여기서 입니다 npair = (norb * (norb + 1) // 2. 이는 다시 말해, 형태 가 가진 4차원 배열의 하삼각 데이터입니다 (norb, norb, norb, norb). 따라서 위의 $\mathcal{P}$ 는 평탄화된 인덱스 $ijkl$ 를, 이 4차원 배열을 인덱싱하는 모든 인덱스 순열 $(i,j,k,l)$ 로 확장합니다.

그러나 two_body_ab 는 S4-fold 에서만 대칭적이다. 따라서 이 함수는 (npair, npair) 행렬의 전체 데이터를 포함하고 있습니다(다만 여전히 평평한 형태로 되어 있습니다). $\mathcal{P'}$ 는 이에 상응하는 인덱스 전개를 수행합니다. (위의 정의에서, 표기법의 남용으로 $ijkl$ 인덱스를 재사용했습니다.)

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> two_body_aa = np.arange(1, 7, dtype=float)
>>> two_body_ab = np.arange(11, 20, dtype=float)
>>> two_body_bb = np.arange(-1, -7, -1, dtype=float)
>>> op = FermionOperator.from_2body_tril_spin(two_body_aa, two_body_ab, two_body_bb, norb=2)
>>> len(op)
64

매개변수

two_body_aa – $\alpha\alpha$ -스핀 종의 대칭 2체 전자 적분 계수 S8-fold 를 포함하는 1차원 배열로, 평면화된 배열 형태로 제공됩니다.
two_body_ab – $\alpha\beta$ -스핀 종의 S4-fold 대칭 2체 전자 적분 계수를 포함하는 1차원 배열로, 평면화된 배열 형태로 제공됩니다.
two_body_bb – $\beta\beta$ -스핀 종의 S8-fold 대칭 2체 전자 적분 계수를 포함하는 1차원 배열로, 평면화된 배열 형태로 제공됩니다.
norb – 궤도 수, $n$ .

리턴

위에서 정의한 전자 구조 해밀토니안의 2체 성분.

from_2body_tril_spin_sym

classmethod from_2body_tril_spin_sym(two_body_aa, norb)

스핀 대칭 삼각형 2체 적분으로부터 연산자를 구성한다.

결과적으로 얻어진 연산자는 다음과 같이 정의된다

\sum_{ijkl} \frac{1}{2} c^{\alpha\alpha}_{ijkl} \sum_{(i,j,k,l) \in \mathcal{P}(ijkl)} (a^\dagger_i a^\dagger_k a_l a_j + a^\dagger_{i+n} a^\dagger_k a_l a_{j+n} + a^\dagger_i a^\dagger_{k+n} a_{l+n} a_j + a^\dagger_{i+n} a^\dagger_{k+n} a_{l+n} a_{j+n})

여기서 $c^{\alpha\alpha}$ 는 에 저장된 적분 계수이며 two_body_aa, $ijkl$ 는 배열의 누적 인덱스이고, $\mathcal{P}$ 는 4-인덱스 $(i,j,k,l)$ (아래 참조)의 고유한 순열을 생성하며, $n$ 는 궤도의 개수이다 norb.

참고

two_body_aa S8-fold 의 대칭 배열입니다. 즉, 이는 모양이 인 행렬의 평탄화된 하부 삼각 행렬 데이터이며 (npair, npair), 여기서 입니다 npair = (norb * (norb + 1) // 2. 이는 다시 말해, 형태가 인 4차원 배열의 하삼각 데이터에 해당합니다 (norb, norb, norb, norb). 따라서 위의 $\mathcal{P}$ 는 평탄화된 인덱스 $ijkl$ 를 이 4차원 배열을 참조하는 모든 인덱스 순열 $(i,j,k,l)$ 로 확장합니다.

>>> import numpy as np
>>> from qiskit_fermions.operators import FermionOperator
>>> two_body_aa = np.arange(1, 7, dtype=float)
>>> op = FermionOperator.from_2body_tril_spin_sym(two_body_aa, norb=2)
>>> len(op)
64

매개변수

two_body_aa – $\alpha\alpha$ -스핀 종의 대칭 2체 전자 적분 계수 S8-fold 를 포함하는 1차원 배열로, 평면화된 배열 형태로 제공됩니다.
norb – 궤도 수, $n$ .

리턴

위에서 정의한 전자 구조 해밀토니안의 2체 성분.

from_dict

classmethod from_dict(data)

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

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

매개변수

data – 용어 튜플을 복소수 계수에 매핑하는 사전. 각 키는 (bool, int) 쌍으로 이루어진 튜플입니다. 구성을 단순화하기 위해 ann() 와 cre() 를 사용할 수 있습니다.

리턴

새로운 사업자.

from_fcidump

classmethod from_fcidump(fcidump)

데이터 FCIDump 구조체 로부터 FermionOperator 를 생성합니다.

라는 이름의 FCIDump 파일이 있다고 가정하면 molecule.fcidump, 다음과 같이 2차 양자화 연산자를 구성할 수 있습니다:

from qiskit_fermions.operators import FermionOperator
from qiskit_fermions.operators.library import FCIDump

fcidump = FCIDump.from_file("molecule.fcidump")
operator = FermionOperator.from_fcidump(fcidump)

매개변수

fcidump – FCIDump 데이터 구조.

리턴

구성 연산자. FCIDump가 일정한 에너지(예: 핵 반발력)를 제공할 경우, 이는 항등항으로 포함됩니다 ().

from_terms

classmethod from_terms(terms)

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

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({(): 2.0, ((True, 0),): 1.0, ((False, 1),): -1.0j})
>>> op.equiv(FermionOperator.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 FermionOperator
>>> op = FermionOperator(
...     [2.0, 1.0, -1.0],
...     [True, False, True, False],
...     [0, 1, 1, 0],
...     [0, 0, 2, 4],
... )
>>> op.groups = [0, 1, 1]
>>> reconstructed = FermionOperator.from_terms_with_groups(op.iter_terms_with_groups())
>>> op.equiv(reconstructed) and op.groups == reconstructed.groups
True

매개변수

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

리턴

새로운 사업자.

get_actions

get_actions()

연산자의 동작을 포함하는 읽기 전용 목록을 반환합니다.

참고

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

관련 참조

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

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.one()
>>> op += FermionOperator.from_dict({((True, 0), (False, 1)): 1.0})
>>> op.get_actions()
[True, False]

리턴

운영자의 조치 목록.

get_boundaries

get_boundaries()

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

참고

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

관련 참조

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

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

리턴

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

get_coeffs

get_coeffs()

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

참고

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

관련 참조

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

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

리턴

연산자의 계수 목록.

get_modes

get_modes()

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

참고

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

관련 참조

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

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

리턴

이 연산자의 모드 목록.

get_support

get_support()

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

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

리턴

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

has_groups

has_groups()

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

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

참고

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

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [True, False, True, False, True, False, True, False],
...     [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 FermionOperator
>>> op = FermionOperator.from_dict({(): 1e-4, ((True, 0),): 1e-6, ((False, 0),): 1e-10})
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
 1.000000e-10 +0.000000e0j * (-0)
  1.000000e-6 +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_hermitian

is_hermitian(atol=1e-08)

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

참고

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

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

매개변수

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

리턴

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

iter_terms

iter_terms()

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

경고

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

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

iter_terms_with_groups

iter_terms_with_groups()

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

경고

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

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

max_rank

max_rank()

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

참고

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

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

리턴

이 연산자의 최대 순위.

min_num_modes

min_num_modes()

이 연산자를 수용할 수 있는 모드 중 가장 적은 개수를 반환합니다.

이는 연산자가 작용하는 최대 모드 지수보다 1 더 큰 값이며, 이는 예를 들어 매핑에 필요한 큐비트의 수를 결정하는 요소입니다. 이는 서로 다른 모드의 개수가 아님을 유의하십시오. 이에 대해서는 get_support() 를 참조하십시오.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict(
...     {
...         ((True, 0), (False, 4)): 1,
...         ((True, 1), (True, 3), (False, 4), (False, 7)): 1,
...     }
... )
>>> op.min_num_modes()
8
>>> FermionOperator.zero().min_num_modes()
0

리턴

모드의 최소 개수, 또는 연산자가 어떤 모드에도 작용하지 않는 경우 0 .

참고

모드 인덱스 에 대해 연산을 수행하는 연산자는 지원되지 2**32 - 1 않습니다. 카운트를 표현할 수 없기 때문에 호출 시 패닉이 발생합니다.

normal_ordered

normal_ordered(sandwich=None)

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

연산자 항의 정상 순서는 모든 생성 작용이 모든 소멸 작용보다 먼저 나타나도록 정의된다. 각 그룹 내에서, 작용받는 모드는 사전순으로 정렬됩니다. 순서가 오름차순인지 내림차순인지는 sandwich 인수의 값에 따라 달라집니다:

None (기본값): 두 그룹 모두 사전순으로 내림차순으로 정렬됩니다 (예: +1 +0 -1 -0)
True: 인덱스가 클수록 중간 쪽으로 위치하며, 즉 생성 작용은 사전순으로 오름차순인 반면 소멸 작용은 내림차순이다 (예: +0 +1 -1 -0)
False: 인덱스가 작을수록 중간 쪽에 위치하며, 즉 생성 작용은 사전순으로 내림차순이고 소멸 작용은 오름차순으로 배열된다 (예: +1 +0 -0 -1)

참고

항의 순서를 재배열할 때는 반교환 관계( $a_i a^\dagger_j = \delta_{ij} - a^\dagger_j a^i$ )를 고려해야 하며, 이로 인해 항의 개수가 달라질 수 있다.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({((False, 1), (True, 1), (False, 0), (True, 0)): 1})
>>> print(format(op.normal_ordered().simplify()))
  1.000000e0 +0.000000e0j * ()
 -1.000000e0 +0.000000e0j * (+0 -0)
 -1.000000e0 +0.000000e0j * (+1 -1)
 -1.000000e0 +0.000000e0j * (+1 +0 -1 -0)
>>> print(format(op.normal_ordered(sandwich=True).simplify()))
  1.000000e0 +0.000000e0j * ()
 -1.000000e0 +0.000000e0j * (+0 -0)
  1.000000e0 +0.000000e0j * (+0 +1 -1 -0)
 -1.000000e0 +0.000000e0j * (+1 -1)
>>> print(format(op.normal_ordered(sandwich=False).simplify()))
  1.000000e0 +0.000000e0j * ()
 -1.000000e0 +0.000000e0j * (+0 -0)
 -1.000000e0 +0.000000e0j * (+1 -1)
  1.000000e0 +0.000000e0j * (+1 +0 -0 -1)

리턴

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

num_groups

num_groups()

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

가 일 groups 경우 None, 이 함수는 또한 를 반환합니다 None. 그렇지 않으면, 가장 많이 나타나는 그룹 인덱스에 1을 더한 값(즉, 다음 그룹의 인덱스로 사용할 수 있는 값)으로 그룹 수를 반환합니다.

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [True, False, True, False, True, False, True, False],
...     [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 FermionOperator
>>> op = FermionOperator.from_dict({(): 2.0})
>>> one = FermionOperator.one()
>>> op & one == op
True

relabel_modes

relabel_modes(permutation)

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

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

매개변수

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

리턴

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

인상

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

simplify

simplify(atol=1e-08)

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

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

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

>>> from qiskit_fermions.operators import FermionOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = FermionOperator(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 FermionOperator
>>> op = FermionOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [True, False, True, False, True, False, True, False],
...     [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())))
[([(True, 0), (False, 1)], (1+0j)), ([(True, 1), (False, 0)], (-1+0j))]
[([(True, 2), (False, 3)], (2+0j)), ([(True, 3), (False, 2)], (-2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(True, 2), (False, 3)], (2+0j)), ([(True, 3), (False, 2)], (-2+0j))]

매개변수

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

리턴

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

zero

classmethod zero()

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

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

>>> from qiskit_fermions.operators import FermionOperator
>>> op = FermionOperator.from_dict({(): 2.0})
>>> zero = FermionOperator.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)

_linear_operator_

_linear_operator_(norb, nelec)

FCI (norb, nelec) 섹터에 대한 이 연산자에 대한 LinearOperator SciPy 를 반환합니다.

이는 로 변환한 ffsim.FermionOperator 다음 이를 에 전달함으로써 ffsim.SupportsLinearOperator 구현됩니다 ffsim.linear_operator(). 시뮬레이션은 ffsim의 담당 영역이며, 이 패키지는 두 번째 시뮬레이션 백엔드보다는 매퍼에 구애받지 않는 회로를 담당합니다.

ffsim은 입자 수와 스핀의 z 성분을 모두 보존하지 않는 연산자를 거부하는데, 이는 그러한 연산자가 고정된 섹터에 대해 아무런 작용을 하지 않기 때문이며, 해당 섹터 외부의 궤도에 작용하는 항은 아무런 오류 메시지 없이 무시합니다 [0, norb).

매개변수

norb (int) – 공간 궤도의 개수.
nelec (int |tuple[int, int]) – 전자 수 – 스핀이 없는 부문의 경우 정수이며, 스핀이 있는 부문의 경우 한 (n_alpha, n_beta) 쌍이다.
self (FermionOperator)

리턴

A 요청된 섹터에 이 연산자를 적용합니다 scipy.sparse.linalg.LinearOperator .

리턴 유형

scipy.sparse.linalg.LinearOperator

_majorana_operator_

_majorana_operator_()

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

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

_trace_

_trace_(norb, nelec)

FCI (norb, nelec) 섹터에서 이 연산자의 추적 정보를 반환합니다.

이는 를 통해 ffsim.SupportsTrace 구현되며 ffsim.trace(), 를 반영합니다 _linear_operator_.

매개변수

norb (int) – 공간 궤도의 개수.
nelec (int |tuple[int, int]) – 전자 수 – 스핀이 없는 부문의 경우 정수이며, 스핀이 있는 부문의 경우 한 (n_alpha, n_beta) 쌍이다.
self (FermionOperator)

리턴

요청된 섹터에 대한 이 연산자의 결과.

리턴 유형

복합체

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

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