Добро пожаловать, Гость. Пожалуйста, войдите или зарегистрируйтесь.

Новости:

Книгу С.Доронина "Квантовая магия" читать здесь
Материалы старого сайта "Физика Магии" доступны для просмотра здесь
О замеченных глюках просьба писать на почту quantmag@mail.ru

Меню навигации для мобильных

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

Автор С.И. Доронин, 24 марта 2007, 19:45:23

« предыдущая - следующая »

0 Пользователей и 3 гостей просматривают эту тему.

С.И. Доронин

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

Цитата: С.И. Доронин от 14 апреля 2007, 17:10:11
Поскольку редуцированная матрица это тоже матрица плотности, то все ее свойства должны иметь место, т.е. ее след будет равен единице, и она эрмитова (симметричная в вещественном случае). Это, естественно, когда в качестве исходной матрицы, тоже берется матрица плотности.
Тестирование можно начинать с самого простого случая, когда редуцируется чистое состояние двухкубитной системы и остается один кубит. Явный вид редуцированных матриц ρ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|2+|b|2    ac*+bd*
ca*+db*    |c|2+|d|2

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

С.И. Доронин

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

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

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

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

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

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


Pipa

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

Цитата: С.И. Доронин от 14 апреля 2007, 22:23:03
матрица плотности имеет вид:

|a|2    ab*    ac*    ad*
ba*    |b|2    bc*    bd*
ca*    cb*    |c|2    cd*
da*    db*    dc*    |d|2
Цитата: С.И. Доронин от 09 апреля 2007, 17:13:53
Если все проделать так, как я написал выше, то получим ρA, которая имеет вид:

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

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

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

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

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

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

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

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

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() «псевдоредуцированная» матрица размером 2N (где N – число кубитов, НЕподвергающихся редукции) может иметь полностью нулевые столбцы или строки, что могло бы потребовать ее дальнейшего сжатия.
Если вам кажется, что я не права, то предлагаю вам придумать такие a, b, c, d (за исключением тривиального случая, когда они все равны по нулям), чтобы в редуцированной матрице оказался полностью нулевой столбец или строка (на матрицах бОльшей размерности полностью нулевая строка или столбец тем более маловероятны).

С.И. Доронин

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

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

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

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

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

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

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


Pipa

Цитата: С.И. Доронин от 15 апреля 2007, 10:11:00
Пипа, я только очень прошу Вас быть более внимательной, иначе мне тяжело, Вы пишите:

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

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

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

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

Цитата: С.И. Доронин от 15 апреля 2007, 10:11:00
И с терминологией тоже давайте договоримся, – редукция по A, это когда A исчезает, а остается все остальное, в данном случае В, т.е. эта матрица, наоборот, редукция по B, когда остается ρA.

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

Цитата: С.И. Доронин от 15 апреля 2007, 10:11:00
Вы не стали нормировать на единицу? Наверное, пока это оправдано, так легче тестировать.

    Так тестировать сложнее, т.к. целые числа в пределах десятка я без труда складываю и умножаю в уме. А дробные числа гораздо менее наглядные и оперировть ими в уме сложнее.
    Программе же все равно что считать. А любая нормировка на 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|2+|b|2    ac*+bd*
ca*+db*    |c|2+|d|2

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

5   11
11  25

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


Pipa

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

С.И. Доронин

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

Pipa

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

Pipa

Цитата: С.И. Доронин от 15 апреля 2007, 11:17:19
Матрица ρA, которая равна:

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

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

Чтобы получить ρ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|2+|c|2    ab*+cd*
ba*+dc*    |b|2+|d|2

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

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

|11111><11111|

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

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

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

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

|10011><11011|,

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

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

|10><10|

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

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

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

С.И. Доронин


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

|10><10|

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

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

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

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

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


Pipa

Цитата: С.И. Доронин от 15 апреля 2007, 17:29:11
Пока не совсем понял насчет нумерации, может в этом дело?

    Я тоже этого не пойму.
Если посмотреть на матрицу плотности, то там кубит A находится ближе к левому верхнему углу (ρ00), а кубит с высоким номером/буквой находится ближе к нижнему краю диагонали.
    Отсюда следует, что с ростом индекса в матрице плотности растет и буква кубита. Значит, цифры и буквы возрастают в одном и том же направлении.
Вы пишите:
Цитата: С.И. Доронин от 09 апреля 2007, 17:13:53
Если простыми словами, то на любой элемент матрицы плотности ρ[i][j] можно смотреть как на запись данного элемента в виде проектора, если под i и j понимать числа в двоичной системе счисления. Например, элемент ρ23 для 5-кубитной системы это проектор вида |00010><00011|, т.е. 2 и 3 нужно записать в двоичной системе. Нумерация начинается с 0, как обычно в Си, т.е. самый первый элемент (в левом верхнем углу матрицы) ρ00. В случае 5-кубитной системы матрица плотности имеет размер 32*32 и самый последний элемент ρ31;31 (в правом нижнем углу). Число 31 в двоичной системе это как раз 11111, т.е. последний элемент в виде проектора записывается |11111><11111|.
С эти я полностью согласна. Но раз уж элемент ρ23 вы представили как |00010><00011|, то стало быть МЛАДШИЙ кубит А у вас СПРАВА. Т.е. если 2 это 00010, а 3 это 00011, то младший бит у вас СПРАВА, как у всех многозначных чисел. Значит, кубиты следуют в этой записи как EDCBA – младший справа. 00001 – это у нас «встал» кубит А, а 10000 – кубит E.
Но сразу же за этим вы пишите:
Цитата: С.И. Доронин от 09 апреля 2007, 17:13:53
Теперь насчет общего алгоритма редуцирования. Поступаем следующим образом, если мы редуцируем, скажем пятикубитную систему ABCDE и оставляем кубиты AD, проводя редукцию по всем остальным (по ВСЕ), то перебираем все элементы 5-кубитной матрицы плотности и по их индексам в двоичной форме смотрим, что стоит на позициях ВСЕ, т.е. на второй, третьей и пятой позиции в проекторе. Например,
|11111><11111|
Отсюда видно, что 2-ю, 3-ю и 5-ю позиции вы подчеркнули начиная с ЛЕВОГО края, т.е. перешли в систему записи, когда младшая цифра находится слева. Т.е. в этой записи биты следуют уже не в двоичном порядке, а в строковом, когда буквы пишут слева направо – ABCDE.
    Такое смешение создало путаницу в вашем объяснении: говоря о индексе вы пользуетесь двоичным представлением чисел (у которых младший разряд находится справа), а при вычеркивании позиций перешли в алфавитную последовательность ADCDE, в которой младшмй кубит находится уже слева.