@skaterqiang/protege-js 0.1.0

package/src/inference/SWRLReasoner.js

@@ -0,0 +1,409 @@
+'use strict';
+
+// SWRL built-in evaluator + forward-chaining rule engine over TripleStore.
+// Applies each rule repeatedly: for each match of the antecedent, asserts the
+// consequent as new triples. Continues to fixpoint.
+
+const { SWRLB_NS, AtomType } = require('../model/SWRL');
+const { NS } = require('./rdf');
+const RDF = NS.RDF, RDFS = NS.RDFS, OWL = NS.OWL, XSD = NS.XSD;
+
+function isVar(t) { return t && typeof t === 'object' && t.iri && t.iri.toString && t.iri.toString().startsWith('urn:swrl:var:'); }
+function varName(t) { return t.iri.toString().slice('urn:swrl:var:'.length); }
+
+function lit(value, datatype) {
+  if (typeof value === 'string' && value.startsWith('"')) return value; // already encoded
+  if (typeof value === 'number') {
+    const dt = Number.isInteger(value) ? 'integer' : 'double';
+    return `"${value}"^^<${XSD}${dt}>`;
+  }
+  if (typeof value === 'boolean') return `"${value}"^^<${XSD}boolean>`;
+  return `"${String(value)}"^^<${XSD}string>`;
+}
+
+function parseLiteral(lex) {
+  if (typeof lex !== 'string' || !lex.startsWith('"')) return null;
+  const end = lex.lastIndexOf('"');
+  const v = lex.slice(1, end);
+  const m = lex.slice(end + 1).match(/^\^\^<([^>]+)>/);
+  const dt = m ? m[1] : null;
+  if (dt === XSD + 'integer' || dt === XSD + 'int' || dt === XSD + 'long' || dt === XSD + 'short' || dt === XSD + 'byte') return parseInt(v, 10);
+  if (dt === XSD + 'decimal' || dt === XSD + 'double' || dt === XSD + 'float') return parseFloat(v);
+  if (dt === XSD + 'boolean') return v === 'true' || v === '1';
+  return v;
+}
+
+class SWRLBuiltins {
+  static call(name, args) {
+    // args already evaluated (JS values); return boolean or assignment value
+    const n = name.startsWith(SWRLB_NS) ? name.slice(SWRLB_NS.length) : name;
+    switch (n) {
+      case 'equal': return args[0] === args[1];
+      case 'notEqual': return args[0] !== args[1];
+      case 'lessThan': return args[0] < args[1];
+      case 'lessThanOrEqual': return args[0] <= args[1];
+      case 'greaterThan': return args[0] > args[1];
+      case 'greaterThanOrEqual': return args[0] >= args[1];
+      case 'add': return args[0] + args[1];
+      case 'subtract': return args[0] - args[1];
+      case 'multiply': return args[0] * args[1];
+      case 'divide': return args[1] === 0 ? null : args[0] / args[1];
+      case 'integerDivide': return args[1] === 0 ? null : Math.floor(args[0] / args[1]);
+      case 'mod': return args[1] === 0 ? null : args[0] % args[1];
+      case 'pow': return Math.pow(args[0], args[1]);
+      case 'abs': return Math.abs(args[0]);
+      case 'ceiling': return Math.ceil(args[0]);
+      case 'floor': return Math.floor(args[0]);
+      case 'round': return Math.round(args[0]);
+      case 'roundHalfToEven': {
+        const x = args[0]; const f = Math.floor(x); const diff = x - f;
+        if (diff > 0.5) return f + 1;
+        if (diff < 0.5) return f;
+        return f % 2 === 0 ? f : f + 1;
+      }
+      case 'sqrt': return Math.sqrt(args[0]);
+      case 'sin': return Math.sin(args[0]);
+      case 'cos': return Math.cos(args[0]);
+      case 'tan': return Math.tan(args[0]);
+      case 'stringConcat': return args.slice(0, -1).join('') === args[args.length - 1] ? true : args.join('');
+      case 'substring': {
+        const s = String(args[0]); const start = args[1]; const len = args[2];
+        return s.substr(start, len);
+      }
+      case 'stringLength': return String(args[0]).length;
+      case 'normalizeSpace': return String(args[0]).trim().replace(/\s+/g, ' ');
+      case 'upperCase': return String(args[0]).toUpperCase();
+      case 'lowerCase': return String(args[0]).toLowerCase();
+      case 'contains': return String(args[0]).includes(String(args[1]));
+      case 'startsWith': return String(args[0]).startsWith(String(args[1]));
+      case 'endsWith': return String(args[0]).endsWith(String(args[1]));
+      case 'matches': return new RegExp(args[1]).test(String(args[0]));
+      case 'replace': return String(args[0]).replace(new RegExp(args[1], 'g'), String(args[2]));
+      // --- string long-tail ---
+      case 'stringEqualIgnoreCase': return String(args[0]).toLowerCase() === String(args[1]).toLowerCase();
+      case 'translate': {
+        const s = String(args[0]), from = String(args[1]), to = String(args[2]);
+        let out = '';
+        for (const ch of s) {
+          const idx = from.indexOf(ch);
+          if (idx < 0) { out += ch; continue; }
+          if (idx < to.length) out += to[idx];
+          // if from longer than to at this idx, char is deleted
+        }
+        return out;
+      }
+      case 'substringBefore': {
+        const s = String(args[0]), m = String(args[1]);
+        const i = s.indexOf(m);
+        return i < 0 ? '' : s.slice(0, i);
+      }
+      case 'substringAfter': {
+        const s = String(args[0]), m = String(args[1]);
+        const i = s.indexOf(m);
+        return i < 0 ? '' : s.slice(i + m.length);
+      }
+      // --- boolean ---
+      case 'booleanNot': return !args[0];
+      // --- list operations (lists as JS arrays) ---
+      case 'listConcat': {
+        const lists = args.slice(0, -1);
+        const result = lists.reduce((acc, l) => acc.concat(l), []);
+        const last = args[args.length - 1];
+        if (Array.isArray(last)) return JSON.stringify(result) === JSON.stringify(last) ? true : result;
+        return result;
+      }
+      case 'listIntersection': {
+        const a = Array.isArray(args[0]) ? args[0] : [];
+        const b = Array.isArray(args[1]) ? args[1] : [];
+        const inter = a.filter(x => b.includes(x));
+        if (args.length > 2 && Array.isArray(args[2])) {
+          return JSON.stringify(inter) === JSON.stringify(args[2]) ? true : inter;
+        }
+        return inter;
+      }
+      case 'listSubtraction': {
+        const a = Array.isArray(args[0]) ? args[0] : [];
+        const b = Array.isArray(args[1]) ? args[1] : [];
+        const diff = a.filter(x => !b.includes(x));
+        if (args.length > 2 && Array.isArray(args[2])) {
+          return JSON.stringify(diff) === JSON.stringify(args[2]) ? true : diff;
+        }
+        return diff;
+      }
+      case 'member': return Array.isArray(args[1]) && args[1].includes(args[0]);
+      case 'length': return Array.isArray(args[0]) ? args[0].length : 0;
+      case 'first': return Array.isArray(args[0]) && args[0].length ? args[0][0] : null;
+      case 'rest': return Array.isArray(args[0]) ? args[0].slice(1) : [];
+      case 'sublist': {
+        const list = Array.isArray(args[0]) ? args[0] : [];
+        const sub = Array.isArray(args[1]) ? args[1] : [];
+        if (!sub.length) return true;
+        outer: for (let i = 0; i + sub.length <= list.length; i++) {
+          for (let j = 0; j < sub.length; j++) if (list[i + j] !== sub[j]) continue outer;
+          return true;
+        }
+        return false;
+      }
+      case 'empty': return Array.isArray(args[0]) && args[0].length === 0;
+      default: return null;
+    }
+  }
+}
+
+// Forward-chaining SWRL execution. rule: SWRLRule; store: TripleStore.
+// atom property/class references are OWL entities with .iri (IRI instance).
+// arg values: SWRLVariable (iri urn:swrl:var:NAME), OWLNamedIndividual, or literal.
+class SWRLReasoner {
+  constructor(store) {
+    this.store = store;
+  }
+
+  /** Run rules until fixpoint. Returns number of new facts added. */
+  run(rules) {
+    let totalNew = 0;
+    let changed = true;
+    let rounds = 0;
+    while (changed && rounds++ < 200) {
+      changed = false;
+      for (const rule of rules) {
+        const newFacts = this._applyRule(rule);
+        if (newFacts > 0) { changed = true; totalNew += newFacts; }
+      }
+    }
+    return totalNew;
+  }
+
+  _applyRule(rule) {
+    // Gather all body matches via backtracking over atoms.
+    const bindings = [{}];
+    for (const atom of rule.body) {
+      const next = [];
+      for (const b of bindings) {
+        for (const nb of this._matchAtom(atom, b)) next.push(nb);
+      }
+      bindings.length = 0;
+      bindings.push(...next);
+      if (bindings.length === 0) return 0;
+    }
+    let added = 0;
+    for (const b of bindings) {
+      for (const atom of rule.head) {
+        if (this._emitAtom(atom, b)) added++;
+      }
+    }
+    return added;
+  }
+
+  _resolve(t, binding) {
+    if (isVar(t)) {
+      const k = varName(t);
+      if (k in binding) return binding[k];
+      return { var: k };
+    }
+    // OWLNamedIndividual or literal
+    if (t && t.iri) return t.iri.toString();
+    if (t && typeof t === 'object' && 'lexicalValue' in t) {
+      const dt = t.datatype ? t.datatype.iri.toString() : XSD + 'string';
+      return `"${t.lexicalValue}"^^<${dt}>`;
+    }
+    return String(t);
+  }
+
+  _bind(binding, varKey, value) {
+    if (varKey in binding) return binding[varKey] === value ? binding : null;
+    const nb = { ...binding, [varKey]: value };
+    return nb;
+  }
+
+  _matchAtom(atom, binding) {
+    const S = this.store;
+    const results = [];
+    switch (atom.type) {
+      case AtomType.CLASS: {
+        const cls = atom.classExpression && atom.classExpression.iri
+          ? atom.classExpression.iri.toString()
+          : String(atom.classExpression);
+        const arg = this._resolve(atom.arg, binding);
+        if (arg.var) {
+          // bind all instances
+          for (const [s] of S.match(null, RDF + 'type', cls)) {
+            const nb = this._bind(binding, arg.var, s);
+            if (nb) results.push(nb);
+          }
+        } else {
+          if (S.match(arg, RDF + 'type', cls).length > 0) results.push(binding);
+        }
+        return results;
+      }
+      case AtomType.OBJECT_PROPERTY: {
+        const p = atom.property.iri.toString();
+        const a1 = this._resolve(atom.arg1, binding);
+        const a2 = this._resolve(atom.arg2, binding);
+        const subjects = a1.var ? S.match(null, p, null).map(t => t[0]) : [a1];
+        for (const s of subjects) {
+          const objs = S.match(s, p, null).map(t => t[2]);
+          for (const o of objs) {
+            let nb = binding;
+            if (a1.var) { nb = this._bind(nb, a1.var, s); if (!nb) continue; }
+            if (a2.var) { nb = this._bind(nb, a2.var, o); if (!nb) continue; }
+            else if (o !== a2) continue;
+            results.push(nb);
+          }
+        }
+        return results;
+      }
+      case AtomType.DATA_PROPERTY: {
+        const p = atom.property.iri.toString();
+        const a1 = this._resolve(atom.arg1, binding);
+        const a2 = this._resolve(atom.arg2, binding);
+        const subjects = a1.var ? S.match(null, p, null).map(t => t[0]) : [a1];
+        for (const s of subjects) {
+          const objs = S.match(s, p, null).map(t => t[2]);
+          for (const o of objs) {
+            let nb = binding;
+            if (a1.var) { nb = this._bind(nb, a1.var, s); if (!nb) continue; }
+            if (a2.var) { nb = this._bind(nb, a2.var, o); if (!nb) continue; }
+            else if (o !== a2) continue;
+            results.push(nb);
+          }
+        }
+        return results;
+      }
+      case AtomType.SAME_AS: {
+        const a1 = this._resolve(atom.arg1, binding);
+        const a2 = this._resolve(atom.arg2, binding);
+        if (a1.var && a2.var) {
+          // try all sameAs pairs
+          for (const [s, , o] of S.match(null, OWL + 'sameAs', null)) {
+            const nb1 = this._bind(binding, a1.var, s);
+            if (nb1) { const nb2 = this._bind(nb1, a2.var, o); if (nb2) results.push(nb2); }
+          }
+          return results;
+        }
+        if (a1.var) {
+          const vals = S.match(null, OWL + 'sameAs', a2).map(t => t[0])
+            .concat(S.match(a2, OWL + 'sameAs', null).map(t => t[2]));
+          for (const v of vals) { const nb = this._bind(binding, a1.var, v); if (nb) results.push(nb); }
+          return results;
+        }
+        if (a2.var) {
+          const vals = S.match(null, OWL + 'sameAs', a1).map(t => t[0])
+            .concat(S.match(a1, OWL + 'sameAs', null).map(t => t[2]));
+          for (const v of vals) { const nb = this._bind(binding, a2.var, v); if (nb) results.push(nb); }
+          return results;
+        }
+        if (a1 === a2 || S.match(a1, OWL + 'sameAs', a2).length > 0 || S.match(a2, OWL + 'sameAs', a1).length > 0) {
+          results.push(binding);
+        }
+        return results;
+      }
+      case AtomType.DIFFERENT_FROM: {
+        const a1 = this._resolve(atom.arg1, binding);
+        const a2 = this._resolve(atom.arg2, binding);
+        if (a1.var || a2.var) return results; // open world: skip
+        if (a1 !== a2 && (S.match(a1, OWL + 'differentFrom', a2).length > 0 || S.match(a2, OWL + 'differentFrom', a1).length > 0)) {
+          results.push(binding);
+        }
+        return results;
+      }
+      case AtomType.BUILTIN: {
+        // Evaluate: if last arg is a variable, bind result; else check truthiness.
+        const args = atom.args.map(a => {
+          const r = this._resolve(a, binding);
+          return r;
+        });
+        // find first unbound
+        let unboundIdx = -1;
+        const values = [];
+        for (let i = 0; i < args.length; i++) {
+          if (args[i] && args[i].var) { unboundIdx = i; values.push(null); }
+          else values.push(parseLiteral(args[i]) !== null ? parseLiteral(args[i]) : args[i]);
+        }
+        if (unboundIdx === -1) {
+          // all bound: predicate form (equal, lessThan, ...)
+          const res = SWRLBuiltins.call(atom.builtin.toString(), values);
+          if (res === true) results.push(binding);
+        } else {
+          // compute builtin with all-but-last bound, bind last
+          const vals = values.slice();
+          vals.splice(unboundIdx, 1);
+          const res = SWRLBuiltins.call(atom.builtin.toString(), vals);
+          if (res !== null && res !== false && res !== true) {
+            const key = args[unboundIdx].var;
+            const dt = typeof res === 'number' ? (Number.isInteger(res) ? XSD + 'integer' : XSD + 'double') : XSD + 'string';
+            const enc = `"${res}"^^<${dt}>`;
+            const nb = this._bind(binding, key, enc);
+            if (nb) results.push(nb);
+          }
+        }
+        return results;
+      }
+      default:
+        return results;
+    }
+  }
+
+  _emitAtom(atom, binding) {
+    const S = this.store;
+    switch (atom.type) {
+      case AtomType.CLASS: {
+        const cls = atom.classExpression && atom.classExpression.iri
+          ? atom.classExpression.iri.toString()
+          : String(atom.classExpression);
+        const arg = this._resolve(atom.arg, binding);
+        if (arg.var) return false; // cannot assert unbound
+        if (S.match(arg, RDF + 'type', cls).length === 0) {
+          S.add(arg, RDF + 'type', cls);
+          return true;
+        }
+        return false;
+      }
+      case AtomType.OBJECT_PROPERTY: {
+        const p = atom.property.iri.toString();
+        const s = this._resolve(atom.arg1, binding);
+        const o = this._resolve(atom.arg2, binding);
+        if (s.var || o.var) return false;
+        if (S.match(s, p, o).length === 0) {
+          S.add(s, p, o);
+          return true;
+        }
+        return false;
+      }
+      case AtomType.DATA_PROPERTY: {
+        const p = atom.property.iri.toString();
+        const s = this._resolve(atom.arg1, binding);
+        const o = this._resolve(atom.arg2, binding);
+        if (s.var || o.var) return false;
+        if (S.match(s, p, o).length === 0) {
+          S.add(s, p, o);
+          return true;
+        }
+        return false;
+      }
+      case AtomType.SAME_AS: {
+        const a = this._resolve(atom.arg1, binding);
+        const b = this._resolve(atom.arg2, binding);
+        if (a.var || b.var) return false;
+        if (S.match(a, OWL + 'sameAs', b).length === 0) {
+          S.add(a, OWL + 'sameAs', b);
+          return true;
+        }
+        return false;
+      }
+      case AtomType.DIFFERENT_FROM: {
+        const a = this._resolve(atom.arg1, binding);
+        const b = this._resolve(atom.arg2, binding);
+        if (a.var || b.var) return false;
+        if (S.match(a, OWL + 'differentFrom', b).length === 0) {
+          S.add(a, OWL + 'differentFrom', b);
+          return true;
+        }
+        return false;
+      }
+      default:
+        return false;
+    }
+  }
+}
+
+module.exports = { SWRLReasoner, SWRLBuiltins };

