#computability theory

[ssjkamui-digitalphoenixug]

Konrad Zuse und der Z3: Vor 80 Jahren erfand ein Deutscher den ersten Computer

Auf den Tag genau vor 80 Jahren stellte Konrad Zuse der Welt den ersten Computer vor. Was viele nicht wissen: Der Berliner Ingenieur veröffentlichte auch philosophische Schriften, die auf technisch-naturwissenschaftlicher Basis eine Weltsicht vermitteln, die sich später in Filmen wie Matrix wiederfand. Dieser Beitrag erschien zuerst in COMPACT 08/2020. Die großen Meilensteine unserer Geschichte beleuchtet unsere Sonderausgabe Schicksalstage der Deutschen: Von Karl dem Großen bis zum Fall der Mauer. Hier mehr erfahren.

Man sieht einen weiten, grenzenlosen Raum, in dem Farben und Linien zu verschwimmen scheinen. Überall sind gleichmäßig Knotenpunkte eines Rasters verteilt, dazwischen zucken rote Informationsblitze. Sie transportieren Daten kreuz und quer durch die unendlich wirkenden Weiten, unaufhörlich, ruhelos. Der Blick geht von oben herab in die Tiefe, auch dort leuchtet alles hell, ist alles in Bewegung. Das System, das man hier vor Augen hat, produziert eine endlose Rechnung, es hält die Welt am Laufen. Die Realität, derer wir gewahr werden, ist letztendlich eine virtuelle.

Was nach einer Szene aus dem Science-Fiction-Film Tron oder einem Video von Kraftwerk klingt, ist in Wirklichkeit ein Ölgemälde mit dem vielsagenden Titel Rechnender Raum. Dessen Schöpfer ist heute allerdings nicht unbedingt als Künstler bekannt, sondern vor allem als Vater des Computers. Den ersten funktionsfähigen digitalen Rechner dieser Art, den Z3, stellte er vor genau 80 Jahren, am 12. Mai 1941, in Berlin vor. Sein Bild Rechnender Raum entstand 1967 – und illustrierte seine philosophische Idee von der Wirklichkeit.

Genialer Tüftler

Zuse arbeitete anfangs nicht im Bereich der Elektronik, sondern in der Luftfahrt. Die Malerei war eine seiner frühen Leidenschaften – inspiriert wurde er dabei hauptsächlich vom italienischen Futurismus. Außerdem war er zeitweise als Reklamezeichner tätig. Seine Bilder verkaufte er, um sein Studium zu finanzieren, das er 1935 in Berlin mit Diplom abschloss. Danach kam er als Statiker bei den Henschel-Flugzeugwerken in Schönefeld unter. Nach Dienstschluss tüftelte er daheim in seiner Erfinderwerkstatt.

An seinem Broterwerb störte ihm vor allem eines: Er musste immer und immer wieder ein und dieselben Rechnungen durchführen. Konnte dies nicht auch eine Maschine erledigen?

Wie der britische Mathematiker Charles Babbage (1791–1871), der Erfinder der sogenannten Analytical Engine, dachte Zuse dabei zunächst an ein mechanisches Gerät, doch das erwies sich schon bald als unpraktikabel. Der Z1, den er 1938 fertigstellen konnte, las die Programme von gelochten Kinofilmstreifen ab, arbeitete aber unzuverlässig und hakte oft. Erst die Verbindung von Elektronik und Mechanik führte zum Erfolg: 1941 realisierte er, inzwischen selbständig, mit dem Z3 seine bekannteste Erfindung.

Im Gegensatz zu heutigen Computern stellte der Z3 fundamentale Logikfunktionen nicht mithilfe von Widerständen dar, sondern per elektrisch steuerbaren Schaltern. Durch diese Art der Konstruktion war er zwar langsamer als der 1942 im Auftrag des US-Militärs entwickelte ENIAC, aber weitaus leichter zu bedienen.

Zuses Rechner erfüllte als Erster das Merkmal der Turing-Vollständigkeit. Dieser liegt das hypothetische Modell einer sogenannten Turingmaschine (benannt nach dem britischen Logiker Alan Turing) zugrunde: Eine fiktive Apparatur, die ein Band nach links und rechts bewegen, die aktuelle Stelle auslesen und in Abhängigkeit vom Inhalt Programmcodes ausführen und das Band neu beschreiben kann. Somit war der Z3 in der Lage, jede mathematische Funktion zu berechnen.

