QkDag

QkDag *qk_dag_new(void)

새로운 빈 DAG를 생성하십시오.

사용이 완료된 반환된 qk_dag_free DAG는 반드시 로 해제해야 합니다.

예

QkDag *empty = qk_dag_new();

리턴

생성된 DAG에 대한 포인터.

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

DAG에 양자 레지스터를 추가합니다.

예

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

안전

가 유효한 null이 아닌 포인터가 QkDag 아니거나, reg``dag 가 유효한 null이 아닌 포인터가 아닌 QkQuantumRegister 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• reg – 양자 레지스터에 대한 포인터.

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

DAG에 클래식 레지스터를 추가하십시오.

예

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

안전

가 유효한 null이 아닌 포인터가 QkDag 아니거나, reg``dag 가 유효한 null이 아닌 포인터가 아닌 QkClassicalRegister 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• reg – 클래식 레지스터에 대한 포인터.

uint32_t qk_dag_num_qubits(const QkDag *dag)

DAG가 포함하는 큐비트 수를 가져옵니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.

리턴

DAG가 정의되는 큐비트 수.

uint32_t qk_dag_num_clbits(const QkDag *dag)

DAG가 포함하는 클비트(clbit)의 개수를 가져옵니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.

리턴

DAG가 정의된 클비트(clbit)의 수.

size_t qk_dag_num_op_nodes(const QkDag *dag)

DAG 내 작업 노드의 총 개수를 반환합니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.

리턴

DAG 내 명령어의 총 개수.

QkParam *qk_dag_global_phase(const QkDag *dag)

DAG의 전역 위상을 가져옵니다.

이 함수는 DAG의 전역 위상(global phase)의 복사본을 반환하며, 사용 후에는 :c:func:qk_param_free 를 통해 해당 값을 해제해야 합니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.

리턴

DAG의 전역 단계.

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

DAG의 전역 위상을 설정합니다.

이 함수는 새로운 전역 페이즈를 설정할 때 이를 복사하므로, 호출자가 해당 QkParam 페이즈에 대한 소유권을 유지하게 되며, 설정 후에는 :c:func:qk_param_free 를 통해 페이즈의 값을 해제해야 합니다.

예

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

안전

QkParam가 QkDag 를 가리키는 유효하고 null이 아닌 포인터가 아니거나, phase``dag 가 를 가리키는 유효하고 null이 아닌 포인터가 아닌 경우, 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• phase – 설정할 전역 페이즈에 대한 포인터.

리턴

QkExitCode_Success 전역 위상이 성공적으로 설정된 후. 오류 발생 시, QkExitCode_ParameterError 매개변수 심볼을 추적하는 과정에서 발생하는 일반적인 오류(예: 유효하지 않은 매개변수 값 등)에 대해 설명합니다. 그렇지 않은 경우, QkExitCode_DagError 이는 DAG에 특정한 오류 원인을 나타냅니다.

QkDagNodeType qk_dag_node_type(const QkDag *dag, uint32_t node)

지정된 노드의 유형을 가져옵니다.

결과는 스위치 문에서 사용되어 알 수 없는 유형의 노드를 반복 처리할 때 적절한 처리를 분배할 수 있습니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 유형을 조회할 대상 노드.

리턴

노드의 유형입니다.

uint32_t qk_dag_qubit_in_node(const QkDag *dag, uint32_t qubit)

주어진 큐비트에 대응하는 와이어의 입력 노드 인덱스를 반환합니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• qubit – 입력 노드 인덱스를 가져올 큐비트.

리턴

큐비트 와이어의 입력 노드.

uint32_t qk_dag_qubit_out_node(const QkDag *dag, uint32_t qubit)

주어진 큐비트에 대응하는 와이어의 출력 노드의 인덱스를 반환합니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 큐비트 – 출력 노드 인덱스를 가져올 큐비트.

리턴

큐비트 와이어의 출력 노드.

uint32_t qk_dag_clbit_in_node(const QkDag *dag, uint32_t clbit)

