QfFermionOperator

struct QfFermionOperator

スピンを含まないフェルミオン演算子。

注

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

定義

この演算子は、スピンを持たないフェルミオンモードに作用するフェルミオン生成演算子および消滅演算子の積の線形結合によって定義される。つまり、個々の項は以下の反交換関係を満たす： [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{QfFermionOperator}} = \sum_i c_i \bigotimes_j \hat{A_j} \, ,

ここで、 $\hat{A_j} \in \{ a_j, a^\dagger_j \}$ 、 $c_i$ は、積の線形結合を構成する（複素）係数である。インデックス $j$ は、0 から、その演算子が作用するフェルミオンモードの数から 1 を引いた値までの間の任意の値をとることができます。

実装

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


`coeffs`	2つの64ビット浮動小数点数からなる、複素係数のベクトル。
`actions`	第2量子化処理の性質を格納するブール値のベクトル。
`modes`	作用を受けたフェルミオンモードのインデックスを格納する32ビット整数のベクトル。
`boundaries`	および `actions` における境界を示す整数のベクトル `modes`。

() で actions 示された項目は、 True (False) による生成（消滅）演算子を表します。でインデックス付けされたフェルミオンモードは、スピンを持たないものと modes みなされます。

注

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

qf_ferm_op_get_coeffs()
qf_ferm_op_get_actions()
qf_ferm_op_get_modes()
qf_ferm_op_get_boundaries()

このデータ構造により、演算子の構築や操作を非常に効率的に行うことができます。しかし、これは、演算子の中にいつでも重複する項が含まれている可能性があることを意味します。これらは、. を使用して手動で解決する必要があります qf_ferm_op_simplify()。

建設

上記で概説した対応する配列を指定することで、新しい演算子を直接構築することができます。あるいは、空のをで初期化し qf_ferm_op_zero() 、を通じて反復的に項を追加することもできます QfFermionOperatorqf_ferm_op_add_term() 。


`qf_ferm_op_new()`	指定された配列から新しい演算子を構築します。
`qf_ferm_op_zero()`	加法単位演算子を構築する。
`qf_ferm_op_one()`	乗法単位演算子を構築します。
`qf_ferm_op_add_term()`	既存の.に項を追加します `QfFermionOperator`。

注

A はを使って解放 QfFermionOperator できます qf_ferm_op_free()。

算数

以下の関数は、算術演算を行うためのものです：


`qf_ferm_op_add()`	2つの演算子を足し合わせます。
`qf_ferm_op_mul()`	演算子にスカラーを乗算します。
`qf_ferm_op_compose()`	2つの演算子を互いに合成します。
`qf_ferm_op_adjoint()`	エルミート共役演算子を返します。

操作

以下の関数は、演算子の操作ロジックを提供します：


`qf_ferm_op_ichop()`	係数の絶対値が小さい項を除去します。
`qf_ferm_op_simplify()`	同等だが簡略化された演算子を返します。
`qf_ferm_op_normal_ordered()`	通常の順序を持つ項を持つ等価演算子を返します。
`qf_ferm_op_relabel_modes()`	演算子のモードに新しいラベルを割り当てます。

プロパティ－

演算子の特定の性質を確認するために、以下の関数が用意されています。


`qf_ferm_op_is_hermitian()`	演算子がエルミートであるかどうかを返します。
`qf_ferm_op_max_rank()`	この演算子に含まれる項の最大ランクを返します。
`qf_ferm_op_conserves_particle_number()`	演算子が粒子数保存であるかどうかを返します。

[ 1 ]

https://en.wikipedia.org/wiki/Second _quantization#フェルミオンの生成・消滅演算子

メンバー

qf_ferm_op_new

QfFermionOperator *qf_ferm_op_new(uint64_t num_terms, uint64_t num_actions, const QkComplex64 *coeffs, const bool *actions, const uint32_t *modes, const uint32_t *boundaries)

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

ポインタ引数のいずれかがとなるのは、それに対応する長さがゼロである場合 NULL に限られる。

