Численный анализ многокубитных систем

[С.И. Доронин]

Если посмотреть на матрицу плотности, то там кубит A находится ближе к левому верхнему углу (ρ00), а кубит с высоким номером/буквой находится ближе к нижнему краю диагонали.
    Отсюда следует, что с ростом индекса в матрице плотности растет и буква кубита. Значит, цифры и буквы возрастают в одном и том же направлении.

Нет, рост индекса к росту буквы кубита отношения не имеет. Ниже поясню подробнее.

С эти я полностью согласна. Но раз уж элемент ρ23 вы представили как |00010><00011|, то стало быть МЛАДШИЙ кубит А у вас СПРАВА. Т.е. если 2 это 00010, а 3 это 00011, то младший бит у вас СПРАВА, как у всех многозначных чисел. Значит, кубиты следуют в этой записи как EDCBA – младший справа. 00001 – это у нас «встал» кубит А, а 10000 – кубит E.

Не так, не надо за индексами искать место расположения кубитов, зачем Вы это делаете? Я же там не писал, что «младший кубит А справа»
Любой элемент матрицы с любым индексом, т.е. любой проектор, в частности |00010><00011|, имеет один и тот же порядок расположения кубитов, и он определяется только позицией в базисе. Попробую еще пояснить, я уже как-то расписывал позиции кубитов A и B в проекторе для двухкубитной системы, например элемент |c|², о котором мы говорили раньше, можно расписать:

|1>_A|0>_B<1|_A<0|_B.

Аналогично для любого числа кубитов. Так элемент ρ₂₃, т.е. |00010><00011|, о котором зашла речь, может быть «разложен по полочкам»:

|0>_A|0>_B|0>_C|1>_D|0>_E<0|_A<0|_B<0|_С<1|_D<1|_E.

И такой буквенный порядок будет для всех остальных проекторов, т.е. для всех элементов матрицы плотности с любым индексом. Индексы (и проекторы) не имеют отношения к выбранному порядку букв.

Думаю, при такой записи уже наглядно видно, почему я подчеркивал позиции 2,3 и 5, когда говорил о редукции по ВСЕ. Т.е. то, о чем Вы пишите далее:

Отсюда видно, что 2-ю, 3-ю и 5-ю позиции вы подчеркнули начиная с ЛЕВОГО края, т.е. перешли в систему записи, когда младшая цифра находится слева. Т.е. в этой записи биты следуют уже не в двоичном порядке, а в строковом, когда буквы пишут слева направо – ABCDE.

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

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

Если я плохо пояснил, и что-то остается непонятным, спрашивайте, это важный момент, и здесь нужно полное понимание.

[Pipa]

Подведем итог.
Имеем матрицу плотности:

|a|²    ab*    ac*    ad*
ba*    |b|²    bc*    bd*
ca*    cb*    |c|²    cd*
da*    db*    dc*    |d|²

редуцируем ее по B, т.е. оставляем A.

По Доронину  получается так:

|a|²+|b|²    ac*+bd*
ca*+db*    |c|²+|d|²

А по Пипиному получается эдак:

|a|²+|c|²    ab*+cd*
ba*+dc*    |b|²+|d|²

Кто прав?

    Я полагаю, что Доронин считал индексы по двоичной системе (слева на право), а удалял их по алфавиту (справа налево), оттого у него и получились "перепутанные" формулы, в которой биты считаются в противоположном порядке. Для двухкубитной системы вместо редукции по А получается редукция по B. А у трехкубитной вместо A было бы C. т.е. порядок кубитов оказывается инвертированным.
    Пипа же везде пользуется единой системой, а потому права .

Для поверки испытаем систему в которой кубита B совсем нет, но в матрице для него зарезервировано место:

p   q   0   0
s   t   0   0
0   0   0   0
0   0   0   0

т.е. блок

p   q
s   t

отвечает матрице кубита А, а матрица кубита B пустая.

Теперь мы редуцируем исходную матрицу 4x4 по B, которого нет. По идее мы должны получить то, что имеем для кубита A. А именно:

p   q
s   t
   
Проверяем это.

В формуле Пипы

|a|²+|c|²    ab*+cd*
ba*+dc*    |b|²+|d|²

подставляем c=d=0 и получим:

|a|²+0    ab*+0
ba*+0*    |b|²+0

или

|a|²    ab*
ba*    |b|²

Что похоже на правду. Т.е. если бы кубита B в самом деле не было, то так бы матрица плотности и выглядела.

По Доронину имеем:

|a|²+|b|²    ac*+bd*
ca*+db*    |c|²+|d|²

снова подставляем c=d=0 и получим:

|a|²+|b|²    0+0
0+0             0+0

или

|a|²+|b|²    0
0                 0

т.е. какую-то фигню .

Так элемент ρ₂₃, т.е. |00010><00011|, о котором зашла речь, может быть «разложен по полочкам»:

|0>_A|0>_B|0>_C|1>_D|0>_E<0|_A<0|_B<0|_С<1|_D<1|_E.

  Нет. Раскладывать мы будем не элемент ρ₂₃, а элемент ρ₂₂ (поскольку именно он у нас спорный), и не по "полочкам", а в виде живых матриц и векторов. Если вам не трудно – прошу изобразить в полной матричной нотации.

[С.И. Доронин]

Пипа, похоже, Вы меня не понимаете . В том вопросе, на котором мы сейчас застопорились, нет предмета для спора или дискуссии. Редуцированная матрица ρ_A, которую я привел – это не моя прихоть, и получена она вовсе не «по Доронину» , а согласно общепринятым правилам КМ. Это правильный ответ, любой другой – ошибочен. Постарайтесь понять, как получается правильный вид редуцированной матрицы, а плодить ошибочные решения можно до бесконечности, в этом нет никакого смысла.

