Forum Coders' city Strona Główna Coders' city
Nasza pasja to programowanie!
 

 PomocPomoc   SzukajSzukaj   UżytkownicyUżytkownicy   GrupyGrupy  RejestracjaRejestracja 
Archiwum starego forum + teoria    RSS & Panel/SideBar
 ProfilProfil   Zaloguj się, by sprawdzić wiadomościZaloguj się, by sprawdzić wiadomości   ZalogujZaloguj 

Potrzebuję szybkiej odpowiedzi na moje pytanie... Zasady

kubit stochastyczny... co Wy na to ??

Idź do strony 1, 2, 3, 4  Następny

 
Odpowiedz do tematu    Forum Coders' city Strona Główna -> Algorytmy + inżynieria oprogramowania
Zobacz poprzedni temat :: Zobacz następny temat  
Autor Wiadomość
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Nie Kwi 08, 2018 11:30 am  OP    Temat postu: kubit stochastyczny... co Wy na to ?? Odpowiedz z cytatem Pisownia

Hej,
mam pomysła, być może głupi, ale tematyka mechaniki kwantowej, jak i informatyki kwantowej interesuje mnie od dłuższego czasu... ale nie znam się na tym dobrze, więc każda uwaga cenna:

w mechanice kwantowej ważny jest objekt tzw. kubitu (uogólnienie bitu, może przyjmować wartości inne niż 0, 1), ale definicja jest postawiona na bazie analizy zespolonej... zastanawiam się czy nie da się podać definicji czysto stochastycznej (probabilistycznej), aby traktować kubit jako zmienną losową, czyli najprostszy dwulementowy kubit byłby to objekt postaci:
Kod:

a * |0> + b * |1>, gdzie a+b=1, a, b nieujemne...


no i ten objekt można próbować analizować... tworzyć nawet jakieś bramki kwantowo-stochastyczne, itd... skąd się wziął pomysł... ?? to długa droga... ale pomogło mi skojarzenie m. in. standardowej logki z logiką rozmytą, coś trułem kiedyś na ten temat ciut... ^^

Natomiast ciekawy jest (???) pomysł kodowania liczby dla takiego stochastycznego kubitu... tylko pytanie czy to ma sens, i dałoby się to w ogóle zaimplementować... ???

Podam jeden przykład, rozmważmy kubit postaci
Kod:

a0 * |1> + a1 * |2> + a2 * |4> + ... + an * |2^n>


dla ustalonego n, odpowiednio dużego...

Załóżmy, że chcemy zakodować liczbę 2018... szukamy max m dla którego 2^m < 2018, czyli m = 10, czyli wartość 2018 się mieści między elementem |1024>, a elementem |2048>... następnie szukamy parametru c, dla którego
Kod:

c * |1024> + (1-c) * |2048> = 2018


okazuje się, że c = 30/1024, i wystarczy wykonać same odejmowania... ^^

Jakie są plusy ?? do kodowania liczby np. o 100000 bitach skupiamy się tylko na dwóch elementach tego kubitu... pojawiają się oczywiście pytania, jak to zaimplementować, o ile to możliwe... no, i jak magazynować dane... ?? bo tutaj ciągów zerojedynkowych raczej niet... ^^ co Wy na to... ?? ^^

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Pią Kwi 13, 2018 11:54 am  OP    Temat postu: Odpowiedz z cytatem Pisownia

Kompresja Tekstu i Struktury Danych… wstępne spostrzeżenia... (sorki, że tak nawijam, ale chcę przekazać swoje przemyślenia, dopóki mam jeszcze siłę)...

Mając kubit, powiedzmy

Kod:

a1 * |A> + a2 * |Z>



możemy zakodować każdą literkę używając tego kubitu…

Natomiast mam propozycję kodowania tekstu (jego kompresji, jest taka, nie wiem czy sensowna):

