QkDag

QkDag *qk_dag_new(void)

Erstellen Sie einen neuen leeren DAG.

Sie müssen die zurückgegebene DAG mit qk_dag_free freigeben, wenn Sie damit fertig sind.

Beispiel

QkDag *empty = qk_dag_new();

Rückgabe

Ein Zeiger auf den erstellten DAG.

void qk_dag_add_quantum_register(QkDag *dag, const QkQuantumRegister *reg)

Füge ein Quantenregister zum DAG hinzu.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(1024, "my_register");
qk_dag_add_quantum_register(dag, qr);
qk_quantum_register_free(qr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, nicht dag null-Zeiger auf ein ist QkDag und wenn kein gültiger, nicht reg null-Zeiger auf ein ist QkQuantumRegister.

Parameter

• dag – Ein Zeiger auf die DAG.
• reg – Ein Zeiger auf das Quantenregister.

void qk_dag_add_classical_register(QkDag *dag, const QkClassicalRegister *reg)

Fügen Sie dem DAG ein klassisches Register hinzu.

Beispiel

QkDag *dag = qk_dag_new();
QkClassicalRegister *cr = qk_classical_register_new(24, "my_register");
qk_dag_add_classical_register(dag, cr);
qk_classical_register_free(cr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, nicht dag null-Zeiger auf ein ist QkDag und wenn kein gültiger, nicht reg null-Zeiger auf ein ist QkClassicalRegister.

Parameter

• dag – Ein Zeiger auf die DAG.
• reg – Ein Zeiger auf das klassische Register.

uint32_t qk_dag_num_qubits(const QkDag *dag)

Ermitteln Sie die Anzahl der Qubits, die der DAG enthält.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(24, "my_register");
qk_dag_add_quantum_register(dag, qr);
uint32_t num_qubits = qk_dag_num_qubits(dag);  // num_qubits==24
qk_quantum_register_free(qr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.

Rückgabe

Die Anzahl der Qubits, für die der DAG definiert ist.

uint32_t qk_dag_num_clbits(const QkDag *dag)

Ermitteln Sie die Anzahl der Clbits, die die DAG enthält.

Beispiel

QkDag *dag = qk_dag_new();
QkClassicalRegister *cr = qk_classical_register_new(24, "my_register");
qk_dag_add_classical_register(dag, cr);
uint32_t num_clbits = qk_dag_num_clbits(dag);  // num_clbits==24
qk_classical_register_free(cr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.

Rückgabe

Die Anzahl der Clbits, auf denen die DAG definiert ist.

size_t qk_dag_num_op_nodes(const QkDag *dag)

Gibt die Gesamtzahl der Betriebsknoten im DAG zurück.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(1, "my_register");
qk_dag_add_quantum_register(dag, qr);

uint32_t qubit[1] = {0};
qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);
size_t num = qk_dag_num_op_nodes(dag); // 1

qk_dag_free(dag);
qk_quantum_register_free(qr);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.

Rückgabe

Die Gesamtzahl der Anweisungen im DAG.

QkParam *qk_dag_global_phase(const QkDag *dag)

Rufe die globale Phase des DAG ab.

Diese Funktion gibt eine Kopie der globalen Phase des DAG zurück; der Wert muss nach der Verwendung über :c:func:qk_param_free freigegeben werden.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(24, "my_register");
qk_dag_add_quantum_register(dag, qr);
QkParam *global_phase = qk_dag_global_phase(dag);
qk_param_free(global_phase);
qk_quantum_register_free(qr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.

Rückgabe

Die globale Phase des DAG.

QkExitCode qk_dag_set_global_phase(QkDag *dag, const QkParam *phase)

Legen Sie die globale Phase des DAG fest.

Diese Funktion kopiert die neue globale Phase beim Setzen, sodass der Aufrufer weiterhin Eigentümer der QkParam Phase bleibt; der Wert der Phase muss daher nach dem Setzen über :c:func:qk_param_free freigegeben werden.

Beispiel

QkDag *dag = qk_dag_new();
QkParam *new_global_phase = qk_param_from_double(1.23);
qk_dag_set_global_phase(dag, new_global_phase);
qk_param_free(new_global_phase);
qk_dag_free(dag);

Sicherheit

QkParamDas Verhalten ist undefiniert, wenn dag kein gültiger, nicht-null-Zeiger auf ein QkDag ist und wenn phase kein gültiger, nicht-null-Zeiger auf ein ist.

Parameter

• dag – Ein Zeiger auf die DAG.
• Phase – Ein Zeiger auf die globale Phase, die festgelegt werden soll.

Rückgabe

QkExitCode_Success nach erfolgreicher Festlegung der globalen Phase. Im Fehlerfall werden allgemeine Fehler beschrieben, QkExitCode_ParameterError die beim Versuch auftreten können, die Parametersymbole nachzuverfolgen, wie z. B. ungültige Parameterwerte. Andernfalls weist dies QkExitCode_DagError auf eine DAG-spezifische Ursache des Fehlers hin.

QkDagNodeType qk_dag_node_type(const QkDag *dag, uint32_t node)

Ruft den Typ des angegebenen Knotens ab.

Das Ergebnis kann in einer switch-Anweisung verwendet werden, um bei der Iteration über Knoten unbekannten Typs die richtige Behandlung zu veranlassen.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Knoten, dessen Typ abgerufen werden soll.

Rückgabe

Der Typ des Knotens.

uint32_t qk_dag_qubit_in_node(const QkDag *dag, uint32_t qubit)

Rufe den Index des Eingangsknotens des Drahtes ab, der dem angegebenen Qubit entspricht.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• qubit – Das Qubit, dessen Eingabeknotenindex abgerufen werden soll.

Rückgabe

Der Eingangsknoten des Qubit-Drahtes.

uint32_t qk_dag_qubit_out_node(const QkDag *dag, uint32_t qubit)

Ruft den Index des Ausgangsknotens der Leitung ab, die dem angegebenen Qubit entspricht.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• qubit – Das Qubit, dessen Ausgabeknotenindex abgerufen werden soll.

Rückgabe

Der Ausgangsknoten des Qubit-Drahtes.

uint32_t qk_dag_clbit_in_node(const QkDag *dag, uint32_t clbit)

Ruft den Index des Eingangsknotens der Leitung ab, der dem angegebenen clbit entspricht.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• clbit – Das clbit, um den Index des Eingabeknotens zu erhalten.

Rückgabe

Der Eingangsknoten des clbit-Kabels.

uint32_t qk_dag_clbit_out_node(const QkDag *dag, uint32_t clbit)

Ruft den Index des Ausgangsknotens der Leitung ab, der dem angegebenen clbit entspricht.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• clbit – Das clbit, um den Ausgabeknotenindex zu erhalten.

Rückgabe

Der Ausgangsknoten des clbit-Kabels.

uint32_t qk_dag_wire_node_value(const QkDag *dag, uint32_t node)

Den Wert eines Drahtendpunktknotens abrufen.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Endpunktknoten, dessen Drahtwert abgerufen werden soll.

Rückgabe

Der Wert (z. B. Qubit, Clbit oder Var) innerhalb des Endpunktknotens.

uint32_t qk_dag_op_node_num_qubits(const QkDag *dag, uint32_t node)

Ruft die Anzahl der Qubits des angegebenen Operationsknotens ab.

Löst eine Panik aus, wenn der Knoten keine Operation ist.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• node – Der Betriebsknoten, dessen Anzahl an Qubits abgerufen werden soll.

Rückgabe

Die Anzahl der Qubits der Operation.

uint32_t qk_dag_op_node_num_clbits(const QkDag *dag, uint32_t node)

Ruft die Anzahl der Clbits des angegebenen Operationsknotens ab.

Löst eine Panik aus, wenn der Knoten keine Operation ist.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Betriebsknoten, dessen Anzahl an Clbits ermittelt werden soll.

Rückgabe

Die Anzahl der Clbits der Operation.

uint32_t qk_dag_op_node_num_params(const QkDag *dag, uint32_t node)

Ruft die Anzahl der Parameter des angegebenen Operationsknotens ab.

Löst eine Panik aus, wenn der Knoten keine Operation ist.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• node – Der Betriebsknoten, dessen Parameteranzahl abgerufen werden soll.

Rückgabe

Die Anzahl der Parameter der Operation.

const uint32_t *qk_dag_op_node_qubits(const QkDag *dag, uint32_t node)

Ruft die Qubits des angegebenen Operationsknotens ab.

Löst eine Panik aus, wenn der Knoten keine Operation ist.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Betriebsknoten, von dem die Qubits abgerufen werden sollen.

Rückgabe

Ein Zeiger auf die Qubits. Verwenden Sie qk_dag_op_node_num_qubits , um die Anzahl der Elemente zu bestimmen.

const uint32_t *qk_dag_op_node_clbits(const QkDag *dag, uint32_t node)

Ruft die clbits des angegebenen Betriebsknotens ab.

Löst eine Panik aus, wenn der Knoten keine Operation ist.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Betriebsknoten, von dem die clbits abgerufen werden sollen.

Rückgabe

Ein Zeiger auf die clbits. Verwenden Sie qk_dag_op_node_num_clbits , um die Anzahl der Elemente zu bestimmen.

uint32_t qk_dag_apply_gate(QkDag *dag, QkGate gate, const uint32_t *qubits, const double *params, bool front)

Wenden Sie ein QkGate auf das DAG an.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(1, "my_register");
qk_dag_add_quantum_register(dag, qr);

uint32_t qubit[1] = {0};
qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);

qk_dag_free(dag);
qk_quantum_register_free(qr);

Sicherheit

Die Typen qubits``params und sollen jeweils auf ein Array double von uint32_t und zeigen, dessen Länge den Erwartungen für das Standardgatter entspricht. Wenn das Array nicht ausreichend lang ist, ist das Verhalten dieser Funktion undefiniert, da außerhalb der Grenzen des Arrays gelesen wird. Es kann ein Nullzeiger sein, wenn für ein bestimmtes Gatter keine Qubits oder Parameter vorhanden sind. Sie können und qk_gate_num_qubits``qk_gate_num_params überprüfen, um festzustellen, wie viele Qubits und Parameter für ein bestimmtes Gate erforderlich sind.

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf den DAG, auf den das Gate angewendet werden soll.
• gate – Die „ StandardGate “ zum Bewerben.
• qubits – Der Zeiger auf das Array der uint32_t Qubit-Indizes, auf die das Gate angewendet werden soll. Dies kann ein Nullzeiger sein, wenn es keine Qubits für gate (z. B. QkGate_GlobalPhase) gibt.
• params – Der Zeiger auf das Array der double Werte, die für die Gate-Parameter verwendet werden sollen. Dies kann ein Nullzeiger sein, wenn keine Parameter für gate (z. B. QkGate_H) vorhanden sind.
• front – Wenn true, wird das Gate als erste Operation auf die angegebenen Qubits angewendet und nicht als letzte.

Rückgabe

Der Index des neu hinzugefügten Betriebsknotens.

uint32_t qk_dag_apply_measure(QkDag *dag, uint32_t qubit, uint32_t clbit, bool front)

Wende eine Maßnahme auf ein DAG an.

Beispiel

Messen Sie alle Qubits am Ende des Schaltkreises in den entsprechenden Clbit-Index.

uint32_t num_qubits = qk_dag_num_qubits(dag);
for (uint32_t i = 0; i < num_qubits; i++) {
    qk_dag_apply_measure(dag, i, i, false);
}

Sicherheit

Das Verhalten ist undefiniert, wenn kein ausgerichteter, QkDagnicht-null dag Zeiger auf ein gültiges ist oder wenn qubit oder außerhalb des clbit Bereichs liegen.

Parameter

• dag – Der zu beantragende Schaltkreis.
• qubit – Der zu messende Qubit-Index.
• clbit – Der clbit-Index, in dem das Ergebnis gespeichert werden soll.
• front – Ob die Maßnahme zu Beginn des Kreislaufs angewendet werden soll. Normalerweise false.

Rückgabe

Der Knotenindex der erstellten Anweisung.

uint32_t qk_dag_apply_reset(QkDag *dag, uint32_t qubit, bool front)

Setzen Sie die DAG zurück.

Beispiele

Führen Sie einen Initial-Reset für alle Qubits durch.

uint32_t num_qubits = qk_dag_num_qubits(dag);
for (uint32_t qubit = 0; qubit < num_qubits; qubit++) {
    qk_dag_apply_reset(dag, qubit, true);
}

Sicherheit

Das Verhalten ist undefiniert, wenn kein ausgerichteter, nicht dag null-Zeiger auf ein gültiges ist oder wenn außerhalb QkDag des qubit Bereichs liegt.

Parameter

• dag – Der zu beantragende Schaltkreis.
• qubit – Der zurückzusetzende Qubit-Index.
• front – Ob das Zurücksetzen zu Beginn des Schaltkreises angewendet werden soll. Normalerweise false.

Rückgabe

Der Knotenindex der erstellten Anweisung.

uint32_t qk_dag_apply_barrier(QkDag *dag, const uint32_t *qubits, uint32_t num_qubits, bool front)

Tragen Sie eine Barriere auf das DAG auf.

Beispiele

Wende eine letzte Barriere auf alle Qubits an:

qk_dag_apply_barrier(dag, NULL, qk_dag_num_qubits(dag), false);

Wende am Anfang eines Kreislaufs eine Barriere auf bestimmte Qubit-Indizes an:

uint32_t qubits[] = {0, 2, 4, 5};
uint32_t num_qubits = sizeof(qubits) / sizeof(qubits[0]);
qk_dag_apply_barrier(dag, qubits, num_qubits, true);

Sicherheit

Das Verhalten ist undefiniert, wenn:

• dag ist kein ausgerichteter, nicht-null Zeiger auf einen gültigen QkDag,
• qubits ist nicht ausgerichtet oder ungültig für num_qubits Lesevorgänge von initialisierten, innerhalb der Grenzen liegenden und nicht duplizierten Indizes, es sei denn, qubits ist null.

Parameter

• dag – Der zu beantragende Schaltkreis.
• qubits – Die Qubit-Indizes, auf die die Barriere angewendet werden soll. Dies kann null sein, in diesem Fall num_qubits wird nicht gelesen und die Barriere wird auf alle Qubits im DAG angewendet.
• num_qubits – Wie viele Qubits die Barriere betrifft.
• Vorderseite – Ob die Barriere zu Beginn der Rennstrecke angebracht werden soll. Normalerweise false.

Rückgabe

Der Knotenindex der erstellten Anweisung.

uint32_t qk_dag_apply_unitary(QkDag *dag, const QkComplex64 *matrix, const uint32_t *qubits, uint32_t num_qubits, bool front)

Wende ein einheitliches Gate auf einen DAG an.

Die Werte in matrix sollten eine zeilenorientierte Einheitsmatrix mit der richtigen Größe für die Anzahl der Qubits bilden. Die Daten werden aus dem Zeiger kopiert und müssen nur für Lesevorgänge gültig sein, bis diese Funktion zurückkehrt.

Siehe: Schaltkreis-Konventionen für Details zur Bit-Kennzeichnung und Matrix-Konventionen von Qiskit.

Sicherheit

Das Verhalten ist undefiniert, wenn eine der folgenden Bedingungen zutrifft:

• dag ist kein ausgerichteter, nicht-null Zeiger auf einen gültigen QkDag,
• matrix ist kein ausgerichteter Zeiger auf 4**num_qubits initialisierte Werte,
• qubits ist kein ausgerichteter Zeiger auf num_qubits initialisierte Werte.

Parameter

• dag – Der zu beantragende Schaltkreis.
• matrix – Eine initialisierte, zeilenorientierte Einheitsmatrix mit einer Gesamtgröße von 4**num_qubits.
• Qubits – Ein Array eindeutiger uint32_t Indizes der Qubits.
• num_qubits – Die Anzahl der Qubits, auf die das Gate angewendet wird.
• front – Ob das Gate am Anfang des Schaltkreises angewendet werden soll. Normalerweise false.

Rückgabe

Der Knotenindex der erstellten Anweisung.

QkGate qk_dag_op_node_gate_op(const QkDag *dag, uint32_t node, double *out_params)

Rufen Sie das Standard-Gate des angegebenen Knotens ab.

Panik, wenn der Knoten kein Standard-Gatterbetrieb ist.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(1, "my_register");
qk_dag_add_quantum_register(dag, qr);

uint32_t qubit[1] = {0};
uint32_t h_gate_idx = qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);

QkGate gate = qk_dag_op_node_gate_op(dag, h_gate_idx, NULL);

qk_dag_free(dag);
qk_quantum_register_free(qr);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag. Wenn out_params nicht NULL ist, muss es auf einen Puffer verweisen, der groß genug ist, um alle Parameter des Gates aufzunehmen, andernfalls ist das Verhalten undefiniert, da diese Funktion über ihre Grenzen hinaus schreibt. Sie können überprüfen qk_dag_op_node_num_params , wie viele Parameter für einen bestimmten Operationsknoten erforderlich sind.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Betriebsknoten, von dem das Standardgatter abgerufen werden soll.
• out_params – Ein Puffer, der mit den Parametern des Gates gefüllt werden soll, oder NULL, wenn diese nicht gewünscht sind.

Rückgabe

Der Torwert.

void qk_dag_op_node_unitary(const QkDag *dag, uint32_t node, QkComplex64 *out)

Kopieren Sie die Einheitsmatrix des entsprechenden Knotenindex.

Verursacht Panik, wenn der Knoten kein einheitliches Tor ist.

Sicherheit

Das Verhalten ist undefiniert, wenn kein QkDagNull-Zeiger dag auf ein gültiges ist, wenn nicht ausgerichtet out ist oder wenn für 4**num_qubits Schreibvorgänge out von QkComplex64ungültig ist.

Parameter

• dag – Der Schaltkreis, aus dem gelesen werden soll.
• Knoten – Der Knotenindex der unitären Matrixanweisung.
• out – Zugewiesener und ausgerichteter Speicher für 4**num_qubits komplexe Werte in Zeilen-Major-Reihenfolge, wobei die Anzahl num_qubits der Qubits ist, auf die das Gate angewendet wird.

QkOperationKind qk_dag_op_node_kind(const QkDag *dag, uint32_t node)

Rufen Sie die „Art“ eines Betriebsknotens ab.

Das Ergebnis kann in einer switch-Anweisung verwendet werden, um bei der Iteration über Operationsknoten die richtige Verarbeitung zu veranlassen.

Panik, wenn kein node Operationsknoten ist.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Betriebsknoten, dessen „Art“ ermittelt werden soll.

Rückgabe

Die „Art“ des Knotens.

QkDagNeighbors qk_dag_successors(const QkDag *dag, uint32_t node)

Ruft die Nachfolger des angegebenen Knotens ab.

Das Nachfolger-Array und seine Länge werden als Struktur QkDagNeighbors zurückgegeben, wobei jedes Element im Array einem DAG-Knotenindex entspricht. Sie müssen die qk_dag_neighbors_clear Funktion aufrufen, wenn Sie fertig sind, um den für die Struktur zugewiesenen Speicher freizugeben.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(2, "qr");
qk_dag_add_quantum_register(dag, qr);
qk_quantum_register_free(qr);

uint32_t node_cx = qk_dag_apply_gate(dag, QkGate_CX, (uint32_t[]){0, 1}, NULL, false);

QkDagNeighbors successors = qk_dag_successors(dag, node_cx);

qk_dag_neighbors_clear(&successors);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Knoten, dessen Nachfolger abgerufen werden sollen.

Rückgabe

Eine Instanz der QkDagNeighbors Struktur mit den Nachfolgeinformationen.

QkDagNeighbors qk_dag_predecessors(const QkDag *dag, uint32_t node)

Ruft die Vorgänger des angegebenen Knotens ab.

Das Array der Vorgänger und seine Länge werden als Struktur QkDagNeighbors zurückgegeben, wobei jedes Element im Array einem DAG-Knotenindex entspricht. Sie müssen die qk_dag_neighbors_clear Funktion aufrufen, wenn Sie fertig sind, um den für die Struktur zugewiesenen Speicher freizugeben.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(2, "qr");
qk_dag_add_quantum_register(dag, qr);
qk_quantum_register_free(qr);

uint32_t node_cx = qk_dag_apply_gate(dag, QkGate_CX, (uint32_t[]){0, 1}, NULL, false);

QkDagNeighbors predecessors = qk_dag_predecessors(dag, node_cx);

qk_dag_neighbors_clear(&predecessors);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Knoten, dessen Vorgänger abgerufen werden sollen.

Rückgabe

Eine Instanz der QkDagNeighbors Struktur mit den Vorgängerinformationen.

void qk_dag_neighbors_clear(QkDagNeighbors *neighbors)

Löschen Sie die Felder der QkDagNeighbors Eingabestruktur.

Die Funktion gibt den Speicher frei, auf den das neighbors Feld zeigt, und setzt ihn auf NULL. Außerdem wird das num_neighbors Feld auf 0 gesetzt.

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, nicht-null neighbors Zeiger auf ein QkDagNeighbors Objekt ist, das entweder qk_dag_successors mit oder gefüllt qk_dag_predecessors ist.

Parameter

• Nachbarn – Ein Zeiger auf ein QkDagNeighbors Objekt.

void qk_dag_get_instruction(const QkDag *dag, uint32_t index, QkCircuitInstruction *instruction)

Geben Sie die Details für eine Anweisung im Schaltkreis zurück.

Dies ist ein Spiegel von qk_circuit_get_instruction. Sie können auch einzelne Methoden wie verwenden qk_dag_op_node_gate_op , um einzelne Eigenschaften abzurufen.

Sie müssen anrufen, qk_circuit_instruction_clear um das Gerät QkCircuitInstruction zurückzusetzen, bevor Sie es wiederverwenden oder entsorgen können.

Beispiele

Durchlaufen Sie einen DAG, um herauszufinden, welche Qubits Messungen aufweisen:

bool *measured = calloc(qk_dag_num_qubits(dag), sizeof(*measured));
uint32_t num_ops = qk_dag_num_op_nodes(dag);
uint32_t *ops = malloc(num_ops * sizeof(*ops));
qk_dag_topological_op_nodes(dag, ops);

// Storage space for the instruction.
QkCircuitInstruction inst;
for (uint32_t i = 0; i < num_ops; i++) {
    qk_dag_get_instruction(dag, ops[i], &inst);
    if (!strcmp(inst.name, "measure"))
        measured[inst.qubits[0]] = true;
    qk_circuit_instruction_clear(&inst);
}

free(ops);
free(measured);

Sicherheit

Das Verhalten ist undefiniert, wenn entweder dag oder keine gültigen, ausgerichteten, instruction nicht-null-Zeiger auf den entsprechenden Datentyp sind. Die Felder instruction müssen nicht initialisiert werden.

Parameter

• dag – Der Schaltkreis, aus dem die Anweisung abgerufen wird.
• index – Der Knotenindex. Es ist ein Fehler, einen Index zu übergeben, der kein gültiger Op-Knoten ist.
• Anweisung – Ein Punkt, an dem das QkCircuitInstruction. geschrieben werden soll.

QkExitCode qk_dag_compose(QkDag *dag, const QkDag *other, const uint32_t *qubits, const uint32_t *clbits)

Erstellen Sie das other DAG auf der dag Instanz mit der Option, dass eine Teilmenge der Eingangsleitungen von auf eine Teilmenge der other Ausgangsleitungen von abgebildet dag wird.

other kann eine geringere oder gleiche Anzahl von Drähten für jeden Typ enthalten.

Beispiel

// Build the following dag
// rqr_0: ──■───────
//          │  ┌───┐
// rqr_1: ──┼──┤ Y ├
//        ┌─┴─┐└───┘
// rqr_2: ┤ X ├─────
//        └───┘
QkDag *dag_right = qk_dag_new();
QkQuantumRegister *rqr = qk_quantum_register_new(3, "rqr");
qk_dag_add_quantum_register(dag_right, rqr);
qk_dag_add_classical_register(dag_right, rcr);
qk_dag_apply_gate(dag_right, QkGate_CX, (uint32_t[]){0, 2}, NULL, false);
qk_dag_apply_gate(dag_right, QkGate_Y, (uint32_t[]){1}, NULL, false);

// Build the following dag
//          ┌───┐
// lqr_0: ──┤ H ├───
//        ┌─┴───┴──┐
// lqr_1: ┤ P(0.1) ├
//        └────────┘
QkDag *dag_left = qk_dag_new();
QkQuantumRegister *lqr = qk_quantum_register_new(2, "lqr");
qk_dag_add_quantum_register(dag_left, lqr);
qk_dag_add_classical_register(dag_left, lcr);
qk_dag_apply_gate(dag_left, QkGate_H, (uint32_t[]){0}, NULL, false);
qk_dag_apply_gate(dag_left, QkGate_Phase, (uint32_t[]){1}, (double[]){0.1}, false);

// Compose left circuit onto right circuit
// Should result in circuit
//             ┌───┐
// rqr_0: ──■──┤ H ├──────────
//          │  ├───┤┌────────┐
// rqr_1: ──┼──┤ Y ├┤ P(0.1) ├
//        ┌─┴─┐└───┘└────────┘
// rqr_2: ┤ X ├───────────────
//        └───┘
qk_dag_compose(dag_right, dag_left, NULL, NULL);

// Clean up after you're done
qk_dag_free(dag_left);
qk_dag_free(dag_right);
qk_quantum_register_free(lqr);
qk_quantum_register_free(rqr);

Sicherheit

Das Verhalten ist undefiniert, wenn dag oder keine gültigen, von Null verschiedenen other Zeiger auf ein sind QkDag. Wenn qubit nor NULL clbit sind, muss es einen Wert enthalten, der kleiner oder gleich dem Wert ist, den der Schaltkreis besitzt.

Parameter

• dag – Ein Zeiger auf die zu erstellende DAG.
• anderes – Ein Zeiger auf die DAG, mit der komponiert dag werden soll.
• Qubits – Eine Liste von Indizes, die die Qubit-Leitungen darstellen, aus denen zusammengesetzt werden soll.
• clbits – Eine Liste von Indizes, die die clbit-Leitungen darstellen, die zusammengesetzt werden sollen.

Rückgabe

QkExitCode_Success bei erfolgreicher Zerlegung, andernfalls ein DAG-spezifischer Fehlercode, der die Ursache des Fehlers angibt.

void qk_dag_free(QkDag *dag)

Befreie die DAG.

Beispiel

QkDag *dag = qk_dag_new();
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn weder null noch ein dag gültiger Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die freizugebende DAG.

QkCircuit *qk_dag_to_circuit(const QkDag *dag)

Konvertieren Sie einen gegebenen DAG in einen Schaltkreis.

Der neue Schaltkreis wird aus dem DAG kopiert; die ursprüngliche dag Referenz befindet sich weiterhin im Besitz des Aufrufers und muss weiterhin mit freigegeben qk_dag_free werden. Sie müssen den zurückgegebenen Schaltkreis mit qk_circuit_free freigeben, wenn Sie damit fertig sind.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(2, "qr");
qk_dag_add_quantum_register(dag, qr);
qk_quantum_register_free(qr);

QkCircuit *qc = qk_dag_to_circuit(dag);

qk_circuit_free(qc);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf den DAG, aus dem der Schaltkreis erstellt werden soll.

Rückgabe

Ein Hinweis auf den neuen Schaltkreis.

void qk_dag_topological_op_nodes(const QkDag *dag, uint32_t *out_order)

Geben Sie die Operationenknoten im DAG in topologischer Reihenfolge zurück.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(1, "my_register");
qk_dag_add_quantum_register(dag, qr);

uint32_t qubit[1] = {0};
qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);
qk_dag_apply_gate(dag, QkGate_S, qubit, NULL, false);

// get the number of operation nodes
uint32_t num_ops = qk_dag_num_op_nodes(dag); // 2
uint32_t *out_order = malloc(sizeof(uint32_t) * num_ops);

// get operation nodes listed in topological order
qk_dag_topological_op_nodes(dag, out_order);

// do something with the ordered nodes
for (uint32_t i = 0; i < num_ops; i++) {
    QkGate gate = qk_dag_op_node_gate_op(dag, out_order[i], NULL);
    printf("The gate at location %u is %u.\n", i, gate);
}

// free the out_order array, register, and dag pointer when done
free(out_order);
qk_quantum_register_free(qr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger, dag nicht-null Zeiger auf ein ist QkDag oder wenn kein gültiger, nicht-null Zeiger auf eine Folge out_order von qk_dag_num_op_nodes(dag) aufeinanderfolgenden Elementen von ist uint32_t.

Parameter

• dag – Ein Zeiger auf die DAG.
• out_order – Ein Zeiger auf ein Array von qk_dag_num_op_nodes(dag) Elementen vom Typ uint32_t, in das diese Funktion die Ausgabe schreibt.

void qk_dag_substitute_node_with_dag(QkDag *dag, uint32_t node, const QkDag *replacement)

Ersetze einen Knoten in einem QkDag durch einen durch einen anderen angegebenen Teilkreis QkDag

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(1, "my_register");
qk_dag_add_quantum_register(dag, qr);

uint32_t qubit[1] = {0};
uint32_t node_to_replace = qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);
qk_dag_apply_gate(dag, QkGate_S, qubit, NULL, false);

// Build replacement dag for H
QkDag *replacement = qk_dag_new();
QkQuantumRegister *replacement_qr = qk_quantum_register_new(1, "other");
qk_dag_add_quantum_register(replacement, replacement_qr);
double pi_param[1] = {3.14159};
qk_dag_apply_gate(replacement, QkGate_RZ, qubit, pi_param, false);
qk_dag_apply_gate(replacement, QkGate_SX, qubit, NULL, false);
qk_dag_apply_gate(replacement, QkGate_RZ, qubit, pi_param, false);

qk_dag_substitute_node_with_dag(dag, node_to_replace, replacement);

// Free the replacement dag, register, dag, and register
qk_quantum_register_free(replacement_qr);
qk_dag_free(replacement);
qk_quantum_register_free(qr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn dag und kein gültiger, nicht replacement null-Zeiger auf ein sind QkDag.

Parameter

• dag – Ein Zeiger auf die DAG.
• Knoten – Der Knotenindex der Operation, die durch die andere ersetzt werden QkDag soll. Dies muss der Knotenindex für einen Operationsknoten in sein dag , und die Anzahl der qargs und cargs muss mit der Anzahl der Qubits und Clbits in replacementübereinstimmen.
• Ersatz – Das andere, durch das node ersetzt QkDag werden soll. Dieser Dag muss dieselbe Anzahl an Qubits haben wie die Operation für node. Die Reihenfolge der Knotenbits wird in der Reihenfolge verarbeitet, sodass qargs[0] für in node``qubits[0] zugeordnet replacement wird, qargs[1] qubits[0]zu usw. Das gleiche Muster gilt auch für klassische Bits.

QkDag *qk_dag_copy_empty_like(const QkDag *dag, QkVarsMode vars_mode, QkBlocksMode blocks_mode)

Gibt eine Kopie von sich selbst mit derselben Struktur zurück, die jedoch leer ist.

Diese Struktur umfasst:

• Name und andere Metadaten
• globale Phase
• Dauer
• alle Qubits und Clbits, einschließlich der Register.

Beispiel

QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(1, "my_register");
qk_dag_add_quantum_register(dag, qr);

uint32_t qubit[1] = {0};
qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);

// As the DAG does not contain any control-flow instructions,
// vars_mode and blocks_mode do not have any effect.
QkDag *copied_dag = qk_dag_copy_empty_like(dag, QkVarsMode_Alike, QkBlocksMode_Drop);
uint32_t num_ops_in_copied_dag = qk_dag_num_op_nodes(copied_dag); // 0

// do something with copied_dag

qk_quantum_register_free(qr);
qk_dag_free(dag);
qk_dag_free(copied_dag);

Sicherheit

Das Verhalten ist undefiniert, wenn kein gültiger dag Zeiger auf ein ist QkDag.

Parameter

• dag – Ein Zeiger auf die zu kopierende DAG.
• vars_mode – Der Modus für die Behandlung klassischer Variablen.
• blocks_mode – Der Modus für die Behandlung von Blöcken.

Rückgabe

Der Zeiger auf die kopierte DAG-Schaltung.

uint32_t qk_dag_replace_block_with_unitary(QkDag *dag, uint32_t num_block_ids, const uint32_t *block_ids, const QkComplex64 *matrix, uint32_t num_qubits, const uint32_t *qubits, bool cycle_check)

Ersetze einen nicht leeren zusammenhängenden Block von Knoten in einem QkDag durch ein einzelnes Unitar-Gatter, das der angegebenen Unitar-Matrix entspricht.

Beim Austausch werden die Knoten im Block entfernt und durch einen neuen Knoten ersetzt, der auf die angegebenen Qubits wirkt.

Beispiel

// Create a DAG with H, T, S, T, H gates on the second qubit
QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(2, "qr");
qk_dag_add_quantum_register(dag, qr);
uint32_t qubit[1] = {1};
qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);
uint32_t idx1 = qk_dag_apply_gate(dag, QkGate_T, qubit, NULL, false);
uint32_t idx2 = qk_dag_apply_gate(dag, QkGate_S, qubit, NULL, false);
uint32_t idx3 = qk_dag_apply_gate(dag, QkGate_T, qubit, NULL, false);
qk_dag_apply_gate(dag, QkGate_H, qubit, NULL, false);

