If you’re new to Cyc, we recommend that you follow these tutorials in order.
KB Browser Interface
Foundations of Knowledge Representation in Cyc
This is an introduction to the foundations of knowledge representation in Cyc.
Predicates and Denotational Functions
This is a talk about predicates and denotational functions. You’ve probably heard a little bit about these in other talks before, but we’ll go into a little more detail than you might have heard before.
- The Basics (pdf)
- Arity (pdf)
- Argument Types (pdf)
- Second-order Predicates (pdf)
- MoreOnFunctions (pdf)
Errors in Representing Knowledge
The “Errors in Representing Knowledge” tutorial covers a whole host of errors people have been known to make when representing knowledge in Cyc.
- Errors with Constants, Variables and Reliance on NL (pdf)
- Errors with Specialization, Generalization & Rules (pdf)
- Other Errors (pdf)
Survey of Knowledge Base Content
This set of lessons is intended to give a broad overview of the content of the Knowledge Base. In an effort to expose you to as much of the knowledge base as possible, we included many examples to illustrate the topics we address.
- Introduction (pdf)
- Fundamental Expression Types (pdf)
- Top Level Collections (pdf)
- Time and Dates (pdf)
- Spatial Properties and Relations (pdf)
- Event Types (pdf)
- Information (pdf)
- More Content Areas (pdf)
Ontology Example: Events and Roles
This section will survey Cyc’s representation of events. This section will tie up with later sections where we’ll see how components of events are related to events in Cyc by roles, such as actor slots and sub-events.
Writing Efficient CycL: Some Concrete Suggestions
This section will give you some specific suggestions on how to write CycL that can be more efficiently handled by our Inference Engine. The lessons will give you a set of heuristics, some of which are mutually contradictory, so you’ll have to trade off between them (all good heuristics are mutually contradictory, otherwise you could set up a decision tree, right?)
If you have completed all of the lessons in order, then you’ve been exposed to a lot of suggestions on doing OE that make representational sense, so they are suggestions from the representational side. This section, however, is focusing on stuff from the implementation and algorithmic side that treats CycL as more than just a notational exercise in predicate calculus calligraphy. You’re writing something that is meant to be used by an automaton efficiently to do useful things. So you’ll see some suggestions which might seem a little bit inelegant; actually, many of them have analogs to software engineering principles which would be considered elegant by software engineers, so it’s worth keeping your mind open.
Inference in Cyc
We’ll be talking about Inference in Cyc. Inference is the mechanism we use to conclude new facts from other existing facts and rules in the system. We’ll be talking about it in four sections and the first section will be about the logical aspects of inference.