Учебник. Изучение квантовой запутанности с помощью Q#

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

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

Классические биты содержат одно двоичное значение, например 0 или 1, но кубиты могут находиться в суперпозиции двух состояний, 0 и 1. Каждое возможное состояние кубита описывается набором амплитуд вероятности.
При измерении состояния кубита вы всегда получаете значение 0 или 1. Вероятность каждого результата определяется амплитудами вероятности, определяющими состояние суперпозиции при измерении.
Несколько кубитов могут быть запутаны таким образом, что вы не можете описать их независимо друг от друга. При измерении одного кубита в запутанной паре вы также получаете информацию о другом кубите, не измеряя его.

В этом руководстве вы узнаете, как:

Создайте Q# операции для инициализации кубита в требуемое состояние.
Поместите кубит в состояние суперпозиции.
Спутайте пару кубитов.
Измерение кубита и наблюдение за результатами.

Совет

Если вы хотите ускорить путешествие квантовых вычислений, ознакомьтесь с кодом с помощью Microsoft Quantum, уникальной функцией веб-сайта Microsoft Quantum. Здесь можно запускать встроенные Q# примеры или Q# собственные программы, создавать новый Q# код из запросов, открывать и запускать код в VS Code для Интернета с помощью одного щелчка мыши и задавать вопросы о квантовых вычислениях.

Предварительные условия

Чтобы запустить пример кода с использованием Copilot для Microsoft Quantum, у вас должна быть электронная почта, зарегистрированная в Microsoft (MSA).

Дополнительные сведения о Copilot для Microsoft Quantum см. в статье "Обзор Azure Quantum".

Инициализировать кубит в известное состояние

Первым шагом является определение Q# операции, которая инициализирует кубит в требуемое классическое состояние либо 0, либо 1. Эта операция измеряет кубит в общем квантовом состоянии, которое возвращает Q#Result значение типа либо Zero или One. Если результат измерения отличается от требуемого состояния, операция перевернет состояние таким образом, чтобы операция возвращала требуемое состояние 100% времени.

Откройте Copilot для Microsoft Quantum, очистите код по умолчанию и скопируйте следующий код в окно редактора кода. Вы не можете запустить этот код самостоятельно, так как он еще не является полной Q# программой.

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

В примере кода представлены две стандартные операции Q#, M и X, которые преобразуют состояние кубита.

Ниже приведено подробное описание работы SetQubitState операции.

Принимает два параметра: параметр типа Result с именем desired, который представляет требуемое состояние кубита (Zero или One), и параметр типа Qubit.
Выполняет операцию измерения, Mкоторая измеряет состояние кубита (Zero или One) и сравнивает результат со значением, которое вы передаете desired.
Если результат измерения не соответствует значению desired, X операция применяется к кубите. Эта операция изменяет состояние кубита таким образом, что вероятности измерения для Zero и One меняются местами.

Написать тестовую операцию для проверки состояния Белла

Чтобы вызвать операцию SetQubitState в вашей программе Q#, создайте другую операцию с именем Main. Эта операция выделяет два кубита, вызовы SetQubitState для задания первого кубита известному состоянию, а затем измеряет кубиты, чтобы увидеть результаты.

Скопируйте следующий код в окно редактора кода после SetQubitState операции.

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

В коде переменные count и initial задаются значениями 1000 и One соответственно. Это инициализирует первый кубит в состоянии One и измеряет каждый кубит 1000 раз.

Операция Main выполняет следующие действия:

Задает переменные для количества снимков (count) и начального состояния кубита (One).
Вызывает инструкцию use для инициализации двух кубитов.
Циклы по времени эксперимента count .
В цикле вызывается SetQubitState, чтобы задать указанное initial значение на первом кубите, а затем снова вызывается SetQubitState, чтобы установить второй кубит в состояние Zero.
В цикле применяется операция M для измерения каждого кубита, а затем сохраняется количество измерений, при которых возвращается One для каждого кубита.
После завершения цикла снова вызывается SetQubitState для сброса кубитов в известное состояние (Zero). Необходимо сбросить кубиты, которые вы выделяете с помощью инструкции use .
Message Вызывает функцию для печати результатов в окне вывода.

