키스킷 0.35 릴리즈 노트

0.35.0

테라 0.20.0

Prelude

키스킷 테라 0.20.0 릴리즈의 주요 내용은 다음과 같습니다:

키스킷 테라의 특정 부분의 성능을 가속화하고 더 많은 수의 큐비트로 확장성을 개선하기 위해 러스트로 작성된 멀티스레드 모듈을 도입했습니다. 그러나 소스에서 키스킷을 빌드할 때는 이제 Rust 컴파일러가 필요합니다.
작업에 대한 기본 지원 강화 Target 작업에 대한 네이티브 지원이 추가되었습니다. 이제 여러 패스가 객체와 직접 작업하는 것을 지원합니다 Target 객체로 직접 작업하는 것을 지원하므로 트랜스파일러가 타겟팅할 수 있는 백엔드 유형이 더욱 강력해졌습니다.
모듈의 도입 qiskit.primitives 모듈을 소개합니다. 이러한 API는 다음에서 관심 있는 출력을 계산하기 위한 다양한 추상화 수준을 제공합니다 QuantumCircuit 및 백엔드 사용에 대한 다양한 추상화 수준을 제공합니다. 예를 들어 BaseEstimator 는 관측값의 기대값을 추정하기 위한 추상 인터페이스를 정의합니다. 그런 다음 기대값을 계산하는 구현에 대해 걱정할 필요 없이 기대값 추정을 사용하여 구축된 상위 수준의 알고리즘과 애플리케이션을 구성하는 데 사용할 수 있습니다. 이러한 디커플링을 통해 정의된 추상 인터페이스를 준수하면서 구현의 속도와 품질을 개선할 수 있습니다. 마찬가지로 BaseSampler 는 회로 측정값으로부터 준확률 분포를 계산합니다. 다른 프리미티브는 향후 도입될 예정입니다.

이 릴리스에서는 더 이상 Python 3.6 을 지원하지 않습니다. 이 릴리스에서는 Python 3.7 ~ Python 3.10 이 필요합니다.

새 기능

클래스에 대한 새로운 생성자 메서드가 추가되었습니다 Operator 클래스에 새로운 생성자 메서드를 추가했습니다, Operator.from_circuit() 클래스에 새로운 생성자 메서드를 추가했습니다 Operator 객체를 생성하기 위한 QuantumCircuit. 일반적으로 기본 생성자를 사용하면 이 작업이 가능했지만 Operator.from_circuit() 메서드는 연산자 생성 방식을 조정할 수 있는 추가 옵션을 제공합니다. 주로 집합을 기반으로 큐비트 순서를 퍼뮤트할 수 있습니다 Layout. 예를 들어
```
from qiskit.circuit import QuantumCircuit
from qiskit import transpile
from qiskit.transpiler import CouplingMap
from qiskit.quantum_info import Operator

circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)

cmap = CouplingMap.from_line(3)
out_circuit = transpile(circuit, initial_layout=[2, 1, 0], coupling_map=cmap)
operator = Operator.from_circuit(out_circuit)
```
의 경우 operator 변수는 레이아웃에 따라 큐비트를 순열하여 번역 전 Operator(circuit) 에서 반환한 것과 동일하게 됩니다.
새로운 메서드 DAGCircuit.copy_empty_like() 메서드를 DAGCircuit 클래스에 새로운 메서드를 추가했습니다. 이 메서드는 기존 객체의 새 복사본을 만드는 데 사용됩니다 DAGCircuit 객체의 새 복사본을 만드는 데 사용됩니다. 이 메서드는 비공개 메서드 _copy_circuit_metadata() 와 동일하지만 이제 클래스의 공용 API의 일부가 되었습니다.
이전에 qiskit.test.mock 에서 사용할 수 있었던 가짜 백엔드 및 가짜 공급자 클래스는 이제 새 모듈에서도 액세스할 수 있습니다: qiskit.providers.fake_provider. 이 새로운 모듈은 키스킷 0.21.0 에서 더 이상 사용되지 않는 이전 모듈 qiskit.test.mock 을 대체합니다.
새로운 게이트 클래스를 추가했습니다, LinearFunction선형 함수(즉, 시퀀스로 표현할 수 있는 함수인 CXGate 및 SwapGate 게이트).
새로운 트랜스파일러 패스 추가 CollectLinearFunctions 연속된 블록을 수집하는 CXGate 및 SwapGate 게이트 블록을 수집하고 각 블록을 LinearFunction 게이트.
새로운 트랜스파일러 패스 추가 LinearFunctionsSynthesis 를 합성하는 새로운 트랜스파일러 패스 LinearFunction 게이트를 합성하는 새로운 트랜스파일러 패스를 추가했습니다. 트랜스파일러 패스와 결합하면 CollectLinearFunctions 트랜스파일러 패스와 결합하면 연속된 블록을 수집할 수 있습니다 CXGate 및 SwapGate 게이트 블록을 수집하고 Patel-Markov-Hayes 알고리즘을 사용하여 재합성할 수 있습니다.
새로운 트랜스파일러 패스가 추가되었습니다 LinearFunctionsToPermutations 를 대체하는 LinearFunction 게이트를 Permutation 회로로 대체하는 새로운 트랜스파일러 패스를 추가했습니다.

FlowController 클래스(예 ConditionalController)를 이제 인스턴스 안에 중첩할 수 있습니다 PassManager 인스턴스 안에 중첩할 수 있습니다 PassManager.append() 메서드를 사용할 때 인스턴스 안에 중첩할 수 있습니다. 이를 통해 중첩된 로직을 사용하여 패스의 실행을 제어할 수 있습니다 PassManager. 예를 들어,

from qiskit.transpiler import ConditionalController, PassManager
from qiskit.transpiler.passes import (
  BasisTranslator, GatesInBasis, Optimize1qGatesDecomposition, FixedPoint, Depth
)
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel

pm = PassManager()

def opt_control(property_set):
    return not property_set["depth_fixed_point"]

def unroll_condition(property_set):
    return not property_set["all_gates_in_basis"]

depth_check = [Depth(), FixedPoint("depth")]
opt = [Optimize1qGatesDecomposition(['rx', 'ry', 'rz', 'rxx'])]
unroll = [BasisTranslator(sel, ['rx', 'ry', 'rz', 'rxx'])]
unroll_check = [GatesInBasis(['rx', 'ry', 'rz', 'rxx'])]
flow_unroll = [ConditionalController(unroll, condition=unroll_condition)]

pm.append(depth_check + opt + unroll_check + flow_unroll, do_while=opt_control)

pmPassManager 객체는 각 루프 반복에서 BasisTranslator 전달( unroll 단계)은 unroll_condition 조건이 충족될 때만 각 루프 반복에서 실행됩니다.

의 생성자와 ZFeatureMap 와 ZZFeatureMap 클래스의 생성자에는 새로운 키워드 인수가 있습니다 parameter_prefix. 이 새로운 인수는 데이터 인코딩 회로의 매개변수 접두사를 설정하는 데 사용됩니다. 예를 들어,
```
from qiskit.circuit.library import ZFeatureMap

feature_map = ZFeatureMap(feature_dimension=4, parameter_prefix="my_prefix")
feature_map.decompose().draw('mpl')
```
생성된 ZFeatureMap 회로는 모든 내부 파라미터 앞에 접두사 "my_prefix" 를 붙였습니다.

이제 TemplateOptimization 트랜스파일러 패스는 이제 Gate 객체와 함께 작동할 수 있습니다 ParameterExpression 매개변수가 있는 오브젝트에서 작동합니다. 를 사용하는 예시 Parameter와 함께 TemplateOptimization 를 사용하는 예는 다음과 같습니다:

from qiskit import QuantumCircuit, transpile, schedule
from qiskit.circuit import Parameter

from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import TemplateOptimization

# New contributions to the template optimization
from qiskit.transpiler.passes.calibration import RZXCalibrationBuilder, rzx_templates

from qiskit.test.mock import FakeCasablanca
backend = FakeCasablanca()

phi = Parameter('φ')

qc = QuantumCircuit(2)
qc.cx(0,1)
qc.p(2*phi, 1)
qc.cx(0,1)
print('Original circuit:')
print(qc)

pass_ = TemplateOptimization(**rzx_templates.rzx_templates(['zz2']))
qc_cz = PassManager(pass_).run(qc)
print('ZX based circuit:')
print(qc_cz)

# Add the calibrations
pass_ = RZXCalibrationBuilder(backend)
cal_qc = PassManager(pass_).run(qc_cz.bind_parameters({phi: 0.12}))

# Transpile to the backend basis gates
cal_qct = transpile(cal_qc, backend)
qct = transpile(qc.bind_parameters({phi: 0.12}), backend)

# Compare the schedule durations
print('Duration of schedule with the calibration:')
print(schedule(cal_qct, backend).duration)
print('Duration of standard with two CNOT gates:')
print(schedule(qct, backend).duration)

출력

Original circuit:

q_0: ──■──────────────■──
     ┌─┴─┐┌────────┐┌─┴─┐
q_1: ┤ X ├┤ P(2*φ) ├┤ X ├
     └───┘└────────┘└───┘
ZX based circuit:
                                         ┌─────────────┐            »
q_0: ────────────────────────────────────┤0            ├────────────»
     ┌──────────┐┌──────────┐┌──────────┐│  Rzx(2.0*φ) │┌──────────┐»
q_1: ┤ Rz(-π/2) ├┤ Rx(-π/2) ├┤ Rz(-π/2) ├┤1            ├┤ Rx(-2*φ) ├»
     └──────────┘└──────────┘└──────────┘└─────────────┘└──────────┘»
«
«q_0: ────────────────────────────────────────────────
«     ┌──────────┐┌──────────┐┌──────────┐┌──────────┐
«q_1: ┤ Rz(-π/2) ├┤ Rx(-π/2) ├┤ Rz(-π/2) ├┤ P(2.0*φ) ├
«     └──────────┘└──────────┘└──────────┘└──────────┘
Duration of schedule with the calibration:
1600
Duration of standard with two CNOT gates:
6848