package/src/inference/TripleStore.js

@@ -0,0 +1,82 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// TripleStore — an in-memory RDF triple store with simple pattern matching.
+// Triples are [subject, predicate, object] string arrays. Literals are kept
+// in a canonical lexical form like  "value"^^<datatype>  or  "value"@lang .
+// Blank nodes (anonymous class expressions) use _:bN identifiers.
+// ---------------------------------------------------------------------------
+
+const SEP = String.fromCharCode(1); // field separator safe for IRIs/literals
+
+class TripleStore {
+  constructor() {
+    this._triples = new Set();       // canonical key s+SEP+p+SEP+o
+    this._byPredicate = new Map();   // p -> Set(tripleKey)
+  }
+
+  static key(s, p, o) { return s + SEP + p + SEP + o; }
+
+  add(s, p, o) {
+    const k = TripleStore.key(String(s), String(p), String(o));
+    if (this._triples.has(k)) return false;
+    this._triples.add(k);
+    if (!this._byPredicate.has(p)) this._byPredicate.set(p, new Set());
+    this._byPredicate.get(p).add(k);
+    return true;
+  }
+
+  has(s, p, o) {
+    return this._triples.has(TripleStore.key(String(s), String(p), String(o)));
+  }
+
+  size() { return this._triples.size; }
+
+  /** All triples as [s,p,o] arrays. */
+  all() {
+    return [...this._triples].map(k => k.split(SEP));
+  }
+
+  /** Match a pattern; null fields are wildcards. Returns array of [s,p,o]. */
+  match(s = null, p = null, o = null) {
+    let candidates;
+    if (p !== null) {
+      if (!this._byPredicate.has(p)) return [];
+      candidates = [...this._byPredicate.get(p)].map(k => k.split(SEP));
+    } else {
+      candidates = this.all();
+    }
+    return candidates.filter(([ts, tp, to]) =>
+      (s === null || ts === s) && (o === null || to === o));
+  }
+
+  /** Distinct objects for a given subject+predicate. */
+  objects(s, p) {
+    return this.match(s, p, null).map(t => t[2]);
+  }
+
+  /** Distinct subjects for a given predicate+object. */
+  subjects(p, o) {
+    return this.match(null, p, o).map(t => t[0]);
+  }
+
+  /** Resolve an RDF list head to its element array (rdf:first/rdf:rest chain). */
+  listElements(head) {
+    const RDF_FIRST = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#first';
+    const RDF_REST = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#rest';
+    const RDF_NIL = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#nil';
+    const out = [];
+    let cur = head;
+    const seen = new Set();
+    while (cur && cur !== RDF_NIL && !seen.has(cur)) {
+      seen.add(cur);
+      const first = this.objects(cur, RDF_FIRST)[0];
+      if (first === undefined) break;
+      out.push(first);
+      cur = this.objects(cur, RDF_REST)[0];
+    }
+    return out;
+  }
+}
+
+module.exports = { TripleStore };

