@skaterqiang/protege-js 0.1.0

package/sample/case2-family-swrl.js

@@ -0,0 +1,147 @@
+'use strict';
+
+// ===========================================================================
+// 业务案例 2：家庭关系推理 —— SWRL 规则推导「叔叔」与「成年」
+// ---------------------------------------------------------------------------
+// 【业务背景】
+//   家谱/社交应用需要从一个家庭的显式关系里，自动推导出隐含亲属关系，
+//   并根据年龄自动判断是否为「成年人」，用于权限与内容分级。
+//
+// 【业务规则】
+//   1. 叔叔规则：x 的父亲/母亲是 y，y 的兄弟是 z  ⇒  z 是 x 的叔叔(hasUncle)。
+//   2. 成年规则：p 的年龄 age >= 18  ⇒  p 是 成年人(Adult)。（SWRL builtin）
+//   3. 家庭关系：hasParent 的逆关系是 hasChild（owl:inverseOf）。
+//   4. 标准本体对齐：Person ⊑ BFO material entity（人是一种物质实体）。
+//
+// 【用到的 OWL 2 能力】
+//   SWRL 规则（ClassAtom + ObjectPropertyAtom + DataPropertyAtom + BuiltInAtom）
+//   owl:inverseOf (prp-inv1/inv2) / SWRLReasoner 前向链执行
+//   BFO 顶层本体导入（Person ⊑ BFO_0000040 material entity）
+//
+// 【预期结果】
+//   - 由 alice -hasParent-> bob，bob -hasBrother-> carol，推出 alice -hasUncle-> carol。
+//   - bob 年龄 40 ⇒ 推出 bob 是 Adult；carol 年龄 12 ⇒ 不是 Adult。
+//   - alice/bob/carol 沿 BFO 层级被归因为 material entity。
+// ===========================================================================
+
+// 引入推理引擎与 SWRL 模型组件
+const fs = require('fs');                                          // 文件系统：读取 BFO 本体
+const path = require('path');                                      // 路径处理
+const { parseRDFXML } = require('../src/io/RDFXMLParser');         // RDF/XML 解析器
+const { TripleStore } = require('../src/inference/TripleStore');
+const {
+  SWRLRule, SWRLClassAtom, SWRLObjectPropertyAtom, SWRLDataPropertyAtom,
+  SWRLBuiltInAtom, SWRLVariable
+} = require('../src/model/SWRL');               // SWRL 规则模型（规则体/规则头原子）
+const { SWRLReasoner } = require('../src/inference/SWRLReasoner'); // SWRL 前向链推理机
+const { OWLClass, OWLObjectProperty, OWLDataProperty } = require('../src/model/OWLEntity'); // OWL 实体
+const { IRI } = require('../src/model/IRI');     // IRI 构造器
+const { NS } = require('../src/inference/rdf');  // 命名空间常量
+
+// 简化命名空间引用
+const RDF = NS.RDF, RDFS = NS.RDFS, OWL = NS.OWL, XSD = NS.XSD;
+// 本案例统一前缀：http://family.example.com/#
+const ex = (s) => 'http://family.example.com/#' + s;
+// BFO 标准类 IRI（顶层本体）
+const BFO_MATERIAL_ENTITY = 'http://purl.obolibrary.org/obo/BFO_0000040'; // material entity
+
+// ========== 快捷构造函数：把字符串包装成模型对象 ==========
+const cls = (s) => new OWLClass(IRI.create(ex(s)));                 // 构造 OWL 类
+const op = (s) => new OWLObjectProperty(IRI.create(ex(s)));         // 构造 OWL 对象属性
+const dp = (s) => new OWLDataProperty(IRI.create(ex(s)));           // 构造 OWL 数据属性
+const v = (n) => new SWRLVariable(IRI.create('urn:swrl:var:' + n)); // 构造 SWRL 变量 ?x ?y ?z
+const intLit = (n) => ({ lexicalValue: String(n), datatype: { iri: IRI.create(XSD + 'integer') } }); // 整数字面量
+
+// 构建知识图谱（实例 + 关系 + 逆关系声明）
+function buildStore() {
+  const s = new TripleStore();
+  // 加载 BFO 顶层本体（Person ⊑ material entity）
+  const bfoPath = path.join(__dirname, 'ontologies', 'bfo.owl');
+  const bfoOnt = parseRDFXML(fs.readFileSync(bfoPath, 'utf8'));
+  for (const ax of bfoOnt.getAxioms()) {
+    if (ax.constructor.name === 'OWLSubClassOfAxiom') {
+      const sub = typeof ax.subClass === 'string' ? ax.subClass : (ax.subClass && ax.subClass.iri && ax.subClass.iri._iri);
+      const sup = typeof ax.superClass === 'string' ? ax.superClass : (ax.superClass && ax.superClass.iri && ax.superClass.iri._iri);
+      if (sub && sup && sub.startsWith('http') && sup.startsWith('http')) s.add(sub, RDFS + 'subClassOf', sup);
+    }
+  }
+  // 声明 Person ⊑ BFO material entity
+  s.add(ex('Person'), RDFS + 'subClassOf', BFO_MATERIAL_ENTITY);
+  // 三个人物实例
+  s.add(ex('alice'), RDF + 'type', ex('Person'));
+  s.add(ex('bob'), RDF + 'type', ex('Person'));
+  s.add(ex('carol'), RDF + 'type', ex('Person'));
+  // 家庭关系：alice 的父亲是 bob；bob 的兄弟是 carol
+  s.add(ex('alice'), ex('hasParent'), ex('bob'));
+  s.add(ex('bob'), ex('hasBrother'), ex('carol'));
+  // hasParent 与 hasChild 互逆（OWL inverseOf）
+  s.add(ex('hasParent'), OWL + 'inverseOf', ex('hasChild'));
+  // 年龄（用 xsd:integer 字面量编码，与 SWRLReasoner 的字面量解析一致）
+  s.add(ex('bob'), ex('age'), '"40"^^<' + XSD + 'integer>');   // bob 40 岁
+  s.add(ex('carol'), ex('age'), '"12"^^<' + XSD + 'integer>'); // carol 12 岁
+  return s;
+}
+
+// 定义 SWRL 规则集
+function rules() {
+  const SWRLB = 'http://www.w3.org/2003/11/swrlb#'; // SWRL builtin 命名空间
+  // 规则1：叔叔规则
+  // body: Person(?x) ∧ hasParent(?x,?y) ∧ hasBrother(?y,?z)
+  // head: hasUncle(?x,?z)
+  const uncle = new SWRLRule(
+    [
+      new SWRLClassAtom(cls('Person'), v('x')),                    // ?x 是 Person
+      new SWRLObjectPropertyAtom(op('hasParent'), v('x'), v('y')), // ?x 的父亲是 ?y
+      new SWRLObjectPropertyAtom(op('hasBrother'), v('y'), v('z')) // ?y 的兄弟是 ?z
+    ],
+    [new SWRLObjectPropertyAtom(op('hasUncle'), v('x'), v('z'))]   // 推出 ?x 的叔叔是 ?z
+  );
+  // 规则2：成年规则（age >= 18 ⇒ Adult）
+  // body: Person(?p) ∧ age(?p,?a) ∧ greaterThanOrEqual(?a,18)
+  // head: Adult(?p)
+  const adult = new SWRLRule(
+    [
+      new SWRLClassAtom(cls('Person'), v('p')),                    // ?p 是 Person
+      new SWRLDataPropertyAtom(dp('age'), v('p'), v('a')),         // ?p 的年龄是 ?a
+      new SWRLBuiltInAtom(IRI.create(SWRLB + 'greaterThanOrEqual'), [v('a'), intLit(18)]) // ?a >= 18
+    ],
+    [new SWRLClassAtom(cls('Adult'), v('p'))]                      // 推出 ?p 是 Adult
+  );
+  return [uncle, adult];
+}
+
+// 执行推理并返回业务结论
+function run() {
+  const store = buildStore();
+  const reasoner = new SWRLReasoner(store);
+  reasoner.run(rules()); // 执行 SWRL 前向链推理
+
+  // 1) 叔叔推理：alice 的叔叔应是 carol
+  const uncleInferred = store.match(ex('alice'), ex('hasUncle'), ex('carol')).length === 1;
+  // 2) 成年判断：bob(40) 应是 Adult；carol(12) 不应是 Adult
+  const bobAdult = store.match(ex('bob'), RDF + 'type', ex('Adult')).length === 1;
+  const carolAdult = store.match(ex('carol'), RDF + 'type', ex('Adult')).length === 1;
+  // 3) 逆关系：hasParent 的逆是 hasChild → bob 的孩子应包含 alice
+  //    SWRLReasoner 不跑 RL 规则，单独用 OWL2RLReasoner 验证 inverseOf
+  const { OWL2RLReasoner } = require('../src/inference/OWL2RLReasoner');
+  const rl = new OWL2RLReasoner(store);
+  rl.materialize();
+  const childInferred = store.match(ex('bob'), ex('hasChild'), ex('alice')).length === 1;
+  // 4) BFO 层级归因：alice 应被归为 material entity
+  const aliceIsMaterialEntity = store.has(ex('alice'), RDF + 'type', BFO_MATERIAL_ENTITY);
+
+  return { uncleInferred, bobAdult, carolAdult, childInferred, aliceIsMaterialEntity, store };
+}
+
+// 导出供测试与复用
+module.exports = { run, buildStore, rules, ex };
+
+// 直接运行时打印业务结论
+if (require.main === module) {
+  const r = run();
+  console.log('推出 alice 的叔叔是 carol   :', r.uncleInferred);   // true
+  console.log('bob(40岁) 被判定为成年人    :', r.bobAdult);         // true
+  console.log('carol(12岁) 被判定为成年人  :', r.carolAdult, '(应为 false)'); // false
+  console.log('逆关系推出 bob 的孩子是 alice:', r.childInferred);   // true
+  console.log('alice 归为 BFO material entity:', r.aliceIsMaterialEntity); // true
+}

