Knowledge Representation

Techniques in AI

Module 3
Knowledge Representation
• What is Knowledge Representation (KR)?
- A method to structure and store knowledge
- Enables machines to reason and act
• AI systems need to understand, process, and make
decisions using knowledge about the world.
• Knowledge Representation (KR) allows encoding this
knowledge in a structured format that machines can
interpret.
• It's crucial for tasks like natural language processing,
planning, problem-solving, and reasoning.

Objectives of KR:
- Represent real-world knowledge
- Enable logical reasoning
- Facilitate understanding and learning
Knowledge Representation Types in AI
• Logical Representation
– Propositional Logic
– Predicate Logic
• Semantic Networks
– Graph-based structure (nodes and edges)
• Frames
– Slot-filler structures similar to objects
• Procedural Representation
– Rules and procedures (e.g., IF-THEN)
• Production Rules
– Condition-action rules used in expert systems
• Probabilistic Representation
– Bayesian Networks
– Probabilistic graphical models
• Scripts and Schemas
– Represent stereotypical sequences of events
1)Logical Representation
Propositional Logic
• Propositional Logic (also called Boolean Logic)
is a type of formal logic that deals with
propositions — statements that can either be
true or false, but not both.
• It is the simplest form of logic used in AI for
knowledge representation and reasoning.
Component Description Example
A statement that is either
Proposition It is raining.
true or false
Common Logical Connectives

Example
Let:
•P: "It is raining"
•Q: "The ground is wet"
Then:
•P → Q: If it is raining, then the ground is wet.
•¬P ∨ Q: Either it is not raining, or the ground is wet.
Why Use Propositional Logic in AI?
• To model facts and rules about the world.
• To perform inference (e.g., Modus Ponens).
• Foundation for more complex systems like Predicate Logic.

Limitations
• Cannot express relationships within propositions (e.g., "All
humans are mortal").
• Doesn't deal with objects, properties, or quantifiers.
• Not ideal for large and complex knowledge bases.

Applications in AI
• Rule-based systems
• Decision-making systems
• Logic programming (e.g., Prolog)
• Digital circuit design
• Game AI and expert systems
2) Predicate Logic is a formal language that represents
facts and rules about the world.
• Predicate Logic is an extension of Propositional Logic that
allows reasoning about objects, their properties, and their
relationships.
Example: Loves(John, IceCream) means John loves ice cream.

•Quantifiers:
– Universal (∀): Applies to all members of a group.
e.g., ∀x (Student(x) → Studies(x)) → All students study.
– Existential (∃): Applies to at least one member.
e.g., ∃x (Teacher(x) ∧ Teaches(x, Math)) → Some teacher
teaches math
Basic Elements of Predicate Logic

Examples of Predicate Logic Statements

"All humans are mortal"
∀x (Human(x) → Mortal(x))
"Some students love AI"
∃x (Student(x) ∧ Loves(x, AI))
"John is a student who likes AI"
Student(John) ∧ Likes(John, AI)
 Predicate Logic (First-Order Logic)
• Formal logic system to represent:
- Objects
- Properties
- Relationships

• Components:
- Constants (e.g., John)
- Predicates (e.g., Likes(John, IceCream))
- Variables (e.g., x, y)
- Quantifiers: ∀ (forall), ∃ (exists)
 Predicate Logic Example & Pros/Cons
• Used in expert systems and theorem provers.
• Can chain multiple logical statements to draw conclusions.
• Example reasoning:
– ∀x (Cat(x) → Animal(x))
Cat(Tom)
⇒ Animal(Tom)
• But it's abstract and not very human-readable.
Example:
"Everyone loves ice cream"
∀x Loves(x, IceCream)
• Advantages:
- Precise and supports inference
• Limitations:
- Not intuitive
- Hard to scale
Why is Predicate Logic Useful in AI?
• Describes complex situations and facts about the
world
• Supports reasoning and inference
• Foundation for expert systems, knowledge bases,
natural language understanding, and planning

Inference in Predicate Logic

