Q# 프로그램을 실행하는 여러 방법

가장 Quantum Development Kit큰 장점 중 하나는 플랫폼 및 개발 환경에서의 유연성입니다. 그러나 이러한 유연성은 Q#을 새로 사용하는 사용자가 설치 가이드에 나와 있는 다양한 옵션을 보고 혼란을 느낄 수도 있음을 의미합니다. 이 페이지에서는 Q# 프로그램이 실행될 때 어떤 일들이 일어나는지 설명하고 사용자가 프로그램을 실행할 수 있는 여러 방법을 비교합니다.

가장 큰 특징은 Q#은 다음과 같이 실행할 수 있다는 것입니다.

• Q#이 사용되는 유일한 언어이고 프로그램이 직접 호출되는 독립 실행형 애플리케이션으로 실행. 이 카테고리에 해당하는 방법에는 두 가지가 있습니다.
  • 명령줄 인터페이스
  • Q# Jupyter Notebook
• Python 또는 .NET 언어로 작성된(예: C# 또는 F#) 추가 호스트 프로그램으로 실행. 호스트 프로그램은 프로그램을 호출하고 반환된 값을 처리합니다.

이러한 프로세스와 각각의 차이점에 대해 더 잘 이해하기 위해 Q# 프로그램을 살펴보고 이 프로그램을 실행하는 여러 방법을 비교해 보겠습니다.

기본적인 Q# 프로그램

기본적인 양자 프로그램은 큐비트를 동일한 중첩 상태 $\ket{0}$ 및 $\ket{1}$로 준비하고 측정한 다음, 결과를 반환하는 작업으로 구성될 수 있습니다. 그 결과로, 이 두 상태 중 하나가 동일한 확률로 무작위로 반환됩니다. 양자 난수 생성기 빠른 시작에서도 이 프로세스를 사용하고 있습니다.

Q#에서 난수 생성은 다음 코드로 수행됩니다.

        use q = Qubit();     // allocates qubit for use (automatically in |0>)
        H(q);                // puts qubit in superposition of |0> and |1>
        return MResetZ(q);   // measures qubit, returns result (and resets it to |0> before deallocation)

그러나 Q#은 이 코드만을 단독으로 실행할 수 없습니다. 실행하려면 연산의 본문을 구성해야 합니다. 이렇게 구성한 본문은 직접적으로 또는 다른 연산에 의해 간접적으로 호출되었을 때 실행됩니다. 따라서 다음과 같은 형식으로 연산을 작성할 수 있습니다.

    operation MeasureSuperposition() : Result {
        use q = Qubit();     // allocates qubit for use (automatically in |0>)
        H(q);                // puts qubit in superposition of |0> and |1>
        return MResetZ(q);   // measures qubit, returns result (and resets it to |0> before deallocation)
    }

위에서는 입력을 받지 않고 Result 형식의 값을 반환하는 연산 MeasureSuperposition을 정의했습니다.

Q#에서는 연산을 수행하는 것 외에도 결정적 계산을 함수로 캡슐화할 수 있습니다. 큐비트에 대해 작용하는 계산은 함수가 아닌 연산으로 캡슐화해야 함을 암시하는 결정적 보장 외에는 연산과 함수 사이에 별다른 차이가 없습니다. 연산과 함수를 통칭하여 ‘호출 가능 항목’이라고 합니다.

Q# 파일에 정의된 호출 가능 항목

호출 가능 항목은 Q#이 호출하여 실행하는 항목입니다. 그러나 완전한 *.qsQ# 파일을 구성하려면 몇 가지가 더 필요합니다.

모든 Q# 형식과 호출 가능 항목(사용자가 정의한 건과 언어에 내장되어 있는 것)은 ‘네임스페이스’ 내에서 정의됩니다. 네임스페이스는 각 항목에 전체 이름을 제공하며, 이 전체 이름은 참조될 수 있습니다.

예를 들어, H 및 MResetZ 연산은 (Q# 표준 라이브러리의 일부인) Microsoft.Quantum.Instrinsic 및 Microsoft.Quantum.Measurement 네임스페이스에서 찾아볼 수 있습니다. 따라서 항상 전체 이름인 Microsoft.Quantum.Intrinsic.H(<qubit>)와 Microsoft.Quantum.Measurement.MResetZ(<qubit>)로 호출할 수 있는데, 항상 이렇게 하려면 코드가 매우 복잡해질 것입니다.

그 대신 open 문을 사용하면 위의 연산 본문에서 한 것처럼 보다 간결한 방식으로 호출 가능 항목을 참조할 수 있습니다. 따라서 연산을 포함하는 전체 Q# 파일은 사용자 자체 네임스페이스의 정의, 연산에서 사용하는 호출 가능 항목에 대한 네임스페이스 열기, 그리고 연산으로 이루어집니다.

namespace Superposition {
    open Microsoft.Quantum.Intrinsic;     // for the H operation
    open Microsoft.Quantum.Measurement;   // for MResetZ

    operation MeasureSuperposition() : Result {
        use q = Qubit();     // allocates qubit for use (automatically in |0>)
        H(q);                // puts qubit in superposition of |0> and |1>
        return MResetZ(q);   // measures qubit, returns result (and resets it to |0> before deallocation)
    }
}

참고

네임스페이스를 연 후에는 ‘별칭을 지정’할 수 있습니다. 두 네임스페이스에 있는 호출 가능 항목/형식 이름이 충돌하는 경우 별칭을 지정하는 것이 유용할 수 있습니다. 예를 들어, 위에서 대신 open Microsoft.Quantum.Instrinsic as NamespaceWithH;를 사용하고 NamespaceWithH.H(<qubit>)를 통해 H를 호출할 수 있습니다.

참고

한 가지 예외는 Microsoft.Quantum.Core 네임스페이스로, 이 네임스페이스는 항상 자동으로 열립니다. 따라서 Length와 같은 호출 가능 항목은 항상 직접적으로 사용할 수 있습니다.

컴퓨터에서 target 실행

이제 Q# 프로그램의 일반적인 실행 모델이 명확해졌습니다.

실행할 호출 가능 항목은 동일한 네임스페이스에 정의된 다른 호출 가능 항목 및 형식에 액세스할 수 있습니다. 이에 더해 모든 Q# 라이브러리에 있는 호출 가능 항목 및 형식에도 액세스할 수 있는데, 그러기 위해서는 해당 호출 가능 항목 및 형식의 전체 이름을 사용하거나 위에서 설명한 open 문을 사용해야 합니다.

그런 다음 호출 가능한 자체는 컴퓨터에서 target실행됩니다. 이러한 target 컴퓨터는 실제 양자 하드웨어 또는 QDK의 일부로 사용할 수 있는 여러 시뮬레이터일 수 있습니다. 여기서 가장 유용한 target 컴퓨터는 노이즈가 없는 양자 컴퓨터에서 실행되는 것처럼 프로그램의 동작을 계산하는 전체 상태 시뮬레이터QuantumSimulator 의 instance.

지금까지 특정 Q# 호출 가능 항목을 실행하면 어떤 일이 일어나는지 살펴보았습니다. Q#이 독립 실행형 애플리케이션으로 사용되든 호스트 프로그램과 함께 사용되든 관계없이 일반적인 프로세스는 비슷합니다. 이것이 바로 QDK의 유연성입니다. 따라서 를 Quantum Development Kit 호출하는 방법의 차이는 해당 호출 가능 항목이 Q# 호출되는 방법과 결과가 반환되는 방식에서 자신을 드러냅니다. 구체적으로 살펴보면 다음과 같은 차이가 있습니다.

• 어느 Q# 호출 가능 항목을 실행할지 나타내는 방식
• 잠재적인 호출 가능 항목의 인수가 제공되는 방식
• target 실행할 컴퓨터 지정
• 결과가 반환되는 방식

다음 섹션에서는 명령 프롬프트에서 Q# 독립 실행형 애플리케이션으로 이를 수행하는 방법에 대해 알아봅니다. 이어서 Python 및 C# 호스트 프로그램을 사용해 봅니다. Q# Jupyter Notebook의 독립 실행형 애플리케이션을 마지막으로 살펴봅니다. 처음 3가지 경우와 달리 이 방법의 기본 기능은 로컬 Q# 파일을 사용하지 않기 때문입니다.

참고

이 예에서는 설명되지 않았지만, 여러 실행 방법의 한 가지 공통점은 Q# 프로그램 내에서(예를 들어 Message 또는 DumpMachine에 의해) 출력되는 메시지는 항상 해당 콘솔에 출력된다는 것입니다.

명령 프롬프트에서 Q# 실행

Q# 프로그램의 작성을 시작하는 가장 쉬운 방법 중 하나는 개별 파일에 대해 신경 쓰지 않고 다른 언어를 사용하는 것입니다. Visual Studio Code 또는 Visual Studio를 QDK 확장과 함께 사용하면 하나의 Q# 파일에서만 Q# 호출 가능 항목을 실행하는 원활한 워크플로가 지원됩니다.

이를 위해 궁극적으로 명령 프롬프트에 입력하여

dotnet run

프로그램을 실행합니다. 가장 단순한 워크플로는 터미널의 디렉터리 위치가 Q# 파일과 동일한 경우입니다. VS Code의 통합 터미널을 사용하여 Q# 파일 편집 작업과 함께 쉽게 처리할 수 있습니다. dotnet run 명령은 여러 옵션을 받으므로 --project <PATH>에 Q# 파일의 위치를 지정하면 프로그램을 다른 위치에서 실행할 수도 있습니다.

Q# 파일에 진입점 추가

대부분의 Q# 파일에는 둘 이상의 호출 가능 항목이 있으므로 dotnet run 명령을 제공할 때 컴파일러에게 ‘어느’ 호출 가능 항목을 실행해야 하는지 알려 주어야 합니다. 이러한 지정은 Q# 파일 자체를 간단히 변경하여 수행됩니다. 호출 가능 항목 바로 앞에 @EntryPoint()가 있는 줄을 추가해야 합니다.

따라서 위의 파일은 다음과 같이 됩니다.

namespace Superposition {
    open Microsoft.Quantum.Intrinsic;     // for the H operation
    open Microsoft.Quantum.Measurement;   // for MResetZ

    @EntryPoint()
    operation MeasureSuperposition() : Result {
        use q = Qubit();     // allocates qubit for use (automatically in |0>)
        H(q);                // puts qubit in superposition of |0> and |1>
        return MResetZ(q);   // measures qubit, returns result (and resets it to |0> before deallocation)
    }
}

명령 프롬프트에서 dotnet run을 호출하면 MeasureSuperposition이 실행되고 반환 값이 터미널에 직접 출력됩니다. 즉, One 또는 Zero가 출력되는 것을 볼 수 있습니다.

그 아래에 더 많은 호출 가능 항목이 정의되어 있더라도 MeasureSuperposition만 실행됩니다. 호출 가능 항목이 선언 앞에 문서 주석을 포함하더라도 문제가 없습니다. 그 위에 @EntryPoint() 특성을 지정하면 됩니다.

호출 가능 항목의 인수

지금까지 이 문서에서는 입력을 받지 않는 연산만 고려했습니다. 이번에는 여러 개의 큐비트에 대해 비슷한 연산을 수행하려는 경우를 살펴보겠습니다. 이때 큐비트의 개수는 인수로 제공됩니다. 이러한 연산은 다음과 같이 작성할 수 있습니다.

namespace MultiSuperposition {
    open Microsoft.Quantum.Intrinsic;     // for the H operation
    open Microsoft.Quantum.Measurement;   // for MResetZ
    open Microsoft.Quantum.Canon;         // for ApplyToEach
    open Microsoft.Quantum.Arrays;        // for ForEach
    
    @EntryPoint()
    operation MeasureSuperpositionArray(n : Int) : Result[] {
        use qubits = Qubit[n];               // allocate a register of n qubits in |0> 
        ApplyToEach(H, qubits);              // apply H to each qubit in the register
        return ForEach(MResetZ, qubits);     // perform MResetZ on each qubit, returns the resulting array
    }
}

여기서 반환 값은 측정 결과로 구성된 배열입니다. ApplyToEach 및 ForEach는 Microsoft.Quantum.Canon 및 Microsoft.Quantum.Arrays 네임스페이스에 있으며 각각 다른 open 문이 필요합니다.

@EntryPoint() 특성이 이 새 연산 앞쪽에 가도록 이동하고(하나의 파일에는 이런 줄이 하나만 있을 수 있습니다) dotnet run을 사용하여 실행하려고 시도하면 어떤 명령줄 옵션이 추가로 필요하며 어떻게 표현해야 하는지를 보여 주는 오류 메시지가 표시됩니다.

명령줄의 일반적인 형식은 원래 dotnet run [options]이며, 여기에 호출 가능 형식의 인수가 지정됩니다. 여기서는 인수 n이 누락되어 있으므로 -n <n> 옵션을 제공해야 한다는 사실을 알 수 있습니다. n=4 큐비트에 대해 MeasureSuperpositionArray를 실행하려면 다음을 실행해야 합니다.

dotnet run -n 4

그러면 다음과 같은 출력이 생성됩니다.

[Zero,One,One,One]

이는 인수가 여러 개인 경우에도 적용됩니다.

참고

camelCase로 정의된 인수 이름은 Q# 입력으로 사용되도록 컴파일러가 변경합니다. 예를 들어, 위에서 n 대신 numQubits라는 이름을 사용하기로 했다면 명령줄에서 이 입력은 -n 4 대신 --num-qubits 4로 제공됩니다.

오류 메시지는 컴퓨터를 변경하는 target 방법을 포함하여 사용할 수 있는 다른 옵션도 제공합니다.

다른 target 컴퓨터

지금까지 작업의 출력이 실제 큐비트에 대한 작업의 예상 결과이므로 명령줄의 기본 target 컴퓨터가 전체 상태 양자 시뮬레이터인 QuantumSimulator임을 알 수 있습니다. 그러나 호출 가능 개체는 옵션 --simulator (또는 약식-s)을 사용하여 특정 target 컴퓨터에서 실행하도록 지시할 수 있습니다.

명령줄 실행 요약

비 Q#dotnet run 옵션

위에서 --project 옵션에 대해 설명할 때 간략히 언급했듯이 dotnet run 명령은 Q# 호출 가능 항목의 인수와 관련 없는 옵션도 받습니다. 두 가지 종류의 옵션을 제공하려면 먼저 dotnet 옵션을 제공한 후에 구분 기호 --를 입력하고 Q# 옵션을 제공해야 합니다. 예를 들어, 경로를 지정하고 연산의 큐비트 개수를 지정하려면 dotnet run --project <PATH> -- -n <n>을 실행합니다.

호스트 프로그램에서 Q# 실행

Q# 파일을 사용할 경우 명령 프롬프트에서 직접 연산 또는 함수를 호출하는 대신 다른 클래식 언어로 된 호스트 프로그램을 사용합니다. 구체적으로는 Python 또는 .NET 언어(예: C# 또는 F#)로 된 호스트 프로그램을 사용하여 이 호출을 수행할 수 있습니다(여기서는 C#만 살펴보겠습니다). 상호 운용성을 지원하려면 몇 가지 설정이 더 필요합니다. 자세한 내용은 설치 가이드를 참조하세요.

간단히 말하면, 이제 Q# 파일과 동일한 위치에 호스트 프로그램 파일(예: *.py 또는 *.cs)이 있습니다. 이제 실행되는 호스트 프로그램입니다. 실행되는 동안 Q# 파일에서 특정 Q# 작업 및 함수를 호출할 수 있습니다. 상호 운용성의 핵심은 호스트 프로그램이 Q# 파일의 콘텐츠에 액세스하여 호출할 수 있도록 해 주는 Q# 컴파일러입니다.

호스트 프로그램을 사용하는 것의 장점 중 하나는 Q# 프로그램이 반환하는 클래식 데이터를 호스트 언어로 처리할 수 있다는 것입니다. (Q# 내부에서 수행할 수 없는) 고급 데이터 처리를 수행한 후에 결과를 바탕으로 추가로 Q# 동작을 호출할 수도 있고, Q# 결과를 플로팅하는 것처럼 간단한 작업을 수행할 수도 있습니다.

일반적인 구성은 아래에 나와 있으며 Python 및 C#의 구체적인 구현에 대한 설명은 아래에 나와 있습니다. .NET 상호 운용성 샘플에서 F# 호스트 프로그램을 사용하는 샘플을 확인할 수 있습니다.

참고

Q#에 사용되는 @EntryPoint() 특성은 호스트 프로그램에서 사용할 수 없습니다. 호스트가 호출하는 Q# 파일에 이 특성이 있으면 오류가 발생합니다.

여러 호스트 프로그램을 사용하려는 경우 *.qsQ# 파일을 변경할 필요가 없습니다. 다음 호스트 프로그램 구현에는 모두 하나의 Q# 파일을 사용할 수 있습니다.

namespace Superposition {
    open Microsoft.Quantum.Intrinsic;     // for H
    open Microsoft.Quantum.Measurement;   // for MResetZ
    open Microsoft.Quantum.Canon;         // for ApplyToEach
    open Microsoft.Quantum.Arrays;        // for ForEach

    operation MeasureSuperposition() : Result {
        use q = Qubit();     // allocates qubit for use (automatically in |0>)
        H(q);                // puts qubit in superposition of |0> and |1>
        return MResetZ(q);   // measures qubit, returns result (and resets it to |0> before deallocation)
    }

    operation MeasureSuperpositionArray(n : Int) : Result[] {
        use qubits = Qubit[n];
        ApplyToEach(H, qubits); 
        return ForEach(MResetZ, qubits);    
    }
}

원하는 호스트 언어에 해당하는 탭을 선택하세요.

Python

Python 호스트 프로그램은 다음과 같이 구성됩니다.

1. Q# 상호 운용성을 위해 모듈 로더를 등록하는 qsharp 모듈을 가져옵니다. 이 가져오기를 통해 Q# 네임스페이스가 Python 모듈로 나타나는데, 여기에서 Q# 호출 가능 항목을 “가져올” 수 있습니다. 이때 가져오는 항목은 Q# 호출 가능 항목 그 자체가 아니라 호출 가능 항목을 호출할 수 있는 Python 스텁입니다. 이 스텁은 Python 클래스의 개체처럼 동작합니다. 하나는 이러한 개체의 메서드를 사용하여 프로그램을 실행할 때 작업이 전송되는 컴퓨터를 지정 target 합니다.

2. 직접 호출할 Q# 호출 가능 항목을 가져옵니다(여기서는 MeasureSuperposition 및 MeasureSuperpositionArray).

   import qsharp
   from Superposition import MeasureSuperposition, MeasureSuperpositionArray
   

   qsharp 모듈을 가져온 후에는 Q# 라이브러리 네임스페이스에서 직접 호출 가능 항목을 가져올 수 있습니다.

3. 이제 일반 Python 코드와 함께 특정 target 머신에서 해당 호출 가능 개체를 실행하고 추가 사용을 위해 해당 반환 값을 변수에 할당할 수 있습니다.

   random_bit = MeasureSuperposition.simulate()
   print(random_bit)
   

진단

Q# 독립 실행형 Notebook과 마찬가지로 Python Notebook의 DumpMachine 및 DumpOperation 같은 진단을 사용하여 Q# 프로그램의 작동 방식을 알아보고 Q# 프로그램의 문제 및 버그를 진단할 수도 있습니다.

namespace DumpOperation {
    open Microsoft.Quantum.Diagnostics;

    operation DumpPlusState() : Unit {
        use q = Qubit();
        within {
            H(q);
        } apply {
            DumpMachine();
        }
    }
}

from  DumpOperation import DumpPlusState
print(DumpPlusState.simulate())

DumpMachine function 호출에서는 다음 출력이 생성됩니다.

# wave function for qubits with ids (least to most significant): 0
∣0❭:     0.707107 +  0.000000 i  ==     ***********          [ 0.500000 ]     --- [  0.00000 rad ]
∣1❭:     0.707107 +  0.000000 i  ==     ***********          [ 0.500000 ]     --- [  0.00000 rad ]

또한 Q# 패키지를 사용하면 이러한 진단을 캡처하고 Python 개체로 조작할 수 있습니다.

with qsharp.capture_diagnostics() as diagnostics:
    DumpPlusState.simulate()
print(diagnostics)

[{'diagnostic_kind': 'state-vector',
  'div_id': 'dump-machine-div-7d3eac24-85c5-4080-b123-4a76cacaf58f',
  'qubit_ids': [0],
  'n_qubits': 1,
  'amplitudes': [{'Real': 0.7071067811865476,
    'Imaginary': 0.0,
    'Magnitude': 0.7071067811865476,
    'Phase': 0.0},
   {'Real': 0.7071067811865476,
    'Imaginary': 0.0,
    'Magnitude': 0.7071067811865476,
    'Phase': 0.0}]}]

진단을 위해 원시 JSON으로 작업하는 것은 비생산적일 수 있으므로 capture_diagnostics 함수는 QuTiP 라이브러리를 사용하여 진단을 양자 개체로 변환하는 것도 지원합니다.

with qsharp.capture_diagnostics(as_qobj=True) as diagnostics:
    DumpPlusState.simulate()
diagnostics[0]

Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
Qobj data =
[[0.707]
 [0.707]]

및 에서 제공하는 Q# 진단 기능에 대한 자세한 내용은 테스트 및 디버깅을 참조하세요.Quantum Development Kit

target 컴퓨터 지정

특정 target 컴퓨터에서 실행 Q# 중인 작업은 가져온 작업 개체에서 Python 메서드를 직접 호출하여 수행됩니다. 따라서 실행에 target 대한 개체(예: 시뮬레이터)를 만들 필요가 없습니다. 대신, 다음 메서드 중 하나를 호출하여 가져온 Q# 연산을 실행합니다.

• .simulate(<args>)는 전체 상태 시뮬레이터를 사용하여 적합한 양자 컴퓨터에 연산을 시뮬레이션합니다. (.simulate()에 대한 API 참조).
• .simulate_sparse(<args>)는 스파스 시뮬레이터를 사용하여 적합한 양자 컴퓨터에 연산을 시뮬레이션합니다. (.simulate_sparse()에 대한 API 참조).
• .toffoli_simulate(<args>)는 Toffoli 시뮬레이터를 사용하여 제한된 양자 프로그램 클래스에 보다 효율적인 시뮬레이션 방법을 제공합니다 (.toffoli_simulate()에 대한 API 참조).
• .simulate_noise(<args>)는 노이즈 시뮬레이터를 사용하여 노이즈 영향으로 열린 양자 시스템에서 작업을 시뮬레이션합니다. qsharp.experimental.enable_noisy_simulation()을 호출하여 노이즈 시뮬레이터를 사용하도록 설정할 수 있습니다.

로컬 target 머신에 대한 자세한 내용은 Quantum 시뮬레이터를 참조하세요.

Q#의 호출 가능 항목에 인수 전달

Q# 호출 가능 항목의 인수는 키워드 인수 형식으로 제공해야 합니다(이때 키워드는 Q# 호출 가능 항목 정의의 인수 이름). 즉, MeasureSuperpositionArray.simulate(n=4)는 유효하지만 MeasureSuperpositionArray.simulate(4)는 오류를 throw합니다.

따라서 다음과 같은 Python 호스트 프로그램은

import qsharp
from Superposition import MeasureSuperposition, MeasureSuperpositionArray

single_qubit_result = MeasureSuperposition.simulate()
single_qubit_resources = MeasureSuperposition.estimate_resources()

multi_qubit_result = MeasureSuperpositionArray.simulate(n=4)
multi_qubit_resources = MeasureSuperpositionArray.estimate_resources(n=4)

print('Single qubit:\n' + str(single_qubit_result))
print(single_qubit_resources)

print('\nMultiple qubits:\n' + str(multi_qubit_result))
print(multi_qubit_resources)

다음과 같이 출력됩니다.

Single qubit:
1
{'CNOT': 0, 'QubitClifford': 1, 'R': 0, 'Measure': 1, 'T': 0, 'Depth': 0, 'Width': 1, 'BorrowedWidth': 0}

Multiple qubits:
[0, 1, 1, 1]
{'CNOT': 0, 'QubitClifford': 4, 'R': 0, 'Measure': 4, 'T': 0, 'Depth': 0, 'Width': 4, 'BorrowedWidth': 0}

비슷한 방식으로 배열을 전달하는 것도 가능합니다. 가역 논리 합성 샘플에서 그 예를 볼 수 있습니다.

큐비트를 클래식 코드에서 인수로 전달하는 것은 불가능합니다. Qubit와 같은 Q# 유형과 관련된 모든 논리는 Q# 코드에 있어야 합니다. Python 코드에서 큐비트 수를 지정하려면 Q# 연산에 nQubits : Int 매개 변수와 같은 것을 사용할 수 있습니다. Python 코드는 이것을 정수로 전달할 수 있으며 Q# 코드는 적절한 큐비트 수의 배열을 할당할 수 있습니다.

Pauli 및 Result 유형의 경우, 실제로 Python 열거형이 정의되어 있으므로 원하는 경우 해당 값을 직접 전달할 수 있습니다. qsharp.Pauli 및 qsharp.Result를 참조하세요.

다른 프로젝트 또는 패키지의 Q# 코드 사용

기본적으로 import qsharp 명령은 모든 .qs 파일을 현재 폴더에 로드하여 Python 스크립트 내에서 Q# 연산 및 함수를 사용할 수 있도록 합니다.

다른 폴더에서 Q# 코드를 로드하려면 qsharp.projects API를 사용하여 Q# 프로젝트(Microsoft.Quantum.Sdk를 참조하는 프로젝트)에 대해 .csproj 파일에 대한 참조를 추가할 수 있습니다. 이 명령은 .csproj 및 하위 폴더를 포함하는 폴더에 있는 모든 .qs 파일을 컴파일합니다. 또한 PackageReference를 통해 참조된 모든 패키지 또는 .csproj 파일의 ProjectReference를 통해 참조된 Q# 프로젝트를 회귀적으로 로드합니다.

일례로 다음 Python 코드는 현재 폴더에 대해 상대적인 경로를 참조하여 외부 프로젝트를 가져오고 Q# 연산 중 하나를 호출합니다.

import qsharp
qsharp.projects.add("../qrng/Qrng.csproj")
from Qrng import SampleQuantumRandomNumberGenerator
print(f"Qrng result: {SampleQuantumRandomNumberGenerator.simulate()}")

이 코드는 다음과 같이 출력됩니다.

Adding reference to project: ../qrng/Qrng.csproj
Qrng result: 0

Q# 코드를 포함하는 외부 패키지를 로드하려면 qsharp.packages API를 사용하세요.

현재 폴더의 Q# 코드가 외부 프로젝트 또는 패키지에 종속적인 경우 import qsharp를 실행하면 종속성이 아직 로드되지 않았으므로 오류가 표시될 수 있습니다. import qsharp 명령 중에 필요한 외부 패키지 또는 Q# 프로젝트를 로드하려면 Python 스크립트의 폴더가 Microsoft.Quantum.Sdk를 참조하는 .csproj 파일을 포함하고 있는지 확인합니다. 해당 .csproj에서 <PropertyGroup>에 속성 <IQSharpLoadAutomatically>true</IQSharpLoadAutomatically>를 추가합니다. 이렇게 변경하면 IQ#이 import qsharp 명령 중에 해당 .csproj에 있는 모든 ProjectReference 또는 PackageReference 항목을 회귀적으로 로드합니다.

예를 들어, 다음은 IQ#이 자동으로 Microsoft.Quantum.Chemistry 패키지를 로드하도록 만드는 간단한 .csproj 파일입니다.

<Project Sdk="Microsoft.Quantum.Sdk/0.17.2105143879">
    <PropertyGroup>
        <OutputType>Library</OutputType>
        <TargetFramework>netstandard2.1</TargetFramework>
        <IQSharpLoadAutomatically>true</IQSharpLoadAutomatically>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Quantum.Chemistry" Version="0.17.2105143879" />
    </ItemGroup>
</Project>

참고

현재 이 사용자 지정 <IQSharpLoadAutomatically> 속성은 Python 호스트에 필요하지만, 다음에는 Python 스크립트와 동일한 폴더에 있는 .csproj 파일의 기본 동작이 될 수 있습니다.

참고

현재 .csproj의 <QsharpCompile> 설정은 Python 호스트에 의해 무시되며, .csproj의 폴더에 있는 모든 .qs 파일과 하위 폴더가 로드되어 컴파일됩니다. 추후 .csproj 설정에 대한 지원이 개선될 예정입니다(자세한 정보는 iqsharp#277 참조).

C#

C# 호스트 프로그램에는 여러 구성 요소가 있습니다. 시뮬레이터와 같이 C#을 기반으로 빌드된 일부 QDK 구성 요소와 긴밀하게 작동합니다.

Q# 컴파일러는 Q# 파일에서 Q# 네임스페이스로부터 동일한 이름을 갖는 C# 네임스페이스를 생성함으로써 작동합니다. 또한 여기에 정의된 각각의 Q# 호출 가능 항목 또는 형식에 대해 동일한 이름을 갖는 C# 클래스를 생성합니다.

첫째, 호스트 프로그램에 사용되는 모든 클래스는 using 문과 함께 사용할 수 있으며, 이는 Q# 파일의 open 문과 거의 유사합니다.

using System;
using System.Threading.Tasks;
using Microsoft.Quantum.Simulation.Simulators;    // contains the target machines (for example, QuantumSimulator, ResourcesEstimator)
using Superposition;                              // make the Q# namespace available

다음으로, 몇 가지 다른 비트 및 부분으로 C# 네임스페이스를 선언해야 합니다. 전체 코드 블록은 다음을 참조하세요. 그런 다음, Q# 호출 가능 개체에 대한 인수를 계산하는 등, 클래식 프로그래밍 작업을 수행합니다. 후자는 필요하지 않지만, .NET 상호 운용성 샘플에서 이러한 예를 살펴볼 수 있습니다.

대상 머신

로 Q#돌아가서 작업을 실행할 컴퓨터의 target instance 만듭니다.

            using var sim = new QuantumSimulator();

다른 target 머신을 사용하는 것은 다른 컴퓨터를 인스턴스화하는 것만큼 간단하지만, 그렇게 하고 반환을 처리하는 방식은 약간 다를 수 있습니다. 간결하게, 이 섹션은 지금은 에 QuantumSimulator 충실합니다.

작업에서 Q# 생성된 각 C# 클래스에는 메서드가 Run 있으며, 첫 번째 인수는 컴퓨터 instance 합니다target. 따라서 QuantumSimulator에서 MeasureSuperposition을 실행하려면 MeasureSuperposition.Run(sim)을 사용합니다. 반환되는 결과는 C# 변수에 할당할 수 있습니다.

            var singleQubitResult = await MeasureSuperposition.Run(sim);

참고

Run 메서드는 실제 양자 하드웨어와 마찬가지로 비동기식으로 실행되므로, await 키워드는 작업이 완료될 때까지 추가 처리를 차단합니다.

Q# 호출 가능 항목에 반환 값이 없으면(예: 반환 형식이 Unit인 경우) 실행은 반환 값을 변수에 할당하지 않고 동일한 방식으로 수행할 수 있습니다. 이 경우 코드가 다음과 같은 줄이 됩니다.

await <callable>.Run(<simulator>);

Q#의 호출 가능 항목에 인수 전달

호출 가능 개체에 대한 Q# 모든 인수는 컴퓨터 다음에 target 추가 인수로 전달됩니다. 따라서 n=4 큐비트에 대한 MeasureSuperpositionArray의 결과는 다음을 통해 가져올 수 있습니다.

            var multiQubitResult = await MeasureSuperpositionArray.Run(sim, 4);

고정 길이 배열을 Q# 코드와 주고받는 데 사용되는 데이터 유형은 QArray입니다. Q# 프로그램에 이 데이터 유형의 인스턴스를 전달하기 전에 어레이에서 이를 명시적으로 만들어야 합니다.

            var qarray = new QArray<long>(arrayCreated);

문자열을 전달하는 것도 비슷한 방식으로 작동합니다. string[]을 Q# 연산에 전달하려면 여기에서 QArray<string> 개체를 생성할 수 있습니다.

큐비트를 C# 코드에 인수로 전달할 수 없습니다. Qubit와 같은 Q# 유형과 관련된 논리는 Q# 코드에 있어야 하며, C# 내에서는 직접 사용할 수 없습니다. 따라서 C# 진입점 역할을 위한 새 Q# 연산을 만들고자 할 수 있습니다. 그런 다음, 이 새 연산을 큐비트를 할당하고 전달해야 합니다.

Q# 유형 Result는 C# 클래스 Microsoft.Quantum.Simulation.Core.Result로 표시되며, 특히 연산의 반환을 비교할 수 있는 상수 Result.Zero 및 Result.One이 있습니다. 연산에 의해 반환된 튜플의 압축을 풀려면 C# ValueTuple 클래스에 의해 노출된 Item1, Item2 필드를 사용하여 수행할 수 있습니다. 결과를 다시 기존 .NET 배열로 바꾸려면 ToArray()를 호출하여 완료합니다. 이러한 기능을 사용하는 방법에 대한 예로 다음 C# 프로그램을 참조하세요.

using Microsoft.Quantum.Simulation.Core;
 
            var task  = QuantumOperation.Run(qsim);
            var data = task.Result.Select((result) > result == Result.One);
  
            var energyEst = data.Item1;
            var measuredState = data.Item2.ToArray();

전체 C# 호스트 프로그램은 다음과 같습니다.

using System;
using System.Threading.Tasks;
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;
using Superposition;

namespace host
{
    static class Program
    {
        static async Task Main(string[] args)
        {
            using var sim = new QuantumSimulator();

            var singleQubitResult = await MeasureSuperposition.Run(sim);
            var multiQubitResult = await MeasureSuperpositionArray.Run(sim, 4);

            Console.WriteLine($"Single qubit result: {singleQubitResult}");
            Console.WriteLine($"Multiple qubit result: {multiQubitResult}");
        }
    }
}

C# 파일의 위치에서, 명령 프롬프트에 다음을 입력하여 호스트 프로그램을 실행할 수 있습니다.

dotnet run

이 경우 콘솔에 다음과 같은 출력이 표시됩니다.

Single qubit result: One
Multiple qubit result: [One,One,Zero,Zero]

참고

컴파일러는 네임스페이스와 상호 운용성을 가지므로 using Superposition; 문을 사용하지 않고 Q# 호출 가능 항목을 사용할 수 있도록 만들고 C# 네임스페이스의 이름을 갖게 만들 수도 있습니다. 즉, namespace host를 namespace Superposition으로 바꿉니다.

Q# Jupyter Notebook

Q# Jupyter Notebook은 IQ# 커널을 사용하는데, 이를 통해 Q# 호출 가능 항목을 명령, 메모 및 기타 내용과 함께 하나의 Notebook에서 정의, 컴파일 및 실행할 수 있습니다. 즉, *.qsQ# 파일의 콘텐츠를 가져오고 사용할 수는 있지만, 실행 모델에서는 필요하지 않습니다.

여기서는 위에서 정의한 Q# 연산을 실행하는 방법에 대해 자세히 설명합니다. 그러나 Jupyter Notebook 사용에 Q# 대한 보다 광범위한 소개는 설정 Quantum Development Kit에서 제공됩니다.

연산 정의

Q# Jupyter Notebook에서는 Q# 파일의 네임스페이스 내에 코드를 입력하는 것처럼 Q# 코드를 입력합니다.

따라서 Q# 표준 라이브러리에서 각각의 네임스페이스에 대해 open 문을 사용하여 호출 가능 항목에 액세스할 수 있습니다. 이러한 문을 사용하여 셀을 실행하면 작업 영역을 통해 해당 네임스페이스의 정의를 사용할 수 있습니다.

참고

Microsoft.Quantum.Intrinsic 및 Microsoft.Quantum.Canon(예: H 및 ApplyToEach)의 호출 가능 항목은 Q# Jupyter Notebook의 셀 내에서 정의된 연산에서 자동으로 사용할 수 있습니다. 단, 외부 Q# 소스 파일에서 가져온 코드의 경우는 그렇지 않습니다(이 프로세스는 Q# 및 Jupyter Notebook 소개에서 볼 수 있습니다).

마찬가지로, 연산을 정의하려면 Q# 코드를 작성하고 셀을 실행하기만 하면 됩니다.

출력에 이러한 연산이 나열되며, 이후에 셀에서 호출할 수 있습니다.

대상 머신

특정 target 머신에서 작업을 실행하는 기능은 IQ# 매직 명령을 통해 제공됩니다. 예를 들어, %simulate는 QuantumSimulator를 사용하고, %estimate를 ResourcesEstimator를 사용합니다.

Q#의 호출 가능 항목에 인수 전달

Q# 연산에 입력을 전달하려면 인수를 run 매직 명령에 key=value 쌍으로 전달할 수 있습니다. 따라서 4개의 큐비트를 사용하여 MeasureSuperpositionArray를 실행하려면 %simulate MeasureSuperpositionArray n=4를 실행할 수 있습니다.

이 패턴은 %estimate 및 기타 run 명령에서도 비슷하게 사용할 수 있습니다.

참고

실행 명령(예: %simulate 또는 %estimate)과 유사한 방식으로 호출 가능 항목을 전달할 수 없습니다.

다른 프로젝트 또는 패키지의 Q# 코드 사용

기본적으로 Q# Jupyter Notebook은 모든 .qs 파일을 현재 폴더에 로드하여 Notebook 내에서 Q# 연산 및 함수를 사용할 수 있도록 합니다. %who 매직 명령은 현재 사용 가능한 모든 Q# 연산 및 함수를 나열합니다.

다른 폴더에서 Q# 코드를 로드하려면 %project 매직 명령을 사용하여 Q# 프로젝트(Microsoft.Quantum.Sdk를 참조하는 프로젝트)에 대해 .csproj 파일에 대한 참조를 추가할 수 있습니다. 이 명령은 .csproj 및 하위 폴더를 포함하는 폴더에 있는 모든 .qs 파일을 컴파일합니다. 또한 PackageReference를 통해 참조된 모든 패키지 또는 .csproj 파일의 ProjectReference를 통해 참조된 Q# 프로젝트를 회귀적으로 로드합니다.

예를 들어, 다음 셀은 외부 프로젝트의 Q# 연산을 시뮬레이션합니다. 프로젝트 경로는 현재 폴더에 대해 상대적으로 참조됩니다.

Q# 코드를 포함하는 외부 패키지를 로드하려면 %package 매직 명령을 사용하세요. 패키지를 로드하면 패키지의 일부인 어셈블리에 포함된 모든 사용자 지정 매직 명령과 디스플레이 인코더도 사용할 수 있습니다.

Notebook 초기화 시점에 외부 패키지 또는 Q# 프로젝트를 로드하려면 Notebook 폴더에 Microsoft.Quantum.Sdk를 참조하는 .csproj 파일이 있어야 합니다. 해당 .csproj에서 <PropertyGroup>에 속성 <IQSharpLoadAutomatically>true</IQSharpLoadAutomatically>를 추가합니다. 이 속성은 IQ#이 Notebook 로드 시점에 해당 .csproj에 있는 모든 ProjectReference 또는 PackageReference 항목을 회귀적으로 로드하도록 지시합니다.

예를 들어, 다음은 IQ#이 자동으로 Microsoft.Quantum.Chemistry 패키지를 로드하도록 만드는 간단한 .csproj 파일입니다.

<Project Sdk="Microsoft.Quantum.Sdk/0.17.2105143879">
    <PropertyGroup>
        <OutputType>Library</OutputType>
        <TargetFramework>netstandard2.1</TargetFramework>
        <IQSharpLoadAutomatically>true</IQSharpLoadAutomatically>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Quantum.Chemistry" Version="0.17.2105143879" />
    </ItemGroup>
</Project>

참고

현재 이 사용자 지정 <IQSharpLoadAutomatically> 속성은 Q# Jupyter Notebook 호스트에 필요하지만, 다음에는 Notebook 파일과 동일한 폴더에 있는 .csproj 파일의 기본 동작이 될 수 있습니다.

참고

현재 .csproj의 <QsharpCompile> 설정은 Q# Jupyter Notebook 호스트에 의해 무시되며, .csproj의 폴더에 있는 모든 .qs 파일과 하위 폴더가 로드되어 컴파일됩니다. 추후 .csproj 설정에 대한 지원이 개선될 예정입니다(자세한 정보는 iqsharp#277 참조).