Knowledge in Artificial Intelligence: From Representation to Reasoning

Abstract

This article explores the concept of knowledge in artificial intelligence (AI), focusing on knowledge engineering, representation, and reasoning. It delves into various aspects of knowledge-based systems, including propositional logic, first-order logic, and theorem proving. The paper discusses key concepts such as model checking, inference rules, and search problems, providing code examples and real-world scenarios to illustrate their applications. Additionally, it examines the challenges and limitations of current knowledge representation techniques and explores future directions in this field.

Introduction

Knowledge representation and reasoning are fundamental components of artificial intelligence systems. They enable machines to understand, interpret, and make decisions based on information about the world. As AI continues to advance, the ability to effectively represent and reason with knowledge becomes increasingly crucial for developing intelligent systems capable of solving complex problems and interacting with humans in meaningful ways.

Knowledge Engineering in AI

Knowledge engineering is the process of capturing, organizing, and implementing knowledge in AI systems. It involves several key steps:

Knowledge Acquisition

Knowledge acquisition is the process of gathering information from various sources, including human experts, databases, and documents. This step is crucial for building a comprehensive knowledge base.

Example:

def acquire_knowledge(expert_input, database_data, document_text):
    knowledge_base = {}
    knowledge_base['expert_knowledge'] = process_expert_input(expert_input)
    knowledge_base['database_knowledge'] = process_database_data(database_data)
    knowledge_base['document_knowledge'] = process_document_text(document_text)
    return knowledge_base

def process_expert_input(expert_input):
    # Process and structure expert input
    return structured_expert_knowledge

def process_database_data(database_data):
    # Extract and structure relevant data from database
    return structured_database_knowledge

def process_document_text(document_text):
    # Extract key information from document text
    return structured_document_knowledge

Knowledge Representation

Knowledge representation involves choosing an appropriate format to store and organize acquired knowledge. Common representation methods include:

Propositional Logic
First-Order Logic
Semantic Networks
Frames
Ontologies

Example of propositional logic representation:

class Proposition:
    def __init__(self, symbol, value=None):
        self.symbol = symbol
        self.value = value

    def __str__(self):
        return self.symbol

class Connective:
    AND = 'AND'
    OR = 'OR'
    NOT = 'NOT'
    IMPLIES = 'IMPLIES'

class LogicalExpression:
    def __init__(self, left, connective=None, right=None):
        self.left = left
        self.connective = connective
        self.right = right

    def __str__(self):
        if self.connective == Connective.NOT:
            return f"¬({self.left})"
        elif self.connective:
            return f"({self.left} {self.connective} {self.right})"
        else:
            return str(self.left)

# Example usage
p = Proposition('P')
q = Proposition('Q')
expr = LogicalExpression(p, Connective.IMPLIES, q)
print(expr)  # Output: (P IMPLIES Q)

Knowledge Validation

Knowledge validation ensures that the represented knowledge is accurate, consistent, and complete. This step often involves testing the knowledge base against known scenarios and expert review.

def validate_knowledge_base(knowledge_base, test_cases):
    for case in test_cases:
        result = apply_knowledge(knowledge_base, case['input'])
        if result != case['expected_output']:
            print(f"Validation failed for case: {case['input']}")
            print(f"Expected: {case['expected_output']}, Got: {result}")
    print("Validation complete")

def apply_knowledge(knowledge_base, input_data):
    # Apply knowledge base rules to input data
    return result

Propositional Logic in AI

Propositional logic is a fundamental form of knowledge representation in AI. It uses symbols to represent statements that can be either true or false.

Propositional Symbols

Propositional symbols are used to represent atomic propositions. For example:

P: “It is raining”
Q: “The ground is wet”

Logical Connectives

Logical connectives are used to combine propositional symbols to form complex statements:

Negation (¬): NOT
Conjunction (∧): AND
Disjunction (∨): OR
Implication (→): IF-THEN
Biconditional (↔): IF AND ONLY IF

Example:

