QuantumCircuit 클래스

회로 데이터(지침 및 컨텍스트).

예제

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2)
qc.measure([0], [1])
print(qc.data)

[CircuitInstruction(operation=Instruction(name='measure', num_qubits=1,
num_clbits=1, params=[]), qubits=(Qubit(QuantumRegister(2, 'q'), 0),),
clbits=(Clbit(ClassicalRegister(2, 'c'), 1),))]

리턴

회로 내의 인스턴스를 CircuitInstruction 포함하는 목록과 유사한 객체입니다.

유형: CircuitData

기본 Rust 객체를 뒷받침하는 불투명한 핸들 QuantumCircuit.

이 객체는 C API 객체와 직접적으로 대응합니다 QkCircuit.

Python 내에서 이 객체를 유용하게 사용할 수 있는 경우는 거의 없습니다. C-API 유형을 기대하는 함수 QkCircuit(예: 를 호출하는 함수)에 이를 전달할 수 있으며 qk_circuit_borrow_from_python(), 이를 로 사용할 수도 있고 passmanager.IR, 를 사용하여 전체 회로를 재구성할 수도 있습니다 QuantumCircuit.from_circuit_data().

현재 회로 범위의 전역 위상(라디안 단위)입니다.

예제

from qiskit import QuantumCircuit

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

0.0

from numpy import pi

circuit.global_phase = pi/4
print(circuit.global_phase)

0.7853981633974483

유형: str

사람이 읽을 수 있는 회로의 이름입니다.

예제

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, name="my_circuit")
print(qc.name)

my_circuit

회로의 메타데이터에 대한 임의의 사용자 정의 사전입니다.

키스킷은 이 매핑의 내용을 검사하지 않지만, 트랜스파일러를 통과하여 출력에 다시 첨부하므로 사용자는 자신의 메타데이터를 추적할 수 있습니다.

예제

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, metadata={'experiment_type': 'Bell state experiment'})

print(qc.metadata)

{'experiment_type': 'Bell state experiment'}

목록 Qubit를 추가한 순서대로 나열합니다. 이를 변경해서는 안 됩니다.

목록 Clbit를 추가한 순서대로 나열합니다. 이를 변경해서는 안 됩니다.

목록 Qubit를 추가한 순서대로 나열합니다. 이를 변경해서는 안 됩니다.

목록 AncillaQubit를 추가한 순서대로 나열합니다. 이를 변경해서는 안 됩니다.

목록 Clbit를 추가한 순서대로 나열합니다. 이를 변경해서는 안 됩니다.

예제

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

qr1 = QuantumRegister(2)
qr2 = QuantumRegister(1)
cr1 = ClassicalRegister(2)
cr2 = ClassicalRegister(1)
qc = QuantumCircuit(qr1, qr2, cr1, cr2)

print("List the qubits in this circuit:", qc.qubits)
print("List the classical bits in this circuit:", qc.clbits)

List the qubits in this circuit: [Qubit(QuantumRegister(2, 'q0'), 0),
Qubit(QuantumRegister(2, 'q0'), 1), Qubit(QuantumRegister(1, 'q1'), 0)]
List the classical bits in this circuit: [Clbit(ClassicalRegister(2, 'c0'), 0),
Clbit(ClassicalRegister(2, 'c0'), 1), Clbit(ClassicalRegister(1, 'c1'), 0)]

회로에 정의된 매개변수입니다.

이 속성은 회로 내의 객체들을 Parameter 알파벳 순서로 정렬하여 반환합니다. 기호 ParameterVector ( )로 인스턴스화된 매개변수도 여전히 숫자 순서대로 정렬된다는 점에 유의하십시오.

예제

아래 스니펫은 매개변수의 삽입 순서는 중요하지 않다는 것을 보여줍니다.

>>> from qiskit.circuit import QuantumCircuit, Parameter
>>> a, b, elephant = Parameter("a"), Parameter("b"), Parameter("elephant")
>>> circuit = QuantumCircuit(1)
>>> circuit.rx(b, 0)
>>> circuit.rz(elephant, 0)
>>> circuit.ry(a, 0)
>>> circuit.parameters  # sorted alphabetically!
ParameterView([Parameter(a), Parameter(b), Parameter(elephant)])

숫자의 경우 알파벳순 정렬이 직관적이지 않을 수 있다는 점을 염두에 두세요. 엄격한 알파벳순 정렬에서는 문자 그대로 '10'이 '2' 앞에옵니다.

>>> from qiskit.circuit import QuantumCircuit, Parameter
>>> angles = [Parameter("angle_1"), Parameter("angle_2"), Parameter("angle_10")]
>>> circuit = QuantumCircuit(1)
>>> circuit.u(*angles, 0)
>>> circuit.draw()
   ┌─────────────────────────────┐
q: ┤ U(angle_1,angle_2,angle_10) ├
   └─────────────────────────────┘
>>> circuit.parameters
ParameterView([Parameter(angle_1), Parameter(angle_10), Parameter(angle_2)])

숫자 순서를 유지하려면 를 ParameterVector 사용할 수 있습니다.

>>> from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector
>>> x = ParameterVector("x", 12)
>>> circuit = QuantumCircuit(1)
>>> for x_i in x:
...     circuit.rx(x_i, 0)
>>> circuit.parameters
ParameterView([
    ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
    ParameterVectorElement(x[2]), ParameterVectorElement(x[3]),
    ..., ParameterVectorElement(x[11])
])

리턴

회로 내의 정렬된 Parameter 객체들.

회로에 대한 모든 관련 레이아웃 정보를 반환합니다.

이 속성에는 선택적 TranspileLayout 객체가 포함됩니다. 이는 일반적으로 또는 PassManager.run() 의 transpile() 출력에서 설정되며, 트랜스필레이션으로 인해 입력 회로에 발생하는 순열에 대한 정보를 유지하기 위함입니다.

SwapGateTarget함수에 transpile() 의해 발생하는 순열에는 두 가지 유형이 있습니다. 하나는 에서 선택된 물리적 큐비트를 기반으로 큐비트의 배열을 재배열하는 초기 배열이고, 다른 하나는 라우팅 과정에서 삽입된 s에 의해 발생하는 출력 순열인 최종 배열입니다.

예제

from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import generate_preset_pass_manager

# Create circuit to test transpiler on
qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.swap(1, 2)
qc.cx(0, 1)

# Add measurements to the circuit
qc.measure([0, 1, 2], [0, 1, 2])

# Specify the QPU to target
backend = GenericBackendV2(3)

# Transpile the circuit
pass_manager = generate_preset_pass_manager(
optimization_level=1, backend=backend
)
transpiled = pass_manager.run(qc)

# Print the layout after transpilation
print(transpiled.layout.routing_permutation())

[0, 1, 2]

스케줄링 트랜스파일러 패스로 설정한 회로의 총 지속 시간입니다. 단위는 unit.

지정된 단위 duration 가 지정된 단위입니다.

작업 시작 시간 목록을 반환합니다.

이 속성은 스케줄링 분석 패스 중 하나가 양자 회로에서 실행되면 활성화됩니다.

예제

from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import generate_preset_pass_manager

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Print the original circuit
print("Original circuit:")
print(qc)

