Skip to main content
IBM Quantum Platform

QfMajoranaOperator

QfMajoranaOperator

struct QfMajoranaOperator

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

참고

이는 C API에 대해서는 불투명한 데이터 구조이며, 내부 구현은 전적으로 Rust로 이루어져 있습니다. 이 페이지의 나머지 부분에서는 이 구조체를 다루기 위한 설계 및 관련 함수에 대해 설명합니다.

정의

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

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

마요라나 페르미온이 그 자체의 반입자인이라는 핵심적 특성은 단번에 명백해집니다:

γi=γi†  and  γi2=(γi†)2=1\gamma_i = \gamma_i^\dagger ~~\text{and}~~ \gamma_i^2 = (\gamma_i^\dagger)^2 = 1

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

{γi,γj}=2δij\left\{\gamma_i,\gamma_j\right\} = 2\delta_{ij}

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

MajoranaOperator=∑ici⨂jγj^ ,\text{\texttt{MajoranaOperator}} = \sum_i c_i \bigotimes_j \hat{\gamma_j} \, ,

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

구현

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

칼럼 1
칼럼 2
coeffs두 개의 64비트 부동소수점 숫자로 구성된 복소수 계수 벡터.
modes작용을 받은 마요라나 모드 인덱스를 저장하는 32비트 정수 벡터.
boundaries와 actions 에서 경계를 나타내는 정수 벡터 indices.

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

참고

각 내부 배열에 대한 읽기 전용 사본은 해당 함수를 통해 액세스할 수 있습니다:

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

건설

위에서 설명한 해당 배열을 지정함으로써 새로운 연산자를 직접 생성할 수 있습니다. 또는 빈 을 으로 초기화한 다음 qf_maj_op_zero() , 을 통해 항을 반복적으로 추가할 수도 있습니다 QfMajoranaOperatorqf_maj_op_add_term() .

칼럼 1
칼럼 2
qf_maj_op_new()지정된 배열을 사용하여 새로운 연산자를 생성합니다.
qf_maj_op_zero()가법 항등 연산자를 생성합니다.
qf_maj_op_one()곱셈 항등 연산자를 생성합니다.
qf_maj_op_add_term()기존의 QfMajoranaOperator.에 항목을 추가합니다.
참고

A는.을 사용하여 해제할 QfMajoranaOperator 수 있습니다 qf_maj_op_free().

산술

다음 함수들은 산술 연산을 수행합니다:

칼럼 1
칼럼 2
qf_maj_op_add()두 연산자를 더합니다.
qf_maj_op_mul()연산자에 스칼라를 곱합니다.
qf_maj_op_compose()두 연산자를 서로 결합합니다.
qf_maj_op_adjoint()헤르미트 공액 연산자를 반환합니다.

조작

다음 함수들은 연산자 조작 로직을 제공합니다:

칼럼 1
칼럼 2
qf_maj_op_ichop()계수의 크기가 작은 항을 제거합니다.
qf_maj_op_simplify()동등하지만 단순화된 연산자를 반환합니다.
qf_maj_op_normal_ordered()일반 순서를 가진 항을 갖는 등가 연산자를 반환합니다.
qf_maj_op_relabel_modes()연산자의 모드를 다시 지정합니다.

특성

연산자의 특정 속성을 확인하기 위한 다음과 같은 함수들이 있습니다.

칼럼 1
칼럼 2
qf_maj_op_is_hermitian()연산자가 헤르미트 연산자인지 여부를 반환합니다.
qf_maj_op_max_rank()이 연산자에 포함된 항들의 최대 차수를 반환합니다.
qf_maj_op_is_even()연산자가 짝수인지 여부를 반환합니다.

[ 1 ]

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

멤버

qf_maj_op_new

QfMajoranaOperator *qf_maj_op_new(uint64_t num_terms, uint64_t num_modes, const QkComplex64 *coeffs, const uint32_t *modes, const uint32_t *boundaries)

새로운 연산자를 생성합니다.

포인터 인자 중 어느 것이든, 해당 인자의 길이가 0일 NULL 경우에만 그 값을 가질 수 있다.

예