Я полагаю, что Доронин считал индексы по двоичной системе (слева на право), а удалял их по алфавиту (справа налево), оттого у него и получились "перепутанные" формулы, в которой биты считаются в противоположном порядке.

В очередной раз замечу, никакие индексы здесь не причем. Вы видели где-нибудь, чтобы я упоминал об индексах, когда записывал матрицы плотности и редуцированные матрицы? Вы что, всерьез полагаете, что я считал при этом какие-то там индексы? Об индексах я упомянул только один раз, когда речь зашла о реализации алгоритма редукции в программе. Вы думаете математический аппарат КМ зависит от того, как осуществляется работа с индексами массивов на компьютере Еще раз подчеркну, чтобы записать матрицы плотности и получить редуцированные матрицы, никакие индексы не нужны, вся работа идет только с базисными векторами. Помните, я писал об «обкладках» из базисных векторов? – именно с их помощью получаются редуцированные матрицы.
Насколько я понимаю, именно индексы сбили Вас с толку . Попробуйте пока совсем о них забыть, и попытайтесь получить правильный вид ρ_A для двухкубитной системы, не думая ни о каких индексах, работая только с базисными векторами. Наверное, чтобы лучше понять алгоритм, нужно просто «вручную» на листе бумаги несколько раз это проделать. Если хотите, я могу дать несколько относительно легких упражнений для трехкубитной системы, а то, боюсь, простой двухкубитной системы не хватит, чтобы «набить руку» и прийти к пониманию редукции.

Для поверки испытаем систему в которой кубита B совсем нет, но в матрице для него зарезервировано место:

p   q   0   0
s   t   0   0
0   0   0   0
0   0   0   0

т.е. блок

p   q
s   t

отвечает матрице кубита А, а матрица кубита B пустая.

Пипа, это Вы сами придумали? О том, что в матрице плотности можно как-то разделить и расположить элементы для кубитов А и В по-отдельности, и даже можно записать двухкубитную систему «в которой кубита B совсем нет» Не думаю, что Вы могли где-то прочитать об этом, а если прочитали – выбросьте эту книгу . Уж лучше бы у меня спросили насчет той матрицы, что Вы приводите . А то Ваше понимание уйдет вообще неизвестно куда, и пропадет совсем .

Хотите, я еще более простой пример приведу. Как Вы думаете, отличаются ли между собой следующие матрицы плотности?

1  0
0  0

1  0  0  0
0  0  0  0
0  0  0  0
0  0  0  0

1  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0
0  0  0  0  0  0  0  0

И т.д.

Думаете, ничем не отличаются? Судя по Вашей логике, все они одинаковы, и кроме кубита А в них ничего нет? Вы глубоко заблуждаетесь, все эти матрицы плотности отличаются, причем это отличие существенно и принципиально. Я запишу векторы состояния, которые соответствуют этим матрицам:
|Ψ> = |0>
|Ψ> = |00> = |0>_A|0>_B
|Ψ> = |000> = |0>_A|0>_B|0>_С
И т.д.

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

Теперь мы редуцируем исходную матрицу 4x4 по B, которого нет. По идее мы должны получить то, что имеем для кубита A. А именно:

А если Вы будете редуцировать по А то получите матрицу ρ_В, состоящую из одних нулей? Ведь по Вашей логике кубита В совсем нет?

Пипа, поймите простую вещь, если «кубита В в самом деле нет», то размер матрицы плотности уже другой, она меньше в два раза. Если же Вы записываете матрицу плотности определенного размера, то там обязательно будут все кубиты, и их число всегда соответствует размеру матрицы плотности, т.е. в матрице 4*4 всегда есть два кубита, в 8*8 – всегда три и т.д. И это не зависит от того, какие элементы в матрице присутствуют, и где они в ней расположены.

По Доронину имеем:

|a|²+|b|²    ac*+bd*
ca*+db*    |c|²+|d|²

снова подставляем c=d=0 и получим:

|a|²+|b|²    0+0
0+0             0+0

или

|a|²+|b|²    0
0                 0

т.е. какую-то фигню

Пипа, это не фигня , это и есть ПРАВИЛЬНЫЙ ОТВЕТ , и опять это ответ не «по Доронину», а согласно КМ.

Нет. Раскладывать мы будем не элемент ρ₂₃, а элемент ρ₂₂ (поскольку именно он у нас спорный), и не по "полочкам", а в виде живых матриц и векторов. Если вам не трудно – прошу изобразить в полной матричной нотации.

Мне не трудно . Вы имеете в виду ρ₂₂ для двухкубитной системы, т.е. |10><10|?

Это векторы:
|10> = (0, 0, 1, 0)^T – вектор-столбец,
<10| = (0, 0, 1, 0) – вектор-строка.

Если перемножить столбец на строку, т.е. найти явный вид проектора |10><10| в виде матрицы, мы получим соответствующий один ненулевой элемент матрицы плотности:

0  0  0  0
0  0  0  0
0  0  1  0
0  0  0  0

Остается только умножить на коэффициент, т.е. на |c|², и будем иметь наш элемент в структуре исходной матрицы плотности.


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

[Pipa]

Pipa:
Нет. Раскладывать мы будем не элемент ρ₂₃, а элемент ρ₂₂ (поскольку именно он у нас спорный), и не по "полочкам", а в виде живых матриц и векторов. Если вам не трудно – прошу изобразить в полной матричной нотации.

