Knowledge Representation

Knowledge Representation Issues

• It becomes clear that particular knowledge representation
models allow for more specific more powerful problem solving
mechanisms that operate on them.
• Examine specific techniques that can be used for representing &
manipulating knowledge within programs.
Representation & Mapping
• Facts :- truths in some relevant world
• These are the things we want to represent.
• Representations of facts in some chosen formalism.
• Things we are actually manipulating. Structuring these entities is
as two levels.
• The knowledge level, at which facts concluding each agents
behaviorFacts& current goals are
Internal described.
Representations

English understanding English generation

English Representations
Approaches to knowledge Representation.
• Representational adequacy the ability to represent all of the kinds of
knowledge that are needed in that domain.
• Inferential Adequacy: - the ability to manipulate the representation
structures in such a way as to derive new structures corresponding
to new knowledge inferred from old ones.
• Inferential Efficiency: - the ability to incorporate into the knowledge
structure additional information that can be used to focus the
attention of the inference mechanism in the most promising
directions.
• Acquisitioned Efficiency: - the ability to acquire new information
easily. The simplest case involves direct insertion by a person of new
knowledge into the database.
Simple relational DB Reg.no Dept CGP

2001 IT 7.9

3001 CSE 6.7

• It is the simplest way of storing facts which uses the relational

method, and each fact about a set of the object is set out
systematically in columns.
• This approach of knowledge representation is famous in database
systems where the relationship between different entities is
represented.
• This approach has little opportunity for inference.
 Inheritable Knowledge
• In the inheritable knowledge approach, all data must be stored into a
hierarchy of classes.
• All classes should be arranged in a generalized form or a hierarchal
manner.
• In this approach, we apply inheritance property.
• Elements inherit values from other members of a class.
• This approach contains inheritable knowledge which shows a relation
between instance and class, and it is called instance relation.
• Every individual frame can represent the collection of attributes and
its value.
• In this approach, objects and values are represented in Boxed nodes.
• We use Arrows which point from objects to their values.
 Inferential knowledge

•Inferential knowledge approach represents knowledge in the form of formal logics.

•This approach can be used to derive more facts.
•It guaranteed correctness.
•Example: Let's suppose there are two statements:
• Marcus is a man
• All men are mortal
Then it can represent as;

man(Marcus)
∀x = man (x) ----------> mortal (x)
Procedural knowledge:

• Procedural knowledge approach uses small programs and codes

which describes how to do specific things, and how to proceed.
• In this approach, one important rule is used which is If-Then rule.
• In this knowledge, we can use various coding languages such as LISP
language and Prolog language.
• We can easily represent heuristic or domain-specific knowledge using
this approach.
• But it is not necessary that we can represent all cases in this
approach.
Issues in Knowledge Representation

• Are any attribute of object so basic that they occur in every problem
domain
• Are there relationships between attributes of objects
• Is any good set of primitives into which knowledge can be broken
• How should set of objects be represented?
• Given large knowledge in database how relevant parts can be
accessed
Representation of facts in Logic
Form
Propositional
Logic
Propositional logic
• Logical constants: true, false
• Propositional symbols: P, Q, S, ... (atomic sentences)
• Wrapping parentheses: ( … )
• Sentences are combined by connectives:
 ...and [conjunction]
 ...or [disjunction]
...implies [implication / conditional]
..is equivalent [biconditional]
 ...not [negation]
• Literal: atomic sentence or negated atomic sentence
Examples of PL sentences
• P means “It is hot.”
• Q means “It is humid.”
• R means “It is raining.”
• (P  Q)  R
“If it is hot and humid, then it is raining”
•QP
“If it is humid, then it is hot”
• A better way:
Hot = “It is hot”
Humid = “It is humid”
Raining = “It is raining”
 Propositional logic (PL)