# Transpile the circuit with a specific basis gates list and print the resulting circuit
backend = GenericBackendV2(2, basis_gates=['u1', 'u2', 'u3', 'cx'])
pm = generate_preset_pass_manager(
    optimization_level=1, backend=backend, scheduling_method="alap"
)
transpiled_qc = pm.run(qc)
print("Transpiled circuit with basis gates ['u1', 'u2', 'u3', 'cx']:")
print(transpiled_qc)

# Print the start times of each instruction in the transpiled circuit
print("Start times of instructions in the transpiled circuit:")
for instruction, start_time in zip(transpiled_qc.data, transpiled_qc.op_start_times):
    print(f"{instruction.operation.name}: {start_time}")

Original circuit:
        ┌───┐      ░ ┌─┐
q_0: ┤ H ├──■───░─┤M├───
        └───┘┌─┴─┐ ░ └╥┘┌─┐
q_1: ─────┤ X ├─░──╫─┤M├
            └───┘ ░  ║ └╥┘
meas: 2/══════════════╩══╩═
                    0  1

Transpiled circuit with basis gates ['u1', 'u2', 'u3', 'cx']:
            ┌─────────┐          ░ ┌─────────────────┐┌─┐
q_0 -> 0 ───┤ U2(0,π) ├──────■───░─┤ Delay(1255[dt]) ├┤M├
        ┌──┴─────────┴───┐┌─┴─┐ ░ └───────┬─┬───────┘└╥┘
q_1 -> 1 ┤ Delay(196[dt]) ├┤ X ├─░─────────┤M├─────────╫─
        └────────────────┘└───┘ ░         └╥┘         ║
meas: 2/═══════════════════════════════════╩══════════╩═
                                            1          0

Start times of instructions in the transpiled circuit:
u2: 0
delay: 0
cx: 196
barrier: 2098
delay: 2098
measure: 3353
measure: 2098

리턴

인스트럭션 예상 시작 시간을 나타내는 정수 목록입니다. 인덱스는 명령의 인덱스에 해당합니다 QuantumCircuit.data.

레이즈

AttributeError – 회로가 예약되지 않은 경우.

안실라 큐비트 수를 반환합니다.

예제

from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister

# Create a 2-qubit quantum circuit
reg = QuantumRegister(2)
qc = QuantumCircuit(reg)

# Create an ancilla register with 1 qubit
anc = AncillaRegister(1)
qc.add_register(anc)  # Add the ancilla register to the circuit

print("Number of ancilla qubits:", qc.num_ancillas)

Number of ancilla qubits: 1

클래식 비트 수를 반환합니다.

예제

from qiskit import QuantumCircuit

# Create a new circuit with two qubits and one classical bit
qc = QuantumCircuit(2, 1)
print("Number of classical bits:", qc.num_clbits)

Number of classical bits: 1

둘러싸는 범위에서 캡처된 것으로 표시된 회로 내 실시간 클래식 변수의 수입니다.

이것은 이터러블의 길이입니다 iter_captured_vars() 이터러블의 길이입니다. 0이 아닌 경우 num_input_vars 는 0이어야 합니다.

둘러싸는 스코프에서 캡처된 것으로 표시된 회로의 스트레치 수입니다.

이것은 이터러블의 길이입니다 iter_captured_stretches() 이터러블의 길이입니다. 0이 아닌 경우 num_input_vars 는 0이어야 합니다.

이 회로 범위에서 선언된 회로 내 실시간 클래식 변수의 수(입력 또는 캡처 제외)입니다.

이것은 이터러블의 길이입니다 iter_declared_vars() 이터러블의 길이입니다.

캡처를 제외하고 이 회로 범위에서 선언된 회로의 스트레치 수입니다.

이것은 이터러블의 길이입니다 iter_declared_stretches() 이터러블의 길이입니다.

회로 입력으로 표시된 회로 내 실시간 클래식 변수의 수입니다.

이것은 이터러블의 길이입니다 iter_input_vars() 이터러블의 길이입니다. 0이 아닌 경우 num_captured_vars 는 0이어야 합니다.

회로의 실시간 클래식 변수 및 스트레치 수입니다.

이는 다음과 같습니다 num_vars() + num_stretches().

회로의 파라미터 개체 수입니다.

반환 큐비트 수입니다.

회로의 스트레치 횟수입니다.

이것은 이터러블의 길이입니다 iter_stretches() 이터러블의 길이입니다.

회로의 실시간 클래식 변수 수입니다.

이것은 이터러블의 길이입니다 iter_vars() 이터러블의 길이입니다.

__init__(*regs, name=None, global_phase=0, metadata=None, inputs=(), captures=(), declarations=())

의 기본 생성자 QuantumCircuit.

매개변수

• regs (Register |int |Sequence[Bit]) –

  회로에 포함할 레지스터입니다.

  • 객체의 목록인 경우 Register 객체를 나타내는 QuantumRegister 및/또는 ClassicalRegister 객체를 나타냅니다.

    예를 들어,

    • QuantumCircuit(QuantumRegister(4))
    • QuantumCircuit(QuantumRegister(4), ClassicalRegister(3))
    • QuantumCircuit(QuantumRegister(4, 'qr0'), QuantumRegister(2, 'qr1'))

  • int 의 목록인 경우 회로에 포함할 큐비트 및/또는 클래식 비트의 양입니다. 양자 비트 수만 하나의 정수로 표시하거나 양자 비트와 기존 비트 수를 각각 2정수로 표시할 수 있습니다.

    예를 들어,

    • QuantumCircuit(4) # A QuantumCircuit with 4 qubits
    • QuantumCircuit(4, 3) # A QuantumCircuit with 4 qubits and 3 classical bits

  • 객체를 포함하는 파이썬 목록의 경우 Bit 객체를 포함하는 파이썬 목록인 경우 Bit 를 회로에 추가할 수 있습니다.

• name (str | None) – 양자 회로의 이름. 설정되지 않은 경우, 자동으로 생성된 문자열이 할당됩니다.

• global_phase (ParameterExpression |float) – 회로의 전역 위상(라디안 단위).

• metadata (dict | None) – 회로에 연결할 임의의 키-값 메타데이터. 이는 속성 metadata 내의 딕셔너리에 자유 형식 데이터로 저장됩니다. 이 부품은 회로에서 직접 사용되지는 않을 것입니다.

• inputs (Iterable[Var]) – 이 회로에 대해 런타임 input 변수로 선언할 변수가 있습니까? 이들은 이미 다른 곳에서 생성된 기존 expr.Var 노드여야 합니다. 입력 노드도 함께 생성해야 한다면 다음을 사용하세요 QuantumCircuit.add_input(). 이 인자에 지정된 변수들은 에 직접 add_input()전달됩니다. 한 회로에서 와 를 inputs 동시에 가질 captures 수는 없다.

• captures (Iterable[Var |Stretch]) – 이 회로 범위가 포함하는 범위에서 가져와야 할 변수들. 여기에 지정된 변수들은. add_capture()로 직접 전달됩니다. 한 회로에서 와 를 inputs 동시에 가질 captures 수는 없다.

