회로 합성

qiskit.synthesis

진화 합성


`EvolutionSynthesis`()	진화 합성 알고리즘을 위한 인터페이스입니다.
`ProductFormula`(순서[, 반복 횟수,...] )	비통근 연산자 지수의 분해를 위한 제품 공식 베이스 클래스입니다.
`LieTrotter`( [반복 횟수, 삽입 장벽,...] )	거짓말 트로터 제품 공식.
`SuzukiTrotter`( [순서, 반복 횟수,...] )	(상위) 스즈키 트로터 제품 공식.
`MatrixExponential`()	행렬 지수화 및 단일 합성을 통한 정확한 연산자 진화.
`QDrift`( [반복 횟수, 삽입 장벽,...] )	Q드리프트 트로터화 방법은 트로터화에서 각 용어를 가중치에 비례하는 확률로 무작위로 선택합니다.

선형 함수 합성

synth_cnot_count_full_pmh

qiskit.synthesis.synth_cnot_count_full_pmh(state, section_size=None)

GitHub

파텔, 마르코프, 헤이즈 방법을 사용하여 올투올 아키텍처를 위한 선형 리버시블 회로를 합성합니다.

이 함수는 $n \times n$ 행렬에 지정된 대로 모든 대 모든 아키텍처에 대한 선형 가역 회로를 최적으로 합성하기 위해 [1의] Patel, Markov 및 Hayes 알고리즘을 구현한 것입니다.

매개변수

state (list[list[bool]] | ndarray[bool]) – $n \times n$ 입력 회로의 상태를 나타내는 부울 역행렬.
section_size (int | None) – 파텔-마르코프-헤이즈 알고리즘의 각 섹션 크기 [1]. None 의 경우 $\alpha = 0.56$ 로 $\max(2, \alpha\log_2(n))$ 으로 선택되며, 이는 [1] 식에 주어진 행 연산 수의 상한을 대략적으로 최소화합니다. (3).

리턴

선형 변환을 구현하는 CX 전용 회로입니다.

레이즈

ValueError - section_size 이 열 수보다 큰 경우.

리턴 유형

QuantumCircuit

참조

파텔, 케탄 N., 이고르 L. 마르코프, 존 P. 헤이즈, 선형 가역 회로의 최적 합성, 양자 정보 및 계산 8.3 (2008): 282-294. arXiv:quant-ph/0302002 [quant-ph]

synth_cnot_depth_line_kms

qiskit.synthesis.synth_cnot_depth_line_kms(mat)

GitHub

쿠틴, 몰튼, 스미스라인 방법을 사용하여 선형 최인접 아키텍처를 위한 선형 가역 회로를 합성합니다.

[1], 섹션 7의 선형 가역 회로를 위한 합성 알고리즘. 이 알고리즘은 최대 깊이 $5n$ 의 CX 게이트를 사용하여 선형 최인접 이웃 아키텍처를 통해 $n$ 큐비트의 선형 가역 회로를 합성합니다.

매개변수

mat (ndarray[bool]) – 부울 반전 행렬입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError - mat 가 반전되지 않는 경우.

리턴 유형

QuantumCircuit

참조

Kutin, S., Moulton, D. P., 스미스라인, L., 원거리에서의 계산, Chicago J. Theor. Comput. Sci.., vol. 2007, (2007), arXiv:quant-ph/0701194

선형 위상 합성

synth_cz_depth_line_mr

qiskit.synthesis.synth_cz_depth_line_mr(mat)

GitHub

마슬로프와 로텔러를 기반으로 한 선형 최인접 이웃(LNN) 연결을 위한 CZ 회로를 합성합니다.

CXGate이 방법은 회로 내 큐비트의 순서를 반대로 바꾸며, s와 위상 게이트(SGate, SdgGate 또는 ZGate)를 포함하는 회로를 반환한다는 점에 유의하십시오.

매개변수

mat (ndarray) – CZ 회로를 나타내는 부울 값으로 구성된 정사각형 상대각 행렬. mat[i][j]=1 for i<j 게이트를 cz(i,j) 나타냅니다. 위쪽 삼각형만 읽혀지며, 대각선과 아래쪽 삼각형은 아무런 영향을 미치지 않습니다.

리턴

LNN 연결을 위한 깊이 $2n+2$ 의 CZ 회로를 구현한 회로입니다.

리턴 유형

QuantumCircuit

참조

드미트리 마슬로프, 마틴 로텔러, 브루하트 분해 및 양자 회로 변환을 통한 더 짧은 안정기 회로, arXiv:1705.09176.

synth_cx_cz_depth_line_my

qiskit.synthesis.synth_cx_cz_depth_line_my(mat_x, mat_z)

GitHub

최대 2쿼비트 깊이의 선형 최인접 이웃(LNN) 연결을 위한 -CZ-CX- 회로의 공동 합성 5n, Maslov와 Yang에 기반합니다. 이 방법은 위상 게이트 삽입을 통해 CX 회로 내부의 CZ 회로를 계산합니다.

매개변수

mat_z (ndarray) – cZ 회로를 나타내는 부울 대칭 행렬입니다. mat_z[i][j]=1 cz(i,j) 게이트를 나타냅니다
mat_x (ndarray) – cX 회로를 나타내는 부울 반전 행렬입니다.

리턴

최대 2큐비트 깊이( 5n)의 CZ 회로를 따르는 CX 회로 구현(-CZ-CX- 회로로 표시)으로, LNN 연결을 위한 회로입니다.

리턴 유형

QuantumCircuit

참조

Kutin, S., Moulton, D. P., 스미스라인, L., 원거리에서의 계산, Chicago J. Theor. Comput. Sci.., vol. 2007, (2007), arXiv:quant-ph/0701194
드미트리 마슬로프, 윌러스 양, CNOT 회로가 생성하는 임의의 하다마드 없는 클리포드 변환을 구현하는 데는 거의 도움이 필요하지 않습니다, arXiv:2210.16195.

synth_cnot_phase_aam

qiskit.synthesis.synth_cnot_phase_aam(cnots, angles, section_size=2)

GitHub

이 기능은 에이미, 아지마데, 모스카의 GraySynth 알고리즘을 구현한 것입니다.

