Частицы теперь волны, а не мячики

Время каминг-аута.

Мне 30 лет, а я до сих пор при слове «атомы» и «электроны» представляю их себе как мячики. Молекулы в учебнике по химии всегда были набором мячиков и палочек между ними, а кристаллическая решетка — это когда целая стена из мячиков!

В целом, это неплохо работало.

Электрический ток я представлял себе как толпу таких мячиков, несущихся по проводу-трубе. Больше мячиков — значит больше ампер (силы тока), быстрее бегут — больше вольт (напряжение), шире труба — значит меньше сопротивление.

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

Так вот теперь время для первой важной части этого поста. Если мне удастся донести хотя бы это, значит вы уже поймете огромную часть квантовой механики, даже если сразу закроете пост после этого.

Мячики, вы лучшие, мы еще вспомним о вас!

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

Волны — это новые мячики

Срач о том, реально ли всё это волны или мы просто натянули имевшиеся для волн уравнения и сказали «опа, а вроде подходит» — один из самых громких споров современных физиков. Там рвут глотки и делятся на лагеря, так что давайте не будем и просто примем, что тот же самый мячик может ВЖУХ и быть посчитан как волна.

Так нам удобно и всё.

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

Главный же прикол в том, что кроме волн больше нет ничего. Вообще ничего. Никаких скрытых параметров, по крайней мере локальных.

Абсолютно любое свойство объекта отныне можно описать одной такой жирной функцией взаимодействия этих волн друг с другом.

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

Но реален ли сам Олег?

ДА, И ТЫ ТОЖЕ ВСЕГО ЛИШЬ НАБОР ВОЛН

Дам вам время подумать над этим. Тут лучше не торопиться. Можете вернуться к посту вечером.

Суперпозиция — всего лишь вероятность

Объясняя, что за фигня такая ваша «суперпозиция», все вспоминают байку с Котом Шредингера, закрытого в коробке со случайно взрывающейся колбой смертельного яда.

Пока мы не откроем коробку, кот для нас как бы ОДНОВРЕМЕННО мертв и жив, потому мы говорим «находится в суперпозиции жизни и смерти».

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

Пора прекратить шутить шутку 100-летней давности. Люди в 21 веке могут себе позволить среднее образование и понять тему чуть глубже.

Предлагаю поговорить о суперпозиции как будто мы люди с айфонами, а не крепостным правом.

Потому вместо кота мы возьмем монетку :D

Когда мы раскручиваем или подбрасываем её в воздух — она находится в суперпозиции орла и решки. Да, «как бы» одновременно. Только поймав монетку мы получаем один из результатов нашего измерения. Не поймаем — не узнаем. Всё.

В чем же драматическая разница с так нелюбимым нами котом?

В том, что внутри монетки всегда есть чёткие вероятности её падения орлом или решкой. В жизни мы принимаем их за 50% на 50%. Но если мы зададимся целью немного «подкрутить» фокус себе на пользу — мы можем сделать монетку из разных сплавов или как-то притягивать одну из сторон магнитом.

В теории мы можем сделать такую монетку, у которой вероятности выпадания орла и решки будут, скажем, 60% на 40%, что поможет нам чаще побеждать (наверное).

Отныне всегда, когда слышите про суперпозицию, представляйте себе именно такую подброшенную монетку.

Суперпозиция – не загадочный феномен «одновременности», а чёткое и простое отношение двух вероятностей

Находясь в «суперпозиции», монетка не просто для нас «как бы одновременно орел и решка», она имеет две вполне стабильные и известные нам вероятности выпадения одного и другого.

Да, мы не знаем 100% исход, но можем чётко влиять на него, например, направляя на монетку магнит.

Всё это уже намного удобнее использовать на практике, не правда ли?

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

Поэтому и дальше, когда мы будем говорить о квантовых битах, про которые все говорят, что они «одновременно 1 и 0», забейте на это и представляйте себе их как монетки. Каждый бит-монетка имеет строгую вероятностью быть прочитанным как 1 и строгую вероятность 0. Компьютер же может управлять этими вероятностями прямо в полёте пока не прочитает сам бит.

Прочитали бит — поймали монетку. Очень удобно.

Если вы поняли монетки — вы уже наполовину поняли квантовый компьютер, поздравляю.

Запутанность — квантовый IF

Чтобы объяснить квантовую запутанность я продолжу аналогию с монеткой, чтобы вас не ЗАПУТАТЬ. Простите, я должен был использовать этот каламбур.

Представим себе, что мы распилили нашу монетку вдоль. Как печеньки Oreo.

Получилось две монетки — одна только с орлом, вторая только с решкой. Пустая сторона разреза нас щас не интересует.

Не подглядывая где какая, мы подбрасываем обе новых монетки в воздух (переводим в суперпозицию, как мы теперь знаем). Монетки начинают вертеться в воздухе и не падают (потому что они теоретические!)

