AI curriculum

Course outline for Neuro-Symbolic AI

Combine a model's ability to interpret text with explicit facts, rules, and checks. Reason forward from known facts and backward from a goal. Run both strategies, a real model extraction, and a small symbolic reasoner. Track premises through the decision and withhold unsupported conclusions. Compare model-only, rules-only, and hybrid behavior without assuming that correct deduction repairs false inputs.

Neuro-Symbolic AI Course Objectives

  • Assign neural interpretation and symbolic deduction distinct responsibilities.
  • Author and execute facts, rules, and queries in SWI-Prolog.
  • Execute forward and backward chaining and compare their proof traces.
  • Explain missing premises, alternative proofs, and bounded-search limits.
  • Represent graph relationships and a bounded domain vocabulary explicitly.
  • Connect actual model extraction to validated, evidence-linked premises.
  • Separate rule deduction, ontology commitments, and business-constraint checks.
  • Produce traceable accept, reject, unknown, and conflict outcomes.
  • Compare error consequences and escalation effort across three bounded approaches.

Pre-requisites

  • Basic Python, tests, structured outputs, and model API operation.
  • Knowledge Engineering Foundations for AI Systems or equivalent entities, relationships, rules, and evidence knowledge.
  • Distinguish candidate information from reviewed accepted facts.
  • No previous Prolog, ontology runtime, or probabilistic-programming experience is required.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Readiness checks

  • Basic Python, tests, structured outputs, and model API operation.
  • Knowledge Engineering Foundations for AI Systems or equivalent entities, relationships, rules, and evidence knowledge.
  • Distinguish candidate information from reviewed accepted facts.
  • No previous Prolog, ontology runtime, or probabilistic-programming experience is required.

Basic Python, tests, structured outputs, and model API operation.

Find your place in the learning map

Lab Setup

Delivery requirements: the environment, access, and exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

Compatible stable Python and SWI-Prolog, tests, synthetic profiles, reviewed rules, safe subprocess/trace adapters, and an authorized structured-output model endpoint. The symbolic runtime starts with a visible query. Delivery requires verified adapter quoting, allowlisted data mapping, execution limits, stable releases, model access/cost, and negative cases. No live hiring system, full ontology reasoner, or advanced probabilistic-symbolic package is required.

Detailed Course Outline

Module 1: Decide which part needs learning or rules (2 hours)

  • Symbolic and neural representations: Symbolic representations versus learned neural representations and predictions.
  • Extraction limits: Language-model extraction, variable output, and unsupported premises.
  • Explicit rules: Explicit rules, reviewable constraints, and deterministic execution limits.
  • Hybrid responsibility boundaries: Neural proposal, premise review, inference, and decision boundaries.
  • Baseline approaches: Model-only and structured-input rules-only baselines.
  • Role-matching evidence: A synthetic role-matching problem with documented evidence requirements.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Allocate interpretation and deduction responsibilities before connecting any components.

Module 2: Execute a small symbolic model (2 hours)

  • Prolog foundations: SWI-Prolog basics: facts, predicates, variables, queries, and answers.
  • Connected rules: Rules, conjunction, shared variables, and relationship traversal.
  • Skill relationships: A bounded graph of skills and explicit category relationships.
  • Evidence states: Supported, missing, explicitly negative, and conflicting evidence states.
  • Negation as failure: Negation-as-failure versus proof of real-world absence.
  • Rule and query tests: Learner-authored rules and query tests with visible derivations.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Run eligibility queries and explain the premises for a result and an unresolved case.

Module 3: Reason forward from facts or backward from a goal (2 hours)

  • Forward chaining: Forward chaining: match known facts, fire rules, and add conclusions.
  • Backward chaining: Backward chaining: select a goal, expand subgoals, and seek evidence.
  • Shared rules and proof traces: Shared finite positive rules, alternative derivations, and explicit proof traces.
  • Python and Prolog operation: Learner-authored Python forward loop versus SWI-Prolog goal-directed queries.
  • Fixed points and bounded search: Duplicate suppression, fixed points, cycles, and bounded search.
  • Choosing a reasoning direction: Data-driven consequences versus targeted questions and missing-premise diagnosis.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Execute both strategies on the same reviewed facts and rules, compare derivations, and explain a missing premise.

Module 4: Turn model outputs into candidate premises (2 hours)

  • Structured model extraction: Actual model extraction with structured output and source spans.
  • Premise validation: Schema validation, identifier mapping, and evidence review.
  • Ontology and instance meanings: Ontology meanings versus extracted instance assertions and rule execution.
  • Safe reasoner adapter: Python adapter and a prepared safe Prolog invocation interface.
  • Allowlisted data facts: Allowlisted data predicates rather than executing generated Prolog code.
  • Adverse extraction cases: Unsupported, malformed, contradictory, and injected candidate records.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Send real extraction candidates through validation without promoting them automatically to accepted facts.

Module 5: Trace hybrid reasoning and constraints (2 hours)

  • Accepted-premise pipeline: Pipeline execution from candidate to accepted premise to conclusion.
  • Independent business constraints: Business restrictions and record checks separate from deduction.
  • Decision explanations: Rule and premise identifiers in a decision explanation.
  • False-premise limits: False-premise injection despite valid symbolic execution.
  • Abstention and escalation: Abstention on missing or disputed evidence and reviewer ownership.
  • Correction provenance: Changed evidence, rerun decisions, and retained result provenance.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Execute a hybrid decision and show which check blocks a plausible but unsupported recommendation.

