Введение в Q# - язык квантовых вычислений от Microsoft

operation Teleport(source : Qubit, target : Qubit) : Unit {
    using (ancilla = Qubit()) {
        // Создание запутанности между вспомогательным и целевым кубитами
        H(ancilla);
        CNOT(ancilla, target);
        
        // Запутывание исходного кубита со вспомогательным
        CNOT(source, ancilla);
        H(source);
        
        // Измерения и классическая коррекция
        let m1 = M(source);
        let m2 = M(ancilla);
        
        // Коррекция состояния целевого кубита
        if (m1 == One) { Z(target); }
        if (m2 == One) { X(target); }
    }
}

operation ApplyNotGate(q: Qubit): Unit {
    body {
        X(q);  // Применение квантового вентиля NOT (вентиль Паули-X)
    }
    adjoint {
        X(q);  // Adjoint операция X совпадает с самой X
    }
    controlled (controlQubits) {
        Controlled X(controlQubits, q);  // Контролируемый NOT
    }
}

mutable results = new Result[5];  // Создание изменяемого массива результатов
set results[0] = One;  // Установка значения элемента массива

function SumInt(a: Int, b: Int): Int {
    return a + b;  // Чистая классическая функция
}

repeat {
    // делаем что-то квантовое
    let success = MeasureQubit(controlQubit);
} until (success == One)
fixup {
    // корректируем состояние, если нужно
}

for (i in 0..2..10) {
    Message($"Итерация {i}");  // Выведет 0, 2, 4, 6, 8, 10
}

open Microsoft.Quantum.Canon;
open Microsoft.Quantum.Intrinsic;

using (qubits = Qubit[3]) {
    // работаем с тремя кубитами
    // при выходе из блока они автоматически вернутся в |0⟩
}

operation PrepareState(q: Qubit): Unit {
    H(q);  // Перевод кубита в равную суперпозицию |0⟩ и |1⟩
    T(q);  // Фазовый вентиль T, добавляет фазовый сдвиг
}

X = [ 0 1 ]
    [ 1 0 ]

let result = M(qubit);  // Измеряем кубит в стандартном базисе
if (result == One) {
    // Кубит коллапсировал в состояние |1⟩
    X(qubit);  // Возвращаем в состояние |0⟩
}

CNOT(control, target);  // Если control=|1⟩, то target переворачивается

operation ApplySequence(q: Qubit): Unit {
    X(q);
    H(q);
    // Результат отличается от:
    // H(q);
    // X(q);
}

operation PrepareSuperposition(q: Qubit): Unit is Adj {
    H(q);
    T(q);
}
 
operation RevertSuperposition(q: Qubit): Unit {
    Adjoint PrepareSuperposition(q);  // Автоматически выполняет T†, затем H
}

operation ControlledRotation(control: Qubit, target: Qubit): Unit is Ctl {
    Ry(0.1, target);  // Поворот вокруг оси Y
}
 
operation ApplyControlled(controls: Qubit[], target: Qubit): Unit {
    Controlled ControlledRotation(controls, target);
}

let rotationBy90 = Ry(1.57, _);  // Создаём новую операцию с фиксированым углом
rotationBy90(myQubit);  // Применяем её к конкретному кубиту

ApplyToEach(H, qubits);  // Применяет H к каждому кубиту
ApplyToEachA(Rx(0.1, _), qubits);  // Поддерживает частичное применение

operation ExploreQuantumState(q: Qubit): Unit {
    H(q);  // Перевести в суперпозицию
    DumpMachine();  // Показать внутреннее состояние (работает только на симуляторе)
    Reset(q);  // Вернуть кубит в |0⟩
}

let result = M(q);  // Измерить кубит
Reset(q);  // Вернуть в исходное состояние |0⟩

operation CustomRotation(q: Qubit, angle: Double): Unit is Adj + Ctl {
    Rx(angle, q);
    Ry(angle * 2.0, q);
}

using (q = Qubit()) {
    // Изобразим из себя волшебника и "угадаем" результат
    // будущего измерения
    H(q);  // Переводим в суперпозицию
    let prediction = (Random([0, 1]) == 0) ? Zero | One;
    Message($"Предсказываю, что измерение даст {prediction}");
    
    // Используем магию симулятора для установки нужного состояния
    if (prediction == One) {
        X(q);  // Гарантируем, что измерение даст One
    }
    
    let actual = M(q);
    Message($"Измерение дало {actual}");
    Reset(q);
}

operation QuantumRNG(): Int {
    using (q = Qubit()) {
        H(q);  // Переводим в равновероятную суперпозицию
        let result = M(q);  // Измерение даст случайный результат
        Reset(q);
        return result == One ? 1 | 0;
    }
}

