10 Essential Tips for Programming in Visual Prolog

Building Expert Systems Using Visual PrologExpert systems are computer programs that emulate the decision-making ability of human specialists. They combine a knowledge base of facts and rules with an inference engine that applies logical reasoning to produce conclusions or recommendations. Visual Prolog (formerly PDC Prolog) is a strongly typed Prolog dialect and development environment particularly well suited for building robust expert systems because it blends logic programming with a structured, object-oriented design and native Windows integration.

This article explains principles of expert systems, why Visual Prolog is a good choice, architecture and components of an expert system, and walks through a complete example: a medical-diagnosis-style expert system. It concludes with testing, deployment considerations, and suggestions for extending the system.

---

Why choose Visual Prolog for expert systems

• Strong typing and modularity: Visual Prolog enforces types, modules, and interfaces, reducing runtime errors common in untyped Prolog and making large knowledge bases easier to maintain.
• Object-oriented features: Support for classes, inheritance, and events enables modeling of agents, user interfaces, or sensor-driven systems in a clean way.
• Integrated IDE and GUI support: The environment provides tools for building Windows applications, useful when deploying interactive expert systems.
• Efficient native code: Compiled code gives good performance for larger rule sets and inference tasks.
• Readable syntax for logic rules: Prolog’s declarative nature makes representing rules and relationships concise and closer to human expert knowledge.

---

Expert system architecture

An expert system usually includes:

• Knowledge base — facts and rules from domain experts.
• Inference engine — applies reasoning (forward or backward chaining) to derive conclusions.
• Working memory — dynamic facts collected during a session.
• Explanation module — traces and explains reasoning steps.
• User interface — for queries, evidence entry, and displaying results.
• Knowledge acquisition tools — interfaces to build or edit rules.

Visual Prolog maps to these components naturally: modules and predicates for the knowledge base; predicates and control code for the inference engine; data structures or an object instance for working memory; and GUI forms or console I/O for the interface.

---

Knowledge representation strategies

Expert systems commonly use rules of the form “if conditions then conclusion”. In Visual Prolog, represent such rules as clauses, possibly enriched with priorities, certainty factors, or meta-data:

• Simple Horn clauses:

  
  has_fever(Person) :-   temperature(Person, Temp),   Temp > 37.5. 

• Rules with certainty factors (CF) — represent CF as an extra numeric argument:

  diagnosis(Person, flu, CF) :-   symptom(Person, cough, CF1),   symptom(Person, fever, CF2),   combine_cf([CF1, CF2], CF). 

• Frames or records for structured facts:

  country{capital: Capital, population: Pop}. 

• Object-based representation for agents or components:

  class patient   properties       id : integer.       symptoms : list(string). end class 

Choosing representation depends on requirements: deterministic logical rules, probabilistic inference, or fuzzy reasoning.

---

Inference strategies

Visual Prolog can implement different reasoning methods:

• Backward chaining (goal-driven): Useful for diagnostic tasks—start with a hypothesis and ask for supporting facts.
• Forward chaining (data-driven): Useful for sensor-driven or monitoring systems—new facts trigger rule firing.
• Hybrid: Maintain both methods to exploit their advantages.

Example of backward chaining predicate in Visual Prolog:

goal diagnose(Person, Disease) :-     rule_for(Disease, Conditions),     check_conditions(Person, Conditions). check_conditions(_, []). check_conditions(Person, [Cond | Rest]) :-     call_condition(Person, Cond),     check_conditions(Person, Rest). 

Use meta-programming to store rules in the knowledge base as data so the inference engine can iterate over rules dynamically.

---

Example: Medical diagnosis expert system

We’ll outline a compact, realistic example: a rule-based system for diagnosing respiratory illnesses. The emphasis is on design and core code sketches rather than a full production system.

System components:

• Knowledge base: symptoms, disease rules, test thresholds.
• Working memory: patient facts (symptoms reported, measured temperature).
• Inference engine: backward chaining with certainty factors and an explanation trace.
• UI: text-based Q&A for this example (can be upgraded to GUI).

Knowledge base (facts & rules):