Während der ENIAC zum Neuprogrammieren jedes Mal auseinander- und wieder zusammengebaut werden musste, besaß Zuses Rechner – wie heutige Computer – einen Befehls- und Datenspeicher sowie ein Rechenwerk. Mit Plankalkül hatte sein Erfinder dazu eigens eine Programmiersprache entwickelt. Der Z3 nahm damit vieles vorweg, was erst mit dem 1946 fertiggestellten EDVAC, dem Nachfolger des ENIAC, Standard werden sollte.

Im letzten Kriegsmonat 1945 verschlug es Zuse zunächst ins Allgäu. Im beschaulichen Hopferau entwickelte er den Z3 zum Z4 weiter. 1948 konnte er seinen neuen Rechner erstmals in Betrieb nehmen und damit die Milchgeldrechnungen der örtlichen Sennerei Lehern erstellen. Deren Inhaber wollte zunächst nicht glauben, dass der Ingenieur aus Berlin mit seiner Apparatur die Milchpreise schneller berechnen könne als seine eigenen Fachleute.

Ein Jahr später gründete der Erfinder in Neukirchen bei Fulda die Zuse KG und vertrieb seine Computer in Zusammenarbeit mit Heinz Nixdorf. Das Unternehmen wurde 1964 von der Schweizer Firma Brown Boveri & Cie. übernommen, 1971 sicherte sich Siemens 70 Prozent der Anteile. Zuse hatte sich inzwischen aus der Firma zurückgezogen, widmete sich wieder der Malerei – und entwickelte überaus bemerkenswerte philosophische Ideen auf naturwissenschaftlicher Basis, die die Welt, wie sie uns als Gewissheit erscheint, radikal infrage stellt.

Universale Turingmaschine

Im Jahr 1970 veröffentlichte er ein Buch, das den gleichen Namen trägt wie sein eingangs erwähntes Gemälde: Rechnender Raum. «Es geschah bei dem Gedanken der Kausalität, dass mir plötzlich der Gedanke auftauchte, den Kosmos als eine gigantische Rechenmaschine aufzufassen», so Zuse.

Seine These: Die materielle Welt, wie sie sich uns offenbart, ist nicht real, sondern eine Simulation, die mit einer gigantischen Rechenmaschine erzeugt wird. Wir leben also buchstäblich in einer Matrix, wie sie viele Jahre später von Hollywood in der gleichnamigen Filmtrilogie dargestellt wurde.

Grundlage für Zuses Annahme ist seine Beobachtung, dass die Expansion von elektromagnetischen Feldern, Gravitationsvektoren und Gasen erstaunlich gut mit der sogenannten Automatentheorie erklärt werden kann. Einer der simpelsten Automaten ist ein Lichtschalter, der durch Tastendruck vom Zustand «Licht aus» in den Zustand «Licht an» übergeht.

Die ausgefeiltesten, allerdings speicherbegrenzten Automaten sind jene, die sozusagen Turing-vollständig sind, also unsere heutigen Computer, Smartphones oder Tablets – und der perfekteste Automat wäre demnach jener, der einer universalen Turingmaschine mit unendlichem Speicher entspräche. Wenn nun ein Automat einen anderen simulieren könnte (und umgekehrt), gälten beide als Äquivalent.

Zuses These setzt genau hier an: Da sehr viele Teile der theoretischen Physik mithilfe von Computern simulierbar sind, könne man anhand der Automatentheorie daraus ableiten, dass die vermeintlich wirkliche Welt eine Computersimulation sei. Je besser diese Simulation funktioniere, desto wahrscheinlicher sei es, dass es sich bei der Wirklichkeit auch nur um eine Fülle von Rechenvorgängen auf einem Computer handle.

Damit befindet sich Zuse in Übereinstimmung mit wesentlich älteren philosophischen Theorien, die davon ausgehen, dass die materielle Welt nur Abbild von Informationen sei – und diese Informationen die eigentliche Wahrheit wären. Man findet diese Vorstellung schon bei Platon und Pythagoras, aber auch in der Kabbala, im christlichen Gnostizismus und im Buddhismus. Und in der hermetischen Alchemie ist das, was mit dem Begriff Azoth (auf Deutsch in etwa mit «Weltgeist» zu übersetzen) beschrieben wird, nichts anderes als ein Informations-Urstoff, der die Grundlage alles Bestehenden bildet. Zuses Rechnender Raum untermauert solche Konzepte wissenschaftlich.