Запуск кода в Copilot для Microsoft Quantum

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

Чтобы запустить код как автономную программу, Q# компилятор в Copilot должен знать, где начать программу. Так как пространство имен не указано, компилятор распознает точку входа по умолчанию как Main операцию. Дополнительные сведения см. в разделе "Проекты" и неявные пространства имен.

Теперь ваша Q# программа выглядит следующим образом:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Скопируйте и вставьте полный пример кода в окно кода Copilot для Microsoft Quantum, установите ползунок количества выстрелов на значение "1", а затем выберите "Выполнить". Результаты отображаются в гистограмме и в полях результатов .

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

Программа еще не изменяет состояния кубита, поэтому измерение первого кубита всегда возвращается One, а второй кубит всегда возвращается Zero.

Если изменить значение initialZero и снова запустить программу, то первый кубит также всегда возвращается Zero.

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Поместите кубит в состояние суперпозиции

В настоящее время кубиты в вашей программе находятся в классическом состоянии либо в 1 или 0, так же, как биты на обычном компьютере. Чтобы запутать кубиты, необходимо сначала поместить один из кубитов в равное состояние суперпозиции. Измерение кубита в состоянии равной суперпозиции имеет 50% шанс выйти Zero, и 50% шанс выйти One.

Чтобы поместить кубит в состояние суперпозиции, используйте Q#H операцию, или Hadamard. Операция H преобразует кубит, который находится в чистом Zero или One состоянии в виде полупутного состояния между Zero и One.

Измените код в операции Main. Сбросьте исходное значение на One и вставьте строку для операции H.

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);  // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Снова запустите программу. Так как первый кубит находится в равной суперпозиции при измерении, вы приближаетесь к результату 50/50 для Zero и One. Например, выходные данные выглядят примерно так:

Q1 - Zeros: 523
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Каждый раз при запуске программы результаты первого кубита немного различаются, но близко к 50% и 50% OneZero, а результаты для второго кубита по-прежнему всегда Zero.

Инициализируйте первый кубит в состояние Zero вместо One и снова запустите программу. Вы получаете аналогичные результаты, так как операция H преобразует как чистое Zero состояние, так и чистое One состояние в состояние равной суперпозиции.

Примечание.

Чтобы узнать, как результаты суперпозиции зависят от распределения выстрелов, переместите ползунок в Copilot для Microsoft Quantum и увеличьте количество выстрелов.

Запутайте два кубита

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

Чтобы создать запутанное состояние, используйте операцию Q#CNOT, или управляемое НЕ. При применении CNOT к двум кубитам один кубит является кубитом управления, а другой — целевым кубитом. Если состояние управляющего кубита равно One, то операция CNOT меняет состояние целевого кубита. В противном случае CNOT ничего не делает с кубитами.

Добавьте в программу операцию CNOT, поместив ее сразу после операции H. Полная программа выглядит следующим образом:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
 }

Запустите программу и просмотрите выходные данные. Ваши результаты немного изменяются при каждом запуске программы.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Статистика для первого кубита по-прежнему показывает около 50% шанс измерять как One, так и Zero, но результаты измерения для второго кубита теперь не всегда Zero. Каждый кубит имеет одинаковое количество Zero результатов и One результатов. Результат измерения для второго кубита всегда совпадает с результатом для первого кубита, так как два кубита запутаны. Если первый кубит измеряется как Zero, тогда запутанный кубит также должен быть Zero. Если первый кубит измеряется как One, тогда запутанный кубит также должен быть One.

Предварительные условия

Чтобы разработать и запустить пример кода в локальной среде разработки, установите следующие средства:

Последняя версия Visual Studio Code (VS Code) или откройте VS Code для Интернета.
Последняя версия расширения Microsoft Quantum Development Kit (QDK). Дополнительные сведения об установке см. в разделе Настройка расширения QDK.

Создайте новый файл Q#

В VS Code откройте меню "Файл " и выберите новый текстовый файл , чтобы создать новый файл.
Сохраните файл как CreateBellStates.qs. В этом файле вы пишете Q# код для программы.

Инициализировать кубит в известное состояние

Откройте CreateBellStates.qs и скопируйте следующий код:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