// Replace the inner T, S, T gates by a unitary gate (representing Z)
uint32_t replaced_ids[3] = {idx1, idx2, idx3};
static const QkComplex64 mat_z[4] = {{1, 0}, {0, 0}, {0, 0}, {-1, 0}};
uint32_t new_node_idx =
    qk_dag_replace_block_with_unitary(dag, 3, replaced_ids, mat_z, 1, qubit, false);

// free the register and dag pointer when done
qk_quantum_register_free(qr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn eine der folgenden Bedingungen zutrifft:

• dag ist kein ausgerichteter, nicht-null Zeiger auf einen gültigen QkDag,
• qubits ist kein ausgerichteter Zeiger auf num_qubits initialisierte Werte.
• matrix ist kein ausgerichteter Zeiger auf 4**num_qubits initialisierte Werte,
• block_ids ist kein ausgerichteter Zeiger auf num_block_ids initialisierte Werte.

Parameter

• dag – Zeiger auf den DAG.
• num_block_ids – Anzahl der Einträge in block_ids. Diese Zahl darf nicht Null sein.
• block_ids – Zeiger auf ein nicht leeres Array von Knoten, die ersetzt werden sollen.
• matrix – Zeiger auf eine initialisierte, zeilenorientierte unitäre Matrix der Größe 4**num_qubits.
• num_qubits – Die Anzahl der Qubits, auf die das resultierende unitäre Gatter wirkt.
• Qubits – Zeiger auf ein Array mit eindeutigen uint32_t Qubit-Indizes. Jeder Eintrag gibt den Index des DAG-Qubits an, der der jeweiligen Argumentposition im unitären Gatter entspricht.
• cycle_check – Wenn true, prüft die Funktion, ob das Ersetzen des übergebenen block_ids durch einen einzelnen Knoten einen Zyklus im DAG verursachen würde (was den DAG ungültig machen würde). Wenn ein Zyklus entstehen würde, bleibt der DAG unverändert und UINT32_MAX wird zurückgegeben. Diese Überprüfung ist mit einem Leistungsabfall verbunden. Wenn Sie garantieren können, dass der bereitgestellte Block block_ids zusammenhängend ist und bei der Reduzierung auf einen einzelnen Knoten keinen Zyklus erzeugt, kann dieser Wert auf falsegesetzt werden.

Rückgabe

Der Index des neu hinzugefügten Operationsknotens oder UINT32_MAX falls cycle_check ist true und die Ersetzung einen Zyklus zur Folge hätte.

void qk_dag_substitute_node_with_unitary(QkDag *dag, uint32_t node, const QkComplex64 *matrix, uint32_t num_qubits)

Ersetze eine Operation in einem Knoten in einem QkDag durch ein unitäres Gatter, das der angegebenen unitären Matrix entspricht.

Die neue Operation sollte der Form der ersetzten Operation entsprechen. Die QARGs und CARGs für den Knoten bleiben unverändert.

Beispiel

// Create a DAG with a Z-gate
QkDag *dag = qk_dag_new();
QkQuantumRegister *qr = qk_quantum_register_new(2, "qr");
qk_dag_add_quantum_register(dag, qr);
uint32_t idx_z = qk_dag_apply_gate(dag, QkGate_Z, (uint32_t[]){1}, NULL, false);

static const QkComplex64 mat[4] = {{1, 0}, {0, 0}, {0, 0}, {-1, 0}};

// Replace the Z-gate by a unitary matrix
qk_dag_substitute_node_with_unitary(dag, idx_z, mat, 1);

// free the register and dag pointer when done
qk_quantum_register_free(qr);
qk_dag_free(dag);

Sicherheit

Das Verhalten ist undefiniert, wenn eine der folgenden Bedingungen zutrifft:

• dag ist kein ausgerichteter, nicht-null Zeiger auf einen gültigen QkDag,
• matrix ist kein ausgerichteter Zeiger auf 4**num_qubits initialisierte Werte,

Parameter

• dag – Zeiger auf den DAG.
• Knoten – Der Knoten, dessen Operation ersetzt wird. Die Anzahl der Qubits in der ersetzten Operation sollte gleich sein, num_qubits und die Anzahl der Clbits sollte betragen 0.
• matrix – Zeiger auf eine initialisierte, zeilenorientierte unitäre Matrix der Größe 4**num_qubits.
• num_qubits – Die Anzahl der Qubits, auf die die Unitaroperation wirkt.

PyObject *qk_dag_to_python(QkDag *dag)

Übergeben Sie die Eigentumsrechte an einem QkDag Objekt an „ Python “.

Nach dem Aufruf dieser Funktion ist die Verwendung des QkDag Zeigers nicht mehr sicher. Insbesondere sollten Sie nicht versuchen, den Speicher zu löschen oder freizugeben. Der Aufrufer muss Eigentümer des Objekts QkDag sein und darf keine geliehene Referenz darauf halten (beispielsweise ist ein qk_dag_borrow_from_python aus QkDag * abgerufenes Objekt kein Eigentum des Aufrufers).

Sicherheit

Der Anrufer muss mit einem Dolmetscher von Python verbunden sein. Das Verhalten ist nicht definiert, wenn kein gültiger, nicht-null-Zeiger auf ein dag initialisiertes und im Besitz befindliches ist QkDag.

Parameter

• dag – Das Objekt, das sich im Besitz befindet.

Rückgabe

Ein verweis auf das Objekt, der von „ Python “ verwaltet wird.

QkDag *qk_dag_borrow_from_python(PyObject *ob)

Rufe einen QkDag Zeiger von einem Python-Objekt ab.

Hierbei wird ein Zeiger auf Python übernommen und der QkDag Zeiger darauf extrahiert, sofern er vom richtigen Typ ist. Der zurückgegebene Zeiger wird vom ob Zeiger ausgeliehen. Wenn der Typ PyObject nicht korrekt ist, ist der NULL Rückgabewert und der Ausnahmezustand des Interpreter „ Python “ wird gesetzt.

Um diese Funktion aufzurufen, muss eine Verbindung zu einem „ Python “-Interpreter bestehen.

Sie können auch verwenden qk_dag_convert_from_python, was logisch gesehen genau dasselbe wie diese Funktion ist, aber direkt als „Konverter“-Funktion für die PyArg_Parse* Familie der Konverterfunktionen von Python genutzt werden kann.

Sicherheit

Der Anrufer muss mit einem Dolmetscher von Python verbunden sein. Das Verhalten ist nicht definiert, wenn kein gültiger, nicht-null-Zeiger auf ein ob Python-Objekt ist.

Parameter

• ob – Ein Objekt vom Typ „ Python “, das ausgeliehen wurde.

Rückgabe

Ein Zeiger auf das native Objekt oder NULL falls das Objekt „ Python “ vom falschen Typ ist.

int qk_dag_convert_from_python(PyObject *object, void *address)

Ruft einen DAG-Zeiger aus einem „ Python “-Objekt ab.

Hierbei wird eine Referenz vom Typ Python übernommen und der QkDag Zeiger darauf in `` addressextrahiert, sofern er vom richtigen Typ ist. Der zurückgegebene Zeiger wird vom object Zeiger ausgeliehen. Wenn nicht vom PyObject richtigen Typ ist, ist der Rückgabewert 1, der Ausnahmezustand des Interpreter „ Python “ wird gesetzt und address bleibt unverändert.

Um diese Funktion aufzurufen, muss eine Verbindung zu einem „ Python “-Interpreter bestehen.

Sie können auch verwenden qk_dag_borrow_from_python, was logisch gesehen genau dasselbe ist wie dies, jedoch eine natürlichere Signatur für die direkte Verwendung bietet.

Sicherheit

Der Anrufer muss mit einem Dolmetscher von Python verbunden sein. Das Verhalten ist nicht definiert, wenn kein gültiger, nicht-null-Zeiger auf ein object Python-Objekt ist oder wenn kein Zeiger auf beschreibbare address Daten des richtigen Typs ist.

Parameter

• Objekt – Ein ausgeliehenes „ Python “-Objekt.
• Adresse – Der Speicherort, an den die Ausgabe geschrieben werden soll.

Rückgabe

1 bei Erfolg, 0 bei Misserfolg.