FuXi Semantic Web Reasoner Meshup

📄 The Origin Story

Chimezie Ogbuji's Medium article (May 2026) narrates FuXi's original development for the Cleveland Clinic CVIR registry, its two-decade journey through Pychinko and RETE-UL, the Backward Fixpoint Procedure, and the vision of SPARQL interlocution as generative expert systems infrastructure.

↗ Read on Medium

⚙️ The Agent Skill

The semantic-web-reasoner-skill is a TypeScript + Python OpenCode / Claude skill exposing 10 tools for OWL ontology management and FuXi reasoning. It integrates owl_dsl, ROBOT, riot, and owlready2 into a tool-aware LLM agent pipeline.

↗ View on GitHub

The Origin Story

From the CVIR registry to SPARQL interlocution — FuXi's two-decade arc

🏥 Historical Context

FuXi was originally built for the Cleveland Clinic Cardiovascular Information Registry (CVIR) at Case Western Reserve University, patented as an "Extensible Database-Backed Web Architecture." The core insight: healthcare data is a natural fit for open-world OWL reasoning.

🔄 Evolution

FuXi grew out of Pychinko, an early Python RETE reasoner. It now implements RETE-UL, BFP (via François Bry's 1990 meta-interpreter), and SPARQL interlocution. Version 2.0.1 was re-released in 2026 alongside the skill.

🧬 Generative Expert Systems

The article's thesis: SPARQL 1.1 Entailment Regimes + BFP + LLM tool-use creates the infrastructure for generative expert systems. The Semantic Web's Open World Assumption becomes an asset when combined with SPARQL interlocution's memoized SLD resolution over recursive rules.

📐 DLP Compilation

Using Description Logic Programs (Grosof et al. 2003), FuXi compiles OWL axioms — inverseOf, TransitiveProperty, subClassOf — into Horn rules for RETE-UL evaluation. The fuxi.owl CLI subcommand orchestrates this pipeline.

Key Theoretical Concepts

The semantic web reasoning stack underlying FuXi

Forward Chaining A data-driven inference method that starts with available data and uses inferenc

Backward Chaining A goal-driven inference method that works backward from a goal, identifying rule

Meta-Interpretation A logic programming technique where an interpreter for a language is written in

RETE-UL A modification of the original RETE production rule algorithm (Doorenbos 1995) t

Backward Fixpoint Procedure (BFP) A meta-interpreter defined by Francois Bry (1990) for reconciling bottom-up and

SPARQL Interlocution An extension of Bry's BFP meta-interpreter that incorporates SPARQL service eval

Description Logic Programs (DLP) A technique from Grosof et al. (2003) providing a direct mapping from a subset o

Open World Assumption (OWA) The semantic principle of OWL and RDF stating that the absence of a stated fact

Sideways Information Passing (SIP) Query evaluation strategies that pass variable binding information (bound/free a

TBox (Terminological Box) In Description Logic, the TBox contains terminological statements: class names,

ABox (Assertional Box) In Description Logic, the ABox contains grounded individual statements: class me

Core Tool Ecosystem

Software stack surrounding FuXi — from RDF I/O to OWL verbalization

🧠

FuXi

A Python bi-directional reasoning engine (forward/bottom-up + backward/top-down) companion to RDFLib. Handles OWL 1.1/2.0, RDF, RDFS, RIF, N3. Impleme

📝

owl_dsl

A Python tool for verbalizing OWL ontologies into Controlled Natural Language. Renders OWL classes and properties as Manchester Syntax phrases. Used b

🤖

ROBOT

A command-line tool for OBO Foundry ontology development. Validates OWL 2 profiles (RL, DL). Used by the skill's check-ontology tool for running struc

⚡

riot (Apache Jena)

Apache Jena's RDF I/O Technology CLI. Parses, converts, and validates RDF in multiple serialization formats. Used by the semantic-web-reasoner-skill f

🦉

owlready2

A Python module for manipulating OWL 2.0 ontologies using SQLite persistence. Used by the skill's ontology management tools (create-ontology, list-ont

🐍

Pychinko

An early Python N3 reasoner using the original RETE algorithm. FuXi (circa 2006) initially continued in Pychinko's footsteps before evolving to the RE

🌐

CWM (Closed World Machine)

W3C's Notation 3 reasoner. One of the first N3 reasoners used in the CVIR project before FuXi was created.

🔄

Euler

An N3 reasoner supporting backward reasoning. One of the early reasoners (alongside CWM and Pychinko) used before FuXi was created to handle larger sc

FuXi CLI Subcommands

Code examples — schema:SoftwareSourceCode instances from the knowledge graph

1 fuxi.core Python / CLI ▼

FuXi CLI subcommand for forward chaining evaluation and RETE network diagnostics.

fuxi.core facts.n3

2 fuxi.owl Python / CLI ▼

FuXi CLI subcommand for OWL reasoning, DLP compilation, and BFP query answering. Supports --dlp, --hybrid, --method=bfp, --why (SPARQL goal), --output (proof-graph-svg, man-owl, pml, etc.).

fuxi.owl --method=bfp --dlp --hybrid --ns eg=http://example.net/vocab# --why "ASK { eg:bob your:isBrotherOf eg:joe }" --output proof-graph-svg test/OWL/inverseOf/premises001.rdf > proof.svg

3 fuxi.proof Python / CLI ▼

FuXi CLI subcommand for proof and SIP graph generation. Output formats include rete-network-svg, sip-collection-svg, adornment, pml (Provenance Markup Language), proof-graph-svg, proof-graph-png.

fuxi.proof --method=bfp --dlp --hybrid --ns eg=http://example.net/vocab# --why "ASK { eg:bob your:isBrotherOf eg:joe }" --output rete-network-svg test/OWL/inverseOf/premises001.rdf > rete_network.svg

FuXi → SPARQL Translation Examples

schema:SoftwareSourceCode SPARQL queries from the FuXi test suite — with the ABox/TBox sample datasets used in each reasoning example

1 FuXi BFP Goal: inverseOf Entailment SPARQL ASK — goal query ▼

The SPARQL ASK goal FuXi evaluates via Backward Fixpoint Procedure using owl:inverseOf. Data: eg:joe isBrotherOf eg:bob. Axiom: isBrotherOf owl:inverseOf isBrotherOf. FuXi proves eg:bob isBrotherOf eg:joe by backward chaining.

Sample Dataset (FuXi test suite ↗):

inverseOf ABox (ABox — asserted facts):

@prefix your: <http://example.net/vocab#> .
@prefix eg: <http://example.net/> .

eg:joe your:isBrotherOf eg:bob .

inverseOf TBox (TBox — ontology axioms):

@prefix your: <http://example.net/vocab#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .

your:isBrotherOf owl:inverseOf your:isBrotherOf .

⇒ eg:bob your:isBrotherOf eg:joe ← proved via owl:inverseOf backward chaining

SPARQL query evaluated by FuXi:

PREFIX your: <http://example.net/vocab#>
PREFIX eg: <http://example.net/>

# FuXi BFP goal — fuxi.owl --method=bfp --dlp --why "ASK { eg:bob your:isBrotherOf eg:joe }"
ASK {
  eg:bob your:isBrotherOf eg:joe .
}

▶ Run on URIBurner 📂 Source: FuXi test suite

2 FuXi SPARQL Interlocution: EDB Property Check SPARQL ASK — EDB sub-query ▼

SPARQL ASK FuXi generates internally during SPARQL interlocution, dispatched to the EDB to check for OWL functional/inverse-functional property axioms before applying Horn rules.

Sample Dataset (FuXi test suite ↗):

intersectionOf Ontology (ABox+TBox) (ABox — asserted facts):

@prefix first: <http://www.w3.org/2002/03owlt/intersectionOf/premises001#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

first:C owl:intersectionOf ( first:Employee first:Student ) .
first:John a first:B .
first:B owl:intersectionOf ( first:Student first:Employee ) .

⇒ FuXi dispatches ASK to EDB: false → no functional properties → skips those Horn rules

SPARQL query evaluated by FuXi:

PREFIX owl: <http://www.w3.org/2002/07/owl#>

# FuXi-generated EDB sub-query during SPARQL interlocution
ASK {
  [] a ?KIND
  FILTER(
    ?KIND = owl:InverseFunctionalProperty ||
    ?KIND = owl:FunctionalProperty
  )
}

▶ Run on URIBurner 📂 Source: FuXi test suite

3 FuXi Forward Chaining: Superproperty Entailment SPARQL SELECT — entailment check ▼

Demonstrates FuXi RETE-UL forward-chaining from rdfs:subPropertyOf + owl:equivalentProperty. ABox: john has_brother jack. TBox: has_brother subPropertyOf has_sibling. Entailed: john has_sibling jack.

Sample Dataset (FuXi test suite ↗):

Superproperty ABox (ABox — asserted facts):

@prefix exterms: <http://example.org/terms/> .
@prefix : <http://example.org/> .

:john exterms:has_brother :jack .
:jack exterms:brother     :john .

Superproperty TBox (TBox — ontology axioms):

@prefix exterms: <http://example.org/terms/> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .

exterms:has_brother rdfs:subPropertyOf exterms:has_sibling .
exterms:brother owl:equivalentProperty exterms:has_brother .

⇒ :john exterms:has_sibling :jack ← proved via RETE-UL forward chaining

SPARQL query evaluated by FuXi:

PREFIX exterms: <http://example.org/terms/>
PREFIX : <http://example.org/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>

# FuXi RETE-UL entailment: john has_sibling jack (via subPropertyOf + equivalentProperty)
SELECT ?subject ?entailedPredicate ?object WHERE {
  BIND(:john AS ?subject)
  BIND(exterms:has_sibling AS ?entailedPredicate)
  BIND(:jack AS ?object)
}

▶ Run on URIBurner 📂 Source: FuXi test suite

4 SELECT: Superproperty Entailment from Named Graph SPARQL SELECT — live named-graph query ▼

Real SELECT against the URIBurner named graph. Retrieves every triple whose subject is in http://example.org/ and predicate in http://example.org/terms/ — including the ABox asserted triples and the triple FuXi forward-chained via rdfs:subPropertyOf.

Sample Dataset (FuXi test suite ↗):

Superproperty ABox (asserted facts):

@prefix exterms: <http://example.org/terms/> .
@prefix : <http://example.org/> .

:john exterms:has_brother :jack .
:jack exterms:brother     :john .

Superproperty TBox (ontology axioms):

@prefix exterms: <http://example.org/terms/> .

exterms:has_brother rdfs:subPropertyOf exterms:has_sibling .
exterms:brother owl:equivalentProperty exterms:has_brother .

⇒ :john exterms:has_sibling :jack ← RETE-UL forward-chained and stored in named graph

SPARQL SELECT — queries named graph:

PREFIX exterms: <http://example.org/terms/>
PREFIX exind: <http://example.org/>

# Real SELECT against the named graph: retrieves ABox + entailed superproperty triples
# FuXi RETE-UL forward-chains exind:john exterms:has_sibling exind:jack
# from:  exind:john exterms:has_brother exind:jack
#        exterms:has_brother rdfs:subPropertyOf exterms:has_sibling
SELECT ?subject ?predicate ?object
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/fuxi-semantic-web-reasoner-meshup-claude_sonnet4-1.ttl> {
    ?subject ?predicate ?object .
    FILTER(STRSTARTS(STR(?subject), 'http://example.org/')
        && STRSTARTS(STR(?predicate), 'http://example.org/terms/'))
  }
}
ORDER BY ?subject ?predicate

▶ Run on URIBurner 📂 Source: FuXi test suite

5 DESCRIBE: inverseOf Individuals from Named Graph SPARQL DESCRIBE — named-graph description ▼

DESCRIBE retrieves all triples about eg:joe and eg:bob from the named graph, exposing the ABox fact and the owl:inverseOf axiom that FuXi's BFP backward-chains to prove eg:bob your:isBrotherOf eg:joe.

Sample Dataset (FuXi test suite ↗):

inverseOf ABox (asserted facts):

@prefix your: <http://example.net/vocab#> .
@prefix eg: <http://example.net/> .

eg:joe your:isBrotherOf eg:bob .

inverseOf TBox (ontology axiom):

@prefix your: <http://example.net/vocab#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .

your:isBrotherOf owl:inverseOf your:isBrotherOf .

⇒ DESCRIBE returns both individuals + the vocab property + the owl:inverseOf axiom

SPARQL DESCRIBE — queries named graph:

PREFIX eg: <http://example.net/>

# DESCRIBE the inverseOf individuals from the named graph
# Retrieves all known triples about eg:joe and eg:bob including
# the ABox fact:  eg:joe your:isBrotherOf eg:bob
# and the TBox:   your:isBrotherOf owl:inverseOf your:isBrotherOf
DESCRIBE eg:joe eg:bob
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/fuxi-semantic-web-reasoner-meshup-claude_sonnet4-1.ttl> {
    eg:joe ?p ?o .
  }
}

