Общие сведения о языке квантового программирования Q#

Q# — это высокоуровневый язык программирования с открытым кодом, разработанный корпорацией Майкрософт для написания квантовых программ. Q# включается в комплект средств разработки Quantum (QDK). Дополнительные сведения см. в разделе "Настройка пакета средств разработки Quantum".

В качестве языка квантового программирования Q# соответствует следующим требованиям для языка, компилятора и среды выполнения:

• Не зависит от аппаратного обеспечения: Кубиты в квантовых алгоритмах не привязаны к определенному квантовому оборудованию или макету. Компилятор Q# и среда выполнения обрабатывают сопоставление от кубитов программы к физическим кубитам, что позволяет одному коду выполняться на разных квантовых процессорах.
• интеграция квантовых и классических вычислений:Q# позволяет интегрировать квантовые и классические вычисления, что является важным для универсальных квантовых вычислений.
• управление Кубитами:Q# предоставляет встроенные операции и функции для управления кубитами, включая создание состояний суперпозиции, запутание кубитов и выполнение квантовых измерений.
• уважать законы физики:Q# и квантовые алгоритмы должны соответствовать правилам квантовой физики. Например, вы не можете напрямую скопировать или получить доступ к состоянию кубита в Q#.

Дополнительные сведения о происхождении Q#см. в записи блога Почему нам нужно Q#?.

Q# Структура программы

Прежде чем приступить к написанию Q# программ, важно понимать их структуру и компоненты. Рассмотрим следующую Q# программу с именем Superposition, которая создает состояние суперпозиции:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

Программа //, согласно комментариям (Q#), сначала выделяет кубит, применяет операцию для помещения кубита в суперпозицию, измеряет состояние кубита, сбрасывает кубит и, наконец, возвращает результат.

Давайте разберём эту программу Q# на её составные части.

Пространства имен пользователей

Q# программы при желании могут начинаться с пространства имен, установленного пользователем, например:

namespace Superposition {
    // Your code goes here.
}

Пространства имен помогают организовывать схожую функциональность. Пространства имен являются необязательными в Q# программах, то есть можно написать программу без определения пространства имен.

Например, Superposition программа из примера также может быть написана без пространства имен следующим образом:

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Примечание.

Каждая Q# программа может иметь только одну namespace. Если пространство имен не указано, компилятор Q# использует имя файла в качестве пространства имен.

Точки входа

Каждая Q# программа должна иметь точку входа, которая является отправной точкой программы. По умолчанию, если она доступна, компилятор Q# начинает выполнение программы, начиная с операции Main(), которая может быть расположена в любом месте программы. При необходимости атрибут можно использовать @EntryPoint() для указания любой операции в программе в качестве точки выполнения.

Например, в программе Superposition операция MeasureOneQubit() является точкой входа программы, так как перед определением этой операции указан атрибут @EntryPoint().

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...
}

Однако программа также может быть написана без атрибута @EntryPoint() путем переименования операции MeasureOneQubit() на Main(), например:

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Типы

Типы важны для любого языка программирования, так как они определяют данные, с которыми может работать программа. Q# предоставляет встроенные типы, которые являются общими для большинства языков, включая Int, Double, Boolи String, а также типы, определяющие диапазоны, массивы и кортежи.

Q# также предоставляет типы, относящиеся к квантовым вычислениям. Например, тип Result представляет результат измерения кубита и может иметь два значения: Zero или One.

В программе Superposition операция MeasureOneQubit() возвращает тип Result, который соответствует возвращаемому типу операции M. Результат измерения хранится в новой переменной, определенной с помощью инструкции let :

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...
}

Другим примером квантового типа является тип Qubit, представляющий квантовый бит.

Q# также позволяет определять собственные пользовательские типы. Дополнительные сведения см. в разделе объявлений типов.

Выделение кубитов

В Q#вы выделяете кубиты с помощью ключевого слова use и типа Qubit. Кубиты всегда выделяются в $\ket{0}$ состоянии.

Например, Superposition программа определяет один кубит и сохраняет его в переменной q:

// Allocate a qubit.
use q = Qubit();

