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

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

Мне сложно что-то сказать, нужно проверять. Пока могу назвать лишь основные моменты. Поскольку редуцированная матрица это тоже матрица плотности, то все ее свойства должны иметь место, т.е. ее след будет равен единице, и она эрмитова (симметричная в вещественном случае). Это, естественно, когда в качестве исходной матрицы, тоже берется матрица плотности.
Тестирование можно начинать с самого простого случая, когда редуцируется чистое состояние двухкубитной системы и остается один кубит. Явный вид редуцированных матриц ρ_A и ρ_В для этого случая я приводил.

[ksv]

Pipa - молодец: так быстро проделали столько работы!

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

Код:

#include <stdio.h>

int main(void)
{
	typedef union {
		short ind;
		struct {
			unsigned int b0:1;
			unsigned int b1:1;
			unsigned int b2:1;
			unsigned int b3:1;
			unsigned int b4:1;
			unsigned int b5:1;
			unsigned int b6:1;
			unsigned int b7:1;
			unsigned int b8:1;
			unsigned int b9:1;
			unsigned int b10:1;
			unsigned int b11:1;
			unsigned int b12:1;
			unsigned int b13:1;
			unsigned int b14:1;
			unsigned int b15:1;
			} byte2;
	} cod;

cod i;

scanf("%d",&i.ind);

printf("\n bite0 = %d",i.byte2.b0);
printf("\n bite1 = %d",i.byte2.b1);
printf("\n bite2 = %d",i.byte2.b2);
printf("\n bite3 = %d",i.byte2.b3);
printf("\n bite4 = %d",i.byte2.b4);
printf("\n bite5 = %d",i.byte2.b5);
printf("\n bite6 = %d",i.byte2.b6);
printf("\n bite7 = %d",i.byte2.b7);
printf("\n bite8 = %d",i.byte2.b8);
printf("\n bite9 = %d",i.byte2.b9);
printf("\n bite10 = %d",i.byte2.b10);
printf("\n bite11 = %d",i.byte2.b11);
printf("\n bite12 = %d",i.byte2.b12);
printf("\n bite13 = %d",i.byte2.b12);
printf("\n bite14 = %d",i.byte2.b14);
printf("\n bite15 = %d",i.byte2.b15);

return 0;
}

Использование битовых полей позволяет получить доступ к отдельным битам индекса элементов матрицы. А далее их уже можно просто сравнивать между собой. Так тип short в Visual C++ занимает 2 байта, что вполне достаточно для индекса элементов матрицы.

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

[Pipa]

Поскольку редуцированная матрица это тоже матрица плотности, то все ее свойства должны иметь место, т.е. ее след будет равен единице, и она эрмитова (симметричная в вещественном случае). Это, естественно, когда в качестве исходной матрицы, тоже берется матрица плотности.
Тестирование можно начинать с самого простого случая, когда редуцируется чистое состояние двухкубитной системы и остается один кубит. Явный вид редуцированных матриц ρ_A и ρ_В для этого случая я приводил.

Результаты проверки следующие:
1) След и эрмитовость сохраняются при любых исходных данных (генерировала случайные эрмитовые матрицы плотности размером 32х32 и редуцировала их до 4х4).
2) Пример

½ 0 0 ½
0 0 0 0
0 0 0 0
½ 0 0 ½

проредуцировался до 

½ 0
0 ½

Вроде бы так ему и положено.
----

    Сергей Иванович! Нарисуйте, пожалуйста исходную матрицу (можно в форме a,b,c,d). Для которой вы привели ответ редукции:

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

Только не ввиде суммы проекторов , а в "живом"виде - в том,  в котором матрицы обычно пишут.

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

Pipa

Сергей Иванович! Нарисуйте, пожалуйста исходную матрицу (можно в форме a,b,c,d). Для которой вы привели ответ редукции:

Для произвольного чистого состояния двухкубитной системы

|Ψ>= a|00> + b|01> + c|10> + d|11>,

матрица плотности имеет вид:

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