例

1uint64_t num_terms = 3;
2uint64_t num_actions = 4;
3bool actions[4] = {true, false, true, false};
4uint32_t modes[4] = {0, 1, 2, 3};
5QkComplex64 coeffs[3] = {{1.0, 0.0}, {-1.0, 0.0}, {0.0, -1.0}};
6uint32_t boundaries[4] = {0, 0, 2, 4};
7QfFermionOperator *op = qf_ferm_op_new(num_terms, num_actions, coeffs,
8                                       actions, modes, boundaries);

パラメーター

num_terms – 演算子に含まれる項の数。
num_actions – すべての項について合計したアクションの数。
coeffs – 項の係数の配列へのポインタ。この配列の長さはであるべきです num_terms。
アクション – すべての項にわたるアクションの配列へのポインタ。この配列の長さはであるべきです num_actions。
modes – すべての項にわたるアクションモードの配列へのポインタ。この配列の長さはであるべきです num_actions。
境界 – 項間の境界の配列へのポインタ。この配列の長さはであるべきです num_terms + 1。

qf_ferm_op_free

void qf_ferm_op_free(QfFermionOperator *op)

既存の演算子を解放します。

例

1QfFermionOperator *op = qf_ferm_op_one();
2qf_ferm_op_free(op);

パラメーター

op – 解放対象のフェルミオン演算子へのポインタ。

qf_ferm_op_get_coeffs

void qf_ferm_op_get_coeffs(const QfFermionOperator *op, QkComplex64 **coeffs_out, uint64_t *coeffs_len)

演算子の係数に対して読み取り専用のアクセス権限を提供します。

関連資料

内部データ構造の説明はこちらです。

例

 1uint64_t num_terms = 2;
 2uint64_t num_actions = 0;
 3QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 4uint32_t boundaries[3] = {0, 0, 0};
 5QfFermionOperator *op =
 6    qf_ferm_op_new(num_terms, num_actions, coeffs, NULL, NULL, boundaries);
 7
 8QkComplex64 *coeffs_out;
 9uint64_t *coeffs_len;
10
11qf_ferm_op_get_coeffs(op, &coeffs_out, &coeffs_len);
12
13assert(coeffs_len == 2);

注

この関数は、内部データのコピーを返します。

パラメーター

op – アクセスする係数を持つフェルミオン演算子へのポインタ。
coeffs_out – 係数を書き込む複素数の配列へのポインタ。
coeffs_len – 出力配列の長さを書き込む整数変数へのポインタ。

qf_ferm_op_get_actions

void qf_ferm_op_get_actions(const QfFermionOperator *op, bool **actions_out, uint64_t *actions_len)

オペレータの操作に対して読み取り専用のアクセス権限を提供します。

関連資料

内部データ構造の説明はこちらです。

例

 1uint64_t num_terms = 2;
 2uint64_t num_actions = 2;
 3bool actions[2] = {true, false};
 4uint32_t modes[2] = {0, 1};
 5QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 6uint32_t boundaries[3] = {0, 0, 2};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10QkComplex64 *actions_out;
11uint64_t *actions_len;
12
13qf_ferm_op_get_actions(op, &actions_out, &actions_len);
14
15assert(actions_len == 2);

注

この関数は、内部データのコピーを返します。

パラメーター

op – アクセスする作用を持つフェルミオン演算子へのポインタ。
actions_out – アクションを書き込むブール値の配列へのポインタ。
actions_len – 出力配列の長さを書き込む整数変数へのポインタ。

qf_ferm_op_get_modes

void qf_ferm_op_get_modes(const QfFermionOperator *op, uint32_t **modes_out, uint64_t *modes_len)

オペレータの対象となるモードインデックスへの読み取り専用アクセスを提供します。

関連資料

内部データ構造の説明はこちらです。

例

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

注

この関数は、内部データのコピーを返します。

パラメーター

op – アクセスするモードを持つフェルミオン演算子へのポインタ。
modes_out – モードを書き込むブール値の配列へのポインタ。
modes_len – 出力配列の長さを書き込む整数変数へのポインタ。