Доронин:
Мне не трудно . Вы имеете в виду ρ₂₂ для двухкубитной системы, т.е. |10><10|?

Это векторы:
|10> = (0, 0, 1, 0)^T – вектор-столбец,
<10| = (0, 0, 1, 0) – вектор-строка.

Если перемножить столбец на строку, т.е. найти явный вид проектора |10><10| в виде матрицы, мы получим соответствующий один ненулевой элемент матрицы плотности:

0  0  0  0
0  0  0  0
0  0  1  0
0  0  0  0

Остается только умножить на коэффициент, т.е. на |c|², и будем иметь наш элемент в структуре исходной матрицы плотности.

    Я просила показать редукцию на элементе ρ₂₂, а вы показали, что в матрице плотности ему соответствует элемент |c|², стоящий в строке 2 и столбце 2 (считая от 0). А это и так очевидно.
    Вопрос именно о соотношениях между номерами строк и столбцов и именем редуцируемого кубита. Ваше утверждение о том, что между ними нет никакой взаимосвязи для меня сомнительно. Именно этот вопрос я и хотела выяснить, заведя разговор об элементе ρ₂₂.
    Я не спроста выбрала для рассмотрения диагональный элемент, у которого номер строки и столбца одинаковый. Благодаря этой своей особенности он несомненно должен войти в редуцируемую матрицу, поскольку при полном совпадении номера строки и столбца не может быть вычеркнут. Впрочем, даже на интуитивном уровне ясно, что все диагональные элементы исходной матрицы останутся живы, а если и произойдет уплотнение с жильем, то переселятся они не в любую коммуналку, а коммуналку лежащую на диагонали.
   Но только вот в какую? Этот ответ будет напрямую зависеть от соотношений между номерами битов в номере их прежней отдельной квартиры. И тут нам никак не уйти от вопроса о том, какая позиция в двоичной записи номера какому кубиту отвечает.
    Для элемента ρ₂₂ двоичный эквивалент номера равен 10. Если мы редуцируем по кубиту B, то должны точно знать, какая позиция в двоичном числе соответствует А, а какая B.
    Порядок следования битов в записи двоичного числа строго определен стандартом двоичной записи – справа налево. Т.е. в записи двоичного числа типа int биты следуют в таком порядке:
b31 b30 b29 b28 b27 b26 b25 b24 b23 b22 b21 b20 b19 b18 b17 b16 b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0

    Индексы строки и столбца тоже имеют у матриц такую же кодировку. Спрашивается, где среди них разряд, соответствующий А, а где разряд, соответствующий B? Ведь при редукции одни из разрядов мы обязаны рассматривать как "удаляемые", а другие как "остающиеся".
    Если полагать, что b0 соответствует кубиту A, b1 – кубиту B, b2 – кубиту C, и т.д. то получится "естественная система, в которой номера букв кубитов совпадают с номерами следования двоичных разрядов. Где у нас кубит G? – 7-ая буква алфавита, значит, это и будет 7-ой разряд по порядку – b6:

G   F   E   D   C   B   A
b6 b5 b4 b3 b2 b1 b0

    Если же вдруг захочется присвоить имя "А" старшему разряду двоичного числа и далее двигаться в порядке уменьшения номера бита, то возникнет сразу же проблема – как найти бит для кубита A? Ведь это только в рукописном варианте мы опускаем старшие нули, оставляя столько значимые, а компьютер этого делать не умеет.
    Очевидно, что А не будет 32-битом b31, но каким? Для этого надобно проводит, так называемый бит-риверс внутри ограниченной области. А именно – присвоить (временно) кубиту A младший разряд числа b0, затем, зная общее число кубитов отсчитать справа на лево такое число двоичных разрядов, а затем переставить этот  разряд со всеми, кто правее него, в обратном порядке, т.е. инвертировать участок от этого бита до самого младшего. Это и будет тот самый порядок, который использует Доронин в своей буквенной нумерации кубитов.
     Если в "естественная" нумерация легко программируется, поскольку позиция бита, задаваемого литерой, определяется его расстоянием от младшего разряда, позиция которого всегда фиксирована. А "доронинская" нумерация неопределенна до тех пор, пока не укажут где внутри сетки двоичного числа находится бит, соответствующий кубиту А, чтобы начать считать от него вправо.
    Соответственно этому, добавление "лишнего" кубита – например, расширение системы ABCD до ABCDE, в "естественной" системе никак не скажется на первой четверке кубитов, в том смысле, что их биты в двоичном числе останутся теми же самыми:

D   C   B   A
b3 b2 b1 b0

E   D   C   B   A
b4 b3 b2 b1 b0

А вот в "доронинской" системе они все сдвинутся:

A   B   C  D
b3 b2 b1 b0

A   B   C   D   E
b4 b3 b2 b1 b0

     Например, наш элемент ρ₂₂ в "естественной" системе всегда отвечает "комбинации" кубитов А и B (B+,A-), как бы много не было кубитов в системе. А в "доронинской" системе исчисления его привязка каждый раз будет меняться.
    Еще более неприятно, что матрицы считаются от левого верхнего угла (ρ₀₀) в порядке увеличения номеров, а нумерация кубитов "по Доронину" оперирует с двоичными разрядами строк и столбцов обратном порядке. Т.е. кубит А у него всегда старший и ассоциируется он со старшими битами номера строки/столбца (когда производится редукция).