package/sample/case3-pharma-safety.js

@@ -0,0 +1,132 @@
+'use strict';
+
+// ===========================================================================
+// 业务案例 3：医疗用药安全 —— 药物相互作用冲突检测（OWL 2 RL 一致性）
+// ---------------------------------------------------------------------------
+// 【业务背景】
+//   医院开药系统要防止给同一病人同时开具两种「相互作用禁忌」的药物，
+//   否则会造成医疗事故。系统在开处方时做一致性校验。
+//
+// 【业务规则】
+//   1. 药物分类：阿司匹林(Aspirin) 与 华法林(Warfarin) 都是 抗凝药(Anticoagulant)。
+//   2. 抗凝药 与 抗凝增效剂(AnticoagBooster) 联合使用属禁忌 → 用 disjoint
+//      表达「安全合用(SafeCombo)」与「禁忌合用(ForbiddenCombo)」互斥。
+//   3. 病人 pat-1 的用药方案 同时被判定为 SafeCombo 与 ForbiddenCombo 时，
+//      推理机应报告本体不一致，系统据此拦截处方。
+//   4. owl:hasKey：病人用 身份证号(ssn) 唯一标识；两个 ssn 相同的病人记录
+//      应被识别为同一个人(prp-key)。
+//   5. 标准本体对齐：药物 ⊑ OGMS medication role（OGMS_0000148）。
+//
+// 【用到的 OWL 2 能力】
+//   owl:disjointWith 一致性 (cax-dw) / owl:hasKey 唯一识别 (prp-key) /
+//   rdfs:subClassOf 分类 (cax-sco) / owl:sameAs 等价合并 (eq-*) /
+//   OGMS 医学本体导入（Drug ⊑ OGMS_0000148 medication role）
+//
+// 【预期结果】
+//   - 合法用药方案一致；叠加禁忌判定后 isConsistent()=false。
+//   - 两条 ssn 相同的病人记录被 prp-key 合并为同一个体（owl:sameAs）。
+//   - 药物沿 OGMS 层级被归因为 medication role。
+// ===========================================================================
+
+// 引入推理引擎核心组件
+const fs = require('fs');                                          // 文件系统：读取 OGMS 本体
+const path = require('path');                                      // 路径处理
+const { parseRDFXML } = require('../src/io/RDFXMLParser');         // RDF/XML 解析器
+const { TripleStore } = require('../src/inference/TripleStore');      // 三元组存储
+const { OWL2RLReasoner } = require('../src/inference/OWL2RLReasoner'); // OWL 2 RL 推理机
+const { NS } = require('../src/inference/rdf');                        // 命名空间常量
+
+// 简化命名空间引用
+const RDF = NS.RDF, RDFS = NS.RDFS, OWL = NS.OWL, XSD = NS.XSD;
+// 本案例统一前缀：http://hospital.example.com/rx#
+const ex = (s) => 'http://hospital.example.com/rx#' + s;
+// OGMS 标准类 IRI
+const OGMS_MEDICATION_ROLE = 'http://purl.obolibrary.org/obo/OGMS_0000148'; // medication role
+
+// 构建知识图谱（药物分类 + 病人记录 + 用药方案）
+function buildStore() {
+  const s = new TripleStore();
+
+  // 加载 OGMS 医学本体（药物 ⊑ medication role）
+  const ogmsPath = path.join(__dirname, 'ontologies', 'ogms.owl');
+  const ogmsOnt = parseRDFXML(fs.readFileSync(ogmsPath, 'utf8'));
+  for (const ax of ogmsOnt.getAxioms()) {
+    if (ax.constructor.name === 'OWLSubClassOfAxiom') {
+      const sub = typeof ax.subClass === 'string' ? ax.subClass : (ax.subClass && ax.subClass.iri && ax.subClass.iri._iri);
+      const sup = typeof ax.superClass === 'string' ? ax.superClass : (ax.superClass && ax.superClass.iri && ax.superClass.iri._iri);
+      if (sub && sup && sub.startsWith('http') && sup.startsWith('http')) s.add(sub, RDFS + 'subClassOf', sup);
+    }
+  }
+  // 声明 Anticoagulant ⊑ OGMS medication role
+  s.add(ex('Anticoagulant'), RDFS + 'subClassOf', OGMS_MEDICATION_ROLE);
+
+  // ========== TBox：药物分类与方案约束 ==========
+  // 阿司匹林是抗凝药
+  s.add(ex('Aspirin'), RDFS + 'subClassOf', ex('Anticoagulant'));
+  // 华法林是抗凝药
+  s.add(ex('Warfarin'), RDFS + 'subClassOf', ex('Anticoagulant'));
+  // 安全合用 与 禁忌合用 互斥（disjointWith）
+  s.add(ex('SafeCombo'), OWL + 'disjointWith', ex('ForbiddenCombo'));
+  // 安全合用是用药方案的一种
+  s.add(ex('SafeCombo'), RDFS + 'subClassOf', ex('PrescriptionPlan'));
+  // 禁忌合用是用药方案的一种
+  s.add(ex('ForbiddenCombo'), RDFS + 'subClassOf', ex('PrescriptionPlan'));
+
+  // ========== hasKey：病人用 ssn 唯一标识 ==========
+  // 声明 Patient 的 hasKey 是 ssn 属性
+  s.add(ex('Patient'), OWL + 'hasKey', '_:key1');
+  // key 列表 _:key1 = ( ssn )，RDF List 结构
+  s.add('_:key1', RDF + 'first', ex('ssn'));
+  s.add('_:key1', RDF + 'rest', RDF + 'nil');
+
+  // ========== ABox：病人记录与用药方案 ==========
+  // 第一条病人记录（ssn: 110101199001011234）
+  s.add(ex('pat-record-1'), RDF + 'type', ex('Patient'));
+  s.add(ex('pat-record-1'), ex('ssn'), '"110101199001011234"^^<' + XSD + 'string>');
+  // 第二条病人记录，ssn 相同 → 应被 hasKey 识别为同一人
+  s.add(ex('pat-record-2'), RDF + 'type', ex('Patient'));
+  s.add(ex('pat-record-2'), ex('ssn'), '"110101199001011234"^^<' + XSD + 'string>');
+
+  // 一个用药方案，初始标记为安全合用
+  s.add(ex('plan-001'), RDF + 'type', ex('SafeCombo'));
+  return s;
+}
+
+// 执行推理并返回业务结论
+function run() {
+  const store = buildStore();
+  const reasoner = new OWL2RLReasoner(store);
+  reasoner.materialize(); // 执行 OWL 2 RL 物化
+
+  // 1) 初始：方案仅标记为 SafeCombo，应一致
+  const consistentBefore = reasoner.isConsistent();
+
+  // 2) hasKey 合并：两条 ssn 相同的病人记录应被识别为同一个体（owl:sameAs）
+  const merged = store.has(ex('pat-record-1'), OWL + 'sameAs', ex('pat-record-2'))
+    || store.has(ex('pat-record-2'), OWL + 'sameAs', ex('pat-record-1'));
+
+  // 3) 制造冲突：医生又开了相互作用的药，方案被追加判定为 ForbiddenCombo
+  store.add(ex('plan-001'), RDF + 'type', ex('ForbiddenCombo'));
+  const r2 = new OWL2RLReasoner(store);   // 重建推理机（因 store 已改）
+  r2.materialize();
+  const consistentAfter = r2.isConsistent(); // 现在应不一致
+  const conflictFound = r2.inconsistencies.length > 0; // 推理机应记录冲突明细
+
+  // 4) OGMS 层级归因：Anticoagulant 应被归为 medication role
+  const anticoagulantIsMedRole = store.has(ex('Anticoagulant'), RDFS + 'subClassOf', OGMS_MEDICATION_ROLE);
+
+  return { consistentBefore, merged, consistentAfter, conflictFound, anticoagulantIsMedRole, store };
+}
+
+// 导出供测试与复用
+module.exports = { run, buildStore, ex };
+
+// 直接运行时打印业务结论
+if (require.main === module) {
+  const r = run();
+  console.log('初始合法用药方案一致         :', r.consistentBefore); // true
+  console.log('相同ssn病人记录被识别为同一人:', r.merged);           // true
+  console.log('叠加禁忌后触发不一致         :', !r.consistentAfter); // true（取反后）
+  console.log('推理机报告了冲突明细         :', r.conflictFound);   // true
+  console.log('抗凝药归为 OGMS medication role:', r.anticoagulantIsMedRole); // true
+}