▶ Run on URIBurner 📂 Source: FuXi test suite

6 CONSTRUCT: owl:inverseOf Entailed Triple SPARQL CONSTRUCT — inference materialisation ▼

CONSTRUCT materialises the triple that FuXi's Backward Fixpoint Procedure proves via owl:inverseOf: because eg:joe your:isBrotherOf eg:bob and your:isBrotherOf owl:inverseOf your:isBrotherOf, FuXi derives eg:bob your:isBrotherOf eg:joe.

Sample Dataset (FuXi test suite ↗):

Combined ABox + TBox from named graph:

@prefix your: <http://example.net/vocab#> .
@prefix eg: <http://example.net/> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .

# ABox (asserted fact)
eg:joe your:isBrotherOf eg:bob .
# TBox (owl:inverseOf axiom)
your:isBrotherOf owl:inverseOf your:isBrotherOf .

⇒ CONSTRUCT emits: eg:bob your:isBrotherOf eg:joe . ← BFP-derived triple

SPARQL CONSTRUCT — materialises entailed triple:

PREFIX your: <http://example.net/vocab#>
PREFIX eg: <http://example.net/>
PREFIX owl: <http://www.w3.org/2002/07/owl#>

# CONSTRUCT the owl:inverseOf entailed triple
# FuXi BFP backward-chains: eg:bob your:isBrotherOf eg:joe
# from: eg:joe your:isBrotherOf eg:bob
#       your:isBrotherOf owl:inverseOf your:isBrotherOf
CONSTRUCT { eg:bob your:isBrotherOf eg:joe . }
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/fuxi-semantic-web-reasoner-meshup-claude_sonnet4-1.ttl> {
    eg:joe your:isBrotherOf eg:bob .
    your:isBrotherOf owl:inverseOf your:isBrotherOf .
  }
}

