Котята Шрёдингера: как я разводил квантовых котов на процессорах IBM

Про кота Шрёдингера слышали, наверное, все. Для тех, кто не слышал, коротко.

Берём кота и сажаем в закрытую коробку. Коробка полностью ограничена от внешнего мира и находится в квантовой позиции. Туда же кладём один радиоактивный атом, счётчик и банку с ядом. Если атом распадётся, счётчик сработает, молоток разобьёт банку, и кот умрёт. Если не распадётся, кот жив. Шанс, что атом распадётся за час, ровно 50%.

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

Кстати, Шрёдингер этим котом вообще-то издевался. Мол, смотрите, какая ерунда выходит, если квантовую механику применить к чему-то большому. А получилось наоборот: кот стал самым знаменитым мысленным экспериментом в физике.

Но как это доказать?

Меня в этой истории всегда смущало одно. Хорошо, кот «и жив, и мёртв» одновременно. Но как это проверить, как доказать?

Открываем коробку, а там либо живой кот, либо мёртвый. Точно так же было бы и с самым обычным котом. Результат уже есть, просто мы его не видим. И как тогда отличить «кот был в суперпозиции» от «кот давно помер, а мы не знали»? Заглянув в коробку один раз, никак не доказать.

И вот пришла идея.

Кот, кошка и 72 дня

А что если взять двух котов? Кота и кошку.

Сажаем их в одну коробку с одним атомом, но банку устраиваем хитро:

• если атом распался — умирает кот;

• если атом не распался — умирает кошка.

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

Но ведь в квантовом мире атом и распался, и не распался одновременно. Значит, и кот «и жив, и мёртв», и кошка «и жива, и мертва». А раз оба на 50% живы… может, им удастся встретиться в 25% случаев?

Поэтому коробку открываем не через час, а через 72 дня. (Еды и воды, конечно, оставляем на весь срок. Котиков обижать мы не будем.)

А вот котята — это уже будет доказательство. Кошки ходят беременными около девяти недель, так что за 72 дня всё успеет случиться. Если в коробке окажутся котята, значит, кот и кошка были живы одновременно, внутри своей суперпозиции. В обычном мире так не бывает. А в квантовом каждый из родителей жив на 50%, значит, оба сразу должны оказаться живыми в 25% случаев. То есть примерно в каждой четвёртой коробке нас должны ждать котята. Есть котята, значит, квантовая странность доказана.

Ну, коробка-то у меня есть, сам механизм в гараже соберу… но где взять квантовых котов? (Живых я обижать не буду — я кошек люблю.)

И тут меня осенило: есть же квантовые компьютеры.

Вот она — наша коробка для квантовых котов. Так выглядит квантовый компьютер IBM без кожуха: золотая «люстра» — это холодильник, а сам процессор с кубитами спрятан в самом низу. Фото: OJB Quantum, Wikimedia Commons, CC BY 4.0.

Кот по имени Кубит

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

Нам понадобится четыре кубита: атом, который ставим ровно «наполовину распавшимся», кот и кошка (в начале оба живы) и котёнок, которого в начале нет.

А дальше квантовый компьютер выполняет три правила «если… то»:

1. Если атом распался, кот умирает.

2. Если атом не распался, кошка умирает.

3. Если и кот, и кошка живы, рождается котёнок.

Потом коробку «открываем»: измеряем кота, кошку и котёнка. И повторяем опыт тысячу раз, чтобы посмотреть, что выпадает и как часто.

Всё это мы написали на Python с помощью Qiskit, бесплатной библиотеки от IBM для квантовых компьютеров. Получилось две программы. Первая, небольшая консольная, сажает котов в коробку, запускает опыт тысячу раз и рисует гистограмму, кто сколько раз выжил. Вторая это блокнот Jupyter: там можно заглянуть внутрь коробки, пошагово посмотреть, что происходит с каждым котом, и поиграться с «шумными» симуляторами. Обе работают и на симуляторе прямо на домашнем ПК, и на настоящих квантовых процессорах IBM.

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

import math
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

cat, she, kit, atom = (QuantumRegister(1, n) for n in ("кот", "кошка", "котёнок", "атом"))
qc = QuantumCircuit(cat, she, kit, atom, ClassicalRegister(3, "c"))

qc.x(cat)                             # кот жив
qc.x(she)                             # кошка жива
qc.ry(math.pi / 2, atom)              # атом: 50 на 50, распался или нет