dzielimy tekst na kawałki, powiedzmy stuelementowe (długości kawałków trzeba jakoś dobierać do kodowanego tekstu) i tworzymy słownik przechowujący pozycje literek, wystarczy w sumie tablicę, przechowującą pozycje elementów w tekście… plus jest taki, że aby się dobrać do końcowej części tekstu, nie trzeba przechodzić przez cały tekst, ani go magazynować całego w pamięci… co więcej, być może tak też warto jakoś magazynować i tworzyć struktury danych, aby np. Technika MapReduce w systemach przetwarzania równoległego danych nie musiała naraz przeszukiwać wszystkich zasobów… (!!!)… Ale to temat chyba raczej trudny… wydaje mi się, że bardzo ważne w tego typu zagadnieniach są odpowiednie struktury danych, być może słowniki, jakieś struktury grafowe oraz być może jakieś mapy hashujące, przerabiające dane we wstępnych fazach gromadzenia danych i porządkujące je w jakąś sensowną całość umożliwiającą szybsze wyszukiwanie… (!!!)
____________________________________________________________
Przykładowy kod w Pythonie:

Kod:

a = "asdfgjkk asdghjkhsa asdfhjfs afsekvvnnjccb"
a = 100 * a
V = {}

al = len(a)
ile = 50
a5 = al // 50
lista = []
for j in range(a5+1):
    w = a[ile*j:ile*j+ile]
    V = {}      
    for i in range(len(w)):
        x = w[i]
        if x in V.keys():
            V[x].append(i)
        else:
            V[x] = [i]
    lista.append(V)

print(lista)



Te uwagi mogą być istotne nie tylko przy ujęciu kubitowym…


Natomiast jak mogłaby wyglądać baza danych w rozproszonym (celowo nie piszę równoległym !!!) ujęciu kubitowym… ??

Wstępny szkic (prosty przykład):

Załóżmy, że chcemy mieć bazę gromadzącą słowa: PEACE, WAR, WAR, PEACE, LOVE, LOVE, LOVE, PEACE, WAR, LOVE

Tworzymy kubitową sieć komputerów:

Kod:

a1 * |P> + a2 * |L> + a3 * |W>



gromadzimy dane tak:

Kod:

|P>: PEACE, PEACE, PEACE
|W>: WAR, WAR, WAR
|L>: LOVE, LOVE, LOVE, LOVE



I teraz… Aby zliczyć ilość słów PEACE w naszej (teoretycznej) bazie danych używając techniki MapReduce… musielibyśmy przeglądać wszystkie zasoby, tak mi się przynajmniej wydaje… natomiast w tak postawionej definicji skupialibyśmy się na „tylko” na elemencie „P” tak utworzonej sieci… Myślę, że to ważne spostrzeżenie… zamiast tworzyć pliki gromadzące danych po różnych serwerach… lepiej chyba umieszczać dane po różnych serwerach według jakiegoś klucza (reguły segregującej dane)…

Wniosek
Zamiast jednolitej struktury danych warto się zastanowić nad rozproszoną strukturą danych… Nie wiem czy takie pojęcie istnieje...
____________________________________________________________
Ciut bardziej skomplikowana struktura (np. dla książki telefonicznej):
Kod:

a1 * |A, B, C> + a2 * |D, E, F> + a3 * |G, H, I>…


i dalej idąc element |A, B, C> jest także kubitem, np. postaci:
Kod:

b1 * |A> + b2 * |B> + b3 * |C>


Natomiast można iść ciut dalej i przedstawić element |A> np. jako kubit taki:
Kod:

a1 * |A>|A, B, C> + a2 * |A>|D, E, F> + a3 * |A>|G, H, I> + …


gdzie element |A>|A, B, C> gromadziłby dane książki telefonicznej z przedrostkami „AA”, „AB”, AC”
Wniosek (z powyższego przykładu dotyczącego książki telefonicznej): zamiast techniki obliczania równoległego może warto zastanowić się nad strukturą grafową obliczeń w wersji rozproszonej…

____________________________________________________________
Generalnie: temat rzeka…
Cel: tworzenie (lub próba tworzenia) optymalnych struktur danych…

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Sob Kwi 14, 2018 9:33 am  OP    Temat postu: Odpowiedz z cytatem Pisownia