package/sample/case4-knowledge-publishing.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// ===========================================================================
+// 业务案例 4：知识库内容发布 —— Turtle 解析 → 本体建模 → 序列化 round-trip
+// ---------------------------------------------------------------------------
+// 【业务背景】
+//   内容团队用 Turtle 手写一份「课程知识图谱」本体（类、层级、属性、个体），
+//   发布平台要：(a) 解析为结构化本体做校验，(b) 再用序列化器导出为
+//   Turtle / Functional Syntax / RDF/XML，供下游系统消费。要求解析-导出
+//   往返（round-trip）后核心公理不丢失。
+//
+// 【业务规则】
+//   1. 类层级：编程课(ProgrammingCourse) / 数据课(DataCourse) ⊑ 课程(Course)。
+//   2. 属性：授课(teaches) 的 domain 是 讲师(Instructor)，range 是 Course。
+//   3. 个体：讲师 alice 讲授 课程 cs101。
+//   4. 前缀保真：解析时记录的 ex: 前缀，导出时应保留缩写。
+//   5. 标准本体对齐：Course ⊑ IAO document（IAO_0000310），Instructor ⊑ BFO role（BFO_0000023）。
+//
+// 【用到的 OWL 2 能力】
+//   TurtleParser / triplesToOntology 桥接 / TurtleWriter / FunctionalSyntaxWriter
+//   / RDFXMLWriter / OWLOntology 前缀保真 (addPrefix/getPrefixes)
+//   IAO 信息本体导入（Course ⊑ IAO_0000310 document）
+//
+// 【预期结果】
+//   - Turtle 解析 + 桥接得到包含类/属性/个体的本体（公理数 > 0）。
+//   - TurtleWriter 导出文本可被 TurtleParser 再次解析（round-trip）。
+//   - 三种 Writer 均产出非空且含关键标识符的文本。
+//   - Course 沿 IAO 层级被归因为 document。
+// ===========================================================================
+
+// 引入解析器与序列化器
+const fs = require('fs');                                          // 文件系统：读取 IAO 本体
+const path = require('path');                                      // 路径处理
+const { parseRDFXML } = require('../src/io/RDFXMLParser');         // RDF/XML 解析器
+const { TurtleParser } = require('../src/io/TurtleParser');            // Turtle 解析器
+const { triplesToOntology } = require('../src/io/RDFGraphToOntology'); // TripleStore → OWLOntology 桥接
+const { writeTurtle } = require('../src/io/TurtleWriter');             // Turtle 序列化器
+const { writeFunctionalSyntax } = require('../src/io/FunctionalSyntaxWriter'); // OWL Functional Syntax 序列化器
+const { writeRDFXML } = require('../src/io/RDFXMLWriter');             // RDF/XML 序列化器
+
+// ========== 输入：课程知识图谱 Turtle 文本（含 IAO 标准本体对齐） ==========
+// 内容团队手写的 Turtle，声明了类、层级、属性和个体，并挂到 IAO 标准类
+const COURSE_TTL = [
+  '@prefix ex: <http://edu.example.com/kg#> .',                      // 定义 ex 前缀
+  '@prefix owl: <http://www.w3.org/2002/07/owl#> .',                  // 定义 owl 前缀
+  '@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .',          // 定义 rdfs 前缀
+  '@prefix obo: <http://purl.obolibrary.org/obo/> .',                 // 定义 obo 前缀（OBO 标准 IRI）
+  '',
+  'ex:Course a owl:Class ; rdfs:subClassOf obo:IAO_0000310 .',        // Course ⊑ IAO document
+  'ex:ProgrammingCourse a owl:Class ; rdfs:subClassOf ex:Course .',   // ProgrammingCourse ⊑ Course
+  'ex:DataCourse a owl:Class ; rdfs:subClassOf ex:Course .',          // DataCourse ⊑ Course
+  'ex:Instructor a owl:Class ; rdfs:subClassOf obo:BFO_0000023 .',    // Instructor ⊑ BFO role
+  'ex:teaches a owl:ObjectProperty ; rdfs:domain ex:Instructor ; rdfs:range ex:Course .', // teaches 属性定义
+  'ex:alice a ex:Instructor .',                                       // alice 是讲师
+  'ex:cs101 a ex:ProgrammingCourse .',                                // cs101 是编程课
+  'ex:alice ex:teaches ex:cs101 .',                                   // alice 讲授 cs101
+  ''
+].join('\n');
+
+// 执行解析 → 建模 → 序列化 → round-trip 全流程
+function run() {
+  // 1) Turtle → TripleStore：把文本解析成三元组存储
+  const store = new TurtleParser().parse(COURSE_TTL);
+
+  // 2) TripleStore → OWLOntology：结构化桥接为 OWL 本体对象
+  const ont = triplesToOntology(store);
+  const axiomCount = ont.getAxiomCount(); // 统计公理数（应 > 0）
+
+  // 3) 前缀保真演示：发布平台记录命名空间缩写
+  ont.addPrefix('ex', 'http://edu.example.com/kg#');
+  const prefixes = ont.getPrefixes(); // 读取已记录的前缀映射
+
+  // 4) 三种序列化导出：Turtle / Functional Syntax / RDF/XML
+  const turtleOut = writeTurtle(ont);       // 导出 Turtle
+  const fsOut = writeFunctionalSyntax(ont); // 导出 OWL Functional Syntax
+  const xmlOut = writeRDFXML(ont);          // 导出 RDF/XML
+
+  // 5) round-trip：导出的 Turtle 能再次被解析，验证核心公理不丢失
+  const store2 = new TurtleParser().parse(turtleOut);
+  const ont2 = triplesToOntology(store2);
+
+  // 6) IAO 层级归因验证：Course 应被归为 IAO document
+  const courseIsDocument = turtleOut.includes('IAO_0000310');
+
+  return {
+    axiomCount,                             // 原始公理数
+    prefixes,                               // 前缀映射
+    turtleOut, fsOut, xmlOut,               // 三种导出文本
+    turtleHasCourse: turtleOut.includes('Course'),      // Turtle 导出含 Course
+    fsHasSubClass: /SubClassOf/.test(fsOut),            // FS 导出含 SubClassOf
+    xmlIsXML: xmlOut.trim().startsWith('<?xml'),        // RDF/XML 是合法 XML
+    roundTripAxiomCount: ont2.getAxiomCount(),          // round-trip 后公理数
+    roundTripOK: ont2.getAxiomCount() > 0,              // round-trip 成功标志
+    courseIsDocument                        // Course ⊑ IAO document
+  };
+}
+
+// 导出供测试与复用
+module.exports = { run, COURSE_TTL };
+
+// 直接运行时打印业务结论
+if (require.main === module) {
+  const r = run();
+  console.log('解析得到公理数         :', r.axiomCount);              // > 0
+  console.log('记录的前缀             :', JSON.stringify(r.prefixes)); // 含 ex 前缀
+  console.log('Turtle 导出含 Course   :', r.turtleHasCourse);          // true
+  console.log('FS 导出含 SubClassOf   :', r.fsHasSubClass);            // true
+  console.log('RDF/XML 导出为合法XML  :', r.xmlIsXML);                 // true
+  console.log('round-trip 后公理数    :', r.roundTripAxiomCount, '(>0 即往返成功)'); // > 0
+  console.log('Course ⊑ IAO document   :', r.courseIsDocument); // true
+}