그리고 DAGOpNode, DAGInNode 및 DAGOutNode 클래스는 이제 표현을 출력하는 사용자 정의 __repr__ 메서드를 정의합니다. Python 문서에 따르면 출력은 동등한 객체를 만드는 데 사용되는 Python 문자열과 거의 동일한 문자열 표현입니다.
메서드의 성능이 크게 향상되었습니다 SparsePauliOp.simplify() 메서드의 성능은 배열의 고유 요소를 계산하는 numpy.unique 사용을 배열을 미리 정렬하지 않는 새로운 유사한 함수로 대체하여 크게 향상되었습니다.
새로운 메서드 equiv() 메서드를 SparsePauliOp 클래스에 동등성을 테스트하기 위한 SparsePauliOp 와 다른 SparsePauliOp 객체와의 동등성을 테스트하는 메서드를 추가했습니다. 연산자를 요소별로 비교하는 == 연산자와 달리, equiv() 는 두 연산자가 동등한지 여부를 비교합니다. 예를 들어,
```
op = SparsePauliOp.from_list([("X", 1), ("Y", 1)])
op2 = SparsePauliOp.from_list([("X", 1), ("Y", 1), ("Z", 0)])
op3 = SparsePauliOp.from_list([("Y", 1), ("X", 1)])

print(op == op2)  # False
print(op == op3)  # False
print(op.equiv(op2))  # True
print(op.equiv(op3))  # True
```
IBM Quantum 시스템의 스냅샷에서 새로운 가짜 백엔드 클래스를 추가했습니다 BackendV2 인터페이스를 기반으로 새로운 가짜 백엔드 클래스를 추가하고 Target 를 제공했습니다. BackendV2 를 기반으로 새로운 가짜 백엔드 클래스를 만드는 데 필요한 스냅샷 파일이 없기 때문에 기존 백엔드 FakeRueschlikon, FakeTenerife 및 FakeTokyo 를 제외한 모든 백엔드의 기반 버전이 추가됩니다 BackendV2.

이 새로운 V2 가짜 백엔드를 사용하면 다음에서 도입한 새로운 기능을 테스트하고 개발할 수 있습니다 BackendV2 및 Target 트랜스파일러 개선과 같은 새로운 기능을 테스트하고 개발할 수 있습니다.
회로 라이브러리에 새로운 게이트 클래스 XXMinusYYGate 를 회로 라이브러리(qiskit.circuit.library)에 XX-YY 상호작용을 위한 새로운 게이트 클래스를 추가했습니다. 이 게이트는 bSwap 게이트와 그 권한을 구현하는 데 사용할 수 있습니다. 이는 초전도 페르미온 모델 시뮬레이션에서도 발생합니다.
새로운 게이트 클래스를 추가했습니다, XXPlusYYGate를 회로 라이브러리(qiskit.circuit.library). 이 게이트는 2쿼비트 매개변수화된 XX+YY 상호 작용으로, XY 게이트라고도 하며, 에 설명된 게이트를 기반으로 합니다 https://arxiv.org/abs/1912.04424.
qiskit.providers.fake_provider 모듈에서 찾을 수 있는 FakeBogota, FakeManila, FakeRome, FakeSantiago 가짜 백엔드는 이제 펄스 실험에서 백엔드로 사용할 수 있습니다 PulseDefaults 동등한 IBM Quantum 머신의 속성의 스냅샷에서 생성되었습니다.
패스에는 ConsolidateBlocks 패스의 생성자에는 새로운 키워드 인수가 있습니다( target). 이 인수는 패스의 컴파일 대상을 나타내는 Target 객체를 지정하는 데 사용됩니다. 지정하면 basis_gates kwarg를 대체합니다. 타겟이 지정되면 패스는 단일 게이트로 통합할 게이트를 결정할 때 Target 에 정의된 명령에 대한 게이트와 큐비트를 존중합니다.
클래스에는 Target 클래스에는 새로운 메서드가 있습니다, instruction_supported() 이 메서드는 타깃을 쿼리하여 명령어(연산과 그 연산이 실행되는 큐비트의 조합)가 모델링된 백엔드에서 지원되는지 확인하는 데 사용됩니다 Target.

새로운 kwarg, metadata_serializer 를 추가했습니다 qpy.dump() 속성을 직렬화할 때 사용할 사용자 정의 JSONEncoder 서브클래스를 지정하기 위한 함수에 QuantumCircuit.metadata 어트리뷰트를 직렬화할 때 사용할 수 있도록 새로운 kwarg metadata_deserializer 를 추가했습니다 qpy.load() 함수에 JSONDecoder 서브클래스를 지정하는 함수를 추가했습니다. 기본적으로 dump() 와 load() 함수는 stdlib 기본 json 인코더 및 디코더를 사용하여 JSON 직렬화 및 역직렬화를 시도합니다. 이후 QuantumCircuit.metadata 에는 모든 Python 사전이 포함될 수 있으므로 기본 인코더로 직렬화할 수 없는 내용이 포함된 경우에도 직렬화할 수 없는 회로로 이어질 수 있습니다. 에 대한 새로운 metadata_serializer 인수는 dump() 에 대한 새로운 JSONEncoder 인수를 사용하면 사용자가 내부 json.dump() 호출과 함께 사용할 사용자 지정 을 지정할 수 있습니다 QuantumCircuit.metadata 사전. 그런 다음 새로운 metadata_deserializer 인수와 결합하여 qpy.load() 함수의 새로운 인수와 결합하여 해당 커스텀 JSON 인코딩을 디코딩할 수 있습니다. metadata_serializer 에 지정되어 있지만 dump() 에 지정되었지만 metadata_deserializer 가 지정되지 않은 경우 load() 호출하면 QPY가 로드되지만 회로 메타데이터가 완전히 재구성되지 않을 수 있습니다.

예를 들어 메타데이터에 대한 사용자 지정 직렬화를 정의한 다음 로드하려는 경우 다음과 같이 할 수 있습니다:

from qiskit.qpy import dump, load
from qiskit.circuit import QuantumCircuit, Parameter
import json
import io

class CustomObject:
    """Custom string container object."""

    def __init__(self, string):
        self.string = string

    def __eq__(self, other):
        return self.string == other.string

class CustomSerializer(json.JSONEncoder):
    """Custom json encoder to handle CustomObject."""

    def default(self, o):
        if isinstance(o, CustomObject):
            return {"__type__": "Custom", "value": o.string}
        return json.JSONEncoder.default(self, o)

class CustomDeserializer(json.JSONDecoder):
    """Custom json decoder to handle CustomObject."""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, object_hook=self.object_hook, **kwargs)

    def object_hook(self, o):
        """Hook to override default decoder."""
        if "__type__" in o:
            obj_type = o["__type__"]
            if obj_type == "Custom":
                return CustomObject(o["value"])
        return o

theta = Parameter("theta")
qc = QuantumCircuit(2, global_phase=theta)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
circuits = [qc, qc.copy()]
circuits[0].metadata = {"key": CustomObject("Circuit 1")}
circuits[1].metadata = {"key": CustomObject("Circuit 2")}
with io.BytesIO() as qpy_buf:
    dump(circuits, qpy_buf, metadata_serializer=CustomSerializer)
    qpy_buf.seek(0)
    new_circuits = load(qpy_buf, metadata_deserializer=CustomDeserializer)

패스에는 DenseLayout 패스의 생성자에는 새로운 키워드 인수가 있습니다( target). 이 인수는 패스의 컴파일 대상을 나타내는 Target 객체를 지정하는 데 사용됩니다. 이 인수를 지정하면 생성자의 다른 인수인 coupling_map 및 backend_prop 을 대체합니다.
클래스에는 Target 클래스에는 새로운 메서드가 있습니다, operation_names_for_qargs(). 이 메서드는 지정된 qargs 튜플에 대한 연산에 대한 연산 이름(즉, 대상의 조회 키)을 가져오는 데 사용됩니다.
모듈에 새 패스 DynamicalDecouplingPadding 가 추가되었습니다 qiskit.transpiler.passes 모듈에 추가되었습니다. 이 새 패스는 기존 패스를 대체합니다 DynamicalDecoupling 패스를 대체하여 트랜스파일러의 새로운 스케줄링 워크플로우로 작업할 수 있습니다. BasePadding 패스의 서브클래스이며, 스케줄링 및 정렬 분석 패스가 그 전에 실행되는 것에 따라 PassManager. 이 새로운 패스는 파형 시작 타이밍에 대한 하드웨어 제약 조건을 나타내는 pulse_alignment 인수를 사용할 수 있습니다. 이제 동적 디커플링 시퀀스를 구성하는 게이트 사이의 간격이 이 제약 조건을 충족하도록 조정되어 제약 조건이 있는 하드웨어에서 회로가 실행될 수 있습니다. 이 값은 일반적으로 BackendConfiguration.timing_constraints 에서 찾을 수 있습니다. 또한 이 패스에는 생성된 동적 디커플링 시퀀스의 지속 시간이 시퀀스로 채우려는 회로의 유휴 시간보다 짧을 때 여분의 여유를 분배하는 방법을 제어하는 extra_slack_distribution 옵션도 있습니다. 기본값은 기존 동작과 동일한 middle 입니다. 새로운 전략 split_edges 은 여분의 여유 시간을 시퀀스 중간에 추가하지 않고 시퀀스의 시작과 끝에 균등하게 분배합니다. 특히 pulse_alignment > 1일 때 노이즈 캔슬링이 더 잘 될 수 있습니다.
클래스는 이제 Z2Symmetries 클래스는 이제 계수의 작은 실수 및 허수 부분을 자르는 데 사용되는 임계값 허용 오차를 노출합니다. 이를 통해 테이퍼 연산자의 계수가 단순화되는 방식을 제어할 수 있습니다. 예를 들어,
```
from qiskit.opflow import Z2Symmetries
from qiskit.quantum_info import Pauli

z2_symmetries = Z2Symmetries(
    symmetries=[Pauli("IIZI"), Pauli("IZIZ"), Pauli("ZIII")],
    sq_paulis=[Pauli("IIXI"), Pauli("IIIX"), Pauli("XIII")],
    sq_list=[1, 0, 3],
    tapering_values=[1, -1, -1],
    tol=1e-10,
)
```
기본적으로 계수는 tol=1e-14 의 허용 오차로 잘게 잘립니다.

