На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS
msm.ru
Модераторы: Qraizer, Hsilgos
  
> Эмуляция квантовых вычислений
    Всем привет!

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

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

    ExpandedWrap disabled
      #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;
      }
      Значения ненормированы. Любая операция над кубитами должна завершаться нормированием состояния, чтобы сумма вероятностей вариантов суперпозиции была строго 1. Где-то потеряно деление на √2

      Добавлено
      P.S. Не настолько спец в квантмехе, чтоб понимать квантовые алгоритмы, но походу, чтобы получилось 5, т.е. вдвое меньше 10, на √2 должны быть поделены каждый из компонент состояния – действительная и мнимая. Подозреваю, что правильный метод сложения
      ExpandedWrap disabled
            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);
      но это неточно
        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 @
            Счас вот нарыл вот такую вот хреновину, и вот смотрят вот в код, вообще нифика не то. Вот.

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


            Рейтинг@Mail.ru
            [ Script execution time: 0,0973 ]   [ 18 queries used ]   [ Generated: 7.11.24, 23:03 GMT ]