키스킷 SDK 2.1 릴리즈 노트

2.1.2

Prelude

키스킷 2.1.2 은 2.1 시리즈에서 발견된 몇 가지 버그를 수정하는 소규모 패치 릴리스입니다.

버그 수정

키스킷 2.1.0 에서 VF2PostLayout 트랜스파일러 패스가 프리셋 패스 매니저의 optimization 단계에 추가되었습니다 optimization_level=3. 그러나 패스의 출력은 회로에 적용된 적이 없습니다. 이번 릴리스에서는 사전 설정 패스 관리자의 optimization 단계에서 패스를 제거하여 런타임 비용을 절약할 수 있습니다. 키스킷 2.2.0 에서 패스는 optimization 단계의 일부가 되며, 패스가 더 나은 레이아웃을 찾으면 출력이 적용됩니다.
트랜스파일러 패스의 문제를 수정했습니다 VF2Layout 트랜스파일러 패스에서 고정 시드가 설정되어 있어도 패스의 출력이 잠재적으로 비결정적일 수 있는 문제, 특히 입력 회로에 단일 큐비트 연산만 포함된 활성 큐비트가 있는 경우의 문제를 수정했습니다. 수정 #14729
버그 수정 PassManager.run() 에서 여러 회로로 실행할 때 callback 함수가 호출되지 않던 버그를 수정했습니다. 이제 병렬 실행을 포함하여 각 회로의 각 패스에 대해 콜백이 올바르게 트리거됩니다.
final_layout 속성을 설정하는 기본 제공 트랜스파일러 패스는 이제 이미 설정된 경우 이 필드 업데이트를 올바르게 처리합니다. 이는 메서드 TranspileLayout.routing_permutation 는 이제 final_layout 을 설정하는 패스를 두 번 이상 실행한 후 올바른 순열을 반환합니다.

이것은 일반 통화에는 영향을 미치지 않았습니다 transpile() 또는 generate_preset_pass_manager() 이 형식으로 구성된 파이프라인은 final_layout 을 두 번 이상 설정하려고 시도하지 않습니다.
의 버그를 수정했습니다 Target.instruction_supported() 에서 기존 인스트럭션과 일치하는 operation_name 및 parameters 인수를 사용하여 메서드를 호출할 때 인스트럭션의 큐비트 순서 확인이 건너뛰는 버그가 수정되었습니다.
ps 단위를 사용하여 지연 명령이 포함된 회로를 QASM3 으로 내보낼 때 정확성 버그가 수정되었습니다.
회로 표시의 가장자리 케이스가 수정되었습니다 QFT 회로 표시의 가장자리 케이스를 수정했습니다. 이전에는 QFT.inverse() 를 호출한 후 QFT 회로의 속성을 수정하면 QFT의 이름이 "IQFT_dg" 로 표시되었습니다. 이는 올바르지 않았으며 이제 "IQFT" 로 올바르게 표시됩니다. 수정 #14758.
qk_circuit_get_instruction 과 qk_circuit_instruction_clear 을 사용할 때의 메모리 누수를 수정했습니다.
잘못된 지정 버전에 대한 오류 메시지를 명확하게 수정했습니다 qpy.dump() 의 잘못된 지정 버전에 대한 오류 메시지를 명확히 하여 조치를 취하기 쉽게 했습니다.
함수 관련 문제를 수정했습니다 generate_preset_pass_manager() 함수가 타이밍 제약 조건 데이터를 잘못 무시하는 문제를 수정했습니다 Targetbackend 인수가 설정되지 않았을 때 제공된 객체에 포함된 타이밍 제약 데이터를 잘못 무시하는 문제를 수정했습니다. 수정 #14329
의 버그를 수정했습니다 SparsePauliOp.simplify() 메서드가 중복을 결합하기 전에 계수의 크기에 따라 폴리 항을 제거하던 버그를 수정했습니다. 이로 인해 두 가지 주요 엣지 케이스에서 잘못된 동작이 발생했습니다:
1. 여러 개의 동일한 폴리 항이 개별적으로 단순화 임계값보다 작지만 합이 임계값을 초과하는 작은 계수를 가진 경우, 해당 항이 잘못 제거되었습니다.
2. 여러 개의 동일한 폴리 항이 임계값을 초과하지만 합이 0에 가까운 계수를 갖는 경우 잘못 보관된 것입니다.
자세한 내용은 #14194를 참조하세요.

2.1.1

Prelude

키스킷 2.1.1 은 2.1 시리즈에서 발견된 몇 가지 버그를 수정하는 소규모 패치 릴리스입니다.

버그 수정

동등성 검사에서 버그를 수정했습니다 DAGOpNode 동일성 검사에서 두 개의 DAGOpNode 객체를 비교하면 BoxOp 명령어를 포함하는 두 객체를 비교하는 버그를 수정했습니다. 이전에는 BoxOp.unit 속성이 동일성 검사의 일부로 고려되지 않았기 때문에 동일하지 않은 두 노드가 동일하다고 평가될 수 있었습니다.
키스킷을 가져올 때 사용자 코드에 의한 것으로 올바르게 식별되도록 Python 3.9 에 대한 사용 중단 경고를 수정했습니다. 이전에는 사용자 코드로 인해 발생한 것으로 식별되지 않았기 때문에 Python 의 기본 경고 필터가 사용자에게 경고를 표시하지 않았습니다.
max_trials 인수의 동작을 수정했습니다 VF2Layout 의 인수가 None 또는 음수로 설정된 경우의 동작을 수정했습니다. 이 패스는 옵션이 None 로 설정된 경우 회로 또는 대상의 크기에 따라 검색을 제한하고, 음수 값을 허용하여 무제한 검색을 지정하는 것으로 문서화되었습니다. 그러나 2.1.0 에서는 이 동작이 잘못 변경되어 None 이 무제한 검색을 실행하고 음수를 사용하면 오류가 발생했습니다. 패스가 문서화된 대로 작동하고 이전 릴리스와 일관성을 유지하도록 이러한 감독 사항이 수정되었습니다.
하이 레벨 합성 플러그인의 문제 수정 MCXSynthesis1DirtyKG24 및 MCXSynthesis2DirtyKG24 의 MCXGate플러그인에서 사용 가능한 깨끗한 보조 큐비트를 사용 가능한 더티 보조 큐비트로 간주하지 않는 문제를 수정했습니다. 특히, 플러그인 MCXSynthesis2DirtyKG24 은 깨끗한 큐비트와 더러운 보조 큐비트가 각각 하나씩 있을 때는 적용되지 않았습니다.
다수의 하위 표현식을 결합하여 점진적으로 빌드할 때 ParameterExpression 를 점진적으로 구축할 때 성능 저하를 수정했습니다. 수정 #14653

2.1.0

Prelude

키스킷( v2.1 ) 릴리스에서는 C API, 트랜스파일러 기능, 양자 회로 사용성 등 주요 영역에서 몇 가지 중요한 개선 사항을 소개합니다. 이 외에도 많은 일반적인 개선 사항과 버그 수정이 포함되어 있습니다. 주요 내용은 다음과 같습니다:

C API 확장: 이전 릴리스에서 시작된 작업을 기반으로, 키스킷( v2.1 )은 표준 게이트, 표준 명령어 및 단일 게이트의 추가를 지원하는 C API 함수를 통해 양자 회로 생성 및 상호 작용을 추가하여 표준 게이트에 대한 지원을 추가합니다. 또한 이번 릴리스에는 다음 릴리스에서 완전한 C API 번역 워크플로우를 지원하기 위해 Target 객체를 빌드하고 조작하는 C 함수 세트가 추가되었습니다. 이는 다음 릴리스에서 완전한 C API 기반 번역 워크플로우를 지원하기 위한 준비 작업입니다. 또한 QkComplex64 는 이제 구조체로 정의되어 키스킷의 C API로 작업할 때 컴파일러에 구애받지 않는 복소수 표현으로 사용됩니다. C API의 헤더 파일도 일반적으로 C++에서 기본적으로 사용할 수 있도록 호환되도록 업데이트되었습니다.

클리포드+T 베이시스 세트 지원: 이제 클리포드+T 게이트가 있는 대상에 대한 트랜스필링 회로가 기본적으로 지원됩니다. 내부적으로 베이시스 세트가 클리포드+T 게이트로만 구성된 경우, 키스킷은 이러한 게이트를 처리하는 데 적합한 패스가 사전 설정된 패스 매니저에 추가되도록 합니다. 이는 내결함성 백엔드에 대한 트랜슬레이션을 지원하기 위한 초기 단계입니다.

향상된 기능 BoxOp: 이 버전은 사용자 정의 어노테이션을 인스트럭션에 첨부하는 기능을 추가한다 BoxOp 명령어에 사용자 정의 주석을 추가하여 키스킷의 OpenQASM 3의 박스 문 개념을 추가로 지원합니다. 여기에는 QASM 및 QPY 형식의 어노테이션 직렬화도 포함됩니다. 또한 상자에서 스트레치 지속 시간을 사용할 수 있도록 지원이 추가되었습니다.

Python 3.9 지원 중단: Python 3.9 는 Qiskit v2.1 부터 지원이 중단되었으며 Qiskit v2.3 에서는 더 이상 지원되지 않습니다.

위 내용을 비롯한 자세한 내용은 아래 릴리즈 노트와 업데이트된 문서를 참조하세요.

C API 기능

이제 키스킷 C API( qiskit.h )는 양자 회로 구축 및 상호 작용을 지원합니다. 회로 C API는 회로를 나타내는 QkCircuit 불투명 유형을 중심으로 합니다. QkCircuit 유형은 키스킷의 내부 러스트 데이터 모델에 기본적으로 정의된 모든 회로 요소로 회로를 구축할 수 있게 해준다 QuantumCircuit. 여기에는 현재 표준 게이트가 포함됩니다, Measure, Delay, Reset, Barrier및 UnitaryGate. 더 많은 키스킷 데이터 모델이 내부 Rust 데이터 모델에 기본적으로 추가되어 C API에서 사용할 수 있게 됨에 따라 향후 릴리스에서 회로 C API의 기능이 확장될 예정입니다.

예를 들어 C API를 사용하여 1000큐비트 GHZ 상태를 구축할 수 있습니다:

#include <qiskit.h>

int main() {
    // Create an empty circuit with 1000 qubits and 1000 clbits
    QkCircuit *qc = qk_circuit_new(1000, 1000);

    // Add a Hadamard Gate on Qubit 0
    uint32_t one_qubit[1] = {0,};
    qk_circuit_gate(qc, QkGate_H, one_qubit, NULL); // The NULL pointer is for the parameter array.
                                                    // Since Hadamard doesn't have parameters it
                                                    // is never accessed.

    // Add the CX Gates:
    uint32_t qubits[2] = {0, 0};
    uint32_t num_qubits = qk_circuit_num_qubits(qc);
    for (int i = 1; i<num_qubits; i++) {
        qubits[1] = i;
        qk_circuit_gate(qc, QkGate_CX, qubits, NULL);
    }

    // Add the measurements:
    uint32_t num_clbits = qk_circuit_num_clbits(qc);

    for (uint32_t i = 0; i<num_clbits; i++) {
        qk_circuit_measure(qc, i, i);
    }
    qk_circuit_free(qc);
    return 0;
}

이제 키스킷 C API( qiskit.h )는 번역 대상을 나타내는 Target 를 생성할 수 있게 되었습니다. 예를 들어,

#include <qiskit.h>
#include <math.h>

int main() {
    // Create a Target with 3 qubits
    QkTarget *target = qk_target_new(3);

    // Create a Target Entry for a CX Gate
    QkTargetEntry *cx_entry = qk_target_entry_new(QkGate_CX);
    // Define properties for CX between qubits (0, 1) with a duration of 1.93e-9 sec and error rate 3.17e-10.
    uint32_t qargs[2] = {0, 1};
    qk_target_entry_add_property(cx_entry, qargs, 2, 1.93e-9, 3.17e-10);
    // Define properties for cx between qubits (1, 0) with a duration of 1.27e-9 sec and no error.
    uint32_t rev_qargs[2] = {1, 2};
    qk_target_entry_add_property(cx_entry, rev_qargs, 2, 1.27e-9, NAN);
    // Add the cx entry to the target.
    QkExitCode result_cx = qk_target_add_instruction(target, cx_entry);
    // Add global ideal Y gate entry to the target
    QkExitCode result_y = qk_target_add_instruction(target, qk_target_entry_new(QkGate_Y));
    // Create a Target entry for a Measurement with increasing duration and error as the qubit indices increase
    QkTargetEntry *measure = qk_target_entry_new_measure();
    for (uint32_t i = 0; i< qk_target_num_qubits(target); i++) {
        uint32_t q[1] = {i};
        qk_target_entry_add_property(measure, q, 1, 1e-6 * (i + 1), 1e-3 * (i + 1));
    }
    QkExitCode result_measure = qk_target_add_instruction(target, measure);
    return 0;
}

다음 매크로를 사용하여 C API에서 키스킷 버전 정보를 쿼리할 수 있도록 지원이 추가되었습니다:
- QISKIT_VERSION_MAJOR 주요 버전 번호를 포함합니다.
- QISKIT_VERSION_MINOR : 부 버전 번호를 포함합니다.
- QISKIT_VERSION_PATCH : 패치 버전 번호를 포함합니다.
- QISKIT_VERSION 버전 정보를 숫자로 표시하여 비교에 사용할 수 있습니다.
- QISKIT_VERSION_NUMERIC(M,m,p) 비교에 사용할 수 있는 버전 " M.m.p "을 숫자 값으로 반환하는 함수형 매크로입니다.
예를 들어 현재 버전이 2.1.0 이상인지 확인하려면 다음을 사용할 수 있습니다:
```
if (QISKIT_VERSION >= QISKIT_VERSION_NUMERIC(2, 1, 0)) {
    // Code for version 2.1.0 or later
}
```