Dodawanie i Mnożenie stochastycznych kubitów...

Załóżmy, że chcemy dodać liczby 15 i 31... W układzie kubitów:

Kod:

a1 * |1> + a2 * |2> +a3 * |4> + a4 * |8> + ...



Przedstawiamy 15 jako

Kod:

7/8 * |16> + 1/8 * |8>



oraz 31 jako:

Kod:

15/16 * |32> + 1/16 * |16>



Okazuje się, że można zaprezentować te liczby np. tak:

Kod:

15 ~ [0, 0, 7, 1, 0, 0, 0]
31 ~ [0, 15, 1, 0, 0, 0, 0]



A może lepiej wykonywać obliczenia wykorzystując współczynniki kubitu... ??

I w takiej sytuacji dodaje się dość prosto, otrzymując:

Kod:

[0, 15, 16, 0, 0, 0, 0]


A po przesunięciu w lewo o jeden otrzymujemy:
Kod:

[15, 16, 0, 0, 0, 0, 0]


Ponieważ 15+16 < 32, stąd musimy bity nieco zmienić i dostajemy układ:
Kod:

[14, 18, 0, 0, 0, 0, 0]


co odpowiada liczbie w ujęciu kubitowym:
Kod:

14/32 * |64> + 18/32 * |32>


co odpowiada stochastycznemu ujęciu liczby 465, co jest raczej zgodne z rzeczywistością... :)

Spróbujmy wymnożyć te liczby... Mając reprezentację liczb 15 i 31 w postaci:

Kod:

15 ~ [0, 0, 0, 0, 0, 0, 7, 1, 0, 0, 0]
31 ~ [0, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0]


Po wymnożeniu standardowym współczynników mamy:

(w wykonywaniu mnożenia być może warto rekurencyjnie wywoływać mnożenie w ujęciu kubitowym, lub trzymać w słowniku zestaw odpowiednich, podręcznych, iloczynów, komentarz na końcu tych wypocin)...
Kod:

[0, 105, 22, 1, 0, 0, 0, 0, 0, 0, 0]


I przesuwamy o 1 miejsce w lewo, odpowiednio zwiększając i transformując współczynniki:
Kod:

[210, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0]


Ponieważ 210 + 45 < 256 dokonujemy zmiany współczynników na:
Kod:

[209, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0]


otrzymując kubitowe przedstawienie liczby w postaci:
Kod:

209/256 * |512> + 47/256 * |256>


co odpowiada liczbie 465... :)

Przykładowy kod w Pythonie dla dodawania (mogą być błędy, i na pewno da się go uprościć)… procedurka dla mnożenia jest podobna, ale ciut bardziej skomplikowana...
Kod:

import math

def dodaj_us_kubit(a, b):
    if b < a:
        a, b = b, a
    n1 = math.log(a, 2)
    n = int(n1)
    if n != n1:
        n += 1
    m1 = math.log(b, 2)
    m = int(m1)
    if m != m1:
        m += 1
    x = 2 + max(m, n)    
    aa = [0 for i in range(x+1)]
    bb = [0 for i in range(x+1)]

    aa[x-n] = 2**n - a
    aa[x-n-1] = 2**(n-1) - aa[x-n]
    bb[x-m] = 2**m - b
    bb[x-m-1] = 2**(m-1) - bb[x-m]
    if a == b:
        bb[x-m-1] *= 2
        bb[x-m] *= 2
    else:
        bb[x-m] += 2 * aa[x-n-1] + aa[x-n]
  
    while bb[x-m] + bb[x-m-1] != 2**m:
        if bb[x-m] + bb[x-m-1] < 2**m:
            bb[x-m-1] -= 1
            bb[x-m] += 2
        else:
            bb[x-m-1] += 1
            bb[x-m] -= 2
    return 2*bb[x-m-1]+bb[x-m]

print(dodaj_us_kubit(15, 31))