package/src/inference/rdf.js

@@ -0,0 +1,83 @@
+'use strict';
+
+// Shared RDF/OWL namespace constants and small literal helpers used by rules.
+
+const NS = Object.freeze({
+  RDF: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  RDFS: 'http://www.w3.org/2000/01/rdf-schema#',
+  OWL: 'http://www.w3.org/2002/07/owl#',
+  XSD: 'http://www.w3.org/2001/XMLSchema#'
+});
+
+const P = Object.freeze({
+  type: NS.RDF + 'type',
+  subClassOf: NS.RDFS + 'subClassOf',
+  subPropertyOf: NS.RDFS + 'subPropertyOf',
+  domain: NS.RDFS + 'domain',
+  range: NS.RDFS + 'range',
+  sameAs: NS.OWL + 'sameAs',
+  differentFrom: NS.OWL + 'differentFrom',
+  equivalentClass: NS.OWL + 'equivalentClass',
+  equivalentProperty: NS.OWL + 'equivalentProperty',
+  disjointWith: NS.OWL + 'disjointWith',
+  propertyDisjointWith: NS.OWL + 'propertyDisjointWith',
+  inverseOf: NS.OWL + 'inverseOf',
+  propertyChainAxiom: NS.OWL + 'propertyChainAxiom',
+  hasKey: NS.OWL + 'hasKey',
+  intersectionOf: NS.OWL + 'intersectionOf',
+  unionOf: NS.OWL + 'unionOf',
+  complementOf: NS.OWL + 'complementOf',
+  someValuesFrom: NS.OWL + 'someValuesFrom',
+  allValuesFrom: NS.OWL + 'allValuesFrom',
+  hasValue: NS.OWL + 'hasValue',
+  onProperty: NS.OWL + 'onProperty',
+  onClass: NS.OWL + 'onClass',
+  maxCardinality: NS.OWL + 'maxCardinality',
+  maxQualifiedCardinality: NS.OWL + 'maxQualifiedCardinality',
+  oneOf: NS.OWL + 'oneOf',
+  members: NS.OWL + 'members',
+  distinctMembers: NS.OWL + 'distinctMembers',
+  sourceIndividual: NS.OWL + 'sourceIndividual',
+  assertionProperty: NS.OWL + 'assertionProperty',
+  targetIndividual: NS.OWL + 'targetIndividual',
+  targetValue: NS.OWL + 'targetValue'
+});
+
+const C = Object.freeze({
+  Class: NS.OWL + 'Class',
+  Thing: NS.OWL + 'Thing',
+  Nothing: NS.OWL + 'Nothing',
+  ObjectProperty: NS.OWL + 'ObjectProperty',
+  DatatypeProperty: NS.OWL + 'DatatypeProperty',
+  AnnotationProperty: NS.OWL + 'AnnotationProperty',
+  FunctionalProperty: NS.OWL + 'FunctionalProperty',
+  InverseFunctionalProperty: NS.OWL + 'InverseFunctionalProperty',
+  IrreflexiveProperty: NS.OWL + 'IrreflexiveProperty',
+  SymmetricProperty: NS.OWL + 'SymmetricProperty',
+  AsymmetricProperty: NS.OWL + 'AsymmetricProperty',
+  TransitiveProperty: NS.OWL + 'TransitiveProperty',
+  AllDifferent: NS.OWL + 'AllDifferent',
+  AllDisjointClasses: NS.OWL + 'AllDisjointClasses',
+  AllDisjointProperties: NS.OWL + 'AllDisjointProperties',
+  Datatype: NS.RDFS + 'Datatype'
+});
+
+/** Is this object term a typed literal "lex"^^<dt> ? */
+function isLiteral(o) {
+  return typeof o === 'string' && o.startsWith('"');
+}
+
+/** Parse "lex"^^<dt> or "lex"@lang -> {lex, dt, lang}. */
+function parseLiteral(o) {
+  if (!isLiteral(o)) return null;
+  const m = /^"((?:[^"\\]|\\.)*)"(?:\^\^<([^>]+)>|@([A-Za-z-]+))?$/.exec(o);
+  if (!m) return { lex: o.slice(1, -1), dt: null, lang: null };
+  return { lex: m[1], dt: m[2] || null, lang: m[3] || null };
+}
+
+/** Canonical typed literal string. */
+function literal(lex, dt) {
+  return `"${lex}"^^<${dt}>`;
+}
+
+module.exports = { NS, P, C, isLiteral, parseLiteral, literal };