주어진 클비트에 대응하는 와이어의 입력 노드 인덱스를 반환합니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• clbit – 입력 노드 인덱스를 가져올 clbit.

리턴

클비트 와이어의 입력 노드.

uint32_t qk_dag_clbit_out_node(const QkDag *dag, uint32_t clbit)

주어진 clbit에 대응하는 와이어의 출력 노드 인덱스를 반환합니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• clbit – 출력 노드 인덱스를 가져올 clbit.

리턴

클비트 와이어의 출력 노드.

uint32_t qk_dag_wire_node_value(const QkDag *dag, uint32_t node)

와이어 엔드포인트 노드의 값을 가져옵니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 와이어 값을 가져올 종단점 노드.

리턴

엔드포인트 노드 내의 값(예: 큐비트, 클비트 또는 변수).

uint32_t qk_dag_op_node_num_qubits(const QkDag *dag, uint32_t node)

지정된 연산 노드의 큐비트 수를 가져옵니다.

해당 노드가 연산이 아닐 경우 패닉 상태가 됩니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 큐비트 수를 얻기 위한 연산 노드.

리턴

연산의 큐비트 수.

uint32_t qk_dag_op_node_num_clbits(const QkDag *dag, uint32_t node)

지정된 작업 노드의 클비트(clbit) 수를 가져옵니다.

해당 노드가 연산이 아닐 경우 패닉 상태가 됩니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 클비트 수를 얻기 위한 연산 노드.

리턴

해당 연산의 클비트 수.

uint32_t qk_dag_op_node_num_params(const QkDag *dag, uint32_t node)

지정된 작업 노드의 매개변수 개수를 가져옵니다.

해당 노드가 연산이 아닐 경우 패닉 상태가 됩니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 매개변수 개수를 가져올 작업 노드.

리턴

작업의 매개변수 개수.

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

지정된 연산 노드의 큐비트를 가져옵니다.

해당 노드가 연산이 아닐 경우 패닉 상태가 됩니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 큐비트를 가져올 연산 노드.

리턴

큐비트에 대한 포인터. 요소의 개수를 결정하기 위해 qk_dag_op_node_num_qubits 사용하십시오.

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

지정된 작업 노드의 클비트를 가져옵니다.

해당 노드가 연산이 아닐 경우 패닉 상태가 됩니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – clbits를 가져올 작업 노드.

리턴

clbits에 대한 포인터. 요소의 개수를 결정하기 위해 qk_dag_op_node_num_clbits 사용하십시오.

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

DAG에 QkGate 적용합니다.

예

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

안전

와 params qubits 타입은 각각 표준 게이트의 기대값과 double 일치하는 길이를 가진 및 uint32_t 배열의 포인터여야 합니다. 배열의 길이가 충분하지 않을 경우, 이 함수는 배열 경계를 벗어난 영역을 읽게 되므로 동작이 정의되지 않습니다. 주어진 게이트에 대한 큐비트나 파라미터가 없는 경우, null 포인터일 수 있습니다. 특정 게이트에 필요한 큐비트 수와 매개변수 수를 확인하려면 와 qk_gate_num_params 를 qk_gate_num_qubits 참조하십시오.

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – 게이트를 적용할 DAG에 대한 포인터.
• 게이트 – 지원할 StandardGate
• 큐비트 – 게이트를 적용할 큐비트 uint32_t 인덱스 배열에 대한 포인터. 해당 큐비트가 존재하지 gate 않을 경우 (예: QkGate_GlobalPhase) 이 값은 null 포인터가 될 수 있습니다.
• params – 게이트 매개변수에 사용할 값들의 double 배열을 가리키는 포인터. 매개 변수가 없는 gate 경우 (예: QkGate_H) 이 값은 null 포인터일 수 있습니다.
• 프론트 – 지정된 true큐비트에 게이트가 마지막이 아닌 첫 번째 연산으로 적용됩니다.

리턴