def create_knowledge_base():
    kb = set()
    kb.add(LogicalExpression(Proposition('P'), Connective.IMPLIES, Proposition('Q')))
    kb.add(Proposition('P'))
    return kb

kb = create_knowledge_base()
for expr in kb:
    print(expr)

Deductive Reasoning

Deductive reasoning involves drawing logical conclusions from a set of premises. It is a fundamental aspect of knowledge-based systems.

Example:

def modus_ponens(p, p_implies_q):
    return p_implies_q[1] if p and p_implies_q[0] else None

# Knowledge base
KB = {
    "It is raining": True,
    ("It is raining", "The ground is wet"): True
}

# Inference
conclusion = modus_ponens(KB["It is raining"], KB[("It is raining", "The ground is wet")])
print(f"Conclusion: The ground is {'wet' if conclusion else 'not necessarily wet'}")

Model Checking Algorithm

The model checking algorithm is used to determine whether a knowledge base entails a query. It works by enumerating all possible models and checking if the query is true in every model where the knowledge base is true.

def model_checking(kb, query):
    symbols = get_symbols(kb.union({query}))
    return check_all(kb, query, symbols, {})

def check_all(kb, query, symbols, model):
    if not symbols:
        if pl_true(kb, model):
            return pl_true(query, model)
        else:
            return True  # When KB is false, always return true
    else:
        P = symbols.pop()
        rest = symbols
        return (check_all(kb, query, rest, extend(model, P, True)) and
                check_all(kb, query, rest, extend(model, P, False)))

def pl_true(kb, model):
    # Check if kb is true in the given model
    pass

def extend(model, P, value):
    # Extend the model with a new assignment
    pass

def get_symbols(kb):
    # Extract all symbols from the knowledge base
    pass

Inference Rules

Inference rules allow the derivation of new knowledge from existing knowledge. Some common inference rules include:

Modus Ponens

If P → Q and P are true, then Q is true.

def modus_ponens(kb):
    for expr in kb:
        if isinstance(expr, LogicalExpression) and expr.connective == Connective.IMPLIES:
            if expr.left in kb:
                kb.add(expr.right)
    return kb

And Elimination

From P ∧ Q, we can infer P and Q separately.

def and_elimination(kb):
    new_kb = set(kb)
    for expr in kb:
        if isinstance(expr, LogicalExpression) and expr.connective == Connective.AND:
            new_kb.add(expr.left)
            new_kb.add(expr.right)
    return new_kb

Double Negation Elimination

¬¬P is equivalent to P.

def double_negation_elimination(kb):
    new_kb = set()
    for expr in kb:
        if isinstance(expr, LogicalExpression) and expr.connective == Connective.NOT:
            if isinstance(expr.left, LogicalExpression) and expr.left.connective == Connective.NOT:
                new_kb.add(expr.left.left)
            else:
                new_kb.add(expr)
        else:
            new_kb.add(expr)
    return new_kb

Implication Elimination

From P → Q, we can infer ¬P ∨ Q.

def implication_elimination(knowledge_base):
    new_knowledge = []
    for sentence in knowledge_base:
        if isinstance(sentence, Implication):
            new_knowledge.append(Or(Not(sentence.antecedent), sentence.consequent))
    return new_knowledge

Biconditional Elimination

From P ↔ Q, we can infer (P → Q) ∧ (Q → P).

def biconditional_elimination(knowledge_base):
    new_knowledge = []
    for sentence in knowledge_base:
        if isinstance(sentence, Biconditional):
            new_knowledge.append(And(Implication(sentence.left, sentence.right),
                                     Implication(sentence.right, sentence.left)))
    return new_knowledge

De Morgan’s Laws

¬(P ∧ Q) is equivalent to (¬P ∨ ¬Q), and ¬(P ∨ Q) is equivalent to (¬P ∧ ¬Q).