• A simple language useful for showing key ideas and definitions
• User defines a set of propositional symbols, like P and Q.
• User defines the semantics of each propositional symbol:
• P means “It is hot”
• Q means “It is humid”
• R means “It is raining”
• A sentence (well formed formula) is defined as follows:
• A symbol is a sentence
• If S is a sentence, then S is a sentence
• If S is a sentence, then (S) is a sentence
• If S and T are sentences, then (S  T), (S  T), (S  T), and (S ↔ T) are sentences
• A sentence results from a finite number of applications of the above rules
 Some terms

• The meaning or semantics of a sentence determines its interpretation.

• Given the truth values of all symbols in a sentence, it can be “evaluated”
to determine its truth value (True or False).
• A model for a KB is a “possible world” (assignment of truth values to
propositional symbols) in which each sentence in the KB is True.
More terms

• A valid sentence or tautology is a sentence that is True under all

interpretations, no matter what the world is actually like or how the
semantics are defined. Example: “It’s raining or it’s not raining.”
• An inconsistent sentence or contradiction is a sentence that is False
under all interpretations. The world is never like what it describes, as
in “It’s raining and it’s not raining.”
• P entails Q, written P |= Q, means that whenever P is True, so is Q. In
other words, all models of P are also models of Q.
Truth tables
Truth tables II
The five logical connectives:

A complex sentence:
Propositional logic is a weak
language
• Can’t directly talk about properties of individuals or relations
between individuals (e.g., “Bill is tall”)
• Generalizations, patterns, regularities can’t easily be represented
(e.g., “all triangles have 3 sides”)
• First-Order Logic (abbreviated FOL or FOPC) is expressive enough to
concisely represent this kind of information
FOL adds relations, variables, and quantifiers, e.g.,
• “Every elephant is gray”:  x (elephant(x) → gray(x))
• “There is a white alligator”:  x (alligator(X) ^ white(X))
Example

• Consider the problem of representing the following information:

• Every person is mortal.
• Confucius is a person.
• Confucius is mortal.
• How can these sentences be represented so that we can infer the
third sentence from the first two?
 Example II
• In PL we have to create propositional symbols to stand for all or part of
each sentence. For example, we might have:
P = “person”; Q = “mortal”; R = “Confucius”
• so the above 3 sentences are represented as:
P  Q; R  P; R  Q
• Although the third sentence is entailed by the first two, we needed an
explicit symbol, R, to represent an individual, Confucius, who is a member
of the classes “person” and “mortal”
• To represent other individuals we must introduce separate symbols for
each one, with some way to represent the fact that all individuals who are
“people” are also “mortal”
First-Order Logic
First-order logic

• First-order logic (FOL) models the world in terms of

• Objects, which are things with individual identities
• Properties of objects that distinguish them from other objects
• Relations that hold among sets of objects
• Functions, which are a subset of relations where there is only one “value”
for any given “input”
• Examples:
• Objects: Students, lectures, companies, cars ...
• Relations: Brother-of, bigger-than, outside, part-of, has-color, occurs-after,
owns, visits, precedes, ...
• Properties: blue, oval, even, large, ...
• Functions: father-of, best-friend, second-half, one-more-than ...
User provides

• Constant symbols, which represent individuals in the world

• Mary
•3
• Green
• Function symbols, which map individuals to individuals
• father-of(Mary) = John
• color-of(Sky) = Blue
• Predicate symbols, which map individuals to truth values
• greater(5,3)
• green(Grass)
• color(Grass, Green)
FOL Provides

• Variable symbols
• E.g., x, y, foo
• Connectives
• Same as in PL: not (), and (), or (), implies (), if and
only if (biconditional )
• Quantifiers
• Universal x or (Ax)
• Existential x or (Ex)
 Sentences are built from terms and