새로 추가된 작업 노드의 인덱스.

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

DAG에 측정을 적용합니다.

예

회로 종료 시점에 모든 큐비트를 해당 클비트 인덱스로 측정한다.

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

안전

가 유효한 에 대한 정렬된, 비어 있지 QkDag 않은 dag 포인터가 아니거나, 또는 qubit 또는 clbit 가 범위를 벗어날 경우 동작이 정의되지 않습니다.

매개변수

• dag – 적용할 회로.
• 큐비트 – 측정할 큐비트 인덱스.
• clbit – 결과를 저장할 clbit 인덱스.
• 전면 – 회로 시작 시 해당 조치를 적용할지 여부. 보통 false.

리턴

생성된 명령어의 노드 인덱스.

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

DAG에 재설정을 적용합니다.

예

모든 큐비트에 초기 리셋을 적용합니다.

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

안전

가 유효한 QkDag에 대한 정렬된, 비공백 포인터가 dag 아니거나 범위를 벗어날 qubit 경우 동작이 정의되지 않습니다.

매개변수

• dag – 적용할 회로.
• 큐비트 – 재설정할 큐비트 인덱스.
• 전면 – 회로 시작 시 리셋을 적용할지 여부. 보통 false.

리턴

생성된 명령어의 노드 인덱스.

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

DAG에 장벽을 적용하십시오.

예

모든 큐비트에 최종 장벽을 적용하십시오:

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

회로 시작 부분에서 지정된 큐비트 인덱스에 장벽을 적용합니다:

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

안전

다음과 같은 경우 동작이 정의되지 않습니다:

• dag 유효한 객체에 대한 QkDag 정렬된, null이 아닌 포인터가 아닙니다
• qubits null이 아닌 qubits 경우, 초기화되었고 범위 내에 있으며 중복되지 않은 인덱스에 대한 읽기 작업에 num_qubits 대해 정렬되지 않았거나 유효하지 않습니다.

매개변수

• dag – 적용할 회로.
• 큐비트 – 장벽을 적용할 큐비트 인덱스. 이 값은 null일 수 있으며, 이 경우 는 num_qubits 읽히지 않고 장벽이 DAG 내 모든 큐비트에 적용됩니다.
• num_qubits – 장벽이 적용되는 큐비트의 수.
• 전면 – 회로 시작 시점에 장벽을 적용할지 여부. 보통 false.

리턴

생성된 명령어의 노드 인덱스.

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

DAG에 단일 게이트를 적용한다.

의 값들은 큐비트 수에 맞는 크기의 matrix 행 우선 단위 행렬을 형성해야 합니다. 데이터는 포인터에서 복사되며, 이 함수가 반환될 때까지 읽기만 가능하면 됩니다.

Qiskit의 비트 라벨링 및 행렬 표기법에 대한 자세한 내용은 : Circuit conventions를 참조하십시오.

안전

다음 중 하나라도 해당될 경우 동작이 정의되지 않습니다:

• dag 유효한 객체에 대한 QkDag 정렬된, null이 아닌 포인터가 아닙니다
• matrix 초기화된 4**num_qubits 값에 대한 정렬된 포인터가 아닙니다
• qubits 초기화된 num_qubits 값을 가리키는 정렬된 포인터가 아닙니다.

매개변수

• dag – 적용할 회로.
• 매트릭스 – 초기화된 행 우선 단위 행렬로, 전체 크기는 4**num_qubits입니다.
• 큐비트 – 큐비트의 고유한 uint32_t 인덱스 배열.
• num_qubits – 게이트가 적용되는 큐비트의 수.
• 전면 – 회로 시작 시점에 게이트를 적용할지 여부. 보통 false.

리턴

생성된 명령어의 노드 인덱스.

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

지정된 노드의 표준 게이트를 가져옵니다.