메서드를 추가했습니다 chop() 메서드를 추가했습니다 SparsePauliOp 클래스에 계수의 실수 부분과 허수 부분을 개별적으로 잘라내는 메서드를 추가했습니다. 이는 절대값이 0에 가까울 때만 계수를 제거하는 SparsePauliOp.simplify() 메서드는 절대값이 0에 가까운 경우에만 계수를 제거합니다. 예를 들어,

>>> from qiskit.quantum_info import SparsePauliOp
>>> op = SparsePauliOp(["X", "Y", "Z"], coeffs=[1+1e-17j, 1e-17+1j, 1e-17])
>>> op.simplify()
SparsePauliOp(['X', 'Y'],
              coeffs=[1.e+00+1.e-17j, 1.e-17+1.e+00j])
>>> op.chop()
SparsePauliOp(['X', 'Y'],
              coeffs=[1.+0.j, 0.+1.j])

촙 메서드는 동일한 폴리스의 계수를 누적하지 않습니다.

>>> op = SparsePauliOp(["X", "X"], coeffs=[1+1e-17j, 1e-17+1j)
>>> op.chop()
SparsePauliOp(['X', 'X'],
              coeffs=[1.+0.j, 0.+1.j])

트랜스파일러 패스의 생성자에 새로운 kwarg( target)를 추가했습니다 GatesInBasis 트랜스파일러 패스의 생성자에 추가했습니다. 이 새로운 인수를 사용하여 선택적으로 백엔드를 나타내는 Target 객체를 지정하는 데 사용할 수 있습니다. 이 설정하면 Target 를 설정하면 DAGCircuit 에 기본 집합 외부의 게이트가 포함되어 있는지 여부를 결정하는 데 사용되며 basis_gates 인수는 사용되지 않습니다.
ppc64le 및 s390x Linux 플랫폼에서 실행에 대한 부분 지원이 추가되었습니다. 이번 릴리스에서는 ppc64le 및 s390x Linux 플랫폼용 사전 컴파일된 바이너리를 모든 Python 버전에 게시하기 시작합니다. 그러나 다른 지원 플랫폼과 달리 키스킷의 모든 업스트림 종속성이 아직 이러한 플랫폼을 지원하는 것은 아닙니다. 따라서 이러한 종속성을 빌드하고 설치하려면 C/C++ 컴파일러가 필요할 수 있으며, Python 환경이 작동하는 간단한 pip install qiskit-terra 만으로는 키스킷을 설치하기에 충분하지 않습니다. 또한 이러한 제약으로 인해 사전 컴파일된 휠을 게시하기 전에 테스트할 수 없으므로 다른 플랫폼에 적용되는 플랫폼 지원과 동일한 보증이 여기에는 적용되지 않습니다.
그리고 Gradient 와 QFI 클래스는 이제 기대값 그래디언트의 가상 부분을 계산할 수 있습니다. 다른 측정 기준을 사용하는 경우(예 -Y 대신 Z 을 사용하여 그라디언트의 가상 부분을 측정할 수 있습니다. 측정 기준은 aux_meas_op 인수를 사용하여 설정할 수 있습니다.

그라디언트의 경우 aux_meas_op = Z 은 0.5Re[(⟨ψ(ω)|)O(θ)|dωψ(ω)〉] 을 계산하고 aux_meas_op = -Y 은 0.5Im[(⟨ψ(ω)|)O(θ)|dωψ(ω)〉] 을 계산합니다. QFI의 경우 aux_meas_op = Z 은 4Re[(dω⟨<ψ(ω)|)(dω|ψ(ω)〉)] 을 계산하고 aux_meas_op = -Y 은 4Im[(dω⟨<ψ(ω)|)(dω|ψ(ω)〉)] 을 계산합니다. 예를 들어,
```
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.opflow import CircuitStateFn, Y
from qiskit.opflow.gradients.circuit_gradients import LinComb
from qiskit.circuit import Parameter

a = Parameter("a")
b = Parameter("b")
params = [a, b]

q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(params[0], q[0])
qc.rx(params[1], q[0])
op = CircuitStateFn(primitive=qc, coeff=1.0)

aux_meas_op = -Y

prob_grad = LinComb(aux_meas_op=aux_meas_op).convert(operator=op, params=params)
```
클래스는 이제 InstructionDurations 클래스는 이제 인스트럭션의 매개변수 작업을 지원합니다. 객체의 각 항목은 이제 InstructionDurations 객체의 각 항목은 이제 (inst_name, qubits, duration, parameters, unit) 의 튜플로 구성됩니다. 이를 통해 InstructionDurations 를 사용하여 특정 매개변수 값이 주어진 명령어의 지속 시간을 정의하여 숫자 매개변수를 사용하는 명령어에서 다른 매개변수 값으로 다른 지속 시간을 고려할 수 있습니다.
회로 서랍 함수에 style 키워드 인수에 새 값을 추가했습니다 circuit_drawer() 와 QuantumCircuit.draw() 메서드에 iqx_dark 키워드 인수를 추가했습니다. mpl 서랍 백엔드를 사용하여 style 을 iqx_dark 으로 설정하면 출력 시각화는 IBM Quantum 작성기에서 사용하는 어두운 모드 색 구성표와 유사한 색 구성표를 사용합니다. 예를 들어,
```
from qiskit.circuit import QuantumCircuit
from matplotlib.pyplot import show

circuit = QuantumCircuit(2)
circuit.h(0)
circuit.cx(0, 1)
circuit.p(0.2, 1)

circuit.draw("mpl", style="iqx-dark")
```
새로운 모듈에 몇 가지 지연 종속성 검사기가 추가되었습니다 qiskit.utils.optionals특정 키스킷 기능을 사용할 수 있는지 쿼리하는 데 사용할 수 있습니다. 예를 들어, 키스킷이 matplotlib 의 존재를 감지했는지 if qiskit.utils.optionals.HAS_MATPLOTLIB 으로 물어볼 수 있습니다. 이러한 객체는 쿼리될 때만 해당 종속성을 가져오려고 시도하므로 가져오기 시간에 영향을 주지 않고 런타임 코드에서 사용할 수 있습니다.
의 가져오기 시간이 qiskit 의 가져오기 시간이 크게 개선되었으며, 특히 키스킷 테라의 선택적 종속성이 많이 설치되어 있는 경우 더욱 그렇습니다.
이제 marginal_counts() 함수는 이제 입력 객체의 memory 필드 여백을 지원합니다 Result 객체의 필드 여백을 지원합니다. 예를 들어, 입력 result 인자가 4비트 측정에서 얻은 qiskit Result 객체이면 첫 번째 큐비트로 한계화할 수 있습니다:
```
print(result.results[0].data.memory)
marginal_result = marginal_counts(result, [0])
print(marginal_result.results[0].data.memory)
```
출력은 다음과 같습니다.
```
['0x0', '0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7']
['0x0', '0x1', '0x0', '0x1', '0x0', '0x1', '0x0', '0x1']
```
알고리즘의 내부는 StochasticSwap 알고리즘의 내부가 멀티스레드로 재구현되었으며, 이제 Cython 대신 Rust 프로그래밍 언어로 작성되었습니다. 이렇게 하면 컴파일러 패스의 런타임 성능이 크게 향상되며, 더 확장하면 transpile()optimization_level 를 0, 1, 2로 실행할 때 더욱 향상됩니다. 기본적으로 패스는 로컬 시스템의 논리적 CPU 수까지 사용하지만 RAYON_NUM_THREADS 환경 변수를 정수 값으로 설정하여 패스에서 사용하는 스레드 수를 제어할 수 있습니다. 예를 들어 RAYON_NUM_THREADS=4 설정하면 StochasticSwap 를 4개의 스레드로 실행합니다.
새로운 환경 변수 QISKIT_FORCE_THREADS 를 사용하여 사용자가 키스킷 코드의 잠재적인 멀티스레드 부분을 멀티스레드에서 실행할지 여부를 직접 제어할 수 있습니다. 현재는 트랜스파일러 패스에만 사용되지만 StochasticSwap 트랜스파일러 패스에서만 사용되지만 향후에는 키스킷의 다른 부분에서도 사용될 가능성이 높습니다. 이 환경 변수를 TRUE 로 설정하면 키스킷 테라의 모든 멀티스레드 코드는 다른 런타임 조건에 따라 함수가 단일 스레드 변형을 사용하게 될 수도 있는 다른 조건에 관계없이 항상 다중 스레드를 사용합니다. 예를 들어 StochasticSwap 패스가 1 회로를 초과하는 호출의 일부로 실행되는 경우 transpile() 를 통해 multiprocessing 와 병렬로 실행되는 1 개 이상의 회로를 가진 호출의 일부로 parallel_map() 를 통해 StochasticSwap 는 잠재적인 CPU 리소스 초과를 피하기 위해 여러 스레드를 사용하지 않습니다. 그러나 패스에서 여러 스레드를 여러 프로세스와 함께 사용하려면 QISKIT_FORCE_THREADS=TRUE 을 설정하면 됩니다.
새로운 가짜 백엔드 클래스는 qiskit.providers.fake_provider 에서 확인할 수 있습니다. 여기에는 ibm_cairo, ibm_hanoi, ibmq_kolkata, ibm_nairobi, ibm_washington 의 모의 버전이 포함됩니다. 다른 가짜 백엔드와 마찬가지로 실제 시스템에서 가져온 보정 및 오류 데이터의 스냅샷을 포함하며 로컬 테스트, 컴파일 및 시뮬레이션에 사용할 수 있습니다.

새로운 클래스 소개 StatePreparation. 이 클래스를 사용하면 재설정이 자동으로 적용되지 않고 Initialize 와 동일한 방식으로 원하는 상태를 준비할 수 있습니다.

예를 들어, 상태에서 큐비트를 준비하려면 $(|0\rangle - |1\rangle) / \sqrt{2}$ :

import numpy as np
from qiskit import QuantumCircuit

circuit = QuantumCircuit(1)
circuit.prepare_state([1/np.sqrt(2), -1/np.sqrt(2)], 0)
circuit.draw()

출력은 다음과 같습니다:

     ┌─────────────────────────────────────┐
q_0: ┤ State Preparation(0.70711,-0.70711) ├
     └─────────────────────────────────────┘

이제 Optimize1qGates 트랜스파일러 패스에 이제 최적화 기능이 지원됩니다 U1Gate, U2Gate및 PhaseGate 게이트 최적화를 지원합니다. 이전에는 이러한 게이트에 바인딩되지 않은 매개변수가 있는 경우 패스에서 해당 매개변수를 사용하지 않았습니다. 예를 들어,

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Optimize1qGates, Unroller

phi = Parameter('φ')
alpha = Parameter('α')

qc = QuantumCircuit(1)
qc.u1(2*phi, 0)
qc.u1(alpha, 0)
qc.u1(0.1, 0)
qc.u1(0.2, 0)

pm = PassManager([Unroller(['u1', 'cx']), Optimize1qGates()])
nqc = pm.run(qc)

는 단 하나의 단일 큐비트 게이트로 회로에 결합됩니다:

qc = QuantumCircuit(1)
qc.u1(2*phi + alpha + 0.3, 0)

메소드 Pauli.evolve() 와 PauliList.evolve() 에는 이제 새로운 키워드 인자 frame 가 추가되어 클리포드에 의한 폴리의 진화를 수행하는 데 사용됩니다. frame='h' (기본값)이면 클리포드에 의한 파울리의 하이젠베르크 그림 진화( $P' = C^\dagger P C$ )를, frame='s' 이면 클리포드에 의한 파울리의 슈뢰딩거 그림 진화( $P' = C P C^\dagger$ )를 수행합니다. 후자의 옵션은 계산 속도가 더 빠르며 특정 경우에 유용합니다. 이 새로운 옵션을 사용하면 decompose_clifford 에서 욕심 많은 클리포드 분해 방법을 훨씬 빠르게 계산할 수 있습니다.
키스킷에 새 모듈을 추가했습니다: qiskit.primitives. 프리미티브 모듈은 QuantumCircuit 에서 기본 실행의 세부 사항을 추상화하는 것과는 다른 특정 공통 함수 계산에 대한 다양한 추상화를 제공하는 API를 정의하는 곳입니다( Backend). 이를 통해 상위 수준의 알고리즘과 애플리케이션은 결과의 실행과 처리에 대해 걱정할 필요 없이 계산 수행에만 집중할 수 있으며, 일반적인 계산을 위한 표준화된 인터페이스를 갖게 됩니다. 예를 들어, 양자 회로와 관측 가능성의 기대값을 추정하는 작업은 해당 클래스를 구현하는 모든 클래스에서 수행할 수 있습니다 BaseEstimator 클래스를 구현하는 모든 클래스에서 수행할 수 있으며 기본 구현에 관계없이 표준화된 방식으로 소비됩니다. 그런 다음 원시 인터페이스를 사용하여 애플리케이션을 직접 작성할 수 있습니다.

모듈을 시작하려면 두 가지 유형의 프리미티브가 포함되어 있습니다 Sampler (추상 클래스 정의는 BaseSampler 참조)와 Estimator (추상 클래스 정의는 BaseEstimator 참조)와 (추상 클래스 정의는 참조 구현은 모듈에 포함되어 있으며 qiskit.primitives 모듈에 포함되어 있으며 qiskit.quantum_info 모듈을 사용하여 구축되며, 원시 연산의 이상적인 시뮬레이션을 수행합니다. 공급자 패키지는 프로토콜을 기본적으로 효율적으로 구현할 수 있는 공급자를 위해 이러한 인터페이스의 자체 구현을 제공할 것으로 예상됩니다(일반적으로 클래식 런타임을 사용). 또한 프리미티브의 기본 구현을 제공하지 않는 공급자의 경우 향후에는 프리미티브 객체를 구성할 수 있는 메서드가 제공될 것입니다 Backend.
새 모듈을 추가했습니다, qiskit.qpy에 이전에 qiskit.circuit.qpy_serialization 에 노출된 기능을 포함하는 새로운 모듈이 추가되었습니다. 이전에는 qiskit.circuit.qpy_serialization 에서 공개 기능이 노출되었습니다, dump() 와 load() 는 이제 이 새 모듈에서 사용할 수 있습니다( qiskit.circuit.qpy_serialization 에서도 여전히 액세스할 수 있지만 향후 릴리스에서 더 이상 사용되지 않을 예정입니다). 이 새로운 모듈은 QPY 파일 형식의 향후 방향성을 위해 추가되었으며, 향후 버전에서는 다음과 같은 표현을 지원할 예정입니다 pulse Schedule 와 ScheduleBlock 객체 외에도 QuantumCircuit 객체를 지원할 예정입니다.
새 속성을 추가했습니다, qubit_properties 속성을 Target 클래스에 새로운 속성을 추가했습니다. 이 어트리뷰트에는 대상의 각 큐비트에 대한 QubitProperties 오브젝트 목록을 포함합니다. 예를 들어,
```
target.qubit_properties[2]
```
에는 대상의 QubitProperties 를 포함하게 됩니다.

For BackendV2 작성자의 경우, 이전에 직접 정의했다면 QubitProperties 를 직접 정의했다면 BackendV2 구현을 재정의하여 BackendV2.qubit_properties() 를 재정의하여 직접 정의했다면 여전히 정상적으로 작동합니다. 그러나 정의를 기본 객체로 이동하고 특수화된 Target 객체로 옮기고 특수한 BackendV2.qubit_properties() 구현을 제거하면 트랜스파일러에서 큐비트 프로퍼티를 사용할 수 있고 이전 구현과의 API 호환성도 유지됩니다.
새로운 함수가 추가되었습니다, qiskit.algorithms.eval_observables()바운드가 주어진 관측값을 평가하는 데 사용되는 새로운 함수인 QuantumCircuit. 클래스의 비공개 메서드인 _eval_aux_ops() 에서 비롯되었지만 qiskit.algorithms.VQE 클래스의 비공개 메서드에서 유래했지만 새로운 eval_observables() 함수는 이제 더 일반적이므로 시간 진화 알고리즘과 같은 다른 알고리즘에서 사용할 수 있습니다.
트랜스파일러 패스의 기준 검색 전략이 BasisTranslator 트랜스파일러 패스의 기저 검색 전략이 도달할 수 없는 기저를 타겟팅하려고 할 때 패스의 런타임 성능을 크게 향상시키는 Dijkstra 검색의 변형으로 수정되었습니다.
트랜스파일러 패스의 DenseLayout 트랜스파일러 패스가 이제 멀티스레드화되어 패스의 런타임 성능이 크게 향상되었습니다. 기본적으로 로컬 시스템의 논리적 CPU 수를 사용하지만 RAYON_NUM_THREADS 환경 변수를 정수 값으로 설정하여 패스에 사용되는 스레드 수를 제어할 수 있습니다. 예를 들어 RAYON_NUM_THREADS=4 설정하면 4개의 스레드로 DenseLayout 패스를 4개의 스레드로 실행합니다.
의 내부 계산은 Statevector.expectation_value() 및 DensityMatrix.expectation_value() 메서드의 내부 계산이 Rust 프로그래밍 언어로 다시 구현되었습니다. 이 새로운 구현은 멀티 스레드이며 기본적으로 Statevector 또는 DensityMatrix >= 19 큐비트인 경우 로컬 시스템에서 사용 가능한 논리적 CPU 수로 스레드 풀을 생성합니다. RAYON_NUM_THREADS 환경 변수를 정수 값으로 설정하여 사용하는 스레드 수를 제어할 수 있습니다. 예를 들어 RAYON_NUM_THREADS=4 을 설정하면 스레드 풀에서 4개의 스레드만 사용됩니다.
새로운 SparsePauliOp.from_sparse_list() 이터러블을 취하는 생성자를 추가했는데, 여기서 요소는 그 자체가 희박한 폴리 항을 나타내므로 이제 "XIIIIIIIIIIIIIIIX" 을 ("XX", [0, 16]) 으로 작성할 수 있습니다. 예를 들어, 운영자

H = X_0 Z_3 + 2 Y_1 Y_4

이제 다음과 같이 구성할 수 있습니다

op = SparsePauliOp.from_sparse_list([("XZ", [0, 3], 1), ("YY", [1, 4], 2)], num_qubits=5)
# or equivalently, as previously
op = SparsePauliOp.from_list([("IZIIX", 1), ("YIIYI", 2)])

이는 종종 아이싱 해밀턴의 경우처럼 많은 큐비트에서 매우 희박한 연산자를 구축하는 것을 용이하게 합니다.

트랜스파일러 패스의 UnitarySynthesis 트랜스파일러 패스의 생성자에는 새로운 키워드 인수가 있습니다( target). 이것은 선택적으로 패스의 컴파일 대상을 나타내는 Target 객체를 컴파일 대상으로 지정하는 데 사용할 수 있습니다. 이 값을 지정하면 basis_gates, coupling_map, backend_props 에 설정된 값을 대체합니다.
추상 플러그인 클래스의 UnitarySynthesisPlugin 추상 플러그인 클래스에는 구현이 추가할 수 있는 새로운 선택적 어트리뷰트가 있습니다, supports_target. 플러그인에 이 속성이 True 로 설정되어 있으면 Target 객체가 target 필드 아래의 options 페이로드에 전달됩니다. 예상되는 것은 이 Target 객체가 coupling_map, gate_lengths, basis_gates, gate_errors 대신 사용될 것으로 예상됩니다.
새로운 트랜스파일러 패스 워크플로우 도입 PassManager 오브젝트를 빌드하기 위한 QuantumCircuit 오브젝트를 빌드하기 위한 새로운 트랜스파일러 패스 워크플로를 도입했습니다. 새로운 워크플로 스케줄링 및 정렬 패스는 모두 AnalysisPass 객체, 특히 각 옵노드의 절대 시작 시간을 보유하는 새로운 속성 세트 항목 node_start_time 만 업데이트합니다. 별도의 TransformationPass 와 같은 PadDelay 를 사용하여 DAG에 스케줄링을 적용합니다. 이 새로운 워크플로는 더 효율적이며 백엔드에 의해 노출되는 추가적인 타이밍 제약을 해결할 수 있습니다.

이전에는 패스 체인이 scheduling -> alignment 으로 구현되었지만 두 트랜스폼 패스 모두에 해당하므로 각 패스마다 여러 개의 DAGCircuit 인스턴스가 여러 개 생성되었습니다. 또한 교육 시작 시간을 얻기 위해 각 패스마다 스케줄링이 발생했습니다. 이제 필요한 패스 체인은 scheduling -> alignment -> padding 이 되고 DAGCircuit 업데이트는 padding 패스가 있는 마지막에만 발생합니다.

사용자 정의 객체를 만드는 경우 PassManager 객체를 생성하는 사용자의 경우 PassManager 를 사용하여 BasePadding 패스 중 하나를 삽입해야 합니다(현재 PadDelay 또는 PadDynamicalDecoupling 사용 가능) 중 하나를 스케줄링 패스 체인의 끝에 삽입해야 합니다. 패딩 패스가 없으면 스케줄링 패스는 사용자 정의 메서드의 출력 회로에 반영되지 않습니다 run() 메서드의 출력 회로에 반영되지 않습니다 PassManager.

예를 들어, 이전에 다음과 같이 PassManager 같은 것을 사용했다면
```
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import TimeUnitConversion, ALAPSchedule, ValidatePulseGates, AlignMeasures

pm = PassManager()
scheduling = [
    ALAPSchedule(instruction_durations), PadDelay()),
    ValidatePulseGates(granularity=timing_constraints.granularity, min_length=timing_constraints.min_length),
    AlignMeasures(alignment=timing_constraints.acquire_alignment),
]
pm.append(scheduling)
```
대신 사용할 수 있습니다:
```
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import TimeUnitConversion, ALAPScheduleAnalysis, ValidatePulseGates, AlignMeasures, PadDelay

pm = PassManager()
scheduling = [
    ALAPScheduleAnalysis(instruction_durations), PadDelay()),
    ConstrainedReschedule(acquire_alignment=timing_constraints.acquire_alignment, pulse_alignment=timing_constraints.pulse_alignment),
    ValidatePulseGates(granularity=timing_constraints.granularity, min_length=timing_constraints.min_length),
    PadDelay()
]
pm.append(scheduling)
```
를 사용하면 더 효율적이고 하드웨어 제약 조건에 따라 명령어를 정렬할 수 있습니다.
새로운 트랜스파일러 패스 추가 ConstrainedReschedule 패스를 추가했습니다. 패스는 ConstrainedReschedule 패스는 객체에서 정의할 수 있는 하드웨어 정렬 제약 조건을 모두 고려합니다 BackendConfiguration 객체, pulse_alignment 및 acquire_alignment 에서 정의할 수 있습니다. 이 새로운 클래스는 기존의 기존 클래스를 대체합니다 AlignMeasures 클래스를 대체하며, 일반 명령어 정렬 외에도 측정 명령어에 대해 동일한 정렬(속성 세트를 통해)을 수행합니다. acquire_alignment 제약 조건 인수를 설정하면 ConstrainedReschedule 패스에 대한 제약 조건 인수를 설정하면 AlignMeasures 를 새 BasePadding 패스로 대체합니다.
새로운 트랜스파일러 패스 2종 추가 ALAPScheduleAnalysis 와 ASAPScheduleAnalysis 를 대체하는 ALAPSchedule 및 ASAPSchedule 를 대체하는 새로운 트랜스파일러 패스가 스케줄링 워크플로의 일부로 추가되었습니다. 새 패스는 동일한 스케줄링을 수행하지만 속성 세트에서 BasePadding 패스에 의존하여 모든 스케줄링 정렬 분석을 기반으로 회로를 조정합니다.

이러한 패스의 표준 동작은 또한 타이밍 순서를 DAG 노드의 토폴로지 순서와 일치시킵니다. 이 변경 사항은 조건부 연산을 포함하거나 동일한 클래식 레지스터(에지 케이스)로 두 개의 큐비트를 동시에 측정하는 경우 스케줄링 결과에 영향을 미칠 수 있습니다. 기존 동작을 재현하려면 측정 명령어 길이와 동일하게 clbit_write_latency 를 설정합니다.

예를 들어 다음과 같은 입력 회로를 예약한다고 가정해 보겠습니다:
```
     ┌───┐┌─┐
q_0: ┤ X ├┤M├──────────────
     └───┘└╥┘   ┌───┐
q_1: ──────╫────┤ X ├──────
           ║    └─╥─┘   ┌─┐
q_2: ──────╫──────╫─────┤M├
           ║ ┌────╨────┐└╥┘
c: 1/══════╩═╡ c_0=0x1 ╞═╩═
           0 └─────────┘ 0
```
```
from qiskit import QuantumCircuit
from qiskit.transpiler import InstructionDurations, PassManager
from qiskit.transpiler.passes import ALAPScheduleAnalysis, PadDelay, SetIOLatency
from qiskit.visualization.timeline import draw

circuit = QuantumCircuit(3, 1)
circuit.x(0)
circuit.measure(0, 0)
circuit.x(1).c_if(0, 1)
circuit.measure(2, 0)

durations = InstructionDurations([("x", None, 160), ("measure", None, 800)])

pm = PassManager(
    [
      SetIOLatency(clbit_write_latency=800, conditional_latency=0),
      ALAPScheduleAnalysis(durations),
      PadDelay(),
    ]
)
draw(pm.run(circuit))
```
타임라인 보기에서 볼 수 있듯이 q_2 의 측정은 q_1 의 조건부 X 게이트보다 먼저 시작되며, 이는 노드의 토폴로지적 순서와 반대되는 것처럼 보입니다. Clbit 쓰기 액세스는 측정 명령의 끝 에지에서 발생하고 조건부 게이트의 읽기 액세스는 명령의 시작 에지에서 발생하므로 이 또한 예상되는 동작입니다. 따라서 타임라인 보기에서 캡처되지 않는 클래식 레지스터의 타임슬롯에 토폴로지 순서가 유지됩니다. 그러나 이는 특정 마이크로 아키텍처 설계를 가정한 것으로, 회로를 이와 같이 스케줄링할 필요는 없습니다.

기본 패스 구성을 사용하면 다음과 같이 서킷이 예약됩니다.
```
from qiskit import QuantumCircuit
from qiskit.transpiler import InstructionDurations, PassManager
from qiskit.transpiler.passes import ALAPScheduleAnalysis, PadDelay
from qiskit.visualization.timeline import draw

circuit = QuantumCircuit(3, 1)
circuit.x(0)
circuit.measure(0, 0)
circuit.x(1).c_if(0, 1)
circuit.measure(2, 0)

durations = InstructionDurations([("x", None, 160), ("measure", None, 800)])

pm = PassManager([ALAPScheduleAnalysis(durations), PadDelay()])
draw(pm.run(circuit))
```
Clbit는 측정 명령 간격 내내 잠겨 있다는 점에 유의하세요. 이 동작은 키스킷 펄스를 기반으로 설계되었으며, 획득 명령어는 다른 명령어와 겹칠 수 없는 AcquireChannel 및 MemorySlot , 즉 다른 명령어의 동시 메모리 액세스가 금지됩니다. 이렇게 하면 타이밍 순서가 항상 토폴로지 노드 순서와 일치하게 됩니다.
새로운 트랜스파일러 패스가 추가되었습니다 PadDynamicalDecoupling 를 대체하는 새로운 트랜스파일러 패스 DynamicalDecoupling 패스를 대체하는 새로운 트랜스파일러 패스를 스케줄링 워크플로의 일부로 추가했습니다. 이 새 패스는 이전 패스에서 발생한 스케줄링 및 정렬 분석에 따라 동적 디커플링 시퀀스를 회로에 삽입합니다.
시각화 기능과 그 위에 구축된 plot_gate_map() 시각화 기능 및 그 위에 구축된 기능, plot_error_map() 와 plot_circuit_layout()에 새로운 키워드 인수 qubit_coordinates 를 추가했습니다. 이 인수는 시각화 중인 백엔드에서 각 큐비트를 플로팅하는 데 사용할 2D 좌표 시퀀스를 받습니다. 이 시퀀스를 지정하면 백엔드의 큐비트 수와 동일한 길이를 가져야 하며 기본 동작 대신 사용됩니다.
시각화 기능과 그 위에 구축된 plot_gate_map() 시각화 기능 및 그 위에 구축된 기능, plot_error_map() 와 plot_circuit_layout()는 이제 큐비트 수가 IBM 백엔드 중 하나와 같은 백엔드뿐만 아니라 모든 백엔드를 플로팅할 수 있습니다. 이는 시각화를 위한 레이아웃을 생성하는 retworkx spring_layout() 함수에 의존합니다. 기본 레이아웃이 백엔드의 특정 커플링 그래프와 작동하지 않는 경우 qubit_coordinates 함수를 사용하여 사용자 지정 레이아웃을 설정할 수 있습니다.
시각화 기능과 그 위에 구축된 plot_gate_map() 시각화 기능 및 그 위에 구축된 기능, plot_error_map() 과 plot_circuit_layout()는 이제 BackendV2 기반 백엔드로 작동할 수 있습니다. 이전에는 이러한 함수가 BaseBackend 또는 BackendV1 기반 백엔드에서만 작동했습니다.
새로운 트랜스파일러 패스가 추가되었습니다, SetIOLatency. 이 패스는 백엔드에서 클래식 비트와 클래식 조건에 대한 I/O 지연 시간을 정의하기 위해 clbit_write_latency 및 conditional_latency 두 개의 인수를 사용합니다. 그러면 이 패스는 패스 매니저의 프로퍼티 세트에서 이 값을 정의하여 후속 스케줄링 및 정렬 패스가 이러한 지연 시간을 수정하고 동적 회로의 스케줄링 출력을 보다 미리 제공할 수 있도록 합니다.
새로운 트랜스파일러 패스 PadDelay 가 추가되었습니다. 이 패스는 큐비트 와이어의 유휴 시간을 다음과 같이 채웁니다 Delay 명령어로 채웁니다. 이 패스는 트랜스파일러에서 패스를 스케줄링하는 새로운 워크플로우의 일부이며 스케줄링 분석 패스( ALAPScheduleAnalysis 또는 ASAPScheduleAnalysis)와 정렬 패스( ConstrainedReschedule) 이전에 실행되는 PadDelay.
트랜스파일러 패스에 VF2Layout 트랜스파일러 패스에는 새로운 키워드 인수가 있는데, target 이 인수는 패스에 대한 Target 객체를 제공하는 데 사용됩니다. 지정하면 Target 가 대상 장치에 대한 모든 정보에 패스에 사용됩니다. 이 옵션을 지정하면 target 옵션이 coupling_map 및 properties 인수보다 우선합니다.

에서 호출 가능 항목을 옵티마이저로 허용 VQE 와 QAOA. 이제 옵티마이저는 다음과 같은 키스킷의 옵티마이저 중 하나가 될 수 있습니다 SPSA 또는 다음 서명을 가진 콜러블일 수 있습니다:

from qiskit.algorithms.optimizers import OptimizerResult

def my_optimizer(fun, x0, jac=None, bounds=None) -> OptimizerResult:
    # Args:
    #     fun (callable): the function to minimize
    #     x0 (np.ndarray): the initial point for the optimization
    #     jac (callable, optional): the gradient of the objective function
    #     bounds (list, optional): a list of tuples specifying the parameter bounds

    result = OptimizerResult()
    result.x = # optimal parameters
    result.fun = # optimal function value
    return result

위의 서명을 사용하면 SciPy 미니마이저를 다음과 같이 직접 전달할 수도 있습니다

from functools import partial
from scipy.optimize import minimize

optimizer = partial(minimize, method="L-BFGS-B")

알려진 문제점

실행 시 parallel_map() (내부적으로 성능에 민감한 함수인 transpile() 및 assemble()) 외부에서 실행되는 서브 프로세스에서 parallel_map()내부에서 수행되는 병렬 디스패치( parallel_map() 가 중단되고 반환되지 않을 수 있습니다. 이는 Linux 및 macOS 에서 Python 3.7 을 사용하여 하위 프로세스를 시작하는 기본 방법과 관련된 CPython의 업스트림 문제로 인한 것입니다 https://bugs.python.org/issue40379 를 참조하세요.) 이 문제가 발생하면 두 가지 옵션이 있습니다: 메인 프로세스에서 호출하면 정상적으로 작동하므로 중첩된 병렬 프로세스를 제거할 수 있습니다 parallel_map() 를 호출해도 정상적으로 작동하므로 중첩된 병렬 프로세스를 제거하거나, CPython 표준 라이브러리 multiprocessing 모듈을 수동으로 호출하여 하위 프로세스에서 유사한 병렬 디스패치를 수행하되 "spawn" 또는 "forkserver" 실행 방법을 사용하여 작업이 중단되어 반환되지 않을 가능성을 방지할 수 있습니다.

업그레이드 주의사항

클래스 Qubit, Clbit 및 AncillaQubit 는 이제 __slots__ 속성을 갖습니다. 이는 메모리 사용량을 줄이기 위한 것입니다. 부작용으로 더 이상 임의의 데이터를 속성으로 첨부할 수 없게 되었습니다. 이는 성능 향상 이외의 다운스트림 코드에는 영향을 미치지 않을 가능성이 매우 높습니다.
핵심 종속성 retworkx 의 버전 요구 사항이 0.10.1 에서 0.11.0 으로 상향 조정되었습니다. 이렇게 하면 트랜스필레이션 패스의 성능이 향상됩니다 ConsolidateBlocks.
symengine 의 최소 지원 버전은 이제 0.9.0 입니다. 이는 내부적으로 병렬 디스패치의 일부로 사용되는 Python 의 pickle 모듈과의 호환성을 개선하기 위해 필요했습니다 parallel_map().
Linux 에서 Python 3.9 로 실행할 때 기본값 QISKIT_PARALLEL 은 이제 TRUE 로 설정됩니다. 즉, 실행할 때 parallel_map() 또는 내부적으로 이를 호출하는 함수(예 transpile() 및 assemble()와 같은 함수는 여러 프로세스에서 실행되며 런타임 성능이 향상됩니다. 이 변경은 병렬 디스패치의 안정성 문제가 해결된 것으로 보이기 때문에 이루어졌습니다(자세한 내용은 #6188 참조). 이로 인해 문제가 계속 발생하면 QISKIT_PARALLEL 환경 변수를 FALSE 으로 설정하거나 사용자 구성 파일에서 parallel 옵션을 False 으로 설정하여 멀티 프로세싱을 비활성화하고 이전 기본 동작으로 되돌릴 수 있습니다(또한 멀티 프로세싱과 관련된 문제를 추적할 수 있도록 문제를 제출해 주세요).
이전에 사용되지 않았던 MSGate 게이트 클래스는 qiskit.circuit.library 에 있던 게이트 클래스가 제거되었습니다. 이 기능은 원래 0.16.0 릴리스에서 더 이상 사용되지 않습니다. 대신 GMS 클래스를 사용하면 원하는 수의 큐비트에 대해 MSGate 외에 동등한 2큐비트 MS 게이트를 생성할 수 있습니다.
이전에 사용되지 않는 mirror() 메서드 Instruction 클래스의 메서드가 제거되었습니다. 이 기능은 원래 0.15.0 릴리스에서 사용되지 않았습니다. 대신 Instruction.reverse_ops().
이전에 더 이상 사용되지 않는 num_ancilla_qubits() 메서드의 qiskit.circuit.library.PiecewiseLinearPauliRotations 및 qiskit.circuit.library.WeightedAdder 클래스의 메서드가 제거되었습니다. 이 기능은 원래 0.16.0 릴리스에서 더 이상 사용되지 않습니다. 대신 PiecewiseLinearPauliRotations.num_ancillas() 및 WeightedAdder.num_ancillas() 방법을 사용해야 합니다.
클래스의 생성자에서 이전에 사용되지 않던 reverse 인수가 제거되었습니다 PolynomialPauliRotations 클래스의 생성자 인수가 제거되었습니다. 이 기능은 원래 0.15.0 릴리스에서 더 이상 사용되지 않습니다. 대신 QuantumCircuit.reverse_bits() 메서드를 사용하여 PolynomialPauliRotations 회로를 역전시키는 방법을 사용해야 합니다.
이전에 사용되지 않는 angle 인수는 생성자에서 C3SXGate 및 C3XGate 게이트 클래스의 생성자에 대한 인수가 제거되었습니다. 이 기능은 원래 0.17.0 릴리스에서 더 이상 사용되지 않습니다. 대신 분수 3 제어 X 게이트의 경우 C3XGate.power() 방법을 사용할 수 있습니다.
np.ndarray 객체를 속성의 일부로 사용하기 위한 지원 params 속성의 일부로 Gate 객체의 속성으로 사용하는 지원이 제거되었습니다. 이 기능은 키스킷 테라( 0.16.0 ) 이후 더 이상 사용되지 않으며 더 이상 작동하지 않습니다. 대신 새로운 서브클래스를 만들고 Gate 의 새로운 서브클래스를 만들고 np.ndarray 입력을 명시적으로 허용해야 합니다 validate_parameter() 메서드를 오버로드해야 합니다.
pip install qiskit-terra 에 대한 설치 대상에 csp-layout-pass 이 새로 추가되었으며 all 에도 포함되어 있습니다. 이것은 키스킷 테라 0.20 에서는 적용되지 않지만, 키스킷 테라 0.21 부터는 트랜스파일러 패스에만 필요한 의존성이 CSPLayout 트랜스파일러 패스에만 필요한 종속성이 필수에서 옵션으로 다운그레이드되어 추가로 설치됩니다. 요구 사항(또는 pip install 명령)을 qiskit-terra[csp-layout-pass] 을 대상으로 설정하여 이 패스에 의존하는 패키지를 준비할 수 있습니다.
Python 3.6 으로 실행에 대한 지원이 제거되었습니다. 키스킷을 실행하려면 최소 Python 버전( 3.7 )이 필요합니다.
이제 AmplitudeEstimator 는 이제 Python 표준 라이브러리의 ABC 클래스를 상속합니다. 이를 위해서는 모든 서브클래스가 이전에는 필요하지 않았던 estimate() 메서드를 구현해야 하는데, 이전에는 필요하지 않았습니다. 이는 클래스의 원래 의도가 항상 ABC 의 하위 클래스가 되는 것이었기 때문에 수행되었습니다 estimate() 의 작동에 필요하기 때문입니다 AmplitudeEstimator 객체의 작동에 필요하기 때문입니다. 그러나 이전에 구현하지 않은 AmplitudeEstimator 서브클래스를 정의했다면 estimate() 를 구현하지 않는 서브클래스를 정의했다면 이제 오류가 발생합니다.
에 의해 발생하는 오류가 HoareOptimizer 선택적 종속성 z3 을 사용할 수 없는 경우 발생하는 오류가 TranspilerError 에서 MissingOptionalLibraryError (이는 QiskitError 및 ImportError)로 변경되었습니다. 이는 다른 선택적 종속성과 일관성을 유지하기 위해 수행되었습니다.
Linux 에서 최소 라이브러리 지원이 manylinux2010 VM에서 manylinux2014. 이는 Numpy와 Scipy의 비슷한 변화를 반영합니다. 시스템에 여전히 아주 오래된 버전의 glibc 이 포함되어 있지 않는 한 대부분의 사용자에게는 의미 있는 효과가 없을 것입니다.
함수를 호출할 때 marginal_counts() 함수를 호출할 때 Result 객체 입력으로 호출될 때, 이제 입력에 설정된 경우 실험 데이터의 memory 필드를 주변 처리합니다 Result. 이전에는 입력란의 memory 필드에 한계선이 표시되지 않았습니다. 이전 동작에서는 counts 필드가 memory 필드와 일치하지 않는 결과가 발생했기 때문에 이러한 변경이 이루어졌습니다 marginal_counts() 가 호출된 후 이전 동작을 원할 경우 marginalize_memory=None 을 인자로 설정하여 복원할 수 있습니다 marginal_counts() 로 설정하면 memory 필드를 무시하지 않습니다.
트랜스파일러 패스는 StochasticSwap 트랜스파일러 패스는 동일한 시드 값을 설정해도 다른 결과를 반환할 수 있습니다. 이는 런타임 성능을 개선하기 위해 트랜스파일러 패스를 내부적으로 재작성했기 때문입니다. 그러나, 이는 만약 당신이 transpile() 를 optimization_level 0, 1(기본값) 또는 2로 실행하고 seed_transpiler 값을 설정하면 키스킷 테라 0.20.0 로 업그레이드한 후 다른 스왑 매핑이 존재하는 출력을 얻을 수 있습니다.
이제 소스에서 키스킷 테라를 빌드하려면 Rust 컴파일러가 필요합니다. 이는 트랜스파일러 패스의 내부 재작성 덕분에 StochasticSwap 트랜스파일러 패스를 내부적으로 재작성하여 트랜스파일러의 런타임 성능을 크게 향상시켰습니다. 러스트 컴파일러는 여기에서 찾을 수 있는 러스트업을 사용하여 쉽게 설치할 수 있습니다: https://rustup.rs/
속성의 name 속성은 PauliEvolutionGate 클래스의 속성이 항상 "PauliEvolution" 로 변경되었습니다. 이 변경은 키스킷의 다른 게이트와 일관성을 유지하기 위해 이루어졌으며, 키스킷의 다른 부분이 회로의 특정 연산이 언제 PauliEvolutionGate. 예를 들어, 폴리 진화 게이트로의 언롤링이 가능합니다.

이전에는 이름에 진화한 연산자가 포함되어 있었지만 이제는 PauliEvolutionGate.label 어트리뷰트를 통해 사용할 수 있습니다. 가 있는 회로를 그리면 PauliEvolutionGate 가 있는 회로를 그려도 게이트는 여전히 동일한 정보를 표시하며 어떤 게이트가 진화 중인지 알 수 있습니다.
이전에는 더 이상 사용되지 않는 메서드입니다:
- qiskit.algorithms.VQE.get_optimal_cost
- qiskit.algorithms.VQE.get_optimal_circuit
- qiskit.algorithms.VQE.get_optimal_vector
- qiskit.algorithms.VQE.optimal_params
- qiskit.algorithms.HamiltonianPhaseEstimationResult.most_likely_phase
- qiskit.algorithms.PhaseEstimationResult.most_likely_phase
키스킷 테라 0.18.0 릴리스에서 더 이상 사용되지 않는 기능이 제거되어 더 이상 작동하지 않습니다.
qiskit.algorithms.VariationalAlgorithm 클래스는 이제 추상 베이스 클래스(ABC)로 정의되며, 이 클래스를 상속하는 클래스는 VariationalAlgorithm.initial_point 게터 및 세터 메서드를 모두 정의해야 합니다.
pass_manager kwarg transpile() 함수가 제거되었습니다. 이 기능은 원래 0.13.0 릴리스에서 더 이상 사용되지 않습니다. 사용자 정의 객체로 회로를 트랜스파일하는 가장 좋은 방법은 PassManager 객체의 run() 메서드를 사용하는 것입니다 PassManager 객체의 메서드를 사용하는 것입니다.
이전에 사용되지 않던 ParametrizedSchedule 클래스는 제거되어 더 이상 존재하지 않습니다. 이 클래스는 0.17.0 릴리스의 일부로 더 이상 사용되지 않습니다. 이 클래스를 사용하는 대신 직접 매개변수화할 수 있습니다 Schedule 또는 ScheduleBlock 객체를 매개변수 펄스 인수로 지정하여 Parameter 객체를 지정하여 파라메트릭 펄스 인수를 직접 파라미터화할 수 있습니다.
qiskit.circuit.library.probability_distributions 모듈은 qiskit-terra 0.17.0 (2021년 4월 1일 출시)의 사용 중단 공지에 따라 제거되었으며 더 이상 존재하지 않습니다. 영향을 받는 클래스는 UniformDistribution, NormalDistribution, LogNormalDistribution 입니다. 이들은 모두 qiskit-finance 라이브러리의 회로 라이브러리 모듈로 이동됩니다: qiskit_finance.circuit.library.probability_distributions.
이전 qiskit.test.mock.fake_mumbai_v2.FakeMumbaiV2 클래스는 FakeMumbaiFractionalCX 으로 이름이 변경되었습니다 BackendV2 기반 가짜 백엔드인 IBM 뭄바이 디바이스( qiskit.test.mock.backends.FakeMumbaiV2)와 구별하기 위해 으로 변경되었습니다. 이전에 FakeMumbaiV2 클래스에 의존하여 타겟에 부분적으로 정의된 CXGateFakeMumbaiFractionalCX 의 부분 적용이 있는 가짜 백엔드를 사용했다면 FakeMumbaiV2 클래스에 더 이상 추가 게이트 정의가 없으므로 Target.
에서 사용하는 리졸버 QuantumCircuit.append() (그리고 결과적으로 인스트럭션을 QuantumCircuit)가 비트 지정자를 변환하는 데 사용하는 리졸버가 더 빠르고 안정적으로 변경되었습니다. 다음과 같은 특정 구조
```
import numpy as np
from qiskit import QuantumCircuit

qc = QuantumCircuit(1, 1)
qc.measure(np.array([0]), np.array([0]))
```
는 이제 이전에는 오류를 잘못 발생시켰지만 다음과 같은 특정 병리적 입력은 정상적으로 작동합니다:
```
from sympy import E, I, pi
qc.x(E ** (I * pi))
```
는 이전에는 가끔 (실수로) 성공했던 오류를 이제 발생시킵니다. 거의 모든 올바른 사용의 경우 일반적인 속도 향상을 제외하고는 눈에 띄는 변화가 없어야 합니다.
준공개 내부 메서드 QuantumCircuit._append() 는 더 이상 입력 유형을 확인하지 않으며 인자 목록에 잘못된 중복이 없다고 가정합니다. 이 기능은 Qiskit 및 기타 라이브러리의 특정 내부 부분에서 빌드하는 데 사용됩니다. QuantumCircuit 데이터가 이미 정확하다는 것이 알려진 경우 오류 검사를 건너뛰어 인스턴스를 가능한 한 빨리 생성합니다. 일반적으로 사용자 데이터를 받는 사용자나 함수는 정수 비트 지정자를 해결하는 public QuantumCircuit.append() 메서드를 사용하여 정수 비트 지정자를 확인하고 인수를 브로드캐스트하며 입력이 올바른지 확인해야 합니다.
사이썬은 더 이상 키스킷 테라의 빌드 종속성이 아니며, 소스에서 키스킷 테라를 빌드할 때 더 이상 설치할 필요가 없습니다.
의 사전 설정된 패스 관리자 qiskit.transpiler.preset_passmanagers 에 의해 생성된 모든 최적화 레벨 2 및 3에 대해 level_2_pass_manager() 와 level_3_pass_manager() 에 의해 생성된 모든 최적화 레벨 2와 3의 사전 설정 패스 관리자가 VF2Layout 를 레이아웃 패스 전에 기본적으로 실행하도록 변경되었습니다. 패스는 VF2Layout 패스는 완벽한 레이아웃을 찾을 수 있는지 빠르게 확인하고 이전에 최적화 레벨 2와 3에서 수행했던 TrivialLayout 와 CSPLayout 를 조합하여 완벽한 레이아웃을 찾으려고 시도했습니다. 이는 다음과 같은 경우 잠재적으로 다른 동작을 초래할 수 있습니다 transpile() 은 기본적으로 호출되며, 트리비얼 레이아웃이 완벽하다고 가정할 때 트리비얼 레이아웃을 사용하는 모든 최적화 수준( circuit.qubits[0] 은 물리적 큐비트 0에 매핑되고 circuit.qubits[1] 은 물리적 큐비트 1에 매핑되는 등)의 기본 경로를 제거하기 때문에 2를 초과하는 모든 최적화 수준에서 기본 경로를 제거합니다. 사용 사례가 사소한 레이아웃에 의존하는 경우 트랜스파일링할 때 layout_method="trivial" 을 호출할 때 명시적으로 요청할 수 있습니다 transpile().
최적화 레벨 1에 대한 사전 설정 패스 관리자( transpile()optimization_level=1 로 호출하거나 optimization_level 인수가 설정되지 않은 경우)에 의해 생성된 최적화 레벨 1에 대한 사전 설정 패스 매니저가 level_1_pass_manager() 가 기본적으로 VF2Layout 가 기본적으로 호출되어 완벽한 레이아웃을 찾을 수 있는지 빠르게 확인하기 위해 DenseLayout. 그러나 최적화 레벨 2 및 3과 달리 실행하기 전에 여전히 사소한 레이아웃이 시도됩니다 VF2Layout 을 실행하고, 완벽한 매핑인 경우 VF2Layout 의 출력이 사용됩니다.

지원 중단 노트

max_credits 인수는 execute()로 설정하고 모든 Qobj 구성(예 QasmQobjConfig 및 PulseQobjConfig)는 더 이상 사용되지 않으며 향후 릴리스에서 제거될 예정입니다. 크레딧 시스템은 IBM Quantum 백엔드에서 2년 동안 사용되지 않았으며, 이 옵션은 효력이 없습니다. 다른 대안은 필요하지 않습니다. 예를 들어 다음과 같이 호출하는 경우 execute() 로 호출하는 경우
```
job = execute(qc, backend, shots=4321, max_credits=10)
```
max_credits 인수를 생략할 수 있습니다:
```
job = execute(qc, backend, shots=4321)
```
클래스의 생성자에서 order 인수에 홀수 정수를 사용하는 것은 더 이상 지원되지 않습니다 SuzukiTrotter 클래스의 생성자에 홀수 인수를 사용하는 것은 더 이상 사용되지 않으며 향후 릴리스에서 더 이상 작동하지 않습니다. 에서 사용하는 제품 공식은 SuzukiTrotter 에서 사용하는 제품 공식은 스즈키 제품 공식이 대칭인 것처럼 순서가 짝수일 때만 정의됩니다.
MatplotlibDrawer, TextDrawing, QCircuitImage 클래스에 대한 qregs, cregs, layout, global_phase 와 MatplotlibDrawer 클래스에 대한 calibrations kwarg는 이제 더 이상 사용되지 않으며 다음 릴리스에서 제거될 예정입니다.

버그 수정

회로 변환 기능의 오류 수정 circuit_to_gate() 및 circuit_to_instruction() (및 관련 회로 메서드 QuantumCircuit.to_gate() 및 QuantumCircuit.to_instruction()) 레지스터가 없는 비트 또는 둘 이상의 레지스터에 비트가 있는 회로에서 작동할 때 발생하는 오류를 수정했습니다.

빌더 인터페이스에서 생성된 제어 흐름 연산에서 QuantumCircuit.copy() 를 호출하면 오류가 발생하는 문제를 수정했습니다. 예를 들어, 이전에는 오류가 발생했지만 이제 성공적으로 반환됩니다:

from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister

qreg = QuantumRegister(4)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg, creg)

with circ.if_test((creg, 0)):
    circ.h(0)

if_else_instruction, _, _ = circ.data[0]
true_body = if_else_instruction.params[0]
true_body.copy()

표준 세션 동등성 라이브러리에서 누락된 항목이 추가되었습니다 CXGate 과 CPhaseGate 뿐만 아니라 CXGate 와 CRZGate.
두 객체 사이에 == 연산자를 실행하면 두 개의 SparsePauliOp 연산자를 실행하면 두 연산자의 계수 수가 다를 때 오류가 발생하는 문제를 수정했습니다. 예를 들어,
```
op = SparsePauliOp.from_list([("X", 1), ("Y", 1)])
op2 = SparsePauliOp.from_list([("X", 1), ("Y", 1), ("Z", 0)])
print(op == op2)
```
이전에는 False 을 반환하는 대신 ValueError 을 반환했습니다.
의 지원 수정 transpile() 의 지원을 수정했습니다 InstructionScheduleMap 객체를 기본 PassManager 를 기반으로 Target for BackendV2 기반 백엔드에 객체를 전달할 수 있도록 수정했습니다. 이전에는 transpile() 함수는 이 처리를 수행하지 않았고, 트랜스파일러 패스는 아직 객체 작업을 지원하지 않는 Target 객체 작업을 지원하지 않는 트랜스파일러 패스는 백엔드의 명령어에 대한 기본 펄스 보정에 액세스할 수 없었습니다 BackendV2 백엔드.
이제 AmplitudeAmplifier 이제 루트 qiskit.algorithms 모듈에서 직접 사용할 수 있습니다. 이전에는 루트 모듈에서 다시 내보낸 클래스에 포함되지 않았으며 qiskit.algorithms.amplitude_amplifiers 에서만 액세스할 수 있었습니다. 수정 #7751.
회로 서랍 기능의 mpl 백엔드 관련 문제 수정 circuit_drawer() 및 QuantumCircuit.draw() 메서드에서 충분한 수의 게이트가 서랍을 두 번째 줄로 접을 때 조건이 있는 게이트가 제대로 표시되지 않던 문제를 수정했습니다. 수정되었습니다: #7752.
특정 조건에서 HHL.construct_circuit() 메서드가 올바른 값을 반환하지 않는 문제를 수정했습니다 QuantumCircuit. 이전에는 이 함수가 고유값을 표현하는 데 필요한 큐비트 수를 계산할 때 반올림 오류가 발생하여 잘못된 회로 출력이 발생했습니다.
의 엔디안 버그를 수정했습니다 BaseReadoutMitigator.expectation_value()diagonal 의 엔디안 버그를 수정했습니다. 이제 빅 엔디안 대신 키스킷 테라의 나머지 부분과 동일한 방식으로 리틀 엔디안으로 올바르게 해석됩니다.
서브시스템이 없는 함수에 quantum_info.partial_trace() 함수에 하위 시스템이 없는지 추적하라는 요청을 받았을 때 이제 오류를 반환하지 않고 모든 차원이 남아 있는 입력 상태의 DensityMatrix 를 반환하는 대신 모든 차원이 남아있는 입력 상태를 반환합니다. 수정 #7613
회로 서랍 기능의 text 백엔드 관련 문제 수정 circuit_drawer() 와 QuantumCircuit.draw() 메서드에서 사이드 텍스트를 사용하는 게이트의 경우 CPhaseGate 및 RZZGate 게이트 클래스와 같은 사이드 텍스트를 사용하는 게이트가 제대로 표시되지 않는 문제를 수정했습니다. 수정 #7532.
함수 관련 문제를 수정했습니다 circuit_drawer() 함수 및 draw() 메서드의 QuantumCircuit. reverse_bits 옵션을 mpl, latex 또는 text 옵션과 함께 사용할 경우 레지스터가 없는 비트가 올바른 순서로 표시되지 않았습니다. 수정 #7303.
메서드의 문제를 수정했습니다 LocalReadoutMitigator.assignment_matrix() 메서드에서 다음과 같은 형식의 사소한 큐비트 시퀀스가 아닌 qubits 인수의 입력값을 거부하던 문제를 수정했습니다: [0, 1, 2, ..., n-1]. 이제 측정할 큐비트 인덱스 목록이 메서드에서 허용되도록 수정되었습니다.
메서드의 기대값 계산에서 StabilizerState.expectation_value() 메서드의 기대값 계산에서, 입력값이 올바르지 않은 경우 출력 기대값이 잘못되는 문제를 수정했습니다 Paulioper 연산자에 사소하지 않은 단계가 있는 경우 출력 기대값이 잘못 계산되는 문제를 수정했습니다. 수정 #7441.
폴리 ID를 포함하는 연산 흐름 표현식 opflow.I 은 더 이상 회로로 변환될 때 IGate 를 생성하지 않습니다. 회로의 아이덴티티 게이트는 지연을 나타내지만 연산 흐름에서는 수학적 아이덴티티, 즉 연산이 전혀 일어나지 않기를 기대합니다.
더 이상 PauliGate 는 더 이상 IGate 를 삽입합니다 "I".
PauliSumOp 동등성 테스트는 이제 비교 항목 중 하나가 단일 항목인 경우를 처리합니다 PauliOp. 예를 들어, 0 * X + I == I 은 이 릴리스 이전에는 False였지만 이제는 True로 평가됩니다.
의 문제를 수정했습니다 ALAPSchedule 및 ASAPSchedule 트랜스파일러 패스가 사용자 정의 펄스 보정(예: 펄스 게이트)이 설정된 인스트럭션으로 작업할 때 발생하는 문제를 수정했습니다. 이전에는 스케줄링 패스가 이러한 명령에 대해 사용자 지정 펄스 보정의 기간을 사용하지 않았기 때문에 회로에 잘못된 스케줄링이 생성되었습니다. 이제 스케줄링 패스가 사용자 지정 보정이 있는 회로의 모든 인스트럭션에 대해 사용자 지정 펄스 보정 기간을 사용하도록 이 문제가 수정되었습니다.
사용 지원이 수정되었습니다 ParameterExpression 명령어 매개변수 사용에 대한 RZXCalibrationBuilder 트랜스파일러 패스에서 인스트럭션 파라미터를 사용할 수 있도록 수정했습니다. 이전에는 명령 매개변수에 바운드가 포함된 경우 ParameterExpression 가 포함된 경우 패스가 이를 올바르게 처리하지 못했습니다.
에서 구문 분석기를 중지했습니다 QuantumCircuit.from_qasm_str() 와 from_qasm_file()2.0 이 아닌 다른 언어 버전에서 온 것으로 식별되는 OpenQASM 프로그램을 허용하지 않도록 합니다. 이 구문 분석기는 OpenQASM 2.0 전용이며, OpenQASM 3.0 에서 가져온 회로에 대한 지원은 다음 릴리스에서 추가될 예정입니다.
OpenQASM 3 익스포터 qasm3.Exporter는 이제 새 고유 이름을 생성하여 예약된 OpenQASM 3 키워드와 충돌하는 레지스터 및 매개변수 이름을 이스케이프합니다. 이제 OpenQASM 3 내보내기에서 출력되는 코드에서 이름이 같은 레지스터와 매개변수의 이름 충돌이 더 이상 발생하지 않습니다. 7742번 수정.

에어 0.10.3

변경 없음

이그니스 0.7.0

변경 없음

IBM Q 제공자 0.18.3

변경 없음

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

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