package/src/inference/rules/owl2el.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// inference/rules/owl2el — OWL 2 EL rule subset.
+// EL is designed for large TBoxes (classification in polynomial time). It
+// supports existential restrictions (someValuesFrom), intersection, nominals
+// are excluded. EL excludes: disjunction (unionOf), complement, allValuesFrom
+// propagation is NOT sound for classification, inverseOf, cardinality.
+// The rule subset below is sound for EL classification.
+// ---------------------------------------------------------------------------
+
+// Rule IDs from owl2rl.js that are sound for EL.
+// EL KEEPS: someValuesFrom, intersection, subClassOf, subPropertyOf chains,
+// domain/range (existential form), transitivity (via chains).
+// EL DROPS: cls-avf (allValuesFrom), cls-int1 is kept (intersection), union
+// handling, complement, equality-heavy rules are partially kept for nominals
+// but sameAs reasoning is excluded in the minimal EL profile.
+const EL_RULE_IDS = [
+  // Existential restrictions
+  'cls-svf1', 'cls-svf2',
+  // Intersection
+  'cls-int1', 'cls-int2',
+  // Class hierarchy
+  'cax-sco', 'cax-eqc1', 'cax-eqc2',
+  // Property hierarchy + chains
+  'prp-spo1', 'prp-spo2',      // spo2 = property chain
+  'prp-dom', 'prp-rng',
+  'prp-trp',                   // transitivity (EL supports it)
+  // Top/bottom
+  'cls-thing', 'cls-nothing1'
+];
+
+module.exports = { EL_RULE_IDS };