Я запишу векторы состояния, которые соответствуют этим матрицам:
|Ψ> = |0>
|Ψ> = |00> = |0>_A|0>_B
|Ψ> = |000> = |0>_A|0>_B|0>_С
И т.д.

   Здесь мы отчетливо видим, что двоичные цифры в |000> находятся с последовательностью литер кубитов в обратном порядке. И только одинаковые нули это скрывают. Т.е 
   Предположим, что у нас было бы не
|Ψ> = |00>
а
|Ψ> = |10>
что бы это было?
|1>_A|0>_B
или
|0>_A|1>_B ?
   По-видимому, это зависит только от того, как мы соотносим биты с буквами. Буквы у нас растут однозначно по алфавиту – тут альтернативы нет. А цифирь можно считать с обеих сторон. И если Доронин ассоциирует с литерой "А" левый справа бит, то, значит, что он и биты считает слева направо. В этом случае XXXXX в записи |XXXXXX> нельзя рассматривать как  двоичное число.
   Если бы это была не двоичная система, а десятичная, ситуация выглядела бы так (только для иллюстрации - я понимаю, что здесь десятичные цифры неуместны):
|Ψ> = |123> = |1>_A|2>_B|3>_С
   Т.е. по Доронину сотни это А, десятки это B, а единицы – С.
В этой ситуации надо либо инвертировать биты на стадии двоичной записи – "переворачивать" двоичные номеров строк и столбцов в матрице плотности, либо присваивать литера с конца, вот так:
|Ψ> = |123> = |3>_A|2>_B|1>_С
    В работах по квантовой механике видимо уже существует привычка, которая не позволяет проделать только что изложенное. Но тогда остается лишь одно – делать битриверс двоичным числам. Это по вычислительным меркам страшно неудобно, а потому бит-инверсию придется делать на входе в процедуру Reduce(), поскольку считать прямо по Доронину компьютер не сможет, а риверсировать индексы при каждом обращении к матрицы – слишком накладно в плане скорости выполнения.
    Риверс битов – часто используется при FFT (Fast Fourier Transform), но на языке Си это делается крайне неэффективно. На ассемблере можно сдвигать число по одному разряду вправо и вталкивать биты переноса в другой регистр слева.
    На все эти ухищрения приходится идти "во имя человечности" , ради дани традиции записывать числа начиная со старшего разряда. В иврите с этим все впорядке – Там квантовую механику считать легче .
    Принимая во внимание эти обстоятельства, написанная мной процедура Reduce() работает правильно, только на ее входе кодировка кубитов должна быть битриверсирована.

Пипа, похоже, Вы меня не понимаете .

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

[С.И. Доронин]

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

Никакого соотношения «между номерами строк и столбцов и именем редуцируемого кубита» нет, Вы меня не слышите .
То о чем Вы спрашиваете, я уже показывал подробно Ответ #36
Попробую еще раз. Редукция элемента |10><10| осуществляется следующим образом. Смотрим на вектор-столбец и вектор строку в проекторе. Различаем в них две позиции – первая позиция соответствует одному кубиту, вторая позиция – другому. Это просто потому, что так строятся векторы, например, вектор-строка <10|=(0, 0, 1, 0) получается в результате тензорного произведения двух векторов <1|, и <0|, соответствующих первому и второму кубиту. Их можно обозначить как угодно, чтобы Вас не смущали индексы, т.е. номера строк и столбцов, или буквы А и В, я возьму вообще какие-нибудь произвольные обозначения, напр. £ для первого кубита и ¥ для второго.

Тогда тензорное произведение двух кубитов, первого <1|_£=(0, 1) и второго <0|_¥=(1, 0) дадут вектор-строку для двух кубитов <1|_£<0|_¥=(0, 0, 1, 0). То же самое для вектор-столбца |1>_£|0>_¥=(0, 0, 1, 0)^Т.

Таким образом, мы видим, что в проекторе первая позиция в векторах соответствует первому кубиту, а вторая – второму. Т.е. мы всегда можем разложить кубиты в проекторе «по полочкам»:
|1>_£|0>_¥<1|_£<0|_¥.

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

Теперь можно переходить к редукции. Допустим, мы хотим редуцировать по второму кубиту, который у нас обозначен как ¥. Чтобы редуцировать по нему, мы в проекторе его находим, и берем «в обкладки» из базисных векторов <0| |0> и <1| |1> (поочередно). Т.е. записываем сначала

|1>_£<0||0>_¥<1|_£<0|_¥|0>.

Смотрим теперь на <0||0>_¥ и <0|_¥|0> – здесь получаются единицы, и остается только |1><1|, т.е. при редукции этот элемент идет в правый нижний угол редуцированной матрицы, размером 2*2.

Очевидно, что когда второй кубит мы возьмем в обкладки из <1| |1> получаться нули, т.е. этого можно не делать.

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

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

Для элемента ρ₂₂ двоичный эквивалент номера равен 10. Если мы редуцируем по кубиту B, то должны точно знать, какая позиция в двоичном числе соответствует А, а какая B.

Не в двоичном числе, а в векторе! Будьте более внимательны, когда я писал об индексах, то говорил, что они лишь дают вид проектора, напомню:

Если простыми словами, то на любой элемент матрицы плотности

Код:

ρ[i][j]

можно смотреть как на запись данного элемента в виде проектора, если под i и j понимать числа в двоичной системе счисления.

Т.е. на 10 надо смотреть не как на число, а как на вектор |10> или <10|. Надеюсь, Вы понимаете, что числа и вектора это разные вещи. И позиция кубита не в двоичном числе, а в векторе! И эту позицию мы всегда знаем – первая позиция всегда кубит А, вторая – кубит В и т.д.