• declarations (Mapping[Var, Expr] | Iterable[tuple[Var, Expr]]) –

  이 회로가 즉시 선언하고 초기화해야 하는 모든 변수입니다. 이후 선언이 이전 선언(입력 또는 캡처 포함)에 종속되도록 이 입력을 정렬할 수 있습니다. 런타임에 나중에 계산될 값에 의존해야 하는 경우 회로 실행의 적절한 시점에 add_var() 을 회로 실행의 적절한 지점에서 사용하세요.

  이 인수는 이미 생성된 변수 집합이 있을 때 편리한 회로 초기화를 위한 것입니다. 여기에 사용되는 변수는 직접 add_var()에 직접 전달되며, 변수를 처음 생성하는 경우 직접 사용할 수 있습니다.

레이즈

• CircuitError - 회로 이름이 유효하지 않은 경우.
• CircuitError - inputs 및 captures 모두 제공된 경우

copy(name=None)

회로를 복사합니다.

매개변수

name (str) – 복사된 회로에 부여할 이름. 'None'인 경우, 이름은 그대로 유지됩니다.

리턴

지정된 이름을 가진 현재 회로의 딥카피입니다

리턴 유형

QuantumCircuit

copy_empty_like(name=None, *, vars_mode='alike')

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

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

• 이름 및 기타 메타데이터
• 글로벌 단계
• 레지스터를 포함한 모든 큐비트와 클립비트
• 키워드 인자에 따라 처리되는 회로에 정의된 실시간 변수를 vars 키워드 인자에 따라 처리합니다.

매개변수

• name (str | None) – 복사된 회로의 이름. 'None'인 경우, 이름은 그대로 유지됩니다.

• vars_mode (Literal['alike', 'captures', 'drop']) –

  실시간 변수를 처리할 모드입니다.

  모두

  출력 회로의 변수는 원래 회로에서와 동일한 선언 의미를 갖습니다. 예를 들어 소스의 input 변수는 출력 회로에서 input 변수가 됩니다. 이렇게 하면 저장소가 복사되지 않으므로 로컬 변수가 초기화되지 않습니다. 초기화 저장소를 다시 추가하지 않으면 회로가 사용자에게 잠재적으로 위험한 상태로 남을 수 있습니다.

  캡처

  모든 변수는 캡처된 변수로 변환됩니다. 이 기능은 기존 회로를 위한 새 레이어를 만들 때 유용합니다 compose() 베이스에 compose() 는 기본 회로에 캡처를 인라인할 수 있기 때문에 유용합니다(다른 변수는 제외).

  드롭

  출력 회로에는 변수가 정의되지 않습니다.

리턴

자아의 빈 사본.

리턴 유형

QuantumCircuit

static from_instructions(instructions, *, qubits=(), clbits=(), name=None, global_phase=0, metadata=None)

CircuitInstructions의 반복 가능한 객체를 사용하여 회로를 구성합니다.

매개변수

• instructions (Iterable[CircuitInstruction |tuple[qiskit.circuit.Instruction] | tuple[qiskit.circuit.Instruction, Iterable[Qubit]] | tuple[qiskit.circuit.Instruction, Iterable[Qubit], Iterable[Clbit]]]) – 회로에 추가할 지침.
• qubits (Iterable[Qubit]) – 회로에 추가할 큐비트입니다. 예를 들어 이 인수는 특정 큐비트 순서를 강제하는 데 사용할 수 있습니다.
• clbits (Iterable[Clbit]) – 회로에 추가할 클래식 비트. 예를 들어 이 인수는 클래식 비트의 특정 순서를 강제하는 데 사용할 수 있습니다.
• name (str | None) – 회로의 이름.
• global_phase (ParameterValueType) – 회로의 글로벌 위상(라디안 단위)입니다.
• metadata (dict | None) – 회로에 연결할 임의의 키-값 메타데이터.

리턴

양자 회로.

리턴 유형

QuantumCircuit

static from_circuit_data(data, /, *, name=None, metadata=None)

불투명한 물체로 회로를 만들어 보세요 CircuitData.

일반적으로 이 함수는 C에서 전달된 객체를 완전한 Python QuantumCircuit 클래스로 감싸는 데 사용됩니다. 이 CircuitData 객체는 C-API 객체에 대응하는 Rust 네이티브 객체입니다 QkCircuit. 이 불투명한 객체에 대한 자세한 내용은 관련 문서를 참조하십시오.

이 함수의 역함수는 속성입니다 _data .

매개변수

• data (CircuitData) – 회로 IR을 포함하는 네이티브 객체.
• name (str | None) – 회로에 적용할 선택적 Python 전용 이름.
• metadata (dict | None) – 회로에 추가할 선택적이며 임의의, Python 전용 메타데이터.

리턴

전체 회로 객체.

리턴 유형

QuantumCircuit

static from_qasm_file(path)

파일에서 OpenQASM 2.0 프로그램을 읽고 QuantumCircuit.

매개변수

path (str |PathLike) – OpenQASM 2 프로그램 파일의 경로

리턴

OpenQASM 입력에 대한 QuantumCircuit 객체 2.

리턴 유형

QuantumCircuit

static from_qasm_str(qasm_str)

OpenQASM 2.0 프로그램이 포함된 문자열을 QuantumCircuit.

매개변수

qasm_str (str) – OpenQASM 2.0 프로그램이 포함된 문자열.

리턴

입력 OpenQASM 2에 대한 QuantumCircuit 객체

리턴 유형

QuantumCircuit

add_bits(bits)

회로에 비트를 추가합니다.

매개변수

bits (Iterable[Bit])

리턴 유형

없음

add_register(*regs)

레지스터를 추가합니다.

매개변수

regs (Register |int |Sequence[Bit])

리턴 유형

없음

add_var(name_or_var, /, initial)

이 회로에 자동 저장 및 범위가 있는 클래식 변수를 추가합니다.

변수는 회로를 시작할 때 "선언"된 것으로 간주되지만, 이 메서드를 호출하는 회로 지점에서만 초기화되므로 그 전에 정의된 변수에 따라 달라질 수 있습니다.

매개변수

• name_or_var (str |Var) – 변수 이름의 문자열이거나, 재사용할 Var 기존 인스턴스 중 하나입니다. 변수는 회로 내에서 이미 사용 중인 이름을 가릴 수 없습니다.

• initial (Any) –

  이 변수를 초기화할 값입니다. 첫 번째 인수가 문자열 이름으로 주어진 경우, 결과 변수의 유형은 초기 표현식에서 유추됩니다. 이를 보다 수동으로 제어하려면 다음을 사용하여 Var.new() 를 사용하여 원하는 유형의 새 변수를 수동으로 생성하거나 expr.cast() 를 사용하여 이니셜라이저를 원하는 유형으로 캐스팅합니다.

  노드이거나 Expr 노드이거나 expr.lift 를 사용하여 노드로 끌어올릴 수 있는 값이어야 합니다.

리턴

생성된 변수입니다. 인스턴스가 주어진 경우 Var 인스턴스가 주어지면 정확히 동일한 객체가 반환됩니다.

레이즈

CircuitError - 기존 식별자를 섀도잉하여 변수를 만들 수 없는 경우.