qc.cx(atom, cat)                      # распался    -> кот умирает
qc.cx(atom, she, ctrl_state=0)        # не распался -> кошка умирает
qc.ccx(cat, she, kit)                 # оба живы    -> котёнок рождается

qc.measure([cat[0], she[0], kit[0]], [0, 1, 2])   # открываем коробку

Здесь всего четыре вида квантовых операций:

• x: переворачивает кубит, 0 становится 1. Так мы «оживляем» котов в начале.

• ry(π/2): поворачивает кубит ровно на полпути от 0 к 1. Получается атом, который распался с вероятностью 50%.

• cx (CNOT): «если управляющий кубит равен 1, переверни целевой». С параметром ctrl_state=0 срабатывает наоборот, когда управляющий равен 0. Это и есть наши два яда.

• ccx (вентиль Тоффоли): то же самое, но с двумя условиями. Котёнок переворачивается из 0 в 1, только если оба родителя равны 1.

Вот так эта схема выглядит в Qiskit (время идёт слева направо):

Открываем коробку

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

Запускаем. Тысяча коробок.

Примерно в половине коробок жив кот, в другой половине кошка. Котят…

Ноль.

Ни в одной из тысячи коробок.

А мы так надеялись.

Почему котят нет

Пришлось разбираться. И оказалось, что ошибка была в нашем понимании слова «одновременно».

Мы-то думали, что каждый кот сам по себе наполовину жив. А на самом деле в коробке сразу две целые истории:

• история первая: атом распался, кот мёртв, кошка жива;

• история вторая: атом не распался, кот жив, кошка мертва.

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

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

Проверка: даём каждому свой атом

Чтобы убедиться, что котята вообще умеют рождаться, поменяем условия: у кота свой атом, у кошки свой, независимый.

Теперь всё как с двумя монетками: в четверти случаев выживают оба. И симулятор послушно выдал котят примерно в 25% коробок.

Значит, наша схема работает. Просто когда атом общий, природа котят не допускает.

И что же, на этом всё? Эксперимент не удался? А вот и нет. Хочу квантового котёнка.

Настоящий квантовый компьютер и котята

Симулятор это хорошо, но хочется живого железа. IBM даёт бесплатный доступ к своим квантовым процессорам: регистрируемся, получаем ключ, пишем программу, запускаем (все ссылки и инструкции в приложении в конце статьи), ставим задачу в очередь, ждём… Получилось. (Мы же оптимисты.)

Открываем результаты, и…

Ура, котята. Мы верили! Около 5% коробок. Собираем наших котят:

Ах вы мои хорошие… Кому квантового котёнка? Пишите в личку, отдам 200 первым, одного оставлю себе. Только покормить не забудьте: не у всех из них есть мамки…

А кстати. Если присмотреться к выводку, с нашими котятами творится что-то странное.

• Кошка мертва, а котёнок есть: 89 раз. Кто его родил? А 32 из них и вовсе круглые сироты, у них мертвы оба родителя.

• Кот мёртв, а котёнок есть: 63 раза. Приговор у нас мгновенный, так что никакое «успел до того» не прокатит.

• Оба живы и котёнок есть: 49 раз. Самые «честные» котята: яд не сработал, повезло. Но в нашей коробке кто-то обязан умереть, так что и тут никакого квантового чуда, банку просто криво прикрутили.

И это ещё не всё. В 19 коробках оба родителя живы, а котят нет («не сложилось»), а в 120 мертвы оба, хотя кто-то обязан был выжить. Правильных исходов (жив ровно один из двоих, котят нет) оказалось 91,5%. Всё остальное это истории, которых не может быть ни в обычном мире, ни в квантовом: прибор просто иногда ошибается. Выходит, у нас котята-призраки.

Откуда взялись котята-призраки

Котята-призраки это шум, и у каждого процессора он свой. Мы запускали котов на двух чипах IBM: на ibm_kingston котята родились в 5% коробок, а на ibm_marrakesh в 3,7%. Может, на каком-нибудь другом их будет ещё больше?

У квантовых компьютеров пока ещё много ошибок, шум в квантовых вычислениях. И у наших призраков нашлось три источника.

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

Ошибки чтения. Когда коробку открывают, прибор иногда путает «жив» и «мёртв». Причём чаще читает живого как мёртвого: возбуждённое состояние кубита любит само «скатиться» вниз. Отсюда и лишние коробки «оба мертвы».

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