C API에 대한 C++ 호환성을 활성화했습니다. 이제 생성된 헤더를 통해 C++에서 객체와 함수를 직접 호출할 수 있습니다. 예를 들어, 처음 3 큐비트에 XYZ라는 용어가 있는 100 큐비트 관측 가능성은 다음과 같이 구성할 수 있습니다

#include <iostream>
#include <complex>
#include <vector>
#include <qiskit.h>

int main() {
    uint32_t num_qubits = 100;

    // Use smart pointer with custom deleter to manage QkObs memory
    QkObs *obs = qk_obs_zero(num_qubits);

    // Construct the observable term
    std::complex<double> coeff_complex = 2.0;
    QkComplex64 coeff = qk_complex64_from_native(coeff_complex);
    std::vector<QkBitTerm> bit_terms = {QkBitTerm_X, QkBitTerm_Y, QkBitTerm_Z};
    std::vector<uint32_t> indices = {0, 1, 2};

    QkObsTerm term {
        .coeff      = coeff,
        .len        = bit_terms.size(),
        .bit_terms  = bit_terms.data(),
        .indices    = indices.data(),
        .num_qubits = num_qubits
    };

    qk_obs_add_term(obs.get(), &term);

    // Print observable properties
    std::cout << "num_qubits: " << qk_obs_num_qubits(obs) << "\n";
    std::cout << "num_terms: "  << qk_obs_num_terms(obs)  << "\n";

    qk_obs_free(obs);
    return 0;
}

회로 기능

함수 추가 random_circuit_from_graph() 인터랙션_그래프에 지정된 것과 동일한 인터랙션 그래프를 유도하는 무작위 회로를 생성하는 함수를 추가했습니다.

인터랙션 그래프에서 에지를 2비트 게이트로 무작위로 뽑을 확률은 사용자가 입력 인터랙션 그래프의 에지 가중치 속성에서 설정할 수 있습니다. 사용자가 확률을 설정하지 않으면 각 가장자리가 균일하게 그려집니다. 즉, 상호작용 그래프에서 에지로 표시되는 각 2큐비트 게이트는 무작위 회로에 추가될 확률이 동일합니다. 에지 확률의 하위 집합만 설정된 경우 ValueError 이 발생합니다.

이 예에서 cp_map 은 임의의 가중치를 가진 엣지 목록입니다.
```
from qiskit.circuit.random.utils import random_circuit_from_graph
import rustworkx as rx
pydi_graph = rx.PyDiGraph()
n_q = 5
cp_map = [(0, 1, 0.18), (1, 2, 0.15), (2, 3, 0.15), (3, 4, 0.22)]
pydi_graph.extend_from_weighted_edge_list(cp_map)
# cp_map can be passed in directly as interaction_graph
qc = random_circuit_from_graph(interaction_graph = pydi_graph,
  min_2q_gate_per_edge = 1,
  max_operands = 2,
  measure = True,
  conditional = True,
  reset = True,
  seed = 0,
  insert_1q_oper = True,
  prob_conditional = 0.21,
  prob_reset = 0.1)
qc.draw(output='mpl')
```
새로운 QuantumCircuit 메서드를 추가했습니다: QuantumCircuit.has_control_flow_op() 메서드를 추가하여 QuantumCircuit 객체에 제어 흐름 연산이 포함되어 있는지 확인하는 메서드가 추가되었습니다.
새로운 모듈 qiskit.circuit.annotation 및 원리 객체 Annotation 가 추가되었습니다.

주석은 로컬 사용자 지정 데이터로 지침(현재는 BoxOp)에 로컬 사용자 지정 데이터로 태그를 지정하는 방법입니다. 이 데이터는 커스텀 트랜스파일러 패스에서 사용하기 위한 것입니다. 어노테이션은 컴파일 중에 전역 컨텍스트 객체를 사용하는 대신 특정 명령어에 데이터를 첨부하는 방법을 제공합니다 PropertySet 를 사용하는 대신 특정 명령어에 데이터를 첨부할 수 있는 방법입니다.

모든 Annotation 객체에는 namespace 필드가 있습니다. 이 문자열 키는 조회에 사용되므로 소비자는 특정 어노테이션을 처리하는지 여부를 알 수 있습니다. 현재 서브클래스의 추상적 의미를 쿼리하는 메서드는 없습니다 Annotation 서브클래스의 추상적 의미를 쿼리하는 메서드는 현재 없지만 향후 확장될 예정입니다.

참조 qiskit.circuit.annotation 에서 기능 및 사용 사례에 대한 자세한 내용을 확인하세요.
BoxOp 인스턴스( QuantumCircuit.box())에 사용자 정의 Annotation 인스턴스로 주석을 달 수 있습니다. 두 상자의 동일성은 주석이 동일한지에 따라 달라집니다.

일반적으로 다음과 같이 컨텍스트 관리자 형식의 QuantumCircuit.box() 를 컨텍스트 관리자 형식으로 사용할 때 유일한 위치 인수로 전달합니다:
```
from qiskit.circuit import annotation, QuantumCircuit

class MyAnnotation(annotation.Annotation):
    namespace = "my.annotation"

    def __eq__(self, other):
        return isinstance(other, MyAnnotation)

qc = QuantumCircuit()
with qc.box([MyAnnotation()]):
    pass
```
메서드의 UnitaryGate.control() 메서드는 이제 내부적으로 qs_decomposition() 대신 Isometry 대신 제어되는 분해에 사용되는 UnitaryGate. 이 변경으로 인해 CXGate 에 사용되는 definition 에 대한 ControlledGate 의 사용 수를 약 2x 만큼 줄입니다.
다중 제어의 합성을 개선했습니다 U1Gate의 합성을 개선하여 컨트롤 수에 따라 기하급수적으로 증가하지 않도록 했습니다.
BoxOp.duration 어트리뷰트는 이제 expr.Expr 유형이 있는 노드 DurationDelay.duration타입의 노드가 될 수 있습니다. 여기에는 다음과 같은 지원도 포함됩니다 Stretch 기간 동안 BoxOp.

기본형 기능

에 대한 입력으로 사용되는 추정기 PUB를 BaseEstimatorV2.run() 의 입력으로 사용되는 PUB는 이제 다음을 사용하여 정의할 수 있습니다 SparseObservablePUB 객체를 사용하여 정의할 수 있습니다. 이는 기존 지원되는 유형에 추가됩니다: str, Pauli, SparsePauliOp및 str 또는 Pauli 를 float 값으로 매핑할 수 있습니다. 그러나 SparseObservable 에 프로젝터가 포함된 경우 원시 구현에 따라 처리 지원이 달라집니다. 이번 릴리스부터 키스킷(StatevectorEstimator 및 BackendEstimatorV2), qiskit-ibm-runtime (qiskit_ibm_runtime.EstimatorV2), 그리고 키스킷 에어의 (qiskit_aer.primitives.EstimatorV2) 프리미티브 구현은 아직 프로젝티브 옵저버를 지원하지 않는다. 투영 관찰 가능 항목은 다음과 같은 용어가 포함된 항목입니다: 0, 1, +, -, r, 또는 l.
클래스에 지원을 추가하여 DataBin 클래스를 직렬화할 수 있도록 pickle. 이를 통해 PrimitiveJob 및 PrimitiveResult 클래스를 직렬화할 수 있도록 pickle 로도 직렬화할 수 있습니다.

