# How Semantica Handles Reasoning and Inference on the Knowledge Graph

> Discover how Semantica powers reasoning and inference on its knowledge graph using Rete style forward chaining deductive abductive Datalog and SPARQL engines with full PROV O provenance tracking.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: deep-dive
- Published: 2026-09-04

---

**Semantica implements a deterministic, Rete‑style forward‑chaining reasoner with specialized engines for deductive, abductive, Datalog, and SPARQL inference, providing full W3C PROV‑O compliant provenance tracking for every derived fact.**

The `semantica-agi/semantica` repository provides a modular **reasoning and inference** layer that sits directly atop the core knowledge graph. This architecture enables deterministic, explainable computation through multiple inference modes while maintaining complete audit trails for regulated domains.

## Core Reasoning Architecture

Semantica’s reasoning stack centers on a **Rete‑style forward‑chaining engine** implemented in the `Reasoner` class. This deterministic engine matches rule conditions against facts in working memory and fires actions to derive new knowledge. The architecture separates rule registration, fact management, and inference execution into distinct phases to ensure transparency and reproducibility.

## Rule Definition and Registration

Users register IF/THEN rules via the `add_rule` method in [`semantica/reasoning/reasoner.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/reasoning/reasoner.py) (lines 70-94). Each rule is parsed into a `Rule` object containing conditions, conclusions, optional actions, and metadata including confidence scores and priority levels.

The implementation includes intelligent deduplication logic that prevents duplicate rule entries while preserving the original rule’s configuration. This ensures that repeated registrations of identical rules do not bloat the working memory or trigger redundant computations.

## Managing Facts in Working Memory

Facts enter the system through the `add_fact` method (lines 100-115 in [`semantica/reasoning/reasoner.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/reasoning/reasoner.py)). The engine accepts both simple string expressions—such as `Person(John)`—and KG‑style dictionaries, normalizing all inputs to a consistent string format for uniform processing.

This normalization layer allows the reasoner to interface seamlessly with the underlying knowledge graph while maintaining a flat, queryable working memory optimized for pattern matching.

## Forward‑Chaining Inference Execution

When `infer_facts` is called (lines 21-31 in [`semantica/reasoning/reasoner.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/reasoning/reasoner.py)), the engine iterates over all registered rules and attempts to unify rule conditions with the current fact set. Successfully matched rules fire their associated actions, and the derived conclusions are returned as a flat list of strings.

For applications requiring detailed metadata, the `infer_with_results` method (lines 33-41) returns full `InferenceResult` objects that include rule provenance, confidence scores, and derivation timestamps.

## Provenance and Auditability

If instantiated with `provenance=True`, the `Reasoner` maintains an `action_log` (lines 13-28 in [`semantica/reasoning/reasoner.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/reasoning/reasoner.py)) that records every fired action. Each log entry captures timestamps, rule IDs, operations performed, and confidence scores.

This log feeds directly into Semantica’s W3C PROV‑O provenance layer, enabling full audit trails that trace derived knowledge back to original source data and rules. This capability satisfies compliance requirements for regulated industries requiring explainable AI.

## Specialized Reasoning Modes

Beyond the core engine, Semantica provides specialized reasoners for distinct logical operations.

### Deductive Reasoning

The `DeductiveReasoner` class in [`semantica/reasoning/deductive_reasoner.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/reasoning/deductive_reasoner.py) extends the core engine to apply logical inference over explicit premises. It adds premises to the knowledge base, runs the forward‑chaining algorithm, and produces `Conclusion` objects (lines 88-102 and 140-165) that include complete proof steps and rule provenance chains.

### Abductive Reasoning

The `AbductiveReasoner` in [`semantica/reasoning/abductive_reasoner.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/reasoning/abductive_reasoner.py) generates plausible hypotheses that explain observed phenomena. When `generate_hypotheses` is called (lines 89-105), the engine scans the rule base for rules whose conclusions match observations, builds `Hypothesis` objects, and ranks candidates by coverage and simplicity (lines 140-170). The system returns the top‑k hypotheses ranked by confidence scores.