package/sample/case5-obda-profiles.js

@@ -0,0 +1,153 @@
+'use strict';
+
+// ===========================================================================
+// 业务案例 5：企业数据集成（OBDA）—— OWL 2 QL 查询 + EL 分类 + Profile 校验
+// ---------------------------------------------------------------------------
+// 【业务背景】
+//   企业把分散的数据库统一映射到一个「领域本体」上做集成查询（OBDA：
+//   Ontology-Based Data Access）。为了在大数据量下仍高效，限定使用
+//   OWL 2 QL profile（适合查询重写）与 OWL 2 EL profile（适合大规模分类），
+//   并先用 profile 检查器确认本体没有超出对应 profile 的表达力。
+//
+// 【业务规则】
+//   1. 组织层级：正式员工(RegularEmployee) / 合同工(Contractor) ⊑ 员工(Employee)
+//      ⊑ 人员(Person)。部门(Department) 通过 employs 关联员工。
+//   2. QL 场景：查询「所有员工」时，正式员工与合同工的实例都应被召回
+//      （子类实例自动归属父类）。
+//   3. EL 场景：传递闭包 —— partOf 具有传递性，「小组 ⊑ 部门 ⊑ 公司」
+//      应推出「小组 partOf 公司」(prp-trp)。
+//   4. Profile 校验：确认该本体不含 RL/QL/EL 之外的构造。
+//   5. 标准本体对齐：Person ⊑ BFO material entity，Department ⊑ BFO object aggregate。
+//
+// 【用到的 OWL 2 能力】
+//   OWL2QLReasoner / OWL2ELReasoner / ReasonerQueries 查询 API /
+//   prp-trp 传递性 / OWL2Profiles profile 检查 (checkQL / checkEL) /
+//   BFO 顶层本体导入（Person ⊑ BFO_0000040 material entity）
+//
+// 【预期结果】
+//   - QL：查询 Employee 召回全部 3 名员工（含子类实例）。
+//   - EL：小组 partOf 公司 经传递性被推导出来。
+//   - profile 检查器对本体的违规列表可正常返回（数组）。
+//   - 员工沿 BFO 层级被归因为 material entity。
+// ===========================================================================
+
+// 引入推理引擎与 Profile 检查器
+const fs = require('fs');                                          // 文件系统：读取 BFO 本体
+const path = require('path');                                      // 路径处理
+const { parseRDFXML } = require('../src/io/RDFXMLParser');         // RDF/XML 解析器
+const { TripleStore } = require('../src/inference/TripleStore');              // 三元组存储
+const { OWL2QLReasoner, OWL2ELReasoner } = require('../src/inference/OWL2ProfileReasoners'); // QL/EL 专用推理机
+const { ReasonerQueries } = require('../src/inference/ReasonerQueries');      // 查询 API
+const { checkQL, checkEL } = require('../src/profiles/OWL2Profiles');         // QL/EL Profile 检查器
+const { triplesToOntology } = require('../src/io/RDFGraphToOntology');        // TripleStore → OWLOntology 桥接
+const { NS } = require('../src/inference/rdf');                               // 命名空间常量
+
+// 简化命名空间引用
+const RDF = NS.RDF, RDFS = NS.RDFS, OWL = NS.OWL;
+// 本案例统一前缀：http://corp.example.com/org#
+const ex = (s) => 'http://corp.example.com/org#' + s;
+// BFO 标准类 IRI
+const BFO_MATERIAL_ENTITY = 'http://purl.obolibrary.org/obo/BFO_0000040'; // material entity
+const BFO_OBJECT_AGGREGATE = 'http://purl.obolibrary.org/obo/BFO_0000027'; // object aggregate
+
+// 构建知识图谱（组织层级 + 员工实例 + partOf 传递链）
+function buildStore() {
+  const s = new TripleStore();
+
+  // 加载 BFO 顶层本体（Person ⊑ material entity，Department ⊑ object aggregate）
+  const bfoPath = path.join(__dirname, 'ontologies', 'bfo.owl');
+  const bfoOnt = parseRDFXML(fs.readFileSync(bfoPath, 'utf8'));
+  for (const ax of bfoOnt.getAxioms()) {
+    if (ax.constructor.name === 'OWLSubClassOfAxiom') {
+      const sub = typeof ax.subClass === 'string' ? ax.subClass : (ax.subClass && ax.subClass.iri && ax.subClass.iri._iri);
+      const sup = typeof ax.superClass === 'string' ? ax.superClass : (ax.superClass && ax.superClass.iri && ax.superClass.iri._iri);
+      if (sub && sup && sub.startsWith('http') && sup.startsWith('http')) s.add(sub, RDFS + 'subClassOf', sup);
+    }
+  }
+
+  // ========== TBox：类层级（含 BFO 对齐） ==========
+  // 人员 ⊑ BFO material entity
+  s.add(ex('Person'), RDFS + 'subClassOf', BFO_MATERIAL_ENTITY);
+  // 部门 ⊑ BFO object aggregate
+  s.add(ex('Department'), RDFS + 'subClassOf', BFO_OBJECT_AGGREGATE);
+  // 正式员工 ⊑ 员工
+  s.add(ex('RegularEmployee'), RDFS + 'subClassOf', ex('Employee'));
+  // 合同工 ⊑ 员工
+  s.add(ex('Contractor'), RDFS + 'subClassOf', ex('Employee'));
+  // 员工 ⊑ 人员
+  s.add(ex('Employee'), RDFS + 'subClassOf', ex('Person'));
+
+  // ========== ABox：员工实例（分散在各子类） ==========
+  s.add(ex('emp-alice'), RDF + 'type', ex('RegularEmployee')); // alice 是正式员工
+  s.add(ex('emp-bob'), RDF + 'type', ex('RegularEmployee'));   // bob 是正式员工
+  s.add(ex('emp-carol'), RDF + 'type', ex('Contractor'));      // carol 是合同工
+
+  // ========== EL 场景：partOf 传递链 ==========
+  // 声明 partOf 是传递属性
+  s.add(ex('partOf'), RDF + 'type', OWL + 'TransitiveProperty');
+  // 小组 partOf 部门
+  s.add(ex('team-ml'), ex('partOf'), ex('dept-ai'));
+  // 部门 partOf 公司
+  s.add(ex('dept-ai'), ex('partOf'), ex('company-hq'));
+  // 声明部门实例类型
+  s.add(ex('dept-ai'), RDF + 'type', ex('Department'));
+  return s;
+}
+
+// 执行 QL 查询 + EL 分类 + Profile 校验
+function run() {
+  const store = buildStore();
+
+  // --- QL：集成查询「所有员工」（子类实例自动归属父类） ---
+  const ql = new OWL2QLReasoner(store);
+  ql.materialize();                        // QL 物化
+  const qQL = new ReasonerQueries(ql);     // 查询 API
+  const allEmployees = qQL.getInstances(ex('Employee')); // 召回所有员工实例
+  const qlCarolIsEmployee = qQL.getTypes(ex('emp-carol')).includes(ex('Employee')); // carol 被归为 Employee
+  const qlCarolIsPerson = qQL.getTypes(ex('emp-carol')).includes(ex('Person'));     // carol 被归为 Person
+
+  // --- EL：传递闭包分类 ---
+  const el = new OWL2ELReasoner(store);
+  el.materialize();                        // EL 物化（含 prp-trp 传递性）
+  const teamInCompany = store.has(ex('team-ml'), ex('partOf'), ex('company-hq')); // 小组 partOf 公司
+
+  // --- Profile 校验：确认本体是否超出 QL/EL 表达力 ---
+  const ont = triplesToOntology(store);    // 桥接为 OWLOntology
+  const qlViolations = checkQL(ont);       // QL 违规列表
+  const elViolations = checkEL(ont);       // EL 违规列表
+
+  // --- BFO 层级归因：员工应被归为 material entity ---
+  const aliceIsMaterialEntity = store.has(ex('emp-alice'), RDF + 'type', BFO_MATERIAL_ENTITY);
+  const deptIsObjectAggregate = store.has(ex('dept-ai'), RDF + 'type', BFO_OBJECT_AGGREGATE);
+
+  return {
+    employeeCount: allEmployees.length,    // 召回员工数（应=3）
+    allEmployees,                          // 员工实例列表
+    qlCarolIsEmployee,                     // carol 归为 Employee
+    qlCarolIsPerson,                       // carol 归为 Person
+    teamInCompany,                         // 小组 partOf 公司被传递推出
+    qlViolationsIsArray: Array.isArray(qlViolations), // QL 校验返回数组
+    elViolationsIsArray: Array.isArray(elViolations), // EL 校验返回数组
+    qlViolationCount: qlViolations.length, // QL 违规数
+    elViolationCount: elViolations.length, // EL 违规数
+    aliceIsMaterialEntity,                 // 员工归为 BFO material entity
+    deptIsObjectAggregate,                 // 部门归为 BFO object aggregate
+    store
+  };
+}
+
+// 导出供测试与复用
+module.exports = { run, buildStore, ex };
+
+// 直接运行时打印业务结论
+if (require.main === module) {
+  const r = run();
+  console.log('QL 集成查询召回员工数      :', r.employeeCount, '(含子类实例, 应为3)'); // 3
+  console.log('  合同工 carol 归为 Employee:', r.qlCarolIsEmployee);                  // true
+  console.log('  合同工 carol 归为 Person  :', r.qlCarolIsPerson);                    // true
+  console.log('EL 传递推出 小组partOf公司  :', r.teamInCompany);                      // true
+  console.log('QL profile 校验返回数组     :', r.qlViolationsIsArray, '(违规数', r.qlViolationCount + ')'); // true
+  console.log('EL profile 校验返回数组     :', r.elViolationsIsArray, '(违规数', r.elViolationCount + ')'); // true
+  console.log('员工归为 BFO material entity :', r.aliceIsMaterialEntity); // true
+  console.log('部门归为 BFO object aggregate:', r.deptIsObjectAggregate); // true
+}