통합 하이브리드 컴퓨팅

아티클
12/07/2023

통합 하이브리드 컴퓨팅은 클래식 및 양자 프로세스를 함께 제공하므로 클래식 코드는 물리적 큐비트가 활성 상태로 유지되는 동안 중간 회로 측정을 기반으로 양자 연산의 실행을 제어할 수 있습니다. 중첩된 조건부, 루프 및 함수 호출과 같은 일반적인 프로그래밍 기술을 사용하면 단일 양자 프로그램이 복잡한 문제를 실행하여 필요한 샷 수를 줄일 수 있습니다. 큐비트 재사용 기술을 사용하면 더 적은 수의 큐비트를 활용하는 컴퓨터에서 더 큰 프로그램을 실행할 수 있습니다.

중요

통합 하이브리드 양자 컴퓨팅은 현재 I 커널%azure, 매직 명령 또는 qsharp.azure 모듈과 같은Q# 이 페이지의 예제에 있는 다른 구성 요소와 함께 Visual Studio Code 대한 최신 Quantum Development Kit (최신 QDK) 확장에서 지원되지 않습니다. 통합 하이브리드 작업을 실행하려면 Microsoft Quantum Development Kit (클래식 QDK)를 사용합니다. 자세한 내용은 클래식 QDK에서 계속 작업을 참조하세요.

자세한 내용은 다음을 참조하세요.

통합 하이브리드 양자 컴퓨팅

targets 지원됨

현재 Azure Quantum의 통합 하이브리드 컴퓨팅 모델은 Quantinuumtargets에서 지원됩니다.

Quantinuum

지원되는 기능	참고
클래식 루프	제한된 루프만
임의 제어 흐름	if/else 분기 사용
중간 회로 측정	클래식 레지스터 리소스 활용
큐비트 재사용	해당 없음
실시간 클래식 컴퓨팅	부호 없는 32비트 정수 산술 클래식 레지스터 리소스 활용

시작

통합 하이브리드 프로그래밍 탐색을 시작하려면 이 문서의 샘플을 살펴보거나 Azure Quantum 포털의 샘플 갤러리에서 하이브리드 양자 컴퓨팅 탭을 살펴보는 것이 좋습니다.

통합 하이브리드 작업 제출

통합 하이브리드 작업을 제출할 때 를 지정한 target 후 기능 매개 변수를 target추가해야 합니다. 그 외에 Azure Quantum의 통합 하이브리드 프로그램은 일반 양자 작업처럼 실행되고 관리됩니다. 각 작업에는 단일 작업 ID가 있으며 결과는 단일 히스토그램입니다.

중요

나Q#

Jupyter Notebook IQ# 커널을 사용하는 경우 %azure를 사용합니다.target매개 변수가 있는AdaptiveExecution -capability 매직 명령입니다.

%azure.target quantinuum.sim.h1-1e
%azure.target-capability AdaptiveExecution

Python + Q#

qsharp Python 패키지를 사용하는 경우 매개 변수와 qsharp.azure.target_capability 함께 함수를 AdaptiveExecution 사용합니다.

qsharp.azure.target("quantinuum.sim.h1-1e")
qsharp.azure.target_capability("AdaptiveExecution")

Azure CLI

Azure CLI를 사용하여 작업을 제출할 때 값AdaptiveExecution이 인 --target-capability 매개 변수를 추가합니다.

az quantum job submit \
    --target-capability AdaptiveExecution \
    --target-id quantinuum.sim.h1-1e \
    --job-name IterativePhaseEstimation \
    --shots 100 \
    --output table

세션 내에서 통합 하이브리드 작업 제출

및 Python을 사용하여 Q#세션 내에서 여러 통합 하이브리드 작업을 결합할 수 있습니다. 세션을 제출할 때 값AdaptiveExecution이 인 targetCapability 입력 매개 변수를 추가합니다.