operation EstimateResources(): Unit {
    using (qubits = Qubit[10]) {
        // Какой-то квантовый алгоритм
        ApplyToEach(H, qubits);
        for (i in 0..8) {
            CNOT(qubits[i], qubits[i+1]);
        }
    }
    // Инструмент ResourcesEstimator покажет, сколько кубитов
    // и операций потребуется
}

// C# код
using Microsoft.Quantum.Simulation.Simulators;
using QuantumApp;  // Наш скомпилированный Q# код
 
using var sim = new QuantumSimulator();
var result = await QuantumRNG.Run(sim);
Console.WriteLine($"Случайное число: {result}");

@EntryPoint()
operation RunQuantumAlgorithm(): Result {
    using (q = Qubit()) {
        // Ваш квантовый алгоритм
        return M(q);
    }
}

operation DeutschJozsa(oracle: ((Qubit[], Qubit) => Unit is Adj)) : Bool {
    using (qubits = Qubit[n + 1]) {
        let input = qubits[0..n-1];
        let output = qubits[n];
        
        // Подготовка входных кубитов в суперпозиции
        X(output);
        ApplyToEach(H, qubits);
        
        // Применяем оракул
        oracle(input, output);
        
        // Измерение после обратного преобразования Адамара
        ApplyToEach(H, input);
        
        // Проверяем, все ли кубиты в состоянии |0⟩
        let allZeros = ForAll(IsResultZero, MeasureEach(input));
        
        ResetAll(qubits);
        return allZeros;
    }
}

operation GroverSearch(oracle: (Qubit[] => Unit is Adj), markedElements: Int, n: Int) : Result[] {
    mutable resultArray = new Result[n];
    using (register = Qubit[n]) {
        // Инициализация в равную суперпозицию
        ApplyToEach(H, register);
        
        // Итерации Гровера
        let iterations = Round(PI() / 4.0 * Sqrt(IntAsDouble(2^n) / IntAsDouble(markedElements)));
        for (i in 1..iterations) {
            // Применение оракула
            oracle(register);
            
            // Диффузия
            ApplyToEach(H, register);
            ApplyToEach(X, register);
            Controlled Z(register[1..n-1], register[0]);
            ApplyToEach(X, register);
            ApplyToEach(H, register);
        }
        
        // Измерение результата
        for (i in 0..n-1) {
            set resultArray w/= i <- M(register[i]);
        }
        
        ResetAll(register);
        return resultArray;
    }
}

operation QFT(qs: Qubit[]) : Unit is Adj+Ctl {
    let n = Length(qs);
    
    for (i in 0..n-1) {
        H(qs[i]);
        for (j in i+1..n-1) {
            // Controlled phase rotation
            Controlled R1Frac([qs[j]], (2, j-i, qs[i]));
        }
    }
    
    // Reverse the order of the qubits
    for (i in 0..n/2-1) {
        SWAP(qs[i], qs[n-i-1]);
    }
}

using var qsim = new QuantumSimulator();
var results = await RunGroverSearch.Run(qsim, 4, 1);

operation EstimateEnergy(
    nQubits : Int,
    statePrep : (Qubit[] => Unit is Adj),
    hamiltonian : Pauli[][],
    coefficients : Double[]
) : Double {
    mutable energy = 0.0;
    
    for (idx in 0..Length(coefficients) - 1) {
        let coefficient = coefficients[idx];
        let paulis = hamiltonian[idx];
        
        if (IsAllIdentity(paulis)) {
            set energy += coefficient;
        } else {
            let expValue = ExpVal(statePrep, paulis, nQubits);
            set energy += coefficient * expValue;
        }
    }
    
    return energy;
}

@Test("QuantumSimulator")
operation QuantumRandomNumberTest() : Unit {
    let repeats = 1000;
    mutable zeros = 0;
    mutable ones = 0;
    
    for (i in 1..repeats) {
        let result = QuantumRNG();
        if (result == 0) {
            set zeros += 1;
        } else {
            set ones += 1;
        }
    }
    
    // Проверяем, что распределение примерно равномерное
    Fact(zeros > 400 and zeros < 600, "Ожидалось равномерное распределение");
}

operation SimulateHamiltonian(
    qubits : Qubit[],
    time : Double,
    evolutionGenerator : (Int, Double, Qubit[]) => Unit is Adj + Ctl
) : Unit is Adj + Ctl {
    evolutionGenerator(1, time, qubits);
}

// C# код запуска квантовой программы в облаке
var connectionString = "Endpoint=...;";
var qsClient = new QuantumJobClient(connectionString);
 
// Выбор квантового устройства
var target = QuantumTarget.GetProvider("ionq.simulator");
 
// Запуск задачи
var job = await qsClient.SubmitJobAsync(
    "Microsoft.Quantum.Samples.QuantumRNG",
    target);
 
