QfMajoranaOperator

struct QfMajoranaOperator

マジョラーナフェルミオン演算子。

注

これは、C API からは内部構造が不透明なデータ構造であり、その内部は完全に Rust で実装されています。このページの残りの部分では、この構造体を使用するための設計および関連する関数について説明します。

定義

この演算子は、マジョラナ演算子の積の線形結合によって定義される [1]。これは、標準的なフェルミオンの第二量子化による生成・消滅演算子を用いて定義することができる（こちらも参照 .QfFermionOperator）：

\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 を引いた値までの間の任意の値をとることができる。

実装

この構造体は、疎行列で一般的に使用される「圧縮疎行形式」と同様に、項と係数を複数の疎ベクトルとして格納します。より具体的に言えば、1つの演算子には4つの配列が含まれています：

コラム「 1 」	コラム「 2 」
`coeffs`	2つの64ビット浮動小数点数からなる複素係数のベクトル。
`modes`	操作の対象となったマジョラナモードのインデックスを格納する、32ビット整数のベクトル。
`boundaries`	および `actions` における境界を示す整数のベクトル `indices`。

整数は、 $j$ というマジョラナモードのインデックス modes を表します。便利関数を使用する場合 gamma()、 $\gamma$ に対して、偶数（奇数）のインデックスが使用されます（ $\gamma'$ ）。

注

これらの内部配列の読み取り専用コピー には、それぞれの関数を介してアクセスできます：

qf_maj_op_get_coeffs()
qf_maj_op_get_modes()
qf_maj_op_get_boundaries()

このデータ構造により、演算子の構築や操作を非常に効率的に行うことができます。しかし、これは、演算子の中にいつでも重複する項が含まれている可能性があることを意味します。これらは、. を使用して手動で解決する必要があります 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()`	2つの演算子を足し合わせます。
`qf_maj_op_mul()`	演算子にスカラーを乗算します。
`qf_maj_op_compose()`	2つの演算子を互いに合成します。
`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)

新しい演算子を構築します。

ポインタ引数のいずれかがとなるのは、それに対応する長さがゼロである場合 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。
modes – すべての項にわたるモードの配列へのポインタ。この配列の長さはであるべきです 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_num_support

uint32_t qf_maj_op_num_support(const QfMajoranaOperator *op)

演算子の支持集合のサイズを取得します。

これを使用して qf_maj_op_get_support()、自身の長さを報告しないの出力バッファのサイズを設定します。

例

1uint32_t modes[3] = {2, 0, 2};
2QkComplex64 coeffs[2] = {{1.0, 0.0}, {1.0, 0.0}};
3uint32_t boundaries[3] = {0, 2, 3};
4QfMajoranaOperator *op = qf_maj_op_new(2, 3, coeffs, modes, boundaries);
5
6uint32_t num_support = qf_maj_op_num_support(op);
7
8assert(num_support == 2);

パラメーター

op – サポートサイズを取得するマジョラナ演算子へのポインタ。

戻り値

演算子が作用する異なるモード指標の数。

qf_maj_op_get_support

void qf_maj_op_get_support(const QfMajoranaOperator *op, uint32_t *support_out)

演算子のサポート、すなわち、その演算子が作用するマジョラーナモードのインデックスを取得します。

添字は昇順で記述され、どの項がそれに対して作用するかにかかわらず、各添字は正確に1回だけ現れます。

例

 1uint32_t modes[3] = {2, 0, 2};
 2QkComplex64 coeffs[2] = {{1.0, 0.0}, {1.0, 0.0}};
 3uint32_t boundaries[3] = {0, 2, 3};
 4QfMajoranaOperator *op = qf_maj_op_new(2, 3, coeffs, modes, boundaries);
 5
 6uint32_t num_support = qf_maj_op_num_support(op);
 7uint32_t *support_out = malloc(num_support * sizeof(uint32_t));
 8
 9qf_maj_op_get_support(op, support_out);
10
11assert(support_out[0] == 0);
12assert(support_out[1] == 2);
13
14free(support_out);

注

他のゲッターとは異なり、このゲッターは演算子へのポインタを返しません。サポートは事前に保存されるのではなく、必要に応じて計算されるため、呼び出し側が出力バッファを用意する必要があります。まずは qf_maj_op_num_support() その必要な長さを確認してください。

注

これらはフェルミオンモードのインデックスではなく、 マジョラーナモードのインデックスです。つまり、2で割られていません。したがって j 、フェルミオンモード上のマジョラーナ演算子は、添字および 2 * j ／またはを持つことになる 2 * j + 1。

パラメーター

op – 取得対象のサポートを持つマジョラナ演算子へのポインタ。
support_out – サポート値を書き込む整数配列へのポインタ。そのサイズは、少なくとも :c:func:qf_maj_op_num_support 個の要素を含むように設定する必要があります。

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_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

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

指定された演算子の属 groups 性を設定します。

この長さの検証はここで行われます。なぜなら、下流の処理でこれを再確認する箇所がないからです。インデックスの数が少なすぎると、項がグループとともに反復処理される際に、末尾の項が黙って除外されてしまいます。また、多すぎると、どの項も持ち合わせていないグループが報告 qf_maj_op_num_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 に含まれる項の数。

戻り値

終了コード。

QfExitCode_Success 成功した際に
QfExitCode_ValueError もしが演算子の項の数と異なれば groups_len

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 に基づいて新しい演算子のリストに分割します。

における重複インデックスは、における出現回数ごとに1回書き込まれます 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)

既存の演算子に項を追加します。

ポインタ引数のいずれかがとなるのは、それに対応する長さがゼロである場合 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)

2つの演算子を足し合わせます。

