Quantum Computing Basics: кубиты и суперпозиция на Go

Привет, бро! 👋

Пока все говорят про AI, настоящие гики уже изучают квантовые вычисления. Это не фантастика - это математика будущего, которая сломает всю современную криптографию.

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

Но как это работает? И можно ли симулировать квантовые вычисления на Go?

Разбираем кубиты, суперпозицию и квантовые гейты с практическими примерами на Go 🚀

1. Квантовые вычисления vs классические

Классический бит vs кубит

Классический бит:

Состояние: 0 или 1
Детерминированность: всегда точное значение

Кубит (quantum bit):

Состояние: |0⟩, |1⟩ или суперпозиция обоих
Вероятностность: измерение даёт случайный результат

// Классический бит
type ClassicalBit struct {
    value bool // true или false
}

// Кубит в суперпозиции
type Qubit struct {
    alpha complex128 // амплитуда состояния |0⟩
    beta  complex128 // амплитуда состояния |1⟩
}

Математика кубита

Кубит описывается вектором состояния:

|ψ⟩ = α|0⟩ + β|1⟩

Где:

α, β - комплексные амплитуды
|α|² + |β|² = 1 - условие нормализации
|α|² - вероятность измерить 0
|β|² - вероятность измерить 1

2. Реализация кубита на Go

Базовая структура

package quantum

import (
    "fmt"
    "math"
    "math/cmplx"
    "math/rand"
)

type Qubit struct {
    Alpha complex128 // амплитуда |0⟩
    Beta  complex128 // амплитуда |1⟩
}

// Создание кубита в состоянии |0⟩
func NewQubit() *Qubit {
    return &Qubit{Alpha: 1, Beta: 0}
}

// Создание кубита в суперпозиции
func NewSuperposition(alpha, beta complex128) *Qubit {
    // Нормализация
    norm := math.Sqrt(real(alpha*cmplx.Conj(alpha) + beta*cmplx.Conj(beta)))
    return &Qubit{
        Alpha: alpha / complex(norm, 0),
        Beta:  beta / complex(norm, 0),
    }
}

Измерение кубита

Зачем нужно измерять кубит? Потому что при измерении кубит “коллапсирует” в одно из классических состояний.

func (q *Qubit) Measure() int {
    prob0 := real(q.Alpha * cmplx.Conj(q.Alpha))
    
    if rand.Float64() < prob0 {
        // Коллапс в состояние |0⟩
        q.Alpha = 1
        q.Beta = 0
        return 0
    }
    
    // Коллапс в состояние |1⟩
    q.Alpha = 0
    q.Beta = 1
    return 1
}

func (q *Qubit) String() string {
    return fmt.Sprintf("%.3f|0⟩ + %.3f|1⟩", q.Alpha, q.Beta)
}

3. Квантовые гейты

Что такое квантовые гейты?

Это операции, которые изменяют состояние кубита.

Гейт Паули-X (NOT)

Краткое описание:

Меняет состояния |0⟩ и |1⟩ местами. Инверсия, другими словами.

func (q *Qubit) PauliX() {
    q.Alpha, q.Beta = q.Beta, q.Alpha
}

Гейт Адамара (суперпозиция)

Создаёт суперпозицию из базового состояния.

func (q *Qubit) Hadamard() {
    newAlpha := (q.Alpha + q.Beta) / complex(math.Sqrt(2), 0)
    newBeta := (q.Alpha - q.Beta) / complex(math.Sqrt(2), 0)
    q.Alpha = newAlpha
    q.Beta = newBeta
}

Гейт поворота фазы

Изменяет фазу состояния |1⟩ на угол θ.
Фаза влияет на интерференцию в многокубитных системах.
А интерференция - ключ к квантовому преимуществу.
А квантовое преимущество - это когда квантовый компьютер решает задачи быстрее классического.
А значит, понимание фаз - важно!