리턴 유형

바르

예제

이름과 이니셜라이저 표현식만 주어진 새 변수를 정의합니다:

from qiskit.circuit import QuantumCircuit

qc = QuantumCircuit(2)
my_var = qc.add_var("my_var", False)

관련 회로에서 가져왔거나 수동으로 구성했을 수 있는 변수를 재사용하고 좀 더 복잡한 표현식으로 초기화합니다:

from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.classical import expr, types

my_var = expr.Var.new("my_var", types.Uint(8))

cr1 = ClassicalRegister(8, "cr1")
cr2 = ClassicalRegister(8, "cr2")
qc = QuantumCircuit(QuantumRegister(8), cr1, cr2)

# Get some measurement results into each register.
qc.h(0)
for i in range(1, 8):
    qc.cx(0, i)
qc.measure(range(8), cr1)

qc.reset(range(8))
qc.h(0)
for i in range(1, 8):
    qc.cx(0, i)
qc.measure(range(8), cr2)

# Now when we add the variable, it is initialized using the real-time state of the
# two classical registers we measured into above.
qc.add_var(my_var, expr.bit_and(cr1, cr2))

add_input(name_or_var: str, type_: Type, /) → Var

add_input(name_or_var: Var, type_: None = None, /) → Var

변수를 회로에 입력으로 등록합니다.

매개변수

• name_or_var (str |Var) – 문자열 이름 또는 입력 변수로 사용할 기존 Var 노드 중 하나입니다.
• 유형 - 이름이 문자열로 지정된 경우 변수에 사용할 값은 Type 를 변수에 사용해야 합니다. 변수가 기존 Var로 지정된 경우에는 변수를 지정해서는 안 되며 대신 객체 자체에서 읽어야 합니다.
• type_ (Type | None)

리턴

생성된 변수 또는 전달된 변수와 동일한 변수를 반환합니다.

레이즈

CircuitError - 기존 변수를 섀도잉하여 변수를 만들 수 없는 경우.

리턴 유형

바르

add_stretch(name_or_stretch)

이 회로로 범위가 지정된 새 스트레치를 선언합니다.

매개변수

name_or_stretch (str |Stretch) – 스트레치 이름의 문자열이거나, 재사용할 Stretch 기존 인스턴스 중 하나입니다. Stretches는 해당 서킷 내에서 이미 사용 중인 이름을 중복하여 사용할 수 없습니다.

리턴

생성된 스트레치입니다. 인스턴스가 주어진 경우 Stretch 인스턴스가 주어지면 정확히 동일한 객체가 반환됩니다.

레이즈

CircuitError - 기존 식별자를 섀도잉하여 스트레치를 만들 수 없는 경우.

리턴 유형

스트레치

예제

이름만 주어진 새 스트레치를 정의하고 사용합니다:

from qiskit.circuit import QuantumCircuit, Duration
from qiskit.circuit.classical import expr

qc = QuantumCircuit(2)
my_stretch = qc.add_stretch("my_stretch")

qc.delay(expr.add(Duration.dt(200), my_stretch), 1)

add_uninitialized_var(var, /)

이니셜라이저가 없는 변수를 추가합니다.

대부분의 경우 add_var() 를 사용하여 변수를 초기화해야 합니다. 이 함수를 사용하려면 이미 인스턴스를 보유하고 있어야 합니다 Var 인스턴스를 보유하고 있어야 합니다. 이 함수는 일반적으로 컨텍스트를 복사하는 경우에만 의미가 있기 때문입니다.

매개변수

var (Var) – 추가할 변수를 지정합니다.

add_capture(var: Var)

add_capture(stretch: Stretch)

회로가 포함될 범위에서 캡처할 식별자를 회로에 추가합니다.

이 방법을 사용하려면 Var 또는 Stretch 노드를 사용하여 외부 회로에서 동일한 객체를 사용하여 동일한 식별자를 선언해야 하므로 식별자에 대한 핸들이 있음을 강제합니다.

이는 낮은 수준의 방법으로, 제어 흐름 작업을 수동으로 구성하는 경우에만 유용합니다. 일반적으로 제어 흐름 범위에 빌더 인터페이스를 사용한다고 가정하면 이 메서드를 호출할 필요가 없습니다(with 컨텍스트 관리자 문에 대한 if_test() 및 다른 범위 지정 구조체). 빌더 인터페이스는 내부 범위 내에서 사용되는 모든 식별자를 캡처하여 사용자를 대신하여 내부 범위를 자동으로 닫습니다.

매개변수

var (Union[expr.Var, expr.Stretch]) – 둘러싸는 범위에서 캡처할 변수 또는 스트레치를 지정합니다.

레이즈

CircuitError - 기존 식별자를 섀도잉하여 식별자를 만들 수 없는 경우.

find_bit(bit)

회로에서 주어진 값을 참조하는 데 사용할 수 있는 위치를 찾습니다 Bit.

특히 이 함수는 트랜스파일드 회로의 하드웨어 인덱스에 해당하는 큐비트의 정수 인덱스를 찾을 수 있습니다.

매개변수

bit (Bit) – 찾을 비트입니다.

리턴

2-튜플입니다. 첫 번째 요소(index)에는 Bit 을 찾을 수 있는 인덱스가 포함되어 있습니다( qubits, clbits또는 유형에 따라 다름). 두 번째 요소(registers)는 회로의 각 항목이 포함된 (register, index) 쌍의 목록입니다 Register 에 대한 항목이 포함된 Bit (그리고 인덱스가 있는 Register 를 포함하는 항목이 있습니다.)

리턴 유형

namedtuple( int, List[Tuple( Register, int )])

레이즈

• CircuitError - 제공된 Bit 가 알 수 없는 유형인 경우.
• CircuitError - 제공된 Bit 을 회로에서 찾을 수 없는 경우.

예제

회로를 반복하여 각 연산에 대한 큐비트와 클럭비트 인덱스를 구합니다:

from qiskit.circuit import QuantumCircuit, Qubit

qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
qc.measure([0, 1, 2], [0, 1, 2])

# The `.qubits` and `.clbits` fields are not integers.
assert isinstance(qc.data[0].qubits[0], Qubit)
# ... but we can use `find_bit` to retrieve them.
assert qc.find_bit(qc.data[0].qubits[0]).index == 0

simple = [
    (
        instruction.operation.name,
        [qc.find_bit(bit).index for bit in instruction.qubits],
        [qc.find_bit(bit).index for bit in instruction.clbits],
    )
    for instruction in qc.data
]

has_register(register)

이 회로에 레지스터 R이 있는지 테스트합니다.

매개변수

register (Register) – 퀀텀 또는 클래식 레지스터.

리턴

레지스터가 이 회로에 포함되어 있으면 참입니다.

리턴 유형

부울

assign_parameters(parameters: Mapping[Parameter, ParameterExpression | float] | Iterable[ParameterExpression | float], inplace: Literal[False] = False, *, flat_input: bool = False, strict: bool = True) → QuantumCircuit

assign_parameters(parameters: Mapping[Parameter, ParameterExpression | float] | Iterable[ParameterExpression | float], inplace: Literal[True] = False, *, flat_input: bool = False, strict: bool = True) → None