with target.open_session(name="Q# session") as session:
    target.submit(input_data=QuantumOperation, name="Job 1", input_params={"count":100, "targetCapability":"AdaptiveExecution"}) # First job submission
    target.submit(input_data=QuantumOperation, name="Job 2", input_params={"count":200, "targetCapability":"AdaptiveExecution"}) # Second job submission
    target.submit(input_data=QuantumOperation, name="Job 3", input_params={"count":300, "targetCapability":"AdaptiveExecution"}) # Third job submission

자세한 내용은 세션 시작을 참조하세요.

참고

모든 양자 컴퓨팅 하드웨어 공급자에 대해 세션을 사용할 수 있지만 통합 하이브리드 양자 컴퓨팅 작업은 현재 Quantinuum targets에서 지원됩니다.

통합 하이브리드 작업의 비용 예측

먼저 에뮬레이터에서 실행하여 Quantinuum 하드웨어에서 통합 하이브리드 작업을 실행하는 비용을 예측할 수 있습니다.

에뮬레이터에서 성공적으로 실행된 후:

Azure Quantum 작업 영역에서 작업 관리를 선택합니다.
제출한 작업을 선택합니다.
작업 세부 정보 팝업에서 비용 예측을 선택하여 사용된 eHQC(Quantinuum 에뮬레이터 크레딧)를 확인합니다. 이 숫자는 Quantinuum 하드웨어에서 작업을 실행하는 데 필요한 HQC(Quantinuum 양자 크레딧)의 수로 직접 변환됩니다.

비용 예측

참고

Quantinuum은 전체 회로의 등록을 취소하고 조건부로 실행되었는지 여부에 관계없이 모든 코드 경로에 대한 비용을 계산합니다.

통합 하이브리드 샘플

다음 샘플에서는 통합 하이브리드 컴퓨팅에 대한 현재 기능 집합을 보여 줍니다.

얽힌 GHZ 상태 확인
3큐비트 반복
반복 위상 추정

사전 요구 사항

Azure Quantum을 새로 사용하는 경우 양자 하드웨어에 대해 샘플을 실행하려면 Azure 구독 및 Azure Quantum 작업 영역이 필요합니다. 자세한 내용은 Azure Quantum 작업 영역 만들기를 참조하세요.
VS Code 및 Quantum Development Kit 로컬 환경에서 설정. 자세한 내용은 설정을 참조하세요 Quantum Development Kit.
VS Code의 최신 버전 Quantum Development Kit (0.27.258160)이 있는지 확인합니다.
- VS Code에서 Ctrl + Shift + X 를 선택하고 "Microsoft Quantum Development Kit"를 검색합니다.

이 문서의 샘플은 VS(Visual Studio) 코드에서 실행되고 기본 제공 Azure CLI(명령줄 인터페이스)를 사용하여 Azure Quantum에 작업을 제출하도록 설정됩니다. 이러한 샘플 및 기타 샘플의 Jupyter Notebook 버전을 실행하려면 Azure Portal 작업 영역에 로그인하고 샘플 갤러리의 하이브리드 양자 컴퓨팅 탭에서 샘플을 확인합니다. 클라우드에서 Notebook을 실행하거나 다운로드하여 로컬로 실행할 수 있습니다.

통합 하이브리드 프로그램의 문제를 해결하려면 통합 하이브리드 문제 해결을 참조하세요.

이 샘플에서는 양자 컴퓨팅 백 엔드에서 완전히 처리되는 동일한 프로그램에서 클래식 및 양자 명령을 혼합하는 방법을 알아보세요.

이 샘플에 대해 주의할 기능은 다음과 같습니다.

루프 및 큐비트 측정은 큐비트가 일관되게 유지되는 동안 발생합니다.
루틴은 클래식 및 양자 컴퓨팅 작업을 혼합합니다.
QPU(예: FPGA) 옆에 실행되는 특수 고성능 하드웨어를 프로그래밍하는 방법을 배울 필요가 없습니다.
통합 하이브리드 기능 없이 동등한 프로그램을 실행하려면 모든 중간 측정 결과를 반환한 다음 데이터에 대한 후처리를 실행해야 합니다.

