The skill provides 10 tool definitions: list-ontologies, verbalize-ontology-class, find-ontology-property, create-ontology, find-ontology-class, dir-ontology, check-ontology, extract-class, ontology-report, and ontology-measure-essentials. It also exposes three FuXi CLI subcommands (fuxi.core for RETE diagnostics; fuxi.owl for OWL/DLP/BFP reasoning; fuxi.proof for proof and SIP graph generation) and ROBOT validation commands.
The Origin Story of a Reborn Semantic Web Reasoner and Interlocutor
What is RETE-UL and how does it relate to RDF?
What is the RETE-UL algorithm and how does it relate to the RDF triple syntax?
The SPARQL ASK goal that FuXi evaluates via Backward Fixpoint Procedure using owl:inverseOf. Data: eg:joe your:isBrotherOf eg:bob. Axiom: your:isBrotherOf owl:inverseOf your:isBrotherOf. FuXi proves eg:bob your:isBrotherOf eg:joe by backward chaining. Source: test/OWL/inverseOf/premises001.rdf
PREFIX your: <http://example.net/vocab#> PREFIX eg: <http://example.net/> # FuXi BFP goal: prove this is entailed via owl:inverseOf # fuxi.owl --method=bfp --dlp --why "ASK { eg:bob your:isBrotherOf eg:joe }" ASK { eg:bob your:isBrotherOf eg:joe . }
A meta-interpreter (Bry 1990) that compiles a ruleset and a goal into meta-interpretation rules evaluated by a forward-chaining RETE network, simulating top-down SLD resolution. Adapted by Chimezie Ogbuji for SPARQL reasoning in 2011.
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.
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.
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.
SIP strategies pass variable binding information (bound/free adornments) between rule body terms, directing search toward known access patterns. They originate from relational database research: Magic Sets (Bancilhon et al. 1985) and the power of magic (Beeri & Ramakrishnan 1987). FuXi uses SIP through its BFP meta-interpreter to efficiently evaluate recursive SPARQL queries, and fuxi.proof can render SIP collection graphs and adorned rules showing b/f adornments.
An N3 reasoner supporting backward reasoning. One of the early reasoners (alongside CWM and Pychinko) used before FuXi was created to handle larger scale reasoning.
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.
Lists ontology terms in Manchester OWL Syntax from an owlready2 SQLite file.
Chimezie Ogbuji envisions FuXi as part of a suite for building generative expert systems — systems combining traditional expert system techniques (OWL ontologies, logic rules, backward-chaining proof, PML provenance) with modern transformer-based LLMs. The FuXi series has three parts: (1) origin story and SPARQL interlocution theory (this article); (2) FuXi as SPARQL service endpoint for high-performance ontology reasoning; (3) verbalizing OWL ontologies, rules, and proofs with owl_dsl for LLM-guided expert reasoning workflows.
OWL ontology used in FuXi BFP query memoization test. Declares first:C and first:B as owl:intersectionOf sets. first:John is asserted as type first:B. FuXi's BFP dispatcher generates SPARQL sub-queries to check for OWL functional/inverse-functional properties in the EDB during reasoning.
2003 WWW paper providing a direct mapping from OWL Description Logic subsets to equivalent Horn rules. Foundational for FuXi's DLP compilation of OWL axioms into N3 rules for RETE-UL evaluation.
Description Logic Programs: Combining Logic Programs with Description Logic
A technique (Grosof et al. 2003) mapping OWL Description Logic axioms to equivalent Horn rules, enabling OWL semantics (inverseOf, TransitiveProperty) to be compiled into Logic Program rules for RETE-UL evaluation.
A Python module for manipulating OWL 2.0 ontologies using SQLite persistence. Used by the skill's ontology management tools (create-ontology, list-ontologies, verbalize-ontology-class).
A step-by-step guide to setting up and using the semantic-web-reasoner-skill and FuXi for Semantic Web ontology management, OWL reasoning, and SPARQL proof generation.
How to Use the Semantic Web Reasoner Skill with FuXi
A clinical outcomes registry at Cleveland Clinic capturing preoperative demographic data, comorbidities, operative variables, complications, and mortality for all cardiac surgery patients. The domain for which the domain interpreter architecture (and ultimately FuXi) was initially developed.
Cardiovascular Information Registry (CVIR)
Defines the Backward Fixpoint Procedure (BFP): a meta-interpreter reconciling bottom-up and top-down evaluation in recursive databases. Adopted and extended by Chimezie Ogbuji for SPARQL interlocution.
Query Evaluation in Recursive Databases: Bottom-up and Top-down Reconciled
A Python tool for verbalizing OWL ontologies into Controlled Natural Language. Renders OWL classes and properties as Manchester Syntax phrases. Used by the semantic-web-reasoner-skill for LLM-assisted ontology management.
Links a theoretical concept or algorithm to a software implementation that realises it.
Exports details about ontology entities as a tabular report file.
The skill uses owl_dsl via owlready2 to render OWL classes and properties as Controlled Natural Language phrases in Manchester Syntax. These are injected into the LLM context, enabling the agent to suggest annotation property values (e.g., IAO definition annotations), check Q&A accuracy, and generate human-readable descriptions. The verbalize-ontology-class workflow was demonstrated using the open-weight Qwen3.6-35B model on commodity hardware.
@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 ) .
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 structural reports on ontology files.
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.
University where Chimezie Ogbuji was a PhD student and Medical Informatics fellow (2011+), deepening his understanding of description logics, Godel's theorems, and formal reasoning systems.
PhD thesis describing RETE-UL: limits RETE fact syntax to 3-item tuples (matching RDF triples), adds hash tables for alpha/beta node efficiency. Foundation of FuXi's rule evaluation engine.
Production Matching for Large Learning Systems
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.
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.
FuXi CLI subcommand for OWL reasoning, DLP compilation, and BFP query answering. Supports --dlp (Description Logic Programs), --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
FuXi's fuxi.proof command generates: proof-graph-svg/png (the full SPARQL interlocution proof trace); rete-network-svg/png (the RETE-UL meta-interpreter network used for evaluation); sip-collection-svg/png (SIP binding adornments showing b=bound / f=free variables); adornment (adorned rule text); and pml (Provenance Markup Language RDF serialisation of the full proof). SVG outputs can be refined in Inkscape for publication.
What is DLP and how does FuXi compile OWL axioms?
What are Description Logic Programs (DLP) and how does FuXi use them to compile OWL axioms?
Query evaluation strategies that pass bound/free variable adornments between rule body terms, enabling efficient evaluation of recursive queries. Related to Magic Sets rewriting. Used by FuXi's BFP implementation and visualised by fuxi.proof --output sip-collection-svg.
DLP (Grosof et al. 2003) provides a direct mapping from OWL Description Logic subsets to equivalent Horn rules. FuXi uses DLP to compile OWL axioms such as owl:inverseOf and owl:TransitiveProperty into N3 Horn rules — for example, owl:inverseOf(hasBrother, isBrotherOf) compiles to two bidirectional Horn rules. These rules are then evaluated by the RETE-UL engine, operationally analogous to how meta-interpreters compile rules into equivalent Horn clauses for SPARQL interlocution.
A lightweight ontology representing the conceptual and implementation mesh between Chimezie Ogbuji's FuXi origin story article and the semantic-web-reasoner-skill GitHub repository. Bridges theoretical reasoning concepts (RETE-UL, BFP, SPARQL Interlocution) with their practical tool manifestations.
FuXi Semantic Web Reasoning Meshup Ontology
Bridges two sources: the Medium article on FuXi's origin story and the semantic-web-reasoner-skill GitHub repository.
Finds OWL classes by label pattern (string or regex) in an ontology SQLite file.
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.
Links an AI agent skill to a software tool it makes available to the agent.
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. Implements RETE-UL networks and the Backward Fixpoint Procedure for SPARQL interlocution. Version 2.0.1 released 2026.
A software tool specifically designed for Semantic Web tasks: ontology management, RDF reasoning, SPARQL querying, or OWL validation.
Academic medical center where Chimezie Ogbuji worked in the Advanced Database department of Cardiothoracic Surgery Research, developing the CVIR outcomes registry system that motivated FuXi.
The SPARQL ASK sub-query FuXi generates internally during SPARQL interlocution when checking the Extensional Database (EDB) for OWL functional and inverse-functional property axioms. FuXi's BFP meta-interpreter dispatches this query to determine whether to apply functional property rules. Source: FuXi/test/testBFPQueryMemoization.py
FuXi SPARQL Interlocution: EDB Property Check
PREFIX owl: <http://www.w3.org/2002/07/owl#> # FuXi-generated EDB sub-query during SPARQL interlocution # Checks whether any OWL functional/inverse-functional properties # exist in the EDB before applying corresponding Horn rules ASK { [] a ?KIND FILTER( ?KIND = owl:InverseFunctionalProperty || ?KIND = owl:FunctionalProperty ) }
Extracts a class and its dependencies from an OWL ontology. Input: owlFile, term, outputOwl.
Real SELECT against the URIBurner named graph that retrieves all triples whose subject is in http://example.org/ and predicate in http://example.org/terms/ — including the ABox facts and the triple FuXi RETE-UL forward-chained via rdfs:subPropertyOf.
SELECT: Superproperty Entailment from Named Graph
PREFIX exterms: <http://example.org/terms/> PREFIX exind: <http://example.org/> 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
FuXi CLI subcommand for proof and SIP graph generation. Output formats include rete-network-svg, sip-collection-svg, adornment (adorned rules), 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
What is the Open World Assumption and why does it matter for SPARQL?
What is the Open World Assumption (OWA) and why is it important for SPARQL reasoning?
Key terms spanning both the FuXi origin story article and the semantic-web-reasoner-skill GitHub repository.
FAQ: FuXi Reasoning and the Semantic Web Reasoner Skill
The BFP (Bry 1990) is a meta-interpreter that compiles a ruleset and a goal into meta-interpretation rules: evaluate-k terms trigger rule body evaluation; query-p terms assert new sub-goals; fact assertions trigger new queries. A forward-chaining RETE-UL network evaluates these rules, simulating backward-chaining SLD resolution. Chimezie Ogbuji adapted BFP for RDF, RDFS, OWL, and N3 in 2011.
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.
Informatics engineer, data scientist, inventor, and business owner. Creator of FuXi reasoner. Founder of Metacognition LLC. Former researcher at Cleveland Clinic Cardiothoracic Surgery Research and PhD student / Medical Informatics fellow at Case Western Reserve University.
What is the 'meshup' relationship between the article and the skill?
What does 'meshup' (not mashup) mean in the context of combining the FuXi article and the semantic-web-reasoner-skill?
OpenLink Software AI agent skill for generating interactive HTML infographics and Markdown companion documents from RDF knowledge graphs.
What is SPARQL interlocution and what problem does it solve?
Links a software to a predecessor system it evolved from.
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.
@prefix your: <http://example.net/vocab#> . @prefix eg: <http://example.net/> . eg:joe your:isBrotherOf eg:bob .
Links a software application to a reasoning paradigm it supports.
The historical origins of FuXi: the CVIR project at Cleveland Clinic, the extensible database patent, the Semantic Web activity period, and the progression from CWM/Euler/Pychinko to RETE-UL and the Backward Fixpoint Procedure.
An extension of BFP meta-interpretation that incorporates SPARQL service queries into the reasoning loop. Enables declarative SPARQL Entailment Regime evaluation without pre-materialising the full inference closure.
What is the vision for generative expert systems?
How does FuXi relate to the concept of generative expert systems?
FuXi CLI subcommand for forward chaining evaluation and RETE network diagnostics.
Computer scientist who defined the Backward Fixpoint Procedure (BFP) in 1990, adapted by Chimezie Ogbuji for SPARQL interlocution.
Expired patent documenting the CVIR domain interpreter architecture: a domain expert specifies a domain model as an RDF Graph, and an interpreter/logical reasoner generates data management tools — XSLT transformations, XForms, and validation documents. The system in which FuXi emerged as a reasoning component.
Extensible Database System and Method (US7836097B2)
A goal-driven inference method that works backward from a goal, identifying rules whose conclusion matches and recursively satisfying their premises. Implemented in FuXi via the Backward Fixpoint Procedure.
SPARQL SELECT demonstrating what FuXi entails via forward chaining (RETE-UL) from rdfs:subPropertyOf and owl:equivalentProperty axioms. ABox: john has_brother jack, jack brother john. TBox: has_brother subPropertyOf has_sibling, brother equivalentProperty has_brother. FuXi forward-chains to entail john has_sibling jack. Source: FuXi/test/test_superproperty_entailment.py
FuXi Forward Chaining: Superproperty Entailment
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 forward-chaining (RETE-UL) entailment via subPropertyOf + equivalentProperty: # ABox: :john exterms:has_brother :jack # :jack exterms:brother :john # TBox: exterms:has_brother rdfs:subPropertyOf exterms:has_sibling # exterms:brother owl:equivalentProperty exterms:has_brother # Entailed triple: :john exterms:has_sibling :jack SELECT ?subject ?entailedPredicate ?object WHERE { BIND(:john AS ?subject) BIND(exterms:has_sibling AS ?entailedPredicate) BIND(:jack AS ?object) }
A company founded by Chimezie Ogbuji focused on recursively introspective AI systems and semantic web technologies. The name reflects the core principle of using AI to reason about and automate aspects of how it functions.
The theoretical foundations of FuXi: RETE-UL production rule matching, the Backward Fixpoint Procedure meta-interpretation, SPARQL interlocution, Sideways Information Passing strategies, and DLP compilation of OWL axioms.
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.
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.
@prefix your: <http://example.net/vocab#> . @prefix owl: <http://www.w3.org/2002/07/owl#> . your:isBrotherOf owl:inverseOf your:isBrotherOf .
@prefix exterms: <http://example.org/terms/> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix owl: <http://www.w3.org/2002/07/owl#> . exterms:Person a rdfs:Class ; rdfs:subClassOf exterms:Agent . exterms:Agent a rdfs:Class . exterms:has_sibling a rdf:Property . exterms:has_brother a rdf:Property ; rdfs:subPropertyOf exterms:has_sibling ; rdfs:domain exterms:Person ; rdfs:range exterms:Person . exterms:brother a rdf:Property ; owl:equivalentProperty exterms:has_brother ; rdfs:domain exterms:Person ; rdfs:range exterms:Person .
A packaged set of tool definitions and routing rules deployable in an AI agent environment such as Claude Code / OpenCode.
SPARQL CONSTRUCT that materialises the triple proved by FuXi BFP via owl:inverseOf: from eg:joe your:isBrotherOf eg:bob and the owl:inverseOf axiom, FuXi derives eg:bob your:isBrotherOf eg:joe.
CONSTRUCT: owl:inverseOf Entailed Triple
PREFIX your: <http://example.net/vocab#> PREFIX eg: <http://example.net/> PREFIX owl: <http://www.w3.org/2002/07/owl#> 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 . } }
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.
A meshup creates a semantic mesh where entities from both sources share IRIs and are interconnected rather than merely mixed. The Medium article provides the theoretical and historical layer: RETE-UL, BFP, SPARQL interlocution, DLP, and OWA. The GitHub skill provides the tool layer: fuxi.owl, fuxi.proof, verbalize-ontology-class, robot, owl_dsl, riot. FuXi is the central connecting entity. Together they form an integrated knowledge graph where every theoretical concept links to its implementation and every tool links to its reasoning foundations.
What is FuXi and why is it called a 'reborn' reasoner?
What is FuXi and why is it called a 'reborn' Semantic Web reasoner?
Lists OWL ontologies saved as owlready2 SQLite files in a working directory.
Links a software application to a named algorithm or procedure it implements.
Creates an owlready2 SQLite ontology and archives provenance for later use. Input: ontologyUri, baseUri, owlFile, workingDir.
What are Sideways Information Passing strategies?
What are Sideways Information Passing (SIP) strategies and why are they important for recursive query evaluation?
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.
Verbalizes an OWL class into Controlled Natural Language using owlready2 and owl_dsl. Input: ontologyUri, sqliteFile, baseUri, classReference. Used to suggest annotation property values for ontologies like IAO.
What is the Backward Fixpoint Procedure and how does FuXi use it?
What is the Backward Fixpoint Procedure (BFP) and how does FuXi use it for backward reasoning?
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.
SPARQL DESCRIBE that retrieves all known triples about eg:joe and eg:bob from the named graph, exposing the ABox assertion and owl:inverseOf axiom that FuXi BFP backward-chains to prove eg:bob your:isBrotherOf eg:joe.
DESCRIBE: inverseOf Individuals from Named Graph
PREFIX eg: <http://example.net/> 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 . } }
Marker class for individuals from FuXi test suite sample datasets, used to demonstrate BFP backward-chaining and RETE-UL forward-chaining reasoning.
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.
How does FuXi's proof visualisation work?
What proof visualisation capabilities does FuXi provide and what formats can it generate?
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.
A variant of the RETE production rule matching algorithm adapted for 3-item tuple facts that map to RDF triples. Uses hash tables to improve alpha and beta network node efficiency. FuXi's core rule evaluation engine.
RETE-UL (from Doorenbos 1995) modifies the original RETE algorithm by limiting fact syntax to 3-item tuples, which correspond naturally to RDF triples (subject, predicate, object). It uses hash tables to improve the efficiency of alpha and beta network nodes. FuXi implements RETE-UL as its production rule evaluation engine for both forward-chaining fact derivation and meta-interpretation rule evaluation.
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.
ABox + TBox used in the FuXi BFP inverseOf entailment example. ABox asserts eg:joe isBrotherOf eg:bob. TBox declares isBrotherOf as its own owl:inverseOf. FuXi backward-chains to prove eg:bob isBrotherOf eg:joe.
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.
Computes quantitative and structural metrics about an OWL ontology: class count, property count, complexity, coverage, and more complex derived metrics.
A data-driven inference method that starts with available data and uses inference rules to derive new facts (extract more data) until a goal is reached. Used in FuXi's RETE-UL evaluation engine.
Apache Jena's RDF I/O Technology CLI. Parses, converts, and validates RDF in multiple serialization formats. Used by the semantic-web-reasoner-skill for RDF I/O operations.
A high-level approach to automated logical inference (e.g., forward chaining, backward chaining, meta-interpretation, SIP).
What tools does the semantic-web-reasoner-skill provide?
What ontology management and reasoning tools are available in the semantic-web-reasoner-skill?
An early Python N3 reasoner using the original RETE algorithm. FuXi (circa 2006) initially continued in Pychinko's footsteps before evolving to the RETE-UL variant.
Computer scientist whose 1995 PhD thesis at Carnegie Mellon University described the RETE-UL algorithm adopted by FuXi.
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.
An OpenCode / Claude skill for Semantic Web architecture and development. Uses tool-aware LLMs and VLMs, taking full advantage of reasoners and SW tools such as FuXi, robot, riot, and owl_dsl.
SPARQL interlocution extends Bry's BFP meta-interpreter by incorporating SPARQL service evaluation into the reasoning loop. It generates only relevant facts and sub-queries in response to intermediate bindings, enabling complete, sound, safely memoized bottom-up simulation of SLD resolution. It solves the problem of dynamically inferring logically entailed RDF triples under SPARQL Entailment Regimes without pre-materialising the full inference closure — analogous to how SQL views are computed on demand rather than stored.
FuXi is a Python bi-directional reasoning engine companion to RDFLib, supporting forward-chaining (RETE-UL) and backward-chaining (Backward Fixpoint Procedure). It is called 'reborn' because version 2.0.1 (2026) is a major modernisation restoring its OWL 1.1/2.0, RDF/RDFS, RIF, and SPARQL Entailment capabilities after years of dormancy, adapting to Python and rdflib changes in the interim.
ABox + TBox used in FuXi forward-chaining (RETE-UL) superproperty entailment test. ABox: john has_brother jack, jack brother john. TBox: has_brother subPropertyOf has_sibling, brother equivalentProperty has_brother. FuXi entails: john has_sibling jack.
@prefix exterms: <http://example.org/terms/> . @prefix : <http://example.org/> . :john exterms:has_brother :jack . :jack exterms:brother :john .
A logic programming technique where an interpreter for a language is written in that same language. In FuXi, the meta-interpreter compiles a ruleset and goal into RETE-UL meta-interpretation rules that drive query evaluation.
A 3-part series by Chimezie Ogbuji: (1/3) FuXi origin story and SPARQL interlocution theory; (2/3) FuXi SPARQL service and high-performance reasoning endpoint; (3/3) Verbalizing OWL ontologies, rules, and proofs with owl_dsl.
How does the skill use LLMs for ontology verbalization?
How does the semantic-web-reasoner-skill integrate LLMs into ontology verbalization and management workflows?
The OWA states that absence of a stated fact does not imply its falsehood. For SPARQL, this means a reasoning-aware implementation should return results for patterns that are logically entailed — not only those explicitly stored. Section 1.3 of the SPARQL 1.1 Entailment Regimes recommendation defines this declaratively: it specifies required answers without mandating any specific reasoning strategy (forward or backward chaining).
The semantic mesh connecting FuXi's theoretical foundations (from the Medium article) with the semantic-web-reasoner-skill's tool implementations (from GitHub), forming a fully interlinked knowledge graph where entities share IRIs across both source contexts.
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.
W3C's Notation 3 reasoner. One of the first N3 reasoners used in the CVIR project before FuXi was created.
Runs a ROBOT-powered structural and quality report on all issues with an OWL ontology file.
Finds OWL properties by label and URL pattern in an ontology SQLite file.
OpenLink Software AI agent skill for generating comprehensive RDF knowledge graphs from web content.
The OWL/RDF semantic principle that the absence of a stated fact does not imply its falsehood. SPARQL Entailment Regimes formalise this: answers include facts logically entailed by the graph, not only explicitly stored facts.