def de_morgan(knowledge_base):
    new_knowledge = []
    for sentence in knowledge_base:
        if isinstance(sentence, Not):
            if isinstance(sentence.operand, And):
                new_knowledge.append(Or(*[Not(conj) for conj in sentence.operand.conjuncts]))
            elif isinstance(sentence.operand, Or):
                new_knowledge.append(And(*[Not(disj) for disj in sentence.operand.disjuncts]))
    return new_knowledge

Distributive Property

P ∧ (Q ∨ R) is equivalent to (P ∧ Q) ∨ (P ∧ R), and P ∨ (Q ∧ R) is equivalent to (P ∨ Q) ∧ (P ∨ R).

def distributive_property(knowledge_base):
    new_knowledge = []
    for sentence in knowledge_base:
        if isinstance(sentence, And) and any(isinstance(conj, Or) for conj in sentence.conjuncts):
            or_conj = next(conj for conj in sentence.conjuncts if isinstance(conj, Or))
            other_conjs = [conj for conj in sentence.conjuncts if conj != or_conj]
            new_knowledge.append(Or(*[And(*(other_conjs + [disj])) for disj in or_conj.disjuncts]))
        elif isinstance(sentence, Or) and any(isinstance(disj, And) for disj in sentence.disjuncts):
            and_disj = next(disj for disj in sentence.disjuncts if isinstance(disj, And))
            other_disjs = [disj for disj in sentence.disjuncts if disj != and_disj]
            new_knowledge.append(And(*[Or(*(other_disjs + [conj])) for conj in and_disj.conjuncts]))
    return new_knowledge

Search Problems in AI

Search problems are a fundamental concept in AI, used to find solutions in a state space. They consist of:

Initial state
Actions
Transition model
Goal test
Path cost function

Example of a simple search problem:

class SearchProblem:
    def __init__(self, initial_state, goal_state):
        self.initial_state = initial_state
        self.goal_state = goal_state

    def actions(self, state):
        # Return possible actions from the given state
        pass

    def result(self, state, action):
        # Return the resulting state after applying the action
        pass

    def goal_test(self, state):
        return state == self.goal_state

    def path_cost(self, path):
        # Calculate the cost of the path
        pass

def breadth_first_search(problem):
    node = problem.initial_state
    if problem.goal_test(node):
        return node
    frontier = [node]
    explored = set()

    while frontier:
        node = frontier.pop(0)
        explored.add(node)
        for action in problem.actions(node):
            child = problem.result(node, action)
            if child not in explored and child not in frontier:
                if problem.goal_test(child):
                    return child
                frontier.append(child)
    return None

Theorem Proving

Theorem proving is the process of deriving new knowledge from existing knowledge using logical inference. It involves:

Starting knowledge base
Inference rules
New knowledge base after inference
Checking if the statement we are trying to prove is in the new knowledge base

Conjunctive Normal Form (CNF)

CNF is a standard form for logical expressions, consisting of a conjunction of clauses, where each clause is a disjunction of literals.

Example of converting to CNF:

def eliminate_implications(expr):
    if isinstance(expr, Proposition):
        return expr
    elif expr.connective == Connective.IMPLIES:
        return LogicalExpression(
            LogicalExpression(expr.left, Connective.NOT),
            Connective.OR,
            eliminate_implications(expr.right)
        )
    else:
        return LogicalExpression(
            eliminate_implications(expr.left),
            expr.connective,
            eliminate_implications(expr.right)
        )

def move_not_inwards(expr):
    if isinstance(expr, Proposition):
        return expr
    elif expr.connective == Connective.NOT:
        if isinstance(expr.left, Proposition):
            return expr
        elif expr.left.connective == Connective.AND:
            return LogicalExpression(
                move_not_inwards(LogicalExpression(expr.left.left, Connective.NOT)),
                Connective.OR,
                move_not_inwards(LogicalExpression(expr.left.right, Connective.NOT))
            )
        elif expr.left.connective == Connective.OR:
            return LogicalExpression(
                move_not_inwards(LogicalExpression(expr.left.left, Connective.NOT)),
                Connective.AND,
                move_not_inwards(LogicalExpression(expr.left.right, Connective.NOT))
            )
    else:
        return LogicalExpression(
            move_not_inwards(expr.left),
            expr.connective,
            move_not_inwards(expr.right)
        )

