Характеристики Квантовых Компьютеров

В реальности за кубиты нужно платить, и в идеале нужно купить ровно столько кубитов, сколько необходимо для выполнения задачи.

Для разработчика эксклюзивных игровых автоматов достаточно одного кубита на автомат (для генерации случайности).

Для «перебора» RSA-2048 — не менее 2048 кубитов.

Наиболее известные квантовые алгоритмы названы в честь Гровера и Шора.

Grover позволяет «взламывать» хэши.

Чтобы вывести из строя Биткойн, вам нужны компьютеры, имеющие на борту не менее 256 кубитов (вы можете поиграть со сложностью Биткойна, но давайте придерживаться этого круглого числа).

Шор позволяет факторизовать числа.

Чтобы факторизовать число длиной n двоичных цифр, вам понадобится как минимум n кубитов.

Текущий максимум: 50 кубитов ( уже 72? ).

И на самом деле 50 кубитов — это предел.

Предел квантового компьютерного моделирования.

Теоретически мы можем моделировать любое количество кубитов на классических компьютерах.

На практике добавление одного кубита в симуляцию требует удвоения мощности классических компьютеров.

Добавьте к этому слухи об удваивании кубитов каждый год, и задайте себе вопрос: как отладить алгоритмы для 256\512\1024\2048 кубитов? Симулятора нет; вы не можете установить точку останова на квантовом процессоре.

Мне нравится сравнивать когерентность с регенерацией рабочей памяти.

На полосе оперативной памяти находятся миллиарды ячеек, каждая из которых имеет заряд, нулевой или один.

У этого заряда есть очень интересное свойство – он истощает. Первоначально «единичной» ячейкой становится ячейка 0,99, затем ячейка 0,98 и так далее.

Соответственно, 0,01, 0,02, 0,03 накапливаются в ноле.

Этот заряд приходится обновлять, «регенерировать».

Все, что меньше половины, сбрасывается в ноль, все остальное сбрасывается в единицу.

Квантовые процессоры невозможно регенерировать.

Соответственно, цикл на все расчеты один, вплоть до первого «утекшего» кубита.

Время до первой «капли» называется временем декогеренции.

Когерентность — это состояние, когда кубиты еще не «утекли».

Здесь Можно посмотреть немного более взрослые объяснения.

Декогерентность связана с количеством кубитов: чем больше кубитов, тем труднее поддерживать когерентность.

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

Отсюда вытекает что количество кубитов само по себе ничего не решает. Вы можете удвоить количество кубитов и потратить 90% из них на устранение декогеренции.

Именно здесь в игру вступает концепция логического кубита.

Грубо говоря, если у вас процессор со 100 кубитами, но 40 из них направлены на исправление декогеренции, у вас остаётся 60 логических кубитов.

Те, на которых вы выполняете свой алгоритм.

Концепция логических кубитов сейчас носит скорее теоретический характер; О практических реализациях я лично не слышал.

Если вы инвертируете кубит, существует 2% вероятность того, что операция завершится неудачно.

Если запутать 2 кубита, то вероятность ошибки достигает 8%.

Возьмите 256-битное число, хэшируйте его до SHA-256, посчитайте количество операций, вычислите вероятность выполнения ВСЕХ этих операций без ошибок.

Математики предлагают решение: исправление ошибок.

Есть алгоритмы.

Для реализации одной запутанности двух логических кубитов требуется 100 000 физических кубитов.

Пройдет совсем немного времени, прежде чем придет конец.

Зачем вам оперативная память, если время работы ограничено миллисекундами? Я программирую на Q#, но это язык высокого уровня.

Выделите себе 15 кубитов и делайте с ними все, что захотите.

Он хотел, перепутал первый кубит с десятым.

Желал - спутал первые шестерки.

На реальном процессоре такой свободы нет. Я попросил запутать первый кубит с 15 — компилятор сгенерирует 26 дополнительных операций.

Если вам повезет. Если вам не повезет, он сгенерирует сотню.

Дело в том, что кубит может запутываться только со своими соседями.

Я не видел более 6 соседей на кубит. В принципе, есть компиляторы, оптимизирующие квантовые программы, но они пока скорее теоретические.

У каждого процессора свой набор инструкций, и связи между кубитами разные.

В идеальном мире у нас есть произвольные Rx, Ry, Rz и их комбинации, плюс свободная запутанность, основанная на дюжине признаков, плюс Swap: посмотрите на операторы в Галтель .

Реально у нас есть несколько пар кубитов, и запутанность CNOT(q[0],q[1]) стоит одну операцию, а CNOT(q[1],q[0]) занимает 7. И когерентность плавится.

.