Спрашивается, где среди них разряд, соответствующий А, а где разряд, соответствующий B? Ведь при редукции одни из разрядов рассматривать , мы обязаны как "удаляемые", а другие как "остающиеся".

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

Предположим, что у нас было бы не
|Ψ> = |00>
а
|Ψ> = |10>
что бы это было?
|1>_А|0>_В
или
|0>_А|1>_В ?
   По-видимому, это зависит только от того, как мы соотносим биты с буквами.

Всегда будет |1>_А|0>_В, и никаких «по-видимому» , это абсолютно точно – биты с буквами никак не соотносятся.

Если бы это была не двоичная система, а десятичная, ситуация выглядела бы так (только для иллюстрации - я понимаю, что здесь десятичные цифры неуместны):
|Ψ> = |123> = |1>_А|2>_В|3>_С
   Т.е. по Доронину сотни это А, десятки это B, а единицы – С.

Пипа, не путайте числа с векторами. Первая позиция А – это никакой не разряд числа, а отдельный самостоятельный вектор первого кубита. То же самое относится к В и С. И редукция идет не по битам, не по разрядам чисел, а по векторам.

В этой ситуации надо либо инвертировать биты на стадии двоичной записи – "переворачивать" двоичные номеров строк и столбцов в матрице плотности, либо присваивать литера с конца, вот так:
|Ψ> = |123> = |3>_А|2>_В|1>_С
    В работах по квантовой механике видимо уже существует привычка, которая не позволяет проделать только что изложенное.
Но тогда остается лишь одно – делать битриверс двоичным числам.

В КМ как раз все предельно просто , ничего инвертировать не надо, и никакой «стадии двоичной записи» там нет, поскольку вектор |123> – это вовсе не число с разрядами, как Вам представляется, и никакие биты здесь ни причем. Это тензорное произведение трех самостоятельных векторов |1>|2>|3>, и каждый из этих векторов относится к своему кубиту.

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

[С.И. Доронин]

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

|Ψ> = a|00> + b|01>,                   (1)

где а и b удовлетворяют условию нормировки |a|²+|b|²=1. Сразу замечу, что векторы |00> и |01> в более подробной покубитной записи это |0>_A|0>_B и |0>_A|1>_B, о чем я подробно говорил в предыдущем сообщении.

Чтобы получить матрицу плотности этого чистого состояния, поступаем как обычно в КМ – записываем проектор |Ψ><Ψ|, т.е.

ρ = |Ψ><Ψ| = (a|00> + b|01>)(a*<00| + b*<01|) = |a|²|00><00| + ab*|00><01| + ba*|01><00| + |b|²|01><01|,             (2)

здесь |a|²=aa*, |b|²=bb*.

По сути дела, мы уже записали матрицу плотности, поскольку если перемножить вектора в каждом из четырех проекторов, мы получим четыре матрицы. Я их привожу в той же последовательности проекторов |00><00|, |00><01|, |01><00|, |01><01|.

1  0  0  0
0  0  0  0
0  0  0  0
0  0  0  0

0  1  0  0
0  0  0  0
0  0  0  0
0  0  0  0

0  0  0  0
1  0  0  0
0  0  0  0
0  0  0  0

0  0  0  0
0  1  0  0
0  0  0  0
0  0  0  0

Если учесть соответствующие множители и сложить эти матрицы, как это делается в выражении (2), то мы как раз получим искомую матрицу плотности в привычном для нас виде:

|a|²   ab*   0   0
ba*   |b|²   0   0
0       0       0   0
0       0       0   0

Узнаете, ту самую матрицу, которую Вы приводили в качестве примера? Но на практике, особенно для бОльшего числа кубитов, слишком утомительно перемножать вектора в каждом проекторе, чтобы узнать, куда пойдет тот или иной элемент. И, чтобы расставить элементы по своим местам, можно использовать следующий простой прием, при помощи которого очень легко получить из проекторной записи, матрицу плотности уже в явном виде.

Делается это следующим образом. Составляем таблицу, где строками и столбцами являются базисные векторы, все базисные векторы – для двухкубитной системы это четыре вектора, для трехкубитной – восемь векторов и т.д. Для двух кубитов шаблон такой таблицы выглядит следующим образом:

                  <0|_A<0|_B   <0|_A<1|_B   <1|_A<0|_B   <1|_A<1|_B
                   ______________________________________
|0>_A|0>_B  |
|0>_A|1>_B  |
|1>_A|0>_B  |
|1>_A|1>_B  |

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

                  <0|_A<0|_B   <0|_A<1|_B   <1|_A<0|_B   <1|_A<1|_B
                  ______________________________________
|0>_A|0>_B  |    |a|²             ab*             0               0
|0>_A|1>_B  |    ba*             |b|²             0               0
|1>_A|0>_B  |    0                 0                 0               0
|1>_A|1>_B  |    0                 0                 0               0

Точно так же можно поступать и во всех других случаях, для 3-х кубитной системы это будет таблица 8*8, для 4-х – 16*16 и т.д.

Как можно видеть, для построения матрицы плотности, никакие индексы вообще не нужны. Хотя теперь, возможно, легче будет понять, каким же образом индексы матричных элементов связаны с проекторами.  Любая пара индексов i и j, какого-нибудь элемента матрицы, указывает на тот или иной проектор, например элемент ρ₁₁=|b|² указывает на проектор |0>_A|1>_B<0|_A<1|_B. И что самое интересное, нам даже не нужно держать таблицу перед глазами и в нее заглядывать, – если мы распишем индексы в двоичной системе, они и будут давать вид соответствующих векторов проектора. Чтобы опять не сбить Вас с толку, подчеркну, именно вид, не двоичное число, то же 01, здесь важно само по себе, а на это число надо смотреть как на вектор |01> (для i) или <01| (для j). Т.е. индексы в двоичной системе служат нам как бы указателями на соответствующие базисные векторы в таблице.

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