qf_ferm_op_get_boundaries

void qf_ferm_op_get_boundaries(const QfFermionOperator *op, size_t **boundaries_out, uint64_t *boundaries_len)

演算子の項間の境界を示すインデックスへの読み取り専用アクセスを提供します。

関連資料

内部データ構造の説明はこちらです。

例

 1uint64_t num_terms = 2;
 2uint64_t num_actions = 2;
 3bool actions[2] = {true, false};
 4uint32_t modes[2] = {0, 1};
 5QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 6uint32_t boundaries[3] = {0, 0, 2};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10QkComplex64 *boundaries_out;
11uint64_t *boundaries_len;
12
13qf_ferm_op_get_boundaries(op, &boundaries_out, &boundaries_len);
14
15assert(boundaries_len == 3);

注

この関数は、内部データのコピーを返します。

パラメーター

op – アクセスする境界を持つフェルミオン演算子へのポインタ。
boundaries_out – 境界値を書き込むブール値の配列へのポインタ。
boundaries_len – 出力配列の長さを書き込む整数変数へのポインタ。

qf_ferm_op_zero

QfFermionOperator *qf_ferm_op_zero(void)

加法単位演算子を構築する。

この方法で構築された演算子を別の演算子に追加しても、何の効果もありません。

例

1QfFermionOperator *zero = qf_ferm_op_zero();
2
3QfFermionOperator *op_plus_zero = qf_ferm_op_add(op, zero);
4
5assert(qf_ferm_op_equal(op, op_plus_zero));

戻り値

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

qf_ferm_op_one

QfFermionOperator *qf_ferm_op_one(void)

乗法単位演算子を構築します。

この方法で構築された演算子を別の演算子と組み合わせても、何の効果もありません。

例

1QfFermionOperator *one = qf_ferm_op_one();
2
3QfFermionOperator *op_times_one = qf_ferm_op_compose(op, one);
4
5assert(qf_ferm_op_equal(op, op_times_one));

戻り値

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

qf_ferm_op_has_groups

bool qf_ferm_op_has_groups(const QfFermionOperator *op)

この演算子がグループインデックスを追跡するかどうかを確認します。

関連資料

グループ演算子の用語に関する説明：演算子の構造を使用してください。

例

1QfFCIDump *fcidump = qf_fcidump_from_file("molecule.fcidump");
2QfFermionOperator *op = qf_ferm_op_from_fcidump(fcidump);
3
4bool has_groups = qf_ferm_op_has_groups(op);
5
6assert(!has_groups);

パラメーター

op – チェック対象のフェルミオン演算子へのポインタ。

戻り値

指定された演算子に属性 groups があるかどうか。

qf_ferm_op_num_groups

uint32_t qf_ferm_op_num_groups(const QfFermionOperator *op)

演算子からグループ数を取得します。

関連資料

グループ演算子の用語に関する説明：演算子の構造を使用してください。

例

1QfFCIDump *fcidump = qf_fcidump_from_file("molecule.fcidump");
2QfFermionOperator *op = qf_ferm_op_from_fcidump(fcidump);
3
4uint32_t num_groups = qf_ferm_op_num_groups(op);

注

グループの数は、出現する最大のグループインデックスに1を加えた値として、遅延評価されます。

パラメーター

op – 取得する群の数を持つフェルミオン演算子へのポインタ。

戻り値

演算子の属性 groups に基づくグループインデックスの数。

qf_ferm_op_group_weights

void qf_ferm_op_group_weights(const QfFermionOperator *op, double *weights_out)

各グループの絶対係数の平均値を取得します。

第- i番目の項は、グループ内の各項 abs(coeff) の和を i、そのグループの項の数で割ったものです。これは、個々の項ではなくグループ全体を抽出するランダム化積分式（例： qDRIFT ）のサンプリング重みであり、呼び出し元側でおよび qf_ferm_op_get_coeffs() を還元（ qf_ferm_op_get_groups()* グループ化されていない*各項につき1つの値を算出）するのではなく、演算子に対して1回のパスで計算されます。