atoms
• A term (denoting a real-world individual) is a constant symbol, a variable
symbol, or an n-place function of n terms.
x and f(x1, ..., xn) are terms, where each xi is a term.
A term with no variables is a ground term
• An atomic sentence (which has value true or false) is an n-place predicate
of n terms
• A complex sentence is formed from atomic sentences connected by the
logical connectives:
P, PQ, PQ, PQ, PQ where P and Q are sentences
• A quantified sentence adds quantifiers  and 
• A well-formed formula (wff) is a sentence containing no “free” variables.
That is, all variables are “bound” by universal or existential quantifiers.
(x)P(x,y) has x bound as a universally quantified variable, but y is free.
Quantifiers
• Universal quantification
• (x)P(x) means that P holds for all values of x in the
domain associated with that variable
• E.g., (x) dolphin(x)  mammal(x)
• Existential quantification
• ( x)P(x) means that P holds for some value of x in the
domain associated with that variable
• E.g., ( x) mammal(x)  lays-eggs(x)
• Permits one to make a statement about some object
without naming it
 Quantifiers
• Universal quantifiers are often used with “implies” to form “rules”:
(x) student(x)  smart(x) means “All students are smart”
• Universal quantification is rarely used to make blanket statements about every
individual in the world:
(x)student(x)smart(x) means “Everyone in the world is a student and is smart”
• Existential quantifiers are usually used with “and” to specify a list of properties
about an individual:
(x) student(x)  smart(x) means “There is a student who is smart”
• A common mistake is to represent this English sentence as the FOL sentence:
(x) student(x)  smart(x)
• But what happens when there is a person who is not a student?
Quantifier Scope

• Switching the order of universal quantifiers does not change the

meaning:
• (x)(y)P(x,y) ↔ (y)(x) P(x,y)
• Similarly, you can switch the order of existential quantifiers:
• (x)(y)P(x,y) ↔ (y)(x) P(x,y)
• Switching the order of universals and existentials does change
meaning:
• Everyone likes someone: (x)(y) likes(x,y)
• Someone is liked by everyone: (y)(x) likes(x,y)
Connections between All and
Exists
We can relate sentences involving  and 
using De Morgan’s laws:
(x) P(x) ↔ (x) P(x)
(x) P ↔ (x) P(x)
(x) P(x) ↔  (x) P(x)
(x) P(x) ↔ (x) P(x)
Quantified inference rules

• Universal instantiation
• x P(x)  P(A)
• Universal generalization
• P(A)  P(B) …  x P(x)
• Existential instantiation
• x P(x) P(F)  skolem constant F
• Existential generalization
• P(A)  x P(x)
Universal instantiation
(a.k.a. universal elimination)
• If (x) P(x) is true, then P(C) is true, where C is any constant in the
domain of x
• Example:
(x) eats(Ziggy, x)  eats(Ziggy, IceCream)
• The variable symbol can be replaced by any ground term, i.e., any
constant symbol or function symbol applied to ground terms only
Existential instantiation
(a.k.a. existential elimination)
• From (x) P(x) infer P(c)
• Example:
• (x) eats(Ziggy, x)  eats(Ziggy, Stuff)
• Note that the variable is replaced by a brand-new constant not
occurring in this or any other sentence in the KB
• Also known as skolemization; constant is a skolem constant
• In other words, we don’t want to accidentally draw other inferences
about it by introducing the constant
• Convenient to use this to reason about the unknown object, rather
than constantly manipulating the existential quantifier
Existential generalization
(a.k.a. existential introduction)
• If P(c) is true, then (x) P(x) is inferred.
• Example
eats(Ziggy, IceCream)  (x) eats(Ziggy, x)
• All instances of the given constant symbol are replaced by the new
variable symbol
• Note that the variable symbol cannot already exist anywhere in the
expression
 Clause Form

• Convert the following to predicate form.

"All Romans who know Marcus either hate Caesar or think that anyone who hates
anyone is crazy."
(x : [Roman(x)  know(x, Marcus)]  [hate(x,Caesar) V ( y:  z: hate(y, z)  think crazy(x ,y))])
• This complex predicates be converted to clause form as follows.
1. Eliminate 

We will eliminate implication  by substituting it with its equivalent.

for e.g. a  b = ~a v b .
Here 'a' and 'b' can be any predicate logic expression.

For the above statement we get :