[Pipa]

   Спущусь на землю от пространных объяснений до означенной темы, т.е. численного анализа.
    Написанная мной процедура Reduce() имеет, помимо указателей на входную и выходную матрицы, управляющий целочисленный параметр offmask. Каждый бит, установленный в единицу у этого параметра сигнализирует о том, что строки и столбцы исходной матрицы, в бинарном номере которых это бит присутствует, должны быть редуцированы, т.е. буквально удалены из матрицы, понижая тем самым ее размерность. При этом к остающимся элементам матрицы возможно «подселение» из числа элементов (клеток) из удаляемых строк и столбцов.
   Пусть мы имеем матрицу плотности:

|a|²    ab*    ac*    ad*
ba*    |b|²    bc*    bd*
ca*    cb*    |c|²    cd*
da*    db*    dc*    |d|²

1) Если положить offmask = 1 (двоичный эквивалент 01), то матрица потеряет все НЕЧЕТНЫЕ строки и столбцы (в них для иллюстрации проставлены нули):

|a|²+    0    ac*+    0
0          0      0        0
ca*+    0    |c|²+    0
0          0      0        0

после переноса в матрице результата получится:

|a|²+   ac*+
ca*+    |c|²+

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

2) Если положить offmask = 2 (двоичный эквивалент 10), то матрица потеряет всю свою нижнюю половину и правую часть:

|a|²+    ab*+
ba*+    |b|²+

Согласно утверждению Доронина, редукция по кубиту B должна быть такая:

|a|²+(|b|²)    ac*+(bd*)
ca*+(db*)    |c|²+(|d|²)

Присмотревшись, мы узнаем в ней вариант 1) offmask = 1 (двоичный эквивалент 01), подселенцев я взяла в скобочки, чтобы четче выглядели хозяева квартир.

А редукция по кубиту А должна быть такая:

|a|²+(|c|²)    ab*+(cd*)
ba*+(dc*)    |b|²+(|d|²)

в ней тоже без труда можно опознать вариант 2) offmask = 2 (двоичный эквивалент 10).

    Таким образом получаем:
редукция по кубиту А – режем старший бит (offmask = 2 dec  = 10 bin)
редукция по кубиту B – режем младший бит (offmask = 1 dec = 01 bin)

    При увеличении числа кубитов тенденция остается та же – редукция по самому старшему кубиту (буква ближайшая к концу алфавита) режет по младшим битам номеров строк и столбцов, а редукция по младшему кубиту «А» режет по старшему биту номеров. Т.е. возрастание буквы редуцируемого кубита влечет уменьшение номера бита в маске. Именно это явление я назвала битриверсом.
    Как бы то оно ни было, но затык возник в месте интерпретации фразы "редуцирование по кубиту X" и битовыми операциями при манипуляции с матрицей. Этот разрыв я ликвидировать не могу. Тем более, что вы сами отрицаете такую взаимосвязь.   
    Предлагаю оставить процедуру как она есть, т.е. задавать ей параметр редукции не по имени кубитов, а по удаляемым битам в нумерации строк и столбцов. Годится ли процедура в таком виде для целей общей залачи?
    Если такое решение вам кажется по каким-либо причинам неприемлемым, то просьба изложить эту причину. И предложить свой вариант исчисления редуцируемых битов номеров строк/столбцов для данной процедуры, в зависимости от списка имен редуцируемых кубитов.

[С.И. Доронин]

Пипа, я подготовил ответ с учетом второй части Вашего сообщения, которая сейчас отсутствует, начну с этого.

Основной момент. При редуцировании работа идет не со всей матрицей, а с каждым из ее элементов в отдельности. Т.е. это то, о чем Вы писали:

Если обкладывать надо не всю матрицу, а каждый из ее элементов в отдельности - тогда обложите мне элемент ρ₂₂, чтобы была ясна РАЗНИЦА в его судьбе при редукции по кубиту А и В. МНЕ НУЖЕН ЧИСЛОВОЙ ПРИМЕР, выясняющий судьбу элемента ρ₂₂ в матрице 4x4. Т.е. "демонстрация фокуса" на конкретном примере.

Пипа, я попытаюсь...

Первый шаг. Берем поочередно каждый элемент матрицы плотности, напр. ρ₂₂ и рассматриваем матрицу этого элемента (когда остальные элементы - нули), т.е.

0   0   0    0                                (1)
0   0   0    0
0   0   ρ₂₂ 0
0   0   0    0

Расписываем эту матрицу в векторном виде:

ρ₂₂ |1>_А|0>_В<1|_А<0|_В.

Как я говорил, конкретный вид проектора для каждого элемента, в данном случае |10><10| можно получить по индексам i и j, если их записать в двоичной системе, но рассматривать как векторы.

Вас смущает запись в виде бракетов? Но я же «переводил» ее и на обычный «язык» в виде векторов. Я отмечал, что на |1> нужно смотреть как на вектор (0, 1)^T (вектор-столбец из двух элементов), на |0> как на вектор-столбец (1, 0)^T. Тоже самое для <1| и <0|, только это уже вектор-строки, а не столбцы.

В явном векторном виде этот элемент расписывается следующим образом:

ρ₂₂ (0, 1)^T_A×(1, 0)^T_В•(0, 1)_A×(1, 0)_В.         (2)