OpenQASM 기능

qasm3.dump() 와 qasm3.dumps() 의 인스턴스를 제공하는 데 사용되는 새로운 annotation_handlers 인수가 있습니다 annotation.OpenQASM3Serializer 의 인스턴스를 제공하는 데 사용되는 OpenQASM 3 내보내기 프로세스에 사용자 정의 Annotation 객체를 OpenQASM 3으로 직렬화할 수 있습니다.
qiskit_qasm3_import>=0.6.0 설치 시 qasm3.load() 와 qasm3.loads() 의 인스턴스를 제공하는 데 사용되는 새로운 annotation_handlers 인수가 있습니다 annotation.OpenQASM3Serializer 의 인스턴스를 제공하는 데 사용되는 OpenQASM 3 가져오기 프로세스에 사용자 정의 AnnotationOpenQASM 객체를 역직렬화할 수 있습니다. 이 지원은 현재 box 문으로 제한되는데, 이는 키스킷이 데이터 모델에서 주석을 표현할 수 있는 유일한 곳이기 때문입니다.

QPY 기능

새로운 QPY 형식 버전 15가 추가되어 새로운 Annotation 객체를 지원하며 외부 직렬화기 및 역직렬화기를 지원합니다. 이 형식을 사용하면 이러한 직렬화기가 상태 저장소가 될 수 있으며, 사용자 정의 상태 개체 및 사용자 정의 주석 표현을 위해 이진 형식의 안전한 위치가 할당됩니다.
qpy.dump() 와 qpy.load() 이제 선택적 annotation_factories 인수가 있는데, 이는 처리할 객체의 생성자 함수를 제공하는 데 사용되는 annotation.QPYSerializer 객체의 생성자 함수를 제공하는 데 사용됩니다 Annotation 서브클래스의 생성자 함수를 제공하는 데 사용됩니다. 일반적으로 키스킷은 외부에서 정의된 모든 가능성에 대해 알 수 없으므로 metadata_serializer 와 유사하게 사용자가 제공해야 합니다 Annotation 객체에 대해 알 수 없기 때문입니다.
새로운 기능 추가 get_qpy_version() 모듈에 qpy 모듈에 새로운 함수를 추가했습니다. 이 함수는 QPY 파일을 검사하고 페이로드에 사용된 QPY 형식 버전을 검색합니다. 버전은 정수로 반환되며, 로깅 또는 디버깅 목적으로 사용할 수 있습니다. 14201을 참조하세요.

양자 정보 특성

새로운 클래스 PauliLindbladMap클래스가 추가되었는데, 이는 노이즈 학습 애플리케이션에 사용되는 다중 큐비트 연산자의 선형 지도 하위 집합을 폴리 기반으로 매개변수화한 것입니다. 이 클래스는 향상된 노이즈 학습 알고리즘의 중추를 형성하고 향후 버전의 키스킷에서 노이즈 모델을 보다 효율적으로 제어할 수 있을 것으로 기대됩니다.
소개 QubitSparsePauli 과 QubitSparsePauliList 클래스는 Pauli 및 PauliList 와 동일한 개념을 각각 나타내지만, 비신원 용어만 저장하는 SparseObservable. 이러한 클래스는 주로 새로운 PauliLindbladMap.

합성 기능

에 대한 새로운 합성 알고리즘이 추가되었습니다 HalfAdderGate 에 대한 새로운 합성 알고리즘이 추가되었습니다 adder_qft_d00():
- adder_ripple_r25()
다음에 대한 새로운 분해가 추가되었습니다 MCXGate 깨끗한 부속물을 활용하여 회로 깊이와 효율성을 개선합니다:
- synth_mcx_1_clean_kg24()깨끗한 안실라 큐비트 1개 추가 사용
- synth_mcx_1_dirty_kg24()더티 앤실라 큐비트 1개 추가 사용
- synth_mcx_2_clean_kg24()2개의 추가 클린 보조 큐비트 사용
- synth_mcx_2_dirty_kg24()더티 보조 큐비트 2개 추가 사용
사용 예:
```
from qiskit.synthesis.multi_controlled import synth_mcx_1_clean_kg24

n_ctrls = 10
qc = synth_mcx_1_clean_kg24(n_ctrls)
qc.draw()
```
다중 제어 게이트의 합성 CZGate 게이트의 합성이 개선되어 합성된 게이트 수를 줄일 수 있으며, 경우에 따라 최대 99%까지 줄일 수 있습니다. 이는 향상된 합성 기능을 활용하여 달성되었습니다 MCXGate 제어된 CZGate 합성 기능을 활용했기 때문입니다.
객체 합성을 위한 기본 플러그인이 개선되었습니다 AnnotatedOperation 객체 합성을 위한 기본 플러그인을 개선했습니다. 이 개선 사항은 제어 게이트가 있는 제어 회로를 생성하고 그 안에 트랜스파일할 때 특히 유용합니다. 예를 들어,
```
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import CXGate
from qiskit.compiler import transpile

inner = QuantumCircuit(5)
inner.append(CXGate().control(3, annotated=True), [0, 1, 2, 3, 4])
controlled_inner_gate = inner.to_gate().control(2, annotated=True)
qc = QuantumCircuit(15)
qc.append(controlled_inner_gate, [0, 1, 2, 3, 4, 5, 6])
qct = transpile(qc, basis_gates=["cx", "u"])
```
이 코드는 2 제어 양자 회로와 그 안에 3 제어 CX 게이트가 포함된 양자 회로 qc 를 생성합니다. 개선으로 트랜스파일된 회로의 CX 게이트 수가 378 에서 30 로 감소했습니다. 제어 로직을 정의할 때 annotated=True 을 지정하면 제어된 게이트가 주석이 달린 연산으로 생성됩니다. 이를 통해 트랜스파일러는 열성적인 합성을 피하고, controlled_inner_gate 이 6개의 제어된 X-게이트와 동일하다는 것을 감지하고, 특히 사용 가능한 안실라 큐비트를 활용하여 다중 제어 X-게이트에 사용할 수 있는 최상의 합성 방법을 선택할 수 있습니다.
기능 adder_qft_d00()합성하는 데 사용되는 ModularAdderGate 및 HalfAdderGate 게이트에 사용되는 함수는 이제 추가 매개변수 annotated 를 허용합니다. True 인 경우 가산기 내의 역-QFT 게이트가 주석이 달린 연산으로 구현되어 트랜스파일러가 추가 최적화를 적용할 수 있습니다.
양자 섀넌 분해(qs_decomposition())에는 이제 입력 단수가 제어된 단수인 경우 CXGate 카운트를 줄이는 최적화가 포함됩니다.
합성 기능 synth_mcx_1_clean_b95() 는 이제 더 적은 수의 CX 게이트로 회로를 생성합니다.
클래스는 이제 SolovayKitaevDecomposition 클래스에는 이제 이니셜라이저에 추가 인수가 있어 기본 근사값을 위한 basis_gates 및 depth 집합에서 직접 구성할 수 있습니다.
추가 SolovayKitaevDecomposition.save_basic_approximations() 를 추가하여 클래스에서 사용하는 기본 근사치 집합을 이진 형식으로 저장합니다. 이 변경 사항은 새로운 초기화 인자와 결합하여 사용자가 명시적인 generate_basic_approximations() 의 명시적 사용을 건너뛰고 SolovayKitaevDecomposition.