VS Code 프로젝트 만들기

VS Code에서 CheckGHZ라는 새 Q# 독립 실행형 콘솔 애플리케이션 프로젝트를 만듭니다.
1. 명령 팔레트 >Q#보기>: 새 프로젝트 > 독립 실행형 콘솔 애플리케이션 만들기를 선택합니다.

CheckGHZ.csproj의 구성을 다음으로 바꿉니다.

<Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum</ExecutionTarget>
    <TargetCapability>AdaptiveExecution</TargetCapability>
  </PropertyGroup>
</Project>

Program.qs의 코드를 다음으로 바꿉니다.

namespace Microsoft.Quantum.Samples {

    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Intrinsic;

    /// # Summary
    /// Counts the number of times measurements of a prepared GHZ state did not match the expected correlations.
    @EntryPoint() // The EntryPoint attribute is used to mark that this operation is where a quantum program will start running.
    operation CheckGHZ() : Int {
        use q = Qubit[3];
        mutable mismatch = 0;
        for _ in 1..10 {
            // Prepare the GHZ state.
            H(q[0]);
            CNOT(q[0], q[1]);
            CNOT(q[1], q[2]);

            // Measures and resets the 3 qubits
            let (r0, r1, r2) = (MResetZ(q[0]), MResetZ(q[1]), MResetZ(q[2]));

            // Adjusts classical value based on qubit measurement results
            if not (r0 == r1 and r1 == r2) {
                set mismatch += 1;
            }
        }
        return mismatch;
    }
}

VS Code의 터미널 창에서 Azure Quantum 작업 영역에 연결하고 기본 리소스를 설정합니다.
```
az login
```
참고

az quantum workspace list를 실행하여 로그인한 후 터미널 창에 Azure 구독 ID, 리소스 그룹 및 작업 영역 이름을 나열할 수 있습니다. 또는 Azure Quantum 작업 영역의 개요 페이지에서 Azure Portal 찾을 수 있습니다.
```
az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
```

작업을 제출하고 결과를 봅니다. 이 실행에서는 약 10.65 eHQC(Quantinuum 에뮬레이터 청구 단위)를 사용합니다.

az quantum job submit \
  --target-id quantinuum.sim.h1-1e \
  --job-name CheckGHZ \
  --target-capability AdaptiveExecution \
  --shots 50

az quantum job output \
  -o table \
  --job-id [job-id]

GHZ 출력

이 샘플에서는 비트 대칭 이동 오류를 감지하고 수정하는 데 사용할 수 있는 3큐비트 반복 코드를 만드는 방법을 보여 줍니다.

통합 하이브리드 컴퓨팅 기능을 활용하여 논리 큐비트 레지스터의 상태가 일관된 동안 오류 수정이 수행된 횟수를 계산합니다.

VS Code 프로젝트 만들기

VS Code에서 ThreeQubit라는 새 Q# 독립 실행형 콘솔 애플리케이션 프로젝트를 만듭니다.
1. 명령 팔레트 >Q#보기>: 새 프로젝트 > 독립 실행형 콘솔 애플리케이션 만들기를 선택합니다.

ThreeQubit.csproj의 구성을 다음으로 바꿉니다.

<Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum</ExecutionTarget>
    <TargetCapability>AdaptiveExecution</TargetCapability>
  </PropertyGroup>

</Project>

Program.qs의 코드를 다음으로 바꿉니다.