1uint64_t num_terms = 3;
2uint64_t num_modes = 4;
3uint32_t modes[4] = {0, 1, 2, 3};
4QkComplex64 coeffs[3] = {{1.0, 0.0}, {-1.0, 0.0}, {0.0, -1.0}};
5uint32_t boundaries[4] = {0, 0, 2, 4};
6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs,
7                                       modes, boundaries);

매개변수

  • num_terms – 연산자에 포함된 항의 개수.
  • num_modes – 모든 항에 대해 합산된 모드의 개수.
  • coeffs – 항 계수 배열을 가리키는 포인터. 이 배열의 길이는 이어야 합니다 num_terms.
  • 모드 – 모든 항에 대한 모드 배열을 가리키는 포인터입니다. 이 배열의 길이는 이어야 합니다 num_modes.
  • 경계 – 항들 사이의 경계를 담은 배열을 가리키는 포인터입니다. 이 배열의 길이는 이어야 합니다 num_terms + 1.

qf_maj_op_free

void qf_maj_op_free(QfMajoranaOperator *op)

기존 연산자를 해제합니다.

예

1QfMajoranaOperator *op = qf_maj_op_one();
2qf_maj_op_free(op);

매개변수

  • op – 해제될 마요라나 연산자를 가리키는 포인터.

qf_maj_op_get_coeffs

void qf_maj_op_get_coeffs(const QfMajoranaOperator *op, QkComplex64 **coeffs_out, uint64_t *coeffs_len)

연산자의 계수에 대한 읽기 전용 액세스 권한을 제공합니다.

관련 참조

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

예

 1uint64_t num_terms = 2;
 2uint64_t num_modes = 0;
 3QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 4uint32_t boundaries[3] = {0, 0, 0};
 5QfMajoranaOperator *op =
 6    qf_maj_op_new(num_terms, num_modes, coeffs, NULL, boundaries);
 7
 8QkComplex64 *coeffs_out;
 9uint64_t *coeffs_len;
10
11qf_maj_op_get_coeffs(op, &coeffs_out, &coeffs_len);
12
13assert(coeffs_len == 2);
참고

이 함수는 내부 데이터의 복사본 을 반환합니다.

매개변수

  • op – 계수를 조회할 마조라나 연산자에 대한 포인터.
  • coeffs_out – 계수를 기록할 복소수 값 배열을 가리키는 포인터입니다.
  • coeffs_len – 출력 배열의 길이를 기록할 정수 변수에 대한 포인터입니다.

qf_maj_op_get_modes

void qf_maj_op_get_modes(const QfMajoranaOperator *op, uint32_t **modes_out, uint64_t *modes_len)

연산자가 적용된 모드 인덱스에 대한 읽기 전용 액세스 권한을 제공합니다.

관련 참조

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

예

 1uint64_t num_terms = 2;
 2bool actions[2] = {true, false};
 3uint32_t modes[2] = {0, 1};
 4QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 5uint32_t boundaries[3] = {0, 0, 2};
 6QfMajoranaOperator *op =
 7    qf_maj_op_new(num_terms, num_actions, coeffs, modes, boundaries);
 8
 9QkComplex64 *modes_out;
10uint64_t *modes_len;
11
12qf_maj_op_get_modes(op, &modes_out, &modes_len);
13
14assert(modes_len == 2);
참고

이 함수는 내부 데이터의 복사본 을 반환합니다.

매개변수

  • op – 액세스할 모드가 포함된 마조라나 연산자를 가리키는 포인터.
  • modes_out – 모드를 기록할 부울 값 배열을 가리키는 포인터입니다.
  • modes_len – 출력 배열의 길이를 저장할 정수 변수에 대한 포인터입니다.

qf_maj_op_get_boundaries

void qf_maj_op_get_boundaries(const QfMajoranaOperator *op, size_t **boundaries_out, uint64_t *boundaries_len)

연산자 항들 간의 경계를 나타내는 인덱스에 대한 읽기 전용 액세스 권한을 제공합니다.

관련 참조

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

예

 1uint64_t num_terms = 2;
 2uint64_t num_modes = 2;
 3uint32_t modes[2] = {0, 1};
 4QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 5uint32_t boundaries[3] = {0, 0, 2};
 6QfMajoranaOperator *op =
 7    qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 8
 9QkComplex64 *boundaries_out;
