Как вы знаете, я немного поиграл с Amazon Braket, которые дают нам на нашу бедность аж целый час бесплатных квантовых симуляций. И у них все работает.
Через них якобы можно получить доступ к настоящему квантовому компьютеру из 200 кубит с оговорками. Писать нужно на Python, есть спец. функции для вызова кавнтовых операций. Мне это никаких денег не приносит и не требуется для жизни, просто интерес, по этому особо много времени уделить не могу.
Вот что я сделал. Попросил GPT написать реализации этих операций на C# и C++ (может кому удобнее второе). Вот они:
https://dotnetfiddle.net/AZ25DO и
https://ideone.com/DWg4Ak
| бекап |
| using System.Numerics;
class Program
{
class QBit
{
private Complex _alpha = new Complex(1, 0); // |0>
private Complex _beta = new Complex(0, 0); // |1>
private static Random random = new Random();
// H: Hadamard gate
public void H()
{
var newAlpha = (_alpha + _beta) / Math.Sqrt(2);
var newBeta = (_alpha - _beta) / Math.Sqrt(2);
_alpha = newAlpha;
_beta = newBeta;
}
// X: Pauli-X gate or NOT gate
public void X()
{
var temp = _alpha;
_alpha = _beta;
_beta = temp;
}
// Pauli-Y gate
public void Y()
{
var newAlpha = Complex.ImaginaryOne * _beta;
var newBeta = -Complex.ImaginaryOne * _alpha;
_alpha = newAlpha;
_beta = newBeta;
}
// Pauli-Z gate
public void Z()
{
_beta = -_beta;
}
// S: Phase gate
public void S()
{
_beta = Complex.ImaginaryOne * _beta;
}
// T: π/8 gate or T gate
public void T()
{
_beta = Complex.Exp(Complex.ImaginaryOne * Math.PI / 4) * _beta;
}
// Measurement and Collapse!
public bool M()
{
double probabilityZero = _alpha.Magnitude * _alpha.Magnitude;
if (random.NextDouble() < probabilityZero)
{
CollapseToZero();
return false;
}
else
{
CollapseToOne();
return true;
}
}
public void CollapseToZero()
{
_alpha = new Complex(1, 0);
_beta = new Complex(0, 0);
}
public void CollapseToOne()
{
_alpha = new Complex(0, 0);
_beta = new Complex(1, 0);
}
// SWAP: Swap gate
public void Swap(QBit otherQBit)
{
var tempAlpha = _alpha;
var tempBeta = _beta;
_alpha = otherQBit._alpha;
_beta = otherQBit._beta;
otherQBit._alpha = tempAlpha;
otherQBit._beta = tempBeta;
}
// CNOT: Controlled NOT gate or Controlled X gate
public void CNot(QBit control)
{
if (control._beta.Magnitude * control._beta.Magnitude > 0.5) // Control qubit is more likely in |1> state
{
X();
}
}
// CCNOT: Double-controlled NOT gate or Toffoli gate
public void CCNot(QBit control1, QBit control2)
{
double probabilityControl1One = control1._beta.Magnitude * control1._beta.Magnitude;
double probabilityControl2One = control2._beta.Magnitude * control2._beta.Magnitude;
if (probabilityControl1One > 0.5 && probabilityControl2One > 0.5)
{
X();
}
}
}
static void Main()
{
var q1 = new QBit();
q1.H();
Console.Write(q1.M());
}
}
#include <iostream>
#include <complex>
#include <cmath>
#include <random>
# define M_PI 3.14159265358979323846
class QBit {
private:
std::complex<double> _alpha{ 1, 0 }; // |0>
std::complex<double> _beta{ 0, 0 }; // |1>
static std::default_random_engine generator;
static std::uniform_real_distribution<double> distribution;
public:
// H: Hadamard gate
void H() {
auto newAlpha = (_alpha + _beta) / std::sqrt(2.0);
auto newBeta = (_alpha - _beta) / std::sqrt(2.0);
_alpha = newAlpha;
_beta = newBeta;
}
// X: Pauli-X gate or NOT gate
void X() {
auto temp = _alpha;
_alpha = _beta;
_beta = temp;
}
// Pauli-Y gate
void Y() {
auto newAlpha = std::complex<double>(0, 1) * _beta;
auto newBeta = -std::complex<double>(0, 1) * _alpha;
_alpha = newAlpha;
_beta = newBeta;
}
// Pauli-Z gate
void Z() {
_beta = -_beta;
}
// S: Phase gate
void S() {
_beta = std::complex<double>(0, 1) * _beta;
}
// T: π/8 gate or T gate
void T() {
_beta = std::exp(std::complex<double>(0, M_PI / 4.0)) * _beta;
}
// Measurement and Collapse!
bool M() {
double probabilityZero = std::norm(_alpha);
double randomValue = distribution(generator);
if (randomValue < probabilityZero) {
CollapseToZero();
return false;
}
else {
CollapseToOne();
return true;
}
}
void CollapseToZero() {
_alpha = { 1, 0 };
_beta = { 0, 0 };
}
void CollapseToOne() {
_alpha = { 0, 0 };
_beta = { 1, 0 };
}
// SWAP: Swap gate
void Swap(QBit& otherQBit) {
auto tempAlpha = _alpha;
auto tempBeta = _beta;
_alpha = otherQBit._alpha;
_beta = otherQBit._beta;
otherQBit._alpha = tempAlpha;
otherQBit._beta = tempBeta;
}
// CNOT: Controlled NOT gate or Controlled X gate
void CNot(QBit& control) {
if (std::norm(control._beta) > 0.5) { // Control qubit is more likely in |1> state
X();
}
}
// CCNOT: Double-controlled NOT gate or Toffoli gate
void CCNot(QBit& control1, QBit& control2) {
double probabilityControl1One = std::norm(control1._beta);
double probabilityControl2One = std::norm(control2._beta);
if (probabilityControl1One > 0.5 && probabilityControl2One > 0.5) {
X();
}
}
};
std::default_random_engine QBit::generator;
std::uniform_real_distribution<double> QBit::distribution(0.0, 1.0);
int main() {
for (int i = 0; i<10; i++)
{
QBit q1;
q1.H();
std::cout << q1.M() << std::endl;
}
return 0;
}
|
| |
Вроде идея ясна. Но не ясно одно — эти все функции линейны. Как же возможно, что запустить это на квантовом компьютере — даст превосходство? Где здесь может набежать экспоненциальное нарастание сложности то?
Догадки такие. Здесь есть операция CNOT и ССNOT. Это то самое запутывание 2 и 3 кубит. Возможно что если запутать 100 кубит — то это уже потребует нарастания сложности. Но вроде такой операции нет даже на Amazon.
Есть идеи?