노드가 표준 게이트 연산이 아닐 경우 패닉 상태가 됩니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다. 가 NULL이 아닌 out_params 경우, 해당 함수가 경계를 벗어난 쓰기를 수행하게 되어 동작이 정의되지 않으므로, 모든 게이트 매개변수를 수용할 수 있을 만큼 충분히 큰 버퍼를 가리켜야 합니다. 어떤 작업 노드에 필요한 매개변수 개수를 확인하려면 qk_dag_op_node_num_params 를 참조하십시오.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 표준 게이트를 가져올 연산 노드.
• out_params – 게이트의 매개변수로 채워질 버퍼 또는 매개변수가 필요하지 않을 경우 NULL.

리턴

게이트 값.

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

해당 노드 인덱스의 단위 행렬을 복사해 내라.

노드가 단일 게이트가 아닐 경우 패닉 상태가 됩니다.

안전

가 유효한 에 대한 dag 비공 QkDag포인터가 아닐 경우, 가 정렬되지 않았을 경우 out , 또는 가 에 대한 4**num_qubits 쓰기에 out 유효하지 않을 경우 QkComplex64 동작은 정의되지 않습니다.

매개변수

• dag – 읽을 회로.
• 노드 – 단위 행렬 명령어의 노드 인덱스.
• out – 행 우선 순서로 배열된 복소수 4**num_qubits 값을 위한 할당 및 정렬된 메모리. 여기서 num_qubits 는 게이트가 적용되는 큐비트 수입니다.

QkOperationKind qk_dag_op_node_kind(const QkDag *dag, uint32_t node)

작업 노드의 "종류"를 가져옵니다.

이 결과는 작업 노드를 반복 처리할 때 적절한 처리를 분배하기 위한 스위치 문에서 사용할 수 있습니다.

작업 노드가 아닐 경우 패닉 node 상태가 됩니다.

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – "종류"를 가져올 작업 노드.

리턴

노드의 "종류".

QkDagNeighbors qk_dag_successors(const QkDag *dag, uint32_t node)

지정된 노드의 후속 노드를 검색합니다.

후속자 배열과 그 길이는 구조체 QkDagNeighbors (struct)로 반환되며, 배열의 각 요소는 DAG 노드 인덱스에 대응합니다. 작업 완료 시 struct에 할당된 메모리를 해제하려면 해당 qk_dag_neighbors_clear 함수를 호출해야 합니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 후속 노드를 가져올 대상 노드.

리턴

후속자 정보를 포함한 구조체의 QkDagNeighbors 인스턴스.

QkDagNeighbors qk_dag_predecessors(const QkDag *dag, uint32_t node)

지정된 노드의 선행 노드를 검색합니다.

선행자 배열과 그 길이는 구조체로 QkDagNeighbors 반환되며, 배열의 각 요소는 DAG 노드 인덱스에 대응합니다. 작업 완료 시 struct에 할당된 메모리를 해제하려면 해당 qk_dag_neighbors_clear 함수를 호출해야 합니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 선행 노드를 가져올 대상 노드.

리턴

선행자 정보를 포함한 구조체의 QkDagNeighbors 인스턴스.

void qk_dag_neighbors_clear(QkDagNeighbors *neighbors)

입력 QkDagNeighbors 구조체의 필드를 초기화하십시오.

해당 함수는 field가 neighbors 가리키는 메모리를 해제하고 NULL로 설정합니다. 또한 해당 num_neighbors 필드를 0으로 설정합니다.

안전

가 유효한 null이 아닌 포인터가 아니거나, neighbors 또는 qk_dag_successors 로 채워진 객체를 QkDagNeighbors 가리키지 않을 qk_dag_predecessors 경우 동작이 정의되지 않습니다.

매개변수

• neighbors – 객체에 QkDagNeighbors 대한 포인터.

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

회로 내 명령어에 대한 세부 정보를 반환합니다.

이것은 의 미러입니다 qk_circuit_get_instruction. 개별 속성을 가져오려면 qk_dag_op_node_gate_op 와 같은 개별 메서드를 사용할 수도 있습니다.