트랜스파일러 기능

함수 generate_preset_pass_manager() 함수는 이제 기본 집합이 클리포드+T 게이트로만 구성된 경우 특수 패스 매니저를 생성합니다. 공식적으로 클리포드+T 베이시스 세트는 클리포드 게이트만 포함해야 하며, 다음 중 하나를 포함해야 합니다 TGate, TdgGate또는 둘 다 포함해야 합니다. 지원되는 클리포드 게이트의 전체 목록은 다음을 사용하여 얻을 수 있습니다 get_clifford_gate_names().

예를 들어,
```
from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.quantum_info import get_clifford_gate_names

basis_gates = get_clifford_gate_names() + ["t", "tdg"]
pm = generate_preset_pass_manager(basis_gates=basis_gates)

qc = QuantumCircuit(1)
qc.rx(0.8, 0)
qct = pm.run(qc)
print(qct.count_ops())
```
결과로 나타납니다:
```
OrderedDict([('h', 10210), ('t', 4508), ('tdg', 4503), ('sdg', 943), ('s', 941)])
```
이전에는 생성된 패스 관리자가 위의 예시를 처리할 수 없었는데, 이는 단일 큐비트 UGate 회전 게이트를 클리포드+T 게이트로 분해할 수 없었기 때문입니다. 그러나 새로운 패스 관리자는 Solovay-Kitaev 분해를 사용하여 H, T 및 Tdg 게이트를 사용하여 단일 큐비트 회전 게이트를 근사화하고 다음을 호출합니다 BasisTranslator 트랜스파일러 패스를 호출하여 게이트를 목표 기저 집합으로 추가로 변환합니다. 새로운 패스 매니저에는 클리포드+T 게이트로의 보다 효율적인 변환을 위한 다른 변경 사항도 있습니다.

지정된 클리포드+T 기저 게이트 세트는 보편적이어야 하며, 그렇지 않으면 변환이 성공하지 못할 수 있다는 점에 유의해야 합니다. 범용성을 위해 ["h", "t", "tdg"] 또는 ["h", "t"] 게이트 세트로도 충분하지만, 그렇지 않으면 번역 효율이 떨어질 수 있으므로 가능하면 클리포드 게이트를 더 추가하는 것이 좋습니다. 예를 들어, S-게이트가 포함되지 않은 경우 S-게이트가 T-게이트 쌍으로 분해될 수 있습니다(즉, 클리포드 게이트가 비클리포드 게이트로 분해될 수 있으며, 이는 원하는 동작이 아닐 수 있습니다).

다음은 조금 더 큰 예입니다:
```
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import QFTGate
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

qc = QuantumCircuit(4)
qc.append(QFTGate(4), [0, 1, 2, 3])

basis_gates = ["cx", "s", "sdg", "h", "t", "tdg"]
pm = generate_preset_pass_manager(basis_gates=basis_gates, optimization_level=2)

qc = QuantumCircuit(4)
qc.append(QFTGate(4), [0, 1, 2, 3])

qct = pm.run(qc)
print(qct.count_ops())
```
결과로 나타납니다:
```
OrderedDict([('h', 96510), ('tdg', 42396), ('t', 42389), ('s', 8240), ('sdg', 8235), ('cx', 12)])
```
새로운 하이 레벨 합성 플러그인 추가 HalfAdderSynthesisR25 를 합성하기 위한 HalfAdderGate. 새 플러그인은 adder_ripple_r25().

또한 HalfAdderSynthesisDefault 는 하프 가산기 합성기의 다음 순서를 따르도록 업데이트되었습니다: $\leq 3$ 큐비트가 있는 경우 "HalfAdder.ripple_r25" , 보조 큐비트 1개가 있는 경우 "HalfAdder.ripple_c04" , 나머지 모든 경우 "HalfAdder.ripple_r25" .
합성을 위한 여러 하이 레벨 합성 플러그인을 추가했습니다 MCXGate:
- MCXSynthesis1CleanKG24를 기반으로 synth_mcx_1_clean_kg24().
- MCXSynthesis1DirtyKG24를 기반으로 synth_mcx_1_dirty_kg24().
- MCXSynthesis2CleanKG24를 기반으로 synth_mcx_2_clean_kg24().
- MCXSynthesis2DirtyKG24를 기반으로 synth_mcx_2_dirty_kg24().
클래스는 MCXSynthesisDefault 클래스는 또한 첫 번째 메서드가 성공할 때까지 다음과 같은 일련의 MCX 합성 메서드를 실행하도록 업데이트되었습니다: "mcx.2_clean_kg24", "mcx.1_clean_kg24", "mcx.n_clean_m15", "mcx.n_dirty_i15"`, ``"mcx.2_dirty_kg24", "mcx.1_dirty_kg24", "mcx.1_clean_b95", "mcx.noaux_v24". 메서드는 더 나은 품질의 메서드가 먼저 적용되는 방식으로 정렬됩니다.
VF2PostLayout 최적화 레벨 3을 사용할 때 기본 최적화 단계의 마지막에 추가되었습니다.

새로운 OptimizeCliffordT 트랜스파일러 최적화 패스를 추가하여 연속된 T-게이트 쌍을 S-게이트로, 연속된 Tdg-게이트 쌍을 Sdg-게이트로 병합합니다. 이 최적화는 여러 개의 연속적인 T 또는 Tdg 게이트를 생성하는 솔로베이-키타에프 분해에 따른 T 카운트를 줄이는 데 특히 효과적입니다. 예를 들어,

from qiskit.circuit import QuantumCircuit
from qiskit.transpiler.passes import SolovayKitaev, OptimizeCliffordT

qc = QuantumCircuit(1)
qc.rx(0.8, 0)

# Run Solovay-Kitaev pass on qc
transpiled = SolovayKitaev()(qc)
print(transpiled.count_ops().get("t", 0) + transpiled.count_ops().get("tdg", 0))
# Should print 12779

# Run Clifford+T optimization
optimized = OptimizeCliffordT()(transpiled)
print(optimized.count_ops().get("t", 0) + optimized.count_ops().get("tdg", 0))
# Should print 9011

추가 ContextAwareDynamicalDecoupling 패스를 추가하여 월시-하다마드 시퀀스를 기반으로 컨텍스트 인식 동적 디커플링을 구현했습니다. 삽입된 지연 시퀀스는 인접 큐비트에 있는 시퀀스와 상호 직교하며, CX 및 ECR 게이트의 제어/타겟 스펙트럼을 고려합니다. 참조 arXiv:2403.06852 를 참조하세요.

예:

from qiskit.circuit.library import QFT
from qiskit.transpiler import PassManager, CouplingMap
from qiskit.transpiler.passes import ALAPScheduleAnalysis, ContextAwareDynamicalDecoupling
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.providers.fake_provider import GenericBackendV2

num_qubits = 10
circuit = QFT(num_qubits)
circuit.measure_all()

target = GenericBackendV2(
    100,
    basis_gates=["id", "rz", "sx", "x", "ecr"],
    coupling_map=CouplingMap.from_grid(10, 10)
).target

pm = generate_preset_pass_manager(optimization_level=2, target=target)
dd = PassManager([
    ALAPScheduleAnalysis(target=target),
    ContextAwareDynamicalDecoupling(target=target),
])

transpiled = pm.run(circuit)
with_dd = dd.run(transpiled)

with_dd.draw("mpl", idle_wires=False)

클래스에 다음 어트리뷰트를 추가했습니다 DAGCircuit 클래스에 다음 속성을 추가하여 스트레치 변수의 수를 쿼리할 수 있도록 했습니다: num_stretches, num_captured_stretches 와 num_declared_stretches.
새로운 유니타리 합성 플러그인을 추가했습니다 CliffordUnitarySynthesis 주어진 단일 게이트를 클리포드로 표현할 수 있는지 확인하여 합성을 시도하고, 이 경우 이 단일 게이트를 구현하고 클리포드 게이트로만 구성된 회로를 반환하는 새로운 단일 합성 플러그인을 추가했습니다.

플러그인은 매개변수가 UnitarySynthesis 매개변수 method 가 "clifford" 로 설정될 때 트랜스파일러 패스에 의해 호출됩니다.

또한 plugin_config 의 매개 변수 UnitarySynthesis 를 사용하여 다음 플러그인별 매개변수를 전달할 수 있습니다:
- 최소_큐비트: 고려할 최소 큐비트 수입니다(기본값은 1).
- 최대_큐비트: 고려할 최대 큐비트 수입니다(기본값은 3).
예를 들어,
```
import math

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import UnitaryGate
from qiskit.quantum_info import Operator
from qiskit.transpiler.passes import UnitarySynthesis