namespace Microsoft.Quantum.Samples {

    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    operation ThreeQubitRepetitionCode() : (Bool, Int) {
        // Use two qubit registers, one for encoding and an auxiliary one for syndrome measurements.
        use encodedRegister = Qubit[3];
        use auxiliaryRegister = Qubit[2];

        // Initialize the first qubit in the register to a |-〉 state.
        H(encodedRegister[0]);
        Z(encodedRegister[0]);

        // Apply several unitary operations to the encoded qubits performing bit flip detection and correction between
        // each application.
        mutable bitFlipCount = 0;
        within {
            // The 3 qubit register is used as a repetition code.
            Encode(encodedRegister);
        }
        apply {
            let iterations = 5;
            for _ in 1 .. iterations {
                // Apply a sequence of rotations to the encoded register that effectively perform an identity operation.
                ApplyRotationalIdentity(encodedRegister);

                // Measure the bit flip error syndrome, revert the bit flip if needed, and increase the count if a bit flip occurred.
                let (parity01, parity12) = MeasureBitFlipSyndrome(encodedRegister, auxiliaryRegister);
                let bitFlipReverted = RevertBitFlip(encodedRegister, parity01, parity12);
                if (bitFlipReverted) {
                    set bitFlipCount += 1;
                }
            }
        }

        // Transform the qubit to the |1〉 state and measure it in the computational basis.
        H(encodedRegister[0]);
        let result = MResetZ(encodedRegister[0]) == One;
        ResetAll(encodedRegister);

        // The output of the program is a boolean-integer tuple where the boolean represents whether the qubit
        // measurement result was the expected one and the integer represents the number of times bit flips occurred
        // throughout the program.
        return (result, bitFlipCount);
    }

    operation ApplyRotationalIdentity(register : Qubit[]) : Unit is Adj
    {
        // This operation implements an identity operation using rotations about the x-axis.
        // The Rx operation has a period of $2\pi$ (given that it is not possible to measure the difference between
        // states $|\\psi〉$ and $-|\\psi〉$). Using it to apply 4 $\frac{\pi}{2}$ rotations about the x-axis, effectively
        // leaves the qubit register in its original state.
        let theta = PI() * 0.5;
        for i in 1 .. 4 {
            for qubit in register
            {
                Rx(theta, qubit);
            }
        }
    }

    operation RevertBitFlip(register : Qubit[], parity01 : Result, parity12 : Result) : Bool
    {
        if (parity01 == One and parity12 == Zero) {
            X(register[0]);
        }
        elif (parity01 == One and parity12 == One) {
            X(register[1]);
        }
        elif (parity01 == Zero and parity12 == One) {
            X(register[2]);
        }

        return parity01 == One or parity12 == One;
    }

    operation Encode(register : Qubit[]) : Unit is Adj
    {
        CNOT(register[0], register[1]);
        CNOT(register[0], register[2]);
    }

    operation MeasureBitFlipSyndrome(encodedRegister : Qubit[], auxiliaryRegister : Qubit[]) : (Result, Result)
    {
        // Measure the bit flip syndrome by checking the parities between qubits 0 and 1, and between qubits 1 and 2.
        ResetAll(auxiliaryRegister);
        CNOT(encodedRegister[0], auxiliaryRegister[0]);
        CNOT(encodedRegister[1], auxiliaryRegister[0]);
        CNOT(encodedRegister[1], auxiliaryRegister[1]);
        CNOT(encodedRegister[2], auxiliaryRegister[1]);
        let parity01 = MResetZ(auxiliaryRegister[0]);
        let parity12 = MResetZ(auxiliaryRegister[1]);
        return (parity01, parity12);
    }
}

VS Code의 터미널 창에서 Azure Quantum 작업 영역에 연결하고 기본 리소스를 설정합니다.
```
az login
```
참고

az quantum workspace list를 실행하여 로그인한 후 터미널 창에 Azure 구독 ID, 리소스 그룹 및 작업 영역 이름을 나열할 수 있습니다. 또는 Azure Quantum 작업 영역의 개요 페이지에서 Azure Portal 찾을 수 있습니다.
```
az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
```

작업을 제출하고 결과를 봅니다. 이 실행에서는 약 11.31 eHQC(Quantinuum 에뮬레이터 청구 단위)를 사용합니다.

az quantum job submit \
    --target-id quantinuum.sim.h1-1e \
    --job-name ErrorCorrection \
    --target-capability AdaptiveExecution \
    --shots 50

az quantum job output \
    -o table \
    --job-id [job-id]