x ~[Roman(x) know(x,Marcus)] V [hate(x,Caesar) V( y ~( z
hate(y,z))V thinkcrazy(x,y))]
 Clausal Form
2. Reduce the scope of ~
To reduce the scope we can use 3 rules :
~(~p) = p
DeMorgans Laws : ~(aÚb) = ~aÙ~b ~ x P(x) =  x ~ P(x)
~(aÙb) = ~aÚ~b ~  x P(x) = x ~ P(x)
Applying this reduction on our example yields :
x :[~Roman(x)Ú~know(x,Marcus)]Ú[hate(x,Caesar)Ú  y z ~hate(y,z) Ú
thinkcrazy(x,y))]

3.Change variable names such that, each quantifier has a unique name.
We do this in preparation for the next step. As variables are just dummy names,
changing a variable name doesnot affect the truth value of the wff.
Suppose we have
x P(x) Ú x Q(x) will be converted to x P(x) Ú y Q(y)

4.Move all the quantifiers to the left of the formula without changing their relative
order.
As we already have unique names for each quantifier in the previous step, this will not
cause a problem.
Performing this on our example we get :
 x  y  z [ ~Roman(x) Ú ~know(x,Marcus)] Ú [ hate(x,Caesar) Ú(~hate(y,z) Ú
thinkcrazy(x,y))]
5. Eliminate existential quantifiers
We can eliminate the existential quantifier by simply replacing the variable with a reference to a
function that produces the desired value.
for eg. :  y President(y) can be transformed into the formula President(S1)
If the existential quantifiers occur within the scope of a universal quantifier, then the value that
satisfies the predicate may depend on the values of the universal quantified variables.
For eg..  x  z fatherof(z,x) will be converted to  x fatherof( S2(x),x )

6. Drop the Prefix

As we have eliminated all existential quantifiers, all the variables present in the wff are universally
quantified, hence for simplicity we can just drop the prefix, and assume that every variable is
universally quantified.
We have form our example :
[ ~Roman(x) Ú ~know(x,Marcus)] Ú [ hate(x,Caesar) Ú(~hate(y,z) Ú thinkcrazy(x,y))]

7. Convert into conjunction of disjuncts

As we have no ANDs we will just have to use the associative property to get rid of the brackets.
Incase of ANDs we will need to use the distributive property.
(a  b) Ú ( c  d) = (a Ú ( c  d) )  (b Ú ( c  d) ) = (aÚ c )(aÚ d) (bÚ c )(bÚ d)
8. Separate each conjunct into a new clause.
• (aÚ c )
• (aÚ d)
• (bÚ c )
• (bÚ d)
Need for variable standardization
1. Father(x,y)-> 7woman(x)
1 2
2. Mother(x,y)-> woman(x)
3. Mother(chris,Mary)
4. Father(chris,bill)
7Father(x,y) U 7Mother(x,y) 3
Convert to clause form
5. 7Father(x,y) U 7woman(x) chris/x
mary/y
6. 7Mother(x,y)U woman(x)
7. Mother(chris,Mary) 7Father(chris,bill)
8. Father(chris,bill)
Need for variable standardization
1. Father(x,y)-> 7woman(x)
1 2
2. Mother(x,y)-> woman(x) x2/x1
3. Mother(chris,Mary)
4. Father(chris,bill)
Convert to clause form 7Father(x2,y1) U 7Mother(x2,y2) 3
5. 7Father(x1,y1) U 7woman(x1)
6. 7Mother(x2,y2)U woman(x2) chris/x2
7. Mother(chris,Mary)
8. Father(chris,bill) mary/y2

7Father(chris,y1) 4

bill/y1

2 nil
Resolution in Propositional Logic
Steps for Resolution:

• Conversion of facts into first-order logic.

• Convert FOL statements into CNF
• Negate the statement which needs to prove (proof by contradiction)
• Draw resolution graph (unification).
• To better understand all the above steps, we will take an example in
which we will apply resolution.
 Back to Marcus
