Every time you ask a virtual assistant a question or run a search query that “understands” what you mean, a hidden process is at work. The machine is not thinking the way you do. Instead, it is using carefully structured stores of facts and rules to mimic the reasoning of a human specialist. This is the heart of an expert system, and the way it stores and organises facts is called knowledge representation. For anyone studying information processing and retrieval, this concept explains how raw human expertise gets converted into something a computer can actually use to solve problems.
Table of Contents
- What knowledge representation means in an expert system
- The different forms of knowledge in language understanding
- Phonetic and phonological knowledge
- Morphological knowledge
- Syntactic knowledge
- Semantic knowledge
- Methods for representing knowledge
- Production rules
- Unit structures, or frames
- Semantic networks
- Inference and chaining methods
- Forward chaining
- Backward chaining
- Choosing between the two
- Why this matters for information retrieval
What knowledge representation means in an expert system
An expert system is a computer program that uses facts, rules, and reasoning methods to solve complex problems the way a human specialist would. It typically has three core parts: a knowledge base that holds structured facts about a subject, an inference engine that applies logical rules to those facts, and a user interface that lets people interact with the system.
Knowledge representation is the technique of encoding human knowledge into a format the machine can store, search, and reason over. It is the foundation on which expert systems and automated reasoning are built. Without a good representation method, even the most powerful inference engine has nothing useful to work with. So the quality of an expert system depends heavily on how well its knowledge is structured in the first place.
The different forms of knowledge in language understanding
Before a machine can represent knowledge, it helps to understand the layers of knowledge that language itself contains. When a system needs to process natural language, whether for answering questions or retrieving documents, it draws on several distinct types of knowledge. Researchers often describe seven levels of language knowledge, but four of them are especially important for understanding how text and speech are processed.
Phonetic and phonological knowledge
This is the most basic layer. Phonetic and phonological knowledge concerns how words relate to the sounds that produce them. It matters most when a system has to handle spoken input rather than typed text. A voice assistant, for example, must first map the stream of sounds it hears to recognisable words before any further analysis can begin. For text-based retrieval this layer is less critical, but for speech recognition it is the essential first step.
Morphological knowledge
Morphology deals with how words are built from smaller units of meaning called morphemes. A morpheme is the smallest unit of meaning in a language. Take the word “friendly”. It combines the noun “friend” with the suffix “-ly”, which converts it into an adjective. A machine that understands morphology can recognise that “run”, “running”, and “ran” all share a common root. This is extremely useful in information retrieval, where a search for one form of a word should ideally return documents containing its other forms too.
Syntactic knowledge
Syntax is about how words combine to form correct sentences. Syntactic knowledge determines the structural role each word plays and which phrases form parts of other phrases. The process of working out this structure is called parsing, and it is handled by a component called a parser. Syntactic analysis lets a system tell the difference between “the dog bit the man” and “the man bit the dog”, which use the same words but mean very different things. Sentence structure is often represented in a tree form to capture these relationships clearly.
Semantic knowledge
Semantics is the layer of actual meaning. It concerns what words and sentences mean, both on their own and in combination. This is where a system learns to handle ambiguity. Consider the word “bank”, which can mean a financial institution or the side of a river. Resolving which meaning applies requires semantic understanding. Semantic knowledge is what makes meaningful question answering, content recommendation, and retrieval possible, because it lets the machine connect words to real-world concepts rather than just matching strings of letters. A further layer, pragmatic knowledge, goes one step beyond this to account for how context and intention shape meaning, which is why the same sentence can mean different things in different situations.
Methods for representing knowledge
Once we know the kinds of knowledge involved, the next question is how to store that knowledge so a machine can use it. Several techniques exist for this purpose, but two are especially common in expert systems: production rules and unit structures. A third, the semantic network, is also worth knowing.
Production rules
Production rules are among the most widely used methods of representing knowledge. Each rule has two parts: a condition, also called the antecedent, and an action, also called the consequent. The condition describes a situation that must be true, and the action specifies what to do when it is. They follow a simple IF-THEN structure. A basic example might be: IF the patient has a fever AND a sore throat, THEN test for a throat infection.
This approach is popular because it closely mirrors the way humans make decisions, which makes rules easy to write and easy to understand. Rule-based systems are also highly modular, so individual rules can be added, removed, or changed without disturbing the rest. A famous early example is MYCIN, a medical expert system that used production rules, each carrying a “certainty factor” to indicate how strong the rule was. The main limitation is that such systems usually do not learn from past results on their own.
Unit structures, or frames
Unit structures, more commonly known as frames, take a different approach. A frame is a data structure that divides knowledge into substructures by representing typical or “stereotyped” situations. You can think of a frame as a template made up of attributes, often called slots, that describe an object or concept. A frame for a book, for instance, might include slots for title, author, year, and number of pages.
Frames group related information together, which makes them easier to manage and extend than a long list of separate rules. Frame-based systems can store complex relationships between classes while remaining understandable to non-technical users, and they support inheritance, where a specific frame inherits properties from a more general one. This structured, hierarchical organisation makes frames a strong choice when knowledge is naturally organised around objects and categories, as it often is in cataloguing and classification work.
Semantic networks
A semantic network represents knowledge as a graph. Nodes stand for concepts and links show the relationships between them. A network might record that a “cat” is a type of “animal”, and that an “animal” is a type of “living thing”. This makes semantic networks well suited to representing hierarchical relationships and is one reason they appear in natural language processing, where the connections between words carry a lot of meaning.
Inference and chaining methods
Storing knowledge is only half the story. The system also needs a way to reason with that knowledge to actually solve problems. This is the job of the inference engine, which applies logical rules to the knowledge base to derive new facts or reach decisions. Inference engines generally work in one of two modes: forward chaining and backward chaining.
Forward chaining
Forward chaining is a data-driven method. It starts with the available facts and applies inference rules to derive more facts until a goal is reached. The engine looks for rules whose conditions match the known facts, fires those rules, adds the new facts to the knowledge base, and repeats the cycle. Because it moves from facts toward conclusions, it is often described as a bottom-up approach. It works well for planning, monitoring, interpretation, and control tasks. The classic example is DENDRAL, an expert system that used forward chaining to work out chemical structures.
Backward chaining
Backward chaining reverses the direction. It begins with a goal or hypothesis and works backward to find the facts that would support it. The engine identifies rules that could lead to the goal, then checks whether the conditions of those rules are true, often breaking the main goal into smaller sub-goals along the way. This makes it a goal-driven, top-down approach. MYCIN used backward chaining to diagnose bacterial infections, and the method is common in diagnostic and debugging tasks where there is a clear question to answer.
Choosing between the two
The right choice depends on the problem. Forward chaining suits situations where data is the starting point and the conclusion is unknown, while backward chaining is more efficient when a specific hypothesis needs to be tested and the volume of data is large. If you are trying to discover what conclusions follow from a set of observations, forward chaining is efficient. If you already have a question in mind and want to confirm or rule it out, backward chaining usually does less unnecessary work.
Why this matters for information retrieval
For students of information science, these ideas are not just abstract theory. The same layers of language knowledge that power expert systems also drive modern search and retrieval tools. Morphological analysis helps a search engine match different word forms. Semantic understanding lets a system retrieve documents that are relevant in meaning even when the exact keywords differ. And the representation methods, whether rules, frames, or networks, decide how efficiently a system can organise and reason over the knowledge it holds. Understanding knowledge representation gives you a clearer picture of how intelligent retrieval systems move beyond simple keyword matching toward genuine understanding.
What do you think? If you were designing an expert system for a library reference service, would you lean toward production rules or frames to represent your knowledge, and why? And for a diagnostic-style query where users come with a specific question, do you think forward or backward chaining would serve them better?
References
- https://builtin.com/artificial-intelligence/forward-chaining-vs-backward-chaining
- https://www.tutorialspoint.com/artificial_intelligence/ai_knowledge_representation_techniques.htm
- https://arxiv.org/pdf/0712.3705
- https://mind.ilstu.edu/curriculum/protothinker/natlangproc.html
- https://arxiv.org/pdf/0912.1820
- https://image-ppubs.uspto.gov/dirsearch-public/print/downloadPdf/6928448
- https://www.geeksforgeeks.org/artificial-intelligence/knowledge-representation-in-ai/
- https://arxiv.org/pdf/1810.01560
- https://blog.emb.global/knowledge-representation-in-ai/
- https://www.complexica.com/narrow-ai-glossary/framebased-systems
- https://edvancer.in/expert-systems-and-knowledge-representation-in-ai/
- https://en.wikipedia.org/wiki/Inference_engine
- https://en.wikipedia.org/wiki/Forward_chaining
- https://www.educba.com/forward-chaining-vs-backward-chaining/
- https://analyticssteps.com/blogs/forward-chaining-vs-backward-chaining
- https://arxiv.org/pdf/2302.03625

Leave a Reply