# clifford unitary over 2 qubits
c2 = QuantumCircuit(2)
c2.h(0)
c2.rz(math.pi / 4, 1)
c2.rz(math.pi / 4, 1)
c2.sdg(1)
uc2 = UnitaryGate(Operator(c2).data)

# non-clifford unitary over 2 qubits
n2 = QuantumCircuit(2)
n2.h(0)
n2.rz(math.pi / 4, 1)
n2.sdg(1)
un2 = UnitaryGate(Operator(n2).data)

# quantum circuit with two unitary gates
qc = QuantumCircuit(3)
qc.append(uc2, [2, 1])
qc.append(un2, [0, 2])

transpiled = UnitarySynthesis(method="clifford")(qc)
transpiled.draw("mpl")
```
위의 코드를 실행하면 첫 번째 단일 게이트가 클리포드 게이트로 재합성되고, 두 번째 게이트는 변경되지 않습니다.

위의 예제를 다음과 같이 수정하면 됩니다:
```
config = {"min_qubits": 3}
transpiled = UnitarySynthesis(method="clifford", plugin_config=config)(qc)
```
로 설정하면 두 단일 게이트는 변경되지 않습니다.

시각화 기능

함수에 대한 사용자 지정 스타일을 도입했습니다 dag_drawer() 함수에 대한 사용자 지정 스타일을 도입했습니다. 이렇게 하면 함수가 반환하는 DAG의 스타일을 변경하는 사용자 지정 속성과 함께 style 매개변수에 사전을 전달할 수 있습니다. 예를 들어,

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.converters import circuit_to_dag
from qiskit.visualization import dag_drawer

q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)

dag = circuit_to_dag(circ)

style = {
    "inputnodecolor": "pink",
    "outputnodecolor": "lightblue",
    "opnodecolor": "red",
}

dag_drawer(dag, style=style)

업그레이드 주의사항

python-dateutil 라이브러리는 더 이상 키스킷의 종속성이 아닙니다. 키스킷 v2.0 이후 라이브러리의 어떤 것도 python-dateutil 을 사용하지 않았고 키스킷은 더 이상 라이브러리에 의존하지 않았습니다. 이번 릴리스에서는 종속성 목록에서 제거되어 키스킷을 사용하기 위한 전제 조건으로 자동으로 설치되지 않습니다. 키스킷에 의존하여 날짜투틸을 종속성으로 설치했다면 이제 수동으로 설치해야 합니다(직접 종속성의 경우 모범 사례).
sympy 은 더 이상 키스킷을 설치하기 위한 필수 조건이 아닙니다. 클래스에 대한 Rust 기반 심볼릭 엔진으로 마이그레이션한 후 ParameterExpression 클래스에서 SymPy 의 사용은 일부 시각화 유틸리티인 TemplateOptimization 트랜스파일러 패스 ParameterExpression.sympify() (명시적으로 SymPy 상호 운용성을 위한 것) 및 SparsePauliOp.simplify() 매개변수화된 계수를 사용하는 경우. 이 기능은 가장 일반적으로 사용되지 않으므로 SymPy 은 이제 선택적 종속성으로 취급되며 해당 함수가 사용되는 경우 MissingOptionalLibraryErrorSymPy 예외가 발생합니다.
객체 빌드에 사용되었던 symengine 에 대한 종속성이 제거되었습니다 ParameterExpression 객체를 빌드하는 데 사용된 에 대한 종속성이 제거되었습니다. 내부 심볼릭 엔진으로 대체되었으며 더 이상 키스킷의 핵심 기능에 필요하지 않습니다. 유일한 예외는 심 엔진이 QPY 형식 10, 11, 12에 내장되어 있으므로 해당 형식을 역직렬화하는 경우에도 여전히 필요하다는 것입니다. 에 대한 심엔진 종속성은 qpy.load() 에 대한 심엔진 의존성은 2.0.0 에서 명시적으로 선택 사항으로 변경되었지만, 이전에 이 기능을 위해 심엔진이 기본적으로 설치되는 것에 의존했다면 이제 페이로드를 로드하려면 심엔진을 수동으로 설치해야 합니다. 를 사용하여 ParameterExpression.sympify() 에서 심 엔진 표현식 객체를 가져오기 위해 ParameterExpression 이제 sympy 표현식을 반환합니다. 이를 심엔진과 함께 사용해야 하는 경우 symengine.sympify 을 활용하여 sympy 표현식을 심엔진 표현식으로 변환할 수 있습니다.

회로 업그레이드 노트

속성의 definition 속성의 HalfAdderGate 속성이 내부적으로 사용하도록 변경되었습니다 adder_ripple_r25() 로 변경되어 보조 큐비트 없이 보다 효율적인 회로를 위한 게이트 정의를 생성할 수 있습니다. 어떤 이유로 이전 정의가 필요한 경우 대신 직접 adder_qft_d00() 함수를 대신 사용하여 이전 릴리스에서 반환하는 것과 동일한 회로를 생성할 수 있습니다 definition 가 반환하는 것과 동일한 회로를 생성합니다.
함수가 반환하는 회로는 excitation_preserving() 함수와 ExcitationPreserving 클래스가 반환하는 회로는 이제 단일 XXPlusYYGate. 이는 이전 릴리스에서 사용되었던 RXXGate 뒤에 RYYGate. 이 새로운 회로 구조는 동등하지만 더 적은 수의 게이트를 사용하여 더 간단하게 여기 보존이 가능합니다.
여러 표준 게이트의 definition 속성이 다음 원칙에 따라 업데이트되었습니다:
- 가능한 경우 클리포드 게이트를 사용하는 정의가 클리포드 게이트가 아닌 정의를 포함하는 정의보다 선호됩니다.
- 가능한 경우, 클리포드+T 게이트를 사용하는 정의는 UGate.
- 의 사용은 PhaseGate 보다 U1Gate.
- 의 사용은 UGate 를 `U2Gate 및 `U3Gate 보다 선호합니다.
결정적으로, 다음과 같은 불변성은 여전히 유지됩니다. 게이트 정의를 재귀적으로 확장하면 모든 게이트는 궁극적으로 ["cx", "u"] 기반으로만 표현할 수 있습니다. 모든 표준 게이트의 정의는 모두 동일하므로 게이트의 의미는 바뀌지 않고 일부 게이트에 대해 반환되는 정확한 회로 구조만 달라집니다. 이 변경은 클리포드+T 트랜스필레이션을 지원하기 위해 필요했습니다.
이제 키스킷은 자체 Rust 기반 기호 표현식 라이브러리를 사용하여 내부를 구현합니다 ParameterExpression 와 Parameter. 에 사용되는 핵심 기호 수학 엔진을 새롭게 구현한 것이므로 ParameterExpression 에 사용되는 핵심 기호 수학 엔진의 새로운 구현이므로 일부 기능의 정확한 동작에 약간의 차이가 있을 수 있습니다. 문서화된 API에 대해 항상 동등한 결과를 생성해야 합니다. 정확성에 문제가 있는 경우 문제를 제기해 주세요.

C API 업그레이드 노트

키스킷의 C API에서 복소수가 노출되는 방식이 변경되었습니다. 이전에는 QkComplex64 이 컴파일러에 종속된 typedef로, 네이티브 복합형을 키스킷의 API에 포인터로 전달할 수 있었습니다(예: double complex*). 이 접근 방식은 편리하기는 하지만 엄격하게 보장되지 않는 메모리 레이아웃 가정에 암묵적으로 의존합니다.

이제 키스킷 v2.1 은 메모리 레이아웃이 항상 호환되도록 하고 더 광범위한 컴파일러 지원을 위해 QkComplex64 { double re; double im; } 을 구조체로 노출합니다. 편의를 위해 컴파일러 종속 변환기 qk_complex64_from_native 및 qk_complex64_to_native 가 제공되어 구조체에서 네이티브 복소수로 변환할 수 있습니다. double complex 를 지원하는 플랫폼 또는 _Dcomplex 을 사용하는 MSVC 컴파일러에서만 작동합니다.

예를 들어,

#include <qiskit.h>
#include <math.h>
#include <stdio.h>
#include <complex.h>

int main(int argc, char *argv[]) {
    // platform-independent constructions:
    QkComplex64 coeff = {5.0, 3.0};

    // ... or using converter
    // double complex native = 5.0 + I * 3; // uses C11 standard, does not work on MSVC
    // QkComplex64 coeff = qk_complex64_from_native(&native);  // convert from native

    uint32_t num_qubits = 100;
    QkObs *obs = qk_obs_zero(num_qubits);
    QkBitTerm bit_terms[3] = {QkBitTerm_X, QkBitTerm_Y, QkBitTerm_Z};
    uint32_t indices[3] = {0, 1, 2};
    QkObsTerm term = {coeff, 3, bit_terms, indices, num_qubits};
    qk_obs_add_term(obs, &term);
    printf("num_qubits: %u\n", qk_obs_num_qubits(obs));
    printf("num_terms: %lu\n", qk_obs_num_terms(obs));

    qk_obs_free(obs);
    return 0;
}

QPY 업그레이드 노트

에서 내보내는 기본 QPY 버전이 qpy.dump() 가 최신 QPY 버전 15로 변경되었습니다. 어떤 이유로 이전 형식의 버전을 생성해야 하는 경우 version 키워드 인수에 qpy.dump() 를 사용하여 이전 버전을 생성하도록 지정할 수 있습니다.

합성 업그레이드 노트

솔로베이-키타에프 알고리즘의 기본 근사치에 대한 직렬화 형식이 .npy 에서 Rust의 serde 및 bincode 를 기반으로 하는 다른 바이너리 형식으로 변경되었습니다. 기본 근사값을 로드하는 모든 루틴( generate_basic_approximations(), SolovayKitaevDecomposition.load_basic_approximations() 또는 이니셜라이저 SolovayKitaev)는 여전히 레거시 형식 로드를 지원합니다. 그러나 모든 새 파일은 새 형식으로 저장됩니다. 이전 형식을 사용했다면 Qiskit을 < 2.2 로 다운그레이드하고 필요한 파일을 저장하세요.
(및 관련 클래스)의 기본값이 SolovayKitaev (및 관련 클래스)의 기본값이 depth=12 및 reps=5 으로 증가했습니다. 이는 기본 구현이 이제 Rust로 변경되어 이전 Python 버전보다 훨씬 빠르면서도 기본 정밀도를 높일 수 있게 되었기 때문입니다.

트랜스파일러 업그레이드 노트

현재 패스 관리자를 위한 기본 제공 레이아웃 플러그인은 더 이상 주요 컴포넌트(예: "사브르" 단계의 SabreLayout 예를 들어 "세이버" 스테이지의 경우) 커플링 제약 조건이 제공되지 않습니다. 이전에는 별도의 로직이 패스를 실행하지 못하게 하고 예외를 발생시킨다는 가정 하에 플러그인이 레이아웃 패스의 잘못된 인스턴스를 생성했습니다.

유효하지 않은 상태에서 패스를 호출하는 것은 이미 유효하지 않았기 때문에 사전 설정 패스 관리자 또는 플러그인 사용에는 의미 있는 영향을 미치지 않습니다.

지원 중단 노트

Python 3.9 으로 키스킷 실행에 대한 지원은 더 이상 사용되지 않으며, 키스킷 v2.3 릴리스에서 제거될 예정입니다. 버전 2.3.0 은 Python 3.9 이 수명이 종료되어 더 이상 지원되지 않는 이후 첫 번째 릴리스입니다 [1]. 즉, 2.3.0 릴리스부터는 사용 중인 Python 버전을 Python 3.9 이상으로 업그레이드해야 합니다.

[1] https://devguide.python.org/versions/

회로 사용 중단

회로 라이브러리는 키스킷 v1.3 릴리스에서 리팩터링을 거쳤으며, 이 리팩터링에서는 다음과 같은 유형의 객체에 대한 대안이 제공되었습니다 QuantumCircuit 유형의 객체에 대한 대안이 제공되었습니다 Instruction 또는 Python 함수로 구성할 수 있는 대안이 제공되었습니다. 이 리팩터링을 통해 컴파일러는 고수준 명령어를 추론하고 고수준 최적화가 필요하지 않은 회로의 오버헤드를 줄일 수 있습니다.

모든 QuantumCircuit 서브클래스는 이제 키스킷 v1.3 에 도입된 대체 클래스를 위해 더 이상 사용되지 않습니다. 이에 따라 BlueprintCircuit 베이스 클래스도 더 이상 사용되지 않습니다. 모두 사용 중단 기간이 연장되었으며, 키스킷 v3.0 에서만 제거됩니다.

BlueprintCircuit 클래스는 직접 대체할 수 없으며 대신 QuantumCircuit 를 직접 사용하거나 회로를 생성하는 함수를 사용해야 합니다. 자세한 내용은 qiskit.circuit.library 를 참조하세요. 자세한 내용은 몇 가지 일반적인 회로와 그 대체품을 참조하세요:
- QFT → QFTGate
- TwoLocal → n_local() (이것은 오타가 아니며, 이 함수는 NLocal 및 TwoLocal 기능)
- EfficientSU2 → efficient_su2()
- RealAmplitudes → real_amplitudes()
- ZZFeatureMap → zz_feature_map()
- QuantumVolume → quantum_volume()
- EvolvedOperatorAnsatz → evolved_operator_ansatz()
- MCXGrayCode → synth_mcx_gray_code()
- MCXRecursive → synth_mcx_n_dirty_i15()
- MCXVChain → synth_mcx_n_clean_m15()

버그 수정

함수의 버그를 수정했습니다 dag_drawer() 함수와 DAGCircuit.draw() 메서드에서 키워드 인수 style=plain 를 설정해도 시각화에서 DAG 노드의 회로 레이블이 표시되지 않던 버그를 수정했습니다.
메서드의 버그를 수정했습니다 QuantumCircuit.assign_parameters() 메서드에서 인자 strict=False 설정 시 회로에 사용되지 않고 문자열로 전달된 매개변수가 무시되지 않던 버그가 수정되었습니다. 자세한 내용은 이슈 #13933을 참조하세요.
Windows용 Makefile 구성에서 사전 정의된 환경 변수 OS 가 uname -s 명령의 출력과 일치하지 않는 에지 케이스가 수정되었습니다.
수정 name 속성을 수정했습니다 OrGate의 속성이 이전에 예상 값 "or" 대신 "and" 문자열로 잘못 설정되어 이제 반환되는 것을 수정했습니다. 이 잘못된 값 "and" 은 AndGate.name 와 충돌하여 Orgate 사용과 관련하여 몇 가지 문제가 발생할 수 있으며 AndGate.
함수의 버그를 수정했습니다 qpy.load() 함수에서 파라미터가 같은 이름의 파라미터로 재할당된 회로를 역직렬화하지 못하는 버그가 수정되었습니다. 13720, #13720 및 #13720을 수정했습니다.
수정 GenericBackendV2 를 이제 BoxOp 를 생성자에서 지원되는 명령어 유형으로 포함하도록 수정했습니다 GenericBackendV2.target 키워드 인수가 생성자에서 control_flow=True 설정된 경우 지원되는 명령어 유형으로 포함되도록 수정했습니다.
컨트롤이 3개인 게이트를 합성할 때 MCXGate 게이트를 합성할 때, 합성 함수 synth_mcx_n_dirty_i15() 를 사용하면 보조 큐비트 1개가 필요해져 5개의 큐비트(제어 3개, 타겟 1개, 보조 1개)로 구성된 회로가 생성됩니다. 그러나 실제 합성 알고리즘은 이 보조 큐비트를 사용하지 않습니다. 이제 이 동작이 수정되어 합성 회로가 4 큐비트(제어 3, 타겟 1) 이상이므로 합성 기능을 약간 더 많은 경우에 적용할 수 있습니다.
그리고 QuantumCircuit.draw() 와 circuit_drawer() 함수는 이제 BoxOp 명령어를 QuantumCircuit 수직 스팬이 겹치지 않는 경우 가능한 경우 동일한 수직 슬라이스에 렌더링됩니다.
수정 QuantumCircuit.draw() 메서드 및 circuit_drawer() 메서드 및 함수를 수정하여 "mpl" 모드에서 왼쪽 가장자리 안쪽에 불필요한 공간을 덜 삽입하도록 수정했습니다 BoxOp 인스턴스를 그릴 때 QuantumCircuit.

기타 참고사항

새로운 선택적 추가 종속성 대상 qpy-compat 을 추가했습니다. 이 타겟은 이전 QPY 형식을 사용하는 파일을 로드하려는 경우 qpy 파일을 로드하려는 경우 이 타겟을 사용하세요. 대상은 포맷 버전 < 13. If you are only using newer QPY format versions you do no need to install this. The qpy.dump() only generates QPY > =13을 사용하여 QPY 파일을 로드하는 데 사용되는 추가 요구 사항을 설치합니다. 이것은 이전 ( 2.0.0 이전 ) 키스킷 릴리스에서 생성된 파일을 로드할 때만 필요합니다. pip install qiskit[qpy-compat] 으로 이 새로운 선택적 변형을 설치할 수 있습니다.
의 "기본" 및 "룩헤드" 구성 요소의 상대적 가중치는 SabreSwap 및 SabreLayout 휴리스틱의 상대적 가중치는 확장 세트 추적이 활성화될 때 수정되었습니다( SabreLayout에 있으며 기본적으로 SabreSwap). 이제 프론트 레이어의 개별 게이트에서 큐비트 사이의 거리와 관련된 휴리스틱 구성 요소는 더 이상 프론트 레이어의 게이트 수에 비례하여 약해지지 않습니다. 이 동작은 과거에 선택했던 것이지만 회로 크기가 클 경우 프론트 레이어가 거의 무시되는 우연한 효과가 발생하여 효율성에 재앙을 초래할 수 있습니다.

이러한 라우팅 개선은 20개 이상의 병렬 2큐비트 게이트로 계층화할 수 있는 회로에서 가장 두드러지게 나타납니다.

이 페이지가 도움이 되었습니까?

GitHub에서 버그, 오타를 보고하거나 컨텐츠를 요청하십시오.