## MCP Tool Integration

The reasoning engines expose standard interfaces through the Model Context Protocol (MCP). The [`mcp/tools/reasoning.py`](https://github.com/semantica-agi/semantica/blob/main/mcp/tools/reasoning.py) module provides two primary functions:

- **`run_reasoning`** (lines 14-38): Instantiates a `Reasoner`, feeds user‑provided facts and rules, and returns structured JSON results via forward‑chaining inference.
- **`abductive_reasoning`** (lines 40-55): Wraps the `AbductiveReasoner` to generate hypotheses from observations through the MCP interface.

Both functions enable remote execution and integration with higher‑level frameworks such as LangChain and CrewAI.

## Practical Implementation Examples

The following examples demonstrate **Semantica reasoning and inference** in practice:

```python

# Basic forward‑chaining example

from semantica.reasoning import Reasoner

# Initialise the reasoner (enable provenance if you need audit trails)

r = Reasoner(provenance=True)

# Add rules in IF‑THEN syntax

r.add_rule("IF Person(?x) THEN Mortal(?x)")
r.add_rule("IF Mortal(?x) THEN CanDie(?x)")

# Add initial facts

r.add_fact("Person(John)")

# Run inference

derived = r.infer_facts(["Person(John)"])
print(derived)          # ['Mortal(John)', 'CanDie(John)']

# View provenance log (each entry shows which rule fired and when)

for entry in r.action_log:
    print(entry)

```

For hypothesis generation, use the abductive engine:

```python

# Abductive reasoning example

from semantica.reasoning import AbductiveReasoner

ab = AbductiveReasoner(max_hypotheses=3)

# Suppose we observed that a system crashed

observations = ["Crash(SystemA)"]

# Generate hypotheses that could explain the crash

hypotheses = ab.generate_hypotheses(observations)
for h in hypotheses:
    print(f"Hypothesis: {h.explanation} (confidence={h.confidence})")

```

## Summary

- **Semantica** provides a deterministic **Rete‑style forward‑chaining reasoner** as its core inference engine.
- Rules are registered via `add_rule` in [`semantica/reasoning/reasoner.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/reasoning/reasoner.py) with built‑in deduplication logic.
- Facts normalize to string expressions (e.g., `Person(John)`) through the `add_fact` method.
- **Provenance tracking** via `action_log` ensures W3C PROV‑O compliant audit trails for every derivation.
- **DeductiveReasoner** and **AbductiveReasoner** extend the base engine for logical proof generation and hypothesis formation.
- MCP tool wrappers in [`mcp/tools/reasoning.py`](https://github.com/semantica-agi/semantica/blob/main/mcp/tools/reasoning.py) enable API access to all reasoning modes.

## Frequently Asked Questions

### What type of reasoning engine does Semantica use?

Semantica uses a **Rete‑style forward‑chaining reasoner** implemented in the `Reasoner` class. This deterministic algorithm matches rule premises against facts in working memory and derives conclusions through repeated rule firing until no new facts are generated.

### How does Semantica track provenance for inferred facts?

When initialized with `provenance=True`, the `Reasoner` maintains an `action_log` that records every rule firing with timestamps, rule IDs, and confidence scores. This log integrates with Semantica’s W3C PROV‑O layer to provide complete audit trails from derived facts back to original source data.

### What is the difference between deductive and abductive reasoning in Semantica?

**Deductive reasoning** applies logical rules to explicit premises to derive certain conclusions with complete proof steps via the `DeductiveReasoner`. **Abductive reasoning** works backward from observations to generate plausible explanatory hypotheses, ranking candidates by coverage and simplicity using the `AbductiveReasoner`.

### Can Semantica's reasoning capabilities be accessed via API?

Yes. The [`mcp/tools/reasoning.py`](https://github.com/semantica-agi/semantica/blob/main/mcp/tools/reasoning.py) module exposes MCP‑compatible endpoints including `run_reasoning` for forward‑chaining and `abductive_reasoning` for hypothesis generation. These functions instantiate the appropriate reasoner classes and return structured JSON results suitable for remote integration.