새 매개변수 또는 값에 매개변수를 할당합니다.

가 사전(dictionary)으로 전달되는 경우 parameters , 키는 현재 회로 내의 인스턴스여야 Parameter 합니다. 사전의 값은 숫자 값이거나 새로운 매개변수 객체일 수 있습니다.

가 리스트나 배열로 전달되면 parameters , 그 요소들은 (의 ParameterVector 객체 내 순서를 유지하면서) 알파벳순으로 정렬된 순서대로 parameters 현재 매개변수에 할당됩니다.

값은 현재 회로 개체 또는 그 복사본에 할당할 수 있습니다.

매개변수

• parameters (Mapping[Parameter, ParameterExpression |float] | Iterable[ParameterExpression |float]) – 새로운 매개변수 값을 지정하는 사전 또는 반복 가능한 객체.
• inplace (bool) – False인 경우, 바인딩된 매개변수가 포함된 회로의 복사본이 반환됩니다. True인 경우 회로 인스턴스 자체가 수정됩니다.
• flat_input (bool) – 만약 이고 True 가 parameters 매핑 유형이라면, 이는 정확히 의 매핑으로 간주된다 {parameter: value}. 기본적으로 (False), 매핑에는 해당 값 시퀀스를 가리키는 ParameterVector 키가 포함될 수도 있으며, 이러한 키는 매핑 과정에서 전개됩니다. 또한 문자열 키가 포함될 수도 있는데, 이 경우 를 사용하여 Parameter 인스턴스로 변환됩니다 get_parameter().
• strict (bool) – 이 경우 False, 매핑에 지정된 매개변수 중 회로에서 사용되지 않는 것은 무시됩니다. ( True 기본값인) 경우, 논리 오류를 나타내는 오류가 발생합니다.

레이즈

• CircuitError - 매개변수가 딕셔너리이고 회로에 없는 매개변수를 포함하는 경우.
• ValueError – parameters가 리스트/배열인데, 그 길이가 회로의 자유 매개변수 개수와 일치하지 않는 경우.

리턴

inplace 이 False이면 바인딩된 매개변수가 있는 회로의 사본, 그렇지 않으면 없음입니다.

리턴 유형

QuantumCircuit | 없음

예제

매개변수화된 회로를 생성하고 매개변수를 제자리에 할당합니다.

from qiskit.circuit import QuantumCircuit, Parameter

circuit = QuantumCircuit(2)
params = [Parameter('A'), Parameter('B'), Parameter('C')]
circuit.ry(params[0], 0)
circuit.crx(params[1], 0, 1)
circuit.draw('mpl')
circuit.assign_parameters({params[0]: params[2]}, inplace=True)
circuit.draw('mpl')

목록별로 값을 제자리에 바인딩하고 원본 회로의 복사본을 가져옵니다.

from qiskit.circuit import QuantumCircuit, ParameterVector

circuit = QuantumCircuit(2)
params = ParameterVector('P', 2)
circuit.ry(params[0], 0)
circuit.crx(params[1], 0, 1)

bound_circuit = circuit.assign_parameters([1, 2])
bound_circuit.draw('mpl')

circuit.draw('mpl')

has_parameter(name_or_param, /)

이 회로에 매개변수 객체가 있는지 확인합니다.

매개변수

name_or_param (str |Parameter) – 확인할 매개변수 또는 매개변수 이름. 이것이 Parameter 노드인 경우, 이 함수가 를 반환하려면 매개변수가 정확히 주어진 값과 일치해야 합니다 True.

리턴

이 회로에서 일치하는 파라미터를 할당할 수 있는지 여부입니다.

리턴 유형

부울

get_parameter(name: str, default: T) → Parameter | T

get_parameter(name: str, default: builtin_types.EllipsisType = Ellipsis) → Parameter

이 회로 범위에서 이름으로 액세스할 수 있는 컴파일 시간 매개변수를 검색합니다.

매개변수

• name (str) – 가져올 매개변수의 이름.
• default (Any) – : 이 값이 지정된 경우, 해당 매개변수가 없을 때 이 값이 반환됩니다. 지정되지 않은 경우, 대신 a가 발생합니다 KeyError .

리턴

해당 매개변수입니다.

레이즈

KeyError – 기본값이 지정되지 않았으나, 해당 매개변수가 회로에 존재하지 않는 경우.

리턴 유형

매개변수

예제

회로에서 이름으로 매개변수를 검색합니다:

from qiskit.circuit import QuantumCircuit, Parameter

my_param = Parameter("my_param")

# Create a parametrized circuit.
qc = QuantumCircuit(1)
qc.rx(my_param, 0)

# We can use 'my_param' as a parameter, but let's say we've lost the Python object
# and need to retrieve it.
my_param_again = qc.get_parameter("my_param")

assert my_param == my_param_again

회로에서 이름으로 변수를 가져오고, 없는 경우 기본값을 반환합니다:

assert qc.get_parameter("my_param", None) == my_param
assert qc.get_parameter("unknown_param", None) is None

get_var(name: str, default: T) → Var | T

get_var(name: str, default: builtin_types.EllipsisType = Ellipsis) → Var

이 회로 범위에서 이름별로 액세스할 수 있는 변수를 검색합니다.

매개변수

• name (str) – 가져올 변수의 이름.
• default (Any) – : 이 값이 지정된 경우, 해당 변수가 존재하지 않을 때 이 값이 반환됩니다. 지정되지 않은 경우, 대신 a가 발생합니다 KeyError .

리턴

해당 변수입니다.

레이즈

KeyError – 기본값이 지정되지 않았는데 변수가 존재하지 않는 경우.

예제

회로에서 이름으로 변수를 검색합니다:

from qiskit.circuit import QuantumCircuit

# Create a circuit and create a variable in it.
qc = QuantumCircuit()
my_var = qc.add_var("my_var", False)

# We can use 'my_var' as a variable, but let's say we've lost the Python object and
# need to retrieve it.
my_var_again = qc.get_var("my_var")

assert my_var == my_var_again

회로에서 이름으로 변수를 가져오고, 없는 경우 기본값을 반환합니다:

assert qc.get_var("my_var", None) == my_var
assert qc.get_var("unknown_variable", None) is None

get_stretch(name: str, default: T) → Stretch | T

get_stretch(name: str, default: builtin_types.EllipsisType = Ellipsis) → Stretch

이 회로 범위에서 액세스할 수 있는 스트레치를 이름으로 검색합니다.

매개변수

• name (str) – 가져올 구간 이름.
• default (Any) – : 이 값이 지정된 경우, 해당 변수가 존재하지 않을 때 이 값이 반환됩니다. 지정되지 않은 경우, 대신 a가 발생합니다 KeyError .

리턴

해당 스트레치.

레이즈

KeyError – 기본값이 지정되지 않았는데 변수가 존재하지 않는 경우.

예제

서킷에서 이름으로 스트레칭을 검색합니다:

from qiskit.circuit import QuantumCircuit

# Create a circuit and create a variable in it.
qc = QuantumCircuit()
my_stretch = qc.add_stretch("my_stretch")

