Версия для печати
Нажмите сюда для просмотра этой темы в оригинальном формате
Форум на Исходниках.RU > C/C++: Общие вопросы > Эмуляция квантовых вычислений


Автор: Majestio 28.10.24, 07:59
Всем привет!

Немного почитал про квантовые компьютеры, про квантовые вычисления ... ну так, чисто совсем по верхам. И решил напрячь ChatGPT4 :rolleyes: Дал задание написать эмулятор, который реализует эмуляцию "квантового сложения" двух кубитов, инициализируемых целыми числами 2 и 3. Но точного результата так и не добился. В первой итерации ИИ сделал прогу, которая печатала результат 2+3=3, вторая реализация даёт 2+3=10. Дальнейшие попытки уточнения ИИ просто меняет первый алгоритм на второй, потом второй на первый, и так в цикле.

Привожу код второй реализации, которая вычисляет 2+3=10. Кто в теме, гляньте pls, где тут неверные места в коде. Инициализация генератора псевдослучайных чисел проблему не решает - где-то не там не то :lol:

<{CODE_COLLAPSE_OFF}><{CODE_WRAP_OFF}>
    #include <iostream>
    #include <complex>
     
    class Qubit {
    private:
        std::complex<double> alpha; // Коэффициент для состояния |0>
        std::complex<double> beta;  // Коэффициент для состояния |1>
     
    public:
        // Конструктор для инициализации кубита
        Qubit(int value) {
            // Преобразование классического значения в квантовое состояние
            if (value == 0) {
                alpha = std::complex<double>(1, 0);
                beta = std::complex<double>(0, 0);
            } else if (value == 1) {
                alpha = std::complex<double>(0, 0);
                beta = std::complex<double>(1, 0);
            } else {
                // Для значений 2 и 3 создаем суперпозицию
                alpha = std::complex<double>(std::sqrt(2.0 / 5.0), 0); // Примерная амплитуда для |2>
                beta = std::complex<double>(std::sqrt(3.0 / 5.0), 0);  // Примерная амплитуда для |3>
            }
        }
     
        // Приватный конструктор для создания кубита из амплитуд
        Qubit(std::complex<double> a, std::complex<double> b) : alpha(a), beta(b) {}
     
        // Метод для выполнения операции сложения
        Qubit add(const Qubit& other) const {
            // Сложение амплитуд
            std::complex<double> newAlpha = alpha + other.alpha;
            std::complex<double> newBeta = beta + other.beta;
            return Qubit(newAlpha, newBeta);
        }
     
        // Метод для получения классического значения
        int toClassical() const {
            // Преобразуем амплитуды в классическое значение
            return static_cast<int>(std::round(std::norm(alpha) * 2 + std::norm(beta) * 3));
        }
     
        // Метод для печати состояния кубита
        void print() const {
            std::cout << "Состояние кубита: |0>: " << alpha << ", |1>: " << beta << std::endl;
        }
    };
     
    int main() {
        // Инициализация кубитов с числами 2 и 3
        Qubit qubit1(2); // Квантовое представление 2
        Qubit qubit2(3); // Квантовое представление 3
     
        // Печать состояний кубитов
        qubit1.print();
        qubit2.print();
     
        // Выполнение операции сложения
        Qubit result = qubit1.add(qubit2);
     
        // Преобразование результата в классическое представление
        int classicalResult = result.toClassical();
     
        // Печать результата
        std::cout << "Результат сложения (классическое представление): " << classicalResult << std::endl;
     
        return 0;
    }

Автор: Qraizer 28.10.24, 13:47
Значения ненормированы. Любая операция над кубитами должна завершаться нормированием состояния, чтобы сумма вероятностей вариантов суперпозиции была строго 1. Где-то потеряно деление на √2

Добавлено
P.S. Не настолько спец в квантмехе, чтоб понимать квантовые алгоритмы, но походу, чтобы получилось 5, т.е. вдвое меньше 10, на √2 должны быть поделены каждый из компонент состояния – действительная и мнимая. Подозреваю, что правильный метод сложения
<{CODE_COLLAPSE_OFF}><{CODE_WRAP_OFF}>
        Qubit add(const Qubit& other) const {
            // Сложение амплитуд
            std::complex<double> newAlpha = (alpha + other.alpha) / std::sqrt(2.0);
            std::complex<double> newBeta = (beta + other.beta) / std::sqrt(2.0);
            return Qubit(newAlpha, newBeta);
но это неточно

Автор: Majestio 28.10.24, 15:39
Qraizer, прикольно - но ответ совпал с желаемым!

Цитата Qraizer @
понимать квантовые алгоритмы

Qraizer и прочие уважаемые амигос - где, чего почитать, чтобы понять всю глубину этих глубин??? :-?

Чисто для того, чтобы было и потом вспомнилось ... может быть
Скрытый текст
>>> Инструкции для арифметических операций:
FADD: Сложение двух чисел с плавающей запятой.
FSUB: Вычитание двух чисел с плавающей запятой.
FMUL: Умножение двух чисел с плавающей запятой.
FDIV: Деление двух чисел с плавающей запятой.
FABS: Получение абсолютного значения числа с плавающей запятой.
FMAX: Нахождение максимума между двумя числами с плавающей запятой.
FMIN: Нахождение минимума между двумя числами с плавающей запятой.
>>> Инструкции для работы с векторными данными:
ADDPS: Сложение упакованных чисел с плавающей запятой одинарной точности.
SUBPS: Вычитание упакованных чисел с плавающей запятой одинарной точности.
MULPS: Умножение упакованных чисел с плавающей запятой одинарной точности.
DIVPS: Деление упакованных чисел с плавающей запятой одинарной точности.
RCPPS: Обратное значение для упакованных чисел с плавающей запятой одинарной точности.
SQRTPS: Извлечение квадратного корня из упакованных чисел с плавающей запятой одинарной точности 
>>> Инструкции для работы с двойной точностью:
ADDPD: Сложение упакованных чисел с плавающей запятой двойной точности.
SUBPD: Вычитание упакованных чисел с плавающей запятой двойной точности.
MULPD: Умножение упакованных чисел с плавающей запятой двойной точности.
DIVPD: Деление упакованных чисел с плавающей запятой двойной точности.

Добавлено
Цитата Qraizer @
правильный метод сложения
Стоп ... увы. Не, не катит. 2+8, 11+7, 14+2 ... все это даёт неверные вычисления!

:'(

Автор: Qraizer 28.10.24, 18:03
Я сильно сомневаюсь, что сложение вообще правильно запрограммировано. ИМХО нужно не складывать, а эмулировать через битовые операции, а их в свою очередь выполнять кубитной логикой, а не двоичной.

Добавлено
Счас вот нарыл вот такую вот хреновину, и вот смотря вот в код, вообще нифика не то. Вот.

Автор: Majestio 28.10.24, 20:55
Цитата Qraizer @
Счас вот нарыл вот такую вот хреновину, и вот смотрят вот в код, вообще нифика не то. Вот.

+1 ... Сцка, проекты нагрянули >:( Освобожусь - пойду читать, ибо чую там что-то из теории!

Powered by Invision Power Board (https://www.invisionboard.com)
© Invision Power Services (https://www.invisionpower.com)