10/14/2019 What is Cyc?

- CycWiki

What is Cyc?
From CycWiki

This training module will help explain what Cyc is and how it works.

This tutorial briefly touches on important concepts regarding Cyc. For a deeper explanation of some of the concepts
mentioned here, some links to other documentation are dispersed throughout. However, these links do not exhaust
the relevant documentation available on the network.

Cyc is software written primarily in SubLisp (aka SubL) used for automated reasoning (https://en.wikipedia.org/wi
ki/Automated_reasoning).

The parts of Cyc that we're mainly concerned about at the moment are the Cyc Knowledge Base (a.k.a. "the KB")
and the Inference Engine.

Contents
1 What is Ontology?
2 The Cyc Knowledge Base
3 Microtheories
4 The Inference Engine
5 Other parts of Cyc
5.1 Natural Language (NL)
5.2 Semantic Knowledge Source Integration (SKSI)
5.3 Interfaces
5.4 Truth Maintenance System (TMS)
6 Footnotes

What is Ontology?
If you click a certain ORDER NOW button while shopping online, you know that a dozen roses will be delivered to
your spouse tomorrow by 3pm, and s/he will be pleased by that, and your credit card will have a certain charge
incurred.

Just stop and think for a second about what an amazing mental feat you are performing. You are predicting the
consequences of your actions and others’ reactions. You are making sense of the world. You have some sort of
mental model of the world; your brain “runs” that model, that simulation, and “reads off” the results. In fact you
did all that ahead of time, which is how you decided to click that ORDER NOW button.

How did you accomplish that feat of cognition? And -- more to the point, since we are interested in an artificial
intelligence -- how could a program accomplish that?

You understand a large number of concepts, hundreds of thousands if not millions, and you know ten times that
number of facts, suppositions, rules of thumb, beliefs, etc. about those concepts. Let’s call the vocabulary, the
concepts, an ontology. And let’s call all those statements involving those concepts a knowledge base. But those

https://wiki.cyc.com/wiki/index.php/What_is_Cyc%3F 1/6
10/14/2019 What is Cyc? - CycWiki

aren’t just sitting statically in your brain, like books on library shelves; you have some way of logically combining
multiple pieces of knowledge to infer new things -- ephemeral conclusions which you might use and then forget, or
valuable conclusions which you might retain in memory as worthwhile new pieces of your knowledge base.

What kind of thing is a relationship, though? Let’s consider the relationship of one city being between two others
along some highway -- e.g., Los Angeles is between San Diego and San Francisco along highway US101. We can
abstract out the “cities being between two others along some highway” relation, and think of it as taking four
arguments. If we call that relationship R, and use similarly terse names for those three cities and highway, we could
assert that R(LA,SD,SF,101) is true. To reduce ambiguity, we could give each of those five concepts a more
mnemonic name, we might assert:

BetweenAlongHighway (LosAngeles, SanDiego, SanFranciso, USHighway101).

But now that that relationship has a name, we can assert things about it, just like we asserted things about cities,
highways, and bouquets. For example,

NumberOfArguments (BetweenAlongHighway, 4) -- that relation takes exactly four arguments.

FirstArgumentMustBeA (BetweenAlongHighway, City) -- the first argument is always a city.

FourthArgumentMustBeA (BetweenAlongHighway, Highway) -- the fourth argument must designate a highway.

Perhaps surprisingly, we’re treating each relation as just another term in the ontology. Well if that’s true, can we
also assert relationships between two (or more) relationships? Of course. For instance,
moreGeneralRelation(mother, parent) which means that if m is the mother of c, then m is also a parent of c.
Going back to highways, we know that if BetweenAlongHighway(x,y,z,h) is true, then HighWayConnectsTo(x,h)
must also be true. Using the logical relationship or connective Implies, we could express that necessary truth as:

Implies(BetweenAlongHighway(x,y,z,h) , HighWayConnectsTo(x,h))

We’re implicitly assuming, here, that all those free variables x,y,z,h are universally quantified -- there’s an implicit
“For all x, y, z, and h…” at the beginning of the last assertion, for example.

The same analysis applies to contexts, like TheYear2019, or WhilePlayingProfessionalBaseball, or

ThingsThatBenjaminFranklinBelieved. We can think of those as first-class concepts, as just some more terms in
our ontology, and we can make statements involving them, and we can logically infer things from those statements.

Some of the concepts in the ontology are functions, which take some arguments. For example, we don’t know who
(in that fictional context in which he exists) David Copperfield’s paternal grandfather was, but we can still denote
that person as FatherFn(FatherFn(DavidCopperfield)). Even if did know who that person was, we could still
refer to them that way. Functions have values -- sometimes we know the value of a function applied to some
arguments, and sometimes we don’t. Plus is a function which takes any number of arguments which hopefully are
all numbers, and MotherFn is a function which takes one argument which is a person, and most of us know that the
value of Plus(4, 7, -1, 2) is 12, and that the value of MotherFn(GeorgeWBush) is BarbaraBush, but probably
even Charles Dickens didn’t know who FatherFn(FatherFn(DavidCopperfield)) was, even though we all can
say things about that person: he was born before David Copperfield, for instance.