«Es geschah …, dass mir plötzlich der Gedanke auftauchte, den Kosmos als eine gigantische Rechenmaschine aufzufassen.» Konrad Zuse

Zuses philosophische Ideen wurden unter anderem von Stephen Wolfram weiterentwickelt. In seinem 2002 erschienenen Buch A New Kind of Science (Eine neue Form der Wissenschaft) beschrieb der britische Physiker und Informatiker das Universum als ein digitales Wesen, das auf «simple programs» (einfachen Programmen) basiert.

Andere Autoren hingegen meinten, das Universum entspräche weniger einem zellulären Automaten als eher einem riesigen artifiziellen neuronalen Netz. Damit wäre es eine gigantische Künstliche Intelligenz, die sich sogar auf das Verhalten der Menschen einstellen könnte. Eine Vorstellung, die bei dem einen oder anderen für gewisse Paranoia sorgen dürfte.

In der Populärkultur tauchen Zuses Ideen zum Beispiel bei dem US-amerikanischen Science-Fiction-Autor Philip K. Dick (The Man in the High Castle) auf. Dieser wies darauf hin, dass so gut wie jede Religion davon ausgehe, dass sich der Mensch in einer Scheinwelt befände und die Ursünde des Menschen darin bestehe, vergessen zu haben, dass das irdische Leben nur eine Art Simulation sei. Und natürlich spielen Filme wie Tron, Matrix oder auch das Anime Digimon mit solchen Vorstellungen.

Abschied vom Materialismus

Man kann Zuses Ansatz als typische Ausprägung des aufgeklärten Westens kritisieren, der die Welt als ein perfektes Uhrwerk (oder eben als Computer) betrachtet. Unter dieser Prämisse kann der Mensch an Macht gewinnen, wenn er die Regeln des Systems (oder den Code) erlernt und für sich nutzt.

Man kann durch den Rechnenden Raum aber auch zu einem anderen Schluss gelangen: Wenn materieller Erfolg und das Streben nach materiellen Gütern sinnlos ist, weil sich alles nur in einer großen Computersimulation abspielt, ist das Anhäufen von Reichtümern ungefähr genauso relevant wie das Sammeln von Goldmünzen bei Super Mario.

Zuerst veröffentlicht auf

Konrad Zuse und der Z3: Vor 80 Jahren erfand ein Deutscher den ersten Computer

Auf den Tag genau vor 80 Jahren stellte Konrad Zuse der Welt den ersten Computer vor. Was viele nicht wissen: Der Berliner Ingenieur...

[name204act]

Recursive Growth

New Post has been published on https://videopress.newonline.help/2020/10/07/recursive-growth/

Recursive Growth

Based around the video: https://www.youtube.com/watch?v=9HI8FerKr6Q and https://www.youtube.com/watch?v=6LVtqrv_QfA

Done in Houdini with a sop solver, some vdb nodes (to maintain a uniform detail) and a velocity field. I have a few more in the works, with different shapes / shaders.

Shoutout to Eetu on odforce as well, for giving a basic explanation of it which helped me figure it out.

Hip File for those interested. It’s basically measure curvature, use as mask to displace/advect along gradient and vel field. Pretty simple for how neat it looks! It, for whatever reason is a bit crashy. Something with the sop solver and vdbs seems to make Houdini crash more often, usually when interactively hitting esc to stop the sim.

http://fx-td.com/content/misc/recursive_growth_v2.hiplc Likes: 678 Viewed: source

[hitbrother-blog]

Complexity Theory - Calculates Complexity of Problem

Complexity Theory – Calculates Complexity of Problem

Complexity theory is a central topic in theoretical computer science. It has direct applications to computability theory and uses computation models such as Turing machines to help test complexity.

Complexity theory helps computer scientists relate and group problems together into complexity classes. Sometimes, if one problem can be solved, it opens a way to solve other problems in its complexity…

View On WordPress

[goedel-rhymes-with-turtle]

some pedant on the internet: a computer, having a finite amount of memory, is strictly weaker in computational ability than a Turing machine, having at most the power of a finite state machine.

me, smarter than them: -holding up several usb drives on a keychain- oh really? :)