Z odejmowaniem raczej nie powinno być problemu... Problem pojawia się chyba z dzieleniem, na razie nie mam pomysły jak to ugryźć...

Natomiast warto ciut czasu spędzić nad potęgowaniem... Aby podnieść liczbe 2 do 31 potęgi wykonujemy 30 mnożeń; umiejętnie przedstawiając wykładnik można tę liczbę znacznie zmniejszyć... Nie mam pojęcia, czy da się wykonać jakieś kubitowe potęgowanie, pewnie się nie da... ale można znacznie zmniejszyć ilość mnożeń w wersji kubitowej...

Otóż:
Kod:

31 = 2^4 + 2^3 + 2^2 + 2 + 1


Korzystając z tej własności mamy:
Kod:

2^19 = (((2^2)^2)^2^2) * ((2^2)^2^2) * (2^2)^2 * 2^2 * 2


I wtedy wykonujemy tylko 14 mnożeń, a w zasadzie, jeżeli pamiętamy wyniki, to wystarczy tylko wykonać 8 mnożeń, o ile się nie pomyliłem... ^^

Jeszcze jedna uwaga...
Aby komputer nie powielał wielu obliczeń powinniśmy w nim trzymać w jakimś słowniku najczęściej pojawiające się działania, aby za każdym razem nie powielać obliczeń... Czyli np. słownik mógłby zawierać wyniki wszystkie potęgi dwójki np. do n=10000 i przechowywać je w odpowiednim miejscu... następnie wszystkie iloczyny typu a * b, dla a, b < 10000, a, b naturalne... Wtedy dostęp do wyniku byłby z czasem O(1), o ile się dobrze orientuję...

Na razie tyle... :)

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Sob Kwi 14, 2018 3:52 pm  OP    Temat postu: Odpowiedz z cytatem Pisownia

Dzielenie (jednak się udało, może ma to sens ??), trochę niestandardowo... Spróbujmy podzielić liczby 169 oraz 13... Przedstawiamy liczbę 169 w postaci kubitowej:
Kod:

87/128 * |128> + 41/128 * |256>


oraz liczbę 13:
Kod:

13 = 3/8 * |8> + 5/8 * |16>


Liczba 13 leży w kubicie
Kod:

a * |8 > + b * |16>


więc na pewno jest mniejsza od 16... dla a = 0, b = 1... Następnie
dzielimy liczbę 169 w wersji kubitowej przez |16> otrzymując:
Kod:

87/128 * |8> + 41/128 * |16>


Ta liczba (niekoniecznie całkowita) jest w kubicie:
Kod:

a * |8 > + b * |16>


Uruchamiamy następną procedurę wyszukiwania liczby wykorzystując
mnożenie kubitowe (!) oraz, aby przyspieszyć wyszukiwanie, metodę
bisekcji... Szkic algorytmu (wykorzystujemy funkcję mnożenia liczb
w wersji kubitowej pomnoz_liczby(a, b)):
Kod:

a = 8 (dolna granica kubitu wyniku)
b = 16 (górna granica kubitu wyniku)
dzielna = 169
dzielnik = 13
while 1:
    x = int(a/2 + b/2)
    s = pomnoz_liczby(x, dzielnik)
    if s == dzielna:
        return x
    elif a == b:
        return "no solution"
    elif s > dzielna:
        b = x
    else:
        a = x


Ta procedura działa dla liczb całkowitych, ale ze względu na metodę bisekcji można tę metodę także stosować dla liczb niecałkowitych... z dowolną dokładnością... szybkość działania, wykładnicza...
___________________________________________________________________________

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Sob Kwi 14, 2018 5:00 pm  OP    Temat postu: Odpowiedz z cytatem Pisownia

Hmmm... pracowity dzień... Uzyskałem jakiś odpowiednik algorytmu Shora (ale być może to zbyt duże słowo, dopuszczam możliwość, że to zwykły Sheet, ale całość moim zdaniem trzyma się... no wiecie czego się trzyma)...

Idea rozkładu iloczynu liczb pierwszych w ujęciu kubitowym…