10uint64_t *boundaries_len;
11
12qf_maj_op_get_boundaries(op, &boundaries_out, &boundaries_len);
13
14assert(boundaries_len == 3);
참고

이 함수는 내부 데이터의 복사본 을 반환합니다.

매개변수

  • op – 액세스할 경계가 있는 마조라나 연산자에 대한 포인터.
  • boundaries_out – 경계를 기록할 부울 값 배열을 가리키는 포인터.
  • boundaries_len – 출력 배열의 길이를 기록할 정수형 변수에 대한 포인터.

qf_maj_op_zero

QfMajoranaOperator *qf_maj_op_zero(void)

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

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

예

1QfMajoranaOperator *zero = qf_maj_op_zero();
2
3QfMajoranaOperator *op_plus_zero = qf_maj_op_add(op, zero);
4
5assert(qf_maj_op_equal(op, op_plus_zero));

리턴

생성된 연산자에 대한 포인터.

qf_maj_op_one

QfMajoranaOperator *qf_maj_op_one(void)

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

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

예

1QfMajoranaOperator *one = qf_maj_op_one();
2
3QfMajoranaOperator *op_times_one = qf_maj_op_compose(op, one);
4
5assert(qf_maj_op_equal(op, op_times_one));

리턴

생성된 연산자에 대한 포인터.

qf_maj_op_has_groups

bool qf_maj_op_has_groups(const QfMajoranaOperator *op)

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

관련 참조

그룹 연산자 용어 에 대한 설명: 연산자 구조를 사용하십시오.

예

1QfMajoranaOperator *op = ...;
2
3bool has_groups = qf_maj_op_has_groups(op);

매개변수

  • op – 검사할 마조라나 연산자에 대한 포인터.

리턴

지정된 연산자에 속성이 groups 있는지 여부.

qf_maj_op_num_groups

uint32_t qf_maj_op_num_groups(const QfMajoranaOperator *op)

연산자에서 그룹 수를 가져옵니다.

관련 참조

그룹 연산자 용어 에 대한 설명: 연산자 구조를 사용하십시오.

예

1QfMajoranaOperator *op = ...;
2
3uint32_t num_groups = qf_maj_op_num_groups(op);
참고

그룹의 개수는 가장 큰 그룹 인덱스에 1을 더한 값으로 지연 평가됩니다.

매개변수

  • op – 그룹 수를 구할 마조라나 연산자에 대한 포인터.

리턴

연산자의 groups 속성에서 파생된 그룹 인덱스의 개수.

qf_maj_op_group_weights

void qf_maj_op_group_weights(const QfMajoranaOperator *op, double *weights_out)

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

i-번째 항은 그룹 의 항들에 대한 abs(coeff) 의 합을 i, 해당 그룹의 항의 개수로 나눈 값이다. 이는 개별 항이 아닌 전체 그룹을 추출하는 무작위 제품 식(예: qDRIFT )의 표본 가중치이며, 호출자 측에서 qf_maj_op_get_coeffs() 및 ( qf_maj_op_get_groups()* 그룹화되지 않은* 항마다 하나의 값씩)을 축소하는 방식이 아니라, 연산자에 대한 단일 통과 과정에서 계산됩니다.

관련 참조

그룹 연산자 용어 에 대한 설명: 연산자 구조를 사용하십시오.

예

 1uint64_t num_terms = 4;
 2uint64_t num_modes = 8;
 3uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 4QkComplex64 coeffs[4] = {{1.0, 0.0}, {2.0, 0.0}, {-1.0, 0.0}, {-2.0, 0.0}};
 5uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 7
 8uint32_t groups_in[4] = {0, 1, 0, 1};
 9qf_maj_op_set_groups(op, groups_in, num_terms);
10
11double weights[2];
12qf_maj_op_group_weights(op, weights);
13
14assert(weights[0] == 1.0);
15assert(weights[1] == 2.0);
참고

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

매개변수

  • op – 계산할 군 가중치를 가진 마요라나 연산자에 대한 포인터.
  • weights_out – 가중치를 기록할 double형 배열을 가리키는 포인터입니다. :c:funcqf_maj_op_num_groups:에 맞게 크기를 조정해야 합니다.

qf_maj_op_get_groups

void qf_maj_op_get_groups(const QfMajoranaOperator *op, uint32_t **groups_out, uint64_t *groups_len)