# We can use 'my_stretch' as a variable, but let's say we've lost the Python object and
# need to retrieve it.
my_stretch_again = qc.get_stretch("my_stretch")

assert my_stretch == my_stretch_again

회로에서 이름으로 변수를 가져오고, 없는 경우 기본값을 반환합니다:

assert qc.get_stretch("my_stretch", None) == my_stretch
assert qc.get_stretch("unknown_stretch", None) is None

get_identifier(name: str, default: T) → Var | Stretch | T

get_identifier(name: str, default: builtin_types.EllipsisType = Ellipsis) → Var | Stretch

이 회로 범위에서 이름으로 액세스할 수 있는 식별자를 검색합니다.

여기에는 현재 실시간 클래식 변수와 스트레치가 모두 포함됩니다.

매개변수

• name (str) – 검색할 식별자의 이름.
• default (Any) – : 이 값이 지정된 경우, 해당 변수가 존재하지 않을 때 이 값이 반환됩니다. 지정되지 않은 경우, 대신 a가 발생합니다 KeyError .

리턴

해당 변수입니다.

레이즈

KeyError – 기본값이 지정되지 않았으나 식별자가 존재하지 않는 경우.

has_var(name_or_var, /)

이 범위에서 변수에 액세스할 수 있는지 확인합니다.

매개변수

name_or_var (str |Var) – 확인할 변수 또는 변수 이름. 이것이 expr.Var 노드인 경우, 이 함수가 를 반환하려면 변수의 값이 주어진 값과 정확히 일치해야 합니다 True.

리턴

일치하는 변수에 액세스할 수 있는지 여부를 확인합니다.

리턴 유형

부울

has_stretch(name_or_stretch, /)

이 범위에서 스트레치에 액세스할 수 있는지 확인합니다.

매개변수

name_or_stretch (str |Stretch) – 확인하려는 구간 또는 구간의 이름. 이것이 expr.Stretch 노드인 경우, 이 함수가 0을 반환하려면 스트레치가 주어진 값과 정확히 일치해야 합니다 True.

리턴

일치하는 스트레치에 액세스할 수 있는지 여부를 확인합니다.

리턴 유형

부울

has_identifier(name_or_ident, /)

이 범위에서 식별자에 액세스할 수 있는지 확인합니다.

매개변수

name_or_ident (str |Var |Stretch) – 확인할 인스턴스 또는 식별자의 이름. 이 expr.Stretch 노드가 expr.Var 또는 노드인 경우, 이 함수가 를 반환하려면 일치하는 인스턴스가 정확히 주어진 인스턴스와 동일해야 합니다 True.

리턴

일치하는 식별자에 액세스할 수 있는지 여부를 확인합니다.

리턴 유형

부울

iter_vars()

이 회로 내 범위의 모든 실시간 클래식 변수에 대한 이터러블을 가져옵니다.

이 메서드는 범위의 모든 변수에 대해 반복합니다. 보다 세분화된 반복기를 보려면 iter_declared_vars(), iter_input_vars() 와 iter_captured_vars().

리턴 유형

이터러블[* Var* ]

iter_stretches()

이 회로 내 범위의 모든 스트레치에 대한 이터러블을 가져옵니다.

이 메서드는 범위의 모든 스트레치에 대해 반복합니다. 보다 세분화된 반복기를 보려면 iter_declared_stretches() 와 iter_captured_stretches().

리턴 유형

이터러블[* 스트레치* ]

iter_input_vars()

이 회로 범위에 입력으로 선언된 모든 실시간 클래식 변수에 대한 이터러블을 가져옵니다. 여기에는 로컬로 선언된 변수( iter_declared_vars()) 및 캡처된 변수( iter_captured_vars()).

리턴 유형

이터러블[* Var* ]

iter_captured_vars()

포함 범위에서 이 회로 범위가 캡처하는 모든 실시간 클래식 변수에 대한 이터러블을 가져옵니다. 여기에는 입력 변수( iter_input_vars()) 및 로컬로 선언된 변수( iter_declared_vars()).

리턴 유형

이터러블[* Var* ]

iter_captured_stretches()

이 회로 스코프가 캡처한 스트레치에 대한 이터러블을 포함하는 스코프에서 가져옵니다. 여기에는 로컬로 선언된 스트레치는 제외됩니다( iter_declared_stretches()).

리턴 유형

이터러블[* 스트레치* ]

iter_declared_vars()

이 범위에서 자동 저장 기간으로 선언된 모든 실시간 클래식 변수에 대한 이터러블을 가져옵니다. 여기에는 입력 변수( iter_input_vars()) 및 캡처된 변수( iter_captured_vars()).

리턴 유형

이터러블[* Var* ]

iter_declared_stretches()

이 범위에서 선언된 모든 스트레치에 대한 이터러블을 가져옵니다. 여기에는 캡처된 스트레치는 제외됩니다( iter_captured_stretches()).

리턴 유형

이터러블[* 스트레치* ]

append(instruction, qargs=None, cargs=None, *, copy=True)

회로 끝에 하나 이상의 지침을 추가하여 회로를 제자리에서 수정합니다.

Instruction와 cargs``qargs 는 주어진 의 규칙에 따라 확장 및 전파되며, 비-지정자Bit (정수 인덱스 등)는 관련 인스턴스로 해석됩니다.

a가 CircuitInstruction 주어지면, a는 언랩 처리되고 이 회로의 컨텍스트에서 검증된 후, 새로운 객체가 회로에 추가됩니다. 이 경우, 또는 을 cargs 따로 통과할 qargs 수 없습니다.

매개변수

• CircuitInstructioninstruction (Operation |CircuitInstruction) –Instruction 추가할 인스턴스, 또는 전체 컨텍스트를 포함하는. 를 구현하는 to_instruction 객체도 지원되지만, 반복적인 변환 비용을 피할 수 있으므로 일반적으로 를 Instruction 직접 전달하는 것이 권장됩니다.
• 명령을 연결할 대상인 Qubits의 qargs (Sequence[Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]] | None) – 지정자.
• 명령을 연결할 대상인 Clbits의 cargs (Sequence[Clbit |ClassicalRegister |int |slice |Sequence[Clbit |int]] | None) – 지정자.
• copy (bool) – if ( True 기본값)인 경우, 입력값에 기호 매개변수가 포함되어 있으면 회로에 추가하기 전에 해당 입력값을 instruction 복사하므로, 동일한 명령어가 포함된 다른 회로에 영향을 주지 않고 안전하게 변경할 수 있습니다. 이 명령어가 다른 회로에서는 사용되지 않을 것이라고 확신한다면, 이를 설정하여 처리 속도를 약간 False 높일 수 있습니다.

리턴

CircuitInstruction회로에 실제로 추가된 s에 대한 참조.

리턴 유형

qiskit.circuit.InstructionSet

레이즈

InstructionCircuitError – 전달된 연산이 의 인스턴스가 아니거나, 에 대한 호출을 to_instruction 통해 의 인스턴스로 변환될 수 없는 경우.

_append(instruction: CircuitInstruction, *, _standard_gate: bool) → CircuitInstruction

_append(instruction: Operation, qargs: Sequence[Qubit], cargs: Sequence[Clbit]) → Operation