▶ Run on URIBurner 📂 Source: FuXi test suite

Skill Tool Inventory

semantic-web-reasoner-skill — 10 tool definitions for LLM-assisted OWL reasoning

🔧

list-ontologies

Lists OWL ontologies saved as owlready2 SQLite files in a working directory.

🔧

verbalize-ontology-class

Verbalizes an OWL class into Controlled Natural Language using owlready2 and owl_dsl. Input: ontologyUri, sqliteFile, ba

🔧

find-ontology-property

Finds OWL properties by label and URL pattern in an ontology SQLite file.

🔧

create-ontology

Creates an owlready2 SQLite ontology and archives provenance for later use. Input: ontologyUri, baseUri, owlFile, workin

🔧

find-ontology-class

Finds OWL classes by label pattern (string or regex) in an ontology SQLite file.

🔧

dir-ontology

Lists ontology terms in Manchester OWL Syntax from an owlready2 SQLite file.

🔧

check-ontology

Runs a ROBOT-powered structural and quality report on all issues with an OWL ontology file.

🔧

extract-class

Extracts a class and its dependencies from an OWL ontology. Input: owlFile, term, outputOwl.

🔧

ontology-report

Exports details about ontology entities as a tabular report file.

🔧

ontology-measure-essentials

Computes quantitative and structural metrics about an OWL ontology: class count, property count, complexity, coverage, a