関連資料

グループ演算子の用語に関する説明：演算子の構造を使用してください。

例

 1uint64_t num_terms = 4;
 2uint64_t num_actions = 8;
 3bool actions[8] = {true, false, true, false, true, false, true, false};
 4uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 5QkComplex64 coeffs[4] = {{1.0, 0.0}, {2.0, 0.0}, {-1.0, 0.0}, {-2.0, 0.0}};
 6uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10uint32_t groups_in[4] = {0, 1, 0, 1};
11qf_ferm_op_set_groups(op, groups_in, num_terms);
12
13double weights[2];
14qf_ferm_op_group_weights(op, weights);
15
16assert(weights[0] == 1.0);
17assert(weights[1] == 2.0);

注

どの項も含まれていないグループインデックスの重みはであり 0.0、これによりそのグループはサンプルから除外される。

パラメーター

op – 計算対象の群重みを持つフェルミオン演算子へのポインタ。
weights_out – 重みを書き込むdouble型の配列へのポインタ。 :c:funcqf_ferm_op_num_groups: に合わせたサイズにする必要があります。

qf_ferm_op_get_groups

void qf_ferm_op_get_groups(const QfFermionOperator *op, uint32_t **groups_out, uint64_t *groups_len)

すべての演算子項のグループインデックスを取得します。

関連資料

グループ演算子の用語に関する説明：演算子の構造を使用してください。

例

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

パラメーター

op – グループのインデックスを取得するフェルミオン演算子へのポインタ。
groups_out – グループインデックスを書き込む整数配列へのポインタ。
groups_len – 出力配列の長さを書き込む整数変数へのポインタ。

qf_ferm_op_set_groups

void qf_ferm_op_set_groups(QfFermionOperator *op, const uint32_t *groups_in, uint64_t groups_len)

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

関連資料

グループ演算子の用語に関する説明：演算子の構造を使用してください。

例

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

パラメーター

op – 書き込む属性 groups を持つフェルミオン演算子へのポインタ。
groups_in – 演算子に書き込む整数 groups 配列へのポインタ。
groups_len – 配列 groups_in に含まれる項の数。

qf_ferm_op_del_groups

void qf_ferm_op_del_groups(QfFermionOperator *op)

指定された演算子から属 groups 性を削除します。

関連資料

グループ演算子の用語に関する説明：演算子の構造を使用してください。

例

1QfFermionOperator *op = ...;
2
3qf_ferm_op_del_groups(op);

パラメーター

op – 削除する groups 属性を持つフェルミオン演算子へのポインタ。

qf_ferm_op_split_out_groups

void qf_ferm_op_split_out_groups(const QfFermionOperator *op, const uint32_t *group_indices, uint64_t num_indices, QfFermionOperator **group_ops_out)

この演算子を、その属性 groups に基づいて新しい演算子のリストに分割します。

における重複インデックスは、における出現回数ごとに1回書き込まれます group_indices``group_ops_out 。総数に比べてごく少数のグループのみをリクエストする場合、すべてのグループをリクエストする場合に比べて大幅にコストが抑えられます。これは、リクエスト対象外のグループに属する用語は、どこにも追加されることなくスキップされるためです。

関連資料

グループ演算子の用語に関する説明：演算子の構造を使用してください。

例

 1uint64_t num_terms = 4;
 2uint64_t num_actions = 8;
 3bool actions[8] = {true, false, true, false, true, false, true, false};
 4uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 5QkComplex64 coeffs[4] = {{1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}};
 6uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10uint32_t groups_in[4] = {0, 1, 0, 1};
11qf_ferm_op_set_groups(op, groups_in, num_terms);
12
13// build every group, in index order
14QfFermionOperator *group_ops[2];
15qf_ferm_op_split_out_groups(op, NULL, 0, group_ops);
16
17// build only group 1
18uint32_t group_indices[1] = {1};
19QfFermionOperator *group_op[1];
20qf_ferm_op_split_out_groups(op, group_indices, 1, group_op);

