Virtual Machines and Real Implementations

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 to check access.

Fig. 1

Notes

  1. 1.

    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).

  2. 2.

    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.

  3. 3.

    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.

  4. 4.

    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.

  5. 5.

    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.

  6. 6.

    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).

  7. 7.

    Piccinini (2015) discusses these alternatives in greater detail in his discussion of mapping accounts.

  8. 8.

    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.

  9. 9.

    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.

  10. 10.

    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.

  11. 11.

    For a detailed discussion of virtual memory, see Silberschatz et al. (2013) or Bryant and O’Hallaron (2016).

  12. 12.

    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

  1. Aaronson, S. (2011). Why philosophers should care about computational complexity. arXiv:1108.1791

  2. 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.

    MathSciNet  Article  MATH  Google Scholar 

  3. 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.

    Google Scholar 

  4. Brown, C. (2012). Combinatorial-state automata and models of computation. Journal of Cognitive Science, 13(1), 51–73.

    Article  Google Scholar 

  5. Bryant, R., & O’Hallaron, D. (2016). Computer systems: A programmer’s perspective (3rd ed.). London: Pearson Education.

    Google Scholar 

  6. Chalmers, D. J. (1996). Does a rock implement every finite-state automaton? Synthese, 108(3), 309–333.

    MathSciNet  Article  MATH  Google Scholar 

  7. Chalmers, D. (2012). The varieties of computation: A reply. Journal of Cognitive Science, 13(3), 211–248.

    Article  Google Scholar 

  8. Copeland, B. J. (1996). What is computation? Synthese, 108(3), 335–359.

    MathSciNet  Article  MATH  Google Scholar 

  9. Cormen, T., Leiserson, C., Rivest, R., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). Cambridge, MA: MIT Press.

    Google Scholar 

  10. Fodor, J. (1968). Psychological explanation. New York: Random House.

    Google Scholar 

  11. Godfrey-Smith, P. (2009). Triviality arguments against functionalism. Philosophical Studies, 145(2), 273–295.

    Article  Google Scholar 

  12. 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.

    Article  Google Scholar 

  13. Joslin, D. (2006). Real realization: Dennett’s real patterns versus Putnams ubiquitous automata. Minds and Machines, 16, 29–41.

    Article  Google Scholar 

  14. Kolmogorov, A. N. (1963). On tables of random numbers. Sankhy, Series A, 25, 369–376.

    MathSciNet  MATH  Google Scholar 

  15. Klein, C. (2008). Dispositional implementation solves the superfluous structure problem. Synthese, 165, 141–153.

    Article  Google Scholar 

  16. Levenshtein, V. I. (1966). Binary codes capable of correcting deletions, insertions and reversals. Soviet Physics Doklady, 10, 707–710.

    MathSciNet  Google Scholar 

  17. Li, M., & Vitányi, P. (2008). An introduction to Kolmogorov complexity (3rd ed.). New York: Springer.

    Google Scholar 

  18. Maudlin, T. (1989). Computation and consciousness. Journal of Philosophy, 86(8), 407–432.

    Article  Google Scholar 

  19. Millhouse, T. (2017). A simplicity criterion for physical computation. The British Journal for the Philosophy of Science. https://doi.org/10.1093/bjps/axx046.

  20. Nagel, L., & Pederson, D. (1973). SPICE (simulation program with integrated circuit emphasis). Berkeley: EECS Department, University of California.

    Google Scholar 

  21. Piccinini, G. (2015). Physical computation: A mechanistic account. Oxford: Oxford University Press.

    Google Scholar 

  22. Putnam, H. (1988). Representation and reality. Cambridge: MIT Press.

    Google Scholar 

  23. Pylyshyn, Z. (1984). Computation and cognition. Cambridge, MA: Bradford Books.

    Google Scholar 

  24. Rescorla, M. (2014). A theory of computational implementation. Synthese, 191, 1277–1307.

    MathSciNet  Article  Google Scholar 

  25. Scheutz, M. (1999). When physical systems realize functions.... Minds and Machines, 9(2), 161–196.

    Article  Google Scholar 

  26. Scheutz, M. (2001). Computational versus causal complexity. Minds and Machines, 11(4), 543–566.

    Article  MATH  Google Scholar 

  27. 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.

    Article  Google Scholar 

  28. Searle, J. (1980). Minds, brains, and programs. Behavioral and Brain Sciences, 3(3), 417–424.

    Article  Google Scholar 

  29. Searle, J. (1992). The rediscovery of mind. Cambridge, MA: MIT Press.

    Google Scholar 

  30. Sipser, M. (2013). Introduction to the theory of computation. Boston: Cengage Learning.

    Google Scholar 

  31. Silberschatz, A., Galvin, P. B., & Gagne, G. (2013). Operating system concepts (9th ed.). Hoboken, NJ: Wiley.

    Google Scholar 

  32. Sprevak, M. (2012). Three challenges to Chalmers on computational implementation. Journal of Cognitive Science, 13(2), 107–143.

    Article  Google Scholar 

  33. Turing, A. M. (1937). On computable numbers, with an application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, 42(2), 230–265.

    MathSciNet  Article  MATH  Google Scholar 

  34. Van Der Walt, (2011). The numpy array: A structure for efficient numerical computation. Computing in Science and Engineering, 13(2), 22–30.

    Article  Google Scholar 

  35. Wallace, D. (2014). The emergent multiverse. Oxford: Oxford University Press.

    Google Scholar 

Download references

Author information

Affiliations

Authors

Corresponding author

Correspondence to Tyler Millhouse.

Rights and permissions

Reprints and Permissions

About this article

Verify currency and authenticity via CrossMark

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

Download citation

Keywords

  • Physical computation
  • Computer realization
  • Automata
  • Triviality arguments
  • Kolmogorov complexity
  • Simplicity
  • Emulation
  • Simulation