Тензорное произведение я обозначил × (без кружочка), обычное произведение векторов здесь обозначается • (точкой).
Если выполнить все действия с векторами, сначала найти тензорные произведения, а затем перемножить полученные вектор-столбец на вектор-строку, можно убедиться, что мы здесь записали именно матрицу (1). Т.е. выражения (1) и (2) – это полные тождества. Но выражение в виде (2), когда разделены векторы первого и второго кубитов (обозначенные индексами A и В) нам нужно, чтобы провести редукцию. Еще раз подчеркну, что в такой векторной записи порядок кубитов всегда одинаков, т.е. на первом месте стоит первый кубит, на втором – второй, и т.д.

Второй шаг – сама редукция.
Бракетная запись редукции элемента ρ₂₂ по второму кубиту (по В) имеет вид:

|1>_А<0||0>_В<1|_А<0|_В|0>.       (3)

Жирным цветом я выделил те самые «обкладки», т.е. векторы, которые мы добавляем, т.е. вводим дополнительно в исходный матричный элемент, который у нас был раньше: |1>_А|0>_В<1|_А<0|_В.

Куда именно мы помещаем эти «обкладки» зависит от того, по какому элементу делается редукция. В данном случае, когда редукция идет по кубиту В, эти добавочные векторы мы ставим рядом с векторами в исходном элементе, помеченные индексом В.

В обычной матричной (векторной) записи выражение (3) имеет вид:

(0, 1)^T_A×{(1, 0)•(1, 0)^T_В}•(0, 1)_A×{(1, 0)_В(1, 0)^T}.

Сначала мы находим обычное скалярное произведение векторов (в фигурных скобках):

(1, 0)•(1, 0)^T=1.

Получаем единицу, это число, а не матрица, поэтому тензорное произведение здесь пропадает, и мы получаем:

(0, 1)^T_A•(0, 1)_A.          (4)

Осталось сделать последнее действие, перемножить вектор-столбец на строку, и мы получим результирующую матрицу:

0  0
0  1

Она и показывает, куда именно, на какую позицию в результирующей матрице размером 2*2 у нас пошел остаток от редукции данного элемента. То число, которое стояло в исходной матрице на месте ρ₂₂ пойдет сюда. Аналогично все делается для всех остальных элементов исходной матрицы плотности.

Пипа, Вы об этом меня просили? Записать редукцию элемента в явном векторном виде? Это то, что Вы хотели, или нет?

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

<1||1>_А |0>_В <1|_А|1><0|_В. 

И «срабатывать» теперь только будет не базисный вектор |0>, как в предыдущем случае, а базисный вектор |1>. Теперь он будет давать ненулевой результат (единицу) для <1||1>_А и <1|_А|1>. Как я уже говорил, в качестве «обкладок» надо перебирать все базисные векторы. Для редукции по одному кубиту их всего два |0> и |1>, и их надо оба использовать поочередно, оставляя те варианты, которые не дают ноль.

А дальше все опять делается как выше – расписываются бракеты в виде обычных векторов и перемножаются. Только теперь получится |0><0|, т.е. в результате редукции этого элемента ρ₂₂ по A, результирующая матрица (без коэффициента) имеет вид:

1  0
0  0


Таким образом, я попытался расписать редукцию в явном векторном виде без бракетов. Вот только, проделывать все эти операции с векторами нет никакой необходимости! В том-то и дело, что все эти операции в матричном виде можно опустить. Я как раз и предлагал алгоритм, как можно легко без этого обойтись. По двоичным числам индексов i и j нужно просто грамотно «вычеркивать» позиции, а результат правильно собирать в «контейнере». Т.е. то, о чем я говорил раньше. Или по Вашей терминологии – достаточно использовать битовую маску (грамотно ей воспользоваться).
Это можно сделать потому, что скалярные произведения векторов у нас всегда дают либо ноль, либо единицу – нет необходимости их считать, нужно просто «посмотреть» на биты в нужных позициях, сравнить их слева и справа (в двоичной записи i и j), в нашем примере 10 и 10 (при редукции ρ₂₂ по В). Мы сразу можем сказать, ноль будет в результате скалярного произведения (когда они разные), или единица (когда они совпадают). Когда разные, этот элемент совсем пропадает, когда одинаковые, как у нас, просто их «вычеркиваем», и остается то, что нужно, только на числа эти надо смотреть как на проектор, у нас остается |1><1|. Тем самым мы пропускаем все операции с векторами, о которых я писал выше, и сразу приходим к нужному результату (4). В этом случае редукцию мы делаем, не используя матричные операции.


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

0   0   0   0   0   0   0   0
0   1   2   0   3   0   0   0
0   2   4   0   6   0   0   0
0   0   0   0   0   0   0   0
0   3   6   0   9   0   0   0
0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0

Я не стал нормировать на единицу, чтобы легче было проверять. Индексы здесь будут указывать на векторы из трех компонент, т.е. у элемента ρ₂₂ будет проектор |010><010|.

Попробуйте воспользоваться своей программой для следующих вариантов редукции:

1) редукция по С, т.е. по третьему кубиту (по третьей позиции в проекторе, удаляется третий бит), когда остаются А, В и получается ρ_АВ.
2) редукция по В, по второму кубиту, когда остаются А, С и получается ρ_АС.
3) редукция по А, т.е. по первому кубиту, когда остаются В, С и получается ρ_ВС.

В этих случаях редуцированные матрицы имеют размер 4*4, приведите их все три, то, что у Вас получается.

Далее, можно сделать редукцию исходной матрицы по двум кубитам (остается один):