GraySynth [는] 1에서 제시된, 소규모 패리티 네트워크를 합성하기 위한 휴리스틱 알고리즘이다. 이는 그레이 코드에서 영감을 받았습니다. 이진 문자열 집합 $S$ (이하 ‘’이라 cnots 함)이 주어지면, 이 알고리즘은 $S$ 에 대한 패리티 네트워크를 합성한다. 이를 위해 확장할 인덱스 $i$ 를 반복적으로 선택한 다음, 문자열 $y \in S$ 로 구성된 보조 인자 $S_0$ 및 $S_1$ 에 대해 각각 $y_i = 0$ 또는 $1$ 를 사용하여 효과적으로 재귀 연산을 수행한다. $S$ 의 부분 집합이 재귀적으로 확장될 때, 지정된 대상 비트가 (부분) 패리티 $\chi_y(x)$ cx 를 갖도록 게이트가 적용되는데, 여기서 $y_i = 1$ 는 모든 $y' \in S$ 에 대해 $y'_i = 1$ 일 경우에만 성립한다. 만약 $S$ 에 $\{y'\}$ 의 단일 요소가 포함되어 있다면, $y = y'$ 이며, 대상 비트는 원하는 대로 $\chi_{y'}(x)$ 값을 갖게 된다.

특히, 이 알고리즘은 하위 집합 $S$ 합성이 완료되면 이 cx (CNOT) 게이트 시퀀스를 계산하지 않고 계산할 나머지 패리티를 현재 비트 상태에 대해 표현한다는 불변성을 유지합니다. 이를 통해 알고리즘은 비연산 기반 방식에 내재된 '역추적'을 피할 수 있습니다.

알고리즘은 섹션 4의 [1절에] 자세히 설명되어 있습니다.

매개변수

cnots (list[list[int]]) –

열이 합성할 패리티인 행렬 e. g.:

[[0, 1, 1, 1, 1, 1],
 [1, 0, 0, 1, 1, 1],
 [1, 0, 0, 1, 0, 0],
 [0, 0, 1, 0, 1, 0]]

해당사항:

x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1

angles (list[str]) – cnots 에서와 같은 순서로 적용될 모든 위상 시프트 게이트가 포함된 목록입니다. 숫자는 $p(angle)$ 의 각도로 해석되며, 그렇지 않은 경우 요소는 't', 'tdg', 's', 'sdg' 또는 'z' 이어야 합니다.
section_size (int) – 파텔-마코프-헤이즈 알고리즘의 모든 섹션 크기입니다. section_size 는 큐비트 수의 인수여야 합니다.

리턴

분해된 양자 회로.

레이즈

QiskitError - cnots 와 angles 의 치수가 일치하지 않는 경우.

리턴 유형

QuantumCircuit

참조

매튜 에이미, 파시아드 아짐자데, 미셸 모스카. 제어되지 않은 위상 회로의 제어되지 않은 복잡성에 대해.., 양자 과학 및 기술 4.1 (2018): 015002. arXiv:1712.01859

순열 합성

synth_permutation_depth_lnn_kms

qiskit.synthesis.synth_permutation_depth_lnn_kms(pattern)

GitHub

쿠틴, 몰튼, 스미스라인 방법을 사용하여 선형 최접근 이웃 아키텍처의 순열 회로를 합성합니다.

이것은 [1], 섹션 6의 순열 합성 알고리즘입니다. 최대 깊이 $n$ 및 최대 크기 $n(n-1)/2$ (여기서 깊이와 크기는 모두 SWAP과 관련하여 측정됨)의 SWAP 게이트를 사용하여 선형 최인접 이웃 아키텍처를 통해 n 큐비트의 임의의 순열을 합성합니다.

매개변수

pattern (list[int] | ndarray[int]) – 순열 패턴, 순열 적용 후 큐비트들이 0, 1, 2 등의 위치를 차지하는 방식을 설명함. 즉, 순열이 큐비트를 pattern[k] = m 위치 m 로 k매핑할 때. 예를 들어, 패턴 은 큐비트 가 위치 2 로 0이동하고, 큐비트 [2, 4, 3, 0, 1] 가 위치 4 로 1이동하는 등의 의미를 가집니다.

리턴

합성된 양자 회로.

리턴 유형

QuantumCircuit

참조

사무엘 A. 쿠틴, 데이비드 페트리 몰튼, 로렌 M. 스미스라인. 원거리에서의 계산.., arXiv:quant-ph/0701194v1

synth_permutation_basic

qiskit.synthesis.synth_permutation_basic(pattern)

GitHub

정렬을 사용하여 완전히 연결된 아키텍처에 대한 순열 회로를 합성합니다.

더 정확히 말하면, 입력 순열이 길이가 m 인 사이클인 경우 m-1 스왑(그리고 깊이 m-1)이 있는 양자 회로가 생성되고, 입력 순열이 여러 개의 분리된 사이클로 구성된 경우 각 사이클은 본질적으로 독립적으로 처리됩니다.

매개변수

리턴

합성된 양자 회로.

리턴 유형

QuantumCircuit

synth_permutation_acg

qiskit.synthesis.synth_permutation_acg(pattern)

GitHub

알론, 정, 그레이엄 방법을 사용하여 완전히 연결된 아키텍처에 대한 순열 회로를 합성합니다.

이렇게 하면 깊이 2의 양자 회로가 생성됩니다(스왑 수로 측정).

이 구현은 참조 [1의] 명제 4.1 를 기반으로 하며, 자세한 증명은 참조 [2의] 정리 2에 나와 있습니다

매개변수

리턴

합성된 양자 회로.

리턴 유형

QuantumCircuit

참조

N. Alon, F. R. K. Chung, 및 R. L. Graham. 매칭을 통한 그래프의 라우팅 순열.., 제25회 연례 ACM 컴퓨팅 이론 심포지엄(1993) 논문집. 583-591페이지. (확장된 초록) 10.1145/167088.167239
N. Alon, F. R. K. Chung, 및 R. L. Graham. 매칭을 통한 그래프의 라우팅 순열.., (전체 문서)

synth_permutation_reverse_lnn_kms

qiskit.synthesis.synth_permutation_reverse_lnn_kms(num_qubits)

GitHub

쿠틴, 몰튼, 스미스라인 방법을 사용하여 선형 최접근 이웃 아키텍처의 역순열을 합성합니다.

[1의] 역순열을 위한 합성 알고리즘, 섹션 5. 이 알고리즘은 깊이가 있는 CX 게이트를 사용하여 선형 최인접 이웃 아키텍처를 통해 $n$ 큐비트에 대한 역순열을 합성합니다( $2 * n + 2$ ).

매개변수

num_qubits (int) – 큐비트 수입니다.

리턴

합성된 양자 회로.

리턴 유형

QuantumCircuit

참조

Kutin, S., Moulton, D. P., 스미스라인, L., 원거리에서의 계산, Chicago J. Theor. Comput. Sci.., vol. 2007, (2007), arXiv:quant-ph/0701194

클리포드 합성

synth_clifford_full

qiskit.synthesis.synth_clifford_full(clifford, method=None)

GitHub

QuantumCircuit연산자 를 Clifford 로 분해하십시오.

$N \leq 3$ 큐비트의 경우 이는 참조 [1의] 최적 CX 비용 분해를 기반으로 합니다. $N > 3$ 큐비트의 경우 참조 [3의] 일반적인 비최적 욕심 컴파일 루틴을 사용하여 수행되며, 일반적으로 [2의] AG 방식에 비해 더 나은 CX 비용을 산출합니다.

매개변수

clifford (Clifford) – 클리포드 연산자.
method (str | None) – 합성 방법 ('AG' 또는 'greedy'). 이 옵션을 설정하면 $N \leq 3$ 큐비트에 대한 최적 분해 방식을 무시합니다.

리턴

클리포드의 회로 구현입니다.

리턴 유형

QuantumCircuit

참조

S. 브라비, D. 마슬로프, 하다마드가 없는 회로가 클리포드 그룹의 구조를 드러내다, arXiv:2003.09412 [quant-ph]
S. 아론슨, D. 고트스만, 안정기 회로의 향상된 시뮬레이션, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196
세르게이 브라비, 샤오한 후, 드미트리 마슬로프, 루슬란 샤이둘린, 템플릿과 심볼릭 폴리 게이츠를 이용한 클리포드 회로 최적화, arXiv:2105.02291 [quant-ph]

synth_clifford_ag

qiskit.synthesis.synth_clifford_ag(clifford)

GitHub

QuantumCircuit Aaronson-Gottesman 방법 [1] 에 따라 연산자 를 Clifford 로 분해한다.

매개변수

clifford (Clifford) – 클리포드 연산자.

리턴

클리포드의 회로 구현입니다.

리턴 유형

QuantumCircuit

참조

S. 아론슨, D. 고트스만, 안정기 회로의 향상된 시뮬레이션, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196

synth_clifford_bm

qiskit.synthesis.synth_clifford_bm(clifford)

GitHub

Bravyi-Maslov 방법을 기반으로 한 QuantumCircuit 2 큐비트 또는 3 큐비트 연산자의 Clifford 최적 CX-비용 분해 [1].

매개변수

clifford (Clifford) – 클리포드 연산자.

리턴

클리포드의 회로 구현입니다.

레이즈

QiskitError - 클리퍼드가 3큐비트를 초과하는 경우.

리턴 유형

QuantumCircuit

참조

S. 브라비, D. 마슬로프, 하다마드가 없는 회로가 클리포드 그룹의 구조를 드러내다, arXiv:2003.09412 [quant-ph]

synth_clifford_greedy

qiskit.synthesis.synth_clifford_greedy(clifford)

GitHub

Bravyi, Hu, Maslov 및 [Sh] aydulin 1의 부록 A에 설명된 탐욕적 클리포드 컴파일러를 바탕으로 QuantumCircuit 연산자를 Clifford 로 분해하라.

이 방법은 일반적으로 아론슨-고트스만 방법에 비해 더 나은 CX 비용을 산출합니다.

이 함수는 부록 [1의] 욕심 많은 클리포드 컴파일러만 구현하며, 같은 논문에서 언급된 템플릿과 심볼릭 폴리 게이트 최적화는 구현하지 않습니다.

매개변수

clifford (Clifford) – 클리포드 연산자.

리턴

클리포드의 회로 구현입니다.

레이즈

QiskitError - 심플렉틱 가우시안 제거에 실패한 경우.

리턴 유형

QuantumCircuit

참조

세르게이 브라비, 샤오한 후, 드미트리 마슬로프, 루슬란 샤이둘린, 템플릿과 심볼릭 폴리 게이츠를 이용한 클리포드 회로 최적화, arXiv:2105.02291 [quant-ph]

synth_clifford_layers

qiskit.synthesis.synth_clifford_layers(cliff, cx_synth_func=<function _default_cx_synth_func>, cz_synth_func=<function _default_cz_synth_func>, cx_cz_synth_func=None, cz_func_reverse_qubits=False, validate=False)

GitHub

a를 Clifford 층으로 합성함으로써, 이는 Bravyi와 [Mas] lov 1의 보조정리 8에 설명된 합성과 유사한 분해를 제공한다.

예를 들어, 5큐비트 클리포드 회로는 다음과 같은 계층으로 분해됩니다:

     ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0       ├┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1       ├┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_2: ┤2 S2 ├┤2 CZ ├┤2 CX_dg ├┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3       ├┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││        ││     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4       ├┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└────────┘└─────┘└─────┘└─────┘└─────┘└────────┘

이 분해는 기본 cz_synth_func 및 cx_synth_func 함수에 대한 것이며, 다른 함수에서는 약간 다른 분해가 표시될 수 있습니다.

매개변수

cliff (Clifford) – 클리포드 연산자.
cx_synth_func (Callable[[ndarray], QuantumCircuit]) – CX 하위 회로를 분해하는 함수. 입력으로 부울 역행렬을 받아, 출력으로. QuantumCircuit를 반환합니다.
cz_synth_func (Callable[[ndarray], QuantumCircuit]) – CZ 하위 회로를 분해하는 함수입니다. 이 함수는 입력으로 부울 대칭 행렬을 받고, 출력은 QuantumCircuit.
cx_cz_synth_func (Callable) – 선택 사항으로, 하위 회로 CZ와 CX를 모두 분해하는 함수입니다.
validate (Boolean) – true이면 합성 프로세스의 유효성을 검사합니다.
cz_func_reverse_qubits (Boolean) – cz_synth_func 가 synth_cz_depth_line_mr()인 경우에만 참입니다. 이 함수는 큐비트의 순서를 되돌릴 수 있는 회로를 반환하기 때문입니다.

리턴

클리포드의 회로 구현입니다.

리턴 유형

QuantumCircuit

참조

S. 브라비, D. 마슬로프, 하다마드가 없는 회로가 클리포드 그룹의 구조를 드러내다, arXiv:2003.09412 [quant-ph]

synth_clifford_depth_lnn

qiskit.synthesis.synth_clifford_depth_lnn(cliff)

GitHub

선형 최인접 이웃 연결성을 위해 a를 Clifford 층으로 합성한다.

합성된 n-큐비트 회로의 깊이는 $7n+2$ 에 의해 제한되며, 이는 최적이 아닙니다. $7n-4$ [3으로] 제한되는 깊이를 제공하는 더 나은 알고리즘으로 대체해야 합니다.

매개변수

cliff (Clifford) – 클리포드 연산자.

리턴

클리포드의 회로 구현입니다.

리턴 유형

QuantumCircuit

참조

S. 브라비, D. 마슬로프, 하다마드가 없는 회로가 클리포드 그룹의 구조를 드러내다, arXiv:2003.09412 [quant-ph]
드미트리 마슬로프, 마틴 로텔러, 브루하트 분해 및 양자 회로 변환을 통한 더 짧은 안정기 회로, arXiv:1705.09176.
드미트리 마슬로프, 윌러스 양, CNOT 회로가 생성하는 임의의 하다마드 없는 클리포드 변환을 구현하는 데는 거의 도움이 필요하지 않습니다, arXiv:2210.16195.

CNOT 이면체 합성

synth_cnotdihedral_full

qiskit.synthesis.synth_cnotdihedral_full(elem)

GitHub

QuantumCircuit요소를 CNOTDihedral 로 분해하십시오.

$N \leq 2$ 큐비트의 경우 이는 참조 [1의] 최적 CX 비용 분해를 기반으로 합니다. $N > 2$ 큐비트의 경우 참조 [2의] 일반적인 비최적 컴파일 루틴을 사용하여 수행됩니다.

매개변수

elem (CNOTDihedral) – A CNOTDihedral 요소.

리턴

해당 CNOTDihedral 요소의 회로 구현.

리턴 유형

QuantumCircuit

참조

셸리 가리온과 앤드류 W. 크로스, 최적의 두 큐비트 게이트 수를 가진 CNOT-이차원 회로의 합성, 양자 4(369), 2020
앤드류 크로스, 이스와르 마게산, 레프 비숍, 존 스몰린, 제이 엠 감베타, 비클리포드 게이트의 확장 가능한 무작위 벤치마킹, npj Quantum Inf 2, 16012 (2016).

synth_cnotdihedral_two_qubits

qiskit.synthesis.synth_cnotdihedral_two_qubits(elem)

GitHub

QuantumCircuit단일 큐비트와 두 개의 큐비트에 대한 요소를 CNOTDihedral 로 분해하십시오. 이 분해에서 CXGates의 개수는 최적값을 가집니다.

매개변수

elem (CNOTDihedral) – A CNOTDihedral 요소.

리턴

해당 CNOTDihedral 요소의 회로 구현.

레이즈

CNOTDihedralQiskitError – 해당 요소가 1-큐비트나 2-큐비트가 아닌 경우.

리턴 유형

QuantumCircuit

참조

셸리 가리온과 앤드류 W. 크로스, CNOT-이원체 그룹의 구조에 관하여, arXiv:2006.12042 [quant-ph]

synth_cnotdihedral_general

qiskit.synthesis.synth_cnotdihedral_general(elem)

GitHub

QuantumCircuit요소를 CNOTDihedral 로 분해하십시오.

일반적인 CNOTDihedral 요소를 분해하십시오. CX 게이트의 수가 반드시 최적의 수는 아닙니다. synth_cnotdihedral_two_qubits()1-큐비트 또는 2-큐비트 요소의 분해를 보려면 를 호출하십시오.

매개변수

elem (CNOTDihedral) – A CNOTDihedral 요소.

리턴

해당 CNOTDihedral 요소의 회로 구현.

레이즈

QiskitError - 요소를 회로로 분해할 수 없는 경우.

리턴 유형

QuantumCircuit

참조

앤드류 크로스, 이스와르 마게산, 레프 비숍, 존 스몰린, 제이 엠 감베타, 비클리포드 게이트의 확장 가능한 무작위 벤치마킹, npj Quantum Inf 2, 16012 (2016).

안정화 상태 합성

synth_stabilizer_layers

qiskit.synthesis.synth_stabilizer_layers(stab, cz_synth_func=<function _default_cz_synth_func>, cz_func_reverse_qubits=False, validate=False)

GitHub

안정제 상태를 레이어로 합성합니다.

이는 [참고] 문헌 1의 정리 8에 설명된 합성 방식과 유사한 분해를 제공하며, 안정화기 상태에 영향을 미치지 않는 초기 하다마르(Hadamard)가 없는 하위 회로 단계를 제외한다.

예를 들어 5큐비트 스태빌라이저 상태는 다음과 같은 레이어로 분해됩니다:

     ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
     │     ││     ││     ││     ││        │
q_1: ┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
     │     ││     ││     ││     ││        │
q_2: ┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
     │     ││     ││     ││     ││        │
q_3: ┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
     │     ││     ││     ││     ││        │
q_4: ┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
     └─────┘└─────┘└─────┘└─────┘└────────┘

매개변수

stab (StabilizerState) – 안정화된 상태.
cz_synth_func (Callable[[ndarray], QuantumCircuit]) – CZ 하위 회로를 분해하는 함수입니다. 이 함수는 입력으로 부울 대칭 행렬을 받고, 출력은 QuantumCircuit.
cz_func_reverse_qubits (bool) – True 가 cz_synth_func 인 경우에만 synth_cz_depth_line_mr()이 함수는 큐비트의 순서를 되돌릴 수 있는 회로를 반환하기 때문입니다.
validate (bool) – True, 합성 프로세스의 유효성을 검사합니다.

리턴

안정화 상태의 회로 구현입니다.

레이즈

StabilizerStateQiskitError – 입력이.이 아닌 경우

리턴 유형

QuantumCircuit

참조

S. 브라비, D. 마슬로프, 하다마드가 없는 회로가 클리포드 그룹의 구조를 드러내다, arXiv:2003.09412 [quant-ph]

synth_stabilizer_depth_lnn

qiskit.synthesis.synth_stabilizer_depth_lnn(stab)

GitHub

CXGates 게이트와 위상 게이트(SGate, SdgGate 또는 ZGate)를 사용하여, 2-큐비트 깊이 $2n+2$ 와 두 개의 서로 다른 CX 층에서 선형 최인접 연결을 위한 n-큐비트 안정화 상태의 합성.

매개변수

stab (StabilizerState) – 안정화된 상태.

리턴

안정화 상태의 회로 구현입니다.

리턴 유형

QuantumCircuit

참조

S. 브라비, D. 마슬로프, 하다마드가 없는 회로가 클리포드 그룹의 구조를 드러내다, arXiv:2003.09412 [quant-ph]
드미트리 마슬로프, 마틴 로텔러, 브루하트 분해 및 양자 회로 변환을 통한 더 짧은 안정기 회로, arXiv:1705.09176.

synth_circuit_from_stabilizers

qiskit.synthesis.synth_circuit_from_stabilizers(stabilizers, allow_redundant=False, allow_underconstrained=False, invert=False)

GitHub

클리포드 게이트로 가우시안 제거를 사용하여 안정기에 의해 안정화된 상태를 생성하는 회로를 합성합니다. 안정기가 제약 조건에 미달하고 allow_underconstrained 이 True 인 경우 회로는 안정기에 의해 안정화된 상태 중 하나를 출력합니다. 자극 구현을 기준으로 합니다.

매개변수

stabilizers (Collection[str]) – 스태빌라이저 문자열 목록
allow_redundant (bool) – 중복되는 안정자를 허용한다(즉, 일부 안정자가 다른 안정자들의 곱이 될 수 있다)
allow_underconstrained (bool) – 제약 조건이 부족한 안정화기 집합을 허용한다(즉, 안정화기가 유일한 상태를 지정하지 않는 경우)
invert (bool) – 역회로 반환

리턴

stabilizers 에 의해 안정화된 상태를 생성하는 회로입니다.

레이즈

QiskitError - 안정제가 유효하지 않거나, 통용되지 않거나, 서로 모순되는 경우, 목록이 제한되지 않고 allow_underconstrained 이 False 이거나, 목록이 중복되고 allow_redundant 이 False 인 경우.

리턴 유형

QuantumCircuit

참조

이산 기저 합성


`SolovayKitaevDecomposition`([...])	솔로베이 키타에프 이산 분해 알고리즘.

gridsynth_rz

qiskit.synthesis.gridsynth_rz(angle, epsilon=1e-10)

GitHub

Ross-Selinger 알고리즘을 이용한 근사 RZ 회전

알고리즘은 [1절] 에서 설명한다. 소스 코드(Rust)는 에서 확인할 수 https://github.com/qiskit-community/rsgridsynth 있습니다.

매개변수

angle (float) – RZ 회전 각도를 지정합니다.
epsilon (float) – 허용 근사 오차.

리턴

하나의 큐비트를 근사하는 RZ(angle)회로.

리턴 유형

QuantumCircuit

참조 자료:

[1] 닐 J. 로스, 피터 셀린저, z-회전에 대한 최적의 보조변수 없는 클리포드+T 근사법,

arXiv:1403.2975

gridsynth_unitary

qiskit.synthesis.gridsynth_unitary(matrix, epsilon=1e-10)

GitHub

로스-셀링거 알고리즘을 사용하여 1-큐비트 유니터리 행렬을 근사화하십시오.

알고리즘은 [1절] 에서 설명한다. 소스 코드(Rust)는 에서 확인할 수 https://github.com/qiskit-community/rsgridsynth 있습니다.

매개변수

matrix (ndarray) – $2 imes 2$ 의 단위 행렬.
epsilon (float) – 허용 근사 오차.

리턴

하나의 큐비트를 근사하는 matrix회로.

리턴 유형

QuantumCircuit

참조 자료:

[1] 닐 J. 로스, 피터 셀린저, z-회전에 대한 최적의 보조변수 없는 클리포드+T 근사법,

arXiv:1403.2975

generate_basic_approximations

qiskit.synthesis.generate_basic_approximations(basis_gates, depth, filename=None)

GitHub

basis_gates 에 게이트가 있는 GateSequence의 목록을 생성합니다.

2.3 버전부터 사용 중단됨

해당 함수는 Qiskit 2.3qiskit.synthesis.discrete_basis.generate_basis_approximations.generate_basic_approximations() 부터 사용 중단되었습니다. 출시일로부터 3개월이 지나지 않으면 제거되지 않습니다. SolovayKitaevDecomposition 클래스를 직접 사용하여 기본 근사값을 생성, 저장 및 로드하십시오.

매개변수

basis_gates (list[str |Gate]) – 게이트 시퀀스를 생성할 게이트들.
depth (int) – 근사치의 최대 깊이입니다.
filename (str | None) – 제공된 경우 기본 근사값이 이 파일에 저장됩니다.

리턴

basis_gates 에서 게이트를 사용하는 GateSequence의 목록.

레이즈

ValueError - basis_gates 에 잘못된 게이트 식별자가 포함된 경우.

리턴 유형

목록 게이트[ 시퀀스]

기초 변경 합성

synth_qft_line

qiskit.synthesis.synth_qft_line(num_qubits, do_swaps=True, approximation_degree=0)

GitHub

선형 이웃 연결을 사용하여 양자 푸리에 변환을 위한 회로를 구축합니다.

구성은 Fowler 외 [1의] 그림 2.b 을 기반으로 합니다.

참고

기본값이 do_swaps = True 인 이 합성 알고리즘은 QFT 연산을 충실히 구현하는 회로를 생성합니다. do_swaps = False, 이 합성 알고리즘은 QFT를 적용하고 출력 큐비트의 순서를 반전하는 "QFT-with-reversal"에 해당하는 회로를 생성합니다.

매개변수

num_qubits (int) – 양자 푸리에 변환이 작동하는 큐비트 수입니다.
approximation_degree (int) – 근사치 정도입니다(근사치가 없는 경우 0). 임계값 이하의 각도로 제어 위상 회전을 무시하면 대략적으로 QFT를 구현할 수 있습니다. 이에 대한 자세한 내용은 https://arxiv.org/abs/quant-ph/9601018 또는 https://arxiv.org/abs/quant-ph/0403071.
do_swaps (bool) – "QFT" 또는 "QFT-반전" 연산을 합성할지 여부를 설정합니다.

리턴

QFT 연산을 구현하는 회로입니다.

리턴 유형

QuantumCircuit

참조

A. G. 파울러, S. J. 데빗, L. C. L. 홀렌버그, 선형 최인접 큐비트 배열에서 쇼의 알고리즘 구현, Quantum Info. Comput. 4, 4 (7월 2004), 237-251. arXiv:quant-ph/0402196 [quant-ph]

synth_qft_full

qiskit.synthesis.synth_qft_full(num_qubits, do_swaps=True, approximation_degree=0, insert_barriers=False, inverse=False, name=None)

GitHub

올투올 연결을 사용하여 양자 푸리에 변환을 위한 회로를 구축합니다.

참고

do_swaps = True기본값이 인 이 합성 알고리즘은 QFT 연산을 충실히 구현하는 회로를 생성합니다. 이 회로의 끝부분에는 출력 큐비트의 순서를 반전시키는 일련의 스왑 게이트가 포함되어 있습니다. 일부 응용 분야에서는 이러한 역순 배열을 피할 수 있습니다. 이 설정을 do_swaps = False 적용하면 이러한 역순 배열이 없는 회로가 생성되지만, 그 대가로 이 회로는 QFT 대신 “역순이 포함된 QFT”를 구현하게 됩니다. 또는 트랜스파일러 단계에서 ElidePermutations 이러한 스왑 게이트를 제거할 수 있습니다.

매개변수

num_qubits (int) – 양자 푸리에 변환이 작동하는 큐비트 수입니다.
do_swaps (bool) – "QFT" 또는 "QFT-반전" 연산을 합성할지 여부를 설정합니다.
approximation_degree (int) – 근사치 정도입니다(근사치가 없는 경우 0). 임계값 이하의 각도로 제어 위상 회전을 무시하면 대략적으로 QFT를 구현할 수 있습니다. 이에 대한 자세한 내용은 https://arxiv.org/abs/quant-ph/9601018 또는 https://arxiv.org/abs/quant-ph/0403071.
insert_barriers (bool) – True 인 경우 시각화 개선을 위해 배리어가 삽입됩니다.
inverse (bool) – True, 역 양자 푸리에 변환이 구성됩니다.
name (str | None) – 서킷의 이름입니다.

리턴

QFT 연산을 구현하는 회로입니다.

리턴 유형

QuantumCircuit

단일 합성

임의의 수의 큐비트에 대한 일반 $2^n \times 2^n$ 유니타리 행렬의 분해.

qs_decomposition

qiskit.synthesis.qs_decomposition(mat, opt_a1=None, opt_a2=None, decomposer_1q=None, decomposer_2q=None, *, _depth=0)

GitHub

블록 ZXZ-분해에 기반한 양자 섀넌 분해를 사용하여 단일 행렬을 1 큐비트 게이트와 2 큐비트 게이트로 분해합니다.

이 분해는 크롤과 알-아르스 [2에] 설명되어 있으며 쉔데 외 [1의] 방법을 개선한 것입니다.

  ┌───┐              ┌───┐     ┌───┐
 ─┤   ├─      ────□──┤ H ├──□──┤ H ├──□──
  │   │    ≃    ┌─┴─┐└───┘┌─┴─┐└───┘┌─┴─┐
/─┤   ├─      ──┤ C ├─────┤ B ├─────┤ A ├
  └───┘         └───┘     └───┘     └───┘

최적화가 없으면 숫자는 다음과 같습니다. CXGate 분해를 통해 생성된 s는 [1] 의 최적화되지 않은 방법과 동일합니다.

\frac{9}{16} 4^n - \frac{3}{2} 2^n

[1을] 개선하고 자동으로 적용되는 최적화 A.1 는 재귀의 각 단계에서 1초 대신 CXGate2초를 절약하여 CX 카운트를 다음과 같이 줄여줍니다:

\frac{2}{3} (4^{n - 2} - 1).

최적화 A.2 는 [1] 에서와 같이 2큐비트 유니터리를 대각선 게이트와 2-CX 유니터리로 분해하여 CX 개수를 추가로 줄입니다.

4^{n-2} - 1.

이 최적화는 원래의 유니터리가 제어되는 경우 수행되어서는 안 되므로, 입력 행렬이 제어되는 (블록 대각) 유니터리와 동등하지 않은 한 자동으로 적용됩니다.

따라서, 두 가지 최적화 기법을 모두 적용하여 분해했을 때 생성되는 CXGates의 개수는 다음과 같습니다:

\frac{22}{48} 4^n - \frac{3}{2} 2^n + \frac{5}{3}.

2.5.0 버전부터 사용 중단됨

`` 또는 decomposer_1q decomposer_2q 인자로 임의의 호출 가능 객체를 전달하는 것은 더 이상 권장되지 않습니다. Qiskit 3.0 에서는 각각 TwoQubitBasisDecomposer과 OneQubitEulerDecomposer 의 인스턴스만 허용됩니다.

2.5.0 버전부터 사용 중단됨

의 opt_a1 인수는 Qiskit 2.5.0 부터 더 이상 권장되지 않습니다 qs_decomposition() . 출시일로부터 3개월이 지나기 전에는 삭제되지 않습니다. 이제 적절한 경우 최적화가 자동으로 적용됩니다.

2.5.0 버전부터 사용 중단됨

의 opt_a2 인수는 Qiskit 2.5.0 부터 더 이상 권장되지 않습니다 qs_decomposition() . 출시일로부터 3개월이 지나기 전에는 삭제되지 않습니다. 이제 적절한 경우 최적화가 자동으로 적용됩니다.

매개변수

mat (ndarray) – 분해할 단일 행렬
opt_a1 (bool | None) – 이 인수는 더 이상 사용되지 않습니다. None (기본값인) 경우 최적화가 자동으로 적용됩니다.
opt_a2 (bool | None) – 이 인수는 더 이상 사용되지 않습니다. None (기본값인) 경우 최적화가 자동으로 적용됩니다.
decomposer_1q (Callable[[ndarray], QuantumCircuit] | None) – 선택 사항인 1Q 분해기, 의 인스턴스 OneQubitEulerDecomposer. 인 경우 None, 기본 1-큐비트 분해가 사용됩니다.
decomposer_2q (Callable[[ndarray], QuantumCircuit] | None) – 선택 사항인 2Q 분해기, 의 인스턴스 TwoQubitBasisDecomposer. 인 경우 None, 기본 2-큐비트 분해가 사용됩니다.

리턴

분해된 양자 회로.

리턴 유형

QuantumCircuit

참조

쉔데, 불록, 마르코프, 양자 논리 회로의 합성, arXiv:0406176 [quant-ph]
크롤, 알-아스, 퀀텀 섀넌을 넘어서: 블록 ZXZ-분해에 기반한 일반 n큐비트 게이트를 위한 회로 구성, arXiv:2403.13692

근사치 양자 컴파일러는 모듈로 사용할 수 있습니다 qiskit.synthesis.unitary.aqc.

1큐비트 합성


`OneQubitEulerDecomposer`( [basis, use_dag] )	1-큐비트 단항식을 오일러 각도 회전으로 분해하는 클래스입니다.

2큐비트 합성


`TwoQubitBasisDecomposer`(게이트[,...] )	2쿼비트 단위 게이트를 최소한의 사용 횟수로 분해하는 클래스입니다.
`XXDecomposer`( [basis_fidelity, euler_basis,...] )	2-큐비트 유니터리를 (즉, $\alpha$ 가 변할 수 있는 경우 $CAN(\alpha, 0, 0)$ 와 국소적으로 동등한) 유형의 `XX` 2-큐비트 기저 게이트로 최적으로 분해하는 클래스.
`TwoQubitWeylDecomposition`(단일 행렬[,...] )	2큐비트 웨일 분해.
`TwoQubitControlledUDecomposer`(...[, euler_basis] )	`RXXGate`일반적인 2-큐비트 유니터리 연산을, 와 국소적으로 동등한 대상 2-큐비트 게이트를 사용하여 분해한다.

two_qubit_cnot_decompose

qiskit.synthesis.two_qubit_cnot_decompose(*args, **kwargs)

이것은 기저 분해 시 항상 를 TwoQubitBasisDecomposer KAK 게이트로 사용하는 cx 사례입니다. cx이 함수를 사용하면 -기반 2-큐비트 분해에 빠르게 접근할 수 있습니다.

매개변수

unitary (Operator or np.ndarray) – 4x4 는 합성하기 쉬운 단위입니다.
CXGatebasis_fidelity (float or None) –.의 응용에 대해 가정된 정확도가 주어지면,
approximate (bool) – basis_fidelity 이 1.0 보다 작으면 True 대략적인 경우.

리턴

입력 유니티의 합성 회로입니다.

리턴 유형

QuantumCircuit

다중 제어 합성

synth_mcmt_vchain

qiskit.synthesis.synth_mcmt_vchain(gate, num_ctrl_qubits, num_target_qubits, ctrl_state=None)

GitHub

V-체인을 사용하여 MCMT를 합성합니다.

이는 num_ctrl_qubits - 1 보조 큐비트를 사용하는 CCX 게이트 체인을 사용합니다.

예를 들어, 3-컨트롤 및 2-타겟 H 게이트는 다음과 같이 합성됩니다:

q_0: ──■────────────────────────■──
       │                        │
q_1: ──■────────────────────────■──
       │                        │
q_2: ──┼────■──────────────■────┼──
       │    │  ┌───┐       │    │
q_3: ──┼────┼──┤ H ├───────┼────┼──
       │    │  └─┬─┘┌───┐  │    │
q_4: ──┼────┼────┼──┤ H ├──┼────┼──
     ┌─┴─┐  │    │  └─┬─┘  │  ┌─┴─┐
q_5: ┤ X ├──■────┼────┼────■──┤ X ├
     └───┘┌─┴─┐  │    │  ┌─┴─┐└───┘
q_6: ─────┤ X ├──■────■──┤ X ├─────
          └───┘          └───┘

매개변수

gate (Gate) – 타깃에 적용될 베이스 게이트.
num_ctrl_qubits (int) – 제어 큐비트 수입니다.
num_target_qubits (int) – 대상 큐비트 수입니다.
ctrl_state (int | None) – 선택적 제어 상태를 정수로 설정합니다.

리턴

MCMT 게이트용 합성 회로입니다.

리턴 유형

QuantumCircuit

synth_mcmt_xgate

qiskit.synthesis.synth_mcmt_xgate(num_ctrl_qubits, num_target_qubits, ctrl_state=None)

GitHub

MCMT X 게이트를 합성합니다.

여기에는 MCMT X 게이트에 효율적인 특수 회로 구조가 사용됩니다. 부수적인 큐비트가 필요하지 않으며 효율적인 MCX 분해의 이점을 누릴 수 있습니다.

E.g. 로 설정하면 3 컨트롤, 3 타겟 X 게이트가 합성됩니다:

q_0: ─────────────■────────────
                  |
q_1: ─────────────■────────────
                  |
q_2: ─────────────■────────────
                ┌─┴─┐
q_3: ────────■──┤ X ├──■───────
           ┌─┴─┐└───┘┌─┴─┐
q_4: ───■──┤ X ├─────┤ X ├──■──
      ┌─┴─┐└───┘     └───┘┌─┴─┐
q_5: ─┤ X ├───────────────┤ X ├
      └───┘               └───┘

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.
num_target_qubits (int) – 대상 큐비트 수입니다.
ctrl_state (int | None) – 선택적 제어 상태를 정수로 설정합니다.

리턴

MCMT X 게이트용 합성 회로입니다.

리턴 유형

QuantumCircuit

synth_mcx_1_clean_kg24

qiskit.synthesis.synth_mcx_1_clean_kg24(num_ctrl_qubits)

GitHub

$k\ge 3$ 제어 기능을 갖춘 다중 제어 X 게이트를 합성하고, $1$ 의 깨끗한 보조 큐비트를 사용하여 Sec.에 설명된 대로 $2k-3$ 의 토폴리(Toffoli) 게이트 또는 $6k-6$ 의 CX 게이트와 깊이 $O(k)$ 를 갖는 회로를 생성합니다. 5.1 [1]. $k\le 2$ 의 경우, 반환되는 회로는 단일 X, CX 또는 CCX 게이트(각각 $k = 0, 1, 2$ 에 해당)로 구성되며 보조 큐비트를 사용하지 않습니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

1. 카타르와 기드니, 양자 회로 최적화를 위한 조건부 청정 부속물의 등장 arXiv:2407.17966

synth_mcx_1_dirty_kg24

qiskit.synthesis.synth_mcx_1_dirty_kg24(num_ctrl_qubits)

GitHub

$k\ge 3$ 제어 기능을 갖춘 다중 제어 X 게이트를 합성하고, $1$ 더티 보조 큐비트를 사용하여 Sec.에 설명된 대로 $4k-8$ 토폴리 게이트 또는 $12k-18$ CX 게이트와 깊이 $O(k)$ 를 갖는 회로를 생성한다. 5.3 [1]. $k\le 2$ 의 경우, 반환되는 회로는 단일 X, CX 또는 CCX 게이트(각각 $k = 0, 1, 2$ 에 해당)로 구성되며 보조 큐비트를 사용하지 않습니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

1. 카타르와 기드니, 양자 회로 최적화를 위한 조건부 청정 부속물의 등장 arXiv:2407.17966

synth_mcx_2_clean_kg24

qiskit.synthesis.synth_mcx_2_clean_kg24(num_ctrl_qubits)

GitHub

제X절에 설명된 바와 같이, $2$ 의 깨끗한 보조 큐비트를 사용하여 $k\ge 3$ 제어 기능을 갖춘 다중 제어 X 게이트를 합성하고, $2k-3$ 의 토폴리(Toffoli) 게이트 또는 $6k-6$ 의 CX 게이트를 포함하며, 깊이 $O(\log(k))$ 인 회로를 생성한다. 5.2 [1]. $k\le 2$ 의 경우, 반환되는 회로는 단일 X, CX 또는 CCX 게이트(각각 $k = 0, 1, 2$ 에 해당)로 구성되며 보조 큐비트를 사용하지 않습니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

1. 카타르와 기드니, 양자 회로 최적화를 위한 조건부 청정 부속물의 등장 arXiv:2407.17966

synth_mcx_2_dirty_kg24

qiskit.synthesis.synth_mcx_2_dirty_kg24(num_ctrl_qubits)

GitHub

제X절에 설명된 바와 같이, $2$ 의 더티 보조 큐비트를 사용하여 $k\ge 3$ 제어 기능을 갖춘 다중 제어 X 게이트를 합성하고, $4k-8$ 의 토폴리(Toffoli) 게이트 또는 $12k-18$ 의 CX 게이트를 포함하며, 깊이 $O(\log(k))$ 인 회로를 생성한다. 5.4 [1]. $k\le 2$ 의 경우, 반환되는 회로는 단일 X, CX 또는 CCX 게이트(각각 $k = 0, 1, 2$ 에 해당)로 구성되며 보조 큐비트를 사용하지 않습니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

1. 카타르와 기드니, 양자 회로 최적화를 위한 조건부 청정 부속물의 등장 arXiv:2407.17966

synth_mcx_n_dirty_i15

qiskit.synthesis.synth_mcx_n_dirty_i15(num_ctrl_qubits, relative_phase=False, action_only=False)

GitHub

Iten 외 [1명의] 논문을 기반으로 $k$ 제어를 사용하여 다중 제어 X 게이트를 합성합니다.

$k\ge 4$ 의 경우, 이 방법은 $k - 2$ 개의 더티 보조 큐비트를 사용하며, $2 * k - 1$ 개의 큐비트와 최대 $8 * k - 6$ 개의 CX 게이트로 구성된 회로를 생성합니다. $k\le 3$ 의 경우, 보조 큐비트가 필요 없는 명시적으로 구성된 효율적인 회로가 대신 사용됩니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.
relative_phase (bool) – True 로 설정하면 이 메서드는 최적화된 다중 제어 X 게이트를 상대 위상까지 적용하는데, 이는 [1의] 8 대 1 수식에 의해 action part 의 상대 위상이 reset part 의 위상과 상쇄되는 방식입니다.
action_only (bool) – 로 설정하면 True, 이 메서드는 [1의] 8의 1의 action part 만 적용합니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

이텐 외. 등, 등거리 변환을 위한 양자 회로, Phys. Rev. A 93, 2018년 3월 23일 (2016), arXiv:1501.06911

synth_mcx_n_clean_m15

qiskit.synthesis.synth_mcx_n_clean_m15(num_ctrl_qubits)

GitHub

Maslov 1에 따르면 $k - 2$ 깨끗한 보조 큐비트를 사용하여 $k\ge 3$ 개의 제어를 갖는 다중 제어 X 게이트 [를] 합성하고 $2 * k - 1$ 개의 큐비트와 최대 $6 * k - 6$ 개의 CX 게이트를 갖는 회로를 생성합니다. $k\le 2$ 의 경우, 반환되는 회로는 단일 X, CX 또는 CCX 게이트(각각 $k = 0, 1, 2$ 에 해당)로 구성되며 보조 큐비트를 사용하지 않습니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

Maslov.., 실제 Rev. A 93, 022311 (2016), arXiv:1508.03273

synth_mcx_1_clean_b95

qiskit.synthesis.synth_mcx_1_clean_b95(num_ctrl_qubits)

GitHub

단일한 깨끗한 보조 큐비트를 사용하여 $k\ge 3$ 개의 제어 신호를 갖는 다중 제어 X 게이트를 합성하되, $k + 2$ 개의 큐비트와 최대 $16 * k - 24$ 개의 CX 게이트로 구성된 회로를 [1], [2] 까지 구현하라. $k\le 2$ 의 경우, 반환되는 회로는 단일 X, CX 또는 CCX 게이트(각각 $k = 0, 1, 2$ 에 해당)로 구성되며 보조 큐비트를 사용하지 않습니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

Barenco et al. al., 양자 계산을 위한 기본 게이트, Phys.Rev. A52 3457 (1995), arXiv:quant-ph/9503016
이텐 외. 등, 등거리 변환을 위한 양자 회로, Phys. Rev. A 93, 2018년 3월 23일 (2016), arXiv:1501.06911

synth_mcx_noaux_v24

qiskit.synthesis.synth_mcx_noaux_v24(num_ctrl_qubits)

GitHub

MCPhaseGate 에 대한 구현을 기반으로 $k$ 컨트롤을 사용하여 다중 제어 X 게이트를 합성합니다.

차례로 MCPhase 게이트는 [1에서] 설명한 다중 제어 특수 유니터리에 대한 분해를 사용합니다.

$k + 1$ 큐비트로 양자 회로를 생성합니다. CX 게이트의 수는 $k$ 에서 2진수입니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

Vale et al. al., 다중 제어 특수 단일 큐비트 게이트의 회로 분해, IEEE TCAD 43(3) (2024), arXiv:2302.06377

synth_mcx_noaux_hp24

qiskit.synthesis.synth_mcx_noaux_hp24(num_ctrl_qubits)

GitHub

Huang과 Palsberg의 작업을 기반으로 $k$ 컨트롤을 사용하여 다중 제어 X 게이트를 합성합니다.

$k + 1$ 큐비트로 양자 회로를 생성합니다. CX 게이트의 수는 $k$ 에서 선형입니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

리턴

합성된 양자 회로.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴 유형

QuantumCircuit

참조

황과 팔스버그, 헬퍼 큐비트를 사용하지 않고 조건부 양자 게이트 컴파일하기, PLDI (2024), <https://dl.acm.org/doi/10.1145/3656436> `_

synth_mcx_gray_code

qiskit.synthesis.synth_mcx_gray_code(num_ctrl_qubits)

GitHub

그레이 코드를 사용하여 $k\ge 3$ 개의 제어 신호를 갖는 다중 제어 X 게이트를 합성하십시오.

$k + 1$ 개의 큐비트로 구성된 양자 회로를 생성합니다. 이 방법은 기하급수적으로 많은 CX 게이트를 생성하므로, $k$ 의 값이 작을 때에만 사용해야 합니다. $k\le 2$ 의 경우, 반환되는 회로는 단일 X, CX 또는 CCX 게이트(각각 $k = 0, 1, 2$ 에 해당)로 구성되며 보조 큐비트를 사용하지 않습니다.

매개변수

num_ctrl_qubits (int) – 제어 큐비트 수입니다.

레이즈

QiskitError – 만약 num_ctrl_qubits 가 불법인 경우.

리턴

합성된 양자 회로.

리턴 유형

QuantumCircuit

synth_c3x

qiskit.synthesis.synth_c3x()

GitHub

3 제어 X-게이트의 효율적인 합성.

리턴 유형

QuantumCircuit

synth_c4x

qiskit.synthesis.synth_c4x()

GitHub

4 제어 X-게이트의 효율적인 합성.

리턴 유형

QuantumCircuit

이진 산술 합성

독사

adder_qft_d00

qiskit.synthesis.adder_qft_d00(num_state_qubits, kind='half', annotated=False)

GitHub

QFT를 사용하여 두 큐비트 레지스터에서 제자리 덧셈을 수행하는 회로입니다.

$n$ 개의 큐비트를 가진 레지스터의 경우, QFT 가산기는 $2^n$ 를 모듈로 한 덧셈( kind="fixed")을 수행하거나, 캐리 큐비트를 추가하여 일반적인 덧셈( kind="half")을 수행할 수 있다. 고정 가산기는 $(3n^2 - n)/2$ CPhaseGate 연산자를 사용하며, 반가산기에는 추가로 $n$ 가 사용됩니다.

예를 들어, 2쿼비트 크기의 레지스터 2개에서 덧셈을 수행하는 비고정_포인트 QFT 가산기 회로는 다음과 같습니다:

 a_0: ─────────■──────■────────■──────────────────────────────────
               │      │        │
 a_1: ─────────┼──────┼────────┼────────■──────■──────────────────
      ┌──────┐ │      │        │P(π/4)  │      │P(π/2) ┌─────────┐
 b_0: ┤0     ├─┼──────┼────────■────────┼──────■───────┤0        ├
      │      │ │      │P(π/2)           │P(π)          │         │
 b_1: ┤1 Qft ├─┼──────■─────────────────■──────────────┤1 qft_dg ├
      │      │ │P(π)                                   │         │
cout: ┤2     ├─■───────────────────────────────────────┤2        ├
      └──────┘                                         └─────────┘

매개변수

num_state_qubits (int) – 상태 $|a\rangle$ 또는 $|b\rangle$ 에 대한 입력 레지스터의 큐비트 수. 두 입력 레지스터는 동일한 수의 큐비트를 가져야 합니다.
kind (str) – 가산기의 종류는 하프 가산기의 경우 "half" , 고정 크기의 가산기의 경우 "fixed" 으로 지정할 수 있습니다. 하프 가산기는 가장 중요한 비트를 나타내는 캐리아웃을 포함하지만 고정 크기 가산기는 그렇지 않으므로 더하기 모듈로 2 ** num_state_qubits 를 수행합니다.
annotated (bool) – True, 적절한 제어 및 역연산을 AnnotatedOperation 객체로 생성합니다.

리턴 유형

QuantumCircuit

참조 자료:

[1] T. G. 드레이퍼, 양자 컴퓨터의 추가, 2000. arXiv:quant-ph/0008033

[2] 루이즈-페레즈 외., 양자 푸리에 변환을 이용한 양자 연산, 2017. arXiv:1411.5949

[3] 베드랄 외., 초등 산술 연산을 위한 양자 네트워크, 1995. arXiv:quant-ph/9511018

adder_ripple_c04

qiskit.synthesis.adder_ripple_c04(num_state_qubits, kind='half')

GitHub

두 큐비트 레지스터에서 제자리 덧셈을 수행하는 리플 캐리 회로입니다.

이 회로는 $2n + O(1)$ CCX 게이트와 $5n + O(1)$ CX 게이트를 사용하며, 깊이는 $2n + O(1)$ [1입니다]. 상수는 구현된 가산기의 종류에 따라 다릅니다.

예를 들어 캐리 인 비트(kind="full")가 있는 3-큐비트 크기의 레지스터 두 개에서 덧셈을 수행하는 리플 캐리 가산기 회로는 다음과 같습니다:

        ┌──────┐                                     ┌──────┐
 cin_0: ┤2     ├─────────────────────────────────────┤2     ├
        │      │┌──────┐                     ┌──────┐│      │
   a_0: ┤0     ├┤2     ├─────────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐     ┌──────┐│      ││      │
   a_1: ┤  MAJ ├┤0     ├┤2     ├─────┤2     ├┤0     ├┤  UMA ├
        │      ││      ││      │     │      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├──■──┤0     ├┤  UMA ├┤      ├
        │      ││      ││      │  │  │      ││      ││      │
   b_0: ┤1     ├┤      ├┤  MAJ ├──┼──┤  UMA ├┤      ├┤1     ├
        └──────┘│      ││      │  │  │      ││      │└──────┘
   b_1: ────────┤1     ├┤      ├──┼──┤      ├┤1     ├────────
                └──────┘│      │  │  │      │└──────┘
   b_2: ────────────────┤1     ├──┼──┤1     ├────────────────
                        └──────┘┌─┴─┐└──────┘
cout_0: ────────────────────────┤ X ├────────────────────────
                                └───┘

여기서 MAJ 및 UMA 게이트는 [1에서] 소개한 게이트에 해당합니다. 이 구현에서 입력 레지스터 큐비트는 첫 번째 입력 레지스터의 모든 큐비트와 두 번째 입력 레지스터의 모든 큐비트 순서로 정렬됩니다.

두 가지 종류의 가산기가 지원됩니다. kind 인수를 설정하면 반입이 없는 하프 더더와 반입과 반출이 없어 고정 레지스터 크기에 따라 작동하는 고정 크기 더더를 선택할 수도 있습니다. 풀 가산기와 달리 이 회로에는 헬퍼 큐비트 하나가 추가로 필요합니다.

3-큐비트 크기의 입력에 대한 고정 소수점 덧셈기(kind="fixed")의 회로도는 다음과 같습니다

        ┌──────┐┌──────┐                ┌──────┐┌──────┐
   a_0: ┤0     ├┤2     ├────────────────┤2     ├┤0     ├
        │      ││      │┌──────┐┌──────┐│      ││      │
   a_1: ┤      ├┤0     ├┤2     ├┤2     ├┤0     ├┤      ├
        │      ││      ││      ││      ││      ││      │
   a_2: ┤      ├┤  MAJ ├┤0     ├┤0     ├┤  UMA ├┤      ├
        │      ││      ││      ││      ││      ││      │
   b_0: ┤1 MAJ ├┤      ├┤  MAJ ├┤  UMA ├┤      ├┤1 UMA ├
        │      ││      ││      ││      ││      ││      │
   b_1: ┤      ├┤1     ├┤      ├┤      ├┤1     ├┤      ├
        │      │└──────┘│      ││      │└──────┘│      │
   b_2: ┤      ├────────┤1     ├┤1     ├────────┤      ├
        │      │        └──────┘└──────┘        │      │
help_0: ┤2     ├────────────────────────────────┤2     ├
        └──────┘                                └──────┘

캐리아웃이 없기 때문에 풀 애더보다 큐비트가 하나 적지만, 캐리인 대신 헬퍼 큐비트를 사용하므로 큐비트가 두 개가 아니라 하나만 적습니다.

매개변수

num_state_qubits (int) – 상태 $|a\rangle$ 또는 $|b\rangle$ 에 대한 입력 레지스터의 큐비트 수. 두 입력 레지스터는 동일한 수의 큐비트를 가져야 합니다.
kind (str) – 가산기의 종류는 전체 가산기의 경우 "full" , 절반 가산기의 경우 "half" , 고정 크기 가산기의 경우 "fixed" 으로 지정할 수 있습니다. 전체 가산기는 반입과 반출을 모두 포함하며, 절반 가산기는 반출만 포함하며, 고정 크기 가산기는 반입과 반출을 모두 포함하지 않습니다.

레이즈

ValueError - num_state_qubits 이 1보다 작으면

리턴 유형

QuantumCircuit

참조 자료:

[1] 쿠카로 외., 새로운 양자 리플 캐리어 추가 회로, 2004. arXiv:quant-ph/0410184

[2] 베드랄 외., 초등 산술 연산을 위한 양자 네트워크, 1995. arXiv:quant-ph/9511018

adder_ripple_v95

qiskit.synthesis.adder_ripple_v95(num_state_qubits, kind='half')

GitHub

VBE 리플 캐리 가산기 [1].

이 방법은 $4n + O(1)$ CCX 게이트와 $4n + 1$ CX 게이트의 깊이 $6n - 2$ [2].

이 회로는 동일한 크기의 양자 레지스터 두 개를 제자리에서 더하는 작업을 수행합니다. 예를 들어, 2쿼비트 크기의 레지스터 두 개에서 전체 덧셈(즉, 캐리인 비트 포함)을 수행하는 고전적인 가산기 회로는 다음과 같습니다:

          ┌────────┐                       ┌───────────┐┌──────┐
   cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
          │        │                       │           ││      │
     a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
          │        │┌────────┐     ┌──────┐│           ││  Sum │
     a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
          │        ││        │  │  │      ││           ││      │
     b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
          │        ││        │┌─┴─┐│      ││           │└──────┘
     b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
          │        ││        │└───┘│      ││           │
  cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
          │        ││        │     │      ││           │
helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
          └────────┘└────────┘     └──────┘└───────────┘

여기서 캐리 및 합산 게이트는 [1에서] 소개한 게이트에 해당합니다. 캐리_dg는 캐리 게이트의 역수에 해당합니다. 이 구현에서 입력 레지스터 큐비트는 첫 번째 입력 레지스터의 모든 큐비트와 두 번째 입력 레지스터의 모든 큐비트 순서로 정렬됩니다. 이는 그림 2의 [1과] 비교했을 때 순서가 다르므로 회로의 도면이 달라집니다.

매개변수

num_state_qubits (int) – 레지스터의 크기입니다.
kind (str) – 가산기의 종류는 전체 가산기의 경우 "full" , 절반 가산기의 경우 "half" , 고정 크기 가산기의 경우 "fixed" 으로 지정할 수 있습니다. 전체 가산기는 반입과 반출을 모두 포함하며, 절반 가산기는 반출만 포함하며, 고정 크기 가산기는 반입과 반출을 모두 포함하지 않습니다.

레이즈

ValueError - num_state_qubits 이 1보다 작으면

리턴 유형

QuantumCircuit

참조 자료:

[1] 베드랄 외., 초등 산술 연산을 위한 양자 네트워크, 1995. arXiv:quant-ph/9511018

[2] 쿠카로 외., 새로운 양자 리플 캐리어 추가 회로, 2004. arXiv:quant-ph/0410184

adder_ripple_r25

qiskit.synthesis.adder_ripple_r25(num_qubits)

GitHub

RV 리플 캐리 가산기 [1]. [1에] 표시된 RV 리플 캐리 가산기를 기반으로 서브선형 깊이를 가진 무안실리 양자 가산기 회로를 구축합니다. 구현의 깊이는 $O(\log^2 n)$ 이며, math:O(n 로그 n) 게이트를 사용합니다.

예를 들어, 두 개의 4-큐비트 크기 레지스터에서 덧셈을 수행하는 리플 캐리 가산기 회로는 다음과 같습니다:

                               ┌───────────┐                    ┌────────┐
 a_0: ─────────────────────────┤0          ├────────────────────┤0       ├───────────────■─────────────────
                     ┌────────┐│           │                    │        │┌───────────┐  │
 a_1: ──■────────────┤0       ├┤2          ├──■─────────────────┤2       ├┤0          ├──┼────■────────────
        │            │        ││           │  │                 │        ││           │  │    │
 a_2: ──┼────■───────┤1       ├┤4          ├──┼────■────────────┤4       ├┤1 LAD_1_dg ├──┼────┼────■───────
        │    │       │        ││           │  │    │            │        ││           │  │    │    │
 a_3: ──┼────┼────■──┤2       ├┤6          ├──┼────┼────■───────┤6 LAD_2 ├┤2          ├──┼────┼────┼────■──
        │    │    │  │        ││           │  │    │    │       │        │└───────────┘┌─┴─┐  │    │    │
 b_0: ──┼────┼────┼──┤        ├┤1 LAD_2_dg ├──┼────┼────┼───────┤1       ├─────────────┤ X ├──┼────┼────┼──
      ┌─┴─┐  │    │  │  LAD_1 ││           │┌─┴─┐  │    │  ┌───┐│        │    ┌───┐    └───┘┌─┴─┐  │    │
 b_1: ┤ X ├──┼────┼──┤        ├┤3          ├┤ X ├──┼────┼──┤ X ├┤3       ├────┤ X ├─────────┤ X ├──┼────┼──
      └───┘┌─┴─┐  │  │        ││           │└───┘┌─┴─┐  │  ├───┤│        │    ├───┤         └───┘┌─┴─┐  │
 b_2: ─────┤ X ├──┼──┤        ├┤5          ├─────┤ X ├──┼──┤ X ├┤5       ├────┤ X ├──────────────┤ X ├──┼──
           └───┘┌─┴─┐│        ││           │     └───┘┌─┴─┐└───┘└────────┘    └───┘              └───┘┌─┴─┐
 b_3: ──────────┤ X ├┤        ├┤7          ├──────────┤ X ├───────────────────────────────────────────┤ X ├
                └───┘│        ││           │          └───┘                                           └───┘
cout: ───────────────┤3       ├┤8          ├───────────────────────────────────────────────────────────────
                     └────────┘└───────────┘

여기 LAD_1 와 LAD_2 는 각각 [1에서] 소개한 CX 및 CCX 래더입니다. 이 구현에서 입력 레지스터 큐비트는 첫 번째 입력 레지스터의 모든 큐비트와 두 번째 입력 레지스터의 모든 큐비트 순서로 정렬됩니다.

매개변수

num_qubits (int) – 레지스터의 크기입니다.

리턴

RV 리플 캐리 가산기를 구현하는 양자 회로입니다.

레이즈

ValueError - num_qubits 이 1보다 작으면

리턴 유형

QuantumCircuit

참조 자료:

1. 레모와 반다일, 서브선형 깊이를 가진 무앵실라 양자 가산기, 2025. arXiv:2501.16802

adder_modular_v17

qiskit.synthesis.adder_modular_v17(num_qubits)

GitHub

그림 15의 [1의] 반 렌터겜 스타일 가산기를 기반으로 보조 큐비트가 없는 모듈식 가산기 회로를 구성합니다. 구현은 각 레지스터에 k 큐비트가 있는 가산기에 최대 $16k - 13$ CX 게이트를 사용합니다(여기서 k = num_qubits).

매개변수

num_qubits (int) – 레지스터의 크기입니다.

리턴

모듈형 가산기를 구현하는 양자 회로입니다.

레이즈

ValueError - num_qubits 이 1보다 작으면

리턴 유형

QuantumCircuit

참조 자료:

[1] Gidney, n+2 clean 큐비트 및 n-1 dirty 큐비트로 팩터링, 2017. arxiv:1706.07884

승수

multiplier_cumulative_h18

qiskit.synthesis.multiplier_cumulative_h18(num_state_qubits, num_result_qubits=None)

GitHub

두 입력 레지스터의 곱셈을 제자리에 저장하는 곱셈 회로입니다.

이 회로는 참조의 접근 방식을 사용합니다. [1]. 예를 들어 3쿼비트 크기의 레지스터 두 개에서 비모듈식 곱셈을 수행하는 곱셈기 회로는 다음과 같습니다:

from qiskit.synthesis.arithmetic import multiplier_cumulative_h18

num_state_qubits = 3
circuit = multiplier_cumulative_h18(num_state_qubits)
circuit.draw("mpl")

이 회로의 곱셈은 입력 레지스터 중 하나를 사용하여 일련의 시프트 덧셈을 수행하고 다른 입력 레지스터의 큐비트는 가산기의 제어 큐비트 역할을 하는 고전적인 접근 방식으로 구현됩니다.

매개변수

num_state_qubits (int) – 상태 $|a\rangle$ 또는 $|b\rangle$ 에 대한 입력 레지스터의 큐비트 수. 두 입력 레지스터는 동일한 수의 큐비트를 가져야 합니다.
num_result_qubits (int | None) – 출력을 제한할 결과 큐비트 수입니다. 결과 큐비트 수가 $n$ 인 경우 곱셈 모듈러 $2^n$ 를 수행하여 출력을 지정된 큐비트 수로 제한합니다. 기본값은 2 * num_state_qubits 으로 두 입력값의 곱셈으로 가능한 모든 결과를 나타냅니다.

레이즈

ValueError - num_result_qubits 이 주어졌지만 유효하지 않은 경우, 즉 [num_state_qubits, 2 * num_state_qubits] 이 아닌 경우.

리턴 유형

QuantumCircuit

참조 자료:

[1] Häner et al.., 산술을 위한 양자 회로 최적화, 2018. arXiv:1805.12445

multiplier_qft_r17

qiskit.synthesis.multiplier_qft_r17(num_state_qubits, num_result_qubits=None)

GitHub

두 입력 레지스터의 곱셈을 제자리에 저장하는 QFT 곱셈 회로입니다.

이 회로의 곱셈은 그림 3의 [1의] 절차를 사용하여 구현되며, 가중 합계 회전은 그림 5의 [1에] 주어진 대로 구현됩니다. QFT는 출력 레지스터에 사용되며, 그 다음에는 입력 레지스터로 제어되는 회전이 이어집니다. 회전은 상태를 QFT 베이스에서 두 입력 레지스터의 곱으로 변환하고, 역 QFT를 사용하여 QFT 베이스에서 되돌립니다. 예를 들어, 상태 큐비트 3개에서 전체 승수는 다음과 같이 주어집니다:

from qiskit.synthesis.arithmetic import multiplier_qft_r17

num_state_qubits = 3
circuit = multiplier_qft_r17(num_state_qubits)
circuit.draw("mpl")

매개변수

num_state_qubits (int) – 상태 $|a\rangle$ 또는 $|b\rangle$ 에 대한 입력 레지스터의 큐비트 수. 두 입력 레지스터는 동일한 수의 큐비트를 가져야 합니다.
num_result_qubits (int | None) – 출력을 제한할 결과 큐비트 수입니다. 결과 큐비트 수가 $n$ 인 경우 곱셈 모듈러 $2^n$ 를 수행하여 출력을 지정된 큐비트 수로 제한합니다. 기본값은 2 * num_state_qubits 으로 두 입력값의 곱셈으로 가능한 모든 결과를 나타냅니다.

레이즈

ValueError - num_result_qubits 이 주어졌지만 유효하지 않은 경우, 즉 [num_state_qubits, 2 * num_state_qubits] 이 아닌 경우.

리턴 유형

QuantumCircuit

참조 자료:

[1] 루이즈-페레즈 외., 양자 푸리에 변환을 이용한 양자 연산, 2017. arXiv:1411.5949

합계

synth_weighted_sum_carry

qiskit.synthesis.synth_weighted_sum_carry(weighted_sum)

GitHub

상태 큐비트 수와 큐비트 가중치에 따라 가중 합계 게이트를 합성합니다.

이 방법은 부록 [1의] 부록 A에 설명되어 있습니다.

참조:

[1] 스타마토풀로스 외. 양자 컴퓨터를 이용한 옵션 가격 책정 (2020)

퀀텀 4, 291

매개변수

weighted_sum (WeightedSumGate)

리턴 유형

QuantumCircuit

일항 산술 합성

정수 비교기

synth_integer_comparator_2s

qiskit.synthesis.synth_integer_comparator_2s(num_state_qubits, value, geq=True)

GitHub

2s 보수를 기반으로 정수 비교를 구현합니다.

이는 부록 B의 [1을] 기준으로 합니다.

매개변수

num_state_qubits (int) – 비교할 값을 인코딩하는 큐비트 수입니다.
value (int) – 비교할 값입니다.
geq (bool) – True 이 값보다 큐비트 상태가 $\geq$ 이면 목표 비트를 뒤집고, 그렇지 않으면 $<$ 을 구현합니다.

리턴

정수 비교기를 구현하는 회로입니다.

리턴 유형

QuantumCircuit

참조

[1] J. Gacon 외. "양자 강화 시뮬레이션 기반 최적화"

arXiv:2005.10780.

synth_integer_comparator_greedy

qiskit.synthesis.synth_integer_comparator_greedy(num_state_qubits, value, geq=True)

GitHub

값별 비교를 기반으로 정수 비교를 구현합니다.

2 ** (num_state_qubits - 1) 보다 작은 value 의 경우 이 회로는 제어 상태가 0, 1,..., value - 1 인 value 다중 제어 게이트를 구현하여 큐비트 상태가 허용된 값 중 하나를 나타내면 대상 큐비트가 플립되도록 합니다. value 보다 큰 경우 geq 이 뒤집어집니다. 이 구현에는 기하급수적으로 많은 게이트가 필요할 수 있습니다. 보조 큐비트를 사용할 수 있는 경우, 다음에서 제공하는 구현이 더 효율적입니다 synth_integer_comparator_2s() 에서 제공하는 구현이 더 효율적입니다.

매개변수

num_state_qubits (int) – 비교할 값을 인코딩하는 큐비트 수입니다.
value (int) – 비교할 값입니다.
geq (bool) – True 이 값보다 큐비트 상태가 $\geq$ 이면 목표 비트를 뒤집고, 그렇지 않으면 $<$ 을 구현합니다.

리턴

정수 비교기를 구현하는 회로입니다.

리턴 유형

QuantumCircuit

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

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