Think of the ontology as the set of distinctions worth making. This is analogous to words in a language like
English. It’s not quite the same thing, because many concepts would require several words to express in English
(such as the relation “cities being between two others along some highway”, or the context “all the things that

https://wiki.cyc.com/wiki/index.php/What_is_Cyc%3F 2/6
10/14/2019 What is Cyc? - CycWiki

Benjamin Franklin believed to be true on March 8, 1779” or the category “people who ever voted illegally in a US
Presidential Election”). In fact most concepts must be like this, since there are well over 106 important, widely
useful concepts but only a tenth that many words in any natural language like English.

It doesn’t bother us that most of the concepts expressible in English do not have single words denoting them. In
much the same way, most of the concepts in the ontology will not be explicitly named -- the expression
MotherFn(GeorgeWBush) denotes the concept BarbaraBush, where we do happen to have a term for that person in
our ontology. Sometimes we refer to MotherFn as a term-denoting function because its value is always a term in
our ontology even if we don’t have an explicit one-word name for it. We can talk about
MotherFn(MotherFn(MotherFn(MotherFn(GeorgeWBush)))) even though we don’t know who she was. That’s
really the same as in English, when we refer to a concept using two or more words, like “first date” or “date of
death” or “George W. Bush’s maternal great-grand-grandmother”.

Another way to think of all this is that the ontology is the way we choose to carve up concept-space, what we
choose to think of as a primitive -- the metaphysical distinctions we choose to make. There’s no one correct
ontology, and generally the penalty for getting things “wrong” is just one of inefficiency. To take an extreme case,
suppose that someone does a terrible job and decides not to have names for green and blue, but instead only define
the concepts of grue (green by day and blue by night) and bleen (blue by day and green by night). That person can
still express what you or I mean when we say “Grass is green”, but their awkward choice of where to cut the color
concepts requires them to say this in a much wordier way using just grue and bleen: “Grass is grue by day and
bleen by night.”

Using this approach, it is straightforward to get a computer program to do the same sort of reasoning we started out
talking about. We can give the program an ontology that includes the concepts bouquet, charging something to a
credit card, feeling pleased, and so on. And we give it contexts that include modern-day online shopping. And we
give it the default-true rules of thumb that let us infer the consequences -- such as “people usually feel pleased
when they receive gifts”.

The Cyc Knowledge Base

The KB is a store of information. The KB represents knowledge in the form of sentences composed of terms. Cyc
constants are the most typical type of term, but other things, like strings and numbers (and even sentences
themselves), are also terms in Cyc. For a more advanced discussion of Cyc's knowledge representation language,
see What is CycL?.

Every term in Cyc represents either