// Получение результатов
var result = await qsClient.GetResultAsync<int>(job.Id);

operation MeasureInBellBasis(q1 : Qubit, q2 : Qubit) : (Result, Result) {
    // Метод поддерживает прогон на реальном оборудовании,
    // используя только базовые квантовые вентили
    CNOT(q1, q2);
    H(q1);
    return (M(q1), M(q2));
}

operation TrainModel(
    trainData : Double[][],
    labels : Int[],
    params : Double[],
    nQubits : Int,
    nIterations : Int
) : Double[] {
    mutable currentParams = params;
    
    for (i in 1..nIterations) {
        // Оценка градиента
        let gradient = EstimateGradient(trainData, labels, currentParams, nQubits);
        
        // Обновление параметров
        set currentParams = UpdateParams(currentParams, gradient, 0.01);
        
        // Оценка точности модели
        let accuracy = EvaluateModel(trainData, labels, currentParams, nQubits);
        Message($"Итерация {i}: точность {accuracy}");
    }
    
    return currentParams;
}

operation GenerateSharedKey(
    alice : Qubit[],
    bob : Qubit[],
    basis : Result[]
) : Result[] {
    mutable key = new Result[Length(alice)];
    
    for (i in 0..Length(alice)-1) {
        if (basis[i] == Zero) {
            // Базис Z
            set key w/= i <- M(alice[i]);
            if (M(bob[i]) != key[i]) {
                // Обнаружено подслушивание!
                Message("Возможно нарушение безопасности канала");
            }
        } else {
            // Базис X
            H(alice[i]);
            H(bob[i]);
            set key w/= i <- M(alice[i]);
            if (M(bob[i]) != key[i]) {
                Message("Возможно нарушение безопасности канала");
            }
        }
    }
    
    return key;
}

operation QuantumNeuron(
    input : Qubit[],
    weights : Double[],
    activationAngle : Double,
    output : Qubit
) : Unit is Adj + Ctl {
    // Взвешеная сумма через контролируемые вращения
    for (i in 0..Length(input)-1) {
        Controlled Ry([input[i]], (weights[i], output));
    }
    
    // Нелинейная активационная функция
    Ry(activationAngle, output);
}

operation FindOptimalTradingStrategy(
    marketData: Double[][],
    riskParameters: Double[],
    targetReturn: Double
) : Int[] {
    // Кодирование рыночных данных в квантовые состояния
    let encodedState = EncodeMarketData(marketData);
    
    // Определение оракула для идентификации выигрышных стратегий
    let oracle = ConstructProfitOracle(encodedState, riskParameters, targetReturn);
    
    // Применение амплификации амплитуды (алгоритм Гровера)
    return QuantumSearch(oracle, nQubits);
}

operation SolveVRPWithQAOA(
    distances: Double[][],
    nVehicles: Int,
    params: Double[]
) : Int[][] {
    // Кодирование задачи маршрутизации транспорта
    let problem = EncodeVRP(distances, nVehicles);
    
    // QAOA с вариационными параметрами
    let result = RunQAOAOptimization(problem, params);
    
    return DecodeSolution(result);
}

operation SimulateQuantumMaterial(
    interactionMap: Double[][],
    temperture: Double,
    simulationTime: Double
) : PhaseDiagram {
    // Инициализация начального состояния решетки
    using (lattice = Qubit[latticeSize]) {
        PrepareLatticeState(lattice, temperature);
        
        // Моделирование временной эволюции
        TimeDependentSimulation(lattice, interactionMap, simulationTime);
        
        // Измерение наблюдаемых величин
        let measurements = MeasureObservables(lattice);
        ResetAll(lattice);
        
        return ConstructPhaseDiagram(measurements, temperture);
    }
}

operation OptimizeParameters(
    objective: ((Double[]) -> Double),
    initialParams: Double[],
    bounds: (Double[], Double[])
) : (Double[], Double) {
    // Байесовская оптимизация с учётом шума квантовых измерений
    let optimizer = LoadOptimizer("BayesianWithNoise");
    
    let (optimalParams, minValue) = optimizer.Optimize(
        objective,
        initialParams,
        bounds,
        maxIter = 100
    );
    
    return (optimalParams, minValue);
}

operation DebugQuantumState() : Unit {
    using (q = Qubit()) {
        // Создаем сложное состояние
        H(q);
        T(q);
        S(q);
        
        // Отладочная визуализация состояния (работает только на симуляторе)
        DumpMachine();
        
        // Дамп конкретного регистра
        DumpRegister("debug.txt", [q]);
        
        Reset(q);
    }
}

