회로 라이브러리
qiskit.circuit.library
회로 라이브러리는 알고리즘의 구성 요소, 벤치마킹 도구, 그리고 고전적 방법으로 시뮬레이션하기 어렵다고 추정되는 예시 역할을 하는 양자 회로들의 모음입니다. 목표는 명확하게 정의되고, 폭넓게 적용 가능하며, 다양한 워크플로우에서 쉽게 재사용할 수 있는 회로를 제공하는 것입니다.
라이브러리에 포함될 회로의 기준은 다음과 같습니다:
명확히 정의된
이 회로는 논문이나 참고 문헌을 바탕으로 한 명확한 구조나 수학적 원리를 갖추고 있다.
널리 사용되며 관련성이 높은
해당 회로는 명확히 정의된 과제에 대해 정석적이거나 가장 널리 알려진 선택지이거나, 표준 참조 기준 또는 일반적인 기준선이며, 또는 역사적으로 양자 컴퓨팅의 중요한 하위 분야에 기초가 되어 온 것입니다.
독립형
이 회로는 독립적으로 구성되어 있으므로, 새로운 외부 의존성 없이도 효율적으로 생성할 수 있습니다.
QuantumCircuit회로 라이브러리의 요소들은 s 또는 Instructions 중 하나이므로, 이를 쉽게 조사하거나 다른 회로에 연결할 수 있습니다. 이를 통해 더 높은 추상화 수준에서 신속한 프로토타이핑과 회로 설계를 수행할 수 있습니다.
예를 들어,
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp
hamiltonian = SparsePauliOp(["ZZI", "IZZ", "IXI"], coeffs=[1, 1, -1])
gate = PauliEvolutionGate(hamiltonian)
circuit = QuantumCircuit(hamiltonian.num_qubits)
circuit.append(gate, circuit.qubits)
circuit.draw("mpl")
이 라이브러리는 여러 섹션으로 구성되어 있습니다:
당사는 다양한 작업 범주로 구분합니다:
표준 게이트
이것들은 기본적인 양자 게이트이며, 이 중 일부는 일반적으로 양자 컴퓨터에서 기본 게이트 집합을 구성합니다. Gate이것들은 로 표현되는 단일 연산들입니다. 이 라이브러리는 또한 표준 컴파일러 지시문(a Barrier)과 비단위 연산(예: Measure)을 제공합니다.
추상 연산
이 범주에는 수학적 연산으로 정의되지만, 서로 다른 분해 방식을 통해 구현될 수 있는 연산들이 포함됩니다. 예를 들어, 다중 제어 연산(multi-controlled XGate )은 모든 제어 큐비트가 상태일 때 대상 큐비트의 상태를 반전시킵니다. 또한 하위 레벨 게이트를 사용하여 이 연산을 구현하는 다양한 구체적인 회로들이 존재합니다. Instruction이러한 추상적 연산은 또는 로 Gate 표현됩니다. 이를 통해 각 블록의 구체적인 구현 방식을 정하지 않고도 회로를 구성할 수 있으며, 최종적으로는 컴파일러(또는 사용자 본인)가 최적의 분해 방식을 선택하도록 할 수 있습니다. 예를 들어,
from qiskit.circuit.library import MCXGate
mcx = MCXGate(4)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(5)
circuit.append(mcx, [0, 1, 4, 2, 3])
circuit.draw("mpl")
추상 연산이 있는 회로의 경우 트랜스파일링 중에 회로 컨텍스트가 고려됩니다. 예를 들어, 유휴 큐비트를 사용할 수 있는 경우 이를 사용하여 더 얕은 회로를 얻을 수 있습니다:
from qiskit import transpile
small_circuit = QuantumCircuit(5) # here we have no idle qubits
small_circuit.append(mcx, [0, 1, 4, 2, 3])
small_tqc = transpile(small_circuit, basis_gates=["u", "cx"])
print("No aux:", small_tqc.count_ops())
large_circuit = QuantumCircuit(10) # now we will have 5 idle qubits
large_circuit.append(mcx, [0, 1, 4, 2, 3])
large_tqc = transpile(large_circuit, basis_gates=["u", "cx"])
print("With aux:", large_tqc.count_ops())어떤 인쇄물:
No aux: OrderedDict([('u', 41), ('cx', 36)])
With aux: OrderedDict([('u', 24), ('cx', 18)])구조적 작업
이러한 작업에는 고유한 분해가 있습니다. 컴파일러가 상위 수준에서 추론할 필요가 없으므로, 이들은 반환하는 함수로 구현됩니다 QuantumCircuit 객체를 반환하는 함수로 구현됩니다. 예를 들어,
from qiskit.circuit.library import real_amplitudes
ansatz = real_amplitudes(5, entanglement="pairwise")
ansatz.draw("mpl")
표준 게이트
Gate이러한 연산들은 가역적인 유니터리 게이트이며, 모두 의 하위 클래스에 속합니다. control()to_matrix()결과적으로, 이들 모두에는, power(), 및 메서드가 있는데, 이 메서드들은 일반적으로 유니터리 연산에만 적용할 수 있습니다.
예를 들어,
from qiskit.circuit.library import XGate
gate = XGate()
print(gate.to_matrix()) # X gate
print(gate.power(1/2).to_matrix()) # √X gate -- see also the SXGate
print(gate.control(1).to_matrix()) # CX (controlled X) gate[[0.+0.j 1.+0.j]
[1.+0.j 0.+0.j]]
[[0.5+0.5j 0.5-0.5j]
[0.5-0.5j 0.5+0.5j]]
[[1.+0.j 0.+0.j 0.+0.j 0.+0.j]
[0.+0.j 0.+0.j 0.+0.j 1.+0.j]
[0.+0.j 0.+0.j 1.+0.j 0.+0.j]
[0.+0.j 1.+0.j 0.+0.j 0.+0.j]]기능 get_standard_gate_name_mapping() 기능을 사용하면 사용 가능한 표준 게이트와 작업을 확인할 수 있습니다.
get_standard_gate_name_mapping
qiskit.circuit.library.get_standard_gate_name_mapping()
표준 게이트의 이름과 명령어를 해당 이름의 객체에 매핑하는 사전을 반환합니다.
예제
from qiskit.circuit.library import get_standard_gate_name_mapping
gate_name_map = get_standard_gate_name_mapping()
cx_object = gate_name_map["cx"]
print(cx_object)
print(type(cx_object))Instruction(name='cx', num_qubits=2, num_clbits=0, params=[])
_SingletonCXGate1큐비트 표준 게이트
HGate(*args[, _force_mutable] ) | 단일 큐비트 하다마드 게이트. |
IGate(*args[, _force_mutable] ) | 신원 게이트. |
PhaseGate(theta[, 레이블] ) | Z축을 중심으로 한 단일 큐비트 회전. |
RGate(세타, 피[, 레이블] ) | 축을 중심으로 회전. |
RXGate(theta[, 레이블] ) | X축을 중심으로 한 단일 큐비트 회전. |
RYGate(theta[, 레이블] ) | Y축을 중심으로 한 단일 큐비트 회전. |
RZGate(phi[, 레이블] ) | Z축을 중심으로 한 단일 큐비트 회전. |
SGate(*args[, _force_mutable] ) | 단일 큐비트 S 게이트 ( ). |
SdgGate(*args[, _force_mutable] ) | 단일 큐비트 S-공액 게이트 ( ). |
SXGate(*args[, _force_mutable] ) | 단일 큐비트 Sqrt(X) 게이트 ( ). |
SXdgGate(*args[, _force_mutable] ) | 역 단일 큐비트 Sqrt(X) 게이트입니다. |
TGate(*args[, _force_mutable] ) | 단일 큐비트 T 게이트 ( ). |
TdgGate(*args[, _force_mutable] ) | 단일 큐비트 T-부속 게이트 ( ). |
UGate(세타, 피, 람[, 레이블] ) | ZYZ 오일러 각도의 일반적인 단일 큐비트 회전. |
U1Gate(theta[, 레이블] ) | Z축을 중심으로 한 단일 큐비트 회전. |
U2Gate(phi, lam[, label] ) | X+Z 축을 중심으로 한 단일 큐비트 회전. |
U3Gate(세타, 피, 람[, 레이블] ) | 3개의 오일러 각을 가진 일반 단일 큐비트 회전 게이트. |
XGate(*args[, _force_mutable] ) | 단일 큐비트 폴리-X 게이트 ( ). |
YGate(*args[, _force_mutable] ) | 단일 큐비트 폴리-Y 게이트 ( ). |
ZGate(*args[, _force_mutable] ) | 단일 큐비트 폴리-Z 게이트 ( ). |
2큐비트 표준 게이트
CHGate(*args[, _force_mutable] ) | 제어-하다마드 게이트. |
CPhaseGate(theta[, label, ctrl_state,...] ) | 제어 위상 게이트. |
CRXGate(theta[, label, ctrl_state, _base_label] ) | 제어된 RX 게이트. |
CRYGate(theta[, label, ctrl_state, _base_label] ) | 제어-RY 게이트. |
CRZGate(theta[, label, ctrl_state, _base_label] ) | 제어형 RZ 게이트. |
CSGate(*args[, _force_mutable] ) | 제어-S 게이트. |
CSdgGate(*args[, _force_mutable] ) | 제어형 - 게이트. |
CSXGate(*args[, _force_mutable] ) | 제어 √X 게이트. |
CUGate(세타, 피, 람, 감마[, 레이블,...] ) | 제어-U 게이트(4-파라미터 2-큐비트 게이트). |
CU1Gate(theta[, label, ctrl_state, _base_label] ) | Controlled-U1 게이트. |
CU3Gate(세타, 피, 람[, 레이블,...] ) | Controlled-U3 게이트(3-파라미터 2-쿼비트 게이트). |
CXGate(*args[, _force_mutable] ) | 제어된-X 게이트. |
CYGate(*args[, _force_mutable] ) | 제어-Y 게이트. |
CZGate(*args[, _force_mutable] ) | 제어-Z 게이트. |
DCXGate(*args[, _force_mutable] ) | 더블-CX 게이트. |
ECRGate(*args[, _force_mutable] ) | 울려 퍼지는 교차 공명 게이트. |
iSwapGate(*args[, _force_mutable] ) | iSWAP 게이트. |
RXXGate(theta[, 레이블] ) | 파라메트릭 2쿼비트 상호작용(XX를 중심으로 회전). |
RYYGate(theta[, 레이블] ) | 파라메트릭 2쿼비트 상호작용(YY를 중심으로 회전). |
RZXGate(theta[, 레이블] ) | 파라메트릭 2쿼비트 상호작용(ZX를 중심으로 회전). |
RZZGate(theta[, 레이블] ) | 파라메트릭 2쿼비트 상호작용(ZZ를 중심으로 회전). |
SwapGate(*args[, _force_mutable] ) | 스왑 게이트입니다. |
XXMinusYYGate(세타[, 베타, 레이블] ) | XX-YY 인터랙션 게이트. |
XXPlusYYGate(세타[, 베타, 레이블] ) | XX+YY 인터랙션 게이트. |
3개 이상의 큐비트 표준 게이트
C3SXGate(*args[, _force_mutable] ) | 3-큐비트 제어 sqrt-X 게이트. |
C3XGate(*args[, _force_mutable] ) | X 게이트는 3 큐비트로 제어됩니다. |
C4XGate(*args[, _force_mutable] ) | 4-큐비트 제어 X 게이트. |
CCXGate(*args[, _force_mutable] ) | 토폴리 게이트라고도 하는 CCX 게이트. |
CCZGate(*args[, _force_mutable] ) | CCZ 게이트. |
CSwapGate(*args[, _force_mutable] ) | 제어형 스왑 게이트, 프레드킨 게이트라고도 합니다. |
RCCXGate(*args[, _force_mutable] ) | 단순화된 토폴리 게이트는 마골루스 게이트라고도 합니다. |
RC3XGate(*args[, _force_mutable] ) | 간소화된 3 제어 토폴리 게이트. |
글로벌 표준 게이트
다음 게이트는 전역적이며 큐비트 인수를 받지 않습니다.
GlobalPhaseGate(단계[, 레이블] ) | 글로벌 위상 게이트 ( ). |
표준 지침
지시어는 백엔드 또는 트랜스파일러가 해석하도록 되어 있는 퀀텀 스택에 대한 연산입니다. 일반적으로 트랜스파일러 또는 백엔드는 해당 구현이 없는 경우 선택적으로 이를 무시할 수 있습니다.
표준 오퍼레이션
연산은 회로의 양자 상태를 되돌릴 수 없는 상태로 변경하는 것입니다.
또한 Measure, 파울리 기반 계산의 기본 연산으로 사용되는 일반화된 공동 파울리 측정이 존재한다.
PauliProductMeasurement(pauli[, 레이블] ) | 파울리 곱 측정 지침. |
일반화된 게이트
이 모듈은 더 광범위한 기본 게이트 모음으로 표준 게이트를 확장합니다. 여기에는 가변적인 게이트, 즉 입력에 따라 큐비트 수가 달라지는 게이트가 포함됩니다. 예를 들어,
from qiskit.circuit.library import DiagonalGate
diagonal = DiagonalGate([1, 1j])
print(diagonal.num_qubits)
diagonal = DiagonalGate([1, 1, 1, -1])
print(diagonal.num_qubits)인쇄합니다:
1
2DiagonalGate(진단) | 일반적인 대각선 양자 게이트입니다. |
PermutationGate(패턴) | 큐비트를 퍼미팅하는 게이트입니다. |
MCMTGate(게이트, 제어 큐비트 수,...[,...] ) | 임의의 단일 제어 대상 게이트를 위한 다중 제어 멀티 타겟 게이트입니다. |
MCPhaseGate(lam, num_ctrl_qubits[, label,...] ) | 다중 제어 위상 게이트. |
MCXGate( [num_ctrl_qubits, label,...] ) | 일반적인 다중 제어 X 게이트입니다. |
MSGate(num_qubits, theta[, label] ) | 몰머-쇠렌센 게이트. |
RVGate(v_x, v_y, v_z[, 기저] ) | 임의의 회전축을 중심으로 한 회전 여기서 는 라디안 단위의 회전 각도이다. |
PauliGate(라벨) | 멀티 큐비트 폴리 게이트. |
PauliProductRotationGate(pauli, angle[, label] ) | 일반적인 파울리 회전. |
LinearFunction(선형[, validate_input] ) | N개의 큐비트로 구성된 선형 가역 회로. |
Isometry(등거리 변환, num_ancillas_zero,...[,...] ) | 에서 큐비트로의 임의 아이소메트리 분해. |
UnitaryGate(데이터[, 레이블, check_input,...] ) | 유니터리 행렬로 정의된 양자 게이트를 나타내는 클래스. |
UCGate(gate_list[, up_to_diagonal, mux_simp] ) | 균일하게 제어되는 게이트(멀티플렉싱 게이트라고도 함). |
UCPauliRotGate(각도_목록, 회전_축) | 균일하게 제어되는 폴리 회전. |
UCRXGate(angle_list) | 균일하게 제어되는 폴리-X 회전. |
UCRYGate(angle_list) | 균일하게 제어되는 폴리-Y 회전. |
UCRZGate(angle_list) | 균일하게 제어되는 폴리-Z 회전. |
Instruction위의 객체들은 또는 를 파생시키며 Gate , 이를 통해 컴파일러는 추상적인 수준에서 해당 객체들을 분석할 수 있습니다. 따라서 우리는 다음의 표현들 대신 이 표현들을 사용할 것을 제안합니다. 다음의 표현들은 파생되며 QuantumCircuit , 조급하게 생성되기 때문입니다.
Diagonal(진단) | 대각선 변환을 구현하는 회로입니다. |
MCMT(게이트, 제어 큐비트 수, 대상 큐비트 수) | 임의의 단일 제어 대상 게이트를 위한 다중 제어 멀티 타겟 게이트입니다. |
MCMTVChain(게이트, 제어 큐비트 수,...) | CCX V-체인을 사용한 MCMT 구현. |
MCXGrayCode( [num_ctrl_qubits, label,...] ) | 그레이 코드를 사용하여 다중 제어 X 게이트를 구현합니다. |
MCXRecursive( [num_ctrl_qubits, label,...] ) | 재귀를 사용하여 다중 제어 X 게이트를 구현합니다. |
MCXVChain( [num_ctrl_qubits, dirty_ancillas,...] ) | CX 게이트의 V-체인을 사용하여 다중 제어 X 게이트를 구현합니다. |
Permutation(num_qubits[, pattern, seed] ) | 큐비트를 퍼미팅하는 n_큐비트 회로입니다. |
GMS(num_qubits, theta) | 글로벌 몰머-쇠렌센 게이트. |
GR(num_qubits, theta, phi) | 글로벌 R 게이트. |
GRX(num_qubits, theta) | 글로벌 RX 게이트. |
GRY(num_qubits, theta) | 글로벌 RY 게이트. |
GRZ(num_qubits, phi) | 글로벌 RZ 게이트. |
부울 논리
Gate이들은 큐비트 상태 집합의 논리적 or 연산과 같은 부울 논리 연산을 구현합니다.
AndGate(변수_큐비트 수[, 플래그] ) | 여러 큐비트에 대한 논리 AND 연산을 나타내는 게이트입니다. |
OrGate(변수_큐비트 수[, 플래그] ) | 여러 큐비트에 대한 논리적 OR 연산을 나타내는 게이트입니다. |
BitwiseXorGate(qubit 수, 수량) | 어떤 정수로 입력을 비트 단위로 XOR하는 n-큐비트 게이트 amount. |
InnerProductGate(num_qubits) | 에 대해 두 n-큐비트 벡터의 내적 곱을 계산하는 2n-qubit 부울 함수입니다. |
위의 객체들은 이 타입을 파생받거나 Gate (또는 이 타입을 반환하므로), 컴파일러가 추상적인 수준에서 이를 분석할 수 있게 해줍니다. 따라서 우리는 를 QuantumCircuit 유도하고 조급하게 생성되는 다음의 것들 대신 이 것을 사용할 것을 제안합니다.
AND(num_variable_qubits[, flags, mcx_mode] ) | 여러 큐비트에 논리 AND 연산을 구현하는 회로입니다. |
OR(num_variable_qubits[, flags, mcx_mode] ) | 여러 큐비트에서 논리 OR 연산을 구현하는 회로입니다. |
XOR(num_qubits[, amount, seed] ) | 어떤 정수로 입력을 비트 단위로 XOR하는 n_쿼비트 회로 amount. |
InnerProduct(num_qubits) | 에 대해 두 n-큐비트 벡터의 내적 곱을 계산하는 2n-qubit 부울 함수입니다. |
임의의 비트 단위 xor 회로를 사용하여 직접 생성할 수 있습니다:
random_bitwise_xor(num_qubits, seed) | 무작위로 BitwiseXorGate 을 생성합니다. |
기준 변경
이 게이트는 큐비트 상태의 기저 변환을 수행합니다. 예를 들어, 양자 푸리에 변환(QFT)의 경우 계산 기저와 푸리에 기저 사이에서 변환합니다.
QFTGate(num_qubits) | 양자 푸리에 변환 게이트. |
Gate위의 객체는 를 파생시키며, 이를 통해 컴파일러는 추상적인 수준에서 해당 객체에 대해 추론할 수 있습니다. 따라서 우리는 를 QuantumCircuit 유도하고 조급하게 구성되는 다음 코드 대신 이 코드를 사용할 것을 제안합니다.
QFT( [qubit_수, 근사화_정밀도,...] ) | 양자 푸리에 변환 회로. |
산술
이러한 게이트와 회로는 덧셈이나 곱셈과 같은 고전적인 산술을 수행합니다.
독사
덧셈기는 두 개의 -쿼비트 레지스터의 합을 계산합니다
여기서 출력 레지스터의 크기 는 사용된 가산기 유형에 따라 달라집니다.
ModularAdderGate(num_state_qubits[, label] ) | 크기의 큐비트 레지스터 두 개를 합한 모듈을 계산합니다. |
HalfAdderGate(num_state_qubits[, label] ) | 캐리아웃 비트를 포함하여 동일한 크기의 큐비트 레지스터 두 개의 합을 계산합니다. |
FullAdderGate(num_state_qubits[, label] ) | 반입 비트와 반출 비트를 포함한 크기의 큐비트 레지스터 두 개의 합을 계산합니다. |
Gate위의 객체들은 를 파생시키며, 이를 통해 컴파일러는 추상적인 수준에서 해당 객체들을 분석할 수 있습니다. 따라서 우리는 를 QuantumCircuit 유도하고 조급하게 생성되는 다음의 것들 대신 이 것을 사용할 것을 제안합니다.
DraperQFTAdder(num_state_qubits[, kind, name] ) | QFT를 사용하여 두 큐비트 레지스터에서 제자리 덧셈을 수행하는 회로입니다. |
CDKMRippleCarryAdder(num_state_qubits[,...] ) | 두 큐비트 레지스터에서 제자리 덧셈을 수행하는 리플 캐리 회로입니다. |
VBERippleCarryAdder(num_state_qubits[,...] ) | VBE 리플 캐리 가산기 [1]. |
승수
승수는 두 개의 -쿼비트 레지스터의 곱을 계산합니다
여기서 은 결과를 표현하는 데 사용되는 비트 수입니다.
MultiplierGate(num_state_qubits[,...] ) | 동일한 크기의 큐비트 레지스터 두 개를 새 레지스터로 곱한 값을 계산합니다. |
Gate위의 객체는 를 파생시키며, 이를 통해 컴파일러는 추상적인 수준에서 해당 객체에 대해 추론할 수 있습니다. 따라서 우리는 를 QuantumCircuit 유도하고 조급하게 생성되는 다음 표현식 대신 이 표현식을 사용할 것을 제안합니다.
HRSCumulativeMultiplier(num_state_qubits[,...] ) | 두 입력 레지스터의 곱셈을 제자리에 저장하는 곱셈 회로입니다. |
RGQFTMultiplier(num_state_qubits[,...] ) | 두 입력 레지스터의 곱셈을 제자리에 저장하는 QFT 곱셈 회로입니다. |
진폭 함수
진폭 함수는 큐비트의 진폭에 적용된 함수를 근사화합니다. 자세한 내용은 클래스 문서 문자열을 참조하세요.
LinearAmplitudeFunctionGate(...[, ...]) | 큐비트 진폭에 대해 (부분적으로) 선형 함수를 구현하는 회로입니다. |
Gate위의 객체는 를 파생시키며, 이를 통해 컴파일러는 추상적인 수준에서 해당 객체에 대해 추론할 수 있습니다. 따라서 우리는 를 QuantumCircuit 유도하고 조급하게 구성되는 다음 코드 대신 이 코드를 사용할 것을 제안합니다.
LinearAmplitudeFunction(num_state_qubits,...) | 큐비트 진폭에 대해 (부분적으로) 선형 함수를 구현하는 회로입니다. |
기능적 파울리 회전
함수형 폴리 회전은 다음과 같은 형식의 연산을 구현합니다
선형, 다항식 또는 이들의 조각별 버전과 같은 다양한 유형의 함수 에 대해 Pauli- 회전을 사용합니다. 위의 진폭 함수와 유사하지만 대상 함수의 도메인 및 이미지에 대한 사전 및 사후 처리가 없습니다.
LinearPauliRotationsGate(num_state_qubits[,...] ) | 선형 제어 X, Y 또는 Z 회전. |
PolynomialPauliRotationsGate(num_state_qubits) | 다항식 폴리 회전을 구현하는 게이트입니다. |
PiecewiseLinearPauliRotationsGate([...]) | 조각 단위로 선형 제어되는 폴리 회전. |
PiecewisePolynomialPauliRotationsGate(...[, ...]) | 조각 단위로 다항식으로 제어되는 폴리 회전. |
PiecewiseChebyshevGate(f_x, num_state_qubits) | 입력 함수에 대한 부분적인 체비셰프 근사치입니다. |
Gate위의 객체들은 를 파생시키며, 이를 통해 컴파일러는 추상적인 수준에서 해당 객체들을 분석할 수 있습니다. 따라서 우리는 를 QuantumCircuit 유도하고 조급하게 생성되는 다음의 것들 대신 이 것을 사용할 것을 제안합니다.
FunctionalPauliRotations( [num_state_qubits,...] ) | 함수형 폴리 로테이션을 위한 베이스 클래스입니다. |
LinearPauliRotations( [num_state_qubits,...] ) | 선형 제어 X, Y 또는 Z 회전. |
PolynomialPauliRotations( [num_state_qubits,...] ) | 다항식 폴리 회전을 구현하는 회로입니다. |
PiecewiseLinearPauliRotations([...]) | 조각 단위로 선형 제어되는 폴리 회전. |
PiecewisePolynomialPauliRotations([...]) | 조각 단위로 다항식으로 제어되는 폴리 회전. |
PiecewiseChebyshev(f_x[, 각도,...] ) | 입력 함수에 대한 부분적인 체비셰프 근사치입니다. |
기타 산술 함수
여기에는 추가 산술 회로가 나열되어 있습니다. 자세한 내용은 개별 클래스 설명서를 참조하세요.
ExactReciprocalGate(num_state_qubits, 스케일링) | 정확한 상호 기능을 구현합니다. |
IntegerComparatorGate(num_state_qubits, value) | 기존 정수에 대해 큐비트 레지스터에서 (또는 )를 수행합니다. |
QuadraticFormGate( [num_result_qubits,...] ) | 큐비트 레지스터로 인코딩된 이진 변수에 2진법 형식을 구현합니다. |
WeightedSumGate(num_state_qubits[, weights,...] ) | 큐비트 레지스터의 가중치 합계를 계산하는 게이트입니다. |
Gate위의 객체들은 를 파생시키며, 이를 통해 컴파일러는 추상적인 수준에서 해당 객체들을 분석할 수 있습니다. 따라서 우리는 를 QuantumCircuit 유도하고 조급하게 생성되는 다음의 것들 대신 이 것을 사용할 것을 제안합니다.
ExactReciprocal(num_state_qubits, scaling[,...] ) | 정확한 상호 |
IntegerComparator( [num_state_qubits, value,...] ) | 정수 비교기. |
QuadraticForm( [num_result_qubits,...] ) | 큐비트 레지스터로 인코딩된 이진 변수에 2진법 형식을 구현합니다. |
WeightedAdder( [num_state_qubits, weights, name] ) | 큐비트 레지스터의 가중치 합계를 계산하는 회로입니다. |
특정 양자 회로
다음 게이트와 양자 회로는 관심 있는 특정 연산을 정의합니다:
fourier_checking(f, g) | 푸리에 검사 회로. |
hidden_linear_function(인접 행렬) | 숨겨진 선형 함수 문제를 해결하기 위한 회로입니다. |
iqp(상호작용) | 순간 양자 다항식 시간(IQP) 회로. |
random_iqp(num_qubits[, seed] ) | 임의의 순간 양자 다항식 시간(IQP) 회로입니다. |
quantum_volume(qubit 수[, 깊이, 시드] ) | 양자 볼륨 모델 회로입니다. |
phase_estimation(평가 큐비트 수, 유니터리) | 위상 추정 회로. |
grover_operator(오라클[, state_preparation,...] ) | Grover 연산자를 구축합니다. |
unitary_overlap(unitary1, unitary2[, ...]) | 두 유니타리 사이의 중첩을 반환하는 회로 . |
GraphStateGate(인접 행렬) | 그래프 상태를 나타내는 게이트입니다. |
PauliEvolutionGate(연산자[, 시간, 레이블,...] ) | 폴리스로 구성된 연산자의 시간 진화. |
HamiltonianGate(데이터, 시간[, 레이블] ) | 해밀턴 연산자에 의한 진화를 게이트로 표현하는 클래스입니다. |
아래에서는 클래스 파생과 동일한 연산을 제공합니다 QuantumCircuit. 그러나 런타임 및 컴파일러 성능을 개선하려면 위의 함수와 게이트를 사용하는 것이 좋습니다.
FourierChecking(f, g) | 푸리에 검사 회로. |
GraphState(인접 행렬) | 회로를 사용하여 그래프 상태를 준비합니다. |
HiddenLinearFunction(인접 행렬) | 숨겨진 선형 함수 문제를 해결하기 위한 회로입니다. |
IQP(상호작용) | 순간 양자 다항식(IQP) 회로. |
QuantumVolume(num_qubits[, depth, seed,...] ) | 양자 볼륨 모델 회로입니다. |
PhaseEstimation(평가 큐비트 수, 유니터리) | 위상 추정 회로. |
GroverOperator(오라클[, state_preparation,...] ) | Grover 운영자. |
UnitaryOverlap(unitary1, unitary2[, ...]) | 두 유니타리 사이의 중첩을 반환하는 회로 . |
N-로컬 회로
다음 함수는 매개변수화된 QuantumCircuit 을 반환하여 다양한 가변 양자 알고리즘에서 앤사츠로 사용할 수 있습니다.
예를 들어, 변형 회로를 만들 수 있습니다
from qiskit.circuit.library import efficient_su2
num_qubits = 4
ansatz = efficient_su2(num_qubits, entanglement="pairwise")
ansatz.draw("mpl")
와 결합하여
from qiskit.circuit.library import zz_feature_map
circuit = zz_feature_map(num_qubits)
circuit.barrier()
circuit.compose(ansatz, inplace=True)
circuit.draw("mpl")
를 사용하여 가변 양자 분류를 위한 회로를 얻습니다.
다음 함수는 모두 변형 회로를 구성하며 빠른 구성에 최적화되어 있습니다:
n_local(qubit 수, 회전 블록 수,...[,...] ) | N-국소 변동 회로를 구축합니다. |
efficient_su2(num_qubits[, su2_gates,...] ) | 하드웨어 효율이 높은 2-로컬 회로. |
real_amplitudes(qubit 수[, 얽힘,...] ) | 실제 진폭 2 로컬 회로를 구축합니다. |
pauli_two_design(num_qubits[, reps, seed,...] ) | 폴리 2 디자인 안사츠를 구축합니다. |
excitation_preserving(num_qubits[, mode,...] ) | 휴리스틱 여기 보존 파동 함수 안사츠. |
qaoa_ansatz(cost_operator[, reps,...] ) | 사용자 지정 초기 상태 및 믹서를 지원하는 일반화된 QAOA 양자 회로입니다. |
hamiltonian_variational_ansatz(해밀토니안) | 해밀턴의 변형 안식을 구축합니다. |
evolved_operator_ansatz(운영자[, 담당자, …] ) | 연산자 진화에서 안사츠를 구축합니다. |
위의 기능을 사용하는 것이 좋지만, 회로를 블록으로 감싸고 회로의 제자리 변형을 허용하는 다음 BlueprintCircuit 도 계속 지원합니다:
NLocal( [qubit 수, 회전 블록 수,...] ) | N-로컬 서킷 클래스입니다. |
TwoLocal( [qubit 수, 회전 블록 수,...] ) | 두 개의 로컬 회로. |
PauliTwoDesign( [num_qubits, reps, seed,...] ) | 폴리 투 디자인 안사츠. |
RealAmplitudes( [qubit 수, 얽힘,...] ) | 실제 진폭 2 로컬 회로. |
EfficientSU2( [num_qubits, su2_gates,...] ) | 하드웨어 효율적인 SU(2) 2-로컬 회로. |
EvolvedOperatorAnsatz( [운영자, 담당자, …] ) | 진화한 연산자 안사츠. |
ExcitationPreserving( [num_qubits, mode,...] ) | 휴리스틱 여기 보존 파동 함수 안사츠. |
QAOAAnsatz( [cost_operator, reps,...] ) | 사용자 지정 초기 상태 및 믹서를 지원하는 일반화된 QAOA 양자 회로입니다. |
데이터 인코딩 회로
다음 함수는 일련의 가변 양자 알고리즘에서 데이터 인코딩 회로로 사용할 수 있도록 매개변수화된 QuantumCircuit 를 반환하여 일련의 가변 양자 알고리즘에서 데이터 인코딩 회로로 사용할 수 있습니다:
pauli_feature_map(feature_dimension[, reps,...] ) | 폴리 확장 회로. |
z_feature_map(feature_dimension[, reps,...] ) | 첫 번째 차수 폴리 Z-진화 회로. |
zz_feature_map(feature_dimension[, reps,...] ) | 2차 폴리-Z 진화 회로. |
위의 기능을 사용하는 것이 좋지만, 회로를 블록으로 감싸고 회로의 제자리 변형을 허용하는 다음 BlueprintCircuit 도 계속 지원합니다:
PauliFeatureMap( [feature_dimension, reps,...] ) | 폴리 확장 회로. |
ZFeatureMap(feature_dimension[, reps,...] ) | 첫 번째 차수 폴리 Z-진화 회로. |
ZZFeatureMap(feature_dimension[, reps,...] ) | 2차 폴리-Z 진화 회로. |
데이터 준비 회로
상태 준비에는 다음 작업이 사용됩니다:
StatePreparation(params[, num_qubits,...] ) | 복잡한 진폭 상태 준비. |
Initialize(params[, num_qubits, normalize] ) | 복잡한 진폭 초기화. |
오라클
'오라클'은 양자 상태에 대한 다양한 블랙박스 연산을 지칭할 수 있습니다. 여기서는 위상 플립을 통해 부울 함수 를 구현하는 오라클을 고려합니다
또는 비트 플립
이는 다음에서 구현됩니다
PhaseOracleGate(표현식[, var_order, 레이블] ) | 위상 오라클을 구현합니다. |
BitFlipOracleGate(표현식[, var_order, 레이블] ) | 비트 플립 오라클 구현 |
grover_operator()또한 그로버 알고리즘의 중요한 구성 요소이기도 합니다(참조).
QuantumCircuitGate- 기반 구현 외에도, 위상 반전 오라클의 - 버전도 지원합니다
PhaseOracle(식[, var_order] ) | 단계 Oracle. |
템플릿 회로
템플릿은 ID를 계산하는 회로를 반환하는 함수입니다. 템플릿의 일부를 일치시키면 컴파일러가 템플릿에서 나머지 부분의 역으로 일치하는 부분을 대체하는 회로 최적화에서 사용됩니다.
이 예에서는 템플릿의 ID 상수를 확인합니다:
from qiskit.circuit.library.templates import template_nct_4b_1
from qiskit.quantum_info import Operator
import numpy as np
template = template_nct_4b_1()
identity = np.identity(2 ** len(template.qubits), dtype=complex)
data = Operator(template).data
np.allclose(data, identity) # True, template_nct_4b_1 is the identityNCT(Not-CNOT-Toffoli) 템플릿 회로
XGate, CXGate, 및 CCXGate (토폴리) 게이트용 템플릿 회로.
참조 자료:
Maslov, D. 및 Dueck, G. W. 및 Miller, D. M., 가역적 토폴리 네트워크 합성 기법, 2007 https://dx.doi.org/10.1145/1278349.1278355
template_nct_2a_1
qiskit.circuit.library.templates.nct.template_nct_2a_1()
템플릿 2a_1:
┌───┐┌───┐
q_0: ┤ X ├┤ X ├
└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_2a_2
qiskit.circuit.library.templates.nct.template_nct_2a_2()
템플릿 2a_2:
q_0: ──■────■──
┌─┴─┐┌─┴─┐
q_1: ┤ X ├┤ X ├
└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_2a_3
qiskit.circuit.library.templates.nct.template_nct_2a_3()
템플릿 2a_3:
q_0: ──■────■──
│ │
q_1: ──■────■──
┌─┴─┐┌─┴─┐
q_2: ┤ X ├┤ X ├
└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_4a_1
qiskit.circuit.library.templates.nct.template_nct_4a_1()
템플릿 4a_1:
q_0: ───────■─────────■──
│ │
q_1: ──■────┼────■────┼──
│ │ │ │
q_2: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_3: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_4: ┤ X ├─────┤ X ├─────
└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_4a_2
qiskit.circuit.library.templates.nct.template_nct_4a_2()
템플릿 4a_2:
q_0: ──■─────────■───────
│ │
q_1: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_2: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_3: ┤ X ├─────┤ X ├─────
└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_4a_3
qiskit.circuit.library.templates.nct.template_nct_4a_3()
템플릿 4a_3:
q_0: ──■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──┼──┤ X ├──┼──┤ X ├
┌─┴─┐└───┘┌─┴─┐└───┘
q_2: ┤ X ├─────┤ X ├─────
└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_4b_1
qiskit.circuit.library.templates.nct.template_nct_4b_1()
템플릿 4b_1:
q_0: ───────■─────────■──
│ │
q_1: ──■────┼────■────┼──
│ │ │ │
q_2: ──■────■────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_3: ┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_4b_2
qiskit.circuit.library.templates.nct.template_nct_4b_2()
템플릿 4b_2:
q_0: ──■─────────■───────
│ │
q_1: ──■────■────■────■──
┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐
q_2: ┤ X ├┤ X ├┤ X ├┤ X ├
└───┘└───┘└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_5a_1
qiskit.circuit.library.templates.nct.template_nct_5a_1()
템플릿 5a_1:
q_0: ──■────■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_5a_2
qiskit.circuit.library.templates.nct.template_nct_5a_2()
템플릿 5a_2:
q_0: ──■─────────■─────────■──
│ ┌───┐ │ ┌───┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_5a_3
qiskit.circuit.library.templates.nct.template_nct_5a_3()
템플릿 5a_3:
q_0: ───────■─────────■────■──
┌─┴─┐ ┌─┴─┐ │
q_1: ──■──┤ X ├──■──┤ X ├──┼──
┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
q_2: ┤ X ├─────┤ X ├─────┤ X ├
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_5a_4
qiskit.circuit.library.templates.nct.template_nct_5a_4()
템플릿 5a_4:
┌───┐ ┌───┐
q_0: ──■──┤ X ├──■──┤ X ├
┌─┴─┐└───┘┌─┴─┐├───┤
q_1: ┤ X ├─────┤ X ├┤ X ├
└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_6a_1
qiskit.circuit.library.templates.nct.template_nct_6a_1()
템플릿 6a_1:
┌───┐ ┌───┐ ┌───┐
q_0: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_1: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_6a_2
qiskit.circuit.library.templates.nct.template_nct_6a_2()
템플릿 6a_2:
q_0: ──■────■────■────■────■────■──
│ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_6a_3
qiskit.circuit.library.templates.nct.template_nct_6a_3()
템플릿 6a_3:
q_0: ───────■─────────■────■────■──
┌─┴─┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_6a_4
qiskit.circuit.library.templates.nct.template_nct_6a_4()
템플릿 6a_4:
q_0: ───────■──────────────■───────
┌─┴─┐ ┌───┐ │ ┌───┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_6b_1
qiskit.circuit.library.templates.nct.template_nct_6b_1()
템플릿 6b_1:
q_0: ──■─────────■────■─────────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────■──┤ X ├──■────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_6b_2
qiskit.circuit.library.templates.nct.template_nct_6b_2()
템플릿 6b_2:
q_0: ───────■────■─────────■────■──
│ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────■──┤ X ├──■────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_6c_1
qiskit.circuit.library.templates.nct.template_nct_6c_1()
템플릿 6c_1:
q_0: ──■─────────■─────────■────■──
│ ┌───┐ │ ┌───┐ │ ┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├──■──┤ X ├
┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐└─┬─┘
q_2: ┤ X ├──■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_7a_1
qiskit.circuit.library.templates.nct.template_nct_7a_1()
템플릿 7a_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└─┬─┘┌─┴─┐ │ ┌─┴─┐└─┬─┘ │
q_1: ──■──┤ X ├──■────■──┤ X ├──■────■──
└───┘┌─┴─┐┌─┴─┐└───┘ ┌─┴─┐
q_2: ──────────┤ X ├┤ X ├──────────┤ X ├
└───┘└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_7b_1
qiskit.circuit.library.templates.nct.template_nct_7b_1()
템플릿 7b_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├──■────■──┤ X ├───────■──
└───┘┌─┴─┐┌─┴─┐└───┘ ┌─┴─┐
q_2: ──────────┤ X ├┤ X ├──────────┤ X ├
└───┘└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_7c_1
qiskit.circuit.library.templates.nct.template_nct_7c_1()
템플릿 7c_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├──■────■──┤ X ├───────■──
└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_7d_1
qiskit.circuit.library.templates.nct.template_nct_7d_1()
템플릿 7d_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└─┬─┘┌─┴─┐ │ ┌─┴─┐└─┬─┘ │
q_1: ──■──┤ X ├──■────■──┤ X ├──■────■──
└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_7e_1
qiskit.circuit.library.templates.nct.template_nct_7e_1()
템플릿 7e_1:
┌───┐ ┌───┐
q_0: ┤ X ├──■─────────■────■──┤ X ├──■──
└───┘┌─┴─┐ │ ┌─┴─┐└───┘ │
q_1: ─────┤ X ├───────┼──┤ X ├───────┼──
└─┬─┘┌───┐┌─┴─┐└─┬─┘ ┌─┴─┐
q_2: ───────■──┤ X ├┤ X ├──■───────┤ X ├
└───┘└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9a_1
qiskit.circuit.library.templates.nct.template_nct_9a_1()
템플릿 9a_1:
┌───┐ ┌───┐ ┌───┐
q_0: ┤ X ├──■──┤ X ├──■────■──┤ X ├──■──
└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐
q_1: ──■──┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├
└─┬─┘ │ ├───┤└─┬─┘┌───┐└─┬─┘
q_2: ───────■────■──┤ X ├──■──┤ X ├──■──
└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_1
qiskit.circuit.library.templates.nct.template_nct_9c_1()
템플릿 9c_1:
┌───┐ ┌───┐┌───┐ ┌───┐ ┌───┐
q_0: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_1: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_2
qiskit.circuit.library.templates.nct.template_nct_9c_2()
템플릿 9c_2:
q_0: ───────■────■──────────────■────■─────────■──
┌───┐ │ ┌─┴─┐┌───┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_3
qiskit.circuit.library.templates.nct.template_nct_9c_3()
템플릿 9c_3:
q_0: ───────■────────────────────────■────────────
┌───┐ │ ┌───┐┌───┐ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_4
qiskit.circuit.library.templates.nct.template_nct_9c_4()
템플릿 9c_4:
q_0: ──■────■─────────■──────────────■────────────
┌─┴─┐ │ ┌───┐┌─┴─┐ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_5
qiskit.circuit.library.templates.nct.template_nct_9c_5()
템플릿 9c_5:
q_0: ────────────■─────────■──────────────■───────
┌───┐ ┌─┴─┐┌───┐ │ ┌───┐ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_6
qiskit.circuit.library.templates.nct.template_nct_9c_6()
템플릿 9c_6:
q_0: ───────■────■─────────■─────────■────■───────
┌───┐ │ ┌─┴─┐┌───┐ │ ┌───┐ │ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_7
qiskit.circuit.library.templates.nct.template_nct_9c_7()
템플릿 9c_7:
q_0: ──■────■────■────■────■─────────■────■───────
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ │ ┌───┐ │ │ ┌───┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_8
qiskit.circuit.library.templates.nct.template_nct_9c_8()
템플릿 9c_8:
q_0: ──■─────────■────■─────────■──────────────■──
┌─┴─┐ ┌─┴─┐┌─┴─┐ ┌─┴─┐ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_9
qiskit.circuit.library.templates.nct.template_nct_9c_9()
템플릿 9c_9:
q_0: ──■────■────■────■─────────■────■─────────■──
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├─────┤ X ├──■───────┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌───┐└─┬─┘┌─┴─┐┌───┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_10
qiskit.circuit.library.templates.nct.template_nct_9c_10()
템플릿 9c_10:
q_0: ──■─────────■────■────■────■─────────■────■──
┌─┴─┐ ┌─┴─┐┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_11
qiskit.circuit.library.templates.nct.template_nct_9c_11()
템플릿 9c_11:
q_0: ───────■────■─────────■────■────■────■────■──
┌───┐ │ ┌─┴─┐┌───┐ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9c_12
qiskit.circuit.library.templates.nct.template_nct_9c_12()
템플릿 9c_12:
q_0: ──■────■────■────■────■────■────■────■────■──
┌─┴─┐ │ ┌─┴─┐┌─┴─┐ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ┤ X ├──■──┤ X ├┤ X ├──┼──┤ X ├──■────┼──┤ X ├
└─┬─┘┌─┴─┐└───┘└─┬─┘┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ──■──┤ X ├───────■──┤ X ├──■──┤ X ├┤ X ├──■──
└───┘ └───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_1
qiskit.circuit.library.templates.nct.template_nct_9d_1()
템플릿 9d_1:
┌───┐ ┌───┐ ┌───┐
q_0: ──■───────┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌───┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_1: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_2
qiskit.circuit.library.templates.nct.template_nct_9d_2()
템플릿 9d_2:
q_0: ──■────■────■──────────────■──────────────■──
│ │ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_3
qiskit.circuit.library.templates.nct.template_nct_9d_3()
템플릿 9d_3:
q_0: ──■────■───────────────────■─────────────────
│ │ ┌───┐ ┌─┴─┐ ┌───┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_4
qiskit.circuit.library.templates.nct.template_nct_9d_4()
템플릿 9d_4:
q_0: ───────■─────────■──────────────■────────────
│ ┌───┐ │ ┌───┐ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_5
qiskit.circuit.library.templates.nct.template_nct_9d_5()
템플릿 9d_5:
q_0: ──■────■─────────■─────────■────■────────────
│ │ ┌───┐ │ ┌─┴─┐ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_6
qiskit.circuit.library.templates.nct.template_nct_9d_6()
템플릿 9d_6:
q_0: ──■────■──────────────■────■─────────■───────
│ │ ┌───┐ │ ┌─┴─┐ │ ┌───┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_7
qiskit.circuit.library.templates.nct.template_nct_9d_7()
템플릿 9d_7:
q_0: ──■────■─────────■────■────■────■────■───────
│ │ ┌───┐ │ │ ┌─┴─┐ │ │ ┌───┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_8
qiskit.circuit.library.templates.nct.template_nct_9d_8()
템플릿 9d_8:
q_0: ──■────■────■────■─────────■────■─────────■──
│ │ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_9
qiskit.circuit.library.templates.nct.template_nct_9d_9()
템플릿 9d_9:
q_0: ──■────■────■─────────■────■─────────■────■──
│ │ ┌─┴─┐ │ ┌─┴─┐ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├───────■──┤ X ├───────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘┌───┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
template_nct_9d_10
qiskit.circuit.library.templates.nct.template_nct_9d_10()
템플릿 9d_10:
q_0: ──■────■────■────■────■────■────■────■────■──
│ │ ┌─┴─┐ │ │ ┌─┴─┐ │ │ ┌─┴─┐
q_1: ──■────┼──┤ X ├──┼────■──┤ X ├──┼────■──┤ X ├
┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘┌─┴─┐┌─┴─┐└─┬─┘
q_2: ┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──┤ X ├┤ X ├──■──
└───┘└───┘ └───┘└───┘ └───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
클리포드 템플릿 회로
클리포드 게이트 위의 템플릿 회로.
clifford_2_1
qiskit.circuit.library.clifford_2_1()
클리포드 템플릿 2_1:
q_0: ─■──■─
│ │
q_1: ─■──■─리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_2_2
qiskit.circuit.library.clifford_2_2()
클리포드 템플릿 2_2:
q_0: ──■────■──
┌─┴─┐┌─┴─┐
q_1: ┤ X ├┤ X ├
└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_2_3
qiskit.circuit.library.clifford_2_3()
클리포드 템플릿 2_3:
┌───┐┌───┐
q_0: ┤ H ├┤ H ├
└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_2_4
qiskit.circuit.library.clifford_2_4()
클리포드 템플릿 2_4:
q_0: ─X──X─
│ │
q_1: ─X──X─리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_3_1
qiskit.circuit.library.clifford_3_1()
클리포드 템플릿 3_1:
┌───┐┌───┐┌───┐
q_0: ┤ S ├┤ S ├┤ Z ├
└───┘└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_4_1
qiskit.circuit.library.clifford_4_1()
클리포드 템플릿 4_1:
┌───┐
q_0: ──■──┤ X ├──■───X─
┌─┴─┐└─┬─┘┌─┴─┐ │
q_1: ┤ X ├──■──┤ X ├─X─
└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_4_2
qiskit.circuit.library.clifford_4_2()
클리포드 템플릿 4_2:
q_0: ───────■────────■─
┌───┐┌─┴─┐┌───┐ │
q_1: ┤ H ├┤ X ├┤ H ├─■─
└───┘└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_4_3
qiskit.circuit.library.clifford_4_3()
클리포드 템플릿 4_3:
┌───┐ ┌─────┐
q_0: ┤ S ├──■──┤ SDG ├──■──
└───┘┌─┴─┐└─────┘┌─┴─┐
q_1: ─────┤ X ├───────┤ X ├
└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_4_4
qiskit.circuit.library.clifford_4_4()
클리포드 템플릿 4_4:
┌───┐ ┌─────┐
q_0: ┤ S ├─■─┤ SDG ├─■─
└───┘ │ └─────┘ │
q_1: ──────■─────────■─리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_5_1
qiskit.circuit.library.clifford_5_1()
클리포드 템플릿 5_1:
q_0: ──■─────────■─────────■── ┌─┴─┐ ┌─┴─┐ │ q_1: ┤ X ├──■──┤ X ├──■────┼── └───┘┌─┴─┐└───┘┌─┴─┐┌─┴─┐ q_2: ─────┤ X ├─────┤ X ├┤ X ├ └───┘ └───┘└───┘
리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_6_1
qiskit.circuit.library.clifford_6_1()
클리포드 템플릿 6_1:
┌───┐ ┌───┐┌───┐ q_0: ┤ H ├──■──┤ H ├┤ X ├ ├───┤┌─┴─┐├───┤└─┬─┘ q_1: ┤ H ├┤ X ├┤ H ├──■── └───┘└───┘└───┘
리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_6_2
qiskit.circuit.library.clifford_6_2()
클리포드 템플릿 6_2:
┌───┐ q_0: ┤ S ├──■───────────■───■─ ├───┤┌─┴─┐┌─────┐┌─┴─┐ │ q_1: ┤ S ├┤ X ├┤ SDG ├┤ X ├─■─ └───┘└───┘└─────┘└───┘
리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_6_3
qiskit.circuit.library.clifford_6_3()
클리포드 템플릿 6_3:
┌───┐ ┌───┐
q_0: ─X──■─┤ H ├──■──┤ X ├─────
│ │ └───┘┌─┴─┐└─┬─┘┌───┐
q_1: ─X──■──────┤ X ├──■──┤ H ├
└───┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_6_4
qiskit.circuit.library.clifford_6_4()
클리포드 템플릿 6_4:
global phase: 7π/4
┌───┐┌───┐┌───┐┌───┐┌───┐┌───┐
q: ┤ S ├┤ H ├┤ S ├┤ H ├┤ S ├┤ H ├
└───┘└───┘└───┘└───┘└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_6_5
qiskit.circuit.library.clifford_6_5()
클리포드 템플릿 6_5:
┌───┐
q_0: ─■───■───┤ S ├───■───────
│ ┌─┴─┐┌┴───┴┐┌─┴─┐┌───┐
q_1: ─■─┤ X ├┤ SDG ├┤ X ├┤ S ├
└───┘└─────┘└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_8_1
qiskit.circuit.library.clifford_8_1()
클리포드 템플릿 8_1:
┌───┐ ┌───┐ ┌───┐┌─────┐
q_0: ──■───────┤ X ├─┤ S ├─┤ X ├┤ SDG ├
┌─┴─┐┌───┐└─┬─┘┌┴───┴┐└─┬─┘└┬───┬┘
q_1: ┤ X ├┤ H ├──■──┤ SDG ├──■───┤ H ├─
└───┘└───┘ └─────┘ └───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_8_2
qiskit.circuit.library.clifford_8_2()
클리포드 템플릿 8_2:
┌───┐
q_0: ──■─────────■───┤ S ├───■────────────
┌─┴─┐┌───┐┌─┴─┐┌┴───┴┐┌─┴─┐┌───┐┌───┐
q_1: ┤ X ├┤ H ├┤ X ├┤ SDG ├┤ X ├┤ S ├┤ H ├
└───┘└───┘└───┘└─────┘└───┘└───┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
clifford_8_3
qiskit.circuit.library.clifford_8_3()
클리포드 템플릿 8_3:
q_0: ─────────────────■───────────────────────■──
┌───┐┌───┐┌───┐┌─┴─┐┌─────┐┌───┐┌─────┐┌─┴─┐
q_1: ┤ S ├┤ H ├┤ S ├┤ X ├┤ SDG ├┤ H ├┤ SDG ├┤ X ├
└───┘└───┘└───┘└───┘└─────┘└───┘└─────┘└───┘리턴
템플릿을 양자 회로로 사용합니다.
리턴 유형
RZXGate 템플릿 회로
RZXGate.이 포함된 템플릿 회로
rzx_yz
qiskit.circuit.library.rzx_yz(theta=None)
CX용 RZX 기반 템플릿 - RYGate - CX.
┌────────┐ ┌─────────┐┌─────────┐┌──────────┐
q_0: ──■──┤ RY(-ϴ) ├──■──┤ RX(π/2) ├┤0 ├┤ RX(-π/2) ├
┌─┴─┐└────────┘┌─┴─┐└─────────┘│ RZX(ϴ) │└──────────┘
q_1: ┤ X ├──────────┤ X ├───────────┤1 ├────────────
└───┘ └───┘ └─────────┘매개변수
theta (ParameterExpression |float | None)
rzx_xz
qiskit.circuit.library.rzx_xz(theta=None)
CX용 RZX 기반 템플릿 - RXGate - CX.
global phase: π
┌───┐ ┌───┐┌─────────┐┌─────────┐┌─────────┐┌──────────┐»
q_0: ┤ X ├─────────┤ X ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤0 ├»
└─┬─┘┌───────┐└─┬─┘└─────────┘└─────────┘└─────────┘│ Rzx(-ϴ) │»
q_1: ──■──┤ Rx(ϴ) ├──■───────────────────────────────────┤1 ├»
└───────┘ └──────────┘»
« ┌─────────┐┌─────────┐┌─────────┐
«q_0: ┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └─────────┘└─────────┘└─────────┘
«q_1: ─────────────────────────────────
«매개변수
theta (ParameterExpression |float | None)
rzx_cy
qiskit.circuit.library.rzx_cy(theta=None)
CX용 RZX 기반 템플릿 - RYGate - CX.
┌──────────┐
q_0: ──■─────────────■─────────────────────────────────┤0 ├───────────
┌─┴─┐┌───────┐┌─┴─┐┌────────┐┌──────────┐┌───────┐│ RZX(-ϴ) │┌─────────┐
q_1: ┤ X ├┤ RY(ϴ) ├┤ X ├┤ RY(-ϴ) ├┤ RZ(-π/2) ├┤ RX(ϴ) ├┤1 ├┤ RZ(π/2) ├
└───┘└───────┘└───┘└────────┘└──────────┘└───────┘└──────────┘└─────────┘매개변수
theta (ParameterExpression |float | None)
rzx_zz1
qiskit.circuit.library.rzx_zz1(theta=None)
CX용 RZX 기반 템플릿 - RZGate - CX.
global phase: π/2
»
q_0: ──■────────────────────────────────────────────■───────────────────────»
┌─┴─┐┌───────┐┌────┐┌───────┐┌────┐┌────────┐┌─┴─┐┌────────┐┌─────────┐»
q_1: ┤ X ├┤ Rz(ϴ) ├┤ √X ├┤ Rz(π) ├┤ √X ├┤ Rz(3π) ├┤ X ├┤ Rz(-ϴ) ├┤ Rz(π/2) ├»
└───┘└───────┘└────┘└───────┘└────┘└────────┘└───┘└────────┘└─────────┘»
« ┌──────────┐ »
«q_0: ───────────────────────────────┤0 ├──────────────────────»
« ┌─────────┐┌─────────┐┌───────┐│ Rzx(-ϴ) │┌─────────┐┌─────────┐»
«q_1: ┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├»
« └─────────┘└─────────┘└───────┘└──────────┘└─────────┘└─────────┘»
«
«q_0: ───────────
« ┌─────────┐
«q_1: ┤ Rz(π/2) ├
« └─────────┘매개변수
theta (ParameterExpression |float | None)
rzx_zz2
qiskit.circuit.library.rzx_zz2(theta=None)
CX용 RZX 기반 템플릿 - PhaseGate - CX.
global phase: π
»
q_0: ──■────────────■─────────────────────────────────────────────────────»
┌─┴─┐┌──────┐┌─┴─┐┌───────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
q_1: ┤ X ├┤ P(ϴ) ├┤ X ├┤ P(-ϴ) ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├»
└───┘└──────┘└───┘└───────┘└─────────┘└─────────┘└─────────┘└───────┘»
« ┌──────────┐
«q_0: ┤0 ├─────────────────────────────────
« │ Rzx(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
«q_1: ┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └──────────┘└─────────┘└─────────┘└─────────┘매개변수
theta (ParameterExpression |float | None)
rzx_zz3
qiskit.circuit.library.rzx_zz3(theta=None)
CX용 RZX 기반 템플릿 - RZGate - CX.
global phase: π
»
q_0: ──■─────────────■──────────────────────────────────────────────────────»
┌─┴─┐┌───────┐┌─┴─┐┌────────┐┌─────────┐┌─────────┐┌─────────┐┌───────┐»
q_1: ┤ X ├┤ Rz(ϴ) ├┤ X ├┤ Rz(-ϴ) ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├┤ Rx(ϴ) ├»
└───┘└───────┘└───┘└────────┘└─────────┘└─────────┘└─────────┘└───────┘»
« ┌──────────┐
«q_0: ┤0 ├─────────────────────────────────
« │ Rzx(-ϴ) │┌─────────┐┌─────────┐┌─────────┐
«q_1: ┤1 ├┤ Rz(π/2) ├┤ Rx(π/2) ├┤ Rz(π/2) ├
« └──────────┘└─────────┘└─────────┘└─────────┘매개변수
theta (ParameterExpression |float | None)