Załóżmy, że mamy liczbę 290123…

1. Obliczamy pierwiastek z tej liczby, jest równy ~540…
2. wypisujemy tablicę liczb pierwszych mniejszych od 540…

Kod:

a = [2 3 5 7 11 13 17 19 23 ... 79 83 89 97 101 103 ... 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 ... 503 509 521 523]



Następnie zapisujemy liczbę 290123 w wersji kubitowej:
Kod:

a*|2^18> + b*|2^19>


Współczynniki tak naprawdę… nie są potrzebne... !!! I teraz dla każdej liczby pierwszej z tablicy wykonujemy następującą procedurę…

Na przykładzie np. liczby 223 (jedna z liczb w rozkładzie)…

Zapisujemy liczbę 223 w wersji kubitowej:
Kod:

33/128 * |128 > + 95/128 * |256>


I następnie wykonujemy procedurę dzielenia kubitowego… Zgodnie z poprzednim wpisem… Czyli dzielimy 2^18 przez 2^7 i szukamy rozwiązania w kubicie:
Kod:

a * |2^11> + (1-a) * |2^12>


I tak naprawdę dopiero po znalezieniu rozwiązania całkowitego, sprawdzamy czy to rozwiązanie jest liczbą pierwszą… jeżeli jest, to OK… jeżeli nie, procedura jest przerywana… ponieważ mielibyśmy w takim razie liczbę będącą iloczynem co najmniej trzech liczb pierwszych… ^^

________________________________________
Chyba wyczerpałem na razie temat... ^^
________________________________________

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
karolinavb
Site Admin


Dołączył: 25 Maj 2005
Posty: 7905

PostWysłany: Nie Kwi 15, 2018 7:29 pm      Temat postu: Odpowiedz z cytatem Pisownia

Cytat:
Chyba wyczerpałem na razie temat...
Ja jednak będę dalej czekała z zapartym tchem ;-)) na dalsze Twoje rozważania.
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Pon Kwi 16, 2018 5:12 am  OP    Temat postu: Odpowiedz z cytatem Pisownia

miło, że ktoś to czyta... :) muszę trochę odpocząć, ciutkę ochłonąć... i ogarnąć to wszystko... to wersja robocza, nazwijmy ją on-line... jest bardzo dużo pytań, wątpliwości, itd., temat jest świeży jak w bułeczki w piekarni, ale jest to efekt wieloletnich przemyśleń, kursów on-line, i działalności programistycznej, także na tym forum... dzisiaj może wrzucę implementację mnożenia... samo kodowanie raczej nie jest trudne w podstawowej, klasycznej, wersji... pozdrawiam... :)
_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Pon Kwi 16, 2018 11:21 am  OP    Temat postu: Odpowiedz z cytatem Pisownia

a to wpis dedykowany karolinie, tej vb... :)

Mając kubit, najprostszy kubit:
Kod:

a1 * |0> + a2 * |1>


można zauważyć, że przyjmuje on wartości między zerem, a jeden, o ile założymy, że |0> jest zwykłym zerem, a |1> zwykłą jedynką... natomiast, jeżeli 0 będziemy interpretować jako wartość logiczną FALSE, a 1 jako TRUE... to wtedy dostaniemy wszystkie wartości pośrednie między TRUE, a FALSE... czyli mamy prezentację logiki rozmytej na podstawie najprostszego kubitu... ten kubit można także interpretować jako prosty model sterownika rozmytego... na razie tyle w tematyce, nazwijmy ją rozmytą... :)

PS1. ale to tylko idea, w tematykę AI raczej nie planuję wchodzić, raczej interesują mnie deterministyczne rozwiązania, ewentualnie jakieś stochastyczne symulacje... ale można chyba systemy AI modelować w tym ujęciu, o ile ktoś będzie miał taką potrzebę...
PS2. jak się wyrobię to jeszcze dzisiaj kod mnożenia w moim (chyba ulubionym) języku programowania...

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Wto Kwi 17, 2018 10:53 am  OP    Temat postu: Odpowiedz z cytatem Pisownia

no i obiecane mnożenie, w prostej wersji...
Kod:

def multi_kubit(a, b):
    if b < a:
        a, b = b, a
    n1 = math.log(a, 2)
    n = int(n1)
    if n != n1:
        n += 1
    m1 = math.log(b, 2)
    m = int(m1)
    if m != m1:
        m += 1
    x = 2 + max(m, n)    
    aa = [0 for i in range(x+1)]
    bb = [0 for i in range(x+1)]

    aa[x-n] = 2**n - a
    aa[x-n-1] = 2**(n-1) - aa[x-n]
    bb[x-m] = 2**m - b
    bb[x-m-1] = 2**(m-1) - bb[x-m]

    aabb = [0 for i in range(2*x+2)]
    aabb[2*x-m-n-2] = aa[x-n-1]*bb[x-m-1]
    aabb[2*x-m-n-1] = aa[x-n-1]*bb[x-m]+aa[x-n]*bb[x-m-1]
    aabb[2*x-m-n] = aa[x-n]*bb[x-m]
    return 4*aabb[2*x-m-n-2]+2*aabb[2*x-m-n-1] + aabb[2*x-m-n]


Pojawia się oczywiście naturalny problem dużych współczynników dla odpowiednio dużych n... Zastanawiałem się, czy wtedy nie dzielić tych wielkich kubitów na jakieś podkubity... tylko pytanie jak... Następna idea, to może praca na współczynnikach postaci kubitowej danej liczby... tylko jest jeden problem... możemy tracić dokładność przy zaokrągleniach...

Druga idea to tworzenie kubitów bardziej równomiernych... no, ale wtedy tracilibyśmy własność eksponencjalności kubitu... Także pomysł jest... Pytanie czy da się to efektywnie, i lepiej kodować...

_____________________________________________________________________________________________________

Skąd sie wzięła idea... ?? Od paru lat interesuje mnie ciut Mechanika Kwantowa... i zakakujące jest dla mnie to, że jest opisana "urojonym" aparatem matematycznym, a my chyba żyjemy w Świecie Trójwymiarowo-Rzeczywistym... a ponieważ pojawiają się tam prawdopodobieństwa, zacząłem się zastanawiać, czy nie da się tego opisać probabilistycznie... Oczywiście ten temat na razie jest dla mnie za trudny, i to zdecydowanie... Natomiast zacząłem podchodzić do tematu od ciut innej strony... Otóż... Mamy Komputery Kwantowe, które teoretycznie (i chyba nawet już co nieco praktycznie) mają przynieść nową jakość szybkości w obliczaniu... Natomiast pojawiają się problemy z tworzeniem struktur (procesorów) kwantowych ze względu, m. in. na "ujarzmieniu" odpowiednich struktur fizycznych tak, aby pracowały zgodnie z oczekiwaniem... No i zastanawiam się czy nie dałoby się zasymulować zachowania się Komputera Kwantowego przy użyciu procesora działającego na zasadach probabilistycznych (jakieś metody stochastyczne, metody mechaniki statystycznej lub może ten kubt, a uj wie)... czyli w skrócie: rozglądam się za metodami, które umożliwiłyby stworzenie procesora działającego podobnie jak kwantowy, ale w oparciu o metody deterministyczno-stochastyczne... natomiast nie znam kompletnie metod tworzenia komputera kwantowego... więc moje ujęcie może być ciut lamerskie, na razie to wszystko co mam do powiedzenia na ten temat... Miłego Czytania... i ewentualnego analizowania...
_____________________________________________________________________________________________________

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
hurgadion



Dołączył: 06 Kwi 2011
Posty: 853
Skąd: Web :)

PostWysłany: Wto Kwi 17, 2018 7:57 pm  OP    Temat postu: Odpowiedz z cytatem Pisownia

i kolejny odcinek... da się trochę przyspieszyć działanie mnożenia w ujęciu kubitowym na następującej zasadzie...

