arXiv:quant-ph/0701019v1 5 Jan 2007
Quantum gravity computers: On the
theory of computation with indefinite
causal structure
Lucien Hardy
Perimeter Institute,
31 Caroline Street North,
Waterloo, Ontario N2L 2Y5, Canada
February 9, 2008
Abstract
A quantum gravity computer is one for which the particular effects
of quantum gravity are relevant. In general relativity, causal structure is
non-fixed. In quantum theory non-fixed quantities are subject to quantum
uncertainty. It is therefore likely that, in a theory of quantum gravity, we
will have indefinite causal structure. This means that there will be no
matter of fact as to whether a particular interval is timelike or not. We
study the implications of this for the theory of computation. Classical
and quantum computations consist in evolving the state of the computer
through a sequence of time steps. This will, most likely, not be possible
for a quantum gravity computer because the notion of a time step makes
no sense if we have indefinite causal structure. We show that it is possible
to set up a model for computation even in the absence of definite causal
structure by using a certain framework (the causaloid formalism) that
was developed for the purpose of correlating data taken in this type of
situation. Corresponding to a physical theory is a causaloid, Λ (this is a
mathematical object containing information about the causal connections
between different spacetime regions). A computer is given by the pair
{Λ, S} where S is a set of gates. Working within the causaloid formalism,
we explore the question of whether universal quantum gravity computers
are possible. We also examine whether a quantum gravity computer might
be more powerful than a quantum (or classical) computer. In particular,
we ask whether indefinite causal structure can be used as a computational
resource.
1
Introduction
A computation, as usually understood, consists of operating on the state of
some system (or collection of systems) in a sequence of steps. Turing’s universal
1
computer consists of a sequence of operations on a tape. A classical computation is often implemented by having a sequence of operations on a collection of
bits and a quantum computation by a sequence of operations on a collection of
qubits. Such computations can be built up of gates where each gate acts on a
small number of bits or qubits. These gates are defined in terms of how they
cause an input state to be evolved. A physical computer may have some spatial
extension and so gates may be acting at many different places at once. Nevertheless, we can always foliate spacetime such that we can regard the computer
as acting on a state at some time t and updating it to a new state at time t + 1,
and so on, till the computation is finished. Parallel computation fits into this
paradigm since the different parts of the parallel computation are updated at the
same time. The notion that computation proceeds by a sequence of time steps
appears to be a fairly pervasive and deep rooted aspect of our understanding
of what a computation is. In anticipation of more general computation, we will
call computers that implement computation in this way step computers (SC).
This includes Turing machines and parallel computers, and it includes classical
computers and quantum computers.
Turing developed the theory of computation as a formalization of mathematical calculation (with pencil, paper, and eraser for example)[1]. Deutsch later
emphasized that any computation must be implemented physically [2]. Consequently, we must pay attention to physical theories to understand computation. Currently, there are basically two fundamental physical theories, quantum
theory (QT) and Einstein’s theory of general relativity (GR) for gravity. However, we really need a physical theory which is more fundamental - a theory of
quantum gravity (QG). A correct theory of QG will reduce to QT and GR in
appropriate situations (including, at least, those situations where those physical
theories have been experimentally verified). We do not currently have a theory
of quantum gravity. However, we can hope to gain some insight into what kind
of theory this will be by looking at QT and GR. Causal structure in GR is not
fixed in advance. Whether two events are time-like or not depends on the metric and the metric depends on the distribution of matter. In quantum theory
a property that is subject to variation is also subject to quantum uncertainty we can be in a situation where there is no matter of fact as to the value of that
quantity. For example, a quantum particle can be in a superposition of being in
two places at once. It seems likely that this will happen with causal structure.
Hence, in a theory of QG we expect that we will have indefinite causal structure.
Indefinite causal structure is when there is, in general, no matter
of fact as to whether the separation between two events is time-like
or not.
If this is, indeed, the case then we cannot regard the behaviour of a physical
system (or collection of systems) as evolving in time through a sequence of
states defined on a sequence of space-like hypersurfaces. This is likely to have
implications for computer science. In particular, it is likely that a quantum
gravity computer cannot be understood as an instance of a SC. In this paper we
will explore the consequences of having indefinite causal structure for the theory
2
of computation. In particular, we will look at how the causaloid framework
(developed in [3]) can be applied to provide a definite model for computation
when we have indefinite causal structure. Although there are compelling reasons
for believing that the correct theory of QG will have indefinite causal structure,
it is possible that this will not be the case. Nevertheless, in this paper we will
assume that QG will have this property. There may be other features of a
theory of QG which would be interesting for the study of computation but, in
this paper, we will restrict ourselves to indefinite causal structure.
2
2.1
General ideas
What counts as a computer?
The idea of a computer comes from attempting to formalize mathematical calculation. A limited notion of computation would entail that it is nothing more
than a process by which a sequence of symbols is updated in a deterministic
fashion - such as with a Turing machine. However, with the advent of quantum
computation, this notion is no longer sufficient. David Deutsch was able to establish a theory of quantum computation which bares much resemblance to the
theory of classical computation. Given that quantum computers can be imagined (and may even be built one day) we need a richer notion of computation.
However, a quantum computer still proceeds by means of a sequence of time
steps. It is a SC. The possibility of considering time steps at a fundamental level
will, we expect, be undermined in a theory of quantum gravity for the reasons
given above.
This raises the question of whether or not we want to regard the behaviour
of a physical machine for which the particular effects of QG are important
and lead to indefinite causal structure as constituting a computer. We could
certainly build a machine of this nature (at least in principle). Furthermore,
somebody who knows the laws by which this machine operates could use it to
address mathematical issues (at the very least they could solve efficiently the
mathematical problem of generating numbers which would be produced by a
simulation of this machine in accordance with the known laws). Hence, it is
reasonable to regard this machine as a computer - a quantum gravity computer.
At this point it is worth taking a step back to ask, in the light of these
considerations, what we mean by a the notion of a computer in general? One
answer is that
(1) A computer is a physical device that can give correct answers
to well formulated questions.
For this to constitute a complete definition we would need to say what the
terms in this definition mean. However, whatever a “well formulated question”
means, it must be presented to the computer in the form of some physical
input (or program). Likewise, whatever an “answer” is, it must be given by the
computer in the form of some physical output. It is not clear what the notion of
3
“correctness” means. However, from the point of view of the physical computer
it must mean that the device operates according to sufficiently well known rules.
Hence, a more physical definition is that
(2) A computer is a physical device has an output that depends
on an input (or program) according to sufficiently well known rules.
This still leaves the meaning of the word “sufficiently” unclear. It is not necessary that we know all the physics that governs a computer. For example, in
a classical computer we do not need to have a detailed understanding of the
physics inside a gate, we only need an understanding of how the gate acts on an
input to produce an output. There remain interesting philosophical questions
about how we understand the translation from the terms in definition (1) to
those in definition (2) but these go beyond the scope of this paper.
These definitions are useful. In particular they do not require that the
computational process proceed by a sequence of steps. We will see how we can
meaningfully talk about computation in the absence of any spacelike foliation
into timelike steps in the sense of definition (2) of a computer.
It is likely that, in going to QG computers, we will leave behind many of the
more intuitive notions of computation we usually take for granted. This already
happened in the transition from classical to quantum computation - but the
the likely failure of the step computation model for a QG computer may cause
the transition from quantum to quantum gravity computation to be even more
radical.
2.2
The Church-Turing-Deutsch principle
Consider the following
The Church-Turing-Deutsch principle: Every physical process
can be simulated by a universal model computing device.
Deutsch [2] was motivated to state this principle by work of Church [4] and
Turing [1] (actually he gives a stronger and more carefully formulated version).
Deutsch’s statement emphasizes the physical aspect of computation whereas
Church and Turing were more interested in mathematical issues (note that, in
his acknowledgements, Deutsch thanks “C. H. Bennett for pointing out to me
that the Church-Turing hypothesis has physical significance”). We can take the
widespread successful simulation of any number of physical processes (such as
of cars in a wind tunnel, or of bridges prior to their being built) on a modern
classical computer, as evidence of the truth of this principle. A principle like this
would seem to be important since it provides a mechanism for verifying physical
theories. The physical theory tells us how to model physical processes. To verify
the physical theory there needs to be some way of using the theory to simulate
the given physical process. However, there is a deeper reason that this principle
is interesting. This is that it might lead us to say that the universe is, itself,
a computer. Of course, the CTD principle does not actually imply that. Even
4
though we might be able to simulate a physical process on a computer, it does
not follow that the computation is an accurate reflection of what is happening
during that physical process. This suggests a stronger principle
The computational reflection principle: The behaviour of any
physical process is accurately reflected by the behaviour of an appropriately programmed universal model computing device.
A proper understanding of this principle requires a definition of what is meant by
“accurately reflected” (note that a dictionary definition of the relevant meaning
of the word reflect is to “embody or represent in a faithful or appropriate way”
[5]). We will not attempt to provide a precise definition but rather will illustrated our discussion with examples. Nevertheless, “accurate reflection” would
entail that not only is there the same mapping between inputs and outputs for
the physical process and the computation, but also that there is a mapping between the internal structure of the physical process and the computation. This
relates to ideas of functional equivalence as discussed by philosophers.
We may think of a universal computer in the Turing model where the program is included in the tape. But we may also use the circuit model where the
program is represented by a prespecified way of choosing the gates.
It is possible to simulate any quantum system with a finite dimensional
Hilbert space (including quantum computers) to arbitrary accuracy on a classical computer. In fact, we can even simulate a quantum computer with polynomial space on a classical computer but, in general, this requires exponential
time [6]. We might claim, then, that the CTD principle holds (though, since
this is not exact simulation, we may prefer to withhold judgment). However, we
would be more reluctant to claim that the CR principle holds since the classical
simulation has properties that the quantum process does not: (i) It is possible to
measure the state of the classical computer without effecting its subsequent evolution; (ii) the exponential time classical computer is much more powerful than
a polynomial time quantum computer; and (iii) the detailed structure of the
classical computation will look quite different to that of the quantum process.
2.3
Physics without state evolution
The idea of a state which evolves is deeply ingrained in our way of thinking about
the world. But is it a necessary feature of any physical theory? This depends
what a physical theory must accomplish. At the very least, a physical theory
must correlate recorded data. Data is correlated in the evolving state picture in
the following way. Data corresponding to a given time is correlated by applying
the mathematical machinery of the theory to the state at that given time. And
data corresponding to more than one time is correlated by evolving the state
through those given times, and then applying the mathematical machinery of
the theory to the collection of states so generated. However, there is no reason to
suppose that this is the only way of correlating data taken in different spacetime
regions. In fact, we have already other pictures. In GR we solve local field
equations. A solution must simply satisfy the Einstein field equations and be
5
consistent with the boundary conditions. We do not need the notion of an
evolving state here - though there are canonical formulations of GR which have
a state across space evolving in time. In classical mechanics we can extremise
an action. In this case we consider possible solutions over all time and find the
one that extremizes the action. Again, we do not need to use the notion of an
evolving state. In quantum theory we can use Feynman’s sum over histories
approach which is equivalent to an evolving state picture but enables us to
proceed without such a picture. In [3] the causaloid formalism was developed
as a candidate framework for a theory of QG (though QT can be formulated in
this framework). This enables one to calculate directly whether (i) there is a
well defined correlation between data taken from two different spacetime regions
and, if there is, (ii) what that correlation is equal to. Since this calculation is
direct, there is no need to consider a state evolving between the two regions.
The causaloid formalism is, in particular, suited to dealing with the situation
where there is no matter of fact to whether an interval is time-like or not.
2.4
What is a quantum gravity computer?
A quantum gravity computer is a computer for which the particular effects of
QG are important. In this paper we are interested in the case where we have
indefinite causal structure (and, of course, we are assuming that QG will allow
this property).
As we discussed in Sec. 2.1, a computer can be understood to be a physical
device having an output that depends on an input (or program) according to sufficiently well known rules. The computer occupies a certain region of spacetime.
The input can consist of a number of inputs into the computer distributed across
this region, and likewise, the output can consist of a number of outputs from the
computer distributed across the region. Typically the inputs are selected (by
us) in accordance with some program corresponding to the question we wish to
use the computer to find an answer to. Usually we imagine setting the computer
in some initial state (typically, in quantum computing, this consists of putting
all the qubits in the zero state). However, physically this is accomplished by
an appropriate choice of inputs prior to this initial time (for example, we might
have a quantum circuit which initializes the state). Hence, the picture in which
we have inputs and outputs distributed across the given region of spacetime
is sufficient. We do not need to also imagine that we separately initialize the
computer. This characterization of a computer is useful for specifying a QG
computer since we must be careful using a notion like “initial state” when we
cannot rely on having a definite notion of a single time hypersurface in the absence of definite causal structure. The QG computer itself must be sensitive to
QG effects (as opposed to purely quantum or purely general relativistic effects).
To actually build a QG computer we need a theory of quantum gravity because
(i) this is the only way to be sure we are seeing quantum gravity effects and (ii)
we need to have known physical laws to use the device as a computer.
In the absence of a theory of QG it is difficult to give an example of a device
which will function as a QG computer. Nevertheless we will give a possible
6
candidate example for the purposes of discussion. We hope that the essential
features of this example would be present in any actual QG computer. We
imagine, for this example, that our quantum gravity computer consists of a
number of mesoscopic probes of Planck mass (about 20 micrograms) immersed
in a controlled environment of smaller quantum objects (such as photons). There
must be the possibility of having inputs and outputs. The inputs and outputs are
distributed across the region of spacetime in which the QG computer operates.
We take this region of spacetime to be fuzzy in the sense that we cannot say
whether a particular interval in it is time-like or space-like. However, we can still
expect to be able to set up physical coordinates to label where a particular input
or output is “located” in some appropriate abstract space. For example, imagine
that a GPS system is set up by positioning four satellites around the region.
Each satellite emits a signal carrying the time of its internal clock. We imagine
that the mesoscopic probes can detect these four times thus providing a position
x ≡ (t1 , t2 , t3 , t4 ). Each satellite clock will tick and so x is a discrete variable. A
given probe will experience a number of different values of x. Assume that each
probe can be set to give out a light pulse or not (denote this by s = 1 or s = 0
respectively), and has a detector which may detect a photon or not (denote this
by a = 1 or a = 0 respectively) during some given short time interval. Further,
allow the value of s to depend on x. Thus,
s = F (x, n)
(1)
where n labels the probe. We imagine that we can choose the function F as we
like. This constitutes the program. Thus, the inputs are given by the s’s and
the outputs by the a’s. We record many instances of the data (x, n, s, a). We
might like to have more complicated programs where F is allowed to depend on
the values of previous outputs from other probes. However, we cannot assume
that there is fixed causal structure, and so we cannot say, in advance, what will
constitute previous data. Thus, any program of this nature must “physicalize”
the previous data by alowing the probe to emit it as a physical signal, r. If this
signal is detected at a probe along with x then it can form part of the input
into F . Thus, we would have
s = F (x, n, r)
(2)
At the end of a run of the QG computer, we would have many instances of
(x, n, r, s, a).
This is just a possible example of a possible QG computer. We might have
the property of indefinite causal structure in this example since the mesoscopic
probes are (possibly) sufficiently small to allow quantum effects and sufficiently
massive to allow gravitational effects. Penrose’s cat [7] consists of exploring the
possible gravity induced breakdown of quantum theory for a Planck mass mirror
recoiling (or not) from a photon in a quantum superposition.
Regardless of whether this is a good example, we will assume that any such
computer will collect data of the form (x, n, s, a) (or (x, n, r, s, a)), and that a
program can be specified by a function F (x, n) (or F (x, n, r)). Whilst we can
7
imagine more complicated examples, it would seem that they add nothing extra
and could, anyway, be accommodated by the foregoing analysis. Importantly,
although we have the coordinate x, we do not assume any causal structure on
x. In particular, there is no need to assume that some function of x will provide
a time coordinate - this need not be a SC.
3
3.1
The causaloid formalism
Analyzing data
We will now given an abbreviated presentation of the causaloid formalism which
is designed for analyzing data collected in this way and does not require a time
coordinate. This formalism was first presented in [3] (see also [8] and [9] for more
accessible accounts). Assume that each piece of data ((x, n, s, a) or (x, n, r, s, a))
once collected is written on a card. At the end of the computation we will have a
stack of cards. We will seek to find a way to calculate probabilistic correlations
between the data collected on these cards. The order in which the cards end
up in the stack does not, in itself, constitute recorded data and consequently
will play no role in this analysis. Since we are interested in probabilities we
will imagine running the computation many times so that we can calculate
probabilities as relative frequencies (though, this may not be necessary for all
applications of the computer). Now we will provide a number of basic definitions
in terms of the cards.
The full pack, V , is the set of all logically possible cards.
The program, F , is the set of all cards from V consistent with a given program
F (x, n, s, a) (or F (x, n, r, s, a)). Note that the set F and the function F
convey the same information so we use the same notation, the meaning
being clear from the context.
A stack, Y , is the set of cards collected during a particular run of the computer.
An elementary region, Rx , is the the set of all cards from V having a particular x written on them.
Note that
Y ⊆F ⊆V
(3)
We will now give a few more definitions in terms of these basic definitions.
Regions. We define a composite spacetime region by
[
RO1 =
Rx
x∈O1
We will often denote this by R1 for shorthand.
8
(4)
The outcome set in region R1 is given by
YR1 ≡ Y ∩ R1
(5)
This set contains the results seen in the region R1 . It constitutes the raw
output data from the computation. We will often denote this set by Y1 .
The program in region R1 is given by
FR1 ≡ F ∩ R1
(6)
This set contains the program instructions in region R1 . We will often
denote it by F1 .
3.2
Objective of the causaloid formalism
We will consider probabilities of the form
Prob(Y2 |Y1 , F2 , F1 )
(7)
This is the probability that we see outcome set Y2 in R2 given that we have
procedure F2 in that region and that we have outcome set Y1 and program F1
in region R1 . Our physical theory must (i) determine whether the probability
is well defined, and if so (ii) determine its value. The first step is crucial. Most
conditional probabilities we might consider are not going to be well defined. For
example if R1 and R2 are far apart (in so much as such a notion makes sense)
then there will be other influences (besides those in R1 ) which determine the
probabilities of outcomes in R2 , and if these are not take into account we cannot do a calculation for this probability. To illustrate this imagine an adversary.
Whatever probability we write down, he can alter these extraneous influences
so that the probability is wrong. Conventionally we determine whether a probability is well defined by simply looking at the causal structure. However, since
we do not have definite causal structure here we have to be more careful.
To begin we will make an assumption. Let the region R be big (consisting
of most of V ).
Assumption 1: We assume that there is some condition C on FV −R and YV −R
such that all probabilities of the form
Prob(YR |FR , C)
(8)
are well defined.
We can regard condition C as corresponding to the setting up and maintenance
of the computer. We will consider only cases where C is true (when it is not, the
computer is broken or malfunctioning). We will regard region R as the region
in which the computation is performed. Since we will always be assuming C is
true, we will drop it from our notation. Thus, we assume that the probabilities
Prob(YR |FR ) are well defined.
9
The probabilities Prob(YR |FR ) pertain to the global region R. However,
we normally like to do physics by building up a picture of the big from the
small. We will show how this can be done. We will apply three levels of physical
compression. The first applies to single regions (such as R1 ). The second applies
to composite regions such as R1 ∪ R2 (the second level of physical compression
also applies to composite regions made from three or more component regions).
The first and second levels of physical compression result in certain matrices.
In the third level of physical compression we use the fact that these matrices
are related to implement further compression.
3.3
First level physical compression
First we implement first level physical compression. We label each possible pair
(YR1 , FR1 ) in R1 with α1 . We will think of these pairs as describing measurement
outcomes in R1 (YR1 denotes the outcome of the measurement and FR1 denotes
the choice of measurement). Then we write
pα1 ≡ Prob(YRα11 ∪ YR−R1 |FRα11 ∪ FR−R1 )
(9)
By Assumption 1, these probabilities are all well defined. We can think of
what happens in region R − R1 as constituting a generalized preparation of a
state in region R1 . We define the state to be that thing represented by any
mathematical object which can be used to calculate pα1 for all α1 . Now, given a
generalized preparation, the pα1 ’s are likely to be related by the physical theory
that governs the system. In fact we can just look at linear relationships. This
means that we can find a minimal set Ω1 such that
pα1 = rα1 (R1 ) · p(R1 )
where the state p(R1 ) in R1 is given by


..
 . 

p(R1 ) = 
 p l1 
..
.
l 1 ∈ Ω1
(10)
(11)
We will call Ω1 the fiducial set (of measurement outcomes). Note that the
probabilities pl1 need not add up to 1 since the l1 ’s may correspond to outcomes
of incompatible measurements. In the case that there are no linear relationships
relating the pα1 ’s we set Ω1 equal to the full set of α1 ’s and then rα1 consists
of a 1 in position α1 and 0’s elsewhere. Hence, we can always write (10). One
justification for using linear compression is that probabilities add in a linear
way when we take mixtures. It is for this reason that linear compression in
quantum theory (for general mixed states) is the most efficient. The set Ω1 will
not, in general, be unique. Since the set is minimal, there must exist a set of
|Ω1 | linearly independent states p (otherwise further linear compression would
10
be possible). First level physical compression for region R1 is fully encoded in
the matrix
(12)
Λlα11 ≡ rlα11
where rlα11 is the l1 component of rα1 . The more physical compression there is
the more rectangular (rather than square) this matrix will be.
3.4
Second level physical compression
Next we will implement second level physical compression. Consider two regions
R1 and R2 . Then the state for region R1 ∪ R2 is clearly of the form


..
.



p(R1 ∪ R2 ) = 
(13)
 pk1 k2  k1 k2 ∈ Ω12
..
.
We can show that it is always possible to choose Ω12 such that
Ω12 ⊆ Ω1 × Ω2
(14)
where × denotes the cartesian product. This result is central to the causaloid
formalism. To prove (14) note that we can write pα1 α2 as
prob(YRα11 ∪ YRα22 ∪ YR−R1 −R2 |FRα11 ∪ FRα22 ∪ FR−R1 −R2 )
=
=
rα1 (R1 ) · pα2 (R1 )
X
2
rlα11 (R1 )pα
l1 (R1 )
l1 ∈Ω1
=
X
rlα11 (R1 )rα2 (R2 ) · pl1 (R2 )
l1 ∈Ω1
=
X
rlα11 rlα22 pl1 l2
(15)
l1 l2 ∈Ω1 ×Ω2
where pα2 (R1 ) is the state in R1 given the generalized preparation (YRα22 ∪
YR−R1 −R2 , FRα22 ∪ FR−R1 −R2 ) in region R − R1 , and pl1 (R2 ) is the state in R2
given the generalized preparation (YRl11 ∪ YR−R1 −R2 , FRl11 ∪ FR−R1 −R2 ) in region
R − R2 , and where
pl1 l2 = prob(YRl11 ∪ YRl22 ∪ YR−R1 −R2 |FRl11 ∪ FRl22 ∪ FR−R1 −R2 )
(16)
Now we note from (15) that pα1 α2 is given by a linear sum over the probabilities
pl1 l2 where l1 l2 ∈ Ω1 × Ω2 . It may even be the case that we do not need all of
these probabilities. Hence, it follows that Ω12 ⊆ Ω1 × Ω2 as required.
Using (15) we have
pα1 α2
=
rα1 α2 (R1 ∪ R2 ) · p(R1 ∪ R2 )
X
rlα11 rlα22 pl1 l2
=
X
=
l1 l2
rlα11 rlα22 rl1 l2 · p(R1 ∪ R2 )
l1 l2
11
We must have
rα1 α2 (R1 ∪ R2 ) =
X
rlα11 rlα22 rl1 l2 (R1 ∪ R2 )
(17)
l1 l2
since we can find a spanning set of linearly independent states p(R1 ∪ R2 ). We
define
Λlk11lk22 ≡ rkl11lk22
(18)
where rkl11lk22 is the k1 k2 component of rl1 l2 . Hence,
rkα11kα22 =
X
rlα11 rlα22 Λlk11lk22
(19)
l1 l2
This equation tells us that if we know Λlk11lk22 then we can calculate rα1 α2 (R1 ∪R2 )
for the composite region R1 ∪ R2 from the corresponding vectors rα1 (R1 ) and
rα2 (R2 ) for the component regions R1 and R2 . Hence the matrix Λkl11lk22 encodes
the second level physical compression (the physical compression over and above
the first level physical compression of the component regions). We can use Λkl11lk22
to define a new type of product - the causaloid product - denoted by ⊗Λ .
rα1 α2 (R1 ∪ R2 ) = rα1 (R1 ) ⊗Λ rα2 (R2 )
(20)
where the components are are given by (19).
We can apply second level physical compression to more than two regions.
For three regions we have the matrices
Λlk11lk22l3k3
(21)
and so on.
3.5
Third level physical compression
Finally, we come to third level physical compression. Consider all the compression matrices we pick up for elementary regions Rx during first and second level
compression. We have

 lx
Λαx
for all x ∈ OR



 k k

 Λ x x′
′
for all x, x ∈ OR

 lx lx ′




(22)

 kx kx′ kx′′
′
′′

 Λlx l ′ l ′′
for
all
x,
x
,
x
∈
O
R
x x






..
..
.
.
where OR is the set of x in region R. Now, these matrices themselves are likely
to be related by the physical theory. Consequently, rather than specifying all
12
of them separately, we should be able to specify a subset along with some rules
for calculating the others
Λ ≡ (subset of Λ′ s; RULES)
(23)
We call this mathematical object the causaloid. This third level of physical
compression is accomplished by identities relating the higher order Λ matrices
(those with more indices) to the lower order ones. Here are some examples from
two families of such identities. The first family uses the property that when Ω
sets multiply so do Λ matrices.
k ···k
k
···k
k ···k
k
···k
Λlxx···lxx′ l′x′′x′′···lx′′′x′′′ = Λlxx···lxx′ ′ Λlxx′′′′···lxx′′′′′′
Ωx···x′ x′′ ···x′′′ = Ωx···x′ × Ωx′′ ···x′′′
(24)
The second family consists of identities from which Λ matrices for composite
regions can be calculated from some pairwise matrices (given certain conditions
on the Ω sets). The first identity in this family is
X
k′ k
Λkl11lk22l3k3 =
Λlk11kk′2 Λl22l33 if Ω123 = Ω12 ×Ω6 23 and Ω23 = Ω26 3 ×Ω6 23 (25)
if
2
k2′ ∈Ω26 3
where the notation Ω6 23 means that we form the set of all k3 for which there
exists k2 k3 ∈ Ω23 . The second identity in this family is
Ω1234 = Ω12 × Ω6 23 × Ω6 34
Ω23 = Ω26 3 × Ω6 23
2
3
Ω34 = Ω36 4 × Ω6 34
k2′ ∈Ω26 3 ,k3′ ∈Ω36 4
(26)
and so on. These identities are sufficient to implement third level physical
compression for classical and quantum computers. However, we will probably
need other identities to implement third level physical compression for a QG
computer. The task of fully characterizing all such identities, and therefore of
fully characterizing third level physical compression, remains to be completed.
Λlk11lk22l3kl34k4 =
3.6
X
k′ k
k′ k
Λlk11kk′2 Λl22k′3 Λl33l44
if
Classical and quantum computers in the causaloid formalism
Since third level compression has been worked out for classical and quantum
computers we should say a little about this here (see [3] and [8] for more details).
Consider a classical (quantum) computer which consists of pairwise interacting
(qu)bits. This is sufficient to implement universal classical (quantum) computation. This situation is shown in Fig. 1. Each (qu)bit is labeled by i, j, . . .
and is shown by a thin line. The nodes where the (qu)bits meet are labeled by
x. Adjacent nodes (between which a (qu)bit passes) have a link. We call this
diagram a causaloid diagram. At each node we have a choice, s, of what gate
to implement. And then there may be some output, a, registered at the gate
itself (in quantum terms this is both a transformation and a measurement). We
record (x, s, a) on a card. The program is specified by some function s = F (x).
13
Figure 1: This figure shows a number of pairwise interacting (qu)bits. The (qu)bits
travel along the paths indicated by the thin lines and interact at the nodes. At each
node we can choose a gate.
We can use our previous notation. Associated with each (x, s, a) at each gate is
some rαx . It turns out that there exists a choice of fiducial measurement outcomes at each node x which break down into separate measurement outcomes
for each of the two (qu)bits passing through that node. For these measurements
we can write lx ≡ lxi lxj where lxi labels the fiducial measurements on (qu)bit
i and lxj labels the fiducial measurements on the other (qu)bit j. All Ω sets
involving different (qu)bits factorize as do all Ω sets involving non-sequential
clumps of nodes on the same (qu)bit and so identity (24) applies in these cases.
For a set of sequential nodes the Ω sets satisfy the conditions for (25, 26) and
related identities to hold. This means that it is possible to specify the causaloid
for a classical (quantum) computer of pairwise interacting (qu)bits by
clumping method
kxi kx′ i
′
lxi lxj
Λ = {Λαx ∀ x}, {Λlxi lx′ i ∀ adjacent x, x };
causaloid diagram
(27)
where the “clumping method” is the appropriate use of the identities (24, 25, 26)
and related identities to calculate general Λ matrices. The causaloid diagram
is also necessary so we know how the nodes are linked up and how the (qu)bits
move. There is quite substantial third level compression. The total number of
possible Λ matrices is exponential in the number of nodes but the number of
matrices required to specify the causaloid is only linear in this number. There
may be simple symmetries which relate the matrices living on each node and
each link. In this case there will be even further compression.
14
3.7
Using the causaloid formalism to make predictions
We can use the causaloid to calculate any r vector for any region in R. Using
these we can calculate whether any probability of the form (7) is well defined,
and if so, what it is equal to. To see this note that, using Bayes rule,
rα α (R1 ∪ R2 ) · p(R1 ∪ R2 )
p ≡ Prob(Y1α1 |Y2α2 , F1α1 , F2α2 ) = P 1 2
β1 rβ1 α2 (R1 ∪ R2 ) · p(R1 ∪ R2 )
(28)
where β1 runs over all (Y1 , F1 ) consistent with F1 = F1α1 (i.e. all outcomes
consistent with the program in region R1 ). For this probability to be well
defined it must be independent of what happens outside R1 ∪ R2 . That is, it
must be independent of the state p(R1 ∪ R2 ). Since there exists a spanning set
of linearly independent such states, this is true if and only if
X
(29)
rβ1 α2 (R1 ∪ R2 )
rα1 α2 (R1 ∪ R2 ) is parallel to
β1
This, then, is the condition for the probability to be well defined. In the case
that this condition is satisfied then the probability is given by the ratio of the
lengths of these two vectors. That is by
X
(30)
rβ1 α2 (R1 ∪ R2 )
rα1 α2 (R1 ∪ R2 ) = p
β1
It might quite often turn out that these two vectors are not exactly parallel. So
long as they are still quite parallel we can place limits on p. Set
X
(31)
rβ1 α2 (R1 ∪ R2 )
v ≡ rα1 α2 (R1 ∪ R2 ) and u ≡
β1
Define vk and v⊥ as the components of v parallel and perpendicular to u
respectively. Then it is easy to show that
|vk |
|v⊥ |
|vk |
|v⊥ |
−
≤p≤
+
|u|
|v| cos φ
|u|
|v| cos φ
(32)
where φ is the angle between v and v⊥ (we get these bounds using |v·p| ≤ |u·p|).
3.8
The notion of state evolution in the causaloid formalism
In setting up the causaloid formalism we have not had to assume that we can
have a state which evolves with respect to time. As we will see, it is possible to
reconstruct an evolving state even though this is looks rather unnatural from
point of view of the causaloid formalism. However, this reconstruction depends
on Assumption 1 of Sec. 3.2 being true. It is consistent to apply the causaloid
formalism even if Assumption 1 does not hold. In this case we cannot reconstruct
an evolving state.
15
We choose a nested set of spacetime regions Rt where t = 0 to T for which
R0 ⊃ R1 ⊃ R2 · · · ⊃ RT
(33)
where R0 = R and RT is the null set. We can think of t as a “time” parameter
and the region Rt as corresponding to all of R that happens “after” time t. For
each region Rt we can calculate the state, p(t) ≡ p(Rt ), given some generalized
preparation up to time t (that is in the region R − Rt ). We regard p(t) as the
state at time t. It can be used to calculate any probability after time t (corresponding to the region Rt ) and can therefore be used to calculate probabilities
corresponding to the region Rt+1 since this is nested inside Rt . Using this fact
it is easy to show that the state is subject to linear evolution so that
p(t + 1) = Zt,t+1 p(t)
(34)
where Zt,t+1 depends on YRt −Rt+1 and FRt −Rt+1 .
Thus, it would appear that, although we did not use the idea of an evolving
state in setting up the causaloid formalism, we can reconstruct a state that, in
some sense, evolves. We can do this for any such nested set of regions. There
is no need for the partitioning to be generated by a foliation into spacelike
hypersurfaces and, indeed, such a foliation will not exist if the causal structure
is indefinite. This evolving state is rather artificial - it need not correspond to
any physically motivated “time”.
There is a further reason to be suspicious of an evolving state in the causaloid
formalism. To set up this formalism it was necessary to make Assumption 1
(in Sec. 3.2). It is likely that this assumption will not be strictly valid in a
theory of QG. However, we can regard this assumption as providing scaffolding
to get us to a mathematical framework. It is perfectly consistent to suppose that
this mathematical framework continues to be applicable even if Assumption 1
is dropped. Thus it is possible that we can define a causaloid and then use
the causaloid product and (29, 30) to calculate whether probabilities are well
defined and, if so, what these probabilities are equal to. In so doing we need
make no reference to the concept of state. In particular, since we cannot suppose
that all the probabilities prob(YR |FR , C) are well defined, we will not be able
to force an evolving state picture. The causaloid formalism provides us with a
way of correlating inputs and outputs across a region of space time even in the
absence of the possibility of an evolving state picture.
4
4.1
Computation in the light of the causaloid formalism
Gates
In the standard circuit model a computer is constructed out of gates selected
from a small set of possible gates. The gates are distributed throughout a
spacetime region in the form of a circuit. Hence we have a number of spacetime
16
locations (label them by x) at which we may place a gate. At each such location
we have a choice of which gate to select. The gates are connected by “wires”
along which (qu)bits travel. This wiring represents the causal structure of the
circuit. Since the wiring is well defined, causal structure cannot be said to be
indefinite. In fact in classical and quantum computers we can work with a fixed
wiring and vary only the choice of gates. The wires can form a diamond grid
like that shown in Fig. 1. Where the wires cross two (qu)bits can pass through a
gate. As long as we have a sufficient number of appropriate gates we can perform
universal computation. In Sec. 3.6 we outlined how to put this situation into
the causaloid formalism.
In the causaloid model we have spacetime locations labeled by x. At each
x we have a choice of setting s. This choice of setting can be regarded as
constituting the choice of a gate. Since we may have indefinite causal structure
we will not be able to think in terms of “wiring” as such. However information
about the causal connections between what happens at different x’s is given
by the Λ matrices which can be calculated from the causaloid. For example
k k
the matrix Λlxxlxx′ ′ tells us about the causal connection between x and x′′ by
quantifying second level compression. Thus, the matrices associated with second
level compression (which can be deduced from the causaloid, Λ) play the role
of wiring. Since we do not have wires we cannot necessarily think in terms of
(qu)bits moving between gates. Rather, we must think of the gates as being
immersed in an amorphous interconnected sea quantitatively described by the
causaloid. In the special case of a classical or quantum computer we will have
wiring and this can be deduced from Λ.
Typically, in computers, we restrict the set of gates we employ. Thus, assume
that we restrict to s ∈ {s1 , s2 , . . . , sN } ≡ S where S is a subset of the set, SI ,
of all possible s. Then a computer is defined by the pair
{Λ, S} where S ⊂ SI
(35)
The program for this computer is given by some function like s = F (x, n) (or
s = F (x, n, r)) from Sec. 2.4 where s ∈ S. This is a very general model for
computation. Both classical and quantum computers can be described in this
way as well as computers with indefinite causal structure.
4.2
Universal computation
Imagine we have a class of computers. A universal computer for this class is a
member of the class which can be used to simulate any computer in the class
if it is supplied with an appropriate program. For example, a universal Turing
machine can be used to simulate an arbitrary Turing machine. This is done by
writing the program for the Turing machine to be simulated into the first part
of the tape that is fed into the universal Turing machine. It follows from their
definition that universal computers can simulate each other.
Given a causaloid, Λ and some integer M we can generate an interesting
M
class of computers - namely the class CΛ
defined as the class of computers
17
{Λ, S} for all S ⊂ SI such that |S| ≤ M . We will typically be interested in the
case that M is a fairly small number (less than 10 say). The reason for wanting
M to be small is that usually we imagine computations being constructed out
of a small set of basic operations.
We can then ask whether there exist any universal computers in this class.
We will say that the computer {Λ, SU } with |SU | ≤ M is universal for the class
M
CΛ
if we can use it to simulate an arbitrary computer in this class. This means
that there must exist a simple map from inputs and outputs of the universal
computer to inputs and outputs (respectively) of the computer being simulated
such that the probabilities are equal (or equal to within some specified accuracy).
We will then refer to SU as a universal set of gates.
If we choose the causaloid Λ of classical or quantum theory discussed in
Sec. 3.6 then it is well established that there exist universal computers for small
M . This is especially striking in the quantum case since there exist a infinite
number of gates which cannot be simulated by probabilistic mixtures of other
gates. One way to understand how this is possible in the classical and quantum
cases is the following. Imagine that we want to simulate {Λ, S} with {Λ, SU }.
We can show that any gate in the set S can be simulated to arbitrary accuracy
with some number of gates from the set SU . Then we can coarse-grain on
the diamond grid to larger diamonds which can have sufficient gates from SU
to simulate an arbitrary gate in S. In coarse-graining in this way we do not
change in any significant way the nature of the causal structure. Thus we can
still link these coarse-grained diamonds to each other in such a way that we
can simulate {Λ, S}. This works because, in classical and quantum theory, we
have definite causal structure which has a certain scale invariance property as
we coarse-grain.
M
However, if we start with a class of computers CΛ
generated by a causaloid,
Λ, for which there is indefinite causal structure, then we do not expect this scale
invariance property under coarse-graining. In particular, we would expect, as
we go to larger diamonds, that the causal structure will become more definite.
Hence we may not be able to arrange the same kind of causal connection between
the simulated versions of the gates in S as between the original versions of these
gates. Hence, we cannot expect that the procedure just described for simulation
in the classical and quantum case will work in the case of a general causaloid.
This suggests that the concept of universal computation is may not be applicable in QG. However the situation is a little more subtle. The classical physics
that is required to set up classical computation should be a limiting case of
any theory of QG. If a given causaloid, Λ, corresponds to QG then we expect
that it is possible to use this to simulate a universal classical computer if we
coarse-grain to a classical scale. We can also build random number generator
since we have probabilistic processes (since QT is also a limiting case). This
suggests a way to simulate (in some sense of the word) a general QG computer in the class corresponding to Λ. We can use the classical computer to
calculate whether probabilities are well defined and, if so, what they are equal
to arbitrary accuracy from the causaloid by programming in the equations of
the causaloid formalism. We can then use the random number generator to
18
provide outputs with the given probabilities thus simulating what we would
see with a genuine QG computer. We might question whether this is genuine
simulation since there will not necessarily be a simple correspondence between
the spacetime locations of these outputs in the simulation and the outputs in
the actual QG computation. In addition, in simulating the classical computer
from the quantum gravitational Λ, we may need a gate set S with very large
M . Nevertheless, one might claim that the Church Turing Deutsch principle
is still true. However, it seems that the computational reflection principle is
under considerable strain. In particular, the classical simulation would have
definite causal structure unlike the QG computer. But also the detailed causal
structure of the classical simulation would look quite different from that of the
QG computer it simulates. There may also be computational complexity issues.
With such issues in mind we might prefer to use the QG causaloid to simulate
a universal quantum computer (instead of a universal classical computer) and
then use this to model the equations of the causaloid formalism to simulate the
original causaloid. This may be quicker than a classical computer. However,
the computational power of a QG computer may go significantly beyond that
of a quantum computer (see Sec. 4.3).
If the computational reflection principle is undermined for QG processes
then we may not be able to think that the world is, itself, a computational
process. Even if we widen our understanding of what we mean by computation,
it is possible that we will not be able to define a useful notion of a universal
computer that is capable of simulating all fundamental quantum gravitational
processes in a way that accurately reflects what is happening in the world. This
would have an impact on any research program to model fundamental physics
as computation (such as that of Lloyd [10]) as well as having wider philosophical
implications.
4.3
Will quantum gravity computers have greater computational power than quantum computers?
Whether or not we can define a useful notion of universal QG computation,
it is still possible that a QG computer will have greater computational power
than a quantum computer (and, therefore, a classical computer). Are there any
reasons for believing this?
Typically we are interested in how computational resources scale with the
input size for a class of problems. For example we might want to factorize
a number. Then the input size is equal to the number of bits required to
represent this number. To talk about computational power we need to a way of
measuring resources. Computer scientists typically make much use of SPACE
and TIME as separate resources. TIME is equal to the number of steps required
to complete the calculation and SPACE is equal to the maximum number of
(qu)bits required. Many complexity classes have been defined. However, of
most interest is the class P of decision problems for which TIME is a polynomial
function of the size of the input on a classical computer (specifically, a Turing
machine). Most simple things like addition, multiplication, and division, are in
19
P . However factorization is believed not to be. Problems in P are regarded as
being easy and those which are not in P are regarded as being hard. Motivated
by the classical case, BQP is the class of decision problems which can be solved
with bounded error on a quantum computer in polynomial time. Bounded
error means that the error must be, at most, 1/3. We need to allow errors
since we are dealing with probabilistic machines. However, by repeating the
computation many times we can increase our certainty whilst still only requiring
only polynomial time.
In QG computation with indefinite causal structure we cannot talk about
SPACE and TIME as separate resources. We can only talk of the SPACETIME resources required to complete a calculation. The best measure of the
spacetime resources is the number of locations x (where gates are chosen) that
are used in the computation. Thus, if we have x ∈ O for a computation then
SPACETIME = |O|.
In standard computation, the SPACE used by a computer with polynomial
TIME is, itself, only going to be at most polynomial in the input size (since,
in the computational models used by computer scientists, SPACE can only
increase as a polynomial function of the number of steps). Hence, if a problem
is in P then SPACETIME will be a polynomial function of the input size also.
Hence, we can usefully work with SPACETIME rather than TIME as our basic
resource.
We define the class of problems BP{Λ,S} which can be solved with bounded
error on the computer {Λ, S} in polynomial SPACETIME. The interesting question, then, is whether there are problems which are in BP{Λ,S} but not in BQP
for some appropriate choice of computer {Λ, S}. The important property that
a QG computer will have that is not possessed by a quantum (or classical)
computer is that we do not have fixed causal structure. This means that, with
respect to any attempted foliation into spacelike hypersurfaces, there will be
backward in time influences. This suggests that a QG computer will have some
insight into its future state (of course, the terminology is awkward here since
we do not really have a meaningful notion of “future”). It is possible that this
will help from a computational point of view.
A different way of thinking about this question is to ask whether a QG
computer will be hard to simulate on a quantum computer. Assuming, for the
sake of argument, that Assumption 1 is true then, as seen in Sec. 3.8, we can
force an evolving state point of view (however unnatural this may be). In this
case we can simulate the QG computer by simulating the evolution of p(t) with
respect to t. However, this is likely to be much harder when there is not the
kind of causal structure with respect to t which we would normally have if t was
a physically meaningful time coordinate. In the classical and quantum cases we
can determine the state at time t by making measurements at time t (or at least
in a very short interval about this time). Hence, to specify the state, p(t), we
need only list probabilities pertaining to the time-slice Rt − Rt+1 rather than all
of Rt . The number of probabilities required to specify p(t) (i.e. the number of
entries in this vector) is therefore much smaller than it might be if we needed to
specify probabilities pertaining to more of the region Rt . If, however, we have
20
indefinite causal structure, then we cannot expect to have this property. Hence
the state at time t may require many more probabilities for its specification.
This is not surprising since the coordinate t has no natural meaning in this
case. Hence, it is likely that we will require much greater computational power
to simulate the evolution of p(t) simply because we will have to store more
probabilities at each stage of the evolution. Hence we can expect that it will
be difficult to simulate a QG computer on a quantum computer. However, an
explicit model is required before we can make a strong claim on this point.
5
Conclusions
It is likely that a theory of quantum gravity will have indefinite causal structure.
If this is the case it will have an impact on the theory of computation since,
when all is said and done, computers are physical machines. We might want to
use such QG effects to implement computation. However, if there is no definite
causal structure we must depart from the usual notion of a computation as
corresponding to taking a physical machine through a time ordered sequence
of steps - a QG computer will likely not be a step computer. We have shown
how, using the causaloid formalism, we can set up a mathematical framework
for computers that may not be step computers. In this framework we can
represent a computer by the pair {Λ, S}. Classical and quantum computers can
be represented in this way.
We saw that the notion of universal computation may be undermined since
the nature of the causal structure is unlikely to be invariant under scaling (the
fuzzyness of the indefinite causal structure is likely to go away at large enough
scales). If this is true then it will be difficult to make the case that the universe
is actually a computational process.
It is possible that the indefinite causal structure will manifest itself as a
computational resource allowing quantum gravity computers to beat quantum
computers for some tasks.
An interesting subject is whether general relativity computers will have
greater computational powers. There has been some limited investigation of
the consequences of GR for computation for static spacetimes (see [11, 12] and
[13]). General relativity has not been put into the causaloid framework. To explore the computational power of GR we would need to put it into an operational
framework of this nature.
The theory of quantum gravity computation is interesting in its own right.
Thinking about quantum gravity from a computational point of view may shed
new light on quantum gravity itself - not least because thinking in this way forces
operational clarity about what we mean by inputs and outputs. Thinking about
computation in the light of indefinite causal structure may shed significant light
on computer science - in particular it may force us to loosen our conception
of what constitutes a computer even further than that already forced on us
by quantum computation. Given the extreme difficulty of carrying out quantum gravitational experiments, however, it is unlikely that we will see quantum
21
gravity computers any time soon.
We have investigated the issue of QG computers in the context of the causaloid framework. This is a candidate framework for possible theories of QG within
which we can use the language of inputs and outputs and can model indefinite
causal structure (a likely property of QG). The main approaches to QG include
String Theory [14], Loop Quantum Gravity [15, 16, 17], Causal Sets [18], and
Dynamical Triangulations [19]. These are not formulated in a way that it is clear
what would constitute inputs and outputs as understood by computer scientists.
Aaronson provides an interesting discussion of some of these approaches and the
issue of quantum gravity computation [20]. He concludes that it is exactly this
lack of conceptual clarity about what would constitute inputs and outputs that
prohibits the development of a theory of quantum gravity computation. Whilst
the causaloid formalism does not suffer from this problem, it does not yet constitute an actual physical theory. It is abstract and lacks physical constants,
dimensionalful quantities, and all the usual hallmarks of physics that enable
actual prediction of the values of measurable quantities.
Issues of computation in the context of quantum gravity have been raised by
Penrose [21, 22]. He has suggested that quantum gravitational processes may
be non-computable and that this may help to explain human intelligence. In
this paper we have chosen to regard quantum gravitational processes as allowing
us to define a new class of computers which may have greater computational
powers because they may be able to harness the indefinite causal structure as a
computational resource. It is likely that QG computers, as understood in this
paper, can be simulated by both classical and quantum computers so they will
not be able to do anything that is non-computable from the point of view of
classical and quantum computation. However, it may require incredible classical
or quantum resources to simulate a basic QG computational process. Further
the internal structure of a QG computation will most likely be very different to
that of any classical or quantum simulation. Hence, the “thought process” on a
QG computer may be very different to that of a classical or quantum computer
in solving the same problem and so, in spirit if not in detail, the conclusions of
this paper may add support to Penrose’s position. Of course, QG computation
can only be relevant to the human brain if it can be shown that the particular
effects of QG can be resident there [23, 22].
Dedication
It is a great honour to dedicate this paper to Abner Shimony whose ideas permeate the field of the foundations of quantum theory. Abner has taught us the
importance of metaphysics in physics. I hope that not only can metaphysics
drive experiments (Abner’s “experimental metaphysics”) but that it can also
drive theory construction.
22
References
[1] A. Turing, “On Computable Numbers, With an Application to the
Entscheidungsproblem”, Proc. of the London Math. Soc. , Series 2, Volume 42 (1936).
[2] D. Deutsch, “Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer”, Proc. of the Roy. Soc. of London. Series A,
Math. and Phys. Sci. Vol. 400, No. 1818, pp. 97-117 (1985).
[3] L. Hardy, “Probability Theories with Dynamic Causal Structure: A New
Framework for Quantum Gravity” gr-qc/0509120 (2005).
[4] A. Church, “An Unsolvable Problem of Elementary Number Theory”, Am.
J. of Math. 58, 345-363, (1936).
[5] C. soans and A. Stevenson (Eds.) Concise Oxford English Dictionary, 11th
edition (OUP, 2004).
[6] E. Bernstein and U. Vazirani, “Quamtum Complexity Theory”, SIAM J.
Comput., 26(5), 1411-1473 (1997).
[7] R. Penrose, “Gravity and State Vector Reduction”, in R. Penrose and C. J.
Isham (eds.), Quantum Concepts in Space and Time pp 129-146 (Clarendon
Press, Oxford, 1986).
[8] L. Hardy, “Towards Quantum Gravity: A Framework for Probabilistic Theories with Non-Fixed Causal Structure”, gr-qc/0608043 (2006), and forthcoming in J. Phys. A. (2007).
[9] L. Hardy, “Causality in quantum theory and beyond: towards a theory of
quantum gravity”, PIRSA#:06070045 (pirsa.org, 2006).
[10] S. Lloyd, “The computational universe: quantum gravity from quantum
computation”, quant-ph/0501135 (2005).
[11] M. L. Hogarth, “Does General Relativity Allow an Observer to View an
Eternity in a Finite Time?”, Found. Phys. Lett. 5, pp. 173-181 (1992).
[12] M. L. Hogarth, “Non-Turing Computers and Non-Turing Computability”,
PSA: Proceedings of the Biennial Meeting of the Philosophy of Science Association, Vol. 1994, Volume One: Contributed Papers, pp. 126-138 (1994).
[13] I. Pitowsky, “The Physical Church Thesis and Physical Computational
Complexity”,Iyyun 39, pp. 81-99 (1990).
[14] J. Polchinski, String theory, vols. 1 and 2, Cambridge University Press
1998.
[15] C. Rovelli, Quantum gravity, (Cambridge University Press, 2004).
23
[16] T. Thiemann, “Lectures on loop quantum gravity”, Lecture Notes in
Physics 541 (2003).
[17] L. Smolin, “An invitation to loop quantum gravity”, hep-th/0408048
(2004).
[18] R. D. Sorkin “Causal sets: Discrete gravity”, qr-qc/0309009, 2003.
[19] J. Ambjorn, Z. Burda, J. Jurkiewicz, and C. F. Kristjansen, “Quantum
gravity represented as dynamical triangulations”, Acta Phys. Polon. B 23,
991 (1992).
[20] S. Aaronson, “NP-complete
quant-ph/0502072 (2005).
Problems
and
Physical
Reality”,
[21] R. Penrose, Emperors New Mind (OUP, 1989)
[22] R. Penrose, Shadows of the Mind (OUP, 1994).
[23] M. Tegmark, “Importance of quantum decoherence in brain processes”,
Phys. Rev. E 61, 4194 - 4206 (2000).
24