이 샘플 코드는 오스트레일리아의 KPMG Quantum 팀 구성원이 작성했으며 MIT 라이선스에 속합니다. 경계 루프, 런타임 시 클래식 함수 호출, 중첩된 조건부 if 문, 중간 회로 측정 및 큐비트 재사용의 확장된 기능을 Basic Measurement Feedbacktargets 보여 주는 것을 목표로 합니다.

3개의 큐비트에서 반복 위상 추정을 사용하여 2차원 내부 제품 계산

이 샘플 프로그램은 내에서 Q#반복 단계 추정을 보여 줍니다. 반복 위상 추정을 사용하여 큐비트와 ancilla 큐비트에 인코딩된 target 두 개의 2차원 벡터 사이의 내부 제품을 계산합니다. 측정에 사용되는 유일한 큐비트인 추가 컨트롤 큐비트도 초기화됩니다.

회로는 큐비트와 ancilla 큐비트에서 벡터 쌍을 target 인코딩하여 시작합니다. 그런 다음, Oracle 연산자를 전체 레지스터에 적용하고 제어 큐비트에서 제어하며 이는 $\ket +$ 상태로 설정됩니다. 제어된 Oracle 연산자는 컨트롤 큐비트의 $\ket 1$ 상태에 대한 단계를 생성합니다. 그런 다음, H 게이트를 컨트롤 큐비트에 적용하여 측정 시 단계를 관찰할 수 있도록 하여 읽을 수 있습니다.

VS Code 프로젝트 만들기

VS Code에서 IPE라는 새 Q# 독립 실행형 콘솔 애플리케이션 프로젝트를 만듭니다.
1. 명령 팔레트 >Q#보기>: 새 프로젝트 > 독립 실행형 콘솔 애플리케이션 만들기를 선택합니다.

IPE.csproj의 구성을 다음으로 바꿉니다.

<Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
  </PropertyGroup>

</Project>

Program.qs의 코드를 다음으로 바꿉니다.

namespace IPE {

    //IMPORT LIBRARIES
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Arrays;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Convert;


    // additional code added here


}

인코딩 벡터

벡터 v 및 c는 큐비트와 ancilla 큐비트에 인코딩 target 되어야 합니다. 벡터 $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2})))$은 양자 상태 $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$로 나타낼 수 있습니다. 마찬가지로 $\theta_2$을 사용하여 $c$를 생성할 수 있습니다.

$\ket 0$ 상태의 target 큐비트에 적용된 Y 회전:

$$RY(\theta)\ket 0 = e^{iY\theta/2}\ket 0 = cos(\frac{\theta}{2})\ket 0 + sin(\frac{\theta}{2})\ket 1$$

참고

여기서는 2의 인수 가 세타에 있습니다. $\ket 0$에 $RY(2\pi)$ 게이트의 애플리케이션은 $-\ket 0$ 상태를 제공하고 벡터 $(-1,0)$를 인코딩합니다. 이 단계는 전역 단계로 간주될 수 없으며 전체 레지스터가 얽히기 때문에 제거됩니다.

큐비트 및 ancilla 큐비트의 레지스터 target 는 입니다.

$$\ket \Psi = \ket {\Psi_\text{Target qubit}}\ket {\Psi_\text{Ancilla qubit}}$$

만들 target 상태는 큐비트에 있고 ancilla 큐비트는 입니다.

$$\ket{\Psi}=\frac{1}{\sqrt{2}}(\ket{v}\ket{+}+\ket{c}\ket{-}),$$

양식도 사용합니다.

$$\ket{\Psi} = \frac{1}{2}(\ket{v}+\ket{c})\ket{0}+\frac{1}{2}(\ket{v}-\ket{c})\ket{1}.$$

Program.qs 파일에 다음 작업을 추가합니다.

