GroverOperator

class qiskit.circuit.library.GroverOperator(oracle, state_preparation=None, zero_reflection=None, reflection_qubits=None, insert_barriers=False, mcx_mode='noancilla', name='Q')

GitHub

베이스: QuantumCircuit

Grover 운영자.

그로버의 검색 알고리즘 [1, 2는] 원하는 출력 상태의 진폭을 증폭하는 데 사용되는 소위 그로버 연산자를 반복적으로 적용하는 것으로 구성됩니다. 이 연산자( $\mathcal{Q}$ )는 위상 오라클( $\mathcal{S}_f$ ), 제로 위상 편이 또는 제로 반사( $\mathcal{S}_0$ ), 입력 상태 준비( $\mathcal{A}$ )로 구성됩니다:

\mathcal{Q} = \mathcal{A} \mathcal{S}_0 \mathcal{A}^\dagger \mathcal{S}_f

표준 Grover 검색에는 $\mathcal{A} = H^{\otimes n}$ 이 있습니다:

\mathcal{Q} = H^{\otimes n} \mathcal{S}_0 H^{\otimes n} \mathcal{S}_f = D \mathcal{S_f}

$D = H^{\otimes n} \mathcal{S}_0 H^{\otimes n}$ 작업은 확산 연산자라고도 합니다. 이 공식에서 Grover의 연산자는 두 단계로 구성되어 있음을 알 수 있습니다. 먼저 위상 오라클이 좋은 상태에 -1 를 곱한 다음( $\mathcal{S}_f$ ), 전체 상태를 평균에 반영합니다( $D$ ).

이 클래스를 사용하면 양자 진폭 증폭(그로버 알고리즘의 일반화)과 같이 서로 다른 상태 준비 과정을 설정할 수 있습니다. $\mathcal{A}$ 는 하다마르 게이트의 레이어가 아닐 수도 있습니다. [3].

위상 오라클 $\mathcal{S}_f$ 의 동작은 다음과 같이 정의됩니다

\mathcal{S}_f: |x\rangle \mapsto (-1)^{f(x)}|x\rangle

여기서 $x$ 상태가 양호하면 $f(x) = 1$ , 그렇지 않으면 0입니다. 이 오라클이 좋은 상태의 위상을 뒤집고 결과 큐비트의 상태를 뒤집지 않는다는 사실을 강조하기 위해 $\mathcal{S}_f$ 을 위상 오라클이라고 부릅니다.

비트플립 오라클에서 위상 오라클을 쉽게 구성하려면 결과 큐비트에 제어된 X 게이트를 X와 H 게이트로 끼워 넣으면 됩니다. 인스턴스

Bitflip oracle     Phaseflip oracle
q_0: ──■──         q_0: ────────────■────────────
     ┌─┴─┐              ┌───┐┌───┐┌─┴─┐┌───┐┌───┐
out: ┤ X ├         out: ┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├
     └───┘              └───┘└───┘└───┘└───┘└───┘

오라클 및 $\mathcal{A}$ 연산자를 정의하는 데 약간의 유연성이 있습니다. 그로버 알고리즘에서 그로버 연산자를 적용하기 전에 먼저 $\mathcal{A}$ 연산자(또는 표준 공식에서는 하다마드 게이트)를 한 번 적용하여 큐비트를 준비합니다. 따라서 항상 $\mathcal{A} \mathcal{S}_f \mathcal{A}^\dagger$ 형식의 연산이 있습니다. 따라서 비트플립 로직을 $\mathcal{A}$ 으로 옮기고 오라클은 비트플립에 기반한 Z 게이트를 통해 위상 플립만 수행하도록 남겨둘 수 있습니다. 이에 대한 한 가지 가능한 사용 사례는 상태 큐비트의 계산을 해제하지 않는 오라클입니다.

제로 리플렉션 $\mathcal{S}_0$ 은 일반적으로 다음과 같이 정의됩니다

\mathcal{S}_0 = 2 |0\rangle^{\otimes n} \langle 0|^{\otimes n} - \mathbb{I}_n

여기서 $\mathbb{I}_n$ 은 $n$ 쿼빗의 ID입니다. 기본적으로 이 클래스는 네거티브 버전 $2 |0\rangle^{\otimes n} \langle 0|^{\otimes n} - \mathbb{I}_n$ 을 구현하는데, 이는 대상 큐비트에 X 게이트로 샌드위치된 다중 제어 Z로 간단히 구현할 수 있고 도입된 글로벌 위상은 Grover의 알고리즘에 중요하지 않기 때문입니다.

예제