모든 연산자 항에 대한 그룹 인덱스를 가져옵니다.

관련 참조

그룹 연산자 용어 에 대한 설명: 연산자 구조를 사용하십시오.

예

1QfMajoranaOperator *op = ...;
2uint32_t *groups_out;
3uint32_t groups_len;
4
5qf_maj_op_get_groups(op, &groups_out, &groups_len);

매개변수

  • op – 그룹 지수를 가져올 마조라나 연산자에 대한 포인터.
  • groups_out – 그룹 인덱스를 기록할 정수 배열을 가리키는 포인터입니다.
  • groups_len – 출력 배열의 길이를 기록할 정수 변수에 대한 포인터입니다.

qf_maj_op_set_groups

void qf_maj_op_set_groups(QfMajoranaOperator *op, const uint32_t *groups_in, uint64_t groups_len)

지정된 연산자의 groups 속성을 설정합니다.

관련 참조

그룹 연산자 용어 에 대한 설명: 연산자 구조를 사용하십시오.

예

1QfMajoranaOperator *op = ...;
2
3uint32_t num_terms = 4;
4uint32_t groups_in[4] = {0, 1, 0, 1};
5qf_maj_op_set_groups(op, groups_in, num_terms);

매개변수

  • op – 쓰기 대상 속성을 groups 가진 마조라나 연산자에 대한 포인터.
  • groups_in – 연산자에 쓰기 위한 정수 groups 배열을 가리키는 포인터입니다.
  • groups_len – groups_in 배열에 포함된 항의 개수.

qf_maj_op_del_groups

void qf_maj_op_del_groups(QfMajoranaOperator *op)

지정된 연산자에서 속성을 groups 삭제합니다.

관련 참조

그룹 연산자 용어 에 대한 설명: 연산자 구조를 사용하십시오.

예

1QfMajoranaOperator *op = ...;
2
3qf_maj_op_del_groups(op);

매개변수

  • op – 삭제할 groups 속성을 가진 마조라나 연산자에 대한 포인터.

qf_maj_op_split_out_groups

void qf_maj_op_split_out_groups(const QfMajoranaOperator *op, const uint32_t *group_indices, uint64_t num_indices, QfMajoranaOperator **group_ops_out)

이 연산자를 해당 속성을 groups 기준으로 새로운 연산자 목록으로 분할합니다.

의 중복 인덱스는 에서 나타나는 횟수만큼 한 번씩 기록됩니다 group_indices``group_ops_out . 전체 그룹 중 극히 일부만 요청하는 것은 모든 그룹을 요청하는 것보다 비용이 훨씬 저렴합니다. 요청되지 않은 그룹에 속한 용어들은 어디에도 추가되지 않고 건너뛰어지기 때문입니다.

관련 참조

그룹 연산자 용어 에 대한 설명: 연산자 구조를 사용하십시오.

예

 1uint64_t num_terms = 4;
 2uint64_t num_modes = 8;
 3uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 4QkComplex64 coeffs[4] = {{1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}};
 5uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 7
 8uint32_t groups_in[4] = {0, 1, 0, 1};
 9qf_maj_op_set_groups(op, groups_in, num_terms);
10
11// build every group, in index order
12QfMajoranaOperator *group_ops[2];
13qf_maj_op_split_out_groups(op, NULL, 0, group_ops);
14
15// build only group 1
16uint32_t group_indices[1] = {1};
17QfMajoranaOperator *group_op[1];
18qf_maj_op_split_out_groups(op, group_indices, 1, group_op);

매개변수

  • op – 분리할 groups 마조라나 연산자를 가리키는 포인터.
  • group_indices – 연산자를 생성할 그룹 인덱스 배열에 대한 포인터로, 원하는 출력 순서대로 정렬되어 있어야 합니다. 그럴 수도 있습니다 NULL. 이 경우 모든 그룹은 인덱스 순서대로 생성됩니다(이는 모든 인덱스를 :c:func:qf_maj_op_num_groups 에 0 전달하는 것과 동일합니다 - 1).
  • num_indices – 배열에 group_indices 포함된 인덱스의 개수. 가 일 group_indices 경우 무시됩니다 NULL.
  • group_ops_out – 요청된 각 그룹에 대한 연산자를 기록할 :c:struct:QfMajoranaOperator 배열을 가리키는 포인터입니다. 의 크기는 group_indices 일 때 num_indices 로NULL, 일 때는 :c:func:qf_maj_op_num_groups 로 설정되어야 합니다 NULL.