//This is state preparation operator A for encoding the 2D vector
operation StateInitialisation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    H(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector v.
    Controlled R([AncilReg], (PauliY, theta_1, TargetReg));

    // X gate on ancilla to change from |+> to |->
    X(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector c.
    Controlled R([AncilReg], (PauliY, theta_2, TargetReg));
    X(AncilReg);
    H(AncilReg);
}

더 오라클

오라클 G는 큐비트와 ancilla 큐비트에 인코딩된 target 상태에서 고유성을 생성하도록 생성되어야 합니다. 이 오라클의 생성은 이 예제 내에서 데모에 중요하지 않지만 적용되는 작업은 다음과 같습니다.

$$G\ket \Psi = e^{2\pi i\phi} \ket \Psi.$$

여기서 내부 제품 $\braket {v|c}$이 (가) [0,1] 사이에 바인딩된 $\phi$단계에 포함되어 있습니다. 해당 상태에서 시작하는 컨트롤 큐비트에서 제어되는 경우 $\ket{\Psi_\text{Control Qubit}} = \ket +$

$$\begin{aligned} \text{Controlled }G \ket{\Psi_\text{Control Qubit}} \ket \Psi & = \frac {1}{\sqrt{2}} (\ket 0 \ket \Psi + e^{2\pi i\phi}\ket 1 \ket \Psi )\ & =\frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1) \ket \Psi \end{aligned}$$

이제 컨트롤 큐비트에 내부 제품 $\braket {v|c}$에 관련된 단계가 포함됩니다.

$$\ket{\Psi_\text{Control Qubit}} = \frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1)$$

Program.qs 파일에 다음 작업을 추가합니다.

operation GOracle(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    Z(AncilReg);
        within {
            Adjoint StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);

            // Apply X gates individually here as currently ApplyAll is not Adj + Ctl
            X(AncilReg);
            X(TargetReg);
        }
        apply {
            Controlled Z([AncilReg],TargetReg);
        }
    }

반복

이제 회로의 반복 부분에 대해. n 측정의 경우 위상을 이진 값 $\phi$로 나타낼 수 있고 $2^n$ 오라클을 적용하면 단계의 n번째 이진 지점을 관찰할 수 있습니다(간단한 이진 곱하기 및 모듈러스 $2\pi$를 통해). 컨트롤 큐비트의 값은 다음 반복에서 사용할 수 있는 클래식 레지스터 및 큐비트 재설정에 배치된 읽기 전용일 수 있습니다. 다음 반복은 $2^{n-1}$ 오라클을 적용하여 n번째 측정값에 따라 컨트롤 큐비트의 단계를 수정합니다. 컨트롤 큐비트의 상태는 로 표시될 수 있습니다.

$$ \ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i\phi}\ket 1 $$

where $\phi = 0.\phi_0\phi_1\phi_2\phi_3$...

$2^n$ 제어된 오라클을 적용하면 컨트롤 큐비트의 상태가 지정됩니다.

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n\phi_{n+1}\phi_{n+2}\phi_{n+3}...} \ket 1 $$

단계에 $\phi_n$(즉, $\phi_{n+1},\phi_{n+2}, \text{etc}$)보다 더 깊은 용어가 없다는 점을 고려합니다.

$$ G^{2^n}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n}\ket 1 $$

이제 값 $\phi_n$은 H 게이트 및 Z 축을 따라 프로젝션되는 측정값으로 관찰할 수 있습니다. 컨트롤 큐비트 다시 설정 및 oracle $2^{n-1}$ 시간 적용

$$ G^{2^{n-1}}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}\phi_n}\ket 1 $$

$\phi_n$에 대해 측정된 이전 값을 사용하여 추가 이진 지점을 회전할 수 있습니다.

$$ RZ(-2\pi \times 0.0\phi_n)G^{n-1}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}}\ket 1 $$

이 프로세스는 $0.\phi_0\phi_1\phi_2...\phi_{n}$단계를 얻기 위해 비트 정밀도 n에 대해 반복적으로 적용됩니다. 값은 현재 런타임에 정수만 조작할 수 있으므로 = \phi_0\phi_1\phi_2...\phi_{n}$$x 이진 값으로 저장됩니다.