A collection or set (e.g. #$Boat, which refers to the collection of all boats, and (#$TheSet 1 2 3), which
refers to the mathematical set of the integers 1, 2, and 3)
An individual (e.g. #$IndianOcean or #$TonyBlair)

Furthermore, there are some important kinds of #$Individual Cyc knows about:

Denotational Functions, which produce terms that are not truth values (e.g. #$GovernmentFn is a function
that takes in a geopolitical entity, and returns the organization that is its government2
Predicates (a.k.a. truth functions), which tell us if something is true or not by returning a truth value
(e.g. #$siblings is a predicate that tells us whether or not two animals are siblings)
Microtheories are another important type of, aka specialization of, #$Individual. (See next section.)

Microtheories

https://wiki.cyc.com/wiki/index.php/What_is_Cyc%3F 3/6
10/14/2019 What is Cyc? - CycWiki

Microtheories are overlapping sets of assertions that we use to categorize knowledge in the KB. Each microtheory
is represented with a term in the Cyc KB that is an instance of #$Microtheory. See Cyc Microtheories for a more
detailed discussion.

Microtheories provide context in which facts are considered. Every assertion that is present in the Cyc KB is stated
in a microtheory.

Microtheories are useful because some statements (e.g. "Unicorns are animals", or (#$genls #$Unicorn
#$Animal)) may be known to be true in certain contexts/microtheories (e.g. #$WorldMythologyMt, a
context/microtheory concerning mythology) but not others (e.g. #$RealWorldDefinitionalMt, a
context/microtheory concerning the current world).

Though there may be contradictions in the KB as a whole, there are no contradictions within a given microtheory:
Cyc requires local consistency (consistency within a microtheory), but Cyc does not require global consistency
across the full Cyc Knowledge Base.

The Inference Engine

Informally, the Inference Engine does all the "thinking." (See Inference Algorithm for a detailed discussion of how
the Cyc Inference Engine works).

The Inference Engine is the software that takes the information in the KB and creates new knowledge.

The Inference Engine uses rules of thumb and heuristics, along with other techniques, and applies them to
information stored in the KB to draw conclusions that may be useful in answering questions we ask it.

Some questions we may ask the inference engine could be:3

Who was the president of the United States in 1854?

Do sea horses live underwater?
Can plants eat fish?

We interact with the Inference Engine using the Query Tool in the Cyc Browser, or via SubL code with (software)
functions like new-cyc-query.

Other parts of Cyc

Cyc is a large, complex system with many subsystems, of which the KB and Inference Engine are two (very
important!) examples. A few others merit mentioning here.

Natural Language (NL)

Some of the content of the Cyc KB is lexical knowledge: explicit representations of natural language words, the
strings that they can appear as, knowledge of how they behave grammatically, and the Cyc terms that they may
denote.

The Paraphrase subsystem allows Cyc to express CycL sentences in English.

See Lexifying Non-Relational Individuals and Collections and Lexifying Relations for more information.

Semantic Knowledge Source Integration (SKSI)

https://wiki.cyc.com/wiki/index.php/What_is_Cyc%3F 4/6
10/14/2019 What is Cyc? - CycWiki

When the meaning of the rows and columns of a database, or triples in a triple store, or other such structured
knowledge sources is described to Cyc using assertions stored in its KB, the SKSI subsystem can connect to that
knowledge source during inference, using premises stored there as parts of proofs.

See SKSI Training for more information.

Interfaces

Cyc knowledge base developers use the Cyc Browser, a web-based GUI, to add and edit knowledge and to ask
queries. For more on the browser, see Using the KB Browser.

Java programs can interact directly with Cyc using its KB and Inference APIs. Programs written in other languages
can do the same via web service calls. For more on Cyc's web services, see Asking Queries via Webservices.

Truth Maintenance System (TMS)

When an assertion in the Cyc KB is removed or changes, Cyc's TMS is responsible for propagating the effects of
that change to other affected assertions. For example, if an assertion has been deduced, but one of the assertions
required to support that deduction goes away, TMS will remove the deduced assertion.

Footnotes
1: Cyc is software that we aim to have view the world (by having knowledge of it) and reason about it as a sane
common person would. The explanations in this tutorial will be very vague. We'll get into the details and specifics
of how the tools in Cyc work in a different tutorial. This is intended to just briefly explain the abstract concepts first
before we get into the technical details.

2: In case you're not familiar with denotational functions, a function is something that takes things in and gives
things back (or returns things). Using mathematical syntax, here are some example functions:

Where f(x)=2x+1, f is function that takes in a number and gives back a different number.
Where g(age) = (age<21), g is a function that tells us whether or not age is less than 21. It takes in an age
and returns true or false.

If you have a philosophy background, you might think of functions as things that are used to construct terms that
denote something new. For example, if mother(x) denotes x's mother, mother is such a denotational function. (In
the Cyc KB, we have #$MotherFn, which is a #$Function-Denotational.)

In addition, you may think of truth functions as predicates. For example, age(x,21) states that x's age is 21.
Here, age is a predicate or truth function. (In Cyc, we have #$age, which is a #$Predicate.)

On reflection, you can see that these two ways of thinking of functions are analogous.

Sometimes functions are referred to as relations. In Cyc, #$Relation is a #$Collection encompassing predicates

and denotational functions. Among Cyclists (i.e. those who work with the Cyc KB), "function" is often used
conversationally to mean non-truth-functional #$Relations.

We call the things that a relation takes in arguments.

The number of arguments a relation takes is called the arity. For example, let's say f is a function
where f(x,y)=x+y. The arity of f is 2 since it takes in two arguments, which are x and y.

https://wiki.cyc.com/wiki/index.php/What_is_Cyc%3F 5/6
10/14/2019 What is Cyc? - CycWiki

3: In case you're wondering how the inference engine would answer some of these questions:

Who was the president of the United States in 1854?

The KB has knowledge that Franklin Pierce was president of the U.S. from 1853 to 1857. The
Inference Engine can conclude that 1854 is within that duration of time. Thus, the Inference Engine
knows that Franklin Pierce was the president of the United States in 1854.
Do seahorses live underwater?
It's not explicitly stated that seahorses live underwater in the KB. However, the KB has knowledge that
aquatic organisms live underwater. Since the KB has knowledge that seahorses are aquatic organisms,
the inference engine can conclude that seahorses live underwater.
Can plants eat fish?
There is no explicit knowledge that plants can or cannot eat fish in the KB. However, the KB contains
knowledge stating that the only things that can eat are animals. The KB also has knowledge that plants
are not animals. This lets the Inference Engine now create new knowledge that plants cannot eat. From
there, the Inference Engine can further conclude that plants cannot eat fish.

There are more interesting questions we can ask the Inference Engine, but those would be too complicated to get
into here.

Retrieved from "https://wiki.cyc.com/wiki/index.php?title=What_is_Cyc%3F&oldid=77095"

Categories: Documentation Training Modules External Approved for Website

This page was last edited on 11 October 2019, at 09:07.

https://wiki.cyc.com/wiki/index.php/What_is_Cyc%3F 6/6