# **References**

- [1]Harold Abelson and Gerald Jay Sussman with Julie Sussman, *Structure and Interpretation of Computer Programs* (2nd ed.). Cambridge, MA: MIT Press, 1996.
- [2]Harold Abelson, Don Allen, Daniel Coore, Chris Hanson, George Homsy, Thomas F. Knight Jr., Radhika Nagpal, Erik Rauch, Gerald Jay Sussman, and Ron Weiss; "Amorphous Computing," in *Communications of the ACM*, 43(5) (May 2000): 74–82.
- [3]Lee Altenberg; "The Evolution of Evolvability in Genetic Programming," in *Advances in Genetic Programming*, ed. Kenneth E. Kinnear Jr., 47–74. Cambridge, MA: MIT Press, 1994.
- [4]*The ARRL Handbook for Radio Amateurs*, American Radio Relay League, Newington, CT (annual).
- [5]Jean-Paul Arcangeli and Christian Pomian; "Principles of Plasma Pattern and Alternative Structure Compilation," in *Theoretical Computer Science*, 71 (1990): 177–191.
- [6]Franz Baader and Wayne Snyder; "Unification theory," in *Handbook of Automated Reasoning*, ed. Alan Robinson and Andrei Voronkov. Elsevier Science Publishers B.V., 2001.
- [7]Jonathan B.L. Bard; *Morphogenesis*, Cambridge: Cambridge University Press, 1990.

- [8]Alan Bawden and Jonathan Rees; "Syntactic closures," in *Proc. Lisp and Functional Programming* (1988).
- [9]Jacob Beal; *Generating Communications Systems Through Shared Context*, S.M. thesis, MIT, also Artificial Intelligence Laboratory Technical Report 2002-002, January 2002.
- [10]Jacob Beal; "Programming an Amorphous Computational Medium," in *Unconventional Programming Paradigms International Workshop* (September 2004). Updated version in Lecture Notes in Computer Science, 3566 (August 2005).
- [11]M.R. Bernfield, S.D. Banerjee, J.E. Koda, and A.C. Rapraeger; "Remodelling of the basement membrane as a mechanism of morphogenic tissue interaction," in *The role of extracellular matrix in development*, ed. R.L. Trelstad, 542–572. New York: Alan R. Liss, 1984.
- [12]Martin Berz; "Automatic differentiation as nonarchimedean analysis," in *Computer Arithmetic and Enclosure Methods*, ed. L. Atanassova and J. Herzberger. Elsevier Science Publishers B.V. (North-Holland), 1992.
- [13]Philip L. Bewig; *Scheme Requests for Implementation 41: Streams* (2008). <https://srfi.schemers.org/srfi-41/>
- [14]R.C. Bohlin and R.L. Gilliland; "Hubble Space Telescope Absolute Spectrophotometry of Vega from the Far-Ultraviolet to the Infrared," in *The Astronomical Journal*, 127(6) (June 2004): 3508–3515.
- [15]J.P. Brocks; "Amphibian limb regeneration: rebuilding a complex structure," in *Science*, 276 (1997): 81–87.
- [16]Alonzo Church; *The Calculi of Lambda-Conversion*. Princeton, NJ: Princeton University Press, 1941.
- [17]Alonzo Church; "An Unsolvable Problem of Elementary Number Theory," *American Journal of Mathematics*, 58 (1936): 345–

- [18]Alonzo Church; "A Note on the Entscheidungsproblem," in *Journal of Symbolic Logic*, 1 (1936): 40–41.
- [19]Lauren Clement and Radhika Nagpal; "Self-Assembly and Self-Repairing Topologies," in *Workshop on Adaptability in Multi-Agent Systems*, RoboCup Australian Open, January 2003.
- [20]William Kingdon Clifford; "Preliminary sketch of biquaternions," in *Proceedings of the London Mathematical Society*, 4 (1873): 381– 395.
- [21]William Clinger; "Nondeterministic Call by Need is Neither Lazy Nor by Name," in *Proceedings of the 1982 ACM symposium on LISP and functional programming*, 226–234 (August 1982).
- [22]William Clinger and Jonathan Rees; "Macros that work," in *Proceedings of the 1991 ACM Conference on Principles of Programming Languages*, 155–162 (1991).
- [23]A Colmerauer., H. Kanoui, R. Pasero, and P. Roussel; *Un système de communication homme-machine en français*, Technical report, Groupe Intelligence Artificielle, Université d'Aix Marseille, Luminy, 1973.
- [24]*Constraints, An International Journal* ISSN: 1383-7133 (Print) 1572-9354 (Online).
- [25]Wikipedia article on continuations. <https://en.wikipedia.org/wiki/Continuation>
- [26]Haskell Brooks Curry; "Grundlagen der Kombinatorischen Logik," in *American Journal of Mathematics*. Baltimore: Johns Hopkins University Press, 1930.
- [27]Johan deKleer, Jon Doyle, Guy Steele, and Gerald J. Sussman; "AMORD: Explicit control of reasoning," in *Proceedings of the*

- *ACM Symposium on Artificial Intelligence and Programming Languages*, 116–125 (1977).
- [28]E.M. del Pino and R.P. Elinson; "A novel developmental pattern for frogs: gastrulation produces an embryonic disk," in *Nature*, 306 (1983): 589–591.
- [29]Howard P. Dinesman; *Superior Mathematical Puzzles*. New York: Simon and Schuster, 1968.
- [30]Jon Doyle; "A truth maintenance system," in *Artificial Intelligence*, 12 (1979): 231–272.
- [31]K. Dybvig, R. Hieb, and C. Bruggerman; "Syntactic abstraction in Scheme," in *Proc. Lisp and Symbolic Computation* (1993).
- [32]G.M. Edelman and J.A. Gally; "Degeneracy and complexity in biological systems," *Proceedings of the National Academy of Sciences*, 98 (2001): 13763–13768.
- [33]M. D. Ernst, C. Kaplan, and C. Chambers; "Predicate Dispatching: A Unified Theory of Dispatch," in *ECOOP'98— Object-Oriented Programming: 12th European Conference*, *Proceedings*, ed. Eric Jul, 186–211, Lecture Notes in Computer Science, 1445. Berlin: Springer, 1998.
- [34]Zsuzsa Farkas; "LISTLOG—A PROLOG extension for list processing," in *TAPSOFT 1987*, ed. Ehrig H., Kowalski R., Levi G., Montanari U., Lecture Notes in Computer Science, 250. Berlin: Springer, 1987.
- [35]Robert Floyd; "Nondeterministic algorithms," in *Journal of the ACM*, 14(4) (1967): 636–644.
- [36]Kenneth D. Forbus and Johan de Kleer; *Building Problem Solvers*. Cambridge, MA: MIT Press, 1993.
- [37]Stefanie Forrest, Anil Somayaji, David H. Ackley; "Building Diverse Computer Systems," in *Proceedings of the 6th*

- *workshop on Hot Topics in Operating Systems*, 67–72. Los Alamitos, CA: IEEE Computer Society Press, 1997.
- [38]Joseph Frankel; *Pattern Formation, Ciliate Studies and Models*. New York: Oxford University Press, 1989.
- [39]Eugene C. Freuder; *Synthesizing Constraint Expressions*. AI Memo 370, MIT Artificial Intelligence Laboratory, July 1976.
- [40]Daniel P. Friedman and David S. Wise; "Cons should not evaluate its arguments," in *Automata Languages and Programming*; Proc. Third International Colloquium at the University of Edinburgh, ed. S. Michaelson and R. Milner, 257– 284 (July 1976).
- [41]Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes; *Essentials of Programming Languages.* Cambridge, MA: MIT Press/McGraw-Hill, 1992.
- [42]Richard P. Gabriel and Linda DeMichiel; "The Common Lisp Object System: An Overview," in *Proceedings of ECOOP'87. European Conference on Object-Oriented Programming*, ed. Jean Bezivin, Jean-Marie Hullot, Pierre Cointe, and Henry Lieberman, 151–170. Paris: Springer, 1987.
- [43]George Gatewood and Joost Kiewiet de Jonge; "Map-based Trigonometric Parallaxes of Altair and Vega," in *The Astrophysical Journal*, 450 (September 1995): 364–368.
- [44]George Gatewood; "Astrometric Studies of Aldebaran, Arcturus, Vega, the Hyades, and Other Regions," in *The Astronomical Journal*, 136(1) (2008): 452–460.
- [45]Kurt Gödel; "On Undecidable Propositions of Formal Mathematical Systems," *Lecture notes taken by Kleene and Rosser at the Institute for Advanced Study* (1934), reprinted in Martin Davis *The Undecidable: Basic Papers on Undecidable Propositions, Unsolvable Problems and Computable Functions*, 39–74. New York: Raven, 1965.