operation CountResources() : Unit {
    // Запуск с аннотацией для анализа ресурсов
    @ResourcesEstimator
    using (qubits = Qubit[16]) {
        // Сложный алгоритм
        RunComplexAlgorithm(qubits);
    }
    // Результат будет выведен в консоль:
    // T-gates: 247, CNOT-gates: 134, Qubits: 16
}

operation RunWithErrorCorrection(payload: (Qubit => Unit)) : Result {
    using (code = Qubit[7]) {  // Код Стина исправляет одну ошибку
        let logical = EncodeLogicalQubit(code);
        
        // Запускаем полезную нагрузку на логическом кубите
        payload(logical);
        
        // Коррекция ошибок перед измерением
        let syndrome = MeasureSyndrome(code);
        CorrectErrors(code, syndrome);
        
        // Декодирование и измерение результата
        return DecodeAndMeasure(code);
    }
}

operation SimulateMoleculeDocking(
    drugMolecule: MoleculeData,
    targetProtein: ProteinData
) : BindingAffinity {
    // Квантовая оценка афинности связывания
    let hamiltonian = GenerateInteractionHamiltonian(drugMolecule, targetProtein);
    
    // Определяем основное состояние гамильтониана взаимодействия
    let groundEnergy = EstimateGroundState(hamiltonian);
    
    return ConvertEnergyToAffinity(groundEnergy);
}

// C# код, вызывающий квантовый алгоритм в цикле оптимизации
public async Task<double[]> ClassicalQuantumHybridOptimization()
{
    var simulator = new QuantumSimulator();
    var currentParams = InitializeParameters();
    
    for (int iteration = 0; iteration < 100; iteration++)
    {
        // Квантовая часть: оценка целевой функции
        var quantumCost = await EvaluateQuantumCost.Run(simulator, currentParams);
        
        // Классическая часть: обновление параметров
        currentParams = ClassicalOptimizer.UpdateParameters(currentParams, quantumCost);
    }
    
    return currentParams;
}

// Сравнение квантовых языков на примере создания суперпозиции
// Q#
operation CreateSuperposition(q: Qubit) : Unit {
    H(q);  // Один высокоуровневый вызов
}
 
// Qiskit (Python)
# Явное создание квантовой схемы
qc = QuantumCircuit(1)
qc.h(0)  # Применяем вентиль Адамара к кубиту 0

// C# интеграция с Q# через QDK
using Microsoft.Quantum.Simulation.Simulators;
using QuantumRandomGenerator;
 
public async Task<IEnumerable<int>> GenerateQuantumRandomNumbers(int count)
{
    using var simulator = new QuantumSimulator();
    var numbers = new List<int>();
    
    for (int i = 0; i < count; i++)
    {
        var result = await QuantumRandomGenerator.Run(simulator);
        numbers.Add(result);
    }
    
    return numbers;
}

namespace QuantumRandomGenerator {
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    
    @EntryPoint()
    operation GenerateRandomBit() : Int {
        using (q = Qubit()) {
            H(q);  // Переводим в равную суперпозицию
            let result = M(q);  // Измеряем
            Reset(q);  // Возвращаем кубит в |0⟩
            return result == One ? 1 | 0;
        }
    }
}

operation EncodeLogicalQubit(physicalQubits: Qubit[], auxiliaryQubits: Qubit[]) : Unit is Adj {
    // Код Стяна для защиты от битфлип-ошибок
    CNOT(physicalQubits[0], auxiliaryQubits[0]);
    CNOT(physicalQubits[1], auxiliaryQubits[0]);
    CNOT(physicalQubits[0], auxiliaryQubits[1]);
    CNOT(physicalQubits[2], auxiliaryQubits[1]);
}
 
operation DetectAndCorrectErrors(physicalQubits: Qubit[], auxiliaryQubits: Qubit[]) : Unit {
    // Измерение синдрома
    let syndrome0 = MeasureQubit(auxiliaryQubits[0]);
    let syndrome1 = MeasureQubit(auxiliaryQubits[1]);
    
    // Коррекция в зависимости от синдрома
    if (syndrome0 == One and syndrome1 == Zero) {
        X(physicalQubits[0]);  // Исправляем ошибку в первом кубите
    }
    elif (syndrome0 == One and syndrome1 == One) {
        X(physicalQubits[1]);  // Исправляем ошибку во втором кубите
    }
    elif (syndrome0 == Zero and syndrome1 == One) {
        X(physicalQubits[2]);  // Исправляем ошибку в третьем кубите
    }
}

// C# код для запуска с симулятором шума
using var noiseModel = new OpenSystemsSimulator(
    new OpenSystemsSimulatorOptions
    {
        DeviceNoiseModel = NoiseModel.DepolarizingChannel(0.001)
    });
 
var result = await MyQuantumAlgorithm.Run(noiseModel);