def distribute_and_over_or(expr):
    if isinstance(expr, Proposition):
        return expr
    elif expr.connective == Connective.AND:
        return LogicalExpression(
            distribute_and_over_or(expr.left),
            Connective.AND,
            distribute_and_over_or(expr.right)
        )
    elif expr.connective == Connective.OR:
        if expr.left.connective == Connective.AND:
            return LogicalExpression(
                distribute_and_over_or(LogicalExpression(expr.left.left, Connective.OR, expr.right)),
                Connective.AND,
                distribute_and_over_or(LogicalExpression(expr.left.right, Connective.OR, expr.right))
            )
        elif expr.right.connective == Connective.AND:
            return LogicalExpression(
                distribute_and_over_or(LogicalExpression(expr.left, Connective.OR, expr.right.left)),
                Connective.AND,
                distribute_and_over_or(LogicalExpression(expr.left, Connective.OR, expr.right.right))
            )
        else:
            return expr
    else:
        return expr

def to_cnf(expr):
    expr = eliminate_implications(expr)
    expr = move_not_inwards(expr)
    return distribute_and_over_or(expr)

Resolution

Resolution is a powerful inference rule used in automated theorem proving. It works by combining two clauses to produce a new clause.

def resolve(clause1, clause2):
    resolvents = set()
    for literal1 in clause1:
        for literal2 in clause2:
            if literal1 == negate(literal2):
                new_clause = (clause1 - {literal1}) | (clause2 - {literal2})
                resolvents.add(frozenset(new_clause))
    return resolvents

def negate(literal):
    if isinstance(literal, Proposition):
        return LogicalExpression(literal, Connective.NOT)
    elif literal.connective == Connective.NOT:
        return literal.left
    else:
        raise ValueError("Invalid literal")

def pl_resolution(kb, alpha):
    clauses = set(map(frozenset, to_cnf_clauses(kb | {negate(alpha)})))
    new = set()
    while True:
        for ci, cj in itertools.combinations(clauses, 2):
            resolvents = resolve(ci, cj)
            if frozenset() in resolvents:
                return True
            new = new | resolvents
        if new.issubset(clauses):
            return False
        clauses = clauses | new

First-Order Logic

First-order logic (FOL) is more expressive than propositional logic, allowing for the representation of objects, properties, and relations.

Components of First-Order Logic

Constants: Represent specific objects (e.g., John, 3)
Variables: Represent unspecified objects (e.g., x, y)
Predicates: Represent properties or relations (e.g., IsStudent(x), GreaterThan(x, y))
Functions: Represent mappings from objects to objects (e.g., Father(x))
Quantifiers:
Universal quantification (∀): “for all”
Existential quantification (∃): “there exists”

Example of FOL representation:

“`python
class Term:
pass

class Constant(Term):
def init(self, name):
self.name = name

def __str__(self):
    return self.name

class Variable(Term):
def init(self, name):
self.name = name

def __str__(self):
    return self.name

class Function(Term):
def init(self, name, args):
self.name = name
self.args = args

def __str__(self):
    return f"{self.name}({', '.join(map(str, self.args))})"

class Predicate:
def init(self, name, args):
self.name = name
self.args = args

def __str__(self):
    return f"{self.name}({', '.join(map(str, self.args))})"

class Quantifier:
FORALL = ‘∀’
EXISTS = ‘∃’

class FOLExpression:
def init(self, left, connective=None, right=None):
self.left = left
self.connective = connective
self.right = right

def __str__(self):
    if self.connective == Connective.NOT:
        return f"¬({self.left})"
    elif self.connective:
        return f"({self.left} {self.connective} {self.right})"
    else:
        return str(self.left)

Knowledge-Based Agents

Knowledge-based agents reason by operating on internal representations of knowledge, using logic to reach new conclusions based on existing information.

Example: Simple knowledge-based agent for a medical diagnosis system

class MedicalDiagnosisAgent:
    def __init__(self):
        self.KB = {
            "fever": {"flu": 0.8, "cold": 0.2},
            "cough": {"flu": 0.6, "cold": 0.5},
            "fatigue": {"flu": 0.7, "cold": 0.4}
        }

    def diagnose(self, symptoms):
        diseases = {"flu": 1.0, "cold": 1.0}
        for symptom in symptoms:
            if symptom in self.KB:
                for disease, probability in self.KB[symptom].items():
                    diseases[disease] *= probability

        return max(diseases, key=diseases.get)

# Example usage
agent = MedicalDiagnosisAgent()
symptoms = ["fever", "cough"]
diagnosis = agent.diagnose(symptoms)
print(f"Diagnosis based on symptoms {symptoms}: {diagnosis}")

Conclusion

Knowledge representation and reasoning are fundamental aspects of artificial intelligence. From propositional logic to first-order logic, and from simple inference rules to complex theorem proving techniques, these concepts form the backbone of knowledge-based AI systems. As AI continues to evolve, the ability to effectively represent and reason with knowledge will remain crucial for developing intelligent agents capable of solving complex real-world problems.

Sources

Propositional Logic in Artificial Intelligence – AlmaBetter https://www.almabetter.com/bytes/tutorials/artificial-intelligence/propositional-logic-in-ai
Knowledge Representation in AI – GeeksforGeeks https://www.geeksforgeeks.org/knowledge-representation-in-ai/
Inductive And Deductive Reasoning in AI – Scaler Topics https://www.scaler.com/topics/artificial-intelligence-tutorial/inductive-and-deductive-reasoning/
Knowledge Engineering in Ai – Lark https://www.larksuite.com/en_us/topics/ai-glossary/knowledge-engineering-in-ai
Knowledge Representation in Artificial Intelligence (AI) https://www.appliedaicourse.com/blog/knowledge-representation-in-artificial-intelligence/
[PDF] Probabilistic Reasoning Models in Artificial Intelligence https://thesciencebrigade.com/JAIR/article/download/79/78/486
Hidden Markov model – Wikipedia https://en.wikipedia.org/wiki/Hidden_Markov_models
Bayesian Network Made Simple [How It Is Used In AI & ML] https://spotintelligence.com/2024/02/06/bayesian-network/
Propositional Logic in Artificial Intelligence – GeeksforGeeks https://www.geeksforgeeks.org/propositional-logic-in-artificial-intelligence/
Deductive Reasoning in AI – GeeksforGeeks https://www.geeksforgeeks.org/deductive-reasoning-in-ai/
Propositional Logic in Artificial Intelligence – Javatpoint https://www.javatpoint.com/propositional-logic-in-artificial-intelligence
What is Knowledge Representation in AI? | Different Techniques https://www.edureka.co/blog/knowledge-representation-in-ai/
Types of Reasoning in Artificial Intelligence – GeeksforGeeks https://www.geeksforgeeks.org/types-of-reasoning-in-artificial-intelligence/
Lecture 1 – CS50’s Introduction to Artificial Intelligence with Python https://cs50.harvard.edu/ai/2023/notes/1/
Knowledge Representation in Artificial Intelligence – Javatpoint https://www.javatpoint.com/knowledge-representation-in-ai
Inductive and Deductive Methods in Artificial Intelligence – AI Mind https://pub.aimind.so/inductive-and-deductive-methods-in-artificial-intelligence-a-comparative-analysis-with-python-af3b5c8fc028?gi=4e43b6fd100f
Logic 4 – Inference Rules | Stanford CS221: AI (Autumn 2021) https://www.youtube.com/watch?v=RIk67yGMVv4
Knowledge Representation in Artificial Intelligence (AI) https://www.appliedaicourse.com/blog/knowledge-representation-in-artificial-intelligence/
Reasoning in Artificial Intelligence – Javatpoint https://www.javatpoint.com/reasoning-in-artificial-intelligence
[PDF] Artificial Intelligence Propositional Logic I Knowledge-based Agents https://classes.engr.oregonstate.edu/eecs/spring2019/cs331/slides/PropositionalLogic1.2pp.pdf
Knowledge representation and reasoning – Wikipedia https://en.wikipedia.org/wiki/Knowledge_representation_and_reasoning
On Whether Generative AI And Large Language Models Are Better … https://www.forbes.com/sites/lanceeliot/2024/08/11/on-whether-generative-ai-and-large-language-models-are-better-at-inductive-reasoning-or-deductive-reasoning-and-what-this-foretells-about-the-future-of-ai/
[PDF] Knowledge-Based Agents and Propositional Logic – UMBC https://courses.cs.umbc.edu/671/fall16/Slides/18-kb_agents_logic-aiF16.pdf
[PDF] What Is a Knowledge Representation? https://ojs.aaai.org/aimagazine/index.php/aimagazine/article/download/1029/947
Difference between Inductive and Deductive Reasoning – Javatpoint https://www.javatpoint.com/difference-between-inductive-and-deductive-reasoning
Lecture 14: Knowledge Representation and Inference in AI – Quizlet https://quizlet.com/study-guides/lecture-14-knowledge-representation-and-inference-in-ai-cb8f09fd-7311-4ea0-8fa7-cf66c1facc50
How Machine Learning made AI forget about Knowledge … https://towardsdatascience.com/how-machine-learning-made-ai-forget-about-knowledge-representation-and-reasoning-cbec128aff56
Power of Deductive Reasoning in AI: Turning Logic into Intelligence https://www.linkedin.com/pulse/power-deductive-reasoning-ai-turning-logic-vkpvc
Teaching AI Systems to Understand Real-World Scenarios and … https://ai.stonybrook.edu/about-us/News/Teaching-AI-Systems-Understand-Real-World-Scenarios-and-Suggest-Appropriate-Responses
Knowledge Representation And Reasoning In AI Made Simple https://spotintelligence.com/2024/01/16/knowledge-representation-and-reasoning-ai/
What would be a good internal language for an AI? https://ai.stackexchange.com/questions/16874/what-would-be-a-good-internal-language-for-an-ai
AI system can envision an entire world from a single picture – JHU Hub https://hub.jhu.edu/2024/12/19/a-generated-world-of-pure-imagination/
Understanding knowledge reasoning in AI systems – Telnyx https://telnyx.com/learn-ai/knowledge-reasoning
Knowledge Representation and Reasoning with Answer Set … https://towardsdatascience.com/knowledge-representation-and-reasoning-with-answer-set-programming-376e3113a421
[PDF] Knowledge Engineering in the Long Game of Artificial Intelligence https://advancesincognitivesystems.github.io/acs2021/data/ACS-21_paper_4.pdf
Knowledge Representation in AI | Simplilearn – YouTube https://www.youtube.com/watch?v=_Fn5HYfK858
Knowledge Representation in AI | Semantic Networks – YouTube https://www.youtube.com/watch?v=V-O-RFSRe-E
Real-world gen AI use cases from the world’s leading organizations https://cloud.google.com/transform/101-real-world-generative-ai-use-cases-from-industry-leaders?hl=en
Better AI Solutions With Knowledge Representation In Three … https://www.forbes.com/sites/forbestechcouncil/2018/05/11/better-ai-solutions-with-knowledge-representation-in-three-examples/
Real Life Examples of Artificial Intelligence – Ironhack https://www.ironhack.com/us/blog/real-life-examples-of-artificial-intelligence
Knowledge Representation Schemes – Dev Genius https://blog.devgenius.io/knowledge-representation-schemes-fe5fc4dc2cc5?gi=976ae6b7c1ac
4 Keys to Modern Knowledge Engineering | CCC https://www.copyright.com/blog/4-keys-modern-knowledge-engineering/
Bayesian Belief Network in Artificial Intelligence – Javatpoint https://www.javatpoint.com/bayesian-belief-network-in-artificial-intelligence
Understanding Bayesian Networks: Probabilistic Modeling & Inference https://www.lyzr.ai/glossaries/bayesian-networks/
[PDF] Hidden Markov Models https://web.stanford.edu/~jurafsky/slp3/A.pdf
Top 10 Real-world Bayesian Network Applications – DataFlair https://data-flair.training/blogs/bayesian-network-applications/
Explore Probabilistic Model in Machine Learning – Pickl.AI https://www.pickl.ai/blog/learn-about-the-probabilistic-model-in-machine-learning/
Hidden Markov Models Explained with a Real Life Example and … https://towardsdatascience.com/hidden-markov-models-explained-with-a-real-life-example-and-python-code-2df2a7956d65?gi=ecdd80b05a20
Bayesian Networks: A Comprehensive Guide to AI Modeling https://www.simplilearn.com/tutorials/generative-ai-tutorial/bayesian-networks
Understanding Probabilistic Models: Key Types and Benefits – Lyzr.ai https://www.lyzr.ai/glossaries/probabilistic-models/
Hidden Markov Model in Machine learning – GeeksforGeeks https://www.geeksforgeeks.org/hidden-markov-model-in-machine-learning/
Real-World Applications of Bayesian Belief Networks – Algoscale https://algoscale.com/blog/real-world-applications-of-bayesian-belief-networks/
An Overview of Bayesian Networks in Artificial Intelligence – Turing https://www.turing.com/kb/an-overview-of-bayesian-networks-in-ai
Exploring Hidden Markov Models – Nipun Batra https://nipunbatra.github.io/hmm/
Understanding Bayesian Networks: Significance in Artificial … https://www.researchgate.net/publication/379899229_Understanding_Bayesian_Networks_Significance_in_Artificial_Intelligence
Probabilistic Models in Machine Learning – GeeksforGeeks https://www.geeksforgeeks.org/probabilistic-models-in-machine-learning/
Hidden Markov Model Clearly Explained! Part – 5 – YouTube https://www.youtube.com/watch?v=RWkHJnFj5rY
[PDF] An Introduction to Hidden Markov Models and Bayesian Networks https://mlg.eng.cam.ac.uk/zoubin/papers/ijprai.pdf
[PDF] Markov chains and Hidden Markov Models https://www.mi.fu-berlin.de/wiki/pub/ABI/HiddenMarkovModelsWS14/slides.pdf
What is Knowledge Representation – MarketMuse Blog https://blog.marketmuse.com/glossary/knowledge-representation-definition/
How do knowledge representation and reasoning techniques … https://www.geeksforgeeks.org/knowledge-representation-and-reasoning-techniques-support-intelligent-systems/
Knowledge Engineering | Process , Role & Examples – Lesson https://study.com/learn/lesson/knowledge-engineering-process-examples.html
Bayesian networks in AI: Role in machine learning, example, types … https://www.leewayhertz.com/bayesian-networks-in-ai/
[PDF] 3. Markov chains and hidden Markov models https://www.stat.purdue.edu/~junxie/topic3.pdfKnowledge in Artificial Intelligence: From Propositional Logic to First-Order Logic

Knowledge in Artificial Intelligence: From Representation to Reasoning – Part 2

Knowledge in Artificial Intelligence: From Representation to Reasoning

Abstract

Introduction

Knowledge Engineering in AI

Knowledge Acquisition

Knowledge Representation

Knowledge Validation

Propositional Logic in AI

Propositional Symbols

Logical Connectives

Deductive Reasoning

Model Checking Algorithm

Inference Rules

Modus Ponens

And Elimination

Double Negation Elimination

Implication Elimination

Biconditional Elimination

De Morgan’s Laws

Distributive Property

Search Problems in AI

Theorem Proving

Conjunctive Normal Form (CNF)

Resolution

First-Order Logic

Components of First-Order Logic

Knowledge-Based Agents

Conclusion

Sources