Где а, b, c, d – произвольные комплексные числа, удовлетворяющие условию нормировки:
|a|²+|b|²+|c|²+|d|²=1.

[Pipa]

Кажется первая примерка прошла удачно.

матрица плотности имеет вид:

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

Если все проделать так, как я написал выше, то получим ρ_A, которая имеет вид:

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

Т.е. происходит не просто обнуление, а суммирование отдельных элементов исходной матрицы плотности.
Причем, когда мы берем частичный след по другому кубиту (по A, а не по B, как перед этим), то частичная матрица плотности ρ_В уже другая:

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

Результаты тестов:

    1) Этап 1. Действительные целочисленные числа.
Мнимые части обнуляем и принимаем: a=1, b=2, c=3, d=4.

При этих значениях матрица плотности

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

принимает вид:

1    2    3    4
2    4    6    8
3    6    9   12
4    8   12  16
(след = 1+4+9+12=30)

Ее редукция по A дает:

 5   11
11  25
(след = 5+25=30)

а редукция по B дает:

10   14
14   20
(след = 10+20=30)

что совпадает с приведенным вами общим решением.
 
    2) Этап 2. Действительных случайные числа.
Значения a, b, c, d генерировались с помощью генератора случайных чисел random(), а затем, подстановкой по формулам,  заполнялась исходная матрица плотности и матрица ожидаемого результата.
После проведения редукции результат автоматически сравнивался с ожидаемым (цикл сравнения по всем клеткам) и печатался факт совпадения или расхождения.
На 100 автоматически сгенерированных примерах не обнаружилось ни одного расхождения предсказанного результата с ожидаемым.

    3) Этап 3. Комплексные случайные числа.
Проводился аналогично этапу 2, но матрица мнимых частей заполнялась тем же способом, что и действительная часть, – случайной генерацией нижнего треугольника, а верхний заполнялся с изменением знака.
Те же 100 проходов дали полностью совпадающие результаты с ожидаемыми, как при редукции по A, так и по B.

На этом предлагаю пока считать процедуру работоспособной.

Вопрос: У меня вызывает сомнение, что получаемая процедурой Reduce() «псевдоредуцированная» матрица размером 2^N (где N – число кубитов, НЕподвергающихся редукции) может иметь полностью нулевые столбцы или строки, что могло бы потребовать ее дальнейшего сжатия.
Если вам кажется, что я не права, то предлагаю вам придумать такие a, b, c, d (за исключением тривиального случая, когда они все равны по нулям), чтобы в редуцированной матрице оказался полностью нулевой столбец или строка (на матрицах бОльшей размерности полностью нулевая строка или столбец тем более маловероятны).

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

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

Ее редукция по A дает:

 5   11
11  15
(след = 5+15=30)

Очевидно, что 5+15 это не 30, я догадываюсь, что вместо 15 должно быть 25, но все же будьте повнимательней, в более сложных случаях мы просто запутаемся. И остальные цифры проверьте еще раз.

И с терминологией тоже давайте договоримся, – редукция по A, это когда A исчезает, а остается все остальное, в данном случае В, т.е. эта матрица, наоборот, редукция по B, когда остается ρ_A.

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

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

[Pipa]

Пипа, я только очень прошу Вас быть более внимательной, иначе мне тяжело, Вы пишите:

Ее редукция по A дает:

 5   11
11  15
(след = 5+15=30)

Очевидно, что 5+15 это не 30, я догадываюсь, что вместо 15 должно быть 25, но все же будьте повнимательней, в более сложных случаях мы просто запутаемся. И остальные цифры проверьте еще раз.

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

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

   Здесь я ничего не напутала - результат действительно таков.

Вы не стали нормировать на единицу? Наверное, пока это оправдано, так легче тестировать.

    Так тестировать сложнее, т.к. целые числа в пределах десятка я без труда складываю и умножаю в уме. А дробные числа гораздо менее наглядные и оперировть ими в уме сложнее.
    Программе же все равно что считать. А любая нормировка на a, b, c, d сразу же приведет к масштабированию всей матрицы. А поскольку данный алгоритм имеет дело только с суммированием, то очевидно что и для результа редуцирования сохранится тот же масштаб. Но если вы не верите, то я готова это проверить.