例

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 – 左演算子へのポインタ。
right – right 演算子へのポインタ。

戻り値

結果となる演算子へのポインタ。

qf_maj_op_scaled_add

QfMajoranaOperator *qf_maj_op_scaled_add(const QfMajoranaOperator *left, const QfMajoranaOperator *right, const QkComplex64 *factor)

2つの演算子を足し合わせ、右側の演算子の係数をスケーリングします。

これにより、スケーリングが加算処理に統合されるため、単に right 追加するためだけに完全にスケーリングされたコピーを作成する必要がなくなります。係数を乗じると、結果 -1 として引き算が行われることになるため、個別の引き算関数は用意されていません。

例

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *other = qf_maj_op_one();
3
4// Subtracting via a factor of -1 leaves the two terms cancelling each other out.
5QkComplex64 factor = {-1.0, 0.0};
6QfMajoranaOperator *result = qf_maj_op_scaled_add(one, other, &factor);
7
8QfMajoranaOperator *simplified = qf_maj_op_simplify(result, 1e-10);
9assert(qf_maj_op_len(simplified) == 0);

注

つまり qf_maj_op_add()、これはの項をの項と結合すること right なく追加するため left、結果にはグループインデックスが追跡されません。後で同等の条件で着信料着払いにして qf_maj_op_simplify() ください。

パラメーター

left – 左演算子へのポインタ。
right – right 演算子へのポインタ。
因子 – 右辺演算子の係数をスケールするための因子へのポインタ。

戻り値

結果として得られる演算子へのポインタ、 left + factor * right.

qf_maj_op_add_inplace

void qf_maj_op_add_inplace(QfMajoranaOperator *left, const QfMajoranaOperator *right)

ある演算子を別の演算子に、その場で追加します。

のインプレース版であり qf_maj_op_add()、新しく割り当てられた結果変数 left へのコピーを省略します。

警告

この関数は、演算子の属 groups 性をにリセットします NULL。

例

1QfMajoranaOperator *left = qf_maj_op_one();
2QfMajoranaOperator *right = qf_maj_op_one();
3
4qf_maj_op_add_inplace(left, right);
5
6assert(qf_maj_op_len(left) == 2);

パラメーター

left – 追加先の演算子へのポインタ。
right – 加算する演算子へのポインタ。

qf_maj_op_scaled_add_inplace

void qf_maj_op_scaled_add_inplace(QfMajoranaOperator *left, const QfMajoranaOperator *right, const QkComplex64 *factor)

ある演算子を別の演算子にその場で追加し、右側の演算子の係数をスケーリングします。

のインプレース版であり qf_maj_op_scaled_add()、結果を割り当てる left + factor * right ことなくを計算する。そこで、ある係数が差し引かれます -1 。

警告

この関数は、演算子の属 groups 性をにリセットします NULL。

例

1QfMajoranaOperator *left = qf_maj_op_one();
2QfMajoranaOperator *right = qf_maj_op_one();
3
4// Subtract, leaving two terms that cancel each other out.
5QkComplex64 factor = {-1.0, 0.0};
6qf_maj_op_scaled_add_inplace(left, right, &factor);
7
8QfMajoranaOperator *simplified = qf_maj_op_simplify(left, 1e-10);
9assert(qf_maj_op_len(simplified) == 0);

パラメーター

left – 追加先の演算子へのポインタ。
right – 加算する演算子へのポインタ。
因子 – 右辺演算子の係数をスケールするための因子へのポインタ。

qf_maj_op_mul_inplace

void qf_maj_op_mul_inplace(QfMajoranaOperator *op, const QkComplex64 *scalar)

演算子にスカラーを掛け、その場で計算します。

のインプレース版であり qf_maj_op_mul()、演算子を新たに割り当てられた結果変数にコピーする手間を省くことができます。

例

1QfMajoranaOperator *op = qf_maj_op_one();
2QkComplex64 scalar = {2.0, 0.0};
3
4qf_maj_op_mul_inplace(op, &scalar);

注

上記の2つのインプレース追加とは異なり、この方法では属性 groups が保持されます。係数をスケーリングしても、項の数は変わらず、したがって「1項につき1つのインデックス」という不変性も保たれます。

パラメーター

op – 拡大・縮小を行う演算子へのポインタ。
スカラー – スカラーへのポインタ。

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)

2つの演算子を互いに合成します。

例

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));

注

2つの演算子からなる式では、両方のオペランドがグループ化されている場合でも、グループは追跡されません。

パラメーター

left – 左演算子へのポインタ。
right – right 演算子へのポインタ。

戻り値

へのポインタ left.compose(right)。これは、行列乗算を用いて result = right @ left 定義される演算子に等しい @。つまり、が先に適用される right 。を得るには left @ 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 – 演算子へのポインタ。
昇順 – インデックスを昇順にするか降順にするかを指定します。
reduce – 各項について、恒等式に二乗される作用を除去することで、最小形に簡約するかどうか。

戻り値

作成された演算子へのポインタ。

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)

2つの演算子の等価性を比較する。

例

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 – 左演算子へのポインタ。
right – right 演算子へのポインタ。

戻り値

2つの演算子が等しいかどうか。

qf_maj_op_equiv

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

2つの演算子の等価性を比較する。

この文脈における「等価性」とは、指定された絶対許容誤差の範囲内での近似的な等しさを意味します。より正確に言えば、このメソッドは True、差分に含まれる係数の絶対値がすべて、指定された閾値を下回 other - self っている場合に、を返します 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 – 左演算子へのポインタ。
right – right 演算子へのポインタ。
atol – 係数等価性の絶対許容誤差。

戻り値

この2つの演算子が等価であるかどうか。

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で行ってください。