00:14:46 <ihope> It's not cheating to use constant inputs and outputs, right? :-)
01:08:32 -!- GregorR-W has quit ("And the workday finally comes to an end.").
01:12:13 <ihope> So what's half a NOT gate, I wonder...
01:15:31 <ihope> Must be HVH.
01:19:34 <ihope> And HVH sure is a doozy.
01:27:54 <ihope> Hey: for once I can say I did some fancy quantum stuff to obtain some weird result and I'd actually be right!
02:30:04 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
03:35:50 <pikhq> ihope: My Brainfuck code.
03:37:10 <GregorR> You hope your Brainfuck code what? ;)
04:25:09 -!- Sgeo has joined.
04:55:35 -!- Sgeo has quit ("Ex-Chat").
05:05:26 -!- GregorR has quit (brown.freenode.net irc.freenode.net).
05:05:27 -!- mtve has quit (brown.freenode.net irc.freenode.net).
05:05:30 -!- sp3tt has quit (brown.freenode.net irc.freenode.net).
05:16:15 -!- clog has joined.
05:16:15 -!- clog has joined.
05:33:23 -!- bsmntbombdood has joined.
05:35:38 -!- lament has joined.
05:38:45 -!- cmeme has joined.
05:51:52 -!- clog has joined.
05:51:52 -!- clog has joined.
05:58:23 -!- mtve has joined.
05:59:01 -!- ihope_ has joined.
05:59:05 -!- ihope_ has changed nick to ihope.
06:01:30 -!- pikhq has joined.
06:03:04 -!- nickv111 has joined.
06:09:26 -!- sekhmet has joined.
06:29:28 -!- bsmntbombdood has quit ("all your basment are belong to bsmntbombdood").
07:57:13 -!- Arrogant has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:06:04 -!- bsmntbombdood has joined.
08:53:00 -!- bsmntbombdood has quit ("all your basment are belong to bsmntbombdood").
08:55:20 -!- sekhmet_ has joined.
09:00:44 -!- sekhmet has quit (Read error: 110 (Connection timed out)).
11:02:41 -!- Arrogant has quit ("Leaving").
12:30:51 -!- jix_ has joined.
12:34:21 -!- tgwizard has joined.
13:19:42 -!- jix_ has changed nick to jix.
14:14:49 -!- ihope_ has joined.
14:20:41 -!- ihope has quit (Connection timed out).
14:20:49 -!- ihope_ has changed nick to ihope.
14:37:53 -!- sekhmet_ has changed nick to sekhmet.
14:40:10 -!- ihope_ has joined.
14:42:56 -!- ihope has quit (Connection timed out).
14:43:00 -!- ihope_ has changed nick to ihope.
14:54:02 -!- ihope_ has joined.
15:01:10 <ihope_> ...So CNOT and Hadamard *are* all that's required?
15:01:13 <ihope_> Argh.
15:11:22 -!- ihope has quit (Connection timed out).
16:09:31 -!- GregorR-W has joined.
17:13:29 -!- CXI has joined.
17:18:33 <lament> ihope_: what??????
17:18:58 <ihope_> Hmm, now I don't remember where I read it :-P
17:35:30 <pgimeno> when will we see a qutrit-based language?
17:37:16 <ihope_> Once you tell me how to do a qutrit Hadamard transform.
17:37:34 <ihope_> And a qutrit controlled-V, at that.
20:08:55 -!- ihope_ has changed nick to ihope.
20:18:34 <GregorR-W> Slow day.
20:19:48 <ihope> Yep.
20:20:26 <ihope> Well, there's this question that, well...
20:21:01 <ihope> If I have two qubits that are pretty much entangled copies of each other, what happens when I observe one?
20:22:10 <ihope> Does what I think happens happen?
20:29:50 <ihope> Well, I posted a new version of quantum brainfuck.
20:31:42 <lament> ihope: i think what you think happens happens
20:31:59 <lament> you observe one, the other folds into |0> or |1>
20:33:40 <ihope> Yep, makes sense.
20:34:05 <ihope> So, do you like the new language better? http://esoteric.voxelperfect.net/wiki/Quantum_brainfuck
20:36:17 <lament> yes, if it's "quantum-complete"
20:36:35 <lament> what's controlled-V?
20:36:52 <lament> i mean
20:37:03 <lament> who cares what's controlled V, can you implement Shor's algorithm in that thing? :)
20:37:21 <lament> being able to swap things makes it very much NOT like brainfuck, though
20:37:43 <lament> (which is a good thing in my book since i hate brainfuck clones)
20:37:51 <ihope> :-)
20:39:04 <lament> um
20:39:08 <lament> explain output, i don't get it
20:39:51 <lament> it's a cnot that works on what?
20:40:09 <ihope> Call the current qubit C. Output takes a qubit D initially containing |0>. Then it does a CNOT with C as the control and D as the target, then it sends D out to who-knows-where.
20:40:24 <lament> oh
20:40:48 <lament> and every time you use output, D is initialized to |0> ?
20:41:03 <ihope> Yep.
20:41:08 <ihope> But it's a new D every time.
20:41:20 * lament tries to understand whether that makes sense or not
20:42:23 <ihope> It just outputs a copy of C that's entangled with the original.
20:42:46 <lament> why?
20:42:53 <lament> you can't do that
20:43:01 <lament> i mean
20:43:16 <ihope> Why not?
20:43:23 <lament> are you saying that output does not collapse the qubit?
20:43:30 <lament> is that why you're doing this?
20:43:37 <ihope> Yeah.
20:43:41 <lament> that's cheating
20:43:53 <ihope> Why?
20:44:03 <lament> because observing the entangled qubit leads to collapse of the other one
20:44:35 <ihope> Well, I could zero a qubit upon output.
20:44:46 <lament> i think you should simply observe it
20:44:50 <lament> and output the result
20:44:59 <lament> after which the qubit is either |0> or |1>, whichever's appropriate.
20:45:06 <lament> that's how it would happen in a real quantum computer.
20:45:20 <lament> you can't output things without affecting them.
20:45:20 <ihope> What if it were outputting right into another quantum computer?
20:45:55 <lament> then that would be fine :)
20:46:00 <lament> but that's not output
20:46:16 <ihope> Well, it's still going somewhere.
20:46:25 <lament> but it's not observed
20:46:28 <lament> output implies observation
20:46:33 <lament> so you need to collapse it
20:46:42 <ihope> Why does output imply observation?
20:46:53 <lament> well
20:46:56 <lament> it doesn't.
20:47:15 <lament> but if you want to get a "1" or a "0" out of it, then you have to observe it
20:47:23 <lament> which involves collapsing the qubit
20:48:30 <lament> you seem to get around that by cheating - by collapsing one qubit but not the one entangled with it
20:48:57 <lament> unless i misunderstood you
20:49:54 <ihope> Well, I never said that a classical bit would come from the qubit that was output.
20:50:36 <lament> well, what happens to this D qubit?
20:50:55 <lament> what would happen to it in an actual implementation of this language? (are you writing one?)
20:55:58 <ihope> Well, in a quantum implementation, the qubit itself would go on to wherever it's needed. In a classical implementation, either the qubit would be observed and the result output, or some representation of the qubit would be output.
20:57:20 <lament> supposing it gets observed (which seems to be the most practical solution), would that collaps the qubit on the tape?
20:57:24 <lament> *collapse
20:57:26 <ihope> Yes.
20:57:37 <lament> oh, okay.
20:57:46 <lament> write an implementation!
20:58:10 <lament> or i could do it if you're lazy
20:58:22 <ihope> Oh, I might do it.
20:58:45 <ihope> But lemme reboot first.
20:59:33 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
21:08:44 -!- ihope has joined.
21:08:46 <ihope> There. Better.
21:39:19 <ihope> So now I have the whatchamies down.
21:39:30 <ihope> Complex numbers.
21:45:13 -!- kipple has joined.
21:59:50 <lament> okkay.
22:00:14 <ihope> Actually, it turns out I don't need to implement those after all...
22:00:24 <lament> okkay.
22:00:27 <lament> dude
22:00:34 <lament> use some existing linear algebra library
22:00:41 <lament> you want all these operations to be _fast_
22:00:45 <ihope> Some existing what?
22:00:56 <lament> some existing library for dealing with matrix operations
22:01:28 <ihope> Um...
22:03:53 <ihope> Well, I'm defining these quantum things with wavefunctions.
22:06:47 <lament> now i have no idea what you're doing :)
22:08:38 <ihope> You know. A qubit is a function taking a bit and returning the probability amplitude.
22:22:48 * ihope ponders the Hadamard gate
22:30:49 <ihope> Well, that was harder than I expected.
22:33:18 <lament> haha
22:36:09 * ihope gets dizzy at his long string of type errors
22:36:30 <ihope> I see what whoever said when he/she said that typeless Haskell would be a nightmare to debug.
22:39:21 <jix> typeless haskell?
22:39:35 <ihope> Yep.
22:39:52 <ihope> Well... Haskell with all the type stuff done at runtime.
22:45:45 <lament> ihope: what are you writing the implementation in?
22:46:29 <ihope> H
22:46:35 <ihope> Haskell, with types :-)
22:47:25 <ihope> Oh, you write it. I'm incompetent :-P
22:48:34 <lament> mmmm
22:49:03 <lament> okay
22:49:26 <lament> but i'll write it in non-optimized python for now :)
22:59:59 <lament> mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
23:00:03 <lament> mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
23:00:05 <lament> mmmmmmmmmmmmmmmmmmm
23:00:31 <lament> this sort of requires a good matrix-library, i think
23:00:47 <lament> anyway
23:00:53 <lament> i'll write it in the least efficient way possible, for now
23:01:41 <lament> god this is ugly.
23:14:05 -!- nickv111 has left (?).
23:14:31 <lament> god this is WAY too ugly.
23:14:44 * ihope suddenly realizes that probably the best way to write a wave function is, in fact, using a function
23:14:56 <GregorR-W> .
23:15:20 * ihope doesn't use periods at the end of his CTCP ACTIONs
23:15:31 * GregorR-W .
23:15:59 * ihope decides to do so, so GregorR-W will stop throwing periods at him.
23:16:03 -!- puzzlet has quit (Read error: 104 (Connection reset by peer)).
23:17:00 <GregorR-W> Actually, that first period was a "I have no response for that" mark.
23:17:40 -!- puzzlet has joined.
23:18:28 -!- kipple has quit (Read error: 110 (Connection timed out)).
23:22:00 <ihope> Oh.
23:22:36 <ihope> Well, I expect that wave functions commonly aren't written as functions.
23:31:10 <lament> oh god this is so ugly.
23:33:45 <ihope> Can you give me a code sample?
23:34:29 <lament> no
23:34:39 <lament> i don't actually have any useful code yet :)
23:35:39 <lament> the problem is to apply the gate to all the possible different states of OTHER qubits in the register
23:43:01 <ihope> So are you using actual functions for your wave functions? :-)
23:43:26 <lament> huh
23:43:29 <lament> what
23:43:43 <lament> i dunno what you're talking about :)
23:46:21 -!- fuse has joined.
23:51:39 <ihope> Those things that take things like |000> and tell you their probability amplitudes.
23:51:56 <lament> my god i suck at programming.
23:52:02 <lament> my GOD i suck at programming
23:52:05 <lament> ihope: that's just a number.
23:52:10 <lament> it's not a function :)
23:52:23 <fuse> oh god. quantum mechanics.
23:52:28 <lament> okay
23:52:33 <lament> i finished classes Gate and Register
23:52:43 <fuse> lament: watcha doing?
23:52:55 <ihope> fuse: writing an interpreter for quantum brainfuck.
23:53:08 <fuse> woot.
23:53:11 <ihope> So the probability amplitude of |000> is a number, but how do you determine that number? Is it an array?
23:53:31 <fuse> is there a specification for that somewhere?
23:53:41 <ihope> Yes, it's on the wiki.
23:54:06 <lament> ihope: it's not an array, it's a number
23:54:42 <ihope> lament: yes, but where do you store the whole mass of probability amplitudes?
23:55:49 <lament> in an array
23:55:57 <lament> ahhhh
23:55:58 <lament> Hadamard = Gate(2, [[st, st], [st, -st]])
23:56:00 <lament> :D
23:56:32 <lament> (st = 1/sqrt(2))
23:57:05 <fuse> so the thing between the outermost [ ] is a matrix?
23:57:12 <fuse> sorry, i'll shut up