パラメーター

op – 分離対象 groups となるフェルミオン演算子へのポインタ。
group_indices – 演算子を構築するグループインデックスの配列へのポインタ。出力順序は指定された順序に従う。そうかもしれません NULL。その場合、すべてのグループはインデックスの順に構築されます（これは、すべてのインデックスをから :c:func:qf_ferm_op_num_groups 0 へ渡すことと同等です - 1）。
num_indices – 配列 group_indices に含まれるインデックスの数。が group_indices の場合、無視される NULL。
group_ops_out – 要求された各グループの演算子を書き込む :c:struct:QfFermionOperator の配列へのポインタ。が group_indices 非の num_indices ときはにNULL、がのときは :c:func:qf_ferm_op_num_groups にサイズ設定する必要があります NULL。

qf_ferm_op_add_term

void qf_ferm_op_add_term(QfFermionOperator *op, uint64_t num_actions, const bool *actions, const uint32_t *modes, const QkComplex64 *coeff)

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

ポインタ引数のいずれかがとなるのは、それに対応する長さがゼロである場合 NULL に限られる。

警告

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

例

 1QfFermionOperator *one = qf_ferm_op_one();
 2
 3QfFermionOperator *op = qf_ferm_op_zero();
 4bool actions[0] = {};
 5uint32_t modes[0] = {};
 6QkComplex64 coeff = {1.0, 0.0};
 7
 8qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 9
10assert(qf_ferm_op_equal(op, one));

パラメーター

op – 変更対象のフェルミオン演算子へのポインタ。
num_actions – actions 配列の長さ。
アクション – アクションの配列へのポインタ。この配列の長さはであるべきです num_actions。
modes – アクションモードの配列へのポインタ。この配列の長さはであるべきです num_actions。
coeff – 複素係数を指すポインタ。

qf_ferm_op_add

QfFermionOperator *qf_ferm_op_add(const QfFermionOperator *left, const QfFermionOperator *right)

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

例

1QfFermionOperator *one = qf_ferm_op_one();
2QfFermionOperator *zero = qf_ferm_op_zero();
3
4QfFermionOperator *result = qf_ferm_op_add(one, zero);
5
6assert(qf_ferm_op_equal(result, one));

パラメーター

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

戻り値

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

qf_ferm_op_mul

QfFermionOperator *qf_ferm_op_mul(const QfFermionOperator *op, const QkComplex64 *scalar)

演算子にスカラーを乗算します。

例

 1QfFermionOperator *one = qf_ferm_op_one();
 2QkComplex64 coeff = {2.0, 0.0};
 3QfFermionOperator *result = qf_ferm_op_mul(one, &coeff);
 4
 5QfFermionOperator *expected = qf_ferm_op_zero();
 6bool actions[0] = {};
 7uint32_t modes[0] = {};
 8qf_ferm_op_add_term(expected, 0, actions, modes, &coeff);
 9
10assert(qf_ferm_op_equal(result, expected));

パラメーター

op – 演算子へのポインタ。
スカラー – スカラーへのポインタ。

戻り値

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

qf_ferm_op_compose

QfFermionOperator *qf_ferm_op_compose(const QfFermionOperator *left, const QfFermionOperator *right)

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

例

1QfFermionOperator *one = qf_ferm_op_one();
2QfFermionOperator *zero = qf_ferm_op_zero();
3
4QfFermionOperator *result = qf_ferm_op_compose(one, zero);
5
6assert(qf_ferm_op_equal(result, zero));

パラメーター

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

戻り値

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

qf_ferm_op_adjoint

QfFermionOperator *qf_ferm_op_adjoint(const QfFermionOperator *op)

演算子のエルミート共役（または随伴）を返します。

これにより、項と係数には次のような影響が生じます：

各項における作用は順序が逆転し、生成と消滅が交互に繰り返される
係数は複素共役である

