Поделиться через

Общие сведения о языке квантового программирования 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# также предоставляет типы, которые характерны для квантовых вычислений. Например, тип Result представляет результат измерения кубита и может иметь два значения: Zero или One.

В программе Суперпозиции операция 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}$ состоянии.

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

// 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.

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

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

После выделения кубита его можно передать в операции и функции. Операции являются основными стандартными блоками программы 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. Это эквивалентно MMeasure([PauliZ], [qubit]).

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

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

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

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

// Reset a qubit.
Reset(q);

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

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

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

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

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

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

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Примечание.

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

Вы можете воспользоваться пространством имен Microsoft.Quantum.Measurement, чтобы с помощью операции MResetZ оптимизировать программу суперпозиции . MResetZ объединяет операции измерения и сброса на один шаг, как показано в следующем примере:

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.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. Программа начинается с среды разработки и заканчивается отправкой задания на реальное квантовое оборудование.

Схема, показывающая рабочий процесс разработки квантового программирования.

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

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

Запустите квантовые программы в предпочитаемой среде разработки. Вы можете использовать редактор кода в Интернете на веб-сайте Azure Quantum, размещенные записные книжки Jupyter в рабочей области Azure Quantum в портал Azure или локальную среду разработки с помощью Visual Studio Code. Дополнительные сведения см. в разделе "Различные способы запуска Q# программ".

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

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

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

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

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

Команда %%qsharp

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

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

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

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

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

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

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

Примечание.

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

Запуск программы в имитации

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

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

Вы можете отправить Q# программы в Azure Quantum для выполнения на реальном квантовом оборудовании. Вы также можете запускать и отправлять квантовые каналы, написанные на языках Qiskit и Cirq. При запуске квантовой программы в Azure Quantum создается и выполняется задание . Дополнительные сведения см. в статье о том, как отправлять программы Q# в Azure Quantum.

xref:microsoft.quantum.work-with-jobs

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

Примечание.

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

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

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