Вы также можете выделить несколько кубитов и получить доступ к каждому из них с помощью его индекса:

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Квантовые операции

После выделения кубита его можно передать для использования в операциях и функциях. Операции — это основные стандартные блоки программы Q#. Операция Q# — это квантовая подпрограмма или вызываемая подпрограмма, содержащая квантовые операции, которые изменяют состояние регистра кубита.

Чтобы определить Q# операцию, укажите имя операции, его входные данные и выходные данные. В программе Superposition операция MeasureOneQubit() не принимает параметров и возвращает тип Result.

operation MeasureOneQubit() : Result {
    ...
}

Ниже приведен базовый пример, который не принимает параметров и не ожидает возвращаемого значения. Значение Unit эквивалентно NULL в других языках.

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

Стандартная Q# библиотека также предоставляет операции, которые можно использовать в квантовых программах, таких как операция Hadamard, Hв программе Superposition . Учитывая кубит в Z-основе, H помещает кубит в равномерную суперпозицию, где он имеет 50% вероятность быть измеренным как Zero или One.

Измерение кубитов

Хотя существует множество типов квантовых измерений, Q# основное внимание уделяется проецивным измерениям на отдельных кубитах, также известных как измерения Паули.

В Q#операции Measure измеряется один или несколько кубитов в указанной базе Паули, которая может быть PauliX, PauliYили PauliZ. Measure возвращает тип Result, который может быть либо Zero, либо One.

Для реализации измерения в вычислительной базе $\lbrace\ket{0},\ket{1}\rbrace$ можно также использовать M операцию, которая измеряет кубит в основе Паули Z. Это делает M эквивалентным Measure([PauliZ], [qubit]).

Например, Superposition программа использует M операцию:

// Measure the qubit in the Z-basis.
let result = M(q);

Сброс кубитов

В Q#кубиты должны находиться в состоянии $\ket{0}$, когда они выпускаются, чтобы избежать ошибок в квантовом оборудовании. Вы можете сбросить кубит в состояние $\ket{0}$ с помощью операции Reset в конце программы. Неудача в сбросе кубита приводит к ошибке во время выполнения.

// Reset a qubit.
Reset(q);

Пространства имен стандартной библиотеки

В стандартной Q# библиотеке есть встроенные пространства имен, содержащие функции и операции, которые можно использовать в квантовых программах. Например, Std.Intrinsic пространство имен содержит часто используемые операции и функции, такие как M измерение результатов и Message отображение сообщений пользователей в любой точке программы.

Чтобы вызвать функцию или операцию, можно указать полное пространство имен или использовать import инструкцию, которая делает все функции и операции для этого пространства имен доступными и делает код более читаемым. В следующих примерах вызывается та же операция:

Std.Intrinsic.Message("Hello quantum world!");

// imports all functions and operations from the Std.Intrinsic namespace.
import Std.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Std.Intrinsic namespace.
import Std.Intrinsic.Message;
Message("Hello quantum world!");

Примечание.

Программа Superposition не имеет import инструкций или вызовов с полными пространствами имен. Это связано с тем, что среда разработки Q# автоматически загружает два пространства имен: Std.Core и Std.Intrinsic, которые содержат часто используемые функции и операции.

Вы можете оптимизировать программу Superposition, воспользовавшись операцией MResetZ пространства имен Std.Measurement. MResetZ объединяет операции измерения и сброса в одну операцию, например в следующем примере.

// Import the namespace for the MResetZ operation.
import Std.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Узнайте, как разрабатывать квантовые программы с помощью Q# и Azure Quantum

Q# и Azure Quantum — это мощная комбинация для разработки и запуска квантовых программ. С Q# помощью Azure Quantum можно создавать квантовые программы, моделировать их поведение, оценивать требования к ресурсам и запускать их на реальном квантовом оборудовании. Эта интеграция позволяет исследовать потенциал квантовых вычислений и разрабатывать инновационные решения для сложных проблем. Независимо от того, является ли вы начинающим или опытным квантовым разработчиком, и Azure Quantum предоставляют инструменты и ресурсы, Q# необходимые для разблокировки мощности квантовых вычислений.