• Just like propositional logic, predicate logic
supports inference using rules like:
• Unification (matching variables with values)
• Resolution (automated deduction method)
Modus Ponens
• Modus Ponens (also known as Law of Detachment) is a
fundamental rule of inference used in both propositional
logic and predicate logic.
P->Q, P is T then Q is T
• If P implies Q and P is true, then Q is true.
Modus Ponens works in the same way as in propositional
logic, but involves predicates and quantifiers.
• Modus Ponens Format:
If we have:
1. ∀x (P(x) → Q(x)) (For all x, if P(x), then Q(x))
2. P(a)
(Predicate P holds for a specific element a)
∴ Q(a)
(Therefore, Q holds for a)
• This is a valid application of modus ponens in predicate
logic.
Example:
Let:
• P(x): "x is a bird"
• Q(x): "x can fly"
Then:
1. ∀x (P(x) → Q(x)) (All birds can fly)
2. P(Sparrow) (Sparrow is a
bird)
∴ Q(Sparrow) (Sparrow can fly)

• The universal quantifier ∀x must be instantiated with a

specific constant a (called universal instantiation)
before applying modus ponens.
• Modus ponens is only valid when the implication and
the antecedent are both logically true.
Example Use Case in AI
• Imagine an AI diagnosing patients:
Facts:
• ∀x (HasFever(x) ∧ HasCough(x) → HasFlu(x))
• HasFever(Alice)
• HasCough(Alice)
From this, the AI can infer:
• HasFlu(Alice)

Limitations of Predicate Logic

• Can be computationally expensive
• Hard to scale to massive knowledge bases
• May not handle uncertainty (which probabilistic
models like Bayesian Networks can)
Example with Predicates
• Statement : All humans are mortal.
• Predicate Logic:
∀x (Human(x) → Mortal(x))
• Meaning: For all x, if x is a human, then x is mortal.

Example with Multiple Predicates

• Statement:
Every student who studies hard passes the exam.
• Predicate Logic:
∀x (Student(x) ∧ StudiesHard(x) → Passes(x, Exam))
Example : Students and Assignments
• Student(x): x is a student
• Submits(x, y): x submits assignment y
• Passes(x): x passes the course
• Premises:
1. ∀x (Student(x) ∧ Submits(x, Assignment) → Passes(x))
2. Student(Alice)
3. Submits(Alice, Assignment)
Conclusion:
• ⇒ Passes(Alice)
Explanation: Since Alice is a student and submitted
the assignment, she passes the course.
Example :
Coach(x): x is a Coach
• Coaches(x, y): x Coaches y
• Plays(y): y plays
• Premises:
1. ∀x∀y (Coach(x) ∧ Coaches(x, y) → Plays(y))
2. Coach(Dravid)
3. Coaches(Dravid, Virat)
Conclusion:
• ⇒ Plays(Virat)
Propositional Logic v/s Predicate Logic

Feature Propositional Logic Predicate Logic