package/src/inference/rules/owl2ql.js

@@ -0,0 +1,29 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// inference/rules/owl2ql — OWL 2 QL rule subset.
+// QL is designed for query answering over large ABoxes; it supports a
+// restricted TBox (subClassOf with limited superclass forms, subPropertyOf,
+// domain/range). The sound+complete rule subset excludes equality (sameAs),
+// functional properties, and complex class expressions on the superclass side.
+// ---------------------------------------------------------------------------
+
+// Rule IDs from owl2rl.js that are sound for QL.
+// QL deliberately EXCLUDES: eq-* (equality), prp-fp/prp-ifp (functionality),
+// cax-dw (disjointness-driven inconsistency is fine to keep for consistency
+// checking but not needed for query answering), cls-* complex forms.
+const QL_RULE_IDS = [
+  // Class hierarchy
+  'cls-svf1', 'cls-svf2',      // someValuesFrom
+  'cls-avf',                   // allValuesFrom (kept: sound, cheap)
+  'cax-sco',                   // subclass inheritance of membership
+  'cax-eqc1', 'cax-eqc2',      // equivalentClass membership propagation
+  // Property hierarchy
+  'prp-spo1',                  // subPropertyOf propagation
+  'prp-dom', 'prp-rng',        // domain / range typing
+  'prp-inv1', 'prp-inv2',      // inverseOf
+  'prp-eqp1', 'prp-eqp2',      // equivalentProperty
+  'cax-adc'                    // differentIndividuals via pairwise differentFrom
+];
+
+module.exports = { QL_RULE_IDS };