% symptom(Person, Symptom, CF). CF in [0.0..1.0] symptom(john, cough, 1.0). symptom(john, sore_throat, 0.8). temperature(john, 38.4). % disease_rule(Disease, [Conditions], BaseCF). disease_rule(flu, [fever, cough, body_ache], 0.7). disease_rule(common_cold, [sneezing, sore_throat], 0.6). disease_rule(covid19, [fever, cough, loss_of_taste], 0.8). 

Representation of conditions:

• Map condition names to checks:

  
  check_condition(Person, fever) :- temperature(Person, T), T >= 37.5. check_condition(Person, cough) :- symptom(Person, cough, CF), CF >= 0.5. check_condition(Person, sore_throat) :- symptom(Person, sore_throat, CF), CF >= 0.4. check_condition(Person, loss_of_taste) :- symptom(Person, loss_of_taste, CF), CF >= 0.7. 

Inference with certainty factors:

diagnose(Person, Disease, CF) :-     disease_rule(Disease, Conditions, BaseCF),     evaluate_conditions(Person, Conditions, MinCF),     CF is BaseCF * MinCF. evaluate_conditions(_, [], 1.0). evaluate_conditions(Person, [C|Rest], CF) :-     check_condition_cf(Person, C, CF1),     evaluate_conditions(Person, Rest, CFrest),     CF is min(CF1, CFrest). % check_condition_cf returns a match CF in [0..1] check_condition_cf(Person, fever, 1.0) :-     temperature(Person, T),     T >= 37.5. check_condition_cf(Person, fever, 0.5) :-     temperature(Person, T),     T >= 37.0,     T < 37.5. check_condition_cf(Person, fever, 0.0) :-     temperature(Person, T),     T < 37.0. check_condition_cf(Person, Symptom, CF) :-     symptom(Person, Symptom, CF), !. check_condition_cf(_, _, 0.0). 

Explanation tracing:

• Record each matched condition and its CF in a list as rules are evaluated; present the trace to the user showing which evidence supported the diagnosis and by how much.

User interaction (console pseudo-flow):

1. Ask patient for symptoms (yes/no) or collect sensor values.
2. Assert symptoms into working memory as symptom(Person, Symptom, CF).
3. Call diagnose/3 to get candidate diseases and CFs.
4. Sort and present diagnoses with CF and explanation trace.

---

Implementation tips and best practices

• Modularize: Separate knowledge base, inference engine, UI, and utilities into modules.
• Use types and records: Define domain-specific types to prevent category errors.
• Make rules declarative data: Store rules as facts so you can add/remove rules at runtime and build rule editors.
• Keep explainability: Maintain provenance for every derived fact (which rule fired, which facts used).
• Limit rule interaction complexity: Use rule priorities or conflict resolution mechanisms (e.g., specificity, recency).
• Validate with experts: Iterate rule weights, CFs, and thresholds with domain experts.
• Test with cases: Use a test suite of patient cases (both positive and negative) to verify behavior and prevent regressions.

---

Extending the system

• Add probabilistic reasoning: Integrate Bayesian scoring or use logistic regression for combining evidence instead of simple CF multiplication.
• Temporal reasoning: Add time-stamped facts and rules that consider symptom durations.
• Learning: Use machine learning to suggest rule weights or propose new rules from labeled datasets.
• GUI: Replace console I/O with Visual Prolog forms for richer interaction, charts, and report printing.
• Distributed sensors: Use object classes and events to receive live sensor data and trigger forward-chaining rules.

---

Deployment and maintenance

• Ship as a native Windows application or a service with an API wrapper for other clients.
• Provide a rule editor UI so domain experts can update rules without modifying code.
• Maintain logs and explanation traces to audit decisions and refine rules.
• Periodically validate knowledge base against new clinical guidelines or data.

---

Conclusion

Visual Prolog offers a strong platform for building maintainable, explainable expert systems thanks to its typed logic, object-oriented features, and native tooling. Start small with a clear knowledge representation and modular architecture, add an explanation facility for trust, and iterate with domain experts. With careful design you can extend a rule-based core into hybrid systems that combine symbolic reasoning with statistical learning for better accuracy and robustness.