В примере кода представлены две стандартные операции Q#, M и X, которые преобразуют состояние кубита.

Ниже приведено подробное описание работы SetQubitState операции.

Принимает два параметра: параметр типа Result с именем desired, который представляет требуемое состояние кубита (Zero или One), и параметр типа Qubit.
Выполняет операцию измерения, Mкоторая измеряет состояние кубита (Zero или One) и сравнивает результат со значением, которое вы передаете desired.
Если результат измерения не соответствует значению desired, X операция применяется к кубите. Эта операция изменяет состояние кубита таким образом, что вероятности измерения для Zero и One меняются местами.

Написать тестовую операцию для проверки состояния Белла

Добавьте следующую операцию в файл CreateBellStates.qs после операции SetQubitState.

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Операция Main выполняет следующие действия:

Задает переменные для количества снимков (count) и начального состояния кубита (One).
Вызывает инструкцию use для инициализации двух кубитов.
Циклы по времени эксперимента count .
В цикле вызывается SetQubitState, чтобы задать указанное initial значение на первом кубите, а затем снова вызывается SetQubitState, чтобы установить второй кубит в состояние Zero.
В цикле применяется операция M для измерения каждого кубита, а затем сохраняется количество измерений, при которых возвращается One для каждого кубита.
После завершения цикла снова вызывается SetQubitState для сброса кубитов в известное состояние (Zero). Необходимо сбросить кубиты, которые вы выделяете с помощью инструкции use .
Message Вызывает функцию для печати результатов в консоли.

Выполнение кода

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

Теперь файл CreateBellStates.qs выглядит следующим образом:

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Чтобы запустить программу, выберите команду Run в линзе кода перед операцией Main, или нажмите Ctrl + F5. Программа выполняет Main операцию на симуляторе по умолчанию.

Выходные данные отображаются в консоли отладки.

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

Если изменить значение initialZero и снова запустить программу, то первый кубит также всегда возвращается Zero.

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Поместите кубит в состояние суперпозиции

Измените код в операции Main. Сбросьте исходное значение на One и вставьте строку для операции H.

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);  // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Q1 - Zeros: 523
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Запутайте два кубита

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

График гистограммы частоты

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

Откройте свой файл CreateBellStates.qs в VS Code.
Откройте меню "Вид " и выберите палитру команд.
Введите histogram, чтобы открыть QDK: запустить файл и показать гистограмму. Или выберите команду гистограммы в опции CodeLens, которая предшествует операции Main. Затем введите количество выстрелов (например, 100). Гистограмма Q# открывается на новой вкладке.

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

Совет

Чтобы увеличить масштаб гистограммы, используйте колесико прокрутки мыши или жест трекпада. Чтобы сдвигать диаграмму при увеличении масштаба, удерживайте alt во время прокрутки.
Выберите столбец, чтобы отобразить процент от общего числа снимков, которые привели к этому результату.
Щелкните значок параметров в левом верхнем углу, чтобы отобразить параметры визуализации.
Запустите код еще раз, но на этот раз с 1000 выстрелами. По мере увеличения числа выстрелов распределение результатов приближается к нормальному распределению.

Ознакомьтесь с другими учебниками по Q#:

Алгоритм поиска Гровера показывает, как написать Q# программу, использующую алгоритм поиска Гровера.
Quantum Fourier Transform изучает, как писать программу, которая напрямую Q# обращается к определенным кубитам.
Квантовые катас — это самоуправляемые учебники и упражнения программирования, которые одновременно учат элементы квантовых вычислений и Q# программирования.

Обратная связь

Были ли сведения на этой странице полезными?

Last updated on 2025-12-03

Учебник. Изучение квантовой запутанности с помощью Q#

Предварительные условия

Инициализировать кубит в известное состояние

Написать тестовую операцию для проверки состояния Белла

Запуск кода в Copilot для Microsoft Quantum

Поместите кубит в состояние суперпозиции

Запутайте два кубита

Предварительные условия

Создайте новый файл Q#

Инициализировать кубит в известное состояние

Написать тестовую операцию для проверки состояния Белла

Выполнение кода

Поместите кубит в состояние суперпозиции

Запутайте два кубита

График гистограммы частоты

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

Обратная связь

Дополнительные ресурсы