Module 6: Compare outcomes rather than promised certainty (2 hours)

  • Independent cases: Labeled cases with independent evidence and policy references.
  • Three-way comparison: Model-only, rules-only, and hybrid results under comparable inputs.
  • Error and coverage measures: False acceptance, false rejection, abstention, and coverage.
  • Review effort and cost: Review effort, inference cost, and error-consequence assumptions.
  • Unseen assessment: New learner-designed cases and separate explanatory feedback.
  • Simpler alternatives: When rules alone or human judgment is the better design.
  • Guided-time allocation: 0.75 hours for explanation and a worked example, 0.75 hours for learner practice, 0.25 hours for feedback, and 0.25 hours for questions and contingency.

Practical outcome: Defend the hybrid boundary or recommend a simpler alternative from actual observed results.

Practical exercise

  • Build a synthetic role-and-skills prototype with Python and SWI-Prolog. Write facts, two connected rules, and queries over a small relationship model. Define domain categories and constraints, but do not claim OWL classification from a Prolog rule system. Distinguish missing evidence from an explicit negative fact.
  • Call a real authorized model to extract candidate facts and source spans from synthetic profiles. Validate structure, identifiers, and supporting passages before creating allowlisted data facts. Never load model-generated code as a trusted Prolog program. Execute the adapter and reasoner, recording actual proposals, accepted premises, rule identifiers, and decisions.
  • Use at least six labeled cases covering supported acceptance, policy rejection, missing evidence, conflicting evidence, fabricated extraction, and a false accepted premise. Crafted candidates make adverse tests repeatable but do not replace real model extraction. Show that a valid rule can derive an incorrect real-world conclusion from the false premise. Assign escalation rather than forced rejection where the evidence is insufficient. Test a correction and preserve prior results.
  • Compare actual model-only and hybrid decisions against independent labels. Run rules-only on reviewed structured facts and report its extra input-preparation advantage rather than pretending the systems received equivalent raw inputs. Record coverage, error types, review effort, and cost assumptions. Predict the result of a new learner-authored case before running it. No hiring action or personal data is involved, and the tiny case set does not establish general reliability.
  • Before adding model extraction, use the same finite positive rule subset for both reasoning strategies. Ground the small role-matching rules over an explicit finite set of people and skills. This avoids claiming a general first-order reasoner from a small teaching loop. No function symbols, generated entities, negation, or effectful actions belong in this comparison subset.
  • Implement a small Python forward-chaining loop over facts and grounded rules. Suppress duplicate conclusions and stop when no new facts follow. Record each derived fact, the rule identifier, and its supporting premises. Query the same rules and facts in SWI-Prolog, inspecting goal/subgoal expansion and alternative proofs. Use the prepared trace adapter; learners author rules and independent query tests. Predict the result before running either strategy.
  • Compare one supported goal, one missing-premise goal, irrelevant rules, and an alternative derivation. Check goal support against the forward closure on this bounded positive subset. Compare rule checks and subgoals explored, not a blanket claim that either strategy is faster. A failed proof is not proof of real-world falsity. Explain why backward chaining does not reverse an implication and is not automatically causal diagnosis or abductive reasoning.
  • Introduce a tiny recursive cycle in a separate bounded test. The forward loop must terminate through finite facts and duplicate suppression. Bound Prolog execution with a prepared timeout or inference limit; a limit result is neither false nor a completed proof. Tabling is an optional sourced extension, not a claimed default termination guarantee. Recompute from accepted base facts after a premise correction; retaining old derived facts is not truth maintenance. Complete a changed-rule and new-goal task independently before opening feedback.

Delivery and timing

  • Guided hours include teaching, demonstrations, learner practice, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite setup are additional. Allocations need a timed learner pilot before delivery; they are not measured completion times.

What you will produce

Run forward and backward chaining, validate model-extracted premises, and evaluate a bounded neural-symbolic pipeline.

How the work is checked

  • Learner-authored rules and relationship queries actually execute.
  • Both chaining strategies execute on the same finite positive rule subset.
  • Recorded traces connect supported goals to premises and expose missing evidence.
  • Duplicate, cycle, correction, and execution-limit tests distinguish inference from search failure.
  • A real model produces candidate facts with source references.
  • Evidence and schema checks precede accepted premise construction.
  • Deduction, record validation, ontology meaning, and policy checks remain distinct.
  • Decisions trace premises and rules or explicitly abstain on unresolved evidence.
  • The false-premise test demonstrates the limit of symbolic correctness.
  • Comparisons disclose input differences, small samples, cost, and review effort.

12 guided hours. Forward and backward chaining operate over the same finite positive rule subset. Actual model extraction, premise validation, and Prolog integration are required. A small Python forward loop is not a general first-order reasoner, and a search limit is not a negative proof. Deduction cannot repair false accepted premises. The course does not cover the whole field of differentiable logic or neural theorem proving, and it makes no employment-safety or universal reliability claim.

When another approach is better

  • Use deterministic rules alone when inputs are already structured and reliable.
  • Avoid forced recommendations when domain rules or evidence are incomplete and a reviewer is needed.

How we train

Contact us for full course details, including duration, delivery options and lab requirements.

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals