Ai Forums Home Welcome Guest    Monday, April 24, 2017
Ai Site > Ai Forums > The Artificial Intelligence Forum > quantum computers are just a theory ... Last PostsLoginRegisterWhy Register
Topic: quantum computers are just a theory trick

rouncer
posted 5/6/2016  04:39Send e-mail to userReply with quote
I was thinking quantum computers are just a trick - and u just run them on your pc.


So... can u process a whole lot of logic gates, in a count???

a) you have all symantics separated - they are only grouped with themselves.
b) the computers malfunction if they ever communicate outside their group!
c) ur a supposed to have different states at once, but u dont care really
which one is holding the value. but it has to be in a definite group,
the actual computer is imaginary.
d) so u dont know which ones dont pass the and test, but so many do, and so many dont,
but if it works it doesnt matter, just so many pass, and so many fail.

free energy parallel computers - but the problem is, theres not enough ram for them.

if one failed, itll then show through on the next sum - when you pass through the next
gate, then that one that failed, will show another failure?

all bits are kept separate, so u have an exact count of every separate symantic.


so u dont need this chain extraction - all u do is generate so many computers out of
the group, and ull get the exact proportion of all the states?

when i have an int - i can process 2^32 bits at once, through the same operation,
if i keep how many passed, and how many fail.


so i have so many computers with this on, and so many with this on. but what about
the exact combination of them????


you keep every bit separate.


an int is 2^32 computers at once - each controlling a bit!


a=1000&b=300 = c=300.

when i bring the computer back, i have 300 computers with c being 1, and a heap with it being 0.

but??? it cant be that simple, because i dont know which ones which!

so when i bring the symantics back, i dont know what symantic goes with what symantic.


ok smarty, how do i bring back a picture then?

ive got 1000 reds, and 1000 greens. but which ones got green next to red, and which ones
got red next to red.



now by all that previous HARD!!! thinking - u store log(2^32)*4 x sizeofram x sizeof(int)

and thats supposed to help, because you bring it back in ngrams.
but u said you could keep an absolute state, and even recirculate it, but maybe thats wrong.

the difference is, i dont just keep 1 group - i keep a team of groups, that work independantly.
a+b=c in one hit, is like doing it with just 1 processor.

but what if it doesnt help?

it actually repeats its computations along the team, and it has more truth tables to saturate
to work, so its all alot bigger, but is it any better?


cause ur passing a compound key through addresses!!!!!

well apart from the fact that your input is conflicting to hell and your output is overblown
to absolute shithouse it really works!!



i just add the whole lot up, and then apply it to the symantic. but its actually just setting
it, if it were a previous value, it would be overwritten! so if you have the absolute state,
then i think you pick the max out of the two????

but you gotta remember, that we are pretending we are splitting it up, and then recombining it,
but we are just cheating.




so get the absolute count of how many times that symantic was changed, but which computer
was it?

so thats why i actually do it on many, cause im going to try and work it out in a group.


so if i add it to 0. but i also add it to another one, then i have another clue for which
computer it is!

so if i have it changing on both, then its the minimum.

are u saying its the minimum of all the changes of all the bins- for the whole addressing.
but that isnt actually it.


min(1000,300)=300 a&b=c

the state of the computer for each bit, is the minimum of all its bins, but thats just an
approximation!!!

because that would have to be 1, if it were just the one computer.


so u know the total bits, is computers/2. and the actual amount, is 1.

if ur getting the derivative, youve got more chance, but its still not going to be there as
a 0- if there is too many computers.


i cant just go take 1 from each one, and make the state for each computer, because ill screw
up its collected ram. but it is nicely separated! just not separated enough.


if u have enough bins, its like ngrams! that eventually if you find the 0, you gamble for it!

because its only an exact match! each bit is separate, but theres only so many total bins for
the bit, so you have to have enough bins to fluke finding it when its set to 0. using the
address of the state, onto the bins, to pick the minimum.



0 <- i start here, looking for the bit.

1 <- i start here, looking for the bit.

so i get some probability of it being a 1 or a 0, from the fact my 100% is 2^computers/2

then i can extract all the states, or just look for one. so if i want one state, i then take
that probability, and then apply it again, on the next bin, where i dont even need a ngram!

i just pick the exact bin in a row. but maybe i do, if i want to chain them.

so i multiply the bins together, and i get the total probability of it being a 1 or 0, and then
i do it stochasticly???

so i make two sums, and then i pick out of the two randomly using the distribution between 1 and 0.

so if im 2^computers/2 then i add count to 1, and 2^computers/2-count to 0.

and then i just see what i get???

but think, that wouldnt work, because that would just give me noise! but i do have a different
group set each time???

u could just pick it determined using the max out of the 2 counts, would probably be better, but
not as cool lookin, if it worked.


do you random hash the group? maybe it doesnt make a difference.

if i overlap them, then i get a more closer description to the computer i want in the probabilities.


maybe its allowed to be non exact???


doing the derivative straight out of the filter and keeping it all separate is much easier!!!

its got to be, because its got to have more 0's in it! its only if all the computers change
the same number, it wont find it.


x16 is not good stuff, especially for a beginner computer maker.

3!

01010101010101 x2
2 x4
3 x16
4 x64 <-if u dont have it now, change what your doing.

but dont you just get the minimum???
ur trying to find the 0!!!

but i can get the minimum of all the states, and its an approximation.
then when i get the approximation, i then reapply it, then i find it again!

maybe it goes lower, but you never even find one more.

you could take the original value, find all the minimums reapply the value, and then use
this as a probability for 1 and 0????


so i get the minimum, but unfortunately ud think it would start compounding,

like i find one zero, then i find another???


it means some of the bits have to be 0 in the groups, or it wont work, and it has to be on
a single bit, cause you find each bit one at a time.


but it has to be a 0 of a whole group, so its doubtful.

ur finding each bit. if alot of computers set it, there is no 0.

u have to find the exact state, so there has to be a whole group, that didnt set it, for u
to find that its a 0.

otherwise your just randomizing.


0 <- 01 <- 01
00 00
10
11

1 <- 10 <- 01
11 00
10
11

that i gone triangular subtraction!!!! then we all 1's and 0's.



rouncer
posted 5/6/2016  05:44Send e-mail to userReply with quote
log(greedy)*2.
total ram required->((ramwanted*log(greedy)*2)^2)*log(greedy)*2.
(so thats your null ram - linear separation of the quantum state.)

AND you actually have to offset them to a different symantic - and u copy everything to
A COMPLETELY DIFFERENT symantic. SO MAKE SURE NO LOGIC GATES BETWEEN LOG COMPUTERS TOUCH
EACH OTHERS BITS.

the only time, you have to regenerate the state, is if they ever read from each other!!!

dont get too excited about it, theres got to be a fucking horrible limit on what
one can squeeze out of linear to get exponential. just remember that.

thats what the sad turing flute means. (then ol' quantum dies....)

i reckon ull get a million processors tho!!! especially with a separate quantum state per log
computer!!!

and then you can go bust out your big killer egg robot - 4 sure!
and ull hit the practical limit for monocular terrapixel highspeed 3d cameras, all by yourself!!!


---------------------------------------------------------------------------------------

its still hell, the crawl up to a million is 40, so if its a programmable router with
near neighbour, you want to quantize, then its a shiteload of puny little 1e caps, thats 4 sure.

it aint easy, and its fuckin big dude. but if you really want your pentillian
near-neighbour queries in a second you go to such troubles.

---------------------------------------------------------------------------------------


  1  
'Send Send email to user    Reply with quote Reply with quote    Edit message Edit message

Forums Home    Hal and other child machines    Alan and other chatbots    Language Mind and Consciousness  
Contact Us Terms of Use