읽기가 어느 벡터도 알려주지 않으며 둘 사이의 내부 제품만 알려주기 때문에 큐비트와 ancilla 큐비트의 상태는 target 프로세스 전체 에서 동일한 상태로 유지됩니다 .

Program.qs 파일에 다음 작업을 추가합니다.

operation IterativePhaseEstimation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double, Measurements : Int) : Int{
    use ControlReg = Qubit();
    mutable MeasureControlReg = [Zero, size = Measurements];
    mutable bitValue = 0;

    //Apply to initialise state, this is defined by the angles theta_1 and theta_2
    StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);
    for index in 0 .. Measurements - 1{
        H(ControlReg);

        //Don't apply rotation on first set of oracles
        if index > 0 {

            //Loop through previous results
            for index2 in 0 .. index - 1{
                if MeasureControlReg[Measurements - 1 - index2] == One{
                    let angle = -IntAsDouble(2^(index2))*PI()/(2.0^IntAsDouble(index));

                    //Rotate control qubit dependent on previous measurements and number of measurements
                    R(PauliZ, angle, ControlReg);
                }
            }
        }
        let powerIndex = (1 <<< (Measurements - 1 - index));

        //Apply a number of oracles equal to 2^index, where index is the number or measurements left
        for _ in 1 .. powerIndex{
                Controlled GOracle([ControlReg],(TargetReg, AncilReg, theta_1, theta_2));
            }
        H(ControlReg);

        //Make a measurement mid circuit
        set MeasureControlReg w/= (Measurements - 1 - index) <- MResetZ(ControlReg);
        if MeasureControlReg[Measurements - 1 - index] == One{

            //Assign bitValue based on previous measurement
            set bitValue += 2^(index);

        }
    }
    return bitValue;
}

내부 제품 계산

마지막으로 측정된 값에서 내부 제품을 계산합니다.

$$\braket {v|c} = -cos(2\pi x / 2^n)$$

where $x = \phi_0\phi_1\phi_2...\phi_{n}$. 코사인 함수 내의 분모는 원래 값 $\phi$에 맞게 이진 지점을 이동하는 것입니다.

참고

-1 또는 1이 아닌 내부 제품의 경우 솔루션은 $2^{n-1}$의 값 차이와 쌍을 이룬다. 예를 들어 n=3 측정의 경우 측정된 비트 값 2의 쌍 솔루션도 6입니다. 이러한 값 중 하나가 짝수 함수 코사인에 변수로 입력할 때 내부 제품의 동일한 값을 생성합니다(이 예제에서는 내부 곱이 0이 됩니다).

불연속 비트 정밀도 간의 내부 제품 솔루션의 경우 내부 제품이 불연속 비트 값 사이에 있는 위치에 따라 결과 분포가 생성됩니다.

Program.qs 파일에 다음 작업을 추가합니다.

function CalculateInnerProduct(Results : Int, theta_1 : Double, theta_2 : Double, Measurements : Int): Unit{
    let DoubleVal = PI() * IntAsDouble(Results) / IntAsDouble(2 ^ (Measurements-1));

    //Convert to the final inner product
    let InnerProductValue = -Cos(DoubleVal);
    Message("The Bit Value measured is:");
    Message($"{Results}");
    Message("The Inner Product is:");
    Message($"{InnerProductValue}");
    Message("The True Inner Product is:");
    Message($"{Cos(theta_1/2.0)*Cos(theta_2/2.0)+Sin(theta_1/2.0)*Sin(theta_2/2.0)}");
}

프로그램 실행

이제 프로그램을 테스트할 수 있습니다. 먼저 로컬에서 시뮬레이션 작업을 사용하여 프로그램을 실행한 다음, Azure Quantum에 연결하고 하드웨어 target에 대해 실행합니다.

반복 단계 추정 시뮬레이션

Q# 프로그램에는 @EntryPoint() 프로그램 실행을 시작할 위치를 컴파일러에 알려야 합니다. Programs.qs에 다음 코드를 추가하여 작업을 사용하여 프로그램을 SimulateInnerProduct() 시작합니다. 이 버전의 내부 제품 작업은 출력이 터미널에 표시되는 doubles 조작을 포함하여 추가 정보를 출력합니다.