func (q *Qubit) PhaseShift(theta float64) {
    phase := cmplx.Exp(complex(0, theta))
    q.Beta *= phase
}

4. Многокубитные системы

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

Двухкубитная система

type TwoQubitSystem struct {
    // Базисные состояния: |00⟩, |01⟩, |10⟩, |11⟩
    Amplitudes [4]complex128
}

func NewTwoQubitSystem() *TwoQubitSystem {
    return &TwoQubitSystem{
        Amplitudes: [4]complex128{1, 0, 0, 0}, // |00⟩
    }
}

func (tqs *TwoQubitSystem) CNOT(control, target int) {
    if control == 0 && target == 1 {
        // Меняем |01⟩ ↔ |11⟩ и |00⟩ ↔ |10⟩
        tqs.Amplitudes[1], tqs.Amplitudes[3] = tqs.Amplitudes[3], tqs.Amplitudes[1]
        tqs.Amplitudes[0], tqs.Amplitudes[2] = tqs.Amplitudes[2], tqs.Amplitudes[0]
    }
}

Квантовая запутанность (Entanglement)

func CreateBellState() *TwoQubitSystem {
    tqs := NewTwoQubitSystem()
    
    // Применяем Hadamard к первому кубиту
    sqrt2 := complex(1/math.Sqrt(2), 0)
    tqs.Amplitudes[0] = sqrt2  // |00⟩
    tqs.Amplitudes[2] = sqrt2  // |10⟩
    
    // Применяем CNOT
    tqs.CNOT(0, 1)
    
    return tqs // Результат: (|00⟩ + |11⟩)/√2
}

5. Квантовые алгоритмы

Алгоритм Дойча

Краткое описание:

Позволяет определить, является ли функция константной или сбалансированной с помощью одного запроса к оракулу.
Оракул - это “чёрный ящик”, который реализует функцию.
Т.е. он принимает кубит и изменяет его состояние в зависимости от функции.

func DeutschAlgorithm(oracle func(*Qubit)) bool {
    // Инициализация
    x := NewQubit()
    y := NewSuperposition(1, -1) // |−⟩ состояние
    
    // Hadamard на x
    x.Hadamard()
    
    // Применяем оракул
    oracle(x)
    
    // Hadamard на x
    x.Hadamard()
    
    // Измеряем x
    result := x.Measure()
    
    // 0 = константная функция, 1 = сбалансированная
    return result == 1
}

Квантовое преобразование Фурье

Для тех, кто забыл:

Фурье-преобразование переводит сигнал из временной области в частотную.
В квантовом мире это позволяет эффективно анализировать периодичность функций.
Т.е. преобразование в частотную область помогает решать задачи, связанные с периодами.
А это важно для многих квантовых алгоритмов, например, для алгоритма Шора.

func QFT(qubits []*Qubit) {
    n := len(qubits)
    
    for i := 0; i < n; i++ {
        qubits[i].Hadamard()
        
        for j := i + 1; j < n; j++ {
            angle := math.Pi / math.Pow(2, float64(j-i))
            // Controlled phase shift
            controlledPhaseShift(qubits[j], qubits[i], angle)
        }
    }
    
    // Reverse order
    for i := 0; i < n/2; i++ {
        qubits[i], qubits[n-1-i] = qubits[n-1-i], qubits[i]
    }
}

func controlledPhaseShift(control, target *Qubit, theta float64) {
    // Упрощённая реализация для демонстрации
    if real(control.Beta*cmplx.Conj(control.Beta)) > 0.5 {
        target.PhaseShift(theta)
    }
}

6. Квантовый симулятор

Симуляция квантовых систем на классическом компьютере - сложная задача из-за экспоненциального роста состояний с увеличением числа кубитов.
Но для небольших систем это возможно и полезно для обучения и экспериментов.

Полная реализация симулятора

type QuantumSimulator struct {
    qubits []*Qubit
    gates  []string
}