qf_maj_op_add_term

void qf_maj_op_add_term(QfMajoranaOperator *op, uint64_t num_modes, const uint32_t *modes, const QkComplex64 *coeff)

기존 연산자에 항을 추가합니다.

포인터 인자 중 어느 것이든, 해당 인자의 길이가 0일 NULL 경우에만 그 값을 가질 수 있다.

주의

이 함수는 연산자의 속성을 groups 로 재설정합니다 NULL.

예

1QfMajoranaOperator *one = qf_maj_op_one();
2
3QfMajoranaOperator *op = qf_maj_op_zero();
4uint32_t modes[0] = {};
5QkComplex64 coeff = {1.0, 0.0};
6
7qf_maj_op_add_term(op, 0, modes, &coeff);
8
9assert(qf_maj_op_equal(op, one));

매개변수

  • op – 수정할 마요라나 연산자에 대한 포인터.
  • num_modes – modes 배열의 길이.
  • modes – 모드 인덱스 배열을 가리키는 포인터. 이 배열의 길이는 이어야 합니다 num_modes.
  • coeff – 복소수 계수를 가리키는 포인터.

qf_maj_op_add

QfMajoranaOperator *qf_maj_op_add(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

두 연산자를 더합니다.

예

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4QfMajoranaOperator *result = qf_maj_op_add(one, zero);
5
6assert(qf_maj_op_equal(result, one));

매개변수

  • left – left 연산자에 대한 포인터.
  • right – right 연산자에 대한 포인터.

리턴

결과 연산자에 대한 포인터.

qf_maj_op_mul

QfMajoranaOperator *qf_maj_op_mul(const QfMajoranaOperator *op, const QkComplex64 *scalar)

연산자에 스칼라를 곱합니다.

예

1QfMajoranaOperator *one = qf_maj_op_one();
2QkComplex64 coeff = {2.0, 0.0};
3QfMajoranaOperator *result = qf_maj_op_mul(one, &coeff);
4
5QfMajoranaOperator *expected = qf_maj_op_zero();
6uint32_t modes[0] = {};
7qf_maj_op_add_term(expected, 0, modes, &coeff);
8
9assert(qf_maj_op_equal(result, expected));

매개변수

  • op – 연산자를 가리키는 포인터.
  • 스칼라 – 스칼라를 가리키는 포인터.

리턴

결과 연산자에 대한 포인터.

qf_maj_op_compose

QfMajoranaOperator *qf_maj_op_compose(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

두 연산자를 서로 결합합니다.

예

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4QfMajoranaOperator *result = qf_maj_op_compose(one, zero);
5
6assert(qf_maj_op_equal(result, zero));

매개변수

  • left – left 연산자에 대한 포인터.
  • right – right 연산자에 대한 포인터.

리턴

결과 연산자에 대한 포인터.

qf_maj_op_adjoint

QfMajoranaOperator *qf_maj_op_adjoint(const QfMajoranaOperator *op)

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

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

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

예

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[0] = {};
 3QkComplex64 coeff = {0.0, 1.0};
 4qf_maj_op_add_term(op, 0, modes, &coeff);
 5
 6QfMajoranaOperator *adjoint = qf_maj_op_adjoint(op);
 7
 8QfMajoranaOperator *expected = qf_maj_op_zero();
 9QkComplex64 coeff_adj = {0.0, -1.0};
10qf_maj_op_add_term(expected, 0, modes, &coeff_adj);
11
12assert(qf_maj_op_equal(adjoint, expected));

매개변수

  • op – 연산자를 가리키는 포인터.

리턴

생성된 연산자에 대한 포인터.

qf_maj_op_ichop

void qf_maj_op_ichop(QfMajoranaOperator *op, double atol)

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

주의

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

예

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[0] = {};
 3QkComplex64 coeff = {1e-8};
 4qf_maj_op_add_term(op, 0, modes, &coeff);
 5
 6qf_maj_op_ichop(op, 1e-6);
 7
 8QfMajoranaOperator *expected = qf_maj_op_zero();
 9
10assert(qf_maj_op_equal(op, expected));

매개변수

  • op – 연산자를 가리키는 포인터.
  • atol – 계수 절삭에 대한 절대 허용 오차.

qf_maj_op_simplify

QfMajoranaOperator *qf_maj_op_simplify(const QfMajoranaOperator *op, double atol)

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

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

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

 1uint64_t num_terms = 100000;
 2uint64_t num_modes = 0;
 3uint32_t modes[0] = {};
 4QkComplex64 coeffs[100000];
 5uint32_t boundaries[100001];
 6for (int i = 0; i < 100000; i++) {
 7  coeffs[i].re = 1e-5;
 8  coeffs[i].im = 0.0;
 9  boundaries[i] = 0;
10}
11boundaries[100000] = 0;
12QfMajoranaOperator *op =
13    qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
14
15QfMajoranaOperator *canon = qf_maj_op_simplify(op, 1e-4);
16
17QfMajoranaOperator *one = qf_maj_op_one();
18bool canon_is_equal = qf_maj_op_equiv(canon, one, 1e-6);
19
20qf_maj_op_ichop(op, 1e-4);
21
22QfMajoranaOperator *zero = qf_maj_op_zero();
23bool ichop_is_equal = qf_maj_op_equiv(op, zero, 1e-6);

매개변수

  • op – 단순화할 마요라나 연산자에 대한 포인터.
  • atol – 계수 절삭에 대한 절대 허용 오차.

리턴

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

qf_maj_op_normal_ordered

QfMajoranaOperator *qf_maj_op_normal_ordered(const QfMajoranaOperator *op, bool ascending, bool reduce)

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

연산자 항의 정상 순서는 모든 동작이 사전순으로 정렬되도록 정의된다. 상승할지 하강할지는 ascending 매개변수의 값에 따라 달라집니다.

예

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[4] = {0, 2, 1, 3};
 3QkComplex64 coeff = {1.0, 0.0};
 4qf_maj_op_add_term(op, 4, modes, &coeff);
 5
 6QfMajoranaOperator *normal_ordered = qf_maj_op_normal_ordered(op, false, true);
 7
 8QkComplex64 coeff_minus = {-1.0, 0.0};
 9QfMajoranaOperator *expected = qf_maj_op_zero();
10uint32_t modes_exp[4] = {3, 2, 1, 0};
11qf_maj_op_add_term(expected, 4, modes_exp, &coeff_minus);
12
13assert(qf_maj_op_equal(normal_ordered, expected));

매개변수

  • op – 연산자를 가리키는 포인터.
  • 오름차순 – 지수가 오름차순으로 정렬될지 내림차순으로 정렬될지 여부.
  • 축소 – 항의 제곱이 항등식과 같아지는 항을 제거하여 각 항을 최소 형태로 축소할지 여부.

리턴

생성된 연산자에 대한 포인터.

qf_maj_op_is_hermitian

bool qf_maj_op_is_hermitian(const QfMajoranaOperator *op, double atol)

연산자가 헤르미트 연산자인지 확인합니다.

예

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes1[2] = {0, 1};
 3QkComplex64 coeff1 = {0.0, 1.00001};
 4qf_maj_op_add_term(op, 2, modes1, &coeff1);
 5uint32_t modes2[2] = {0, 1};
 6QkComplex64 coeff2 = {0.0, -1};
 7qf_maj_op_add_term(op, 2, modes2, &coeff2);
 8
 9assert(qf_maj_op_is_hermitian(op, 1e-4));
10assert(!qf_maj_op_is_hermitian(op, 1e-8));
참고

이 검사는 op 와 그 qf_maj_op_adjoint() 및 의 qf_maj_op_normal_ordered() 차이에 대해 qf_maj_op_equiv() 를 사용하여 구현됩니다 qf_maj_op_zero().

매개변수

  • op – 검사 대상인 마요라나 연산자를 가리키는 포인터.
  • atol – 계수들이 서로 같다고 간주되는 절대 허용 오차.

리턴

주어진 연산자가 헤르미트 연산자인지 여부.

qf_maj_op_max_rank

uint32_t qf_maj_op_max_rank(const QfMajoranaOperator *op)

연산자의 최대 순위를 확인합니다.

예

1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes[4] = {0, 1, 2, 3};
3QkComplex64 coeff = {1.0, 0.0};
4qf_maj_op_add_term(op, 4, modes, &coeff);
5
6assert(qf_maj_op_max_rank(op), 4);
참고

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

매개변수

  • op – 검사 대상인 마요라나 연산자를 가리키는 포인터.

리턴

연산자의 최대 등급.

qf_maj_op_is_even

bool qf_maj_op_is_even(const QfMajoranaOperator *op)

연산자가 짝수인지 확인합니다.

예

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2QkComplex64 coeff = {1.0, 0.0};
 3uint32_t modes1[2] = {0, 1};
 4qf_maj_op_add_term(op, 2, modes1, &coeff);
 5
 6assert(qf_maj_op_is_even(op));
 7
 8uint32_t modes2[1] = {2};
 9qf_maj_op_add_term(op, 2, modes2, &coeff);
10
11assert(!qf_maj_op_is_even(op));
참고

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

매개변수

  • op – 검사 대상인 마요라나 연산자를 가리키는 포인터.

리턴

주어진 연산자가 짝수인지 여부.

qf_maj_op_equal

bool qf_maj_op_equal(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

두 연산자의 등가성을 비교합니다.

예

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4assert(qf_maj_op_equal(one, one));
5assert(!qf_maj_op_equal(one, zero));

매개변수

  • left – left 연산자에 대한 포인터.
  • right – right 연산자에 대한 포인터.

리턴

두 연산자가 같은지 여부.

qf_maj_op_equiv

bool qf_maj_op_equiv(const QfMajoranaOperator *left, const QfMajoranaOperator *right, double atol)

두 연산자의 동치성을 비교하십시오.

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

예

1QfMajoranaOperator *zero = qf_maj_op_zero();
2
3QfMajoranaOperator *op = qf_maj_op_zero();
4uint32_t modes[0] = {};
5QkComplex64 coeff = {1e-7, 0.0};
6qf_maj_op_add_term(op, 0, modes, &coeff);
7
8assert(qf_maj_op_equiv(op, zero, 1e-6));
9assert(!qf_maj_op_equiv(op, zero, 1e-8));

매개변수

  • left – left 연산자에 대한 포인터.
  • right – right 연산자에 대한 포인터.
  • atol – 계수 등가성에 대한 절대 허용 오차.

리턴

두 연산자가 서로 동등한지 여부.

qf_maj_op_len

size_t qf_maj_op_len(const QfMajoranaOperator *op)

지정된 연산자의 길이(또는 항의 개수)를 반환합니다.

예

1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes[4] = {0, 1, 2, 3};
3QkComplex64 coeff = {1.0, 0.0};
4qf_maj_op_add_term(op, 4, modes, &coeff);
5
6assert(qf_maj_op_len(op) == 1);

매개변수

  • op – 마요라나 연산자를 가리키는 포인터.

리턴

연산자의 길이(또는 항의 개수).

qf_maj_op_relabel_modes

QfExitCode qf_maj_op_relabel_modes(QfMajoranaOperator *op, uint64_t num_modes, const uint32_t *permutation)

지정된 연산자의 모드를 다시 지정합니다.

예

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[4] = {0, 1, 2, 3};
 3QkComplex64 coeff = {1.0, 0.0};
 4qf_maj_op_add_term(op, 4, modes, &coeff);
 5
 6uint32_t permutation[4] = {3, 2, 1, 0};
 7
 8QfExitCode exit = qf_maj_op_relabel_modes(op, 4, permutation);
 9
10assert(exit == QfExitCode_Success);

매개변수

  • op – 마요라나 연산자를 가리키는 포인터.
  • num_modes – 제공된 순열 목록에 포함된 모드 인덱스의 개수.
  • 순열 – 인덱스 순열 목록.

리턴

종료 코드.

  • QfExitCode_Success 성공 시
  • QfExitCode_DuplicateIndexError 순열에서 중복된 인덱스가 발견된 경우
  • QfExitCode_IndexError 무효 인덱스 등과 같은 기타 인덱스 오류의 경우.
이 페이지가 도움이 되었습니까?
GitHub에서 버그, 오타를 보고하거나 컨텐츠를 요청하십시오.