Abstract
What does it take to implement a computer? Answers to this question have often focused on what it takes for a physical system to implement an abstract machine. As Joslin (Minds Mach 16:29–41, 2006) observes, this approach neglects cases of software implementation—cases where one machine implements another by running a program. These cases, Joslin argues, highlight serious problems for mapping accounts of computer implementation—accounts that require a mapping between elements of a physical system and elements of an abstract machine. The source of these problems is the complexity introduced by common design features of ordinary computers, features that would be relevant to any real-world software implementation (e.g., virtual memory). While Joslin is focused on contemporary views, his discussion also suggests a counterexample to recent mapping accounts which hold that genuine implementation requires simple mappings (Millhouse in Br J Philos Sci, 2017. https://doi.org/10.1093/bjps/axx046; Wallace in The emergent multiverse, Oxford University Press, Oxford, 2014). In this paper, I begin by clarifying the nature of software implementation and disentangling it from closely related phenomena like emulation and simulation. Next, I argue that Joslin overstates the degree of complexity involved in his target cases and that these cases may actually give us reasons to favor simplicity-based criteria over relevant alternatives. Finally, I propose a novel problem for simplicity-based criteria and suggest a tentative solution.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
Notes
This formalism is also useful for understanding Kolmogorov complexity, discussed in Sect. 1.3. In particular, it shows that choosing a different reference universal Turing machine can only increase the length of minimal programs up to a constant—i.e., the length of the standard description of the original UTM (Kolmogorov 1963; Sipser 2013).
An example of a circuit simulator is the open-source SPICE simulator (Nagel and Pederson 1973). Higher-level simulators (e.g., for the simulation of logic circuits) are also widely available.
Within computer science, the term “implementation” often refers to the implementation of algorithms. That is, it refers to the process of translating a general description of an algorithm into a working program for computing that algorithm in a particular programming language (Cormen et al. 2009). As I will show, the implementation of specific algorithms is also of central importance to computer implementation.
It is easy to miss the fact that I (Millhouse 2017) propose a graded notion of implementation. Realizing that this might be unpalatable to some readers, he also considers but does not endorse variations on his view which might provide a threshold for implementation. This is an interesting feature of the view, but I have omitted a detailed discussion of it for the sake of simplicity.
In particular, it asks us to consider how long this program would be relative to \({\text {K}}(M)\) on our reference Turing machine. Unfortunately, I was somewhat vague about exactly what \({\text {K}}(M)\) is. Sorting out this point is interesting from the standpoint of fine-tuning the simplicity constraint, but not essential to understanding the motivation for the constraint.
Edit distance is symmetric since each operation is reversible by a single operation (e.g., a single insertion can be reversed by a single deletion). Algorithmic information distance is symmetric because as its measure of distance it takes the longest of the two shortest programs for (1) transforming the first string into the second and (2) transforming the second string into the first (Bennett et al. 1998).
Piccinini (2015) discusses these alternatives in greater detail in his discussion of mapping accounts.
For simplicity, I ignore systems that fail to halt on some inputs. Chalmers’s modifications allow the input recorder to handle these systems. Chalmers also recognizes that the input recorder is limited by memory in a way that finite state machines typically are not (i.e., there are finite state machines that can accept arbitrarily large, finite input strings). This may be a problem, but if it is, then it’s unclear how any physical system can implement a Turing machine since it is assumed that the Turing machine has infinite tape.
It is important to remember that the simplicity of interpretations is discounted by machine complexity under the simplicity criterion. Hence, ‘relative simplicity’ might be a better way to capture what he has in mind. See fn. 4 for more discussion.
Rejecting the idea that simulation is a sufficient condition for implementation is interesting in its own right. Some have suggested that we might, for example, be able to upload minds and run them as a simulation or emulation on a digital computer. This might be feasible, but if the argument here is correct, we may need to be careful to ensure that our simulation meets whatever additional criteria are required for genuine implementation. Ironically, this might be a way of reconstructing Searle’s (1980) concerns about the difference between genuine and simulated mentality within computational functionalism.
Though I think the problems it raises for the simplicity criterion are covered by the cases discussed in the body, Joslin’s “worm” case is hard to resist commenting on. The worm is a harmless computer virus which moves between computers, at each stop implementing Pi(1000) for a few steps before moving on, taking the accumulated digits of \(\pi\) along with it. At each stop, I think the simplicity criterion will agree that the relevant computation is being carried out. After all, if not for its movement, the implementation would be unexceptional. What makes the case so interesting is that it concerns the conditions on the continuity of computation over time. So far as I know, no one in the computer implementation literature has explored this subject, though it seems highly relevant to other areas, including the philosophy of personal identity.
References
Aaronson, S. (2011). Why philosophers should care about computational complexity. arXiv:1108.1791
Bennett, C. H., Gács, P., Li, M., Vitányi, P. M., & Zurek, W. H. (1998). Information distance. IEEE Transactions on Information Theory, 44(4), 1407–1423.
Block, N. (1995). The mind as the software of the brain. In D. N. Osherson & E. E. Smith (Eds.), An invitation to cognitive science (Vol. 3, pp. 377–425). Cambridge: MIT Press.
Brown, C. (2012). Combinatorial-state automata and models of computation. Journal of Cognitive Science, 13(1), 51–73.
Bryant, R., & O’Hallaron, D. (2016). Computer systems: A programmer’s perspective (3rd ed.). London: Pearson Education.
Chalmers, D. J. (1996). Does a rock implement every finite-state automaton? Synthese, 108(3), 309–333.
Chalmers, D. (2012). The varieties of computation: A reply. Journal of Cognitive Science, 13(3), 211–248.
Copeland, B. J. (1996). What is computation? Synthese, 108(3), 335–359.
Cormen, T., Leiserson, C., Rivest, R., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). Cambridge, MA: MIT Press.
Fodor, J. (1968). Psychological explanation. New York: Random House.
Godfrey-Smith, P. (2009). Triviality arguments against functionalism. Philosophical Studies, 145(2), 273–295.
Hayes, P. J., Berkeley, I. S. N., Bringsjord S., Hartcastle, V., McKee, G. & Stufflebeam, R. (1997). What is a computer? An electronic discussion. The Monist, 80(3), 389–404.
Joslin, D. (2006). Real realization: Dennett’s real patterns versus Putnams ubiquitous automata. Minds and Machines, 16, 29–41.
Kolmogorov, A. N. (1963). On tables of random numbers. Sankhy, Series A, 25, 369–376.
Klein, C. (2008). Dispositional implementation solves the superfluous structure problem. Synthese, 165, 141–153.
Levenshtein, V. I. (1966). Binary codes capable of correcting deletions, insertions and reversals. Soviet Physics Doklady, 10, 707–710.
Li, M., & Vitányi, P. (2008). An introduction to Kolmogorov complexity (3rd ed.). New York: Springer.
Maudlin, T. (1989). Computation and consciousness. Journal of Philosophy, 86(8), 407–432.
Millhouse, T. (2017). A simplicity criterion for physical computation. The British Journal for the Philosophy of Science. https://doi.org/10.1093/bjps/axx046.
Nagel, L., & Pederson, D. (1973). SPICE (simulation program with integrated circuit emphasis). Berkeley: EECS Department, University of California.
Piccinini, G. (2015). Physical computation: A mechanistic account. Oxford: Oxford University Press.
Putnam, H. (1988). Representation and reality. Cambridge: MIT Press.
Pylyshyn, Z. (1984). Computation and cognition. Cambridge, MA: Bradford Books.
Rescorla, M. (2014). A theory of computational implementation. Synthese, 191, 1277–1307.
Scheutz, M. (1999). When physical systems realize functions.... Minds and Machines, 9(2), 161–196.
Scheutz, M. (2001). Computational versus causal complexity. Minds and Machines, 11(4), 543–566.
Scheutz, M. (2012). What it is not to implement a computation: A critical analysis of Chalmers notion of implemention. Journal of Cognitive Science, 13(1), 75–106.
Searle, J. (1980). Minds, brains, and programs. Behavioral and Brain Sciences, 3(3), 417–424.
Searle, J. (1992). The rediscovery of mind. Cambridge, MA: MIT Press.
Sipser, M. (2013). Introduction to the theory of computation. Boston: Cengage Learning.
Silberschatz, A., Galvin, P. B., & Gagne, G. (2013). Operating system concepts (9th ed.). Hoboken, NJ: Wiley.
Sprevak, M. (2012). Three challenges to Chalmers on computational implementation. Journal of Cognitive Science, 13(2), 107–143.
Turing, A. M. (1937). On computable numbers, with an application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, 42(2), 230–265.
Van Der Walt, (2011). The numpy array: A structure for efficient numerical computation. Computing in Science and Engineering, 13(2), 22–30.
Wallace, D. (2014). The emergent multiverse. Oxford: Oxford University Press.
Author information
Authors and Affiliations
Corresponding author
Rights and permissions
About this article
Cite this article
Millhouse, T. Virtual Machines and Real Implementations. Minds & Machines 28, 465–489 (2018). https://doi.org/10.1007/s11023-018-9472-7
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1007/s11023-018-9472-7