例

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[0] = {};
 3uint32_t modes[0] = {};
 4QkComplex64 coeff = {0.0, 1.0};
 5qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 6
 7QfFermionOperator *adjoint = qf_ferm_op_adjoint(op);
 8
 9QfFermionOperator *expected = qf_ferm_op_zero();
10QkComplex64 coeff_adj = {0.0, -1.0};
11qf_ferm_op_add_term(expected, 0, actions, modes, &coeff_adj);
12
13assert(qf_ferm_op_equal(adjoint, expected));

パラメーター

op – 演算子へのポインタ。

戻り値

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

qf_ferm_op_ichop

void qf_ferm_op_ichop(QfFermionOperator *op, double atol)

指定された閾値未満の係数の絶対値を持つ項を除去します。

警告

この関数は、係数を貪欲に切り捨ててしまいます！対象となる演算子に、重複する項に対して個別の係数が含まれている可能性がある場合は、代わりに qf_ferm_op_simplify() を呼び出すことを検討してください！

例

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[0] = {};
 3uint32_t modes[0] = {};
 4QkComplex64 coeff = {1e-8};
 5qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 6
 7qf_ferm_op_ichop(op, 1e-6);
 8
 9QfFermionOperator *expected = qf_ferm_op_zero();
10
11assert(qf_ferm_op_equal(op, expected));

パラメーター

op – 演算子へのポインタ。
atol – 係数の切り捨てに対する絶対許容誤差。

qf_ferm_op_simplify

QfFermionOperator *qf_ferm_op_simplify(const QfFermionOperator *op, double atol)

同等だが簡略化された演算子を返します。

簡略化のプロセスでは、まず同じ項に属するすべての係数を合計し、その合計係数が指定された許容誤差を超えるもののみを残します（ちょうどのように qf_ferm_op_ichop()）。

演算子が算術的に操作されたり、一意な項が保証されない方法で構築されたりした場合、情報の損失を防ぐために、数値的に小さい係数をフィルタリングするメソッドを適用する前に、このメソッドを呼び出す必要があります。以下の例では、合計係数の絶対値が切り捨てられるべきではないにもかかわらず、項が切り捨てられて qf_ferm_op_ichop() しまう様子が示されています

 1uint64_t num_terms = 100000;
 2uint64_t num_actions = 0;
 3bool actions[0] = {};
 4uint32_t modes[0] = {};
 5QkComplex64 coeffs[100000];
 6uint32_t boundaries[100001];
 7for (int i = 0; i < 100000; i++) {
 8  coeffs[i].re = 1e-5;
 9  coeffs[i].im = 0.0;
10  boundaries[i] = 0;
11}
12boundaries[100000] = 0;
13QfFermionOperator *op = qf_ferm_op_new(num_terms, num_actions, coeffs,
14                                       actions, modes, boundaries);
15
16QfFermionOperator *canon = qf_ferm_op_simplify(op, 1e-4);
17
18QfFermionOperator *one = qf_ferm_op_one();
19bool canon_is_equal = qf_ferm_op_equiv(canon, one, 1e-6);
20
21qf_ferm_op_ichop(op, 1e-4);
22
23QfFermionOperator *zero = qf_ferm_op_zero();
24bool ichop_is_equal = qf_ferm_op_equiv(op, zero, 1e-6);

パラメーター

op – 簡略化するフェルミオン演算子へのポインタ。
atol – 係数の切り捨てに対する絶対許容誤差。

戻り値

同等だが簡略化された演算子。

qf_ferm_op_normal_ordered

QfFermionOperator *qf_ferm_op_normal_ordered(const QfFermionOperator *op, const bool *sandwich)

通常の順序を持つ項を持つ等価演算子を返します。

演算子項の通常の順序は、すべての生成作用がすべての消滅作用よりも前に現れるように定義される。各グループ内では、作用を受けるモードは辞書順に並べられます。順序が昇順になるか降順になるかは、引 sandwich 数の値によって決まります：

