-
Notifications
You must be signed in to change notification settings - Fork 15
The New Turing Omnibus Chapter 58 Predicate Calculus
As Tom kindly volunteered to shepherd the group this meeting, we first circulated his notes and some copies of the chapter (after a few rounds of Crossy Road on Geckoboard's new Apple TV).
Learning from our struggle to see the big picture last meeting, we began by going through Tom's notes, specifically "The big picture" and "The main pieces" to immediately set the scene.
We then jumped to Tom's example proof, working through resolution using a simpler problem than the one given in the chapter, specifically:
- Axioms:
- All humans are mortal;
- Socrates is human.
- Theorem:
- Socrates is mortal.
Tom led us through the expression of the problem in predicate calculus then its clausal form before showing how we could take a negation of the theorem (in this example, that Socrates is not mortal) and mechanically use resolution to arrive at a proof by contradiction. We initially skimmed the details to ensure we had the gist of the matter before diving into the problem more deeply.
The first topic to cover was predicate calculus itself (or "first-order logic"), reviewing the specific notation used in the chapter and its meaning. We spent some time explaining implication with several practical examples from Tom's notes:
NightTime(x) → Dark(x)
- If it's night time then it must be dark;
- If it's not dark then it must not be night time;
- If it's not night time then we don't know whether it's dark;
- If it's dark then we don't know whether it's night time.
We then worked through the translation of our predicate calculus into clausal form by working through the following transformations:
-
X → Y = ~(X ∧ ~Y) = ~X ∨ Y
(touching on De Morgan's laws) -
∃y(LT(x, y)) = LT(x, f(x))
(Skolemization) - Moving
∀
to the left (renaming variables as needed) and then removing it as it is implied
This lead us to convert our problem into conjunctive normal form and therefore suitable for resolution.
We then stepped through the resolution of our problem by trying to produce clauses that shared the same predicate (using unification where necessary), e.g. ~X
and X
, so that we could combine them (and hopefully arrive at a contradiction).
With the Socrates example thoroughly completed, we spent the remaining time working through the much more complicated example of the man, the wolf, the goat and the cabbage.
- Feedback was almost universally positive with many people praising Tom's efforts to distill a dense chapter into something digestible for a single meeting;
- The suggestion was floated that we might want to spend longer than one meeting on a chapter but there was some resistance due to our past experience spending many months on the same book (and how this may have put off newcomers);
- Tom noted that it took a lot of his time to prepare for the meeting and this might make the act of shepherding off-putting for others.
Chris talked about his work on a new language called "Sentient" as a means of expressing first-order logic problems at a high level of abstraction which could then be automatically solved by a SAT solver.
Thanks to Leo & Geckoboard for hosting and to Tom for his enormous efforts both in preparing for and running the meeting.
- Home
- Documentation
- Choosing a Topic
- Shows & Tells
- Miscellaneous
- Opt Art
- Reinforcement Learning: An Introduction
- 10 Technical Papers Every Programmer Should Read (At Least Twice)
- 7 More Languages in 7 Weeks
- Lua, Day 1: The Call to Adventure
- Lua, Day 2: Tables All the Way Down
- Lua, Day 3
- Factor, Day 1: Stack On, Stack Off
- Factor, Day 2: Painting the Fence
- Factor, Day 3: Balancing on a Boat
- Elm, Day 1: Handling the Basics
- Elm, Day 2: The Elm Architecture
- Elm, Day 3: The Elm Architecture
- Elixir, Day 1: Laying a Great Foundation
- Elixir, Day 2: Controlling Mutations
- Elixir, Day 3: Spawning and Respawning
- Julia, Day 1: Resistance Is Futile
- Julia, Day 2: Getting Assimilated
- Julia, Day 3: Become One With Julia
- Minikanren, Days 1-3
- Minikanren, Einstein's Puzzle
- Idris Days 1-2
- Types and Programming Languages
- Chapter 1: Introduction
- Chapter 2: Mathematical Preliminaries
- Chapter 3: Untyped Arithmetic Expressions
- Chapter 4: An ML Implementation of Arithmetic Expressions
- Chapter 5: The Untyped Lambda-Calculus
- Chapters 6 & 7: De Bruijn Indices and an ML Implementation of the Lambda-Calculus
- Chapter 8: Typed Arithmetic Expressions
- Chapter 9: The Simply-Typed Lambda Calculus
- Chapter 10: An ML Implementation of Simple Types
- Chapter 11: Simple Extensions
- Chapter 11 Redux: Simple Extensions
- Chapter 13: References
- Chapter 14: Exceptions
- Chapter 15: Subtyping – Part 1
- Chapter 15: Subtyping – Part 2
- Chapter 16: The Metatheory of Subtyping
- Chapter 16: Implementation
- Chapter 18: Case Study: Imperative Objects
- Chapter 19: Case Study: Featherweight Java
- The New Turing Omnibus
- Errata
- Chapter 11: Search Trees
- Chapter 8: Random Numbers
- Chapter 35: Sequential Sorting
- Chapter 58: Predicate Calculus
- Chapter 27: Perceptrons
- Chapter 9: Mathematical Research
- Chapter 16: Genetic Algorithms
- Chapter 37: Public Key Cryptography
- Chapter 6: Game Trees
- Chapter 5: Gödel's Theorem
- Chapter 34: Satisfiability (also featuring: Sentient)
- Chapter 44: Cellular Automata
- Chapter 47: Storing Images
- Chapter 12: Error-Correcting Codes
- Chapter 32: The Fast Fourier Transform
- Chapter 36: Neural Networks That Learn
- Chapter 41: NP-Completeness
- Chapter 55: Iteration and Recursion
- Chapter 19: Computer Vision
- Chapter 61: Searching Strings
- Chapter 66: Church's Thesis
- Chapter 52: Text Compression
- Chapter 22: Minimum spanning tree
- Chapter 64: Logic Programming
- Chapter 60: Computer Viruses
- Show & Tell
- Elements of Computing Systems
- Archived pages