00:00:37 <ihope_> And the number is 74037563479561712828046796097429573142593188889231289084936232638972765034028266276891996419625117843995894330502127585370118968098286733173273108930900552505116877063299072396380786710086096962537934650563796359.
00:00:54 <AndrewNP> Try 3. I've got a good feeling that it's some number times 3.
00:01:33 <ihope_> Nope, it's congruent to 1 mod 3.
00:02:14 <ihope_> Okay. Choose a random number from 1 to RSA-704.
00:02:14 <AndrewNP> So to break this one, you'd need a 704-qubit register, right? Pfft, good luck, hardware designers.
00:03:08 <AndrewNP> Uh... We already did 3. So... um... floor(pi * googol).
00:03:44 <AndrewNP> That's 101 digits, about the right size for one of the offending factors.
00:03:54 <AndrewNP> Probably not even prime, but since when is that MY problem?
00:04:17 <ihope_> Okay, the number is 31415926535897939206342872074089512377015178275785648855278065595809401623948916766946766405184258048.
00:05:00 <ihope_> No, we can still use it.
00:05:07 <ihope_> But this and that are coprime.
00:05:23 <AndrewNP> This and 3, or this and the RSA number?
00:05:31 <ihope_> This and the RSA number.
00:05:46 <ihope_> Now, f(x) = this^x mod that.
00:06:06 <ihope_> Do you know the period of that function?
00:07:27 <AndrewNP> Maybe... write a BF program. Or Glass. And wait 20 years or something.
00:07:53 <ihope_> What if somebody else does it first?
00:08:20 <ihope_> Okay, I need you to create a register that contains everything from 0 to the RSA number minus one, all with equal positive probability amplitudes.
00:08:23 <AndrewNP> Then we use a different algorithm: find the guys who did it, then beat the crap out of 'em and take credit for the accomplishment.
00:08:45 <AndrewNP> I'll split the cash 100-0 your way, since odds are you're the one who's gonna be in charge of the beating.
00:08:56 <AndrewNP> And I wouldn't know what to do with the money.
00:09:07 <ihope_> But nobody's done it yet, and the RSA guys will probably know it's them before we will.
00:09:37 <AndrewNP> Okay then, back to the original plan. Um... crap. I'm gonna need a lot more RAM.
00:11:15 <AndrewNP> The reciprocal. The probability. We can figure out the amplitude from that.
00:11:43 <ihope_> The reciprocal is 1/74037563479561712828046796097429573142593188889231289084936232638972765034028266276891996419625117843995894330502127585370118968098286733173273108930900552505116877063299072396380786710086096962537934650563796359.
00:12:08 <ihope_> Approximately 1.3506657337204956e-212, that is.
00:13:30 <AndrewNP> Uh... huh. Is it too late to kill this process and just do a simple "Hello World"?
00:13:39 <AndrewNP> 'Cause this could take a while.
00:14:26 <AndrewNP> The quantum factoring algorithm.
00:14:44 <AndrewNP> It's not working nearly as well as I had hoped.
00:15:43 <ihope_> Anyway, the probability amplitude you need is about 1.1621814547309278e-106. Initialize them to that.
00:16:56 <ihope_> You need to be an IRC operator to do that.
00:17:26 <AndrewNP> Then I'll have to try the old exception-handling way.
00:17:32 <AndrewNP> Please stop trying to factor RSA-704.
00:18:00 <AndrewNP> Interrupt the running, and all that. ^^
00:19:06 <ihope_> What if I don't want to stop?
00:19:35 <AndrewNP> Well, knock yourself out, but don't expect me to continue helping as a parallel processor.
00:19:58 <AndrewNP> But... the other chatters might complain. Or they would if they were still here.
00:20:08 * AndrewNP pokes the sleepy chatroom citizens.
00:24:13 * AndrewNP is slapped with a sexual harassment class-action suit.
00:25:32 <pikhq> And statutory rape.
00:26:04 <AndrewNP> But not that kind of poke... I think.
00:26:22 <pikhq> The courts don't care what kind of poke it was.
00:27:16 <AndrewNP> Honestly, ONE body-fluid-stained corpse and they're all like "Ooh, Murder in the First Degree!"
00:28:21 <AndrewNP> I mean, two or three, sure, I can understand. But doesn't everyone get a freebie? I think that's in the UN charter or something.
00:28:29 <GregorR-W> http://www.donotputthebaby.com/index.php?s=Knife
00:28:45 <ihope_> How hard does one have to try to kill someone in order for it to be considered attempted murder?
00:28:54 <ihope_> It doesn't count if I just want someone to die, does it?
00:29:10 <AndrewNP> Eh, you probably have to DO something at least.
00:29:49 <ihope_> Doing something that could have been fatal, but wasn't?
00:29:49 <AndrewNP> Here's an esolang for ya: http://www.donotputthebaby.com/index.php?s=Code
00:30:00 <AndrewNP> Probably. Like, you really really REALLY expected 'em to die.
00:30:18 <AndrewNP> Shooting 'em and just missing the heart, for example.
00:34:08 <ihope_> Well, let's try to factor 4 using Shor's algorithm.
00:34:14 <ihope_> Just for practice and all that.
00:35:41 <ihope_> So a = 1. The GCD thingy is 1... well, yeah, 1 is a factor of 4.
00:36:11 <ihope_> Let's say a = 3, since that's *not* a factor of 4.
00:36:32 <GregorR-W> Speaking of just wanting somebody to die ...
00:39:05 <AndrewNP> GregorR: Uh-oh. I'm sorry! :'(
00:40:02 <AndrewNP> Okay, so now we take .5|00>+.5|01>+.5|10>+.5|11>
00:40:17 <AndrewNP> .5^2 = .25, so that should work as the amplitude.
00:40:29 <ihope_> No, .5|00> + .5|10> + .5|20> + .5|30>.
00:41:03 <GregorR-W> Speaking of just wanting somebody to die ... :P
00:41:16 <AndrewNP> GregorR: Yes, what? Who do ye want dead?
00:41:35 <AndrewNP> Okay, fine. First register = 0-3, Second = 0.
00:41:55 <AndrewNP> So then we take... 3^x mod 4, right?
00:42:29 <ihope_> So we turn that into (|01> + |13> + |21> + |32>)/2, I think.
00:43:08 <ihope_> ...No, (|01> + |13> + |21> + |33>)/2.
00:43:51 <AndrewNP> Now Fourier transform that bad boy!
00:44:03 <AndrewNP> Er, inverse. Inverse Fourier transform.
00:45:09 <ihope_> Oh, let's skip to the probability part.
00:45:28 <AndrewNP> You have to do the transform first, buddy.
00:45:50 <Razor-X> Is there some sort of Introduction to Quantum Computing?
00:46:11 <ihope_> Razor-X: well, you might wanna look at... something. Lemme see...
00:46:17 <AndrewNP> I think. Otherwise the numbers we're working with would be all wrong.
00:46:37 <AndrewNP> Razor: Actually, I promised a couple guys I'd write up a QC tutorial for 'em.
00:46:49 <AndrewNP> Razor: Do you want the physics behind it, or just the math and comp-sci part?
00:47:04 <ihope_> Well, you have to understand wavefunctions.
00:47:35 <Razor-X> AndrewNP: Well, depends on how involved the physics is.
00:47:43 <Razor-X> No, I don't have enough background for the wavefunctions.
00:47:54 <Razor-X> Unless a wave function is a sine curve :D.
00:48:10 <AndrewNP> I thought the whole point of the bra-ket thingie was to abstract out the wavefunction?
00:48:35 <ihope_> Now, instead of 0 and 1, we have |0> and |1>.
00:49:06 <ihope_> And we can use |0> and |1> as numbers, sort of.
00:49:27 <AndrewNP> And this time, instead of covering up a voltage, they stand for a whole crapload of physics.
00:49:56 <ihope_> We can add quantum states to each other, and we can multiply quantum states with numbers.
00:50:28 <ihope_> Essentially, you have to be able to turn it into something of the form a|0> + b|1>.
00:50:43 <ihope_> And |a|^2 + |b|^2 has to be 0.
00:51:08 <ihope_> So |0>*sqrt 2 + |1>*sqrt 2 is valid, but 2|0> isn't.
00:51:12 <lament> You mean, has to be 1.
00:51:48 <Razor-X> So you can have like... sqrt(2)|0>
00:51:55 <lament> Razor-X: so now that you understand everything, write me a qbf program.
00:52:25 <ihope_> Razor-X: well, no, because the square of the absolute value of the square root of 2 is 2.
00:52:42 <Razor-X> Mmmm. Can someone make a TeX proof of this? >_>.
00:53:03 <Razor-X> But, it's hard to see without only ASCII on IRC.
00:53:15 <Razor-X> (Note. I should be studying for my Statistics final. Do I care? No.)
00:53:22 <ihope_> Oh, wait, I meant |0>/sqrt 2 + |1>/sqrt 2.
00:53:36 <Razor-X> So, uh ... |0> is divided by sqrt(2) ?
00:53:51 <Razor-X> But what value does |0> have?
00:54:05 <ihope_> |0> is just |0>. It's like a variable.
00:55:14 <Razor-X> But then, since |0> is symbolysis for physics cr*p, then you can at most simplify to |0>/sqrt(2) ?
00:55:32 <ihope_> Well, |0> and |0>/sqrt(2) are different thinges.
00:55:50 <Razor-X> Well, yeah... I understand that...
00:55:54 <AndrewNP> Yeah. Think of it as an ordered pair with |0> and |1> coordinates.
00:56:16 <Razor-X> What operations can you do to these |0> and |1> ?
00:57:12 <Razor-X> There must be some repeatability in the operations to produce logic with them, no?
00:57:16 <ihope_> An example would be the Hadamard gate, which turns |0> into (|0> + |1>)/sqrt(2) and |1> into (|0> - |1>)/sqrt(2).
00:58:07 <Razor-X> How do you perform logic, then?
00:58:22 <Razor-X> With different gates, on a bit level?
00:58:24 <ihope_> Well, there's, say, the Toffoli gate, which is simply a logic gate turned quantum.
00:58:41 <lament> toffoli gate is not quantum.
00:58:50 <lament> it operates on regular bits.
00:59:05 <ihope_> The Toffoli gate leaves everything the same, except that it turns |110> into |111> and vice versa.
00:59:07 <AndrewNP> But the Toffoli gate IS reversible, one-to-one, which is what all quantum gates need to be.
00:59:31 <AndrewNP> Something about thermodynamics. Don't know, don't care.
00:59:49 <Razor-X> So there's no such thing as a ``Quantum Truth Table'' ?
01:00:14 <ihope_> Well, yes, but they're more complicated.
01:00:25 <AndrewNP> Quantum gates use a square matrix to describe the transformation.
01:00:54 <ihope_> Well, the outputs can be any quantum states, instead of simple bits.
01:01:45 <Razor-X> But here, the quantum states are |0> and |1> ?
01:02:04 <ihope_> Yeah, those are just the base states.
01:02:38 <ihope_> You can also have things like (|0> + |1>)/sqrt(2).
01:03:21 <Razor-X> So, all you can do is divide by sqrt(2) one or both of the quantum states?
01:03:48 <ihope_> There are also states like -|1> and |1>i.
01:04:09 <Razor-X> Well, |1>-1 is the same thing as -|1> ?
01:04:11 <ihope_> The only rule for quantum states is that the squares of the absolute values have to add up to 1.
01:04:31 <AndrewNP> Razor: It has to be in the form a|0>+b|1>.
01:04:38 <AndrewNP> Adding a constant is meaningless.
01:05:10 <Razor-X> abs( a|0> ? b|1> )^2 = 1 ?
01:05:16 <GregorR-W> Trying to pastebin an explanation of matrix notation, but it's being slow >_<
01:05:23 <Razor-X> abs( a|0> + b|1> )^2 = 1 ?
01:05:51 <AndrewNP> And as ihope pointed out, a and b can be complex.
01:05:52 <GregorR-W> http://pastebin.ca/101581 < matrix notation
01:06:33 <AndrewNP> To use the quantum gate, you just have to multiply the state vector by the matrix.
01:07:01 <AndrewNP> For example, for a single qubit a|0>+b|1>, the state vector is [a,b].
01:07:20 <Razor-X> But, you would get a resulting matrix then, no?
01:07:28 <Razor-X> Isn't the goal to get a resulting vector?
01:07:35 <AndrewNP> A vector times a matrix is a vector.
01:07:43 <AndrewNP> And since the matrix is square, it'll be the same dimension.
01:08:00 <Razor-X> Ah, OK, so then these gates are scientifically designed to be possible?
01:08:09 <ihope_> Yep, something like that.
01:08:23 <AndrewNP> Don't ask me how. Maybe ihope knows? (If you care, that is.)
01:08:38 <GregorR-W> IIRC, at least a few exist in reality.
01:08:44 <ihope_> Well, what do you mean by "these gates"?
01:09:02 <ihope_> But which ones are "these" ones?
01:09:14 <AndrewNP> The ones that are used in QC. Hadamard, CNOT, and so forth.
01:09:36 <ihope_> Well, if they weren't actually possible, we probably wouldn't be using them.
01:09:53 <AndrewNP> There is one limitation, though. QC gates have to be "unitary" matrices.
01:10:29 <AndrewNP> Its conjugate transpose has to equal its inverse.
01:10:37 <ihope_> I don't know if there are any rules other than that they have to be unitary and they have to actually produce valid states.
01:10:57 * Razor-X decides to look up Matrix conjugate transposes.
01:11:45 <Razor-X> Then, I gather there's a large-but-finite amount of states?
01:12:14 <AndrewNP> Any two complex numbers that obey |a|^2 + |b|^2 = 1 are legal.
01:12:41 <Razor-X> .... I'll assume that complex numbers can be states too :P.
01:13:01 <AndrewNP> Yeah. You could have 3/5i |0> + -4/5 |1>.
01:13:06 <Razor-X> Anyhow, how does this fit into computing?
01:13:15 <ihope_> You can compute with these.
01:13:20 <AndrewNP> Well, the real magic happens once you get more than one qubit.
01:13:29 <ihope_> For multiple qubits, you have things in the form a|00> + b|01> + c|10> + d|11>.
01:13:44 <Razor-X> But, can 4 qubits go into one gate?
01:13:46 <ihope_> And |a|^2 + |b|^2 + |c|^2 + |d|^2 = 1.
01:13:56 <ihope_> Razor-X: if it's a 4-qubit gate, yes :-)
01:14:14 <AndrewNP> Yep. 4x4 matrices = 2-qubit gates. 8x8 = 3 qubits.
01:14:23 <Razor-X> So the rules stay the same, just reversible and produces valid states?
01:14:51 <Razor-X> Is there any math to decrease the ``circuitry'' involved?
01:15:04 <Razor-X> Like a K-map or something?
01:16:07 <Razor-X> Well wait... because normal bits have two possible states, you can produce logic in the form of base-2 numbers..., if the number of possible states is infinite, you have base-infinite numbers???
01:16:28 <AndrewNP> The numbers are actually *probabilities*.
01:16:55 <AndrewNP> That when you observe the bit or do something irreversible, the value will be |0> or |1>.
01:17:16 <Razor-X> So... if you want a |1>, you want to get the probability for |0> as low as possible?
01:17:45 <GregorR-W> All the qubits in QBF start as (0,1), so that's easy :P
01:17:59 <Razor-X> So that also chops down the number of possible states by a lot too, if you want totally probably states, no?
01:18:03 <ihope_> But if you want a |1>, you can just pull one out of thin air.
01:18:11 <ihope_> Razor-X: if you want what?
01:18:49 <AndrewNP> Yeah. Part of the problem with QC is figuring out a way to make the correct answer the probable outcome.
01:18:53 <GregorR-W> Mind you, I believe that in QBF you can actually only achieve about six states ...
01:19:12 <ihope_> GregorR-W: what're those?
01:19:22 <AndrewNP> Razor: 'Cause once you observe something, it stays in that state. It collapses to a pure |0> or |1>.
01:19:41 <Razor-X> So, the goal of qubits is to apply a certain number of gates until the probability for a certain qubit becomes 1 and the rest 0?
01:19:55 <GregorR-W> OK, much more than six, but finite :P
01:19:58 <ihope_> Razor-X: well, sort of, yeah.
01:20:26 <AndrewNP> Well, you usually can't guarantee a 100% probability, but if you get a high figure and run the algorithm several times, you should get a pretty good idea of the answer.
01:20:36 <Razor-X> What's the advantage of quantum computing over binary computing?
01:20:47 <GregorR-W> (0, 1), (1, 0), (1/sqrt(2), 1/sqrt(2)), (1/sqrt(2), -1/sqrt(2)), (0, i), (i, 0), (0, -1), (-1, 0), (0, -i), (-i, 0), (i/sqrt(2), i/sqrt(2)), (i/sqrt(2), -i/sqrt(2)), (-1/sqrt(2), -1/sqrt(2)), (-1/sqrt(2), 1/sqrt(2)), (-i/sqrt(2), i/sqrt(2))
01:20:49 <ihope_> Razor-X: doing lots at the same time.
01:21:05 -!- GregorR-W has quit ("Chatzilla 0.9.73 [Firefox 1.5.0.2/0000000000]").
01:21:47 <AndrewNP> Razor: The number of states that can be manipulated at once goes up exponentially with the number of qubits.
01:22:12 <ihope_> If you put something into a superposition of every basis state, then apply some function to it...
01:22:14 <Razor-X> But, what's the advantage to the different number of states?
01:22:33 <AndrewNP> Each one represents a binary number. Like |01001>.
01:22:51 <AndrewNP> So with 5 qubits, you can apply the function to the range [0..31] simultaneously.
01:23:21 <AndrewNP> Now the lightbulb goes off, and she becomes a believer. :)
01:23:21 <Razor-X> What operations does QBF allow?
01:23:50 <AndrewNP> And with QC, you can access some of the weirder parts of quantum physics. Like entanglement.
01:23:55 <ihope_> Hadamard gate, controlled-V gate, swap.
01:24:01 <AndrewNP> The bits don't have to be indpendent of each other.
01:24:20 <AndrewNP> Using probabilities instead of those godawful magnitudes, let's say you have...
01:24:21 <Razor-X> The Hadamard gate and controlled-V gates have their own matricies, I gather?
01:24:36 <ihope_> Razor-X: well, just don't thing of them apart. And yes, they have their own matrices.
01:24:54 <AndrewNP> 10% |00> + 20% |01> + 30% |10> + 40% |11>.
01:25:15 <Razor-X> 100%! Woohoo! I can count!
01:25:21 <ihope_> Instead of two (|0> + |1>)/sqrt(2) that have to be the same, you can just have (|00> + |11>)/sqrt(2).
01:25:41 <AndrewNP> Better example, ihope. I yield to you.
01:25:45 <Razor-X> So if the probability of two qubits is the same, they're considered to be the same qubit?
01:26:16 <AndrewNP> Well, when you have two or more qubits, you can't consider them in isolation.
01:26:38 <AndrewNP> In ihope's case, whatever the first bit is observed to be, the second bit will NECESSARILY be also.
01:26:59 <AndrewNP> In my case, observing one bit will alter the probability state of the other bit.
01:27:16 <AndrewNP> If you've taken a stats class, this should all be simple enough. ;)
01:27:18 <Razor-X> Physically though, you can only view one of the two, no?
01:27:38 <AndrewNP> Nah, you can view any one of them. Ideally, at least.
01:28:12 <AndrewNP> Probably. And the probability of each outcome is determined, again, by the overall matrix.
01:28:35 <AndrewNP> So for ihope, there's a 50-50 chance of seeing |00> or |11>. But you will NOT get |10> or |01>.
01:29:33 <Razor-X> But if physically you only see one of the two, what's the point of them having the same probability other than to confuse?
01:30:13 <AndrewNP> Well, ihope's case is more to give you a feel of how it works.
01:30:33 <AndrewNP> I don't think it would occur in a practical algorithm.
01:31:01 <Razor-X> Well, it doesen't seem *too* complicated... if that's all there is to it....
01:31:20 <Razor-X> At a very high, abstract, I-don't-care-about-the-very-complicated-physics level.
01:31:29 <AndrewNP> Yeah, the math concepts are pretty easy. The challenge is designing algorithms for it.
01:31:41 <Razor-X> Seems like a perfect job for the Esolang community.
01:32:02 <AndrewNP> And, of course, there's the hardware level. They think 7 qubits is an accomplishment. They factored 15.
01:33:39 <AndrewNP> Razor: Yeah, that could be a good field of study.
01:33:57 <AndrewNP> Certainly more fruitful than "How many ways can we encode Brainf***?" X-D
01:34:34 <Razor-X> Well, 7 qubits is better than binary for sure.
01:34:35 <AndrewNP> like a perfect job for the Esolang community.
01:34:35 <AndrewNP> [20:31] <AndrewNP> And, of course, there's the hardware level. They think 7 qubits is an accomplish
01:35:16 <AndrewNP> Sorry. Need to not play with ctrl-C while this window is open. ^^;;;
01:35:31 <Razor-X> Is the QBF interpreter ready yet?
01:36:18 <ihope_> But with ! and % and & and such.
01:36:24 <Razor-X> But I mean..., you don't have a ``tape'' here do you?
01:36:48 <AndrewNP> It works on a "tape" of qubits.
01:37:06 <ihope_> All initialized to |1>.
01:37:18 <AndrewNP> ihope: Any reason for that instead of |0>?
01:37:42 <AndrewNP> Well, the qubits can be entangled, as in a single register.
01:37:46 <ihope_> AndrewNP: well, it might actually be impossible to create a NOT gate.
01:38:21 <AndrewNP> Oh right. 'Cause of the controls. Do they make "inverse-controlled" gates?
01:38:27 <ihope_> But it's possible to get a CNOT, so it starts with |1> so people can use that.
01:38:56 <ihope_> And they don't make gates wholesale. :-)
01:39:21 <AndrewNP> Heh. I meant, like, physically and mathically speaking.
01:39:26 <Razor-X> So You can invert one way but not the other?
01:40:08 <AndrewNP> Well, controlled gates only work if there's a |1> bit somewhere.
01:40:30 <AndrewNP> Like, if bit one = 1, do THIS to bit two.
01:40:43 <AndrewNP> It's a convenient way to entangle two qubits.
01:42:27 <AndrewNP> Make their states codependent.
01:42:44 <Razor-X> By changing the probabilities?
01:43:14 <AndrewNP> Pretty much. Controlled gates change |10> and |11> without touching |00> or |01>.
01:43:47 <ihope_> Well, if we have multiple qubits, then we use |00> and such as basis states instead of |0> and such.
01:44:11 <Razor-X> I feel happy with my now-new-knowledge in fancy lingo.
01:45:24 <ihope_> The problem with bra-ket notation is that it can be tricky to tell | and 1 apart :-
01:45:52 <Razor-X> My font sees it fine, heh.
01:47:04 <ihope_> Razor-X: I mean when writing them down. I tend to write both the same, except with | a bit longer.
01:47:29 <Razor-X> I write the 1 with the extra appendage up top.
01:48:13 <AndrewNP> In QBF, you take a classical bit from cin and write it to the current qubit. Right?
01:48:29 <ihope_> AndrewNP: that's one way of doing it.
01:48:33 <Razor-X> So then, you're manipulating 8 qubits, I imagine?
01:50:38 <AndrewNP> Eh, I guess you could handle it like that BIT language, where it reads in the character 1 bit at a time...
01:50:53 <AndrewNP> The only problem is, since it's ASCII, you'd never get a 1 for the high bit.
01:51:27 <pikhq> If you give it Unicode, you could.
01:51:52 <Razor-X> Or if you only limit it to 7 qubits....
01:52:02 <Razor-X> (Which seems physically possible, at least.)
01:52:58 <AndrewNP> Well, I don't think you have to limit the qubits -- since you can write the input one bit at a time.
01:53:38 <AndrewNP> Right. Maybe you could just discard every 8th bit...?
01:55:08 <Razor-X> Well, that would also be quite painful.
01:55:17 <Razor-X> More so than it already is with matricies :P.
01:56:15 <AndrewNP> True. I guess you could just live with the always-zeroed bit.
01:56:34 <AndrewNP> The bigger concern would be actually writing it. Since you'd probably have to observe and collapse the qubit first.
01:57:05 <AndrewNP> So that it'd be in a pure state that could be flipped.
01:57:22 <ihope_> If you want to write to a qubit, discard it and get a new one :-)
01:57:42 <AndrewNP> But what would that do to the existing state vector?
01:57:52 <AndrewNP> I wanna make sure whatever happens is physically possible.
01:58:02 <AndrewNP> If, God forbid, QBF becomes *the* language for QCs.
01:58:05 <Razor-X> You can't flip non-collapsed qubits?
01:58:18 <Razor-X> Well, if we have enough algorithms, it'll probably be used in the beginning.
01:58:27 <AndrewNP> Well, you could, but you wouldn't have a guaranteed |0> or |1>.
01:58:32 <ihope_> Razor-X: nah, something like QPL would be used.
01:58:53 <ihope_> You can throw away qubits just by keeping them somewhere safe.
01:59:47 <AndrewNP> Hm... I guess that could work. As long as you don't observe it, the probabilities of the other qubits should stay the same,
02:02:08 <AndrewNP> But if you did a lot of input, you'd end up with a lot of discarded qubits. And would it even be *possible* to swap qubits out of a register?
02:02:48 <ihope_> You can move qubits out of a register by physically transporting them, or by using quantum teleportation.
02:03:34 <AndrewNP> Yeah, but could you do that without totally disrupting the rest of the register, is my question.
02:04:15 <AndrewNP> Eh, if you say so. I'm not the physics... knowing... guy here.
02:04:36 <ihope_> Unless all the stuff I know about observing quantum states is wrong. Not that I know much...
02:05:16 <Razor-X> .... Quantum teleportation?
02:05:34 <Razor-X> It exists, it's always existed.
02:07:02 <AndrewNP> By entangling one qubit with another, you can set it up so that the one's state can be saved to the other when you collapse it.
02:07:18 <ihope_> Quantum teleportation is some weird thing that allows transmission of a qubit by transmitting two classical bits and using two entangled qubits.
02:07:47 <AndrewNP> Yeah. The classical bits are required if you want any information out of it, so you can't transmit at faster than the speed of light.
02:08:10 <AndrewNP> Though... if the state of the classical bits were agreed upon beforehand, couldn't you get around that rule?
02:08:28 <ihope_> You can't agree on them; they're determined by observation.
02:08:57 <ihope_> Just like you can't have two people agree on the result of flipping a coin.
02:09:11 <AndrewNP> Ohhh. K then. I'll have to reread that part.
02:09:59 <AndrewNP> Ah. Got it. So never mind then.
02:11:09 <AndrewNP> It's a bit weird at first, but it makes sense in terms of entanglement.
02:11:18 <AndrewNP> All you're doing is moving the entangled qubits apart.
02:11:22 <Razor-X> You change the probabilities and they teleport?
02:11:33 <Razor-X> How can you ``move'' a qubit, first of all?
02:11:38 <AndrewNP> The only thing you're "teleporting" is the state of the qubit.
02:11:44 <AndrewNP> You're not actually moving anything physical.
02:11:45 <Razor-X> Hell, I don't even know what a qubit physically represents :P.
02:11:55 <AndrewNP> Neither do most physicists. ;)
02:12:08 <Razor-X> Orwell has given me a great tool to understand all of this.
02:12:13 <Razor-X> Thank you Mr. Orwell, now.....
02:12:15 <AndrewNP> Seriously, they still get into fist fights with philosophers of science about it.
02:12:48 <Razor-X> So..., magically, real bits with real values and qubits have their probabilities change, and they swap like magic?
02:13:45 <Razor-X> Not magic. But doublethink.
02:15:55 <AndrewNP> Yeah, I still don't get how it works, math-wise. But rest assured, when the one qubit gets observed, the other collapses into a state equivalent to that of the first.
02:16:19 <Razor-X> So... the entire tape fills up with qubits of the same value?
02:16:48 <ihope_> Well... that's what happens when you do quantum teleportation.
02:17:20 <Razor-X> Is there a quantum teleportation operation in QBF?
02:17:29 <ihope_> There's a swap operator.
02:17:53 <Razor-X> But does that turn every qubit on the tape to the same value as the current qubit?
02:18:05 <ihope_> Nope; it just swaps two qubits.
02:18:08 <Razor-X> Or is the qubit only collapsed when you output it?
02:18:24 <ihope_> Outputting can collapse a qubit, and loops always do.
02:18:32 <ihope_> You could probably construct quantum teleportation in QBF.
02:18:52 <AndrewNP> I would assume so. If your gates are computationally complete, which I think I saw some citation saying they are.
02:19:45 <AndrewNP> Maybe that'd be a good program. Combine QBF with classical BoolF to simulate teleportation?
02:20:04 <Razor-X> I still don't understand the exact process behind a teleportation.....
02:20:21 <Razor-X> So how can you make QBF do it?
02:20:56 <ihope_> I can't, but somebody else probably could :-P
02:21:09 <Razor-X> How did I know you'd say that? :P.
02:21:39 <AndrewNP> You'd need to entangle the qubits, observe one, and somehow use its state to control what is done to the other.
02:22:02 <Razor-X> Can't you make a loop do that?
02:22:14 <AndrewNP> *Maybe*[21:17] <ihope_> Nope; it just swaps two qubits.
02:22:14 <AndrewNP> [21:17] <Razor-X> Or is the qubit only collapsed when you output it?
02:22:41 * Razor-X ignores the fact that she seems to be in each of those pastes.
02:22:58 * AndrewNP kills the hypersensitive Insert key.
02:23:12 <AndrewNP> Anyway, it SHOULD be possible to make a loop do what needs to be done.
02:23:51 <AndrewNP> The only trick would be moving the pointer to a pure |0> so that it doesn't repeat the operation.
02:24:18 <ihope_> Well, with quantum teleportation, it'd be "easy" to construct a quantum network.
02:24:48 <pikhq> With quantum foo, it'd be "easy" to bar. :p
02:25:02 <Razor-X> Are there any other quantum programming languages out there?
02:25:11 <ihope_> Other than QBF and QPL?
02:25:39 <ihope_> http://www.google.com/search?q=Quantum+programming+language
02:25:58 <pikhq> I think QBF is a first generation QPL. ;)
02:26:18 <pikhq> That scares me, to tell you the truth.
02:26:37 <ihope_> Maybe there isn't a language called QPL.
02:26:40 <Razor-X> At least we're doing something useful.
02:26:51 <Razor-X> http://en.wikipedia.org/wiki/Quantum_programming_language
02:26:57 <ihope_> I must have been thinking of QCL.
02:27:24 <Razor-X> And I can doublethink myself into assuming it's all possible and existable.
02:27:36 <AndrewNP> Then again, do we really NEED quantum-specific languages beyond the assembly level?
02:27:51 <AndrewNP> Seems you could just have the compiler optimize quantum-efficient algorithms. Maybe.
02:27:57 <ihope_> Do we really NEED classical programming languages beyond the assembly level?
02:28:50 <AndrewNP> No, no, I mean, we can avoid the quantum nastiness. Keep the high-level languages classical, and let the compiler take care of the quantum stuff.
02:29:19 <Razor-X> At some peoint, algorithms probably need to be changed.
02:29:21 <AndrewNP> I can't imagine your average monkey-suited coder wants to learn complex linear algebra just to factor a number. ;)
02:29:33 <Razor-X> You can simulate a classical computer, but I don't think it'll be as effecient.
02:29:47 <ihope_> Well, if your compiler can completely rewrite algorithms...
02:30:07 <Razor-X> Finally! The end of the Silicon Valley army of Coders-With-No-Heart!
02:30:10 <pikhq> AndrewNP: The average code-monkey doesn't even want to learn basic arithmetic.
02:31:27 <pikhq> Jeez. I'm in *high school*, and I know more then a code-monkey could ever hope to learn.
02:31:50 <Razor-X> I'm in high school too, ya know.
02:32:01 <Razor-X> Which is why I'm using doublethink to quell my curiosity.
02:32:26 <AndrewNP> ihope: Okay, so it was a stupid idea and I apologize. But how well is this quantum stuff going to mesh with all our existing languages...?
02:32:44 <AndrewNP> I can see it now: "import java.quantum.*;"
02:33:02 <AndrewNP> Because Java will not die, as much as it may deserve to.
02:33:07 <pikhq> I'm just saying that, even with the math knowledge from high school math, it is p[ossible to know much, much more then a code-monkey. . .
02:33:29 <ihope_> Yeah, there are ways to combine quantum stuff with current languages.
02:33:41 <Razor-X> Well, I have a nice advantage.
02:34:04 <ihope_> But oddly enough, quantum stuff at base seems to be imperative.
02:34:09 <Razor-X> So, if I don't understand something, either I'll spend many of my 22 hours searching for how to understand something, or badger someone to death until they tell me.
02:34:57 <pikhq> Razor-X: That's fairly normal in my experience. ;p
02:35:19 <Razor-X> Most high-schoolers want to do this weird thing called ``sleep'' when they're done with homework and studying.
02:36:00 <pikhq> And most high-schoolers want to do this weird thing called "studying". Why bother? I know more then the teacher already! :p
02:36:26 <AndrewNP> Just remember, kids: if they knew anything about the subject, they wouldn't be stuck in a teaching job! :)
02:43:40 <AndrewNP> Well, I think I'm gonna call it a night. You guys -- and lady :) -- stay classy out there.
02:43:49 -!- AndrewNP has quit ("See ya!").
03:07:05 <Razor-X> I have a few more questions about QBF, if someone wants to entertain me.
03:07:58 <Razor-X> What does QBF output when the probabilities aren't totally certain?
03:08:04 <Razor-X> Output the most likely one, or error out?
03:08:45 <Razor-X> Or output using a weighted distribution?
03:10:48 <ihope_> Well, I think the current distribution chooses randomly.
03:11:02 <ihope_> s/distribution/implementation/ (common typo, eh?)
03:12:45 <Razor-X> And what's the matrix for a Hadamard gate?
03:14:11 <ihope_> Divided by the square root of two.
03:15:57 <Razor-X> Now. Time to pursue my semi-useful idea.
03:16:10 <Razor-X> Oh yeah, and where can you get this awesome piece of interpreter from, and what's it written in?
03:16:55 <ihope_> It's written in Python, and it's probably at the file archive.
03:17:39 <ihope_> http://esoteric.voxelperfect.net/files/qbf/impl/
03:19:46 <ihope_> (|useful> + |not useful>)/sqrt(2)
03:19:46 <Razor-X> It's an idea I got from my Statistics final.
03:20:25 <pikhq> Statistics == Math for a business major.
03:20:34 <pikhq> AKA pure bullshit.
03:20:41 <Razor-X> But it gave me a nifty idea.
03:20:57 <Razor-X> Our teacher allowed us a letter-paper page front-and-back of notes.
03:21:20 <ihope_> You're lucky. My algebra teacher only gave me an index card for notes.
03:21:33 <Razor-X> So, a thought struck me at making a form of condensed English that's human readable and reproducable.
03:21:37 <pikhq> Notes? Bah, humbug. . .
03:21:48 <Razor-X> It's a summer course with a nice teacher.
03:21:49 <ihope_> I stuffed it full of formulas and only used one.
03:21:54 <Razor-X> My teachers have never given me notes in the past.
03:22:00 <pikhq> Razor-X: Got it already. I'll try making a document to explain it for you.
03:22:24 <pikhq> Boredom inspired. ;)
03:22:29 <Razor-X> Can it reproduce mathematical formulae?
03:23:27 <pikhq> I can't help but think that making a formula any more condensed and it won't be understandable. . .
03:23:41 <pikhq> Unless, of course, you don't mind postfix notation. :p
03:24:08 <Razor-X> I was thinking of implementing a functional style notation to represent mathematical operations.
03:24:25 <pikhq> Now that could be interesting.
03:24:34 <Razor-X> Well, it's easy to condense and read.
03:25:05 <Razor-X> I was also going to condense the most common English polygraphs.
03:25:25 <Razor-X> ps, th, ch, ough, ead, ae, and others.
03:25:30 <Razor-X> Needs some time and analysis.
03:25:37 <pikhq> What I produced was simply a very condensed writing system for English, taking advantage of the fact that 'nglsh 's vr rdbl whn wrttn 's 'n 'bjd.
03:26:15 <Razor-X> I was thinking of omitting vowels, but I wasn't sure.
03:26:24 <Razor-X> Or simply implying glide using an accent on the consonant.
03:26:34 <pikhq> That, alone, makes it much shorter. . .
03:27:00 <Razor-X> (Of course, the accent is on top of the letter.)
03:27:21 <pikhq> I made my writing system so that I can write each characters using one stroke on the paper, so that I can write in it much faster. . .
03:27:27 <pikhq> Probably not something you need.
03:27:42 <Razor-X> My requirement is that it must be TeX-symbol compatible.
03:27:58 <Razor-X> Handywrite does shorthand well enough.
03:28:07 <pikhq> It's new graphomes entirely.
03:28:18 <pikhq> Pretty much, it's my own, personal shorthand. ;)
03:28:19 <Razor-X> Yeah, this must be printable by a computer.
03:28:29 <Razor-X> Because a computer can get a lot more condensed than my hand can ;).
03:28:58 <pikhq> I'm capable of writing stuff that's very small. . .
03:29:18 <pikhq> Roughly 9pt font, I believe.
03:29:35 <Razor-X> It's double worse because I'm a girl X_X.
03:30:05 <Razor-X> Because girls must have good handwriting. It's social stigma.
03:30:36 <Razor-X> Not that I care that much, but it's a good asset to have >_>.
03:30:55 <pikhq> I think that being a good typist is a much more useful skill, personally.
03:31:09 <Razor-X> I was thinking of borrowing Greek letters too, but mathematical functions use those.
03:31:19 <Razor-X> It maybe more concise to use global Greek letters.
03:31:26 <pikhq> People are *impressed* by me typing at 70 wpm. :/
03:31:29 <Razor-X> So maybe Hebrew, if TeX supports it by default.
03:32:07 <pikhq> I've got fat fingers, which sort of slows my typing speed; need to go back and correct myself.
03:32:38 <Razor-X> There are some advantages to having ``dainty'' hands :P.
03:32:56 <Razor-X> I use an IBM Model M all the same.
03:33:24 <pikhq> I'm thinking about learning Dvorak sometime. . .
03:33:53 <pikhq> Also. . . I WANNA BUCKLING SPRING! :'(
03:34:45 <Razor-X> It's reeeeaaaalllyyy nice.
03:35:06 <pikhq> Now, if I can get a Dvorak buckling spring keyboard, I'll be incredibly happy.
03:35:26 <Razor-X> IBM Model M's can be rearranged.
03:35:35 <Razor-X> (Except the home keys will lose their little indentation.)
03:37:28 <pikhq> qId rather not do xmodmap for it.
03:38:00 <Razor-X> I don't use xmodmap, I load the keymap itself.
03:38:51 <pikhq> Remind me to stab whoever thought that mapping xoff to C-a s was a good idea, please.
03:40:24 <pikhq> It's so easy to accidently hit C-a s when trying to type just C-a. . .
03:40:54 <pikhq> And, since you don't really notice it, you just think that the screen session locked up on you.
03:43:01 <Razor-X> I use Emacs binds, so meh.
03:44:01 <Razor-X> I'm thinking of also using tense modifiers in the condensed English.
03:44:09 <pikhq> Screen can do Emacs binds?
03:45:22 <Razor-X> Oh. I rebound screen to the character C-z.
03:45:44 <Razor-X> Because Emacs uses C-a for beginning-of-line.
03:46:09 <pikhq> I've gotten used to doing C-a a. . .
03:46:41 <pikhq> Just too lazy to figure out what to do to my .screenrc. ;)
04:04:19 <GregorR> EgoBot going down for upgrades.
04:04:46 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
04:05:19 <pikhq> I'm thinking about doing a presentation on esoteric languages for the local LUG. . .
04:12:20 <ihope_> Do the upgrades include a QBF thing?
04:13:26 <GregorR> Yes, but that's the least notable part :P
04:13:51 <GregorR> Can you give me the URL so I don't have to dig? :P
04:14:02 <GregorR> The most significant part if I ever get it working is persistent daemons.
04:14:10 <ihope_> http://esoteric.voxelperfect.net/files/qbf/impl/
04:14:45 <ihope_> But shouldn't you wait for the restart-for-upgrades until you've actually finished them? :-P
04:15:30 <GregorR> I finished it, it just doesn't work.
04:16:06 <ihope_> If it doesn't work, then how is it finished?
04:16:15 <GregorR> OK, lemme put it this way:
04:16:18 <GregorR> I wrote the code, but it's buggy.
04:16:51 <ihope_> Eh, time to go to Sleepyland.
04:17:28 -!- ihope_ has quit ("I don't suppose you're an honorary Sleepyhead too...").
04:47:45 <GregorR> Yeah, let's not patiently let it reload.
04:48:25 -!- EgoBot has joined.
04:48:44 <EgoBot> 1 EgoBot: daemon repeater reload
04:48:51 <GregorR> Watch this, this is amazing.
04:48:58 <GregorR> That daemon was of course killed on the last run.
04:49:05 <GregorR> I already told it Line 1 and Line 2.
04:50:02 <GregorR> Whoops, one more quickfix.
04:50:05 -!- EgoBot has quit (Client Quit).
04:50:37 -!- EgoBot has joined.
04:51:18 <lament> GregorR: can you do one change to the interpreter
04:51:43 <lament> GregorR: in qbf.py on line 89 add a , at the end of the line
04:52:02 <lament> so that debug info is shown in one line and displayed in the channel
04:53:32 <lament> but only after you change line 89, or you'll change the wrong line 89 :)
04:54:41 <lament> sorry, i guess i changed the interpreter without telling anybody
04:54:49 <lament> print '%.2f' % (abs(memory.contents[i])**2),
04:54:59 <lament> (note the added comma at the end)
04:55:28 <EgoBot> |00> 0.00 |10> 0.00 |01> 1.00 |11> 0.00
04:56:12 <GregorR> Nobody but me realizes how cool this is.
04:56:28 <lament> quantum brainfuck, on the other hand!...
04:56:40 <GregorR> Now we could, for example, implement a daemon to store memos to eachother with no fear of losing them.
04:56:48 <GregorR> Or, at least, much less fear.
04:57:08 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
04:57:16 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
04:57:34 <GregorR> Erk what? That seems right.
04:58:00 <lament> the ordering of the states is the reverse of what it should be
04:58:16 <GregorR> Yeah, should be 00 01 10 11
04:58:32 <lament> it just has the strings reversed
04:59:37 <lament> the direction of the memory tape is to the right
04:59:45 <lament> but the direction in which binary numbers "grow" is to the left
04:59:53 <lament> so when i add a third qubit
05:00:11 <lament> it will show up on the wrong side
05:00:24 <EgoBot> |000> 0.00 |100> 0.00 |010> 0.00 |110> 0.50 |001> 0.00 |101> 0.00 |011> 0.00 |111> 0.50
05:00:38 <GregorR> Ah, right is left, left is right.
05:01:16 <lament> so the trick is to think of these |x> things as pieces of Brainfuck memory tape
05:01:30 <lament> 011 means 3 memory cells that contain 0,1,1
05:02:14 <EgoBot> |000> 0.12 |100> 0.12 |010> 0.12 |110> 0.12 |001> 0.12 |101> 0.12 |011> 0.12 |111> 0.12
05:03:16 <lament> | could mean "start of tape" and > "the direction in which the tape can grow
05:04:28 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
05:05:24 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
05:05:36 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
05:05:44 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
05:06:04 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
05:06:18 <EgoBot> |00> 0.25 |10> 0.25 |01> 0.25 |11> 0.25
05:06:38 <EgoBot> 1 0 |00> 0.00 |10> 0.00 |01> 1.00 |11> 0.00
05:12:41 <lament> !qbf mwahahahahahahahahhaaaaaa>>>>>>>>>>>>>>#
05:12:55 <EgoBot> |000000000000000> 0.00 |100000000000000> 0.00 |010000000000000> 0.00 |110000000000000> 0.00 |001000000000000> 0.00 |101000000000000> 0.00 |011000000000000> 0.00 |111000000000000> 0.00 |000100000000000> 0.00 |100100000000000> 0.00 |010100000000000> 0.00 |110100000000000> 0.00 |001100000000000> 0.00 |101100000000000> 0.00 |011100000000000> 0.00 |111100000000000> 0.00 |000010000000
05:14:22 <lament> the complete output is ~750 KB
05:16:16 <GregorR> Committed latest egobot to files archive.
05:35:31 -!- thematrixeatsyou has joined.
05:37:56 <thematrixeatsyou> (((((((((())))))))))(()()()()()()()()()()()()()()()()())((()()()()())((())(())(())(())(())(())(())(()))(()()()()()()()))((()()()()()()()()())(())()()()()()()())
05:38:56 <thematrixeatsyou> it's called RETURN. want it on the wiki? no implementation yet but I'll get onto it.
05:51:46 <Razor-X> By far the most exciting part of quantum computing is not that we're advancing science, but the fact that you get to say ``Hadamard'' in your head when thinking about programming.
05:51:55 <Razor-X> It's almost as cool a name as ``Backus-Naur''.
05:57:19 <Razor-X> Come on. Don't you all agree?
06:04:18 <thematrixeatsyou> then again, the (((((((((())))))))))(()()()()()()()()()()()()()()()()())((()()()()())((())(())(())(())(())(())(())(()))(()()()()()()()))((()()()()()()()()())(())()()()()()()()) would ring a wtf
06:07:27 <Razor-X> Well, ``Backus-Naur'' is just an awesome cool name.
06:12:44 * GregorR considers writing a persistent daemon to manage the contest.
06:13:34 <Razor-X> Well, we need a voting mechanism.
06:13:39 <Razor-X> In some language or the other.
06:22:10 <Razor-X> If we're doing it in Glass, I want to make it look as much like disfigured smilies as possible.
06:22:27 <Razor-X> Although I was thinking of an INTERCAL version.
06:23:41 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
06:23:43 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
06:23:46 * GregorR doesn't recall whether he even has INTERCAL on the bot ...
06:24:08 <Razor-X> It's not a turing tarpit, unlike most of those.
06:24:38 <Razor-X> INTERCAL forces you to think in... interesting ways, so it's fun.
06:25:13 <Razor-X> I've been meaning to make a BF interpreter in INTERCAL, but I'm too lazy to do it as of now :P.
06:25:38 <Razor-X> I'm not sure if the INTERCAL compiler dynamically allocates arrays either, because dynamic arrays are a total *pain* in INTERCAL.
06:27:53 <GregorR> Hm, is there an INTERCAL interpreter?
06:28:18 <Razor-X> I use the standard C-INTERCAL compiler.
06:28:43 <Razor-X> You'll also have to implement the standard library in it.
06:29:19 <GregorR> To work in EgoBot, needs an interpreter.
06:29:35 <Razor-X> Mmmm. Maybe I'll make one.
06:29:40 <Razor-X> What're the interpreters written in? C++?
06:30:07 <lament> thematrixeatsyou: "The memory allocation is the same as in Brainfuck: 8-bits, planar." - that is wrong
06:30:19 <GregorR> "The only symbols used are the two standard brackets ( and )" ... these aren't brackets.
06:30:19 <lament> thematrixeatsyou: brainfuck never specifies what the memory allocation is.
06:30:34 <Razor-X> GregorR: They are in some countries.
06:30:36 <GregorR> Razor-X: Heww no, fork and exec.
06:31:09 * GregorR never knew they were called brackets anywhere.
06:31:11 <Razor-X> In America they're called parentheses.
06:31:38 <thematrixeatsyou> in new zealand, britain, australia, and virtually all of europe they're called brackets.
06:31:53 <Razor-X> Because ] are also brackets.
06:32:10 <Eidolos> Yes. [ and ] are brackets, ( and ) are parentheses, { and } are braces, < and > are angle brackets, etc.
06:32:35 <thematrixeatsyou> what i mean by memory allocation is that the memory works the same way
06:33:03 <lament> then change the : to ,
06:33:42 <lament> your language seems a bit too much like brainfuck
06:34:00 <lament> Eidolos: write me a quantum brainfuck program!
06:34:17 <Eidolos> I know virtually nothing about quantum mechanics. Sorry.
06:34:18 <Razor-X> I should write a QBF program.
06:34:26 <Razor-X> Now that I know t3h basics.
06:34:44 <GregorR> So, my list of possible states ... at all accurate?
06:35:37 <lament> i guess the boring way to do that would be to implement the standard logic gates (you can just solve for them, it's easy) and then you can write any non-quantum program
06:35:47 <Razor-X> Can you do that in Egobot?
06:35:55 <EgoBot> Use: i <pid> <input> Function: send input to a process
06:36:33 <lament> erk i guess solving for them is not _that_ easy, but still doable
06:36:47 <EgoBot> Please enter 1 or 0: Traceback (most recent call last):
06:36:49 <EgoBot> File "./qbf/qbf.py", line 55, in ?
06:37:49 <EgoBot> Please enter 1 or 0: 1
06:37:59 <Razor-X> Alright. that obviously died :D.
06:38:13 <lament> "Please enter 1 or 0:" is the input prompt
06:38:17 <EgoBot> 1 thematrixeatsyou: ps
06:38:27 <lament> and then it happened to also output 1
06:38:31 <Razor-X> Well, I got a PM with an error in it.
06:38:43 <lament> because you didn't enter 1 or 0 like it asks to.
06:38:43 <Razor-X> <EgoBot> i = int(i) <EgoBot> ValueError: invalid literal for int(): a
06:39:01 <EgoBot> Please enter 1 or 0: 0
06:39:11 <lament> now i entered 1 again, but it output 0.
06:39:43 <EgoBot> Please enter 1 or 0: |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
06:39:51 <Razor-X> Does it operate on the same tape head?
06:39:58 <lament> does what operate on what?
06:41:02 <Razor-X> I mean both of the QBF programs.
06:41:25 <lament> you mean if you run two at once?
06:41:44 <Razor-X> If you run two, one after the other.
06:42:03 <GregorR> It's two separate instances of the interpreter.
06:42:14 <GregorR> You'd have to implement multiprocessing in QBF first :P
06:42:14 <lament> the tape is always initialized to all 1s
06:42:33 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
06:43:07 <lament> (the visible part of the tape is 2 qubits long before you start moving the pointer)
06:43:11 <Razor-X> When you give it a `0' for input, you're setting the cell to 00 ?
06:43:21 <lament> you're setting the cell to 0.
06:43:41 <lament> |00> is the state of _two_ cells.
06:43:55 <Razor-X> It automatically uses two qubits then?
06:44:18 <lament> but you can add more by moving the pointer.
06:44:18 <Razor-X> So if you use <, then you could set the previous qubit?
06:44:31 <EgoBot> |000> 0.00 |100> 0.00 |010> 0.00 |110> 0.00 |001> 0.00 |101> 0.00 |011> 0.00 |111> 1.00
06:44:47 <lament> if you use <, the program will likely die.
06:44:53 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
06:45:05 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
06:45:07 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
06:45:26 <lament> Conclusion: Don't use <
06:45:38 <GregorR> Well, don't < past the beginning of the tape.
06:45:40 <lament> (many brainfuck implementations don't like it either)
06:46:14 <lament> also don't use too many > because the memory required increases exponentially.
06:46:39 <lament> I put a hard limit of 20 in the interpreter just in case.
06:47:05 <lament> Adding an extra qubit makes all operations run twice as slowly.
06:47:18 <lament> On a real quantum computer, there would be no difference in speed.
06:48:00 <Razor-X> But this isn't a real quantum computer :P.
06:49:23 -!- cmeme has quit (calvino.freenode.net irc.freenode.net).
06:51:05 * GregorR wonders why it is that it needed to slow down that much ...
06:51:19 <GregorR> Do you need to do anything with the rest of the qubits when you're looking at some specific one or two?
06:52:17 <GregorR> Hm, other than entanglement?
06:52:19 <lament> GregorR: the operations don't work on qubits, they work on states
06:52:44 <lament> GregorR: any operation will potentially update the probabilities of _all_ states
06:53:22 -!- cmeme has joined.
06:53:54 <lament> because everything could be entangled with everything else
06:54:06 <Razor-X> What does ``entangled'' mean?
06:54:12 <Razor-X> Non-zero probability of occurring?
06:54:25 <lament> Razor-X: the state of one qubit depends on the state of another qubit.
06:54:41 <GregorR> If you observe one and it's 1, and observe the other, it will be 1.
06:54:55 <Razor-X> What determines entanglement, though?
06:55:04 <Razor-X> (Scratch out ``For sure''.)
06:55:07 <GregorR> Doesn't one of the operations cause entanglement?
06:55:43 <lament> Razor-X: here's an example
06:55:45 <Razor-X> It just swaps the probabilities, no?
06:55:56 -!- thematrixeatsyou has quit ("I am NOT cooking up some RETURN to print BYE....").
06:56:13 <EgoBot> |00> 0.00 |10> 0.50 |01> 0.50 |11> 0.00
06:56:17 <GregorR> If & entangled, it'd be problematic ...
06:56:43 <lament> Razor-X: observe the final state.
06:56:51 <lament> |10> and |01> with equal probability.
06:57:03 <lament> So if we observe the first qubit, and find it to be 1, that means the second one has to be 0.
06:57:24 <lament> If we output the first qubit and then the second, the output is always either 1 0 or 0 1
06:57:41 <Razor-X> Oh OK, if they have equal probability.
06:57:55 <lament> so the state of one qubit depends on the state of the other.
06:58:11 <lament> And if we change the state of one, that could potentially affect the state of the other one.
06:58:14 <Razor-X> Only if the probabilities were equal?
06:58:32 <lament> This has nothing to do with probabilities.
06:58:49 <lament> on the other hand, i have no idea how to make the probabilities be NOT equal.
06:58:59 * lament is still not convinced quantum brainfuck is quantum-complete
06:59:01 <Razor-X> Oh I see, ! is the entanglement one.
06:59:10 <GregorR> With QBF, I'm not sure you can make them anything but 50/50
06:59:29 <lament> and if you can't, that seems to automatically mean it's not quantum-complete
06:59:46 <GregorR> What does "Quantum-complete" mean (to you)?
06:59:53 <lament> i'm not a big fan of it anyway, because it's brainfuck-based
07:00:29 <lament> it means (to me) that any valid state for the qubit register can be reached from the initial state
07:00:52 <lament> and i think the only way to do that is by having a parametrized rotation gate
07:01:08 <GregorR> The parameter would need to be infinitely specifiable ...
07:01:17 <GregorR> That is, specifiable to infinite depth.
07:01:38 <lament> it's possible that you don't actually need that for "quantum logic"
07:01:51 <GregorR> I'm gonna say "probable" :)
07:01:57 <lament> i haven't looked into what the existing quantum algorithms require
07:02:14 <lament> but i doubt they're satisfied with 50-50 splits.
07:02:24 <GregorR> Well, zleep for me. Somebody write a daemon that needs persistence :P
07:04:37 <EgoBot> |000> 0.00 |100> 0.25 |010> 0.25 |110> 0.00 |001> 0.25 |101> 0.00 |011> 0.00 |111> 0.25
07:04:54 <lament> that's a cute final state
07:05:08 <lament> either exactly 1 bit is on, or all three bits are on.
07:06:38 <lament> !qbf >%<%!!%>>%<%!!%<.>.>.
07:07:02 <lament> !qbf >%<%!!%>>%<%!!%<.#
07:07:05 <EgoBot> 0 |000> 0.00 |100> 0.00 |010> 0.50 |110> 0.00 |001> 0.50 |101> 0.00 |011> 0.00 |111> 0.00
07:07:38 <lament> but observing one does not in itself destroy the entanglement of the other two.
07:07:41 <lament> !qbf >%<%!!%>>%<%!!%<.#
07:07:43 <EgoBot> 0 |000> 0.00 |100> 0.00 |010> 0.50 |110> 0.00 |001> 0.50 |101> 0.00 |011> 0.00 |111> 0.00
07:07:50 -!- CXII has quit ("If you're reading this, it's probably xchat's fault.").
07:07:55 <lament> !qbf >%<%!!%>>%<%!!%<.#
07:07:59 <EgoBot> 0 |000> 0.00 |100> 0.00 |010> 0.50 |110> 0.00 |001> 0.50 |101> 0.00 |011> 0.00 |111> 0.00
07:08:01 <lament> !qbf >%<%!!%>>%<%!!%<.#
07:08:03 <EgoBot> 1 |000> 0.00 |100> 0.50 |010> 0.00 |110> 0.00 |001> 0.00 |101> 0.00 |011> 0.00 |111> 0.50
07:09:17 <lament> but if you observe two qubits, you will know for sure what the third one is...
07:11:17 <lament> note that if you observe two qubits, the third one will be XNOR of the other two
07:12:07 <lament> (or even if you don't observe them...)
07:19:57 <Razor-X> So that's an interesting way to make an XNOR gate.
07:26:59 <lament> no, it doesn't actually make an XNOR gate.
07:27:27 <lament> an XNOR gate would have two inputs, look at them and produce two things one of which is XNOR.
07:28:05 <lament> and the second, presumably, one of the original inputs.
07:28:24 <lament> (that way the operation is reversible)
07:30:57 <lament> the first bit of the output is XNOR, the second doesnt change
07:31:52 <lament> so the matrix that does that is
07:33:09 <lament> If you can solve for that matrix using combinations of the ones available in QBF, you'll make a xnor gate.
07:33:54 <lament> (that matrix probably has to be normalized)
07:46:41 -!- CXI has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:03:31 -!- bsmntbombdood has quit (Read error: 104 (Connection reset by peer)).
08:04:14 -!- bsmntbombdood has joined.
08:13:48 -!- bsmntbombdood has quit (Client Quit).
08:55:49 -!- bsmntbombdood has joined.
09:37:41 -!- bsmntbombdood has quit ("all your basment are belong to bsmntbombdood").
09:49:10 -!- bdtg has joined.
09:53:41 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
09:53:43 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
09:54:52 <bdtg> !bf >,----------[>,----------]++++++++++++++++++++++<[<]>[++++++++++.[>----------------------]+>]<[[-]<]
09:55:13 <bdtg> !i 1 just testing this thing
09:55:45 <EgoBot> To use an interpreter: <interpreter> <program> Note: <program> can be the actual program, an http:// URL, or a file:// URL which refers to my pseudofilesystem.
09:55:49 <EgoBot> Use: i <pid> <input> Function: send input to a process
10:49:17 -!- bdtg has left (?).
13:42:37 -!- CXI has quit ("If you're reading this, it's probably xchat's fault.").
14:10:34 -!- CXI has joined.
14:52:06 -!- CXI has quit ("If you're reading this, it's probably xchat's fault.").
15:12:52 <EgoBot> bf/, glass/, linguine/
15:13:02 <EgoBot> dice.glass, hangman.glass, urls.glass
15:13:14 <EgoBot> /bin/ls: ./files/glass/dice: No such file or directory
15:41:31 -!- ihope has joined.
15:41:40 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
15:41:42 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
15:42:24 <ihope> !qbf %!!%<%!!%<%!!%<%!!%<%!!%
15:42:28 <EgoBot> Traceback (most recent call last):
15:42:49 <ihope> File "./qbf/qbf.py", line 40, in ?
15:42:54 <ihope> qubit.Hadamard.apply(memory, [qubit_positions[mp]])
15:42:58 <ihope> IndexError: list index out of range
15:43:10 <ihope> That's no fun, eh?
15:43:33 <ihope> !qbf %>%>%>%>%>%>%>%>%
15:45:49 <ihope> !qbf .%.%.%.%.%.%.%.%.
15:46:42 <EgoBot> 1 1 0 0 1 1 1 0 0 0 1 1 1 1 0 0 0 0 1 0 0 1 1 0 0 1 0 1 0 1 0 1 1 1 0 0 0 0 1 0 0 1 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 0 1 1 1 1 0 1 1 1 0 1 0 1 1 1 0 1 1 0 0 0 1 0 0 1 1 1 1 1 0 1 1 1 0 1 0 0 0 0 1 1 1 0 1 1 0 0 1 1 0 1 1 0 1 0 1 1 0 0 1 1 0 1 0 1 0 1 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 0 0 0 1 1 1 0 0 0 0 0 1 0 0 1 1 0 1 1 0 0 0 0 1 1 0 0 0 0 1 0 0 1 1 1 1 1 1 0 1 1 1 1 1 0 1 1 0 0
15:47:06 <ihope> It's a random number generator. :-)
15:48:34 <ihope> Now to implement Shor's algorithm...
15:51:05 <ihope> First, the random number.
15:51:31 <ihope> Okay, the number is 2. The GCD of 2 and 4 is 2, so we're done.
15:52:16 <ihope> Let's try factoring 6 with a number from 1 to 5.
15:53:28 <ihope> Maybe 1 wasn't supposed to be an option. 2 to 5, then.
15:54:08 <ihope> Our number's 4, so the GCD is 2, so 2 is a factor of 6.
15:55:58 <ihope> Let's factor 9, now. The random number is 5, so the function: f(x) = 5^x mod 9.
16:00:45 <ihope> But that function isn't reversible...
16:04:03 -!- GregorR-W has joined.
16:07:44 <ihope> So that's |00000000> -> |00000001>; |00010000> -> |00010101>; |00100000> -> |00100111>; |00110000> -> |00111000>; |01000000> -> |01000100>; |01010000> -> |01010010>; |01100000> -> |01100001>; |01110000> -> |01110101>; |10000000> -> |10000111>.
16:08:13 <ihope> Now we just need a QBF thing that can do that.
16:13:35 <GregorR-W> I agree with lament. We don't need a QBF thing to do anything, we need a quantum language more flexible than QBF.
16:52:50 <ihope> "Quantum INTERCAL" seems quite... well, weird.
17:25:58 <lament> ihope: You can do irreversible stuff in QBF.
17:26:12 <ihope> With observation, yeah.
17:26:22 <lament> i also added two commands, 1 and 0
17:26:32 <lament> that destructively set the current qubit
17:26:47 <lament> of course, they're for debugging only :)
17:28:31 <ihope> !qbf 0.1.0.1.0.1.0.1.
17:28:54 <lament> that doesn't seem right :)
17:28:57 <GregorR-W> sed 's/1/[%!!%]%!!%/g ; s/0/[%!!%]/g'
17:29:20 <ihope> But that's a controlled... thing.
17:29:20 <lament> something's very very wrong :)
17:29:32 <ihope> Loops containing controlled gates are Bad.
17:29:47 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
17:30:08 <lament> this is a horrible horrible bug in the interpreter.
17:33:30 <lament> http://z3.ca/~lament/qubit.py updated
17:34:27 <lament> I still think qubits are boring.
17:34:36 <lament> And we need quantum objects with more states.
17:34:52 <lament> Possibly infinitely many states. :)
17:35:14 <lament> or at least make the states more interesting than 1 and 0
17:35:29 <lament> they could be functions of some kind
17:35:43 <lament> so you can apply a qubit to another qubit...
17:41:12 <lament> more like quantum unlambda
17:42:07 <lament> i suppose that can't work :(
17:42:15 <ihope> Well... how would it work?
17:42:39 <ihope> That just looks like alternate syntax.
17:43:12 <ihope> Well, time to go... somewhere.
17:43:13 <lament> it allows you to turn several different lines of computation at once
17:43:35 <ihope> But I don't see how to construct new ones, or observe anything.
17:43:45 <ihope> If you come up with a spec, let me know :-)
17:43:56 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
19:15:43 <Razor-X> We need more committee members!
19:17:32 <lament> i'm pretty sure there's already something very much like quantum haskell.
19:18:42 <Razor-X> Well, there's already quantum lambda calculus, so I wouldn't doubt it.
19:18:58 <Razor-X> I need to do more research into lambda calculus..., anyone have any convenient free sources?
19:20:21 <Razor-X> Thank you for the tip I would never have guessed about.
19:23:33 <GregorR-W> My fav way to say that is "Yeah, there's a great link page at http://www.google.com/search?q=lambda+calculus "
19:24:01 <Razor-X> Yeah. It's quite convenient.
19:28:20 <lament> Razor-X: just start by learning Unlambda, it's what I did.
19:30:24 <Razor-X> I understand the concept of application and combinators.
19:30:29 <Razor-X> But I mean, there must be more.
19:31:03 <lament> do you understand the concept of functions that only take other functions as parameters?
19:31:25 <Razor-X> You have to understand that to code in Haskell too.
19:31:35 <lament> time to learn something new
19:31:43 <lament> take up piano or something
19:31:49 <Razor-X> That's my next thing, yeah.
19:32:27 <Razor-X> The only thing I really don't understand is if you have something like λxyz.zxyx how you expand that.
19:32:40 <Razor-X> I can intuitively figure it out, but bleh.
19:33:13 <lament> you take the things and apply them to each other in the correct order.
19:34:32 <Razor-X> But doesen't it expand to λx(λy(λz((((z)x)y)x))) ?
19:34:49 <Razor-X> So wouldn't you need like... 4 arguments?
19:37:05 <lament> that's three arguments
19:37:42 <Razor-X> Yeah, I know, but it can't magically just bind the first argument to every x, because the x is in different functions.
19:41:26 <lament> then you don't understand the scoping rules of lambda calculus.
19:42:01 <lament> (lambda x . foo) essentially replaces all instances of 'x' inside foo with the real value of x it got passed.
19:42:13 <Razor-X> Well, I can see that intuitively, yeah.
19:42:23 <lament> Except when something inside also uses x as a parameter.
19:42:59 <lament> (\xyz.zxyx) A = \yz.zAyA
19:43:20 <lament> (\yz.zAyA) B = \z.zABA
19:43:41 <Razor-X> Well, why does A bind to `x' in that case?
19:43:56 <Razor-X> I would think it binds to `y' because that's the closest unbound instance....
19:44:13 <lament> \xyz.zxyx = \x.\yz.zxyx
19:44:13 <Razor-X> I mean logically it does, but the definition makes me think otherwise....
19:44:35 <Razor-X> So it bounds to the outermost unbound function first?
19:51:27 <GregorR-W> About the OMGSOFTWARE_MONOPOLYOMGWTFBBQ
19:51:50 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
19:52:30 <lament> i guess there's a bug in qbf
19:52:40 <EgoBot> Traceback (most recent call last):
19:53:15 <Razor-X> The probabilities aren't supposed to be equal?
19:54:09 <Razor-X> So says the author of EgoBot.
19:54:46 <lament> the bug is that you can't do ! when you're at the end of the tape
19:55:08 <lament> the workaround is to make the tape longer by doing >< first
19:55:24 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
19:55:53 <EgoBot> Traceback (most recent call last):
19:57:48 <EgoBot> |00> 0.00 |10> 0.50 |01> 0.00 |11> 0.50
19:58:16 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.50 |11> 0.50
19:58:32 <EgoBot> |00> 0.25 |10> 0.25 |01> 0.25 |11> 0.25
19:58:46 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00 |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
19:58:53 <EgoBot> |00> 0.25 |10> 0.25 |01> 0.25 |11> 0.25
19:58:58 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
19:59:08 <lament> Razor-X: Hadamard is its own inverse.
20:00:46 <lament> !qbf !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!#
20:00:48 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
20:01:02 <lament> !qbf !%!%!%!%!%!%!%!%!%!%!%!%!%!%!%#
20:01:04 <EgoBot> |00> 0.00 |10> 0.00 |01> 0.00 |11> 1.00
20:03:39 <lament> your MOM uses fortran!
20:04:05 <Razor-X> Yes my Master of Miracles uses FORTRAN.
20:05:47 <Razor-X> Awww. I need to compile GNUPlot first.
20:08:51 <GregorR-W> It's not GNUPlot, it's Gnuplot or gnuplot. The 'gnu' in it has nothing to do with GNU.
20:09:26 <lament> it's just a coincidence.
20:09:28 <GregorR-W> (gnuplot = one author wanted to name it llamaplot, the other newplot, they agreed on gnuplot, since a gnu is an animal not-very-similar to a llama)
20:13:08 -!- ihope has joined.
20:13:43 <ihope> Let's see... split the cursor position in two halves and monitor either the vertical or the horizontal.
20:14:23 <ihope> Get the numbers that correspond to how far it goes up, then how far it goes down, then up, then down...
20:14:55 <ihope> Then take all those modulo 2.
20:15:32 <ihope> Then skew transform.
20:16:17 <ihope> You should end up with a stream that's reasonably random.
20:18:11 <Razor-X> Looks like a Glass program!
20:27:42 <Razor-X> Uggh. Octave takes forever to compile.
20:44:18 <GregorR-W> When I get home somebody remind me to update my hats page.
20:44:33 <GregorR-W> (#esoteric: The world's coolest todo system)
20:46:53 <Razor-X> Let's put a BF daemon notice in.
20:47:45 <GregorR-W> Now there's a good idea for a persistent daemon 8-D
20:50:49 <ihope> !bf_txtgen <GregorR-W> When I get home somebody remind me to update my hats page.
20:51:41 <EgoBot> 621 ++++++++++++++[>++++>+++>++++++++>+++++<<<<-]>++++.>>>+.<++.-------------.++.++++++++.+++.>+++++++++++.<<+++.>>+++++.<<<++.>-------------.>>.+++++++++++++++++.---.<----.<.<+++++++++++.>.<++++++++++++++++++++++++++++++.--.>>++++++.<.<+++.+++++++.--.--------.>.>-.----.--.>.---.<++.<<-.>>++++++++++.<.>-------.<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
20:52:07 <Razor-X> What's with all the +'s at the end.
20:52:41 <Razor-X> !bf ++++++++++++++[>++++>+++>++++++++>+++++<<<<-]>++++.>>>+.<++.-------------.++.++++++++.+++.>+++++++++++.<<+++.>>+++++.<<<++.>-------------.>>.+++++++++++++++++.---.<----.<.<+++++++++++.>.<++++++++++++++++++++++++++++++.--.>>++++++.<.<+++.+++++++.--.--------.>.>-.----.--.>.---.<++.<<-.>>++++++++++.<.>-------.<
20:52:45 <EgoBot> <GregorR-W> When I get home somebody r
20:53:06 <Razor-X> !bf_txtgen Gregor! Update Hats!
20:53:18 <ihope> Oh, that's much better.
20:53:27 <EgoBot> 45 +++++++++++[>+++++++>++++++++++>><<<<-]>+.>+. [270]
20:53:35 <EgoBot> 163 +++++++++++++++[>+++++>++>++++++++>+++++++<<<<-]>----.>>------.>----.++.<---.+++.<+++.-.<++++++++++++++.>>--.>---.---.<++++.>++++.<<.<-------------.>>>----.<.-.<+. [428]
20:53:43 <Razor-X> !bf +++++++++++++++[>+++++>++>++++++++>+++++++<<<<-]>----.>>------.>----.++.<---.+++.<+++.-.<++++++++++++++.>>--.>---.---.<++++.>++++.<<.<-------------.>>>----.<.-.<+.
20:53:44 <ihope> !bf +++++++++++++++[>+++++>++>++++++++>+++++++<<<<-]>----.>>------.>----.++.<---.+++.<+++.-.<++++++++++++++.>>--.>---.---.<++++.>++++.<<.<-------------.>>>----.<.-.<+.
20:54:13 <ihope> !daemon reminder bf +[,]+++++++++++++++[>+++++>++>++++++++>+++++++<<<<-]>----.>>------.>----.++.<---.+++.<+++.-.<++++++++++++++.>>--.>---.---.<++++.>++++.<<.<-------------.>>>----.<.-.<+.
20:54:25 <ihope> Just !ps d and !eof.
20:54:29 <Razor-X> Eh, why the loop? Don't you just want to trigger it once?
20:54:54 <pikhq> Razor-X: It'll trigger when an eof is sent.
20:55:17 <EgoBot> 1 ihope: daemon reminder bf
20:55:41 <ihope> That won't do anything. :-)
20:56:15 <ihope> !daemon reminder bf ,+++++++++++++++[>+++++>++>++++++++>+++++++<<<<-]>----.>>------.>----.++.<---.+++.<+++.-.<++++++++++++++.>>--.>---.---.<++++.>++++.<<.<-------------.>>>----.<.-.<+.
20:56:19 <Razor-X> It only terminates the loop on EOF, eh?
20:56:22 <ihope> Now just don't !reminder.
20:58:05 <Razor-X> Wow. Octave takes longer than even mplayer to compile o_O.
20:58:41 <Razor-X> (And thusly the Linux kernel.)
20:58:43 <GregorR-W> Come sit in my cubicle and compile firefox on Solaris 8. Until you've done at least that compile, shut up.
20:59:00 <Razor-X> Well, it's been compiling for almost an hour now.
20:59:15 <GregorR-W> Firefox on Sol8 is a just-leave-it-running-over-night job.
20:59:19 <pikhq> I recommend DistCC. :p
20:59:29 <Razor-X> If someone wants to donate me the bandwidth.....
20:59:32 <GregorR-W> pikhq: I've tried to get it in :( :( :(
20:59:39 <Razor-X> *Makes girly eyes* Pweeeeez?
20:59:59 <pikhq> Try Firefox on a K-6. . . Got fed up after a few days.
21:00:11 <pikhq> Razor-X: Not at my home computer right now.
21:00:20 <Razor-X> So donate me its bandwidth!
21:00:40 <pikhq> Root on this box would be mightily pissed.
21:00:55 <pikhq> And, since he's a rather close friend of mine, I'd rather not piss him off. ;p
21:01:18 <Razor-X> (Note. I could do this on my own SSH shell, but I'm not for the same reason you're not :D.)
21:11:18 <Razor-X> How does Lambda Calculus use piecewise functions?
21:12:41 <ihope> Piecewise functions? Like, curried ones?
21:13:02 <Razor-X> Like, if x < 0 f(x) = 3, if x >= 0 f(x) = 4.
21:14:11 <ihope> Well, the Haskell form of that is "f x = if x < 0 then 3 else 4", and that's pretty much how it works in lambda calculus.
21:14:35 <Razor-X> So Lambda calculus has if?
21:14:59 <ihope> Well, you can think of boolean values as having "if" built in.
21:14:59 <Razor-X> I know Haskell (I've written some nifty big things, like an IRC bot), but it *is* a programming language after all.
21:15:09 <Razor-X> Oh. It uses the Church booleans?
21:15:25 <ihope> I guess. You can use any booleans you want, as long as they work :-)
21:18:19 -!- bsmntbombdood has joined.
21:18:29 <pikhq> Lambda calculus is also a programming language. . . Bit of a Turing tarpit, but most certaintly a programming language. ;)
21:19:43 -!- CXI has joined.
21:34:26 <Razor-X> ....And Octave is still compiling....
21:35:49 <Razor-X> OMG. It's *finally* compiling octave.cc.
21:36:19 <pikhq> What's it written in? ORK, compiled to Brainfuck, compiled to C, compiled to C++?!?
21:36:29 <Razor-X> It's written in C++ and FORTRAN.
21:36:31 <pikhq> (surely that's got to be inefficient)
21:36:56 <pikhq> FORTRAN. . . I think I'm going to go vomit for a bit.
21:37:08 <Razor-X> It's not that bad, y'know.
21:37:45 <Razor-X> Hey, I'm writing a BF compiler in INTERCAL.
21:38:09 <Razor-X> I could write a compiler too, I think it would be easier.
21:39:00 <Razor-X> ... Not very optimized, but....
21:50:27 -!- oerjanj has joined.
21:53:16 <GregorR-W> Oh I see, nobody else gets hi's :P
21:53:52 <oerjanj> you asked about dynamic arrays in INTERCAL, i made a bit of code for growing arrays in my Unlambda interpreter
21:53:57 <lament> he's just in it for the chicks
21:54:23 <oerjanj> ihope: did you see my question about (())?
21:54:30 <ihope> Growing arrays? Why not just use linked lists?
21:54:58 <oerjanj> because the array is the one implementing a heap
21:55:12 -!- CXI has changed nick to Ceiling_Seal.
21:56:46 <oerjanj> the main problem in growing is that resizing clears the array, as i recall
21:56:59 -!- Ceiling_Seal has changed nick to CXI.
21:57:04 <ihope> And yeah, I saw the question :-P
21:57:39 * ihope wonders why he thought of "ships and shoes and ceiling wax" upon seeing that nick change
21:59:08 * oerjanj suggests ze psychoanalysis for ihope
21:59:35 <ihope> You mean word association?
22:00:54 * ihope collects the million-dollar prize from oerjanj
22:01:56 <oerjanj> perhaps thematrixeatsyou can steal the name for RETURN, now...
22:03:11 <oerjanj> ah, the language list is now spotless
22:04:02 -!- oerjanj has quit ("Leaving").
22:41:17 -!- Asztal has joined.
22:43:38 <Asztal> When the contest page at http://www.esolangs.org/wiki/2006_Esolang_Contest says Befunge, does it mean Befunge-93 or -98?
22:46:04 <GregorR-W> I didn't write the page, but I'd say -98
22:48:02 <ihope> They have to be polyglots. :-P
22:50:36 <Asztal> I don't know -98 since I never finished my interpreter for it :(
22:51:20 <GregorR-W> Finish your interpreter so I can add it to EgoBot :P
22:52:03 <Razor-X> I'm also going to add a clause about licensing.
22:52:39 <Razor-X> I will release the code, contestants. I hope that was implied by the rules.
22:52:54 <Razor-X> Hmmm. Do you all want it under the GPL or the BSD license?
22:53:19 <Razor-X> Or something more strict or less strict?
22:53:47 <pikhq> For this, I'd say BSD.
22:54:11 <Asztal> release the contestants' code, you mean?
22:54:19 <Razor-X> Yeah, the contestants code.
22:54:33 <Asztal> Public domain! Get rid of it I say :)
22:54:34 <pikhq> Well, BSD without ad clause.
22:54:47 <Razor-X> Are you all sure you want something as free as PD or MIT?
22:54:54 <GregorR-W> How about, it's up to the contestant, but if they say nothing it's assumed to be MIT?
22:55:48 * pikhq would prefer FSF-approved, but. . .
22:55:50 <Razor-X> Someone should release it under AFPL and then change it, for kicks :P.
22:56:16 <Asztal> MPL... (in tiny letters: Microsoft Permissive License)
22:57:26 <GregorR-W> pikhq: OMG ... normally I would've said FSF-approved ... this damn business is rotting my FS brain *sobbles*
22:59:05 <GregorR-W> Reason to hate the term "Open Source" #0: Big business loves it.
23:00:31 <pikhq> Reason #1: Morals > better development methedology.
23:00:59 <Razor-X> Flipside reason: It's Communism (TM).
23:01:20 <Razor-X> We all know that Americans are raised from birth to hate the word by assosciation.
23:01:31 <Razor-X> ``That's a bad dog, yes it is... COMMUNISM ... yes it is.''
23:01:32 <GregorR-W> Flipside reason #2: GOD HATES FAGS. Erm, Free Software. Whatever.
23:02:04 <GregorR-W> Flipside reason #3: If English is good enough for Jesus, it's good enough for Texas. Open Source too.
23:02:48 <pikhq> Flipside reason #4: ESR supports guns. Guns are cool. ESR supports Open Source, too. Therefore, Open Source is too. QED.
23:03:11 <Razor-X> Ah. Awesome logical flaws.
23:03:37 <Razor-X> That's one my mom labors under, though.
23:04:05 * pikhq is convinced that man is one of the most illogical things on the face of the planet. . .
23:04:13 <Razor-X> ``All Muslims support Hezbollah. Hezbollah is evil. Therefore all muslims are evil.''
23:04:27 <Razor-X> Aside from the great axioms there.... :D.
23:06:16 <pikhq> My favorite axiom comes from #gnu. . .
23:06:24 <pikhq> ams is always right.
23:06:45 <Razor-X> The American Mathematical Society?
23:07:08 <pikhq> No, Alfred M. Szmdit.
23:07:09 <GregorR-W> Razor-X: Have you known the American Mathematical Society to ever be wrong?
23:07:47 <Razor-X> Because even if I thought they were logically wrong, I'd use Doublething to change that.
23:07:47 <pikhq> He's in charge of the gnu-system ATM.
23:08:21 <bsmntbombdood> the man page for clock():http://dark-code.bulix.org/mrh2e6-11342
23:08:48 <Razor-X> I should get started writing mah BF CPU.
23:08:59 <Razor-X> If anyone has an FPGA, 'twould be nice.
23:20:56 * ihope bends his deck of cards
23:21:01 <ihope> They're not shuffling.
23:24:26 <Razor-X> Wiki page updated for Licensing, specified the preferrable use of C-INTERCAL and Befunge-98, and and requested that the next participants are committee members.
23:25:04 <Asztal> Does my being based in GMT present a problem?
23:25:22 <GregorR-W> Nah, it's not a everybody-sit-down-at-once-and-write type contest.
23:25:28 <Razor-X> ``All times are posted in respect of UTC''.
23:25:58 <Razor-X> I've tried to make this as professional as I can.
23:27:13 <ihope> It's surprisingly easy to to double those short words ;-)
23:27:56 <Razor-X> The alt.lang.intercal post brought in some new contestants.
23:28:01 <Razor-X> I think we need to expand....
23:28:13 <Razor-X> Yes, it maybe a sea of stupidity, but bear with me!
23:28:33 <Asztal> I'm sure gamedev.net would be receptive to it
23:28:48 <Razor-X> Spread it wherever you can.
23:28:52 <Asztal> I can spam^inform them for you
23:29:09 <Razor-X> I do hope we get more committee members, since we only have 2 now.
23:29:16 <Razor-X> But we have a good 10/11 participants.
23:29:45 <Razor-X> It seems the languages of choice are INTERCAL, Befunge and Unlambda/LazyK.
23:30:09 <Eidolos> I bet Slashdot would frontpage it.
23:30:14 <pikhq> Going to need to pick up Befunge, then.
23:31:22 <Razor-X> Oh, I didn't say BF, did I?
23:31:37 <Eidolos> They frontpage the NetHack tournament announcements.
23:31:48 <Razor-X> That's why I think they'll do it to the Esolang competition.
23:32:06 <Razor-X> I'd do it, but they may have blacklisted me after my attempt to spread a paper against the Spread Firefox movement and Google.
23:32:11 <GregorR-W> Do not put the baby in the esoteric programming competition.
23:32:19 <Razor-X> Because it is Anti-Slashdot, of course :P.
23:33:02 <lament> why are unlambda and lazyk grouped together?
23:33:17 <Razor-X> Because every contestant who wanted Unlambda also wanted LazyK.
23:33:18 <ihope> Because they're the same. :-P
23:33:26 <Razor-X> And LazyK has Unlambda in it :P.
23:33:46 <lament> Your MOM has unlambda in it.
23:34:03 <Razor-X> Yes, my Master of Miracles does have Unlambda in it.
23:35:05 <ihope> "That's why I think they'll do her to the Esolang competition." <- hmm...
23:36:04 <Razor-X> Nah. Mah mom 'aint a Master Of Miracles.
23:36:11 <Razor-X> She's a Pain In The Arse, though.
23:38:55 <Razor-X> !bf +++++++++++++++++++++++[>++++++++++++++++++++<-]>.
23:39:11 <Razor-X> !bf +++++++++++++++++++++++[>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<-]>.
23:40:12 <pikhq> I bork it. Schweet.
23:40:30 <EgoBot> 27 ++++++++[>++++>>><<<<-]>+.. [26]
23:40:48 <GregorR-W> !bf_txtgen abcdefghijklmnopqrstuvwxyz
23:40:49 <Razor-X> Wow. That's horribly ineffecient.
23:41:10 <EgoBot> 103 ++++++++++++++[>+++++++>+++++++>>++<<<<-]>-.+.+.+.+.>++++.<++.+.>+++.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+. [910]
23:41:14 <GregorR-W> Razor-X: Heheh, it's a genetic algo. If I let it go more rounds, it would eventually clear that out.
23:41:18 <Razor-X> !bf ++++++++[>++++>++++<<-]>.>.
23:41:21 <puzzlet> 정답! (EgoBot, 21621.000000 초)
23:41:35 <pikhq> !bf +[.,]++++++++[>++++<-]>+..
23:41:53 <Razor-X> !bf ++++++++[>++++>++++<<-]>.>.
23:42:14 <GregorR-W> EgoBot answered a trivia question properly XD
23:42:33 <GregorR-W> <puzzlet> Right answer! (EgoBot, 21621.000000 seconds) <puzzlet> -1. Read afterwords: Hab
23:43:20 <pikhq> !i 1 Indeed I do.\n
23:44:53 <GregorR-W> !bf_txtgen wants you to stop harassing him.
23:45:18 <EgoBot> 224 ++++++++++++[>++++++++>++++++++++>+++++++++>+++<<<<-]>>-.<+.>>++.++++++.-.>----.<<++.<++++++++++++++.>----.>>.<+.-----.>.<<--.+.>.<----.>>.<-------.-------.<<+++.>>.<<+..----------.>--.<--.>>>.<+++++++.+.<-.>>++++++++++++++. [652]
23:45:26 <pikhq> !i 1 /me loves being abused\n
23:45:29 <GregorR-W> !bf_txtgen ACTION wants you to stop harassing him.
23:45:30 <EgoBot> /me loves being abused
23:45:47 <Razor-X> Let's overload the memory!
23:45:56 <EgoBot> 283 +++++++++++[>+++++++>++++++>+++>++++++++++<<<<-]>>-.++.<+++++++.>++++++.++++++.-.>-.<+++++++++++++++++++++++++++++++++++++++++.<+++++++++++++.+++++++++++++.>---.-.>.<++++++.<+.>----.>.<-.<.>>.<-.+.<.+.>>.<<--------.-------.>--.<.>+..<++++++++.>>>.-------.<.>+.+.++++.<++++++++++++++. [983]
23:46:11 <GregorR-W> !bf +.++++++++++[>+++++++>++++++>+++>++++++++++<<<<-]>>-.++.<+++++++.>++++++.++++++.-.>-.<+++++++++++++++++++++++++++++++++++++++++.<+++++++++++++.+++++++++++++.>---.-.>.<++++++.<+.>----.>.<-.<.>>.<-.+.<.+.>>.<<--------.-------.>--.<.>+..<++++++++.>>>.-------.<.>+.+.++++.<++++++++++++++.
23:46:15 <EgoBot> <CTCP>ACTION wants you to stop harassing him.
23:46:23 <pikhq> !i 1 ACTION is getting abused too much.\n
23:46:25 <ihope> !bf_txtgen aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
23:46:27 <EgoBot> hACTION is getting abused too much.
23:46:34 <pikhq> !i 1 ACTION is getting abused too much.\n
23:46:36 <EgoBot> ACTION is getting abused too much.
23:46:41 <GregorR-W> !glass {M[m(_e)(Emote)!"tests it here."(_e)e.?]}
23:47:01 <EgoBot> 115 ++++++++++++[>++++++++>++++++++>><<<<-]>>+....<+.....>.<.>......<..>.<.>...<.>.....<...>.<......>..<.>....<...>..<. [998]
23:47:19 -!- Asztal has quit ("Smoke me a kipper, I'll be back for breakfast").
23:47:48 -!- EgoBot has left (?).
23:48:05 <Razor-X> I can't do that. I'm a girl.
23:48:07 <GregorR> You're flooding the channel anyway.
23:48:09 * ihope laughs like a maniac
23:48:13 <GregorR> Razor-X: That's what strap-ons are for.
23:48:39 <pikhq> !i 1 Lesbians don't have innocence.\n
23:48:42 <Razor-X> So uh... strap-on mode off.... I guess?
23:49:01 <GregorR> It'll be back in a moment, I'm reloading it to drop all your programs.
23:49:12 -!- EgoBot has joined.
23:49:25 <Razor-X> !bf_txtgen Razor-X is sorry for raping you.
23:49:31 <ihope> Oh, did you get the reminder thingy?
23:49:31 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
23:49:33 <EgoBot> 1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl
23:49:39 <EgoBot> 1 EgoBot: daemon reminder reload
23:49:39 <Razor-X> Awww. He forgot the reminder.
23:49:51 <EgoBot> 247 ++++++++++++[>+++++++>++++>++++++++>++++++++++<<<<-]>--.>>+.>++.-----------.+++.<<---.<++++++.>-------------.>++++++++.>+.<<.>>.<++++++.+++..>++++++.<<.<++++++++++++++.>>---.+++.<.>.<<-----.>>--.<<++++++++.>>--.<<--.>.>>.<+.>----.<<++++++++++++++. [993]
23:50:02 <Razor-X> !bf ++++++++++++[>+++++++>++++>++++++++>++++++++++<<<<-]>--.>>+.>++.-----------.+++.<<---.<++++++.>-------------.>++++++++.>+.<<.>>.<++++++.+++..>++++++.<<.<++++++++++++++.>>---.+++.<.>.<<-----.>>--.<<++++++++.>>--.<<--.>.>>.<+.>----.<<++++++++++++++.
23:50:05 <EgoBot> Razor-X is sorry for raping you.
23:50:09 <pikhq> !malbolge This isn't valid, but I don't care.
23:50:13 <EgoBot> invalid character in source file
23:50:27 <ihope> That's not the reminder...
23:50:28 <Razor-X> What happened to the reminder.... ?
23:50:49 <Razor-X> I think EgoBot is going through a Midlife Crisis.
23:51:06 <Razor-X> Egobot: It Works, Sometimes.
23:51:07 <GregorR> !daemon repeater glass {M[m(_i)I!(_o)O!(_s)S!(_x)<1>=(_c)""=/(_x)(_c)(_c)*(_i)l.?(_s)a.?=(_c)*(_o)o.?\]}
23:51:19 * Razor-X goes back to the Glass tutorial.
23:51:32 <GregorR-W> (must wait 15 minutes before reloading)
23:51:47 <GregorR-W> Razor-X: Feel free to ask me any questions, I am the world's foremost expert.
23:52:20 <Razor-X> Can you make a better tutorial so I don't have to look back at that document again? :P.
23:52:39 <Razor-X> !repeater Sometimes I like to eat mangoes.
23:52:46 <GregorR-W> Please don't fill up the repeater's buffer
23:53:07 <GregorR-W> No, it doesn't, it just keeps on adding.
23:53:13 <GregorR-W> That's how it's useful as a persistence test.
23:53:24 <ihope> !daemon repeater glass {M[m(_i)I!(_o)O!(_s)S!(_x)<1>=(_c)""=/(_x)(_c)(_c)*(_i)l.?(_s)a.?=(_c)*(_o)o.?\]}
23:53:29 * Razor-X goes back to the Glass tutorial.
23:53:36 <ihope> !undaemon repeater
23:53:38 <GregorR-W> Razor-X: The wiki page, or the IRC log?
23:53:57 <Razor-X> I suddenly got a very good idea. I'll remove all non-Glass related lines from it!
23:54:05 <Razor-X> That way, it won't take up a large amount of RAM!
23:54:18 <ihope> There, now you can use !repeater to spam me.
23:54:18 <Razor-X> I'm just so smart, I scare myself sometimes.
23:54:28 <Razor-X> !repeater I like eating banannas too.
23:54:44 <ihope> {EgoBot} I like eating banannas too.
23:55:16 <Razor-X> I got an idea earlier today for a Conlang.
23:55:26 <Razor-X> But, I shall save the fruitition for later.
23:55:38 <Razor-X> But I'm not as awesome as ihope yet :(.
23:56:10 <Razor-X> In the meantime, I'll continue on my INTERCAL->BF interpreter, some QBF programs, my Verilog BF CPU, and writing some documentation for the Esolangs I like.
23:56:21 <GregorR-W> !daemon repeater glass {M[m(_i)I!(_o)O!(_x)<1>=(_c)""=/(_x)(_c)*(_c)(_i)l.?=(_o)o.?\]}
23:56:48 <GregorR-W> Now it'll output the last line you entered when you enter a line.
23:56:49 <EgoBot> 1 ihope: daemon repeater glass
23:56:51 <EgoBot> 2 GregorR-W: daemon repeater glass
23:57:03 <GregorR-W> !daemon repeater glass {M[m(_i)I!(_o)O!(_x)<1>=(_c)""=/(_x)(_c)*(_c)(_i)l.?=(_o)o.?\]}
23:57:32 * ihope gets his own repeater
23:59:48 <ihope> !ihope_repeater :-(