재사용하거나 폐기하기 전에 반드시 를 QkCircuitInstruction 호출하여 를 qk_circuit_instruction_clear 재설정해야 합니다.

예

DAG를 순회하며 어떤 큐비트에 측정값이 적용되었는지 찾는다:

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

안전

또는 instruction``dag 가 유효하지 않거나 정렬되지 않았거나 해당 데이터 유형에 대한 비공백 포인터가 아닌 경우 동작이 정의되지 않습니다. 필드들은 instruction 초기화할 필요가 없습니다.

매개변수

• dag – 명령어를 가져올 회로.
• index – 노드 인덱스. 유효한 연산 노드가 아닌 인덱스를 전달하는 것은 오류입니다.
• 지시사항 – 어디에 작성할지 지시하는 QkCircuitInstruction지점.

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

DAG를 other 인스턴스에 dag 구성할 때, 입력 와이어의 부분 dag집합을 출력 other 와이어의 부분 집합에 매핑하는 옵션을 포함한다.

other 각 유형별로 더 적은 수 또는 동일한 수의 전선을 포함할 수 있습니다.

예

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

안전

또는 가 other 유효하지 않은, dag null이 아닌 포인터가 아닐 경우 동작이 QkDag정의되지 않습니다. nor가 clbit``qubit NULL인 경우, 회로가 보유한 양보다 적거나 같은 양을 포함해야 합니다.

매개변수

• dag – 구성할 DAG에 대한 포인터.
• 기타 – 조합할 DAG에 대한 dag 포인터.
• 큐비트 – 합성할 큐비트 와이어를 나타내는 인덱스 목록.
• clbits – 합성할 clbit 와이어를 나타내는 인덱스 목록.

리턴

QkExitCode_Success 성공적인 분해 시, 그렇지 않으면 실패 원인을 나타내는 DAG 특정 오류 코드.

void qk_dag_free(QkDag *dag)

DAG를 해방하라.

예

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

안전

가 null이거나 유효한 포인터가 아닌 QkDag dag 경우 동작이 정의되지 않습니다.

매개변수

• dag – 해제할 DAG에 대한 포인터.

QkCircuit *qk_dag_to_circuit(const QkDag *dag)

주어진 DAG를 회로로 변환하십시오.

새 회로는 DAG에서 복사됩니다; 원본 dag 참조는 여전히 호출자가 소유하며, 여전히 해제되어야 합니다 qk_dag_free. 사용이 끝난 후에는 qk_circuit_free 반환된 회로를 반드시 해제해야 합니다.

예

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

안전

가 유효한 null이 아닌 포인터가 아닐 QkDag dag 경우 동작은 정의되지 않습니다.

매개변수

• dag – 회로를 생성할 DAG에 대한 포인터.

리턴

새로운 회로에 대한 포인터.

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

DAG에 포함된 작업 노드를 위상 순서대로 반환합니다.

예

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

안전

가 유효한 비공 포인터가 QkDag 아니거나, out_order 가 qk_dag_num_op_nodes(dag) 연속된 개의 요소로 구성된 dag 유효한 비공 포인터가 uint32_t아닌 경우 동작은 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• out_order – 타입의 개 qk_dag_num_op_nodes(dag) 요소로 구성된 uint32_t배열에 대한 포인터로, 이 함수가 출력을 기록할 대상입니다.

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

의 노드를 다른 노드가 QkDag 지정한 하위 회로로 교체한다 QkDag

예

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

안전

와 replacement 가 유효한 null이 아닌 dag 포인터가 아닐 QkDag 경우 동작이 정의되지 않습니다.

매개변수

• dag – DAG에 대한 포인터.
• 노드 – 다른 노드로 대체할 QkDag작업의 노드 인덱스. 이것은 내의 연산 노드에 대한 dag 노드 인덱스여야 하며, qargs와 cargs의 개수는 내의 큐비트와 클비트 replacement수와 일치해야 합니다.
• 대체물 – 대체할 node QkDag 다른 것. 이 다그(dag)는 해당 연산과 동일한 수의 node큐비트를 가져야 합니다. 노드 비트 순서는 순차적으로 처리되므로, qargs[0] 에 대한 node 는 에 매핑되고 qubits[0] , qargs[1]``replacement 는 에 매핑되며 qubits[0], 이와 유사하게 처리됩니다. 클래식 비트에도 동일한 패턴이 적용됩니다.

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