(1) man(Marcus)
(2) Pompeian(Marcus)
(3) x Pompeian(x)  Roman(x)
(4) ruler(Caesar)
(5) x Roman(x)  loyalto(x, Caesar)  hate(x, Caesar)
(6) x y loyalto(x, y)
(7) x y man(x)  ruler(y)  tryassassinate(x, y)  loyalto(x, y)
(8) tryassassinate(Marcus, Caesar)

(1) man(Marcus)
(2) Pompeian(Marcus)
(3) Pompeian(x1)  Roman(x1)
(4) ruler(Caesar)
(5) Roman(x2)  loyalto(x2, Caesar)  hate(x2, Caesar)
(6) loyalto(x3, S1(x3))
(7) man(x4)  ruler(y1)  tryassassinate(x4, y1)  loyalto(x4, y1)
(8) tryassassinate(Marcus, Caesar)
 Proving Marcus Not Loyal to Caesar
loyalto(M, C)  man(x4)  ruler(y1)  tryassassinate(x4, y1)  loyalto(x4, y1)
(M/x4)(C/y1)

 man(M)  ruler(C)  tryassassinate(M,C) man(M)

ruler(C)  tryassassinate(M,C) ruler(C)

tryassassinate(M,C) tryassassinate(M,C)

nil
 Back to Marcus
• Consider the wffs we created above:
1. man(Marcus)
2. Pompeian(Marcus)
3. born(Marcus,40)
4. ∀x: man(x) → mortal(x)
5. erupted(volcano,79) /\ ∀x: Pompeian(x) → died(x,79)
6. ∀x ∀t1 ∀t2: mortal(x) /\ born(x,t1) /\ gt(t2-t1,150) → dead(x,t2)
7. now=2023
8. ∀x ∀t: [alive(x,t) → ~dead(x,t)] /\ [~dead(x,t) →alive(x,t)]
• Suppose we now want to use resolution to prove that “Marcus is not alive now”. We firstly have to
convert these statements to clause form:
1. man(Marcus)
2. Pompeian(Marcus)
3. born(Marcus,40)
4. ~man(x) \/ mortal(x)
5. erupted(volcano,79)
6. ~Pompeian(x1) \/ died(x1,79)
7. ~mortal(x2) \/ ~born(x2,t1) \/ ~gt(t2-t1,150) \/ dead(x2,t2)
8. now=1991
9. ~alive(x3,t) \/ dead(x3,t)
10. ~ dead(x4,t3) \/ alive(x4,t3) 7
• We want to prove ~alive(Marcus,2023).
• We negate this and convert it clause form: alive(Marcus, now) and find a contradication:
alive(Marcus,2023) (10)
↓ Marcus/ x4, 2023/t3

~ dead(Marcus,2023) (7)
↓ Marcus/ x2, 2023/t2

~mortal(Marcus) \/ ~born(Marcus,t1) \/ ~gt(2023-t1,150) (3)

↓ (40/t1)
~mortal(Marcus) \/ ~gt(2023-40,150) (4)

Marcus/ x
~man(Marcus) \/ ~gt(2023-40,150) (1)

~gt(2023-40,150)

Ø
Example:
1.John likes all kind of food.
2.Apple and vegetable are food
3.Anything anyone eats and not killed is food.
4.Anil eats peanuts and still alive
5.Harry eats everything that Anil eats.
Prove by resolution that:
6.John likes peanuts.

Step-1: Conversion of Facts into FOL

In the first step we will convert all the given statements into its first
order logic.
Step-2: Conversion of FOL into CNF
• In First order logic resolution, it is required to convert the FOL into
CNF as CNF form makes easier for resolution proofs.

•Eliminate all implication (→) and rewrite