@EntryPoint()

//Operation for calculating the inner product on local simulators
operation SimulateInnerProduct() : Unit{

    //This operation will output additional classical calculations
    let (Results, theta_1, theta_2, Measurements) = InnerProduct();
    CalculateInnerProduct(Results, theta_1, theta_2, Measurements);
}

operation InnerProduct() : (Int, Double, Double, Int){

    //Specify the angles for inner product
    let theta_1 = 0.0;
    let theta_2 = 0.0;
    let Measurements = 3;

    //Create target register
    use TargetReg = Qubit();

    //Create ancilla register
    use AncilReg = Qubit();

    //This runs iterative phase estimation
    let Results = IterativePhaseEstimation(TargetReg, AncilReg, theta_1, theta_2, Measurements);
    Reset(TargetReg);
    Reset(AncilReg);
    return (Results, theta_1, theta_2, Measurements);
}

프로그램을 실행하려면 VS Code에서 터미널 창을 열고 를 실행합니다.

    dotnet run

Azure Quantum에서 실행 target

하드웨어target에 대해 를 실행하려면 작업을 다음 HardwareInnerProduct() 작업으로 바꿉 SimulateInnerProduct() 다.

//Operation for calculating the inner product on hardware or emulators
operation HardwareInnerProduct() : Int{
    let (Results,_,_,_) = InnerProduct();
    return Results;
}

다음으로, Azure Quantum 작업 영역에 연결하고 기본 리소스를 설정합니다.

az login

참고

az quantum workspace list를 실행하여 로그인한 후 터미널 창에 Azure 구독 ID, 리소스 그룹 및 작업 영역 이름을 나열할 수 있습니다. 또는 Azure Quantum 작업 영역의 개요 페이지에서 Azure Portal 찾을 수 있습니다.

az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>

다음 매개 변수를 사용하여 작업을 제출합니다.

az quantum job submit \
    --target-id quantinuum.sim.h1-1e \
    --target-capability AdaptiveExecution \
    --shots 50 \
    --job-name IterativePhaseEstimation

참고

지정된 target 에는 를 target 지원하는 Basic Measurement Feedback실행 프로필이 필요합니다.

중요

eHQC가 크게 증가할 수 있으므로 Azure targets 에서 실행할 때 3을 초과하여 값을 Measurements 늘리지 않는 것이 좋습니다.

를 사용하여 작업의 상태 볼 수 있습니다.

az quantum job output \
    -o table \
    --job-id [job-id]

[job-id]를 표시된 작업 ID로 바꿉니다. 결과는 대다수 모집단이 있는 상태의 솔루션을 보여줍니다. 정수 결과의 최종 내부 제품은 $\braket {v|c} = -cos(2\pi x / 2^n)$로 계산할 수 있습니다. 여기서 n은 작업에 지정된 측정값의 수입니다.

참고

솔루션 상태가 하나만 있는 입력 매개 변수(내부 제품 -1 또는 1)를 선택하는 것은 적은 수의 샷을 사용할 때 가시성에 적합합니다.

다음 단계

분산 하이브리드 컴퓨팅

통합 하이브리드 컴퓨팅

targets 지원됨

Quantinuum

시작

통합 하이브리드 작업 제출

나Q#

Python + Q#

Azure CLI

세션 내에서 통합 하이브리드 작업 제출

통합 하이브리드 작업의 비용 예측

통합 하이브리드 샘플

사전 요구 사항

VS Code 프로젝트 만들기

VS Code 프로젝트 만들기

3개의 큐비트에서 반복 위상 추정을 사용하여 2차원 내부 제품 계산

VS Code 프로젝트 만들기

인코딩 벡터

더 오라클

반복

내부 제품 계산

프로그램 실행

반복 단계 추정 시뮬레이션

Azure Quantum에서 실행 target

다음 단계

피드백

피드백

추가 리소스