How To Use FuXi with the Skill

Step-by-step workflow from ontology loading to proof export

Install FuXi and owl_dsl via uv

Use uv to install FuXi and owl_dsl into your Python environment: 'uv pip install fuxi owl_dsl'. Alternatively use 'uv pip install -e ".[dev]"' for development mode. uv is preferred for environment isolation and reproducibility.

Create or load an OWL ontology

Use the create-ontology tool with ontologyUri, baseUri, and owlFile parameters to create an owlready2 SQLite ontology. Use list-ontologies to enumerate existing ontologies. Use dir-ontology to list terms in Manchester OWL Syntax.

Verbalize ontology classes with owl_dsl

Use verbalize-ontology-class providing the ontology URI, SQLite file, base URI, and class reference. The tool renders OWL classes in Controlled Natural Language using owl_dsl, enabling LLM-assisted ontology Q&A and annotation suggestion workflows.

Validate the ontology against OWL 2 profiles

Use check-ontology or invoke ROBOT directly: 'robot validate-profile --profile DL --input ontology.owl'. Use '--profile RL' for the OWL 2 RL profile. Structural errors and profile violations are reported in the output.

Run OWL reasoning with FuXi DLP and BFP

Invoke fuxi.owl with --method=bfp --dlp --hybrid flags to compile OWL axioms into Horn rules and run Backward Fixpoint Procedure reasoning. Use --why 'SPARQL GOAL' to specify the entailment query, --ns for namespace prefixes, and --output proof-graph-svg to visualize the proof trace.