• ∀x ¬ food(x) V likes(John, x)
• food(Apple) Λ food(vegetables)
• ∀x ∀y ¬ [eats(x, y) Λ ¬ killed(x)] V food(y)
• eats (Anil, Peanuts) Λ alive(Anil)
• ∀x ¬ eats(Anil, x) V eats(Harry, x)
• ∀x¬ [¬ killed(x) ] V alive(x)
• ∀x ¬ alive(x) V ¬ killed(x)
• likes(John, Peanuts).
• Move negation (¬)inwards and rewrite
• ∀x ¬ food(x) V likes(John, x)
• food(Apple) Λ food(vegetables)
• ∀x ∀y ¬ eats(x, y) V killed(x) V food(y)
• eats (Anil, Peanuts) Λ alive(Anil)
• ∀x ¬ eats(Anil, x) V eats(Harry, x)
• ∀x ¬killed(x) ] V alive(x)
• ∀x ¬ alive(x) V ¬ killed(x)
• likes(John, Peanuts).
Rename variables or standardize variables
• ∀x ¬ food(x) V likes(John, x)
• food(Apple) Λ food(vegetables)
• ∀y ∀z ¬ eats(y, z) V killed(y) V food(z)
• eats (Anil, Peanuts) Λ alive(Anil)
• ∀w¬ eats(Anil, w) V eats(Harry, w)
• ∀g ¬killed(g) ] V alive(g)
• ∀k ¬ alive(k) V ¬ killed(k)
• likes(John, Peanuts).
• Eliminate existential instantiation quantifier by elimination.
In this step, we will eliminate existential quantifier ∃, and this process is
known as Skolemization. But in this example problem since there is no
existential quantifier so all the statements will remain same in this step.
• Drop Universal quantifiers.
In this step we will drop all universal quantifier since all the statements
are not implicitly quantified so we don't need it.
• ¬ food(x) V likes(John, x)
• food(Apple)
• food(vegetables)
• ¬ eats(y, z) V killed(y) V food(z)
• eats (Anil, Peanuts)
• alive(Anil)
• ¬ eats(Anil, w) V eats(Harry, w)
• killed(g) V alive(g)
• ¬ alive(k) V ¬ killed(k)
• likes(John, Peanuts).
• Distribute conjunction ∧ over disjunction ¬.
This step will not make any change in this problem.
Step-3: Negate the statement to be proved
• In this statement, we will apply negation to the conclusion
statements, which will be written as ¬likes(John, Peanuts)
• Step-4: Draw Resolution graph:
Weak Slot Filler Structure

• Semantic Nets
• Frame
Weak slot filler structure
 Partitioned Semantic Nets

a) The dog bit the mail carrier.

b) Every dog has bitten a mail carrier.
c) Every dog in town has bitten the constable.
d) Every dog has bitten every mail carrier.
213
Frames
A Simplified Frame System

214
A Simplified Frame System (Cont’d)

215
A Simplified Frame System (Cont’d)

216
Representing the Class of All
Teams as a Metaclass

217
Representing the Class of All
Teams as a Metaclass (Cont’d)

218
Classes and Metaclasses

219
Representing Relationships among Classes

220
Representing Relationships
among Classes (Cont’d)

221
 Slots as Full – Fledged Objects

We want to be able to represent and use the following

properties of slots (attributes or relations) :

The classes to which the attribute can be attached.

Constraints to either the type or the value of the attribute.

A value that all instances of a class must have by the

definition of the class.

A default value for the attribute.

Rules for inheriting values for the attribute.

Rules for computing a value separately from inheritance.

An inverse attribute.

Whether the slot is single-valued or multivalued.

222
Representing Slots as Frames, I

223
Representing Slots as Frames, II

224
Representing Slots as Frames, III

225
Representing Slots as Frames, IV

226
Associating Defaults with Slots

227
A Shorthand Notation for
slot-Range Specification

228
 Representing Slot - Values

As simple frames :

Using Lambda Notation :

229
Tangled Hierarchies

230
More Tangled Hierarchies

231
 Defining Property Inheritance
Inferential Distance :

Class1 is closer to Class2 than to Class3, if and only if Class1

has an inference path through Class2 to Class3 (in other
words, Class2 is between Class1 and Class3).

We can now define the result of inheritance as follows: The set of