자신의 구조는 동일하지만 비어 있는 복사본을 반환합니다.

해당 구조에는 다음이 포함됩니다:

• 이름 및 기타 메타데이터
• 글로벌 단계
• 지속 기간
• 모든 큐비트와 클래비트, 레지스터를 포함하여.

예

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

안전

가 유효한 포인터가 아닐 dag 경우 QkDag 동작은 정의되지 않습니다.

매개변수

• dag – 복사할 DAG에 대한 포인터.
• vars_mode – 클래식 변수 처리 모드.
• blocks_mode – 블록 처리 모드.

리턴

복사된 DAG 회로에 대한 포인터.

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)

그래프 내의 비어 있지 않은 연속된 노드 QkDag 블록을, 지정된 유니터리 행렬에 해당하는 단일 유니터리 게이트로 대체한다.

교체 시, 블록 내의 노드들은 제거되고 주어진 큐비트에 작용하는 새로운 노드로 대체됩니다.

예

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

안전

다음 중 하나라도 해당될 경우 동작이 정의되지 않습니다:

• dag 유효한 객체에 대한 QkDag 정렬된, null이 아닌 포인터가 아닙니다
• qubits 초기화된 num_qubits 값을 가리키는 정렬된 포인터가 아닙니다.
• matrix 초기화된 4**num_qubits 값에 대한 정렬된 포인터가 아닙니다
• block_ids 초기화된 num_block_ids 값을 가리키는 정렬된 포인터가 아닙니다.

매개변수

• dag – DAG를 가리키는 포인터.
• num_block_ids –. block_ids내 항목 수 이 숫자는 0이 아니어야 합니다.
• block_ids – 교체할 노드들로 구성된 비어 있지 않은 배열을 가리키는 포인터.
• matrix – 크기 인 초기화된 행 우선 단위 4**num_qubits 행렬을 가리키는 포인터.
• num_qubits – 결과적인 유니타리 게이트가 작용하는 큐비트의 수.
• 큐비트 – 서로 다른 uint32_t 큐비트 인덱스로 구성된 배열에 대한 포인터. 각 항목은 유니터리 게이트 내의 해당 인자 위치에 대응하는 DAG 큐비트의 인덱스를 지정합니다.
• cycle_check – 이 함수는 주어진 노드를 block_ids 단일 노드로 대체할 경우 true DAG에 순환이 발생하여 DAG가 무효화되는지 여부를 확인합니다. 사이클이 생성될 경우, DAG는 변경되지 않은 채로 유지되며 결과가 UINT32_MAX 반환됩니다. 이 검사는 실행 시간의 손실을 초래합니다. 제공된 데이터가 block_ids 연속된 블록이며, 단일 노드로 축소될 때 순환 구조를 생성하지 않는다는 것을 보장할 수 있다면, 이 값을 로 설정할 수 false 있습니다.

리턴

새로 추가된 연산 노드의 인덱스, 또는 인 UINT32_MAX cycle_check 경우 true , 그리고 해당 대체로 인해 순환이 발생하게 되는 경우.

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

그래프 내 노드의 연산을, 지정된 QkDag 유니터리 행렬에 대응하는 유니터리 게이트로 대체한다.

새 연산은 대체되는 연산의 형태와 일치해야 합니다. 해당 노드의 qargs와 cargs는 그대로 유지됩니다.

예

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

안전

다음 중 하나라도 해당될 경우 동작이 정의되지 않습니다:

• dag 유효한 객체에 대한 QkDag 정렬된, null이 아닌 포인터가 아닙니다
• matrix 초기화된 4**num_qubits 값에 대한 정렬된 포인터가 아닙니다