1. V[i]=2**i
2. W[i]= V[i]+V[i-1]

Jeżeli chcemy pomnożyć liczby a, b wykonujemy następujące kroki:

1. obliczamy n = int(log(a, 2)) oraz m = int(log(b, 2))
2 przedstawiamy liczby w postaci:
Kod:

a = V[n] + ra
b = V[m] + rb


jeżeli ra > V[n-1] zastępujemy ra = ra1+V[n-1] otrzymując:
Kod:

a = W[n]+ra1


podobnie postępujemy z b... Następnie wykonujemy mnożenie:
Kod:

a * b = W[n] * V[m] + W[n] * rb + V[n] * ra1 + rb * ra1


gdzie odpowiednie mnożenia wykonujemy rekurencyjnie... natomiast łatwo zauważyć, że:
Kod:

W[n] * V[m] = W[n+m]


Takie ujęcie mnożenia umożliwia zapisanie liczby będącej w kubicie (przedziale [2^n, 2^{n+1}]) tak, aby wykorzystać środek ciężkości kubitu (tutaj środek przedziału) do obliczeń...

Kod:
Kod:

import math
import sys

sys.setrecursionlimit(1000000)
V={}
W={}
W[0]=1
for i in range(-1,1000):
    V[i] = 2**i
    if i>0:
        W[i] = V[i]+V[i-1]


def d(x, rx, t):
    if rx <= 0:
        return 0
    xx = int(math.log(rx, 2))
    ry = rx - V[xx]
    rxbool = ry < V[xx-1]
    
    if rxbool:
        if t==1:
            return V[x]*V[xx] + d(x, ry, 1)
            ## V[x]*V[xx] = V[x+xx]
        else:
            return W[x]*V[xx] + d(x, ry, 0)
            ## W[x]*V[xx] = W[x+xx]
    else:
        if t==1:
            return V[x+xx] + d(x, ry, 1)
        
        else:
            return W[x] * W[xx] + d(x, ry-V[xx-1], 0)
            ## W[x] * W[xx] = V[x*xx]+V[m+n-1]+W[m+n-1]
    
def f(a, b):
    if a * b < 100:
        return a * b
    x = int(math.log(a, 2))
    y = int(math.log(b, 2))
    rx = a - V[x]
    ry = b - V[y]
    rxbool = rx < V[x-1]
    rybool = ry < V[y-1]
    if rxbool and rybool:
        return V[x+y] + d(x, ry, 1) + d(y, rx, 1) + f(rx, ry)
    elif not rxbool and rybool:
        return W[x]*V[y] + d(x, ry, 0) + d(y, rx-V[x-1], 1) + f(rx-V[x-1], ry)    
    elif rxbool and not rybool:      
        return V[x]*W[y] + d(x, ry-V[y-1], 1) + d(y, rx, 0) + f(rx, ry-V[y-1])
    else:
        return W[x]*W[y] + d(x, ry-V[y-1], 0) + d(y, rx-V[x-1], 0) + f(rx-V[x-1], ry-V[y-1])
    

print(f(129, 129))


__________________________________

_________________
miasto nauki praktycznej
Powrót do góry
Zobacz profil autora Wyślij prywatną wiadomość Odwiedź stronę autora Numer GG
Wyświetl posty z ostatnich:   
Odpowiedz do tematu    Forum Coders' city Strona Główna -> Algorytmy + inżynieria oprogramowania Wszystkie czasy w strefie CET (Europa)
Idź do strony 1, 2, 3, 4  Następny
Strona 1 z 4

 
Skocz do:  
Możesz pisać nowe tematy
Możesz odpowiadać w tematach
Nie możesz zmieniać swoich postów
Nie możesz usuwać swoich postów
Nie możesz głosować w ankietach
Możesz dodawać załączniki na tym forum
Możesz pobierać pliki z tego forum




Debug: strone wygenerowano w 0.13235 sekund, zapytan = 11
contact

| Darmowe programy i porady Jelcyna | Tansze zakupy w Helionie | MS Office Blog |