competing values for a slot S in a frame F contains all those
values that

• Can be derived from some frame X that is above F in the

isa hierarchy

• Are not contradicted by some frame Y that has a

shorter inferential distance to F than X does

232
 Algorithm : Property Inheritance
To retrieve a value V for slot S of an instance F do:

1. Set CANDIDATES to empty.

2. Do breadth-first or depth-first search up the isa hierarchy from F,

following all instance and isa links. At each step, see if a value for S or
one f its generalizations is stored.

(a) If a value is found, add it to CANDIDATES and terminate that branch of the
search.
(b) If no value is found but there are instance or isa links upward, follow them.
(c) Otherwise, terminate the branch.

3. For each element C of CANDIDATES do:

(a) See if there is any other element of CANDIDATES that was derived from a
class closer to F than
the class from which C came.
(b) If there is, then, remove C from CANDIDATES.

4. Check the cardinality of CANDIDATES:

(a) If it is 0, then report that no value was found.

(b) If it is 1, then return the single element of CANDIDATES as V.
(c) If it is greater than 1, report a contradiction.
233
Strong Slot Filler Structure
• Conceptual Dependency
• Scripts
• CYC
 DESCRIPTION ACTION EXAMPLE
Transfer of abstract relationship ATRANS give
Transfer of the physical location of the object PTRANS go
Application of physical force to an object PROPEL push
Grasping of an object by an actor GRASP clutch
Movement of a body part by its owner MOVE Kick
Ingestion of an object by an animal INGEST Eat
Expulsion of something from body EXPEL Cry
Transfer of mental information MTRANS Tell
Building new information from old MBUILD Decide
Production of sound SPEAK Say
Focusing of sense organ to a stimuli ATTEND Listen
• The use of tense and mood in describing events is extremely important and
schank introduced the following modifiers:
• p -- past
• f – future
• t– transition
• ts -- start transition –
• tf- finished transition
• k -- continuing
• ? -- interrogative
• / -- negative
• delta -- timeless
• c – conditional
the absence of any modifier implies the present tense.
CYC

What is CYC?
• An ambitious attempt to form a very large knowledge base aimed at
capturing common-sense reasoning.
• Initial goals to capture knowledge from a hundred randomly selected articles
in the Encyclopedia Britannica.
• Also, Both Implicit and Explicit knowledge encoded.
• Moreover, Emphasis on study of underlying information (assumed by the
authors but not needed to tell to the readers. )
• Example: Suppose we read that Wellington learned of Napoleon’s
death . Then we (humans) can conclude Napoleon never new that
Wellington had died.
How do we do this?
 So, We require special implicit knowledge or common-sense
such as:
• We only die once.
• You stay dead.
• Moreover, You cannot learn anything when dead.
• Time cannot go backward.
Why build large knowledge bases:

1. Brittleness
• Specialised knowledge bases are brittle.
• Hard to encode new situations and nongraceful degradation in
performance.
• Commonsense based knowledge bases should have a firmer
foundation.
2. Form and Content
• Moreover, Knowledge representation may not be suitable for AI.
• Commonsense strategies could point out where difficulties in content
may affect the form.
3. Shared Knowledge
• Also, Should allow greater communication among systems with
common bases and assumptions.
How is CYC coded?

• By hand.
• Special CYCL language:
• LISP-like.
• Frame-based
• Multiple inheritance
• Slots are fully fledged objects.
• Generalized inheritance — any link not just isa and instance.
 CYCL
• Language to represent CYC
• Frame based system
• Eg. Mary likes people who program solely in Lisp
CYCL
Mary:
likes: ?
Constraints : (Lisp Constraint)
Lisp Constraint:
slot constrained: (likes)
slot value subsumes : ( The set of X(person All Instance) AND (Programs in X Lisp) AND
(NOT (There exists Y (Language All Instance)) AND ( NOT EQUAL Y
Lisp))
( Programs In X)))
Bob: Programs In(Lisp)
John : Programs In (Lisp. C)
THANK YOU