매개변수

• dag – DAG를 가리키는 포인터.
• 노드 – 연산이 대체되는 노드. 대체 연산에서 큐비트의 개수는 와 같아야 num_qubits 하며, 클비트의 0개수는 이어야 한다.
• matrix – 크기 인 초기화된 행 우선 단위 4**num_qubits 행렬을 가리키는 포인터.
• num_qubits – 유니터리 연산이 적용되는 큐비트의 수.

PyObject *qk_dag_to_python(QkDag *dag)

객체의 QkDag 소유권을 Python 에 전달합니다.

이 함수를 호출한 후에는 QkDag 포인터를 사용하는 것이 안전하지 않습니다. 특히, 이를 지우거나 해제하려고 시도해서는 안 됩니다. 호출자는 해당 객체를 소유하고 QkDag있어야 하며, 빌린 참조를 가지고 있어서는 안 됩니다(예를 들어 qk_dag_borrow_from_python , 에서 가져온 QkDag * 객체는 소유권이 없습니다).

안전

호출자는 Python 인터프리터에 연결되어 있어야 합니다. 가 초기화되고 소유권이 있는 에 대한 유효한 비공백 포인터가 QkDag 아닌 dag 경우 동작이 정의되지 않습니다.

매개변수

• dag – 소유된 객체.

리턴

해당 객체에 대한 Python 참조.

QkDag *qk_dag_borrow_from_python(PyObject *ob)

Python 객체에서 QkDag 포인터를 가져옵니다.

이 코드는 Python 참조를 가져와, 해당 참조가 올바른 유형일 경우 그 QkDag 포인터를 추출합니다. 반환된 포인터는 해당 ob 포인터에서 빌려온 것입니다. 의 유형이 올바르지 않은 PyObject 경우, 반환 값은 이 NULL 되며 Python 인터프리터의 예외 상태가 설정됩니다.

이 함수를 호출하려면 Python 인터프리터가 연결되어 있어야 합니다.

또한 를 사용할 수도 있습니다 qk_dag_convert_from_python. 이는 논리적으로는 이 함수와 완전히 동일하지만, Python 변환 함수 계열에 PyArg_Parse* 대한 “변환기” 함수로 직접 사용할 수 있습니다.

안전

호출자는 Python 인터프리터에 연결되어 있어야 합니다. 가 Python 객체를 가리키는 유효한 비공백 포인터가 아닌 ob 경우 동작이 정의되지 않습니다.

매개변수

• ob – 차용된 Python 객체.

리턴

네이티브 객체에 대한 포인터이거나, NULLPython 객체의 유형이 올바르지 않은 경우.

int qk_dag_convert_from_python(PyObject *object, void *address)

Python 객체에서 DAG 포인터를 가져옵니다.

이 코드는 Python 참조를 가져와, 해당 QkDag 포인터가 올바른 유형인 경우 이를 address``로 추출합니다. 반환된 포인터는 해당 object 포인터에서 빌려온 것입니다. 의 PyObject 유형이 올바르지 않은 경우, 반환 값은 1이 되며, Python 인터프리터의 예외 상태가 설정되고 는 변경되지 address 않습니다.

이 함수를 호출하려면 Python 인터프리터가 연결되어 있어야 합니다.

또한 를 qk_dag_borrow_from_python사용할 수도 있는데, 이는 논리적으로는 이와 완전히 동일하지만 직접 사용할 때 더 자연스러운 시그니처를 갖습니다.

안전

호출자는 Python 인터프리터에 연결되어 있어야 합니다. 가 유효한 null이 아닌 Python 객체 포인터가 object 아니거나, 가 올바른 유형의 쓰기 가능한 address 데이터에 대한 포인터가 아닌 경우 동작이 정의되지 않습니다.

매개변수

• 객체 – 빌려온 Python 객체.
• 주소 – 출력을 기록할 위치.

리턴

성공 시 1, 실패 시 0.