[Pipa]

Результаты тестирования на нормированных действительных значениях.

Значения a=1, b=2, c=3, d=4 после нормировки  - почленному делению на sqrt(a*a+b*b+c*c+d*d) - дают значения:
a=0.182574
b=0.365148
c=0.547723
d=0.730297

Отсюда получаем матрицу плотности:

0.0333 0.0667 0.1000 0.1333
0.0667 0.1333 0.2000 0.2667
0.1000 0.2000 0.3000 0.4000
0.1333 0.2667 0.4000 0.5333
(след = 1.0000)

Редукция по А дает (В - остается):

0.1667 0.3667
0.3667 0.8333
(след = 1.0000)

Редукция по B дает (A - остается):

0.3333 0.4667
0.4667 0.6667
(след = 1.0000)

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

P.S. Сделала вывод в файл. Числа теперь точные, а не рукотворные.

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

Здесь я ничего не напутала - результат действительно таков.

Не понял. Матрица ρ_A, которая равна:

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

для Вашего примера это

 5   11
11  25

Данная матрица – редукция по В, а не по А. Это ρ_A=Tr_B(ρ_AВ), когда берется частичный след по В.

[Pipa]

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

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

Почему? Сами матрицы правильные получаются, или дело не в терминологии? Можно пояснить?

[Pipa]

   Уже не в терминологии, а хуже. Я задаю процедуре offmask=1, требуя отредуцировать первый кубит (A), а получаю от нее результат редукции по В. И наоборот. Это порок алгоритма, а не терминологии.

[Pipa]

Матрица ρ_A, которая равна:

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

Никак это не получается .
Вставила трассировку вовнутрь алгоритма. Даю к ней комментарий.

Чтобы получить ρ_A делаю редукцию по B.
Передаю процедуре параметр offmask = 10 (бинарное), что означает редукцию по старшему кубиту – B. (У меня младший бит кода соответствует младшей букве алфавита: A=0001, B=0010, C=0100, D=1000 и т.д.)
 
offmask = 10

Программа вычисляет ему комплиментарный:

onmask =  01

что означает остающийся кубит A.

    Далее идет обход элементов исходной матрицы P[][].
«Element» - номер элемента исходной матрицы
«row» - двоичный код номера строки
«col» - двоичный код номера столбца
«row&onmask» - вырезка остающихся битов из номера строки
«col&onmask» - вырезка остающихся битов из номера столбца
«row&offmask» - вырезка редуцируемых битов из номера строки
«col&offmask» - вырезка редуцируемых битов из номера столбца

Совпадение «row&offmask» и «col&offmask» влечет за собой добавление данного элемента к результату (матрице R[][]) в ячейку, с номером строки «row&onmask» и номером столбца «col&onmask».
Везде в таблице, за исключением индексов в квадратных скобках, числа в двоичном формате.

Код:

Element row col row&onmask col&onmask row&offmask col&offmask
P[0][0]   00  00        00            00            00             00     R[0][0]+=P[0][0]=|a|2
P[0][1]   00  01        00            01            00             00     R[0][1]+=P[0][1]=ab*
P[0][2]   00  10        00            00            00             10
P[0][3]   00  11        00            01            00             10
P[1][0]   01  00        01            00            00             00     R[1][0]+=P[1][0]=ba*
P[1][1]   01  01        01            01            00             00     R[1][1]+=P[1][1]=|b|2
P[1][2]   01  10        01            00            00             10
P[1][3]   01  11        01            01            00             10
P[2][0]   10  00        00            00            10             00
P[2][1]   10  01        00            01            10             00
P[2][2]   10  10        00            00            10             10     R[0][0]+=P[2][2]=|c|2
P[2][3]   10  11        00            01            10             10     R[0][1]+=P[2][3]=cd*
P[3][0]   11  00        01            00            10             00
P[3][1]   11  01        01            01            10             00
P[3][2]   11  10        01            00            10             10     R[1][0]+=P[3][2]=dc*
P[3][3]   11  11        01            01            10             10     R[1][1]+=P[3][3]=|d|2