>>> from qiskit.circuit import QuantumCircuit
>>> from qiskit.circuit.library import GroverOperator
>>> oracle = QuantumCircuit(2)
>>> oracle.z(0)  # good state = first qubit is |1>
>>> grover_op = GroverOperator(oracle, insert_barriers=True)
>>> grover_op.decompose().draw()
         ┌───┐ ░ ┌───┐ ░ ┌───┐          ┌───┐      ░ ┌───┐
state_0: ┤ Z ├─░─┤ H ├─░─┤ X ├───────■──┤ X ├──────░─┤ H ├
         └───┘ ░ ├───┤ ░ ├───┤┌───┐┌─┴─┐├───┤┌───┐ ░ ├───┤
state_1: ──────░─┤ H ├─░─┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├─░─┤ H ├
               ░ └───┘ ░ └───┘└───┘└───┘└───┘└───┘ ░ └───┘

>>> oracle = QuantumCircuit(1)
>>> oracle.z(0)  # the qubit state |1> is the good state
>>> state_preparation = QuantumCircuit(1)
>>> state_preparation.ry(0.2, 0)  # non-uniform state preparation
>>> grover_op = GroverOperator(oracle, state_preparation)
>>> grover_op.decompose().draw()
         ┌───┐┌──────────┐┌───┐┌───┐┌───┐┌─────────┐
state_0: ┤ Z ├┤ RY(-0.2) ├┤ X ├┤ Z ├┤ X ├┤ RY(0.2) ├
         └───┘└──────────┘└───┘└───┘└───┘└─────────┘

>>> oracle = QuantumCircuit(4)
>>> oracle.z(3)
>>> reflection_qubits = [0, 3]
>>> state_preparation = QuantumCircuit(4)
>>> state_preparation.cry(0.1, 0, 3)
>>> state_preparation.ry(0.5, 3)
>>> grover_op = GroverOperator(oracle, state_preparation,
... reflection_qubits=reflection_qubits)
>>> grover_op.decompose().draw()
                                      ┌───┐          ┌───┐
state_0: ──────────────────────■──────┤ X ├───────■──┤ X ├──────────■────────────────
                               │      └───┘       │  └───┘          │
state_1: ──────────────────────┼──────────────────┼─────────────────┼────────────────
                               │                  │                 │
state_2: ──────────────────────┼──────────────────┼─────────────────┼────────────────
         ┌───┐┌──────────┐┌────┴─────┐┌───┐┌───┐┌─┴─┐┌───┐┌───┐┌────┴────┐┌─────────┐
state_3: ┤ Z ├┤ RY(-0.5) ├┤ RY(-0.1) ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ RY(0.1) ├┤ RY(0.5) ├
         └───┘└──────────┘└──────────┘└───┘└───┘└───┘└───┘└───┘└─────────┘└─────────┘

>>> mark_state = Statevector.from_label('011')
>>> diffuse_operator = 2 * DensityMatrix.from_label('000') - Operator.from_label('III')
>>> grover_op = GroverOperator(oracle=mark_state, zero_reflection=diffuse_operator)
>>> grover_op.decompose().draw(fold=70)
         ┌─────────────────┐      ┌───┐                          »
state_0: ┤0                ├──────┤ H ├──────────────────────────»
         │                 │┌─────┴───┴─────┐     ┌───┐          »
state_1: ┤1 UCRZ(0,pi,0,0) ├┤0              ├─────┤ H ├──────────»
         │                 ││  UCRZ(pi/2,0) │┌────┴───┴────┐┌───┐»
state_2: ┤2                ├┤1              ├┤ UCRZ(-pi/4) ├┤ H ├»
         └─────────────────┘└───────────────┘└─────────────┘└───┘»
«         ┌─────────────────┐      ┌───┐
«state_0: ┤0                ├──────┤ H ├─────────────────────────
«         │                 │┌─────┴───┴─────┐    ┌───┐
«state_1: ┤1 UCRZ(pi,0,0,0) ├┤0              ├────┤ H ├──────────
«         │                 ││  UCRZ(pi/2,0) │┌───┴───┴────┐┌───┐
«state_2: ┤2                ├┤1              ├┤ UCRZ(pi/4) ├┤ H ├
«         └─────────────────┘└───────────────┘└────────────┘└───┘

속성

oracle

나쁜 상태에 대한 리플렉션을 구현하는 오라클입니다.

reflection_qubits

리플렉션 큐비트, S0 이 적용되는 경우( S0 이 사용자가 지정하지 않은 경우).

state_preparation

A 연산자 또는 하다마드를 구현하는 서브회로입니다.

zero_reflection

반사를 약 0으로 구현하는 하위 회로입니다.

name

유형: str

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

예제

from qiskit import QuantumCircuit

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

my_circuit

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

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