NULL: 両方のグループは辞書順で降順に並べられている（例： +_1 +_0 -_1 -_0）
True: 中央に向かってより大きな添字が現れる。つまり、生成作用は辞書順に昇順で並び、消滅作用は降順で並ぶ（例： +_0 +_1 -_1 -_0）
False: 中央に向かってインデックスが小さくなる。つまり、生成アクションは辞書順で降順になり、消滅アクションは昇順になる（例： +_1 +_0 -_0 -_1）

例

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[4] = {false, true, false, true};
 3uint32_t modes[4] = {1, 1, 0, 0};
 4QkComplex64 coeff = {1.0, 0.0};
 5qf_ferm_op_add_term(op, 4, actions, modes, &coeff);
 6
 7QfFermionOperator *normal_ordered = qf_ferm_op_normal_ordered(op, NULL);
 8
 9uint64_t num_terms = 4;
10uint64_t num_actions = 8;
11bool actions_exp[8] = {true, false, true, false, true, true, false, false};
12uint32_t modes_exp[8] = {0, 0, 1, 1, 1, 0, 1, 0};
13QkComplex64 coeffs_exp[4] = {
14    {1.0, 0.0}, {-1.0, 0.0}, {-1.0, 0.0}, {-1.0, 0.0}};
15uint32_t boundaries_exp[5] = {0, 0, 2, 4, 8};
16QfFermionOperator *expected =
17    qf_ferm_op_new(num_terms, num_actions, coeffs_exp, actions_exp,
18                   modes_exp, boundaries_exp);
19
20assert(qf_ferm_op_equal(normal_ordered, expected));

注

項の順序を変更する際には、反交換関係（ $a_i a^\dagger_j = \delta_{ij} - a^\dagger_j a^i$ ）を考慮する必要があり、これにより項の数が変わる可能性がある。

パラメーター

op – 演算子へのポインタ。
sandwich – ブール値へのポインタ。このポインタは…である可能性があります NULL。

戻り値

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

qf_ferm_op_is_hermitian

bool qf_ferm_op_is_hermitian(const QfFermionOperator *op, double atol)

演算子がエルミートであるかどうかを判定します。

例

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions1[2] = {true, false};
 3uint32_t modes1[2] = {0, 1};
 4QkComplex64 coeff1 = {0.0, 1.00001};
 5qf_ferm_op_add_term(op, 2, actions1, modes1, &coeff1);
 6bool actions2[2] = {true, false};
 7uint32_t modes2[2] = {1, 0};
 8QkComplex64 coeff2 = {0.0, -1};
 9qf_ferm_op_add_term(op, 2, actions2, modes2, &coeff1);
10
11assert(qf_ferm_op_is_hermitian(op, 1e-4));
12assert(!qf_ferm_op_is_hermitian(op, 1e-8));

注

このチェックは、と op 、その、 qf_ferm_op_adjoint() およびの qf_ferm_op_normal_ordered() 差 qf_ferm_op_equiv() を用いて実装されています qf_ferm_op_zero()。

パラメーター

op – チェック対象のフェルミオン演算子へのポインタ。
atol – 係数が等しいとみなされる絶対許容誤差。

戻り値

指定された演算子がエルミート演算子であるかどうか。

qf_ferm_op_max_rank

uint32_t qf_ferm_op_max_rank(const QfFermionOperator *op)

演算子の最大位数を確認します。

例

1QfFermionOperator *op = qf_ferm_op_zero();
2bool actions[4] = {true, false, true, false};
3uint32_t modes[4] = {0, 1, 2, 3};
4QkComplex64 coeff = {1.0, 0.0};
5qf_ferm_op_add_term(op, 4, actions, modes, &coeff);
6
7assert(qf_ferm_op_max_rank(op), 4);

注

最長の項の長さは、演算子の形式によって異なる場合があり、つまり（例えば）演算子の簡約や正規順序付けを行うと、最大ランクが異なる結果となる可能性がある。

パラメーター

op – チェック対象のフェルミオン演算子へのポインタ。

戻り値

演算子の最大ランク。

qf_ferm_op_conserves_particle_number