Получаю матрицу R[][]:

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

но она не такая, как требуется, а представляет собой редукцию по A, а не по B.

Теперь насчет общего алгоритма редуцирования. Поступаем следующим образом, если мы редуцируем, скажем пятикубитную систему ABCDE и оставляем кубиты AD, проводя редукцию по всем остальным (по ВСЕ), то перебираем все элементы 5-кубитной матрицы плотности и по их индексам в двоичной форме смотрим, что стоит на позициях ВСЕ, т.е. на второй, третьей и пятой позиции в проекторе. Например,

|11111><11111|

Я выделил то, на что нужно смотреть. Если в проекторе слева и справа есть полное совпадение, то этот элемент остается в редуцированной матрице AD и идет, в данном случае к элементам |11><11| (то, что не выделено жирным), таких элементов может получаться несколько, и они будут суммироваться, например,

|11011><11011|
или
|10010><10010|

Тоже пойдут к элементам |11><11| в матрице ρ_AD.

Если же в проекторе нет совпадения слева и справа, например,

|10011><11011|,

То этот элемент при редукции равен нулю, и он просто игнорируется.

У меня для элемента P[2][2]=|c|² двоичный код строки и столбца один и тот же - 10.

|10><10|

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

следовательно я должна принять его в редуцировнную матрицу. Так и появляется в ней слагаемое |c|² в левом углу матрицы.

Что в алгоритме не так? Помогите найти ошибку!

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

У меня для элемента P[2][2]=|c|2 двоичный код строки и столбца один и тот же - 10.

|10><10|

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

Для элемента |c|² проектор правильный, но редукцию Вы делаете по A, а не по В, ведь «вычеркивается» 1 (первый кубит), и остается 0? Это так? Должно быть наоборот – вычеркивается вторая позиция, т.е. 0, а первая остается.

Пока не совсем понял насчет нумерации, может в этом дело? Если Вы первому кубиту сопоставили букву В, то это не значит, что он им стал, ведь Вы не переходите к новому базису? Тогда нужно менять исходную матрицу, записывать ее в новом базисе, и элемент |c|² тогда будет |01><01|, т.е. при редукции он пойдет уже в нужное место. Или я что-то не так понимаю?

Если это так, то буквы нужно переобозначить, т.е. для 5 кубитов и EDCBA, необходимо при редукции E принимать за A, D – за В, и т.д. С учетом такого переобозначения, в примере для двух кубитов, тогда у Вас все правильно – букву А необходимо принимать за В.

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

[Pipa]

Пока не совсем понял насчет нумерации, может в этом дело?

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

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

Код:

ρ[i][j]

можно смотреть как на запись данного элемента в виде проектора, если под i и j понимать числа в двоичной системе счисления. Например, элемент ρ₂₃ для 5-кубитной системы это проектор вида |00010><00011|, т.е. 2 и 3 нужно записать в двоичной системе. Нумерация начинается с 0, как обычно в Си, т.е. самый первый элемент (в левом верхнем углу матрицы) ρ₀₀. В случае 5-кубитной системы матрица плотности имеет размер 32*32 и самый последний элемент ρ_31;31 (в правом нижнем углу). Число 31 в двоичной системе это как раз 11111, т.е. последний элемент в виде проектора записывается |11111><11111|.

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

Теперь насчет общего алгоритма редуцирования. Поступаем следующим образом, если мы редуцируем, скажем пятикубитную систему ABCDE и оставляем кубиты AD, проводя редукцию по всем остальным (по ВСЕ), то перебираем все элементы 5-кубитной матрицы плотности и по их индексам в двоичной форме смотрим, что стоит на позициях ВСЕ, т.е. на второй, третьей и пятой позиции в проекторе. Например,
|11111><11111|

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