После компиляции под реальный процессор схема сильно разрослась. На бумаге у нас три операции: два CNOT и один Тоффоли. Но чип IBM напрямую умеет только одну двухкубитную операцию, CZ, и компилятор Qiskit раскладывает всё на неё. Если бы кубиты были соединены все со всеми, хватило бы 8 штук. А на настоящем чипе с его сотами выходит 14–17, и глубина схемы (сколько шагов подряд) доходит до 54. Вот как наша коробка выглядит после компиляции под ibm_kingston:

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

Ну и можно прикинуть, сколько всего ошибок набегает. Одна CZ на таком чипе ошибается примерно в 0,3% случаев, чтение одного кубита примерно в 1–2%. 17 операций плюс три чтения дают где-то 8% испорченных коробок. У нас «неправильных» вышло 8,5%, так что прикидка почти совпала с железом.

Можно проверить это и дома: у симулятора есть режим «с шумом», где ошибки задаём сами. Чем больше ошибок, тем больше котят-призраков. Причём сильнее всего на них влияют именно операции, где встречаются два кубита. С настройками, похожими на реальный чип, симулятор выдал почти ту же картину, что и kingston.

Так доказали мы или нет?

Доказали. Только не то, что хотели.

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

Зато мы на своей шкуре (ну ладно, на шкуре виртуальных котов) разобрались, как устроена суперпозиция: в ней живут целые истории, и котов из разных историй между собой не смешаешь. А ещё выяснили, что настоящий квантовый компьютер можно пощупать бесплатно. В 90% случаев он ведёт себя как в учебнике, а с остальными 10% сейчас и возятся все, кто такие компьютеры строит.

Эпилог

А одна коробка у меня до сих пор стоит в гараже закрытая.

Пока я её не открываю, котята там и есть, и нет.

Открыть или не открыть — вот в чём вопрос.

Приложение: как повторить

Весь код лежит в репозитории github.com/EstariolGH/schrodinger-kittens: консольная программа cats.py и ноутбук Jupyter с картинками и шумными симуляторами. Там же лежит пошаговая инструкция с самого нуля: как поставить Python, зарегистрироваться в IBM Quantum и запустить котов на настоящем квантовом процессоре.

python cats.py                       # общий атом — котят нет
python cats.py --mode independent    # у каждого свой атом — котята есть
python cats.py --backend ibm         # настоящий квантовый компьютер

Объявляю конкурс в двух номинациях:

• «Самый шумный»: у кого родится больше всех квантовых котят;

• «Самый аккуратный»: у кого меньше всех.

Пишите в комментариях, на каком чипе и сколько котят вышло. Мой рекорд: 201 котёнок на 4000 коробок.

P.S. Для самых внимательных

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

Дыра первая: симметрия. Условие «котята будут, если оба живы» на самом деле несимметричное. Коту достаточно дожить до знакомства, а кошке надо дожить до родов. Если кошка мертва, котят не будет ни при каком коте. Но на самом деле это не важно: судьба котиков всё равно решается в момент открытия коробки.

Так вот: это у нас условность. В нашей коробке прибор проверяет атом ровно один раз, в момент, когда закрывается крышка. Приговор выносится мгновенно и сразу в обоих вариантах: распался — яд коту, не распался — яд кошке. А какой из них окажется настоящим, решится только при открытии. Но до приговора никто ничего не успевает. А дальше котята возможны только в том случае, если оба пережили приговор, и тогда уже неважно, кому сколько надо продержаться.

Квантовый компьютер, кстати, устроен ровно так же: сначала атом решает судьбу котов, и только потом проверяется, родился ли котёнок. Так что к схеме претензий нет, только к биологии. А с биологией в квантовой физике всегда было сложно: ещё Шрёдингер не уточнил, кормили ли его кота.

Дыра вторая: котята, которых мы ждали. А теперь ещё раз посмотрим на выводок с настоящего процессора. 57 котят: папа жив, мамы нет. 63 котёнка: мама жива, папы нет. Да это же ровно то, о чём мы мечтали в самом начале. Пока коробка была закрыта, оба родителя были живы на 50%, успели встретиться, а при открытии один из них, увы, оказался мёртв. Вот он, котёнок, улика налицо.

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

Честное признание. Идея, эксперимент, код и все запуски на IBM мои. А с текстом, картинками и вычиткой помогал Claude. Так что если где-то вам почудился ИИ, вам не почудилось.