Тут квантовый физик скажет, что между монетками создана запутанность. Русская терминология лажает, потому лучше дополнительно запомнить английское слово — Entanglement. Оно встречается чаще.

Всё это означает некую «зависимость», «спутанность» или просто «связь» состояний двух монеток.

Как видите, никакой магии пока нет, законы физики мы не нарушали, на митинг не выходили.

Мы упаковываем одну из наших новых прикольных крутящихся монеток в коробку и отправляем её своему знакомому в другой город. А еще лучше на другую планету или в соседнюю галактику.

Теперь мы оба имеем по монетке, но понятия не имеем орел нам достался или решка. Кажется, пришло время посмотреть.

И вот тут обнаруживается ПАРАДОКС.

Следите за руками: в тот момент, когда один из нас открывает коробку, ловит свою монетку и видит, что на ней орёл — вторая монетка за много тысяч километров МОМЕНТАЛЬНО оказывается решкой.

Звучит тупо, да? Но мы на 100% в этом уверены.

Вот только Эйнштейн не был доволен такой фигнёй.

Монетки находились далеко друг от друга, так? Но результат чтения одной моментально повлиял на значение второй, так? Значит мы только что нарушили теорию относительности и передали информацию быстрее скорости света.

Бежиииим...

Но есть и хорошие новости: мы научились создавать системы из двух частиц, которые вот так моментально при чтении одной гарантируют нам значение другой.

Мы называем такие половинки «запутанными» друг с другом.

Оказывается, в нашем квантовом компьютере мы тоже можем так «запутывать» между собой биты, что если один покажет 0, второй 100% всегда примет значение 1 и наоборот. Такой вот физически нерушимый IF.

Кубит

Подойдём к настоящим квантовым вычислениям.

Другие статьи в интернете сразу начинают с объяснения кубитов, но мне показалось, что зная три правила выше, нам будет намного проще разговаривать и действительно понять суть кубитов, а не «магию». Теперь можно раскидать всё прямо на пальцах.

Кубит (qubit) — это квантовый бит

Звучит крутейше, но для начала вспомним что такое бит.

Прямая бочка пошла... ТУЦ-ТУЦ-ТУЦ-ТУЦ-ТУЦ!

Не, в смысле кумплюктерный бит.

🌚 Обычный бит

Бит — это любой выключатель, который может принимать значение 0 или 1.

Когда таких выключателей на стене много, мы даже можем закодировать в них какую-то информацию, чтобы сосед её увидел.

Восемь битов 01000001, например, будут буквой A, причём что в ASCII, что в Юникоде.

Набор букв АААА, переданных по сети как 01000001 01000001 01000001 01000001, сообщит собеседнику, что вы орёте над его мемом.

Любое устройство, на котором вы сейчас читаете эти строки, состоит из таких вот единичек и ноликов. Вся информация кодируется в битах, биты молотит ваш процессор, биты хранятся на диске, образуя байты, мегабайты, гигабайты — вы это знаете лучше меня.

Физически нам действительно неважно что у них внутри. В первых компьютерах они были механическими реле, в современных — всего лишь импульсы по 5 вольт, суть осталась та же.

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

Цепочка таких битов и инструкций что с ними делать даёт нам Машину Тьюринга. Так появились компьютеры. Привет.

🌖 Квантовый бит

Я так подробно разжёвывал выше про биты, чтобы всем стало понятно — в квантовых битах (кубитах) всё то же самое.

В них мы тоже принимаем за 0 или 1 какое-то их свойство, которое можем писать и читать, и так же можем делать их из разных материалов — просто теперь вместо механических реле мы используем частицы.

В чём же разница?

Кубит можно еще и подбросить как монетку! Перевести в суперпозицию, из которой он будет выпадать 0 (орлом) или 1 (решкой) с чёткой и нужной нам вероятностью.

Это открывает нам третье весёлое состояние, ради которого мы тут и собрались вообще.

Любое чтение кубита уничтожит нашу суперпозицию. Он схлопнется в 0 или 1, то есть монетка будет поймана, а стрелочка на нашей картинке повернётся к |0〉 или |1〉.

Циферблатики со стрелочками — это стандартная форма записи, привыкайте.

До чтения же у нас есть четкая вероятность того и другого исхода. Скажем, 70% на 30%. Мы не можем предсказать результат, но вероятности вот они, пожалуйста.

Мы можем спокойно нарисовать вероятности нашего кубита на картинке. Они не изменятся без нашего вмешательства.

В бульварных газетах тут любят говорить, что кубит как бы ОДНОВРЕМЕННО принимает значение 0 и 1. Думаю, после моего хейта в сторону Кота, вы понимаете почему мне не нравится это слово.