회로의 끝에 명령어를 추가하여 회로를 제자리에서 수정합니다.

매개변수

• 지침 -

  추가할 연산 및 해당 컨텍스트에 대한 완전하고 올바른 CircuitInstruction 형식의 정의.

  Operation이전 버전과의 호환성 모드에서는 이것이 단순한 일 수 있으며, 이 경우 qargs 와 cargs 를 명시적으로 지정해야 합니다.

• qargs – 베어(bare Operation )를 연결할 큐비트에 대한 레거시 인자. 첫 번째 인수가 우선순위 CircuitInstruction 형식인 경우 무시됩니다.

• cargs – clbits가 베어 Operation (bare)를 연결할 대상에 대한 레거시 인자. 첫 번째 인수가 우선순위 CircuitInstruction 형식인 경우 무시됩니다.

• _standard_gate (bool)

리턴

방금 추가한 인스트럭션에 대한 핸들입니다.

리턴 유형

CircuitInstruction

compose(other: QuantumCircuit | Instruction, qubits: Qubit | QuantumRegister | int | slice | Sequence[Qubit | int] | Sequence[Qubit | QuantumRegister | int | slice | Sequence[Qubit | int]] | None = None, clbits: Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int] | Sequence[Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int]] | None = None, front: bool = False, inplace: Literal[True] = True, wrap: bool = False, *, copy: bool = True, var_remap: Mapping[str | Var | Stretch, str | Var | Stretch] | None = None, inline_captures: bool = False) → None

compose(other: QuantumCircuit | Instruction, qubits: Qubit | QuantumRegister | int | slice | Sequence[Qubit | int] | Sequence[Qubit | QuantumRegister | int | slice | Sequence[Qubit | int]] | None = None, clbits: Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int] | Sequence[Clbit | ClassicalRegister | int | slice | Sequence[Clbit | int]] | None = None, front: bool = False, inplace: Literal[False] = False, wrap: bool = False, *, copy: bool = True, var_remap: Mapping[str | Var | Stretch, str | Var | Stretch] | None = None, inline_captures: bool = False) → QuantumCircuit

한 회로의 명령어를 다른 회로의 지정된 큐비트 및/또는 클릿에 적용합니다.

실시간 변수를 다룰 때(expr.Var 및 expr.Stretch 인스턴스)를 다룰 때, 두 가지 주요 전략이 있습니다 compose():

1. other 회로는 변수를 포함하여 완전히 덧셈으로 처리됩니다. other 의 변수는 self 의 변수와 완전히 구별되어야 하며( var_remap 을 사용하면 도움이 됩니다), other 의 모든 변수는 other 에 있는 것과 일치하는 입력/캡쳐/로컬 스코핑을 사용하여 출력에서 새로 선언됩니다. 일반적으로 서로 관련이 없는 두 개의 회로를 연결할 때 이 방법을 사용합니다.
2. other 회로는 self 의 정확한 확장으로 만들어져 self 의 끝에 있는 상태의 기존 변수에 작용하는 것을 포함하여 그 위에 인라인으로 만들어졌습니다. 이 경우 인라인으로 선언할 변수를 모두 "캡처"로 지정하여 other 을 생성한 다음 inline_captures=True 을 사용하여 연결할 수 있습니다. 즉석에서 레이어를 정의하여 회로를 구축하거나 자체에서 가져온 레이어를 사용하여 회로를 재구축하는 경우 일반적으로 원하는 방식입니다. 이 경우 vars_mode="captures" 인수를 copy_empty_like() 인수를 사용하면 각 레이어의 베이스를 만드는 데 유용할 수 있습니다.

매개변수

• other (qiskit.circuit.Instruction orQuantumCircuit) – (하위)회로 또는 자체에 합성하기 위한 명령어. QuantumCircuit가 아니라면, 이는 가 받아들일 수 있는 append 어떤 것이든 될 수 있습니다.

• 조합할 qubits (list[Qubit|int]) – 개의 자기 큐비트.

• clbits (list[Clbit|int]) – 개의 self의 clbits를 조합 대상으로 지정합니다.

• front (bool) – 인 경우 True, 전방 합성이 수행됩니다. 제어 흐름 빌더 컨텍스트 관리자 내에서는 이 작업을 수행할 수 없습니다.

• inplace (bool) – 인 경우 True, 객체를 수정합니다. 그렇지 않으면, 조합된 회로를 반환합니다.

• copy (bool) – 만약 ( True 기본값)이라면, 입력은 공유된 것으로 간주되며, 향후 변경될 가능성이 있는 경우 포함된 모든 명령어가 복사됩니다. 불필요한 복사를 방지하기 위해 입력을 기본 회로의 소유로 간주해야 하는 경우 False 이 옵션을 설정할 수 있습니다. 이 경우, 이후에 other 를 사용하는 것은 유효하지 않으며, 일부 명령어가 제자리에서 변경되었을 수 있습니다.

• var_remap (Mapping) –

  매핑을 다시 작성하는 데 사용할 expr.Var 및 expr.Stretchother 의 노드를 self 로 인라인 처리합니다. 이는 이름 충돌을 피하는 데 사용할 수 있습니다.

  키와 값은 모두 문자열 또는 직접 식별자 인스턴스로 지정할 수 있습니다. 키가 문자열인 경우, 모든 Var 또는 Stretch 와 일치합니다. 값이 문자열인 경우, 새 키가 일치할 때마다 새 Var 또는 Stretch 가 올바른 유형으로 생성됩니다. 값이 a인 경우 Var인 경우 type 는 대체하는 변수의 값과 정확히 일치해야 합니다.

• inline_captures (bool) –

  True 인 경우 other 의 모든 "캡처된" 식별자 노드는 QuantumCircuit 의 모든 "캡처된" 식별자 노드는 self 에 이미 선언된 식별자(입력/캡쳐/로컬 유형)를 참조하는 것으로 간주되며 other 의 사용법은 기존 식별자에 적용됩니다. 와 함께 사용할 기존 회로에 대한 레이어를 구축하려면 compose()와 함께 사용할 레이어를 만들려면 vars_mode="captures" 인수를 copy_empty_like() 유용합니다. vars_remap 의 모든 리매핑은 이 변수 인라이닝을 평가하기 전에 발생합니다.

  False (기본값)인 경우 other 의 모든 식별자는 self 의 식별자와 구별되어야 하며, 이에 대한 새로운 선언이 이루어집니다.

• wrap (bool) – True인 경우, 다른 회로를 게이트(또는 해당 회로에 유니터리 명령어만 포함되어 있는지에 따라 명령어)로 감싼 다음, 이를 self에 합성합니다. 이 옵션을 사용하는 것보다, 또는 to_instruction() to_gate()을 사용하여 직접 수동으로 제어한 다음 를 호출하는 편이 거의 항상 더 좋습니다 append().

리턴

구성 회로를 반환합니다(inplace==True인 경우 None을 반환합니다).

리턴 유형

QuantumCircuit

레이즈