4) редукция по ВС, по второму и третьему кубиту, т.е. по второй и третьей позиции в проекторе (остается А), когда получается ρ_А.
5) редукция по АС (остается В), т.е. получается ρ_В.
6) редукция по АВ (остается С), т.е. получается ρ_С.

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

Я проделаю все это вручную, и мы сравним результаты.

[Pipa]

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

0   0   0   0   0   0   0   0
0   1   2   0   3   0   0   0
0   2   4   0   6   0   0   0
0   0   0   0   0   0   0   0
0   3   6   0   9   0   0   0
0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0

Попробуйте воспользоваться своей программой для следующих вариантов редукции:

1) редукция по С, т.е. по третьему кубиту (по третьей позиции в проекторе, удаляется третий бит), когда остаются А, В и получается ρ_АВ.
2) редукция по В, по второму кубиту, когда остаются А, С и получается ρ_АС.
3) редукция по А, т.е. по первому кубиту, когда остаются В, С и получается ρ_ВС.
4) редукция по ВС, по второму и третьему кубиту, т.е. по второй и третьей позиции в проекторе (остается А), когда получается ρ_А.
5) редукция по АС (остается В), т.е. получается ρ_В.
6) редукция по АВ (остается С), т.е. получается ρ_С.

Я проделаю все это вручную, и мы сравним результаты.

    Учитывая свой прошлый опыт, провожу предварительное бит-риверсирование:
A = 4 dec = 100 bin
B = 2 dec = 010 bin
C = 1 dec = 001 bin
---------------------------------------------
1) редукция по С, т.е. по третьему кубиту (по третьей позиции в проекторе, удаляется третий бит), когда остаются А, В и получается ρ_АВ

offmask = 1

1  0  0  0
0  4  6  0
0  6  9  0
0  0  0  0
---------------------------------------------
2) редукция по В, по второму кубиту, когда остаются А, С и получается ρ_АС.
 
offmask = 2

4  0  0  0
0  1  3  0
0  3  9  0
0  0  0  0
---------------------------------------------
3) редукция по А, т.е. по первому кубиту, когда остаются В, С и получается ρ_ВС.

offmask = 4

9  0  0  0
0  1  2  0
0  2  4  0
0  0  0  0
---------------------------------------------
4) редукция по ВС, по второму и третьему кубиту, т.е. по второй и третьей позиции в проекторе (остается А), когда получается ρ_А.

offmask = 3 = 2+1

5  0
0  9
---------------------------------------------
5) редукция по АС (остается В), т.е. получается ρ_В.

offmask = 5 = 4+1

10  0
 0   4
---------------------------------------------
6) редукция по АВ (остается С), т.е. получается ρ_С.

offmask = 6 = 4+2

13  0
 0   1
---------------------------------------------
У всех матриц след = 14

[С.И. Доронин]

Все ответы ПРАВИЛЬНЫЕ! Я еще подумаю о тестовых примерах для трехспиновой системы, что-нибудь посложнее придумаю .

[С.И. Доронин]

Пипа, а как насчет времени, много занимает редукция? Например, полностью заполненная матрица для 8 кубитов (какая-нибудь произвольная) сколько времени редуцируется по 7-ми кубитам, по 6-ти, 5-ти и т.д.?

[Pipa]

Пипа, а как насчет времени, много занимает редукция? Например, полностью заполненная матрица для 8 кубитов (какая-нибудь произвольная) сколько времени редуцируется по 7-ми кубитам, по 6-ти, 5-ти и т.д.?

   Ничтожно мало, причем настолько, что временем этих вычислительных процедур можно пренебречь (как и тензорным умножением).
   Причина этого в том, что основное время занимают процедуры сложностью N³, т.е. там, где объем вычислений пропорционален кубу поперечника матрицы. Это, прежде всего, умножение матрицы на матрицы - требующая N³ умножений  и столько же сложений (при матрицах равного размера). И нахождения собственных значений и векторов (сейчас точно не помню сколько умножений и сложений там надо, но примерно того же порядка).
    На этом фоне, вычислениями сложности N² уже можно пренебречь. Ведь уже при 7-и кубитах N=2⁷=128, N² будет в 128 раз меньше, чем N³, т.е. менее 1%.
    Тензорное умножение и редукция содержат в себе ничтожно малое число арифметических операций - только копирование и сложение. Все это на общем фоне не заслуживает даже учета.

[С.И. Доронин]

Отлично! Похоже, что во втором блоке программы остается одна времязатратная функция – нахождение собственных значений.

[С.И. Доронин]

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

1   0   0   2   0   3   4   0
0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0
2   0   0   4   0   6   8   0
0   0   0   0   0   0   0   0
3   0   0   6   0   9  12  0
4   0   0   8   0  12 16  0
0   0   0   0   0   0   0   0

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

[Pipa]

    Привожу выходной файл в том виде, в каком его выдала тестовая программа:

Matrix:
    1    0    0    2    0    3    4    0
    0    0    0    0    0    0    0    0
    0    0    0    0    0    0    0    0
    2    0    0    4    0    6    8    0
    0    0    0    0    0    0    0    0
    3    0    0    6    0    9   12    0
    4    0    0    8    0   12   16    0
    0    0    0    0    0    0    0    0

Reduce C:
    1    0    0    4
    0    4    6    0
    0    6    9    0
    4    0    0   16

Reduce B:
    1    0    0    3
    0    4    8    0
    0    8   16    0
    3    0    0    9

Reduce A:
    1    0    0    2
    0    9   12    0
    0   12   16    0
    2    0    0    4

Reduce BC:
    5    0
    0   25

Reduce AC:
   10    0
    0   20

Reduce AB:
   17    0
    0   13