На следующей схеме показаны этапы, через которые проходит квантовая программа, когда вы разрабатываете её с помощью Q# и Azure Quantum. Программа начинается с среды разработки и заканчивается отправкой задания на реальное квантовое оборудование.

Давайте разберем шаги на схеме.

Выбор среды разработки

Запустите квантовые программы в предпочитаемой среде разработки. Можно использовать онлайн-редактор кода на веб-сайте Microsoft Quantum, в локальной среде разработки с использованием Visual Studio Code или объединить код Q# с кодом на Python в Jupyter Notebooks. Дополнительные сведения см. в разделе "Различные способы запуска Q# программ".

Написание квантовой программы

Квантовые программы можно писать в Q#, используя квантовый набор разработки (QDK). Чтобы приступить к работе, смотрите Краткое руководство: Создание первой Q# программы.

Q#Кроме того, QDK предлагает поддержку других языков для квантовых вычислений, таких как Qiskit и Cirq.

Интеграция с Python

Вы можете использовать Q# самостоятельно или вместе с Python в различных IDE. Например, можно использовать проект Q# с узлом Python для вызова операций Q# или интеграции Q# с Python в Jupyter Notebook. Дополнительные сведения см. в разделе Интеграция Q# и Python.

Команда %%qsharp

По умолчанию Q# программы в Jupyter Notebooks используют ipykernel пакет Python. Чтобы добавить код Q# в ячейку записной книжки, используйте команду %%qsharp, которая обеспечивается пакетом Python qsharp, а затем добавьте ваш код Q#.

При использовании %%qsharpпомните следующее:

• Необходимо сначала запустить from qdk import qsharp , чтобы включить %%qsharp.
• %%qsharp применяется к ячейке записной книжки, в которой оно отображается, и изменяет тип ячейки с Python на Q#.
• Вы не можете поместить инструкцию Python до или после %%qsharp.
• Q# %%qsharp Следующий код должен соответствовать синтаксисуQ#. Например, используйте // вместо # обозначения комментариев и ; завершения строк кода.

Оценка ресурсов

Прежде чем работать на реальном квантовом оборудовании, необходимо выяснить, может ли программа работать на существующем оборудовании и сколько ресурсов он будет использовать.

Оценка квантовых ресурсов Azure позволяет оценивать архитектурные решения, сравнивать технологии кубитов и определять ресурсы, необходимые для выполнения заданного квантового алгоритма. Вы можете выбрать из предварительно определенных протоколов отказоустойчивости и указать предположения базовой физической модели кубита.

Дополнительные сведения см. в разделе Запуск первой оценки ресурсов.

Примечание.

Оценка квантовых ресурсов Azure бесплатна и не требует учетной записи Azure.

Запустите вашу программу в режиме симуляции

При компиляции и запуске квантовой программы QDK создает экземпляр квантового симулятора и передает Q# код в него. Симулятор использует код Q# для создания кубитов (имитирующих квантовые частицы) и выполняет операции по изменению их состояния. Результаты квантовых операций в симуляторе затем возвращаются в программу. Изоляция кода Q# в симуляторе гарантирует, что алгоритмы следуют законам квантовой физики и могут правильно работать на квантовых компьютерах.

Отправка программы на реальное квантовое оборудование

После тестирования программы в имитации его можно запустить на реальном квантовом оборудовании. При запуске квантовой программы в Azure Quantum создается и выполняется задание . Чтобы отправить задание поставщикам услуг Azure Quantum, вам требуется учетная запись Azure и квантовая рабочая область. Если у вас нет квантовой рабочей области, см. статью "Создание рабочей области Azure Quantum".

Azure Quantum предлагает одни из самых убедительных и разнообразных квантовых устройств. См. текущий список поддерживаемых поставщиков оборудования в статье Поставщики квантовых вычислений.

После отправки задания Azure Quantum управляет жизненным циклом задания, включая планирование заданий, выполнение и мониторинг. Вы можете отслеживать состояние задания и просматривать результаты на портале Azure Quantum.

Связанный контент

• Различные способы запуска Q# программ
• Настройка пакета средств разработки Quantum
• Быстрый старт: Создание вашей первой Q# программы