• CircuitError - other 이 self 보다 넓은 경우와 같이 두 회로 간에 올바른 와이어 매핑을 수행할 수 없는 경우.
• CircuitErrorself - 의 컨텍스트 관리자 형태와 같이 부분적으로 빌드된 제어 흐름 컨텍스트가 활성화된 상태에서 새 회로를 방출하려고 하는 경우 if_test(), for_loop() 와 while_loop().
• CircuitError - 제어 흐름 빌더 블록이 활성화되어 있을 때 회로의 앞쪽에 컴포지션을 시도하는 경우 이 동작에 대한 명확한 의미가 없습니다.

예제

>>> lhs.compose(rhs, qubits=[3, 2], inplace=True)

            ┌───┐                   ┌─────┐                ┌───┐
lqr_1_0: ───┤ H ├───    rqr_0: ──■──┤ Tdg ├    lqr_1_0: ───┤ H ├───────────────
            ├───┤              ┌─┴─┐└─────┘                ├───┤
lqr_1_1: ───┤ X ├───    rqr_1: ┤ X ├───────    lqr_1_1: ───┤ X ├───────────────
         ┌──┴───┴──┐           └───┘                    ┌──┴───┴──┐┌───┐
lqr_1_2: ┤ U1(0.1) ├  +                     =  lqr_1_2: ┤ U1(0.1) ├┤ X ├───────
         └─────────┘                                    └─────────┘└─┬─┘┌─────┐
lqr_2_0: ─────■─────                           lqr_2_0: ─────■───────■──┤ Tdg ├
            ┌─┴─┐                                          ┌─┴─┐        └─────┘
lqr_2_1: ───┤ X ├───                           lqr_2_1: ───┤ X ├───────────────
            └───┘                                          └───┘
lcr_0: 0 ═══════════                           lcr_0: 0 ═══════════════════════

lcr_1: 0 ═══════════                           lcr_1: 0 ═══════════════════════

tensor(other, inplace=False)

텐서 self 와 other.

리틀 엔디안 규칙에서는 가장 왼쪽 연산이 회로의 맨 아래에 있다는 것을 기억하세요. 자세한 내용은 문서를 참조하세요.

     ┌────────┐        ┌─────┐          ┌─────┐
q_0: ┤ bottom ├ ⊗ q_0: ┤ top ├  = q_0: ─┤ top ├──
     └────────┘        └─────┘         ┌┴─────┴─┐
                                  q_1: ┤ bottom ├
                                       └────────┘

매개변수

• other (QuantumCircuit) – 이 회로를 텐서링할 다른 회로입니다.
• inplace (bool) – 인 경우 True, 객체를 수정합니다. 그렇지 않으면 조합된 회로를 반환합니다.

리턴 유형

QuantumCircuit | 없음

예제

from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')

리턴

텐서드 회로( inplace=True)의 경우 None 를 반환합니다.

리턴 유형

QuantumCircuit

매개변수

• other (QuantumCircuit)
• inplace (bool)

barrier(*qargs, label=None)

신청 Barrier. qargs 이 비어 있으면 회로의 모든 큐비트에 적용됩니다.

매개변수

• qargs (QubitSpecifier) – 하나 이상의 큐비트 인자에 대한 사양입니다.
• label (str) – 배리어의 문자열 레이블.

리턴

핸들을 추가 지침에 추가합니다.

리턴 유형

qiskit.circuit.InstructionSet

ccx(control_qubit1, control_qubit2, target_qubit, ctrl_state=None, label=None)

CCXGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 첫 번째 제어 신호로 사용되는 큐비트.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 두 번째 제어 신호로 사용되는 큐비트(들).
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.
• label (str | None) – 회로 내 게이트의 문자열 레이블.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

ccz(control_qubit1, control_qubit2, target_qubit, label=None, ctrl_state=None)

CCZGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 첫 번째 제어 신호로 사용되는 큐비트.
• control_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 두 번째 제어 신호로 사용되는 큐비트(들).
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘10’)로 표시합니다. 기본적으로 ‘11’ 상태에서 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

ch(control_qubit, target_qubit, label=None, ctrl_state=None)

CHGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cp(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

CPhaseGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• theta (ParameterExpression |float) – 회전 각도.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

crx(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

CRXGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• theta (ParameterExpression |float) – 회전 각도.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cry(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

CRYGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• theta (ParameterExpression |float) – 회전 각도.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

crz(theta, control_qubit, target_qubit, label=None, ctrl_state=None)

CRZGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• theta (ParameterExpression |float) – 회전 각도.
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cs(control_qubit, target_qubit, label=None, ctrl_state=None)

CSGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

csdg(control_qubit, target_qubit, label=None, ctrl_state=None)

CSdgGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cswap(control_qubit, target_qubit1, target_qubit2, label=None, ctrl_state=None)

CSwapGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• target_qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수 또는 비트열(예: '1')로 표시합니다. 기본적으로 '1' 상태를 기준으로 제어합니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

csx(control_qubit, target_qubit, label=None, ctrl_state=None)

CSXGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cu(theta, phi, lam, gamma, control_qubit, target_qubit, label=None, ctrl_state=None)

CUGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• theta (ParameterExpression |float) – 게이트의 $\theta$ 회전 각도.
• phi (ParameterExpression |float) – 게이트의 $\phi$ 회전 각도.
• lam (ParameterExpression |float) – 게이트의 $\lambda$ 회전 각도.
• gamma (ParameterExpression |float) – U 게이트에 적용된 전역 위상(적용된 경우).
• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cx(control_qubit, target_qubit, label=None, ctrl_state=None)

CXGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cy(control_qubit, target_qubit, label=None, ctrl_state=None)

CYGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

cz(control_qubit, target_qubit, label=None, ctrl_state=None)

CZGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• control_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 제어용으로 사용되는 큐비트.
• target_qubit (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 해당 게이트의 대상이 되는 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.
• ctrl_state (str |int | None) – 제어 상태를 10진수로, 또는 비트열(예: ‘1’)로 표시합니다. 기본적으로 ‘1’ 상태일 때 제어됩니다.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

dcx(qubit1, qubit2, label=None)

DCXGate신청하기.

이 게이트의 전체 매트릭스 형태는 기본 게이트 문서를 참조하세요.

매개변수

• qubit1 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 게이트를 적용할 큐비트.
• qubit2 (Qubit |QuantumRegister |int |slice |Sequence[Qubit |int]) – 게이트를 적용할 큐비트.
• label (str | None) – 회로 내 게이트의 문자열 레이블.

리턴

생성된 지침에 대한 핸들입니다.

리턴 유형

InstructionSet

delay(duration, qarg=None, unit=None)

신청 Delay. Qarg가 None 인 경우 모든 쿼비트에 적용됩니다. 여러 큐비트에 적용할 경우 동일한 기간의 지연이 생성됩니다.

매개변수

• duration (Object) – 지연 기간입니다. 인 경우 Expr타입의 상수 표현식이어야 합니다 Duration.
• qarg (Object) – 쿼비트 인수를 사용하여 이 지연을 적용합니다.
• unit (str | None) – 지속 시간의 단위. 단, 인 duration 경우에는 Expr 이를 명시해서는 안 된다. 지원되는 단위: 's', 'ms', 'us', 'ns', 'ps', 및 'dt'. 기본값은 이며 'dt', 이는 대상 백엔드에 따라 정수형 시간 단위를 의미합니다.