Ontological Development Tutorials

If you’re new to Cyc, we recommend that you follow these tutorials in order.

KB Browser Interface

  1. Interface Overview and Browsing the KB (pdf)

Foundations of Knowledge Representation in Cyc

This is an introduction to the foundations of knowledge representation in Cyc.

  1. Why Use Logic? (pdf)
  2. CycL Syntax (pdf)
  3. Collections and Individuals (pdf)
  4. Microtheories (pdf)

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.

  1. The Basics (pdf)
  2. Arity (pdf)
  3. Argument Types (pdf)
  4. Second-order Predicates (pdf)
  5. 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.

  1. Errors with Constants, Variables and Reliance on NL (pdf)
  2. Errors with Specialization, Generalization & Rules (pdf)
  3. 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.

  1. Introduction (pdf)
  2. Fundamental Expression Types (pdf)
  3. Top Level Collections (pdf)
  4. Time and Dates (pdf)
  5. Spatial Properties and Relations (pdf)
  6. Event Types (pdf)
  7. Information (pdf)
  8. 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.

  1. Events in Cyc (pdf)
  2. Roles and Event Predicates (pdf)
  3. Actor Slots (pdf)
  4. Sub-events (pdf)

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.

  1. Writing Efficient CycL: Part 1 (pdf)
  2. Writing Efficient CycL: Part 2 (pdf)

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.

  1. Logical Aspects of Inference (pdf)
  2. Incompleteness in Searching (pdf)
  3. Incompleteness from Resource Bounds and Continuable Searches (pdf)
  4. Efficiency Through Heuristics (pdf)
  5. Inference Features in Cyc (pdf)