- [46]Adele Goldberg and David Robson; *Smalltalk-80: The Language and Its Implementation*. Reading, MA: Addison-Wesley, 1983.
- [47]Michael Gordon, Robin Milner, and Christopher Wadsworth; *Edinburgh LCF*, Lecture Notes in Computer Science, 78. New York: Springer-Verlag, 1979.
- [48]Cordell Green; "Application of theorem proving to problem solving," in *Proceedings of the International Joint Conference on Artificial Intelligence*, 219–240 (1969).
- [49]Cordell Green and Bertram Raphael; "The use of theoremproving techniques in question-answering systems," in *Proceedings of the ACM National Conference*, 169–181 (1968).
- [50]John V. Guttag; "Abstract data types and the development of data structures," *Communications of the ACM*, 20(6) (1977): 397–404.
- [51]Chris Hanson; *MIT/GNU Scheme Reference Manual*. <https://www.gnu.org/software/mit-scheme/>
- [52]Chris Hanson; SOS software: Scheme Object System, 1993.
- [53]Chris Hanson, Tim Berners-Lee, Lalana Kagal, Gerald Jay Sussman, and Daniel Weitzner; "Data-Purpose Algebra: Modeling Data Usage Policies," in *Eighth IEEE International Workshop on Policies for Distributed Systems and Networks (POLICY'07)*, (June 2007).
- [54]Hyman Hartman and Temple F. Smith; "The Evolution of the Ribosome and the Genetic Code," in *Life*, 4 (2014): 227–249.
- [55]Jacques Herbrand; "Sur la non-contradiction de larithmetique," *Journal fur die reine und angewandte Mathematik*, 166 (1932): 1–8.

- [56]Carl E. Hewitt; "PLANNER: A language for proving theorems in robots," in *Proceedings of the International Joint Conference on Artificial Intelligence*, 295–301 (1969).
- [57]Carl E. Hewitt; "Viewing control structures as patterns of passing messages," in *Journal of Artificial Intelligence*, 8(3) (1977): 323–364.
- [58]Carl Hewitt, Peter Bishop, Richard Steiger; "A Universal Modular ACTOR Formalism for Artificial Intelligence," in *IJCAI-73: Proceedings of the Third International Joint Conference on Artificial Intelligence*, 235–245 (1973).
- [59]Edwin Hewitt; "Rings of real-valued continuous functions. I," in *Transactions of the American Mathematical Society*, 64 (1948): 45–99.
- [60]Paul Horowitz and Winfield Hill; *The Art of Electronics*. Cambridge: Cambridge University Press, 1980.
- [61]IEEE Std 1178-1990, *IEEE Standard for the Scheme Programming Language*, Institute of Electrical and Electronic Engineers, Inc., 1991.
- [62]Paul-Alan Johnson; *The Theory of Architecture: Concepts, Themes, & Practices*. New York: Van Nostrand Reinhold, 1994.
- [63]Jerome H. Keisler; "The hyperreal line. Real numbers, generalizations of the reals, and theories of continua," in *Synthese Library*, 242, 207–237. Dordrecht: Kluwer Academic, 1994.
- [64]Richard Kelsey, William Clinger, and Jonathan Rees (editors); *Revised* <sup>5</sup> *Report on the Algorithmic Language Scheme* (1998).
- [65]Richard Kelsey; *Scheme Requests for Implementation 9: Defining Record types* (1999). <https://srfi.schemers.org/srfi-9/>

- [66]Gregor Kiczales; Tiny CLOS software: Kernelized CLOS, with a metaobject protocol, 1992.
- [67]Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Videira Lopes, Jean-Marc Loingtier, and John Irwin; "Aspect-oriented programming," in *ECOOP'97: Proceedings of the 11th European Conference on Object-Oriented Programming*, 220–242 (1997).
- [68]Gregor Kiczales, Jim des Rivieres, and Daniel G. Bobrow; *The Art of the Metaobject Protocol*. Cambridge, MA: MIT Press, 1991.
- [69]Simon Kirby; *Language evolution without natural selection: From vocabulary to syntax in a population of learners.*, Edinburgh Occasional Paper in Linguistics EOPL-98-1, University of Edinburgh Department of Linguistics (1998).
- [70]Marc W. Kirschner and John C. Gerhart; *The Plausibility of Life: Resolving Darwin's Dilemma*. New Haven: Yale University Press, 2005.
- [71]Marc W. Kirschner, Tim Mitchison; "Beyond self-assembly: from microtubules to morphogenesis," in *Cell*, 45(3) (May 1986): 329–342.
- [72]D. Knuth, P. Bendix; "Simple word problems in universal algebras," in *Computational Problems in Abstract Algebra*, ed. John Leech, 263–297. London: Pergamon Press, 1970.
- [73]E. Kohlbecker, D. P. Friedman, M. Felleisen, and B. Duba; "Hygienic Macro Expansion," in *ACM Conference on LISP and Functional Programming* (1986).
- [74]E. Kohlbecker and Mitchell Wand; "Macro-by-example: Deriving syntactic transformations from their specifications," in *Proc. Symposium on Principles of Programming Languages* (1987).

- [75]Milos Konopasek and Sundaresan Jayaraman; *The TK!Solver Book: A Guide to Problem-Solving in Science, Engineering, Business, and Education.* Berkeley, CA: Osborne/McGraw-Hill, 1984.
- [76]Robert Kowalski; *Predicate logic as a programming language*, Technical report 70, Department of Computational Logic, School of Artificial Intelligence, University of Edinburgh, 1973.
- [77]Robert Kowalski; *Logic for Problem Solving*. New York: North-Holland, 1979.
- [78]Robert M. Kowalski; "The Early Years of Logic Programming," in *Communications of the ACM*, 31(1) (January 1988): 38–43.
- [79]Temur Kutsia; "Pattern Unification with Sequence Variables and Flexible Arity Symbols," in *Electronic Notes in Theoretical Computer Science*, 66(5) (2002): 52–69.
- [80]Butler Lampson, J. J. Horning, R. London, J. G. Mitchell, and G. K. Popek; *Report on the programming language Euclid*, Technical report, Computer Systems Research Group, University of Toronto, 1981.
- [81]Peter Landin; "A correspondence between Algol 60 and Church's lambda notation: Part I," *Communications of the ACM*, 8(2) (1965): 89–101.
- [82]Henrietta S. Leavitt; "1777 variables in the Magellanic Clouds," in *Annals of Harvard College Observatory*, 60 (1908): 87–108.
- [83]Floor Van Leeuwen; "Validation of the new Hipparcos reduction," in *Astronomy & Astrophysics*, 474(2) (2007): 653– 664.
- [84]Karl Lieberherr; *Informationsverdichtung von Modellen in der Aus-sagenlogik und das P=NP Problem*, ETH Dissertation, 1977.

- [85]Barbara H. Liskov and Stephen N. Zilles; " Specification techniques for data abstractions," in *IEEE Transactions on Software Engineering*, 1(1) (1975): 7–19.
- [86]Harvey Lodish, Arnold Berk, S Lawrence Zipursky, Paul Matsudaira, David Baltimore, and James E Darnell; *Molecular Cell Biology* (4th ed.). New York: W. H. Freeman & Co., 1999.
- [87]Oleksandr Manzyuk, Barak A. Pearlmutter, Alexey Andreyevich Radul, David R. Rush, and Jeffrey Mark Siskind; "Confusion of Tagged Perturbations in Forward Automatic Differentiation of Higher-Order Functions," arxiv:1211.4892 (2012).
- [88]David Allen McAllester; *A three-valued truth-maintenance system*, AI Memo 473, MIT Artificial Intelligence Laboratory, 1978.
- [89]David Allen McAllester "An outlook on truth maintenance," AI Memo 551, MIT Artificial Intelligence Laboratory, 1980.
- [90]John McCarthy; "A basis for a mathematical theory of computation," in *Computer Programming and Formal Systems*, ed. P. Braffort and D. Hirshberg, 33–70. Amsterdam: North-Holland, 1963.
- [91]Wikipedia article on MDL. <https://en.wikipedia.org/wiki/MDL> (programming language)
- [92]Piotr Mitros; *Constraint-Satisfaction Modules: A Methodology for Analog Circuit Design*, PhD thesis, MIT, Department of Electrical Engineering and Computer Science, 2007.
- [93]Paul Penfield Jr.; *MARTHA User's Manual*, MIT Research Laboratory of Electronics, Electrodynamics Memorandum No. 6 (1970).
- [94]Barak A. Perlmutter and Jeffrey Mark Siskind; "Lazy Multivariate Higher-Order Forward-Mode AD," in *Proc. POPL'07*, 155–160. New York: ACM, 2007.

- [95]Tim Peters; *PEP 20—The Zen of Python*. <http://www.python.org/dev/peps/pep-0020/>
- [96]*POSIX.1-2017*, "Base Definitions," Chapter 9, "Regular Expressions." <http://pubs.opengroup.org/onlinepubs/9699919799/>
- [97]Jonathan Bruce Postel; *RFC 760: DoD standard Internet Protocol* (January 1980). http://www.rfc[editor.org/rfc/rfc760.txt](http://www.rfc-editor.org/rfc/rfc760.txt)
- [98]W. H. Press, B. P. Flannery, S. A. Teukolsky, and W. T. Vetterling; "Richardson Extrapolation and the Bulirsch-Stoer Method," in *Numerical Recipes in C: The Art of Scientific Computing* (2nd ed.), 718–725. Cambridge: Cambridge University Press, 1992.
- [99]Alexey Andreyevich Radul and Gerald Jay Sussman; "The Art of the Propagator," MIT CSAIL Technical Report MIT-CSAIL-TR-2009-002; Abridged version in *Proc. 2009 International Lisp Conference* (March 2009). <http://hdl.handle.net/1721.1/44215>
- [100]Alexey Andreyevich Radul; *Propagation networks: a flexible and expressive substrate for computation*, PhD thesis, MIT, Department of Electrical Engineering and Computer Science, 2009. <http://hdl.handle.net/1721.1/54635>
- [101]Eric Raymond; *The New Hacker's Dictionary* (2nd ed.). Cambridge, MA: MIT Press, 1993.
- [102]Jonathan A. Rees and Norman I. Adams IV; "T: A dialect of Lisp or, lambda: The ultimate software tool," in *Conference Record of the 1982 ACM Symposium on Lisp and Functional Programming*, 114–122 (1982).
- [103]John C. Reynolds; "The discoveries of continuations," in *Proc. Lisp and Symbolic Computation*, 233–248 (1993).

- [104]J.A. Robinson; "A Machine-Oriented Logic Based on the Resolution Principle," in *Journal of the ACM*, 12(1) (January 1965): 23–41.
- [105]Guido van Rossum; *The Python Language Reference Manual*, ed. Fred L. Drake Jr., Network Theory Ltd, 2003.
- [106]Jane L. Russell, George D. Gatewood, and Thaddeus F. Worek; "Parallax Studies of Four Selected Fields," in *The Astronomical Journal*, 87(2) (February 1982): 428–432.
- [107]Erik Sandewall; "From systems to logic in the early development of nonmonotonic reasoning," in *Artificial Intelligence*, 175 (2011): 416–427.
- [108]Moses Schönfinkel; "Uber die Bausteine der mathematischen Logik," in *Mathematische Annalen*, 92 (1924): 305–316.
- [109]Alex Shinn, John Cowan, and Arthur Gleckler (editors); *Revised* <sup>7</sup> *Report on the Algorithmic Language Scheme* (2013). <http://www.r7rs.org/>
- [110]Alex Shinn; *Scheme Requests for Implementation 115: Scheme Regular Expressions* (2014). [https://srfi.schemers.org/srfi-](https://srfi.schemers.org/srfi-115/)115/
- [111]Jeffrey Mark Siskind and Barak A. Perlmutter; "Perturbation confusion and referential transparency: Correct functional implementation of forward-mode AD," in *Implementation and application of functional languages–17th international workshop*, ed. Andrew Butterfield, Trinity College Dublin Computer Science Department Technical Report TCD-CS-2005-60, 2005.
- [112]Brian Cantwell Smith; *Procedural Reflection in Programming Languages*, PhD thesis, MIT, Department of Electrical Engineering and Computer Science, 1982.

- [113]Richard Matthew Stallman; *EMACS: The Extensible, Customizable, Self-Documenting Display Editor*, AI Memo 519A, MIT Artificial Intelligence Laboratory, March 1981.
- [114]Richard Matthew Stallman and Gerald Jay Sussman; "Forward Reasoning and Dependency-Directed Backtracking in a System for Computer-Aided Circuit Analysis," in *Artificial Intelligence*, 9 (1977): 135–196.
- [115]Guy Lewis Steele Jr.; *Common Lisp the language*. Maynard, MA: Digital Equipment Corporation, 1990.
- [116]Guy L. Steele Jr.; *The Definition and Implementation of a Computer Programming Language Based on Constraints*, PhD thesis, MIT, also Artificial Intelligence Laboratory Technical Report 595, August 1980.
- [117]Guy Lewis Steele Jr., Donald R. Woods, Raphael A. Finkel, Mark R. Crispin, Richard M. Stallman, and Geoffrey S. Goodfellow; *The Hacker's Dictionary*. New York: Harper & Row, 1983.
- [118]Patrick Suppes; *Introduction to Logic*. New York: D. Van Nostrand, 1957.
- [119]Gerald Jay Sussman and Richard Matthew Stallman; "Heuristic Techniques in Computer-Aided Circuit Analysis," in *IEEE Transactions on Circuits and Systems*, 22(11) (November 1975): 857–865.
- [120]Gerald Jay Sussman and Guy L. Steele Jr; "The First Report on Scheme Revisited," in *Higher-Order and Symbolic Computation*, 11(4) (December 1998): 399–404.
- [121]Gerald Jay Sussman and Jack Wisdom; *Structure and Interpretation of Classical Mechanics*. Cambridge, MA: MIT Press, 2001/2014.

- [122]Gerald Jay Sussman and Jack Wisdom with Will Farr; *Functional Differential Geometry*. Cambridge, MA: MIT Press, 2013.
- [123]*The TTL Data Book for Design Engineers*, by the Engineering Staff of Texas Instruments Incorporated, Semiconductor Group.
- [124]Alan M. Turing; "On Computable Numbers, with an Application to the Entscheidungsproblem," in *Proceedings of the London Mathematical Society (Series 2)*, 42 (1936): 230– 265.
- [125]David L. Waltz; *Generating Semantic Descriptions From Drawings of Scenes With Shadows*, PhD thesis, MIT, also Artificial Intelligence Laboratory Technical Report 271, November 1972. <http://hdl.handle.net/1721.1/6911>
- [126]Stephen A. Ward and Robert H. Halstead Jr.; *Computation Structures*. Cambridge, MA: MIT Press, 1990.
- [127]Stephen Webb; *Measuring the Universe: The Cosmological Distance Ladder*, Springer-Praxis Series in Astronomy and Astrophysics. Berlin: Springer, 1999.
- [128]Daniel J. Weitzner, Hal Abelson, Tim Berners-Lee, Chris Hanson, Jim Hendler, Lalana Kagal, Deborah McGuinness, Gerald Jay Sussman, and K. Krasnow Waterman; *Transparent Accountable Data Mining: New Strategies for Privacy Protection*, MIT CSAIL Technical Report MIT-CSAIL-TR-2006- 007, January 2006.
- [129]Robert Edwin Wengert; "A simple automatic derivative evaluation program," in *Communications of the ACM*, 7(8) (1964): 463–464.
- [130]Carter Wiseman; *Louis I. Kahn: Beyond Time and Style: A Life in Architecture*. New York: W.W. Norton, 2007.

- [131]Lewis Wolpert, Rosa Beddington, Thomas Jessell, Peter Lawrence, Elliot Meyerowitz, and Jim Smith; *Principles of Development* (2nd ed.). Oxford: Oxford University Press, 2001.
- [132]Ramin Zabih, David McAllester, and David Chapman; "Nondeterministic Lisp with dependency-directed backtracking," in *AAAI-87*. (1987): 59–64.

# **Index**

Any inaccuracies in this index may be explained by the fact that it has been prepared with the help of a computer.

Donald E. Knuth, *Fundamental Algorithms* (Volume 1 of *The Art of Computer Programming*)

Page numbers for Scheme procedure definitions are in *italics*. Page numbers followed by *n* indicate footnotes.

```
% naming convention, 152
! naming convention, 393 n
λ (lambda) calculus, 1 n
λ expression. See lambda
λ notation, 380 n
π (pi), 381
+->interval, 333
' (quote in Scheme), 390
' (backquote in Scheme), 391
, (comma) in backquote, 391
- (negation or subtraction), 390
```

pattern-directed, 168

```
. in formal parameters, 267 (ex. 5.12), 389
. in printed representation of pair, 387
/ in rational constant, 47
;. See Semicolon
? for pattern variable, 158
? in predicate name, 386 n
?? for segment variable, 159
?* in graph matching, 215
() in Scheme (empty list), 387
(...) in Scheme, 380
# in Scheme vector printout, 388
# in character constant, 40
#!optional parameter, 118
#f (false), 386
#t (true), 386
a:, 274 n
a:advance, 274, 275
a:apply, 274
Abelson, Harold, 114 n, 118 n
Abstract predicate, 134
accumulate, 389
Activation policy for propagator, 347
ACTOR framework message passing, 396 n
add-arithmetics, 77
```

add-cell-content!, *346*

```
add-cell-neighbor!, 346
add-content!, 344
add-streams, 255
add-to-generic-arithmetic!, 91
address-of, 218
address=, 219
advance. See a:advance; g:advance; x:advance
Adventure game, 138–152
  inheritance, 140
  object properties, 139, 142, 145
Algebra rules, 161–163
  segment variables in, 162
Algol-60 thunk, 253 n
Alist (association list), 303
all-args, 74
all-knight-moves, 214
Alternative in conditional, 384
Alternative values, set of, 350
Alternative world views and propagation, 349–351
Alyssa P. Hacker, 44 (ex. 2.7), 277 (ex. 5.17)
amb, 271. See also Backtracking
  continuation implementation, 288–292
  evaluator implementation, 273–277
  order of alternatives, 277, 279
  (ex. 5.20), 290–292, 294 (ex. 5.23)
```

### propagation implementation, 355–364

## Amorphous Computing, 10 *n*

analyze, *260*. *See also* x:analyze

analyze-amb, *277*

analyze-application, *260* , 268

(ex. 5.13), *275*

analyze-assignment, *263* , *276*

analyze-begin, *263*

analyze-definition, *264*

analyze-if, *262* , *275*

analyze-lambda, *262*

analyze-quoted, *261*

analyze-self-evaluating, *261*

analyze-undoable-assignment, *276*

analyze-variable, *261*

Anna Logue, 340 (ex. 7.2)

annotate-expr, *196*

Annotation layer, 304

any-arg, 76

any-object?, 91

APL, 87 *n*

Applicability of procedure, 73, 76, 78, 88, 98

application?, *236*

Application of procedures, 235, 244–246

Applicative order, 234, 245

```
apply, 23, 375
  in evaluator, 234 (see also a:apply; g:apply; x:apply)
  with "extra" argument, 85 (ex. 3.2)
Architecture
  parti , 5, 299
  of programs, 5–6
Arguments
  indefinite number of (see n-ary procedure)
  in Scheme, 250, 380
  non-strict, 250
  strict, 251
Arithmetic. See also Arithmetic package; Combinators: arithmetic
combinators
  boolean, 84 (ex. 3.1)
  on functions, 80–83
  generic (see Generic arithmetic) layered, 309–310
  symbolic, 71–73
  with units, 310–314
  on vectors, 85 (ex. 3.2)
Arithmetic operators modulating, 71–73
Arithmetic package, 71
  combining arithmetics, 73–80
Arity. See also n-ary procedure
  of function, 23, 27
  of operator, 74
  procedure-arity, 28
```

```
Armstrong, Edwin, 10 (fig. 1.1)
Aspect-oriented programming, 88 n
assert! in propagator, 336, 349
assert in Scheme, 28
Assignment
  ! naming convention, 393 n
  backtracking and, 276
  in evaluator, 243
  in Scheme, 392–394
  set!, 393
assignment?, 243
assignment-value, 243
assignment-variable, 243
Association list (alist), 303
Astronomy
  distances to stars, 329
  magnitudes of stars, 336
attach-rule!, 168, 170
Automagically, 10
Automatic differentiation, 103
  generic arithmetic handlers for, 107–110
  higher-order functions, 119
  literal functions, 123
  n-ary functions, 111
  Newton's method using, 104
```

```
Autonomous agent in game, 139, 140, 144
Avatar in game, 139
Backquote in Scheme, 391
Backtracking, 269–271. See also Exploratory behavior; Generate and
test; Search
  amb (see amb)
  assignment and, 276
  continuations and, 287, 288–289
  dependency-directed (see Dependency-directed backtracking)
  generate and test, 16
  language and, 270–271
  rules and, 162, 164
  segment variables and, 172
Ballantyne, Michael, 203 n
Bard, Jonathan B. L., 16 n
base-layer, 303
base-layer-value, 305
basic-knight-move, 213
basic-queen-move, 215
Beal, Jacob, 8 n
begin?, 242
begin, in evaluator and Scheme, 242
begin-actions, 242
Belief status of premise, 349
Ben Bitdiddle, 44 (ex. 2.7), 277 (ex. 5.17)
```

```
Bessel, Friedrich Wilhelm, 332
binary-amb, 360
Binary amb, 359–363
Binding, 381 n
  of formal parameters, 234, 246
  of pattern variables, 170, 172, 175
Biology, ideas from, 8–17
board-addresses, 217
Board game domain model, 53
  checkers, 54–55, 59
Body
  of let expression, 385
  of procedure, 234, 381
Body plan, 9–12
  animal, 9
  combinators and, 11, 36
  domain-specific language, 11
  radio receiver, 10
  software, 11
Bohlin, R.C., 337
boolean?, 84 (ex. 3.1)
Boolean arithmetic, 84 (ex. 3.1)
Boolean values, 386
Bourne shell, 42
BRE (Basic Regular Expression), 38
```

```
Breadth-first search, 290–292
Brittle software, 1
Bundle, 395–397
bundle, 396
Byrd, Will, 203 n
C, 65, 238
C++ and overloading, 154
c:, 331 (fig. 7.3)
cache-wrapped-dispatch-store, 132
Caching, for generic dispatch, 131
call-with-current-continuation, 282
call-with-values, 31 n
call/cc, 282
Call by need, 245, 251
capture?, 223
car, 387
Carroll, Lewis, 285 n
cdr, 387
Cell (propagation), 342, 343–346
cell-merge, 344
cell-strongest, 346
chaining-generic-procedure, 138
Chapman, David, 358 n
Checkers, 53–64
  domain model, 54–55, 59
```

```
Chen, Kenny, 203 n
Chess, 64 (ex. 2.12), 213–224
  board as graph, 216
  compiling move patterns to matcher procedures, 225–231
  knight move patterns, 213, 214
  making moves, 221
  move patterns on board graph, 213
  queen move patterns, 215
  Choice, nondeterministic. See amb
Choice propagator, 356–364. See also binary-amb; p:amb
Church, Alonzo, 1 n, 380 n
Circuit, electrical, 340 (ex. 7.2)
Clausal learning, 358 n
Clause in conditional, 383
Clifford, William Klingdon, 106 n
Clinger, William, 277 n
CLOS, 88 n
Code smell, 6 n
Colmerauer, Alain, 271, 370 n
color, 218
Combination in Scheme, 235, 380. See also Procedure: application
of
Combinatorial puzzles, 277 (ex. 5.17), 364–367
Combinator language, 11, 30
Combinators, 11, 22–36
  arithmetic combinators, 67–84
```

```
body plans and, 11, 36
  function combinators, 23–29 (see also Function combinators)
  for pattern matching, 170, 175
  problems with, 83, 88
  for regular expressions, 38–43
  system of, 21, 22
combined-arithmetic, 79
Combining arithmetics, 73–80
Comma in backquote, 391
Common Lisp Object System, 88 n
Compiler optimization, 160, 259, 269 (ex. 5.15)
  assignment and, 264
  constant folding, 268 (ex. 5.14)
  peephole, 168
Compile time, 259
Compiling, 259
  for graph patterns, 225–231
  formal-parameter declarations, 269 (ex. 5.16)
  for pattern matching, 176–179
  to execution procedures, 259–267, 273–277 (see also
  analyze-...)
  to propagator networks, 337 n, 340 (ex. 7.1), 367 (ex. 7.6)
  to regular expressions, 39–43
complement, 203 n, 309 n
compose, 23 , 24 (fig. 2.1), 32 , 382
compound-propagator, 347
```

```
Compound data in Scheme, 386–389
cond
  in evaluator, 241
  in Scheme, 383
cond?, 241
cond-clause-consequent, 241
cond-clause-predicate, 241
cond-clauses, 241
cond->if, 241
Conditionals
  in evaluator, 238
  in Scheme, 383–384
conjoin, 309 n
connect!, 212
connect-up-square, 219
cons, 387
g:cons (graph version), 210
Consequent in conditional, 383, 384
Consequent of rule, 161
constant-union, 77
Constant folding, 268 (ex. 5.14)
Constraint propagator (c:), 330, 331 (fig. 7.3)
Constructors in Scheme, 386
Continuation-passing style, 280–281
  for amb, 273
```

```
in matcher, 170
  in rule system, 164
  in unifier, 186
Continuations in Scheme, 280–287
backtracking and, 287, 288–289
  call/cc, 282
  call-with-current-continuation, 282
  nonlocal exits, 284–285
  nonlocal transfer of control, 285–287
  underlying, 281–287
Contradiction object for
  propagation, 345
Correctness vs. flexibility, 18
Curry, Haskell, 34
curry-argument, 34 , 34 (fig. 2.6)
Currying, 34
  for multiple arguments, 138 n
  partial derivatives and, 113 (ex.
  3.8)
Cy D. Fect, 277 (ex. 5.17)
Data
  layered, 302–305
  restrictions on use of, 324
  tagged, 134, 155
Data-purpose algebra, 325
```

```
Debugging, 24 n, 260, 268 (ex. 5.13). See also Paranoid
programming
  dependencies for, 315, 322, 329
  numerical code, 71, 96, 100
Declarations
  compiling, 269 (ex. 5.16)
  constants, 268 (ex. 5.14)
  on formal parameters, 233, 250
  inferred type, 195
  layering for, 6, 299, 321 (ex. 6.4)
  lazy and lazy memo formal parameters, 253
  optional parameter, 258 (ex. 5.11)
  record type, 388
  relationships between predicates, 135, 155
  rest parameter, 258 (ex. 5.11)
  restrictions on formal parameters, 257 (ex. 5.10)
  restrictions on pattern variables, 163
default-object, 75 n
default-object?, 75 n
define
  '.' for rest parameters, 267 (ex. 5.12), 389
  in evaluator, 244
  in Scheme, 381
define-c:prop, 348
define-clock-handler, 145
define-generic-procedure-handler, 89, 99
```

```
define-layered-procedure-handler, 353
definition?, 244
definition-value, 244
definition-variable, 244
Definitions in Scheme, 381–383. See also Internal definitions in
Scheme
Degeneracy, 4, 12–14
  in biological systems, 12
  in engineered systems, 14
  evolution and, 13
  of genetic code, 12
  partial information and, 14
  physics and, 13
  propagation and, 369
  redundancy vs., 12 n
deKleer, Johan, 358 n
delay, 211
Delegate procedure in bundle, 396
Delegation, 128
del Pino, E. M., 16 n
Dependency-directed
  backtracking, 315, 324, 358–364, 370. See also amb: propagation
  implementation combinatorial puzzles, 364–367
Depth-first search, 277, 290–292
derivative, 107
Derived expression types, 240–242
```

```
Diamond, ball of mud vs., 87
Dictionary, 166, 170, 175
Differential equations, integrating, 68–70, 256 (ex. 5.8)
Differential object, 105
Differentiation, automatic. See Automatic differentiation
Direction
  on checkerboard, 55
  on chessboard, 213
Directional propagator (p:), 331, 332 (fig. 7.4)
discard-argument, 33 , 33 (fig.
2.5)
disjoin*, 77 n
Dispatch. See Generic dispatch; Pattern-directed invocation
Dispatch key, 131, 136
Dispatch store, 90, 98, 125, 128, 131, 136–138
Distances to stars, 329
Domain model for board game, 53
  checkers, 54–55, 59
Domain predicate, 74
Dotted-tail notation, 389
Doyle, Jon, 358 n
Driver loop (read-eval-print loop), 246
Dual numbers, 106 n
Dynamic binding in Scheme, 394–395
e, as integral, 257 (ex. 5.8)
```

```
Edge, of graph, 209, 211
edge-value, 212
Effects. See also Assignment
  in evaluator, 242–243
  in Scheme, 392–394
Efficiency vs. flexibility, 17
Electrical circuit, 340 (ex. 7.2)
Element variable, 171
Elinson, R. P., 16 n
else in cond, 383
else-clause?, 241
Emacs, 1 n
Empty list, 387
Engineering
  degeneracy and, 14
  half-full glass, 18
  redundancy and, 14
Environment, in evaluation, 234, 245
  lexical scoping, 239, 246
  procedure application, 234
Environment, in pattern matching. See Dictionary
eq?, 390
ERE (Extended Regular Expression), 38, 46 (ex. 2.10)
Ernst, M. D., 88 n
eval, 234, 375. See also g:eval; x:eval
```

```
Evaluation of expressions, 235–244
  lambda expressions, 239
  applications, 235
  assignments, 243
  conditionals, 238
  definitions, 243
  derived expressions, 240–242
  quotations, 237
  self-evaluating expressions, 236
  sequences, 242
  variables, 238
Eva Lu Ator, 44 (ex. 2.7), 277 (ex. 5.17), 294 (ex. 5.23)
Evaluator, 12. See also Evaluation of expressions; Interpreter
evolver, 70
Exclamation point in name, 393 n
execute-strict, 275
Exploratory behavior, 14–17, 269–271. See also Backtracking;
Generate and test; Search
Expressions in Scheme, 379
extend-arithmetic, 78
extend-generic-arithmetic!, 93
extract-dx-part, 110
factorial, 384 , 385
  pattern-directed, 168
Fibonacci numbers, 129, 255
finite-part, 118
```

```
Finite part of differential object, 106
First-class object, 282, 382
Flexibility
  additivity, 2
  body plan, 9
  brittleness vs., 1
  combinators (see Combinators)
  combinators vs., 83
  correctness vs., 18
  degeneracy, 4, 12, 370, 371
  diamond vs. ball of mud, 87
  efficiency vs., 17
  exploratory behavior, 14, 329
  generic procedures, 67
  layered system, 4, 299, 356
  mix-and-match parts, 3, 22, 170, 232
  pattern-directed invocation (see Pattern-directed invocation)
  Postel's law, 3, 19 n
  program architecture, 5
  propagator network, 328
  redundancy, 12, 371
  rule system, 157
flip-coin, 144
Floyd, Bob, 271
Fluid variable. See Parameter
```

```
Forbus, Ken, 358 n
force, 211
Formal parameters of procedure, 234, 381
declarations, 233, 250
  lazy and lazy memo declarations, 253
  lazy arguments, 251
  optional argument, 118, 258
  (ex. 5.11)
  rest arguments, 248 n, 258 (ex. 5.11), 267 (ex. 5.12), 389–390
  restriction declarations, 257 (ex. 5.10)
Franklin, Benjamin, 183
Fredkin, Edward, 125 n
Freuder, Eugene, 332 n
Friedman, Daniel P., 254 n
Fully supported, 349
function-extender, 82
Functional programming, 394 n
Function arithmetic, 80–83
Function combinators, 23–29
  compose, 23
  curry-argument, 34
  discard-argument, 33
  parallel-combine, 25
  permute-arguments, 35
  spread-combine, 26
```

```
g:, 236 n
g:advance, 236
  handlers, 254
g:apply, 245
  handlers, 245–246
g:eval, 235
  handlers, 235–244
  Scheme primitives and, 238 n
g:handle-operand, 252
Games. See Adventure game; Checkers; Chess Gatewood, George D.,
334 n
Generate and test, 14–17, 288, 292. See also Backtracking;
Exploratory behavior; Search
  backtracking, 16
  in biology, 14
  in evolution, 16
generic-move!, 146
generic-procedure-constructor, 90, 97
generic-procedure-dispatch, 100 , 125
generic-symbolic, 309
generic-with-layers, 309
Generic arithmetic, 90–96
  automatic differentiation handlers, 107–110
  problems with, 94
Generic dispatch, 4, 99. See also Dispatch store
  caching for, 131
```

```
chaining handlers, 137
  most specific handler, 136
  pattern matching vs., 157
  resolution policy, 98, 130, 136
  rules for, 88
  trie data structure for, 125–130
Generic procedures extensible, 87–101
  flexibility, 67
  implementation, 97–100
  object-oriented programming and, 4, 88 n, 138–152
Gerhart, John C., 9 n, 14 n
get-arity, 28
get-handler, 98
get-hunger, 143
Gilliland, R.L., 337
giuoco-piano-opening, 223
gmatch:compile-path, 226
gmatch:compile-target, 228
gmatch:compile-var, 230
Gödel, Kurt, 1 n
Golden ratio, 256
Gossip propagation, 354 (ex. 7.4)
Graph
  alternate views, 216
  chessboard as, 216
```

```
implementation of, 211–212
  lazy, 211
  list as, 210
  pattern matching on, 209–231
  propagation and, 342 (ex. 7.3)
graph-match, 225
graph-node-view, 216
Graph edge, 209, 211
Graph node, 209, 211
grep, 42
guarantee, 151 n
guarantee-list-of, 151 n
handle-cell-contradiction, 363
handle-operand. See g:handle-operand; x:handle-operand
Handler
  applicability of, 73, 98
  choosing efficiently, 125
  for arithmetic operation, 71
  for generic procedure, 88
  for layered procedure, 306
  term-rewriting rule consequent, 165
has-edge?, 212
Hash table, 29 n
  for memoization, 132
  for sticky note, 29, 254
```

```
Haskell, 22 n, 251
  currying, 138 n
  overloading, 154
  type system, xvi Herbrand, Jacques, 1 n
Hewitt, Carl E., 170 n, 271, 370 n
Hewitt, Edwin, 106 n
Hipparchus, 336 n
Hipparcos satellite, 335, 335 n, 336 n
Hox complex (genes), 9
Hubble space telescope, 337
Hygienic macro, 167, 240 n
Hyperreal numbers, 106 n
Hypothetical premise, 356, 359–364
IDE (Integrated Development Environment), 321 (ex. 6.4)
if
  in evaluator, 239
  in Scheme, 384
if?, 239
if-alternative, 239
if-consequent, 239
if-predicate, 239
Improper list, 248 n
in (believed), 349
Indentation in Scheme, 382 n
Index
```

```
of this book, 409
  trie, 125
  zero-based, 388
infer-program-types, 194, 196
infinitesimal-part, 118
Infinitesimal part of differential object, 106
Infix notation, 250 (ex. 5.7)
Inheritance
  delegation vs., 128
  object-oriented programming, 140
inquire in propagator, 334
install-arithmetic!, 72
Integrated Development Environment (IDE), 321 (ex. 6.4)
Integrating differential equations, 68–70, 256 (ex. 5.8)
Internal definitions in Scheme, 24, 383, 385
Interpreter, 233–254
Intervals
  in measurements, 332–336
  merging, 352
invert-address, 219
iota, 112 n
Iteration in Scheme, 385
Java, 1 n, 6, 22 n
  chaining, 146
  combinators, 65
```

```
interfaces, 6 n
Jonge, Joost Kiewiet de, 334 n
Justification, annotation of, 322
Kahn, Louis Isadore, 5
Kanizsa, Gaetano, 328
Kanizsa's triangle illusion, 328, 328 (fig. 7.1)
Kirschner, Marc W., 9 n, 14 n
Knuth, Donald E., 409
Kowalski, Robert M., 271
Kutsia, Temur, 203 n
lambda
  '.' or symbol for rest parameters, 248 n, 267 (ex. 5.12), 389
  in evaluator, 239
  in Scheme, 380
lambda (λ) calculus, 1 n
lambda?, 239
lambda-body, 239
lambda-parameters, 239
layer-accessor, 305
layered-datum, 303
layered-extender, 310
Layered arithmetic, 309–310
Layered data, 302–305
```

Layered procedure, 301, 305–309, 352

```
Layering, 4, 299. See also Architecture: of programs
  declarations, 299, 321 (ex. 6.4)
  program architecture, 5
Layers
  annotation layer, 304
  base layer, 303
  justification layer, 322
  support layer, 317
  units layer, 304
Lazy arguments, 251. See also Postponed evaluation
  lazy and lazy memo declarations, 253
Lazy graph, 211
Lazy list (stream), 211, 254–256
  integration using, 256 (ex. 5.8)
Lem E. Tweakit, 277 (ex. 5.17)
let
  in evaluator, 241
  in Scheme, 384
let?, 242
let*, 385
let-body, 242
let-bound-values, 242
let-bound-variables, 242
let-cells, 330
let->combination, 242
```

```
let-values, 31 n
Lexical scoping, 239, 245, 246, 382
Lieberherr, Karl, 358 n
Lisp, xvi, 235, 387 n
  Perlis quip, 17
list, 386
list?, 386
list->graph, 211
list->lazy-graph, 211
list-ref, 388
list-set!, 393
Lists
  as graphs, 210
  improper, 248 n
  in pattern matching, 158
  in Scheme, 386–389, 393
  lazy (streams), 211, 254–256, 256 (ex. 5.8)
  printing, 72 n
literal-function, 83
Literal symbol in Scheme, 390–391
Local names in Scheme, 384–385
Local state, 393
  object-oriented programming and, 138
Logic puzzles. See Combinatorial puzzles
lookup-variable-value, 238
```

```
Loops in Scheme, 385
Louis Reasoner, 44 (ex. 2.7), 277 (ex. 5.17)
lset library, 320
Macro, 240 n, 264
  hygienic, 167
  syntactic closure, 167
  syntax rules, 288, 295 (ex. 5.25)
Magnitudes of stars, 336
make-annotation-layer, 304
make-arithmetic, 74
make-begin, 242
make-cached-chaining-dispatch-store, 138
make-cached-most-specific-dispatch-store, 138
make-cell, 344
make-chaining-dispatch-store, 137
make-chess-board, 217
make-chess-board-internal, 218
make-generic-arithmetic, 90
make-graph-edge, 212
make-graph-node, 212
make-if, 239
make-infinitesimal, 116
make-lambda, 240
make-layered-datum, 303
make-layered-procedure, 306
```

```
make-most-specific-dispatch-store, 137
make-operation, 74
make-parameter, 395
make-pattern-operator, 169
make-property, 142, 150, 151
make-rule, 166
make-simple-dispatch-store, 90, 98
make-type, 142, 150, 152
Manzyuk, Oleksandr, 121 n
map, 249 (ex. 5.5)
match-args, 108
match:bindings, 175
match:compile-pattern, 179
match:dict-substitution, 186
match:element, 171, 180
match:element-var?, 178
match:eqv, 171
match:extend-dict, 176
match:list, 174
match:lookup, 176
match:new-dict, 175
match:segment, 173
match:segment-var?, 178
match:var?, 178
```

Matcher. *See* Match procedure Match procedure, 166, 170

```
Matrix arithmetic, 102 (ex. 3.6), 103 (ex. 3.7)
Maximal factor, 117
maybe-grab-segment, 205
maybe-set!, 276, 295 (ex. 5.25)
maybe-substitute, 191
Mayer, Meinhard E., 114 n
McAllester, David, 358 n
McCarthy, John, 271, 277 n
MDL, 249 (ex. 5.6)
Memoization
  hash table for, 132
  lazy evaluation and, 251 n
merge, 351
merge-intervals, 352
merge-value-sets, 353
Message-accepting procedure, 396
Metaobject Protocol, 88 n
Method. See Handler; Message-accepting procedure
MIT/GNU Scheme, 379
Mitros, Piotr, 11 n
Mix-and-match parts, 3, 7 n, 22. See also Combinators
Moses, Joel, 87 n
most-specific-generic-procedure, 138
Mud, ball of, 87
Multiple values in Scheme, 30–32
```

```
n:, 69 n
Naming conventions
  ! for assignment, 393 n
  ? for predicate, 386 n
  %, 152
narrate!, 144
n-ary procedure (indefinite number of arguments), 29, 72 n, 248
(ex. 5.2), 258 (ex. 5.11), 267 (ex. 5.12), 389–390
Neighbor in propagator, 342
Nested definition in Scheme. See Internal definitions in Scheme
.net, 1 n
Newton's method, 104
next-turn, 219
Node, of graph, 209, 211
node-at, 218
Nogood set, 358
Nondeterministic choice. See amb
Non-strict argument, 250. See also Postponed evaluation
Non-strict procedure, 250
Normal order, 236, 245
nothing?, 343
null?, 387
number?, 237
*number-of-calls-to-fail*, 289
Numbers in Scheme, 237
```

Numeral, 379. *See also* Rational constant

```
numeric-arithmetic, 75
Numerical integration, 68–70, 256 (ex. 5.8)
Object-oriented programming generic procedures and, 4, 88 n, 138–
152
  inheritance, 140
  local state and, 138
  modeling with, 138
ODE integrator, 68–70
Offset on checkerboard, 55
operands, 236
Operands of combination, 234, 380
  order of evaluation, 246
operation-applicability, 74
operation-union, 78
operation-union-dispatch, 78
operator, 236
Operator of combination, 234, 380
Optical illusion, 328, 328 (fig.
7.1)
Optional argument, 118
  optional declarations, 258 (ex. 5.11)
out (not believed), 349
Overloading, 71–73, 154
override-rule!, 170
```

```
p:, 332 (fig. 7.4)
p:amb, 357, 363, 364
pair?, 387
Pairs in Scheme, 387, 393
parallel-combine, 25 (fig. 2.2), 26
Parameter (fluid variable), 395
Parameter (of procedure). See Formal parameters of procedure
parameterize, 395
Parametric types, 202 (ex. 4.15)
Paranoid programming, 28, 65, 321 (ex. 6.3)
Parentheses in Scheme, 380, 387
Parti , 5, 299
partial (derivative), 111
Partial information, 4, 130, 157
  degeneracy and, 14
  propagation, 344
  type inference, 193–201
  unification, 183, 185
Pattern, 157
  partial information, 157, 183
  rules and, 157, 160
Pattern-directed invocation, 158, 168–170, 370 n
  - (negation or subtraction), 168
  factorial, 168
Pattern matching, 157. See also Pattern-directed invocation;
Unification
```

```
combinators for, 170, 175
  equality testing vs., 157, 183
  generic dispatch vs., 157
  on graphs, 209–231
  on lists, 158
  term rewriting, 160–167
Pattern variable, 157, 158. See also Segment variable
  in graph matching, 213, 215
  restrictions, 163
Perlis, Alan J., 17, 150, 159
Perlmutter, Barak A., 121 n
permute-arguments, 35 (fig. 2.7), 36
Perturbational programming, 323
π (pi), 381
piece-at, 221
piece-in, 221
PLANNER
  backtracking, 271
  pattern-directed invocation, 370 n
populate-sides, 220
possible-directions, 55
Postel, Jonathan Bruce, 3
Postel's law, 3, 19 n
Postponed evaluation, 236. See also delay; force; Stream
  compound propagator, 347
```

```
lazy graph, 211
  non-strict arguments, 253–254, 266
pp (pretty-print), 72 n
predicate?, 133
predicate-constructor, 135
Predicate as type, 132–138
  for argument checking, 151 n
  as dispatch key, 136
  for formal parameter, 257 (ex. 5.10)
  in pattern variable, 162, 179
Predicate in conditional, 383, 384
Predicates, 386 n. See also Predicate as type
  ? naming convention, 386 n
  abstract predicate, 134
  domain predicate, 74
  for procedure applicability, 73, 98
  registration of, 133
  relationships between, 135, 155
Premise, 315
  belief status, 349
  hypothetical, 356, 359–364
premise-nogoods, 359
Pretty-print (pp), 72 n
Prime number test, 134
primitive-propagator, 347
```

```
Primitive procedure, 245
print-all-results, 173
Printing list structure, 72 n
Procedure
  application of, 235, 244–246
  lambda expression for, 380 (see also lambda)
  layered, 301, 305–309, 352
  match procedure, 166, 170
  message-accepting, 396
  with multiple values, 30–32
  n-ary (see n-ary procedure)
  with non-strict arguments, 250–256
  non-strict, 250
  primitive, 245
  strict, 245, 250
  variadic (see n-ary procedure)
  with indefinite number of arguments (see n-ary procedure)
procedure-parameter-name, 252
program-constraints, 199
Programming
  additive, 1–5
  architecture of, 5–6
  layered, 299
Prolog
  backtracking, 271
```

```
occurs check, 191 n
  pattern-directed invocation, 370 n
  segment variables, 203 n
Propagation
  activation policy, 347
  alternative world views, 349–351
  amb, 355–364
  astronomy example, 329–340
  cell, 342, 343–346
  circuit example, 340 (ex. 7.2)
  degeneracy and, 369
  graph example, 342 (ex. 7.3)
  mechanism, 342–349
  merging values, 351–354
  model of computation, 327–329
  neighbor, 342
  partial information, 344
  propagator, 342, 346–349 (see also Propagator)
  scheduler, 342, 343
  searching alternatives, 355–364
  type inference, 368 (ex. 7.8)
  unification and, 354 (ex. 7.4)
  wiring diagram vs. expression, 327, 331 (fig. 7.3), 337 n, 340 (ex.
  7.1), 367 (ex. 7.6), 369
Propagator, 342, 346–349
  choice propagator (see Choice propagator)
```

```
constraint propagator (c:), 330, 331 (fig. 7.3)
  directional propagator (p:), 331, 332 (fig. 7.4)
  input and output cells, 343
propagator, 346
property-getter, 145
Property list, 303
Provenance, 299, 315, 322, 328, 333
Puzzles (combinatorial), 277 (ex. 5.17), 364–367
Pythagorean triples, 272, 293 (ex. 5.22), 357
Python, 6, 14 n
  generic arithmetic, 87
Quasiquotation in Scheme, 391
Question mark. See ?
Quotation
  in evaluator, 237
  in Scheme, 390–391
quote, 237
quoted?, 237
Radio receiver, 10
Radul, Alexey Andreyevich, 121 n, 344 n, 358 n, 370
random-bias, 143
random-choice, 143
random-number, 144
Randomness. See flip-coin; random-...
```

```
Rational constant, 47, 379
Read-eval-print loop (repl), 246
Records in Scheme, 151, 386–389, 394
  record type declaration, 388
Recursive procedures, 384
reduce-right, 263
Redundancy, 12–14, 130
  in biological systems, 12
  degeneracy vs., 12 n
  in engineered systems, 14
ref-stream, 255
Referee for game, 53, 210
Registration of predicate, 133
Regular expressions, 37–38
  combinator implementation, 38–43
Relationships between predicates, 135, 155
repl, 246
require, 272, 292
Resolution policy for generic dispatch, 98, 130, 136
Rest parameter, 248 n, 267 (ex. 5.12), 390
rest declarations, 258 (ex. 5.11)
restrict-arity, 28
Restrictions
  on formal parameters, 257 (ex. 5.10)
  on pattern variables, 163
```

```
restrict-to declarations, 258
(ex. 5.10)
result-receiver, 170
retract! in propagator, 335, 349
Returning multiple values in Scheme, 30–32
Robinson, John Alan, 183
rotate-180-view, 216
Roussel, Phillipe, 271
Ruby and continuations, 282
rule, 167
rule-simplifier, 161, 165
Rules
  algebra, 161–163
  backtracking and, 162, 164
  for generic procedure dispatch, 88
  patterns and, 157, 160
Run time, 259
Russell, Jane L., 334
Sandewall, Erik, 271 n
Satellite, Hipparcos, 335, 335 n, 336 n
SAT solver, 358 n, 368
say!, 148
Scheduler for propagation, 342, 343
Scheme, xvi, 244, 379–395
  MIT/GNU Scheme, 379
```

```
Schönfinkel, Moses, 34 n
scmutils, 101
Scope, 381 n. See also Lexical scoping
Search, 355–356. See also amb; Backtracking; Exploratory behavior;
Generate and test
  depth-first and breadth-first, 277, 290–292
Segment variable, 159. See also Pattern variable
  in algebra rules, 162
  backtracking and, 172
  unification and, 203–208
Selectors in Scheme, 386
self-evaluating?, 237
Semicolon (;). See also Syntactic sugar
  comment introduced by, 390
Sensitivity analysis, 323
sequence->begin, 240
set!
  in evaluator, 243
  in Scheme, 393
set-car!, 393
set-cdr!, 393
set-piece-at, 221
set-predicate<=!, 136
setup-propagator-system, 366
SI (International System of Units), 314 (ex. 6.1)
SICP, 379
```

```
inhabitants, 44 (ex. 2.7), 277 (ex. 5.17), 294 (ex. 5.23)
simple-abstract-predicate, 134
simple-generic-procedure, 89, 89 , 97
simple-move, 222
simple-operation, 74
Simplification, algebraic, 161–163
Siskind, Jeffrey Mark, 121 n
Smalltalk
  continuations, 282
  currying, 138 n
  message passing, 396 n
Smith, Brian Cantwell, 237 n
SML and continuations, 282
Snark hunt, 285 (ex. 5.21)
Software support for book, 377
SOS, 88 n
Special form, 235, 380
  implemented by macro, 264
  in evaluator, 237–244
spread-apply, 32
spread-combine, 27 (fig. 2.3), 28 , 31 , 31 (fig. 2.4)
square, 381
Stallman, Richard Matthew, 332 n, 358 n
Standards, 46 (ex. 2.10)
Stars
```

```
distances to, 329
  magnitudes of, 336
start-chess-game, 220
Steele, Guy Lewis Jr., 30 n, 332 n, 358 n
Sticky note
  hash table for, 29, 254
  for metadata, 169
stormer-2, 69
Stormer's integrator, 68
Stream (lazy list), 211, 254–256
  integration using, 256 (ex. 5.8)
Strict argument, 251
Strict procedure, 245, 250
strongest-consequence, 351
strongest-value, 350
Struve, Friedrich G. W. von, 332
Suppes, Patrick, 322 n
support-layer, 318
support-layer-value, 318
support-set abstraction (...support-set...), 319
Support for datum, 316
Support layer, 317
Support set, 315
Sussman, Gerald Jay, 106 n, 114 n, 332 n, 358 n, 370
Symbol, in Scheme, 238 n, 390–391
```

```
symbolic-extender, 76
Symbolic arithmetic, 71–73
symmetrize-move, 214
Syntactic sugar, 159, 315 (ex. 6.1)
  define as, 382
  derived expression types, 240–242
Syntax. See Combination; Macro; Special form; Syntactic
sugar
Tag, for predicate, 131, 133, 136
tagged-list?, 238
Tagged data, 134, 155
take-thing, 147
Tannenbaum, Andrew S., 46 (ex. 2.10)
tell! in adventure game, 147
tell! in propagator, 333
Term rewriting, 160–167
  for algebraic simplification, 161–163
  for compiler optimization, 160, 168
  equational theories, 160
  pattern matching, 160–167
test-content!, 344 , 345
text-of-quotation, 237
the-contradiction, 345
the-nothing, 343, 344
the-unspecified-value, 239
```

```
Thunk, 253 n
tinyCLOS, 88 n
Trie data structure, for generic dispatch, 125–130
Troll, 139, 142–144
Truth-maintenance system, 358 n
try-rules, 165
TTL mix-and-match parts, 7 n
Turing, Alan, 1 n
Turn in chess
  labeling edge to piece, 220, 221
  next-turn, 219
  turn state variable, 218
type-instantiator, 142, 150, 152
type-properties, 152
Typed expression, 194
Type inference, 193–201
  inferred declaration, 195
  propagation for, 368 (ex. 7.8)
  unification for, 196, 200
Types. See also Predicate as type in adventure game, 142–145, 150–
152
  parametric, 202 (ex. 4.15)
  union, 202 (ex. 4.16)
  user-defined, 132–138
Unbound variable, 238, 247 (ex. 5.1)
```

```
Unification, 157, 183–184
  as equation solving, 185
  partial information and, 183, 185
  propagation and, 354 (ex. 7.4)
  segment variables and, 203–208
  substitution instance, 183
  type inference and, 193–201
  unifier, 183
unifier, 186
unify, 186
unify-constraints, 200
unify:internal, 187
Union types, 202 (ex. 4.16)
unit, 311
unit-arithmetic, 312
unit-layer, 304
Units (of measurement), 47–48
  arithmetic with, 310–314
  base vs. derived units, 310 n
  SI (International System of Units), 314 (ex. 6.1)
  units layer, 304
  wrappers for, 49–52
UNIX and streams, 297
User-defined types, 132–138
```

```
Value set, 350
  merging, 353
Variable, 381. See also Pattern variable; Segment variable
  in evaluator, 238
  variable?, 238
Variadic procedure. See n-ary procedure
vector, 388
vector?, 388
vector-ref, 388
vector-set!, 393
Vector arithmetic, 85 (ex. 3.2), 102 (ex. 3.6), 103 (ex. 3.7)
Vectors and covectors, 112, 113 (ex. 3.10)
Vectors in Scheme, 386–389, 393
Vectors of procedures, 248 (ex. 5.3)
Waltz, David L., 332 n
  Waltz algorithm, 342 (ex. 7.3)
Warren, David, 271
Website for book software, 377
Wengert, Robert Edwin, 103 n
white-move?, 218
Whitespace in Scheme, 382 n
Wilde, Oscar (Perlis's paraphrase of), 17
Wiring diagram. See Propagation: wiring diagram
Wisdom, Jack, 104 n, 114 n
Wise, David S., 254 n
```

```
with-breadth-first-schedule, 290
with-depth-first-schedule, 290
Wrappers, 46–52
  specializers, 49
  units of measurement and, 49–52
write-line, 392 n
x:, 260 n
x:advance, 261
  handlers, 267
x:analyze, 260
  handlers, 261–264
```

x:apply, *265* handlers, 265–266 x:eval, *259* x:handle-operand, *266*

Zabih, Ramin, 358 *n* Zero-based indexing, 388 Zuras, Dan, 106 *n*

# **List of Exercises**

| 2.1 | 2.4  | 2.7  | 2.10 | 2.13 |
|-----|------|------|------|------|
| 29  | 36   | 44   | 46   | 64   |
| 2.2 | 2.5  | 2.8  | 2.11 | 2.14 |
| 29  | 37   | 45   | 52   | 64   |
| 2.3 | 2.6  | 2.9  | 2.12 |      |
| 32  | 43   | 46   | 64   |      |
|     |      |      |      |      |
| 3.1 | 3.6  | 3.11 | 3.16 | 3.21 |
| 84  | 102  | 123  | 153  | 153  |
| 3.2 | 3.7  | 3.12 | 3.17 | 3.22 |
| 85  | 103  | 124  | 153  | 154  |
| 3.3 | 3.8  | 3.13 | 3.18 |      |
| 86  | 113  | 129  | 153  |      |
| 3.4 | 3.9  | 3.14 | 3.19 |      |
| 101 | 113  | 130  | 153  |      |
| 3.5 | 3.10 | 3.15 | 3.20 |      |
| 101 | 113  | 132  | 153  |      |
|     |      |      |      |      |
| 4.1 | 4.6  | 4.11 | 4.16 | 4.21 |
| 162 | 180  | 193  | 202  | 209  |
| 4.2 | 4.7  | 4.12 | 4.17 | 4.22 |
| 163 | 181  | 193  | 202  | 213  |
| 4.3 | 4.8  | 4.13 | 4.18 | 4.23 |
| 164 | 182  | 193  | 202  | 216  |
| 4.4 | 4.9  | 4.14 | 4.19 | 4.24 |
| 164 | 182  | 201  | 208  | 225  |
| 4.5 | 4.10 | 4.15 | 4.20 | 4.25 |
| 179 | 193  | 202  | 209  | 231  |
|     |      |      |      |      |
| 5.1 | 5.7  | 5.13 | 5.19 | 5.25 |
| 247 | 250  | 268  | 278  | 295  |
| 5.2 | 5.8  | 5.14 | 5.20 | 5.26 |
| 248 | 256  | 268  | 279  | 295  |
| 5.3 | 5.9  | 5.15 | 5.21 |      |
| 248 | 257  | 269  | 285  |      |
| 5.4 | 5.10 | 5.16 | 5.22 |      |
| 249 | 257  | 269  | 293  |      |
| 5.5 | 5.11 | 5.17 | 5.23 |      |
| 249 | 258  | 277  | 294  |      |
| 5.6 | 5.12 | 5.18 | 5.24 |      |
| 249 | 267  | 278  | 294  |      |
|     |      |      |      |      |
| 6.1 | 6.2  | 6.3  | 6.4  | 6.5  |
| 314 | 320  | 321  | 321  | 323  |
|     |      |      |      |      |
| 7.1 | 7.3  | 7.5  | 7.7  |      |
| 340 | 342  | 367  | 368  |      |
| 7.2 | 7.4  | 7.6  | 7.8  |      |
| 340 | 354  | 367  | 368  |      |