bool qf_ferm_op_conserves_particle_number(const QfFermionOperator *op)

演算子が粒子数保存であるかどうかを調べます。

例

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions1[2] = {true, false};
 3uint32_t modes1[2] = {0, 1};
 4QkComplex64 coeff1 = {0.0, 1.00001};
 5qf_ferm_op_add_term(op, 2, actions1, modes1, &coeff1);
 6bool actions2[2] = {true, false};
 7uint32_t modes2[2] = {1, 0};
 8QkComplex64 coeff2 = {0.0, -1};
 9qf_ferm_op_add_term(op, 2, actions2, modes2, &coeff2);
10
11assert(qf_ferm_op_is_hermitian(op, 1e-4));
12assert(!qf_ferm_op_is_hermitian(op, 1e-8));

パラメーター

op – チェック対象のフェルミオン演算子へのポインタ。

戻り値

与えられた演算子が粒子数の保存を満たすかどうか。

qf_ferm_op_equal

bool qf_ferm_op_equal(const QfFermionOperator *left, const QfFermionOperator *right)

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

例

1QfFermionOperator *one = qf_ferm_op_one();
2QfFermionOperator *zero = qf_ferm_op_zero();
3
4assert(qf_ferm_op_equal(one, one));
5assert(!qf_ferm_op_equal(one, zero));

パラメーター

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

戻り値

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

qf_ferm_op_equiv

bool qf_ferm_op_equiv(const QfFermionOperator *left, const QfFermionOperator *right, double atol)

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

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

例

 1QfFermionOperator *zero = qf_ferm_op_zero();
 2
 3QfFermionOperator *op = qf_ferm_op_zero();
 4bool actions[0] = {};
 5uint32_t modes[0] = {};
 6QkComplex64 coeff = {1e-7, 0.0};
 7qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 8
 9assert(qf_ferm_op_equiv(op, zero, 1e-6));
10assert(!qf_ferm_op_equiv(op, zero, 1e-8));

パラメーター

left – 左演算子へのポインタ。
right – right 演算子へのポインタ。
atol – 係数等価性の絶対許容誤差。

戻り値

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

qf_ferm_op_len

size_t qf_ferm_op_len(const QfFermionOperator *op)

指定された演算子の長さ（または項の数）を返します。

例

1QfFermionOperator *op = qf_ferm_op_zero();
2bool actions[4] = {true, false, true, false};
3uint32_t modes[4] = {0, 1, 2, 3};
4QkComplex64 coeff = {1.0, 0.0};
5qf_ferm_op_add_term(op, 4, actions, modes, &coeff);
6
7assert(qf_ferm_op_len(op) == 1);

パラメーター

op – フェルミオン演算子へのポインタ。

戻り値

演算子の長さ（または項の数）。

qf_ferm_op_relabel_modes

QfExitCode qf_ferm_op_relabel_modes(QfFermionOperator *op, uint64_t num_modes, const uint32_t *permutation)

指定された演算子のインデックスに新しいラベルを割り当てます。

例

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[4] = {true, false, true, false};
 3uint32_t indices[4] = {0, 1, 2, 3};
 4QkComplex64 coeff = {1.0, 0.0};
 5qf_ferm_op_add_term(op, 4, actions, indices, &coeff);
 6
 7uint32_t permutation[4] = {3, 2, 1, 0};
 8
 9QfExitCode exit = qf_ferm_op_relabel_modes(op, 4, permutation);
10
11assert(exit == QfExitCode_Success);

パラメーター

op – フェルミオン演算子へのポインタ。
num_modes – 指定された順列リストに含まれるモードインデックスの数。
順列 – インデックスの順列リスト。

戻り値

終了コード。

QfExitCode_Success 成功した際に
QfExitCode_DuplicateIndexError 順列の中に重複するインデックスが見つかった場合
QfExitCode_IndexError 無効なインデックスなど、その他のインデックスに関するエラーについては。

このページは役に立ちましたか？

バグや誤字の報告、またはコンテンツの要求はGitHubで行ってください。