Visualize RETE-UL networks and SIP collections

Use fuxi.proof with --output rete-network-svg to render the meta-interpreter RETE-UL network as SVG. Use --output sip-collection-svg to show Sideways Information Passing binding adornments (b=bound, f=free) flowing through rule evaluation. Both outputs can be refined in Inkscape.

Export proofs in PML and upload to Virtuoso

Use fuxi.proof with --output pml to serialize the reasoning proof in Provenance Markup Language. The generated RDF proof can be uploaded to a Virtuoso SPARQL endpoint (e.g., via the Virtuoso example at linkeddata.uriburner.com) for exploration using SPARQL queries.

Glossary

Key terms from Semantic Web reasoning and the FuXi ecosystem

ABox (Assertional Box): In Description Logic, the ABox contains grounded individual statements: class memberships, object relationships, and data property values for specific named individuals. Uses the vocabulary defined in the TBox.
Backward Fixpoint Procedure (BFP): A meta-interpreter defined by Francois Bry (1990) for reconciling bottom-up and top-down query evaluation in recursive databases. Asserts query and evaluate terms that trigger goal-directed fact generation, enabling a forward-chaining network to simulate SLD resolution.
Description Logic Programs (DLP): A technique from Grosof et al. (2003) providing a direct mapping from a subset of OWL Description Logic into equivalent Horn rules (logic programs). Used in FuXi to compile OWL axioms (inverseOf, TransitiveProperty) into N3 Horn rules for RETE-UL evaluation.
Meta-Interpreter: An interpreter for a language written in the language itself. In FuXi, the meta-interpreter compiles N3/RIF rules and a SPARQL goal into RETE-UL meta-interpretation rules (evaluate-k and query-p terms) that drive backward-reasoning simulation via a forward-chaining network.
Notation 3 (N3): A W3C Semantic Web rule language extending RDF with quantified variables, formula contexts, and rule notation. Supported by early reasoners CWM, Euler, Pychinko, and FuXi. N3 rules use left-to-right infix notation with { premise } => { conclusion } syntax.
Open World Assumption (OWA): The semantic principle of OWL and RDF stating that the absence of a stated fact does not imply its falsehood. A reasoning-aware application can assume a logically entailed statement is present even if not explicitly in the knowledge base. SPARQL 1.1 Entailment Regimes formalise this declaratively.
Production Rule Matching: The process of matching facts in working memory against conditions (left-hand sides) of production rules to determine which rules can fire. RETE and RETE-UL networks implement this efficiently using discriminating network nodes.
RETE-UL: A modification of the original RETE production rule algorithm (Doorenbos 1995) that limits fact syntax to 3-item tuples, naturally mapping to RDF triples (subject, predicate, object). Uses hash tables for efficient alpha and beta network node evaluation.
Rule Interchange Format (RIF): A W3C standard for exchanging rules among rule systems. FuXi adopts the RIF Basic Logic Dialect (BLD) as its abstract syntax and API for representing and serializing Horn rules. FuXi can output rules in both BLD and N3 format.
SLD Resolution: Selective Linear Definite clause resolution — the inference mechanism underlying logic programming. Implemented in FuXi via backward-chaining simulation using the Backward Fixpoint Procedure over a forward-chaining RETE-UL network.
SPARQL Interlocution: An extension of Bry's BFP meta-interpreter that incorporates SPARQL service evaluation into the reasoning loop. Generates open queries and intermediate bindings, enabling complete, sound, memoized bottom-up simulation of SLD resolution even over recursive rules. Enables declarative SPARQL Entailment Regime evaluation without pre-materializing the full inference closure.
Sideways Information Passing (SIP): Query evaluation strategies that pass variable binding information (bound/free adornments) sideways between rule body terms. Originating from relational database Magic Sets research (Beeri & Ramakrishnan 1987; Bancilhon et al. 1985), SIP enables efficient evaluation of recursive queries by directing search toward relevant facts.
TBox (Terminological Box): In Description Logic, the TBox contains terminological statements: class names, property descriptions, restrictions, and their hierarchies. Defines the vocabulary (schema) used to describe a domain.
TBox / ABox: In Description Logic: TBox (Terminological Box) defines the vocabulary — class names, property descriptions, restrictions, and hierarchies. ABox (Assertional Box) contains grounded individual statements using that vocabulary. Together they constitute an OWL knowledge base.

FuXi: Reborn Semantic Web Reasoner & Interlocutor

What is a Meshup?

📄 The Origin Story

⚙️ The Agent Skill

🏥 Historical Context

🔄 Evolution

🧬 Generative Expert Systems

📐 DLP Compilation

FuXi

owl_dsl

ROBOT

riot (Apache Jena)

owlready2

Pychinko

CWM (Closed World Machine)

Euler

list-ontologies

verbalize-ontology-class

find-ontology-property

create-ontology

find-ontology-class

dir-ontology

check-ontology

extract-class

ontology-report

ontology-measure-essentials

Install FuXi and owl_dsl via uv

Create or load an OWL ontology

Verbalize ontology classes with owl_dsl

Validate the ontology against OWL 2 profiles

Run OWL reasoning with FuXi DLP and BFP

Visualize RETE-UL networks and SIP collections

Export proofs in PML and upload to Virtuoso

⚙ Advanced Settings