[showwaysnow]

Sacred Geometry Software — OmniGeometry

Learn how you can create your own Sacred Geometry art, designs and mandalas in only a few minutes using our interactive Recursive Geometry Generator. https://showwaysnow.com/sacred-geometry-software-omnigeometry/ #AdobePhotoshop, #ComputabilityTheory, #ComputerProgramming, #Computing, #Designer, #DesignerSoftware, #DivideAndConquerAlgorithm, #FlowerOfLife, #ImageEditingSoftware, #Mandalas, #Merkaba, #MutualRecursion, #NassimHaramein, #Recursion, #ResonanceProject, #SacredGeometry, #SacredGeometrySoftware, #SeedOfLife, #SelfReference, #SoftwareEngineering, #TechnologyInternet, #TheoreticalComputerScience, #TheoryOfComputation #BestSoftwareServicesProvider

[scientiststhesis-at-pillowfort]

Quantum computation and quantum information

Finally, after a whole lot of posts about quantum mechanics, I'm ready to talk about what I wanted to talk about: quantum computing.

I have explained quite a bit about computability theory, or its classical version anyway. As of the writing of this post, I'm not done - there are things I still haven't mentioned, like the Halting Problem. Still, this is sufficiently distinct from classical computation that I don't think anyone will be confused.

On to definitions. Quantum computation is... computation on quantum information! And quantum information is... information that's quantum! And information is...

...

Uh...

I dunno, man, don't ask me complicated questions.

But anyway. In the same way we have bits, 0 and 1, that form strings that encode messages and information, and on which we operate, and that's classical computation, we have qubits, |0⟩ and |1⟩, that form strings etc etc.

But, as we all know by now (one hopes), quantum mechanical phenomena are very different from classical. And we can't really be straightforward in converting classical information to quantum, and vice-versa. Qubits get entangled, and into superposition, and interfere with each other in all those cute ways we've seen, which ends up creating a whole new and exciting field of knowledge!

Ok, so, let's start with the basics.

Qubits

So, as I said, the basic units of quantum information are the quantum versions of the classical bits, the so-called qubits. For each qubit, we have two orthonormal states, |0⟩ and |1⟩.

How do we implement a qubit? Don't know, don't care. I've shown in my examples ways in which we can do it: the polarisation of a photon and the direction in which it's going are two possibilities. In practice, this isn't as easy as I'm making it sound, and building physical quantum computers is in fact a very delicate task that needs to strike a precise balance between isolation to guarantee quantum evolution and connection with the world to guarantee that we can actually perform computation.

But in the end, it makes no difference. All we need to know in order to perform quantum computation is that we have basic quantum mechanical systems that possess a pair of states as orthonormal basis.

And as you know by now, quantum mechanical systems exist in what are complex superpositions of states. Therefore, a given qubit will normally be in state |ψ⟩ = α|0⟩ + β|1⟩, and to make our lives easier, we will henceforth suppose that |α|2 + |β|2 = 1 so that our qubit will always be in a normalised state.

Now, you may recall that any given complex number z can be expressed as |z|eiφ where φ is a real number; this follows from Euler's Formula. And in particular, for any real φ, |eiφ| = 1. So our arbitrary state |ψ⟩ can be expressed as

for some combination of real γ, θ and φ.

Why is this true? Since we have stipulated that |α|2 + |β|2 = 1, we might as well say that |α| = cos(θ/2) and |β| = sin(θ/2). Once again, we can express the complex numbers α and β themselves as the multiplication of their respective moduli and e to an imaginary power, from which the above follows.

But it turns out that the eiγ factor is completely irrelevant. It has no observable consequences whatsoever and can be completely ignored. I will show that in a bit. This means, therefore, that we can simplify even further our representation:

The number γ is frequently called a global phase while φ is frequently called a relative phase. From this we conclude that the global phase is irrelevant, while the relative phase is meaningful (which will also be shown). Furthermore, the above reduction to θ and φ with an imaginary element only in the |1⟩ basis leads to a useful visual representation of one qubit:

That is called a Bloch sphere, and we can represent a single qubit as a point on its surface. Unfortunately, there is no simple generalisation of the Bloch sphere to more qubits (as they would understandably need more dimensions to be visualised and humans aren't notoriously good at visualising more than 3 dimensions).

As I've already discussed, it's impossible to know the exact state of an arbitrary qubit, which means that even though there's an infinity of possible values for |ψ⟩ to take, we can only extract finite information from it (in the form of repeated collapse by measurement).

And that is something to bear in mind, too: you will only observe states |0⟩ and |1⟩, and your results will be probabilistic in nature, depending on your observations. That's another fundamental difference between quantum computation and classical computation.

And then, what happens when we add more qubits? The hint was given in the two-photon experiment: we then have the basis states |00⟩, |01⟩, |10⟩, and |11⟩. And the generalisation follows for n qubits which will normally be in a superposition of 2n basis states.

A few noteworthy states are:

And the famous Bell states:

Quantum circuits

So now we have defined our qubits. How do we perform computation on them?

In a similar fashion to classical circuits, we have logical gates. In a dissimilar fashion, we have an infinite number of them: one for each possible unitary operator.

Consider the one bit/qubit case. Classicaly, all we can do with one bit is negate it: 0 becomes 1, 1 becomes 0. But every one-qubit unitary operator is a possible gate. A few of the most famous ones are the following:

Let's look at some of them.

The Pauli-X gate is the closest thing quantum circuits have to the classical NOT gate. If you apply it on the states |0⟩ and |1⟩ (using their matrix representation), you'll see it takes |0⟩ to |1⟩ and vice-versa. Therefore it takes an arbitrary state α|0⟩ + β|1⟩ to the state β|0⟩ + α|1⟩.

The Pauli-Z gate takes |0⟩ to itself and |1⟩ to -|1⟩. Therefore it takes the arbitrary state α|0⟩ + β|1⟩ to the state α|0⟩ - β|1⟩. It's also a special case of the phase shift gate of which I'll speak shortly.

The Hadamard gate is a very interesting one: it takes |0⟩ to |+⟩ and |1⟩ to |-⟩. These two states are very often useful for quantum computation and thus this gate is, too.

The phase shift gate is a generalisation of an infinity of gates. The Pauli-Z, Phase, and π/8 gates are all special cases of the phase shift gate for specific values of θ.

And then things get even more exciting with more qubits. Multiple qubit operators are represented by larger square matrices, and larger squares on the circuit board. For example, a three-qubit gate would be represented by

and a 8 × 8 matrix.

There are a few famous multiple-qubit operators, and they all have special symbols.

This is known as the swap gate, and its matrix is

What it does can be thought of as, well, swapping the two qubits. It takes the states |00⟩ and |11⟩ to themselves (after all, if both qubits are 0 then swapping them makes no difference) and exchanges the states |01⟩ and |10⟩.

This is known as a controlled gate. This is how it works: when the qubit on top equals 0, nothing happens; and when the qubit on top equals 1, we apply the gate U on the second qubit. So, if U is given by

then the controlled-U gate is given by

Let's try to see why this works.

Based on the matrix representation of U, it takes the state |0⟩ to the state α|0⟩ + γ|1⟩ and the state |1⟩ to the state β|0⟩ + δ|1⟩.

So, the controlled-U gate takes |00⟩ and |01⟩ to themselves, because as I said when the top qubit is 0 nothing happens. However, it takes the state |10⟩ to the state α|10⟩ + γ|11⟩ and the state |11⟩ to the state β|10⟩ + δ|11⟩, because now the top qubit is 1, and that's equivalent to applying the U operator on the bottom qubit.

A specific instance of a controlled-U gate is the instance when U is the Pauli-X gate, and this is known as the CNOT gate:

When the top qubit is 0, nothing happens to the second; however, when the top qubit is 1, it applies the Pauli-X/NOT gate on the bottom qubit.

Which means |00⟩ and |01⟩ stay the same, but |10⟩ goes to |11⟩ and |11⟩ goes to |10⟩. Pretty simple.

There are a few other interesting gates, like the Fredkin (also known as CSWAP) and Toffoli (also known as CCNOT) gates, which are 3-qubit gates. I'll discuss both in depth in a future post, and mention one use for the Toffoli gate in a bit.

And the above is not really a quantum gate. It is, in fact, the symbol for a measurement. Remember that, once you measure a quantum system, it "collapses" to a definite state? So, too, with a qubit, which becomes a classical bit once a measurement takes place. When that happens, a qubit that's in an arbitrary state |ψ⟩ will be observed to be in state |0⟩ or |1⟩, its superposition gone.

Unitarity and reversibility

A comment on unitarity is necessary here. Since all quantum gates have to be unitary, that also means they have to be reversible, a property not always shared by their classical cousins. For example, the AND logical gate takes two classical bits, a and b, and returns a single classical bit, c, that equals 1 if a = b = 1 and 0 otherwise. If we observe that c = 0, all we know is that at either a = 0, b = 0, or both, which means we can't extract the original state from it.

Does that mean quantum computers can't run classical computation?

No; we can in fact simulate classical computation by adding a flag bit. As an example:

This is known as a Toffoli or CCNOT gate. Basically, what it does is reverse the bottom qubit if the top two qubits are 1, and leave it the same otherwise.

What does this do? Basically, it takes the states |0yz⟩ and |x0z⟩ to themselves, and swaps the states |110⟩ and |111⟩. So, when the two top qubits are 1, it negates the bottom qubit, as promised.

How does that let us simulate the classical AND gate? If we initialise the bottom qubit in state |0⟩, then we know it will be in state |1⟩ if and only if both top qubits are in state |1⟩, and so that bottom qubit is effectively the output of an AND operation.

Measurement and phase

I mentioned that global phases are irrelevant because they have no experimental consequences. Let me prove that now.

First, remember that a measurement is basically equivalent to a nonunitary projection onto a basis state? Yeah, so we can in general represent it by an operator Mn where n is a basis state. In the one qubit case, we have that

And of course, we don't have to choose the basis states |0⟩ and |1⟩. We could equally well have |+⟩ and |-⟩ as our basis states, whose measurement operators, in the |0⟩, |1⟩ basis, are:

To see that these two are the measurement operators of |+⟩ and |-⟩, just apply them on these states. We must have that M+|+⟩ = |+⟩, M+|-⟩ = 0, M-|+⟩ = 0, and M-|-⟩ = |-⟩. This is easily seen to be the case.

Why are those operators relevant? They're not even unitary!

Ah, but you see, they can be used for us to find the probability with which we will observe an outcome.

Suppose I have a qubit in an arbitrary state |ψ⟩ = α|0⟩ + β|1⟩. If I apply the measurement operator M0 on it, I will get its amplitude to be in state |0⟩, namely α, multiplied by state |0⟩ itself. That is, M0|ψ⟩ = α|0⟩. Moreover, if I calculate the inner product of that with itself, I get:

Hmm... so the bra-ket of M0|ψ⟩ with itself is exactly the probability that my qubit will be in state |0⟩! (Recall that we made all of our qubits normalised so that these squared moduli are our probabilities straight.) And this is, of course, valid for any basis state |n⟩, so we'll generalise from now on.

Now, suppose I apply some operator U on |ψ⟩ that shifts it by some global phase: U|ψ⟩ = eiγ|ψ⟩. What's the probability that this new state will be observed to be in basis state |n⟩?

It makes no difference! So, when an operator changes the global phase of my system, my probabilities (and therefore my experimental results) are completely unperturbed, and we say it's the same state up to a global phase difference.

What about relative phases? Why are they relevant?

Well, a direct example would be one of our original experiments

where it's exactly the relative phase between two states that generates the observed weirdness. So relative phases do have experimental consequences.

Once more, superposition and entanglement

When are two (or more) qubits (and, in general, quantum systems) entangled? When are they independent?

I've previously said that we can treat our experimental setup as roughly independent of the rest of the universe because the universal wavefunction roughly factors into a product of "wavefunction of the system" and "wavefunction of everything else." And it is, indeed, a product.

Suppose I have two qubits in one of the Bell states, |Φ+⟩ = (|00⟩ + |11⟩)/√2. What's the state of, say, the top qubit, independently of the whole system?

If we assume both qubits have independent states, then the top qubit would presumably be in some state |ψ⟩ = α|0⟩ + β|1⟩ and the bottom qubit would be in some state |φ⟩ = γ|0⟩ + δ|1⟩, right? Which means that the ensemble must be in state |ψ⟩|φ⟩ = αγ|00⟩ + αδ|01⟩ + βγ|10⟩ + βδ|11⟩ = (|00⟩ + |11⟩)/√2. Now, what possible values could α, β, γ, and δ take that would make this equality true?

None, of course. We would need αδ = βγ = 0, but if that's true then either αγ or βδ (or both) is also 0. The equality can't hold for any values whatsoever.

And that's what entanglement means. When two (or more) quantum systems are built in such a way that the ensemble of them cannot be seen as a product of both systems, when there is no fact of the matter as to what the state of each system is. The systems don't possess independent identities, and it's physical nonsense to try to speak of the state of each of them.

Same goes for our beloved qubits. As they progress through the circuit, they will eventually get into states where they can no longer be thought of as separate units.

Not that they could, before. Not really. It was just that before, they were just independent enough that we could make that intuitive approximation.

An example

First, it's noteworthy that every quantum process can be seen as a quantum circuit. We can easily model all of our experiments so far with such circuits, and they're a good way of picturing the evolution of a quantum system.

While it won't be incredibly useful, I will present here an example of a circuit. This simple one will generate a superposition of the four possible Bell states:

Let's see how it works. On top, we have a simple Hadamard gate, which takes |0⟩ to |+⟩ = (|0⟩ + |1⟩)/√2 and |1⟩ to |-⟩ = (|0⟩ - |1⟩)/√2. Then we have a CNOT, which generates the Bell states. How? The CNOT takes |00⟩ and |01⟩ to themselves, and swaps |10⟩ and |11⟩. Therefore:

If the system starts out in state |0⟩|0⟩, the Hadamard gate will take it to state (|0⟩ + |1⟩)|0⟩/√2 and then the CNOT will take it to (|00⟩ + |11⟩)/√2, the first Bell state.

If it starts out in state |1⟩|0⟩, the Hadamard will take it to (|0⟩ - |1⟩)|0⟩/√2 and then the CNOT will take it to (|00⟩ - |11⟩)/√2, the second Bell state.

If it starts out in state |0⟩|1⟩, the Hadamard takes it to (|0⟩ + |1⟩)|1⟩/√2, and the CNOT to (|01⟩ + |10⟩)/√2, the third Bell state.

Finally, if it starts in state |1⟩|1⟩, the Hadamard takes it to (|0⟩ - |1⟩)|1⟩/√2 and the CNOT to (|01⟩ - |10⟩)/√2, the fourth Bell state.

Since the system can start out in any superposition of the states |00⟩, |01⟩, |10⟩, and |11⟩, it can end up in any superposition of the four Bell states. So if we want to generate Bell states, the above circuit gives us a very easy way to do so.

And why would we want to generate Bell states? Well, they can be very useful for things like quantum teleportation. I'll talk about that in the next post, though.

[scientiststhesis-at-pillowfort]

Computations, Turing Machines and Reductionism

So I've gone to some lengths to develop computability theory in a formal way, and also in a lot of informal ways, but other than one example of a computation by a Turing Machine (which was just copying a string like why), I never showed why this is even called "computability theory." I mean, sure, Turing Machines are cute, I guess. They don't look all that powerful, though.

And yet it looks like the laws of physics are Turing Computable, so much for that.

It turns out that many people believe any possible algorithm is computable by some kind of Turing Machine. And in fact, Turing Machines are more powerful than the computer you're using to read this on. Of course, the problem there is how to define "algorithm." The idea is that what our intuition calls an algorithm, a Turing Machine can do. And that's... alright.

But how?

Well, take your computer, for instance. Everyone knows computers only deal with 0s and 1s, that's common knowledge. Yet most people don't remember that when they're typing away at their tumblr blog while listening to music and playing heavily modded Skyrim. It looks like some faraway fact, like Quantum Physics, some interesting curiosity that doesn't really mean anything. It's not connected to your experiences.

What your processor does is basically limited to a few arithmetical operations and moving stuff around, though. And that can be easily simulated by a Turing Machine. Not only that, but your computer has finite capacity, whereas a Turing Machine has infinite capacity, and so it is strictly more powerful in the sense of being able to do more, albeit maybe less efficiently.

Your neurons only send impulses to one another as they receive input.

Turing Machines formalise what we mean by computation and algorithm. They're very simple, sure, but the world is in fact very simple at its base. We can all be computed.

And you might even argue, "But who builds these Turing Machines, then? What's the point of having A Turing Machine That Adds or something if you can't have A Turing Machine That Does Everything?"

And... yes, yes you can.

There's this thing called a Universal Turing Machine which can simulate every Turing Machine there is. How? Well, I defined a Turing Machine, didn't I? More specifically, it's that ordered 7-tuple M = (Q, Γ, ‿, ∑, δ, q0, F) that can be finitely described.

So a Universal Turing Machine is one that takes as input the formal definition of a Turing Machine in 0s and 1s and then simulates it. In pretty much the same way you would simulate one if you had its specification: looking up transitions and stuff.

Your computer is less powerful than a Turing Machine. So is your brain. But of course, a Turing Machine is only a formalisation, and now we can talk about more interesting stuff that's a consequence of all of the above. From now on, every computability and complexity theory post I make will be written with the assumption that the computation is being made on a Turing Machine.

Because in the end, it could be.

[scientiststhesis-at-pillowfort]

Being formal about other kinds of languages

Now that I have explained Turing Machines, including many of its other types, I can be formal about other kinds of languages than the ones presented thus far.

Context-sensitive grammar

A grammar G = (N, ∑, P, S) is context sensitive if the productions follow the rule

(α, β) ∈ P → ∃A ∈ N : [(∃γ, θ, η ∈ (N ∪ ∑)* : (α = γAθ ∧ β = γηθ ∧ η ≠ ε)) ∨ (α = A ∧ β = ε ∧ ¬∃(m, n) ∈ P ∃γ, θ ∈ (N ∪ ∑)* : (n = γAθ))]

The first part of the above says that a nonterminal becomes a string of things based on its surroundings. And that's why they're called context-sensitive: in a context-free grammar, either A can become β or it can't, all the time, whereas in a context-sensitive one nonterminals can sometimes become terminals only when accompanied by other stuff (like, aA → aB but bA → ba).

And then there's the second part of the above, which says that a single nonterminal symbol is allowed to become the empty string as long as it doesn't appear on the right side of any derivation.

So that means that, other than the production S → ε which produces specifically the empty string, all productions u → v imply |u| ≤ |v| (that is, no production shrinks the string created thus far).

Unrestricted grammar

An unrestricted grammar G = (N, ∑, P, S) is one such that

(α, β) ∈ P → α ≠ λ

And that's it. Any production that doesn't outright create stuff out of thin air is an unrestricted grammar. So, in fact, you don't even need N and ∑ to be disjoint, because you can have terminals producing terminals and stuff.

The languages and the automata

There are three languages missing from description, then: context-sensitive, recursive and recursively enumerable. Context-sensitive languages are the ones that are generated by context-sensitive grammars; however, recursive and recursively enumerable languages are only generated by unrestricted grammars. How do we tell them apart them?

Why, by the automata that accept them.

Context-sensitive languages

A context-sensitive language is also accepted by a Turing Machine. However, only by a very specific kind of Turing Machine: a linear bounded automaton (LBA). That is a nondeterministic Turing Machine with a finite tape whose size is the size of the input.

It's very easy to see that every context-sensitive language is accepted by an LBA: since every production rule in a context-sensitive grammar can only make the string grow (or stay the same size), no intermediate step in the derivation of a string can have a string that's larger than the end result. Therefore, as the Turing Machine examines the input it was given, it can only shrink. Furthermore, the nondeterminism condition means that we need some sequence of steps to accept the string, not every one of them.

And on the other hand, the languages accepted by LBAs are precisely those generated by a context-sensitive grammar. Every context-free language can be generated by a context-sensitive grammar with very few modifications (only the ones necessary to guarantee that there is only one generation of the form S → ε), and every regular language can be generated by a context-free language, therefore the only languages that effectively break the rule of increase in size are those generated by unrestricted grammars.

Recursive and recursively enumerable languages

A recursive language is one that is decided by a Turing Machine; that is, the Turing Machine halts on all inputs, accepts only inputs in the language and rejects all others.

A recursively enumerable language is one that is enumerated by a Turing Machine; that is, the Turing Machine doesn't halt on all inputs, and the inputs on which it does halt are exactly those belonging to the language.

And... well, that's it. Since this lifts all restrictions on a language, including size ones, except for the ones where something comes from nothing, the equivalence is vacuous. Every recursive language is clearly also a recursively enumerable language because given a decider for the language you can create an enumerator that loops forever when finding a string not belonging to the language; and the inclusion is proper, since the Halting Problem being undecidable means you can't in general make an enumerator always halt.

So, that's it. We're done with languages. Finally. After more than six months. Because I'm lazy. Sorry!