func NewSimulator(numQubits int) *QuantumSimulator {
    qubits := make([]*Qubit, numQubits)
    for i := range qubits {
        qubits[i] = NewQubit()
    }
    
    return &QuantumSimulator{
        qubits: qubits,
        gates:  []string{},
    }
}

func (qs *QuantumSimulator) ApplyGate(gate string, qubitIndex int) {
    switch gate {
    case "H":
        qs.qubits[qubitIndex].Hadamard()
    case "X":
        qs.qubits[qubitIndex].PauliX()
    case "Z":
        qs.qubits[qubitIndex].PhaseShift(math.Pi)
    }
    
    qs.gates = append(qs.gates, fmt.Sprintf("%s(%d)", gate, qubitIndex))
}

func (qs *QuantumSimulator) MeasureAll() []int {
    results := make([]int, len(qs.qubits))
    for i, qubit := range qs.qubits {
        results[i] = qubit.Measure()
    }
    return results
}

7. Практический пример

Генератор истинно случайных чисел

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

func QuantumRandomGenerator(bits int) []int {
    sim := NewSimulator(bits)
    
    // Создаём суперпозицию всех кубитов
    for i := 0; i < bits; i++ {
        sim.ApplyGate("H", i)
    }
    
    // Измеряем все кубиты
    return sim.MeasureAll()
}

func main() {
    // Генерируем 8-битное случайное число
    randomBits := QuantumRandomGenerator(8)
    
    // Конвертируем в число
    var result int
    for i, bit := range randomBits {
        result += bit << i
    }
    
    fmt.Printf("Квантовое случайное число: %d\n", result)
    fmt.Printf("Биты: %v\n", randomBits)
}

8. Бенчмарки и производительность

func BenchmarkQuantumSimulation(b *testing.B) {
    sim := NewSimulator(10)
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        // Создаём случайную квантовую схему
        for j := 0; j < 100; j++ {
            gate := []string{"H", "X", "Z"}[rand.Intn(3)]
            qubit := rand.Intn(10)
            sim.ApplyGate(gate, qubit)
        }
        sim.MeasureAll()
    }
}

// Результат: ~50μs для 10 кубитов, 100 гейтов

9. Ограничения классической симуляции

Экспоненциальный рост

// Память для n кубитов: 2^n комплексных чисел
func memoryRequired(qubits int) int {
    return int(math.Pow(2, float64(qubits))) * 16 // 16 bytes per complex128
}

// 20 кубитов = 16 MB
// 30 кубитов = 16 GB  
// 40 кубитов = 16 TB (!)

Квантовое превосходство

Классический предел: ~50 кубитов
Google Sycamore: 53 кубита, 200 секунд vs 10,000 лет на суперкомпьютере

Вывод: Будущее уже здесь

Квантовые вычисления: 🔐 Сломают RSA и современную криптографию
🚀 Экспоненциальное ускорение для специфических задач
🧬 Революция в науке: моделирование молекул, оптимизация
💰 Новые возможности: машинное обучение, финансы

Что изучать дальше:

Алгоритм Шора (факторизация) - главная угроза современной криптографии
Алгоритм Гровера (поиск) - Квантовая телепортация и запутанность
Квантовое машинное обучение - применение в AI
Post-quantum криптография - Квантовые аппаратные платформы (IBM Q, Google Sycamore)

P.S. Готов к квантовому будущему? Начинай изучать уже сейчас! 🚀

// Дополнительные ресурсы:
// - IBM Qiskit (Python, но концепции те же) - https://qiskit.org/
// - Microsoft Q# Development Kit - https://docs.microsoft.com/en-us/azure/quantum/
// - "Quantum Computing: An Applied Approach" (Hidary) - https://www.springer.com/gp/book/9783030259643
// - Quantum Country - https://quantum.country/
// - Qubit by Qubit - https://www.qubitbyqubit.org/
// - Quantum Computing for the Determined - https://quantum.country/qcvc
// - Quantum Algorithm Zoo - https://quantumalgorithmzoo.org/