Оно отвратительно бесполезно! Щас еще параллельные миры плодить будем, ну уж нет.

Главная фишка такого кубита-монетки именно в том, что мы МОЖЕМ влиять на вращение этой монетки пока она в воздухе, влияя тем самым на вероятность выпадения орла или решки в конце.

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

Никакой магии, просто вероятность.

Мы можем направить на нашу монетку магнит, чтобы замедлить её вращение, инвертировать её в другую сторону или вообще заморозить, чтобы орёл был строго вверх. В этом случае он будет выпадать в 100% случаев, если вдруг нам это нужно.

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

Мы имеем право сколько угодно шалить с вероятностями внутри кубита, но когда мы читаем его значение — он всегда схлопывается в 0 или 1 с заданной вероятностью, превращаясь по сути в обычный бит.

Да, мы можем имитировать им обычный бит, просто записывая 100% вероятность за один из вариантов кубита.

Это легально, однако обычный бит справится с этим лучше и быстрее, а всё квантовое веселье таится именно между состояниями 1 и 0.

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

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

Квантовый компьютер

Много кубитов + алгоритм

Итак, что у нас есть на данном этапе:

Кубиты, которые похожи на обычные биты, только вместо 0 или 1 они хранят вероятность выпадения 0 или 1, которую мы можем как-то корректировать «в полёте» чтобы прочитать нужный результат в конце.

Как только мы «читаем» кубит, он всегда схлопывается в 0 или 1 как та монетка, которая в итоге выпадает только орлом или решкой. Кубит после этого уничтожается, потому чтение логичнее делать в самом конце.

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

Нарастающее стрёмное ощущение, что всё вокруг волна — даже небо, даже кубит. Появляющиеся сомнения в объективности наблюдаемой реальности и своей роли в этом мире.

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

Так получается алгоритм. Машина Тьюринга. Такой вот фигней, только на более высоком уровне, занимаются все программисты.

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

Решительно очевидно, что мы имеем полное право писать и читать наши кубиты как обычные биты. Записали в кубит 100% вероятность выпадения 1 — получили в итоге 1. Вау.

Но смысла в этом ноль. Как колоть орехи микроскопом — никто не запретит, но это достаточно медленно и бессмысленно. Обычный компьютер справится с этим лучше.

Сила же квантового компьютера именно в том, что мы берём несколько кубитов, которые как вы помните можно представлять как крутящиеся монетки, и взаимодействуем именно с вероятностями их выпадения в 0 (орел) или 1 (решка), а не самими результатами 0 и 1.

Вот это уже куда более интересно. Квантово!

В наших алгоритмах мы больше не мыслим концепциями «прочитай здесь, если 1, переложи туда», а начинаем как бы настраивать взаимодействие наших монеток (кубитов) пока они еще крутятся, чтобы в итоге получить интересующий нас результат.

Как вы понимаете, никто не гарантирует какой стороной упадёт первый кубит, а значит и нельзя ничего гарантировать про второй, и так далее. Получается как будто дерево расчёта вариантов исхода алгоритма.

Добавление всего лишь одного кубита увеличивает мощность компьютера сразу в два раза, а не на +1 бит как в обычном. Это и даёт нам вот ту самую экспоненциальную скорость вычислений в квантовом компьютере.

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

Если хотите более подробного разбора дерева по шагам, рекомендую вот эту годную статью.

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

Условно говоря, мы подкручиваем наши монетки и говорим как им вращаться друг относительно друга, чтобы в итоге они выпали на стол в комбинацию, например, «орел-решка-орел» (010).

Это и будет правильный ответ алгоритма.

И да, как вы уже догадались, вероятность правильного ответа на выходе квантового алгоритма бывает не 100%. Ну вот не получилось у нас связать все кубиты-монетки так, чтобы в 100% случаях они выдавали «орел-решка-орел», получилось только в 90%.

Тогда в 1 случае из 10 квантовый компьютер будет вполне легально нам врать, выдавая неправильный ответ. Тогда мы просто запускаем алгоритм много-много раз как настоящие боги инженерии! :)

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

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

Белые же европейцы в это время воюют за запрет термина «превосходство» потому что оно оскорбительно и нетолерантно.

Лет через пять меня точно отменят за этот пост. Сохраняйте.

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

Сейчас объясню.

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

Читеры вставляют палки в колёса, короче, и всё равно не могут догнать. Разве что иногда.

Именно поэтому квантовое превосходство интересно журналистам и историкам, но точно не инженерам.

Я как инженер жду не формального победителя первого забега, а того, кто покажет мне первый стабильный квантовый компьютер.

Сейчас с этим всё плохо. С текущим количеством шумов они попросту бесполезны для практических задач. Компьютер, который считает быстро, но постоянно врёт — разве это годится? Превосходство у них, блин.