Expressiveness Low High
Handles Variables No Yes
Describes
No Yes
Relations
Inference Support Basic Advanced
Semantic Networks
• A semantic network is a knowledge
representation technique used in artificial
intelligence (AI) to model relationships between
concepts.
• It organizes information in a graph-like structure
where nodes represent objects, concepts, or
entities, and edges represent the relationships or
associations between them.
• Semantic networks are widely used in AI for tasks
such as natural language processing (NLP),
knowledge representation, reasoning, and
information retrieval.
Key Components of Semantic Networks
• Nodes :
– Represent entities, concepts, or objects.
Examples: "Dog," "Animal," "John," "Red."
• Edges (or Links) :
– Represent relationships between nodes.
Examples: "is-a" (e.g., "Dog is-a Animal"), "has-a" (e.g., "Car has-a
Wheel"), "part-of" (e.g., "Wheel is-part-of Car").
• Labels :
– Both nodes and edges can have labels to provide additional
context or meaning.
Example: A node labeled "Dog" might have an edge labeled "is-a"
pointing to another node labeled "Animal."
• Hierarchical Structure :
– Semantic networks often exhibit a hierarchical organization,
where more general concepts are at the top and more specific
ones are at the bottom.
Example: "Animal" → "Mammal" → "Dog."
Types of Relationships in Semantic Networks
• Taxonomic Relationships :
– These describe hierarchical or class-subclass relationships.
Example: "Dog is-a Mammal," "Mammal is-a Animal."
• Attribute Relationships :
– These describe properties or characteristics of an entity.
Example: "Dog has-color Brown," "John has-age 30."
• Part-Whole Relationships :
– These describe composition or containment.
Example: "Car has-part Engine," "Body has-part Arm."
• Causal Relationships :
– These describe cause-and-effect connections.
Example: "Rain causes Wet Ground."
• Temporal Relationships :
– These describe time-based dependencies.
Example: "Morning precedes Afternoon."
Why Use Semantic Networks in AI?

Semantic networks aim to mimic how humans

think and associate concepts. They are used to:
• Represent hierarchical knowledge (eg: “A robin is a bird”)
• Enable inference and reasoning (eg: If a bird can fly, then a
robin can fly”)
• Power natural language understanding and dialogue
systems.
• Model conceptual relationship for ontologies and knowledge
graphs.
Advantages of Semantic Networks
• Intuitive Representation :
– The graphical nature of semantic networks makes them easy to
understand and visualize.
• Flexibility :
– They can represent a wide variety of relationships and adapt to
different domains.
• Inheritance :
– Properties of higher-level nodes can be inherited by lower-level nodes,
reducing redundancy.
Example: If "Animal" has the property "can-move," then "Dog" inherits
this property.
• Scalability :
– Semantic networks can grow to include large amounts of information
while maintaining clarity.
• Support for Reasoning :
– They enable logical inference and querying based on relationships.
Example: If "Dog is-a Mammal" and "Mammal is-a Animal," then "Dog is-
a Animal."
Limitations of Semantic Networks
• Ambiguity :
– The same relationship label might mean different things in
different contexts.
Example: "is-a" could mean "is an instance of" or "is a type of."
• Lack of Formal Semantics :
– Unlike formal logic systems, semantic networks do not always
have precise rules for interpretation.
• Scalability Challenges :
– As the network grows, it can become complex and difficult to
manage.
• Inefficiency in Querying :
– Searching for specific information in large semantic networks
can be computationally expensive.
• Limited Expressiveness :
– Some types of relationships or constraints may be difficult to
represent.
Applications of Semantic Networks
• Natural Language Processing (NLP) :
– Semantic networks are used to model word meanings and relationships in text.
Example: WordNet, a lexical database, uses semantic networks to organize words into
synonym sets and define relationships like hypernyms and hyponyms.
• Knowledge Bases :
– Semantic networks form the backbone of many knowledge bases, such as ontologies
used in expert systems.
Example: Cyc, a large AI project, uses semantic networks to encode common-sense
knowledge.
• Information Retrieval :
– They help in understanding user queries and retrieving relevant information by mapping
query terms to related concepts.
• Expert Systems :
– Semantic networks are used to encode domain-specific knowledge and perform
reasoning tasks.
• Recommendation Systems :
– By modeling user preferences and item attributes, semantic networks can suggest
relevant recommendations.

• Question Answering Systems

• Chat bots and Virtual Assistants.
• Cognitive Modeling
 Example of a Semantic Network
Let’s consider a simple semantic network representing some facts about animals:
• Animal
• |
• |-- Mammal
• | |
• | |-- Dog
• | | |
• | | |-- Labrador
• | |
• | |-- Cat
• |
• |-- Bird
• |
• |-- Sparrow

Nodes: "Animal," "Mammal," "Dog," "Labrador," "Cat," "Bird," "Sparrow."

Edges: "is-a" relationships between nodes.
 Frames
• Frames are a knowledge representation
technique used in artificial intelligence (AI) to
model complex, structured information about
objects, concepts, or situations.
• They extend the idea of semantic networks by
organizing information into reusable
templates that include attributes (or slots) and
their corresponding values.
• Frames provide a way to represent both static
knowledge (facts about entities) and dynamic
knowledge (how entities behave or interact).
Key Components of Frames

• Frame Name :
– Each frame represents a specific concept or object and is
given a unique name.
Example: "Dog," "Car," "Person."
• Slots :
– Slots represent attributes or properties of the concept or
object.
Example: For a "Dog" frame, slots might include "Color,"
"Breed," "Age," and "Owner."
• Facets (or Fillers) :
– Facets define the characteristics of a slot, such as its value,
default value, range of possible values, or constraints.
Example: For the "Age" slot in a "Dog" frame, the facet might
specify that the value must be a positive integer.
• Values :
– Values are the data assigned to slots, representing specific
instances of the concept.
Example: For a "Dog" frame, the "Color" slot might have the
value "Brown."
• Inheritance :
– Frames can inherit attributes from more general frames
(parent frames), reducing redundancy.
Example: A "Labrador" frame might inherit attributes like
"CanBark" and "IsMammal" from a more general "Dog"
frame.
• Procedural Attachments :
– Frames can include procedures or functions that define
how to compute or manipulate certain attributes.
Example: A "Temperature" slot might include a procedure to
convert Celsius to Fahrenheit.
Structure of a Frame
• Here’s an example of a simple frame for a "Dog":

Frame: Dog
--------------------------
| Slot | Value |
--------------------------
| Type | Animal |
| Species | Canine |
| Legs |4 |
| Color | Brown |
| Owner | John |
| CanBark | True |
| Default Age | 5 years |
--------------------------------
• Type : Specifies that "Dog" is a type of
"Animal."
• Species : Describes the biological classification
of the dog.
• Legs : Specifies the number of legs a dog has.
• Color : Indicates the dog's color.
• Owner : Specifies who owns the dog.
• CanBark : Indicates whether the dog can bark.
• Default Age : Provides a default value for the
dog's age if no specific age is given.
Types of Slots in Frames
• Attribute Slots :
– Represent properties of the object.
Example: "Color," "Weight," "Height."
• Relationship Slots :
– Represent relationships between objects.
Example: "Owner" (relationship between a dog and a person).
• Procedural Slots :
– Contain procedures or functions to compute values dynamically.
Example: A "Temperature" slot might include a function to convert units.
• Default Slots :
– Provide default values for attributes when no specific value is given.
Example: A "Car" frame might have a default "Color" of "Silver."
• Constraint Slots :
– Specify restrictions on the values a slot can take.
Example: A "Temperature" slot might only allow values between -273°C
and 1000°C.
Advantages of Frames
• Structured Representation :
– Frames organize information in a clear, hierarchical manner, making it
easier to understand and manage.
• Inheritance :
– Attributes from parent frames can be inherited by child frames,
reducing redundancy and promoting modularity.
Example: A "Labrador" frame inherits attributes from a "Dog" frame.
• Default Values :
– Default values allow frames to handle incomplete information
gracefully.
• Procedural Attachments :
– Procedures can be attached to slots to perform computations or
actions dynamically.
• Flexibility :
– Frames can represent a wide variety of knowledge types, including
facts, rules, and behaviors.
• Reusability :
– Frames can be reused across different domains and applications.
Limitations of Frames
• Complexity :
– As the number of frames and slots grows, the system can
become difficult to manage.
• Ambiguity :
– Without proper constraints, frames can lead to ambiguity
in interpretation.
• Scalability :
– Large-scale systems with many interconnected frames can
become computationally expensive.
• Lack of Formal Semantics :
– Unlike formal logic systems, frames do not always have
precise rules for interpretation.
• Limited Expressiveness :
– Some types of relationships or constraints may be difficult
to represent.
Applications of Frames
• Expert Systems :
– Frames are widely used in expert systems to represent domain-specific
knowledge.
Example: MYCIN, an early expert system for diagnosing bacterial infections, used
frames to represent medical knowledge.
• Natural Language Processing (NLP) :
– Frames help in understanding and generating natural language by modeling
the structure of sentences and concepts.
Example: FrameNet, a lexical database, uses frames to represent semantic roles
in sentences.
• Object-Oriented Programming :
– The concept of frames influenced object-oriented programming (OOP), where
objects have attributes (slots) and methods (procedures).
• Robotics :
– Frames are used to model the environment and objects in robotics
applications.
Example: A robot might use frames to represent objects it interacts with, such as
"Table" or "Chair."
Example of a Frame System Frame: SportsCar (inherits from Car)
• --------------------------
Frame: Vehicle • | Slot | Value |
• --------------------------
• | Slot | Value |
• --------------------------
• -------------------------- • | Inherits From| Car |
• | Type | Object | • | Top Speed | 200 mph |
• | Wheels |4 | • | Color | Red |
• | Engine | Yes |
• --------------------------
• | Default Color| Black |
• --------------------------
• The "SportsCar" frame inherits
Frame: Car (inherits from Vehicle) attributes like "Wheels" and
• --------------------------
• | Slot | Value |
"Engine" from the "Vehicle"
• -------------------------- frame, and "Doors" and
• | Inherits From| Vehicle | "Trunk" from the "Car" frame.
• | Doors |4 | It overrides the "Color" slot
• | Trunk | Yes | with a specific value ("Red")
• --------------------------
and adds a new slot, "Top
Speed."
Frames vs Semantic Networks
While semantic networks focus on representing relationships
between concepts using nodes and edges, frames provide a
more structured and detailed representation of knowledge.
Here’s a comparison:

Feature Semantic Networks Frames

Graph-like structure (nodes Structured templates with
Representation
and edges) slots/values

Relationships between Detailed attributes and

Focus
concepts inheritance

Inheritance Limited Strong support

Default Values Not supported Supported

Procedural Attachments Not supported Supported

Inference Methods in Artificial
Intelligence (AI)
Forward Chaining and Backward
Chaining
 What is Inference?
• Inference in AI is the process of deriving
logical conclusions from known data or rules.
• Used in knowledge-based and expert systems
to infer new knowledge.
Types of Inference Methods
1. Forward Chaining (Data-driven)
2. Backward Chaining (Goal-driven)
Forward Chaining
Starts with known facts and applies rules to infer new facts.
Working:
- Start with facts
- Apply rules
- Infer new facts
- Repeat until goal is reached

Example:
• It is raining → Ground is wet → Car may slip → Accident
may occur

Applications:
- Monitoring systems
- Real-time decision making
Forward Chaining - Pros & Cons
Advantages:
- Efficient with many facts
- Good for real-time systems

Disadvantages:
- Can produce irrelevant facts
- Inefficient for specific goals
Backward Chaining
Starts with a goal and works backward to check if data
supports it.
Working:
- Start with goal
- Find rules to support it
- Check or prove each condition recursively
Example:
• Accident? ← Car slips? ← Ground is wet? ← It is raining

Applications:
- Diagnostic systems
- Expert systems (e.g., medical)
 Backward Chaining - Pros & Cons
Advantages:
- Efficient for specific goals
- Avoids unnecessary rules

Disadvantages:
- Can struggle with sub-goals
- May loop without controls
 Comparison: Forward vs Backward
Chaining
Forward Chaining:
- Data to goal
- Data-driven
- Good for monitoring

Backward Chaining:
- Goal to data
- Goal-driven
- Good for diagnosis
 Real-World Examples
Forward Chaining:
- Home automation
- Weather prediction
- Fraud detection

Backward Chaining:
- Medical diagnosis
- Legal reasoning
- Tech support
Resolution in Propositional Logic
What is Resolution?
• Resolution is a rule of inference used for automated
theorem proving in AI.
• It helps derive new knowledge or contradictions from a
set of known facts and rules.

Purpose of Inference Rules

• Inference rules help derive new facts from known
propositions.
Applications:
- Logical reasoning
- Expert systems
- Forward and backward chaining
- Theorem proving
 1. Modus Ponens
• Form:
• P→Q
• P
• ∴Q

• Example:
• If it rains, the ground is wet.
• It rains.
• ∴ The ground is wet.
 2. Modus Tollens
• Form:
• P→Q
• ¬Q
• ∴ ¬P

• Example:
• If the alarm rings, there is a fire.
• There is no fire.
• ∴ Alarm does not ring.
 3. Disjunctive Syllogism
• Form:
• P∨Q
• ¬P
• ∴Q

• Example:
• It's either Monday or Tuesday.
• It's not Monday.
• ∴ It is Tuesday.
 4. Hypothetical Syllogism
• Form:
• P→Q
• Q→R
• ∴P→R

• Example:
• If I study, I pass.
• If I pass, I graduate.
• ∴ If I study, I graduate.
 5. Addition
If a statement is true, then the disjunction (“or”) of
that statement with any other statement is also
true.
• If P is T
• ∴ P ∨ Q is T

• Example:
• It’s sunny.
• ∴ It’s sunny or raining.
 6. Simplification
If a conjunction (“and”) is True, then each of its
conjuncts is also True.
• P ∧ Q is T
• ∴ P is T
• P ∧ Q is T
• ∴ Q is T

• Example:
• It’s warm and sunny.
• ∴ It’s warm.
 7. Conjunction
If two statement are True, Then their conjunction
(“and”) is also True.
• P
• Q
• ∴P∧Q

• Example:
• It’s hot.
• It’s humid.
• ∴ It’s hot and humid.
 8. Resolution Rule
• Form:
• P∨Q
• ¬Q ∨ R
• ∴P∨R

• Example:
• John is smart or he studies.
• He doesn’t study or he passes.
• ∴ John is smart or he passes.
Applications of Inference in AI
• Medical Research and Diagnoses: AI aids in
medical research and diagnoses by analyzing
patient data to provide optimized treatment
plans and prognoses.
• Recommendation Systems and Personalized
Advertisements: E-commerce platforms utilize
inference to suggest products based on user
preferences, enhancing user experience and
engagement.
• Self-Driving Vehicles: Inference enables self-
driving cars to interpret sensor data and navigate
through dynamic environments safely and
efficiently.
Resolution Principle
• Based on the refutation principle:
To prove a statement, assume its negation and show a
contradiction.

• Goal: Derive an empty clause (⊥) using resolution

rules.

Resolution Rule (Binary)

• If you have:
-A∨B
- ¬B ∨ C

• You can resolve on B to get:

-A∨C
 Resolution Example
• Given:
1. P ∨ Q
2. ¬Q ∨ R

• Resolution on Q and ¬Q yields:

⇒P∨R
 Steps in Resolution Process
1. Convert statements to CNF (Conjunctive
Normal Form)
2. Negate the conclusion
3. Add negated conclusion to the knowledge
base
4. Apply resolution rules
5. Derive empty clause (⊥) to prove
contradiction
Step 1 – Convert to CNF
• Convert all propositions to CNF (Conjunctive
Normal Form):
• Eliminate implications (P → Q becomes ¬P ∨
Q)
• Move NOT inwards using De Morgan’s laws
• Distribute OR over AND
• Flatten nested expressions
Step 2 – Negate the Goal
• Negate the goal proposition you want to
prove.
• Add the negated goal to the set of CNF
clauses.
• The aim is to reach a contradiction using this
set.
Step 3 – Apply Resolution
• Use the resolution rule on pairs of clauses.
• Identify complementary literals (e.g., A and
¬A).
• Combine the remaining parts to form a new
clause.
• Add new clause to the clause set.
Step 4 – Repeat Until Empty Clause
• Continue applying resolution:
– If you derive the empty clause (⊥), the original
goal is proven.
– If no new clause can be derived, the proof fails
(goal not provable with current clauses).
"If it rains, then the ground gets wet." If we also know "It is raining," we can
deduce that "The ground gets wet." Resolution can be used to demonstrate
this deduction formally.
Example:
• Premises (Axioms):
• If it rains (R), then the ground gets wet (W) : R → W
• It is raining (R): R
• To Prove: The ground gets wet (W)
• Steps in Resolution:
Convert to Clause Form:
– R → W is converted to ¬R ∨ W
– R remains as R
Negate the Conclusion: ¬W (We want to prove W, so we negate it)
Combine with Negated Conclusion:
– ¬R ∨ W (from premise 1)
– R (from premise 2)
– ¬W (negated conclusion)
Apply Resolution:
– Resolve ¬R ∨ W and R. This yields W (since R and ¬R cancel out).
– Resolve W and ¬W. This yields ∅ (the empty clause, indicating a contradiction)
Interpretation: The empty clause ∅ indicates
that the original premises and the negated
conclusion led to a contradiction, which means
the conclusion is true.

Conclusion: Since we reached a contradiction by

resolving the premises and the negated
conclusion, we have proven that if it rains and if
it rains implies wet ground, then the ground is
wet.
Example:
Given:
1)P ∨ Q
2)¬P
3)¬Q ∨ R
• Goal: Prove R Is T
Steps:
• Negate goal → ¬R
• Add ¬R to clauses
• Resolve (¬Q ∨ R) and (¬R) → ¬Q
• Resolve (P ∨ Q) and (¬Q) → P
• Resolve (P) and (¬P) → ⊥(Empty)
• ⊥ derived → Goal R is proven
 Applications in AI
• Automated theorem proving
• Expert systems
• Logic programming (e.g., Prolog)
• Knowledge reasoning

Resolution is essential in AI for proving

statements using logic.

Widely used in logic programming, and expert

systems.
Advantages & Limitations
• Advantages:
- Systematic method
- Complete for propositional logic

• Limitations:
- Computationally intensive(Resolution logic, while
theoretically elegant, can be computationally
intensive due to the potential for an unbounded
search space and the need to track and manage a
large number of clauses)
- CNF conversion can be complex