Случайно подняться на гору легко — куда сложнее подниматься на неё каждый день. Можно использовать эту фразу как кредо по жизни.

The Алгоритм

Время программировать программы!

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

Программисты знают их почти наизусть: NOT, AND, OR, XOR и производные NOR, NAND, XNOR, и.т.д.

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

В этот процессор можно вшить язык ассемблера, на котором программисты смогут складывать и умножать настоящие числа типа 25 + 48 вместо перекладывания единичек и ноликов.

Потом они соберут из этих операций жирные высокоуровневые языки программирования.

Начнется бум кремния, крах доткомов, курсы «профессия Data Scientist за неделю» и вот уже даже бездомные пишут на React за еду.

Короче, в квантовых компьютерах всё то же самое!

Только уровень развития тут пока плавает где-то до изобретения ассемблера. Представляете сколько всего еще впереди?

ПИШЕМ. КВАНТОВЫЙ. КОД.

Я обещал вам квантовый Hello, World — держите. И да, он НА ПИТОНЕ.

Как и любой Hello World, он абсолютно бесполезен. Он лишь подбрасывает две монетки, связывает одну с другой и говорит орлами они упали или решками.

С другой стороны, мне очень нравится этот пример, потому что в нём сразу есть и суперпозиция, и квантовая запутанность двух кубитов, ну и самое главное — сраный if'чик на питоне!

Разберём всё подробно по шагам.

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

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2) # 2 qubits + 2 bits

Все наши биты и кубиты по умолчанию инициализируются в 0.

Дальше накидываем гейты. Потому что можем. Я хочу перевести первый кубит в суперпозицию гейтом H, то есть «подбросить» эту монетку. Если сразу после этого H наш кубит прочитать — мы получим идеальный генератор случайных чисел, в 50% выдающий 0, в 50% — 1.

Физически обоснованный!

Но мы не хотим читать 0 или 1, мы хотим программировать на вероятностях.

Потому вторым гейтом я наложу условие CNOT. Если наш кубит выпадает в 1 — он автоматически перевернёт и соседний кубит. То есть сделает из 0 в 1. Если нет — ничего не изменится. Оба наших кубита остаются по нулям.

qc.h(0) # gate H for qubit 0

qc.cnot(0, 1) # gate CNOT between 0 -> 1 qubits

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

qc.measure(0, 0) # read qubit 0 -> bit 0

qc.measure(1, 1) # read qubit 1 -> bit 1

qc.draw(output="mpl")

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

from qiskit import assemble, Aer

from qiskit.visualization import plot_histogram

simulator = Aer.get_backend("qasm_simulator")

result = simulator.run(assemble(qc)).result()

plot_histogram(result.get_counts())

Имитируя вероятности квантового компьютера, наш симулятор выполняет код 1024 раза и замеряет результат каждого эксперимента. Получается вот такая картинка:

Как можно заметить, вероятности близки к 50/50, но даже за 1024 броска монетки наш глупый цифровой рандом не приблизился к идеалу. Но жить вроде можно.

Дальше дело за малым — прочитать результат и сделать с ним что-то полезное в реальном мире. Тут уже можно наговнокодить if'чик на питоне и никто нас не осудит.

if "11" in result.get_counts():

print("РЕШКА")

else:

print("ОРЁЛ")

Он говорит «если оба кубита выпали в 11 — скажи решка, если в 00 — орел». Вариантов 01 и 10 у нас быть не может, иначе всю эту квантовую лавочку можно просто закрывать.

Для визуализации еще можно вывести получившиеся сферы Блоха для обоих кубитов. Если сделать это много раз, будет видно как стрелочки вдвоем прыгают вверх-вниз. Веселье.

Конец.

Нет, стойте, не конец.

Я же обещал выполнить это на реальном квантовом компьютере. С симуляторами ощущения не те. Придётся показать.

from qiskit import IBMQ

IBMQ.save_account("YOUR_API_KEY")

qpu = IBMQ.load_account().get_backend("ibmq_casablanca")

result = qpu.run(assemble(qc)).result()

plot_histogram(result.get_counts())

Ждём два часа в очереди и вуаля:

Ох-███ДАННЫЕ█УДАЛЕНЫ███-еть.

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

Вот теперь точно конец.

Зачем нам это все?

Наверное, стоило начинать с этого пост, но уже как-то поздновато :D

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

Тут действительно есть где посомневаться.

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

Даже самые топовые квантовые компьютеры гугла и IBM (на март 2021) содержат по 53 и 65 физических кубитов, что вроде неплохо для начала, но работают они не ахти как и не всегда.

Нам остаётся лишь ждать и надеяться, пока скептики прыгают вокруг с криками «ну и хернёй же вы занимаетесь, это всё хайп, надите нормальную работу».

Источник, не обрезанный

https://vas3k.ru/blog/quantum_computing/