@skaterqiang/protege-js 0.1.0

package/sample/case1-ecommerce-risk.js

@@ -0,0 +1,170 @@
+'use strict';
+
+// ===========================================================================
+// 业务案例 1：电商订单风控 —— 高风险订单识别（OWL 2 RL）
+// ---------------------------------------------------------------------------
+// 【业务背景】
+//   电商平台要在下单后实时识别「高风险订单」，交给人工审核，防止欺诈。
+//
+// 【业务规则】
+//   1. 预售订单(PreOrder)、批发订单(WholesaleOrder) 都是 订单(Order) 的子类。
+//   2. 黑名单买家(BlacklistedBuyer) 是 买家(Buyer) 的一种。
+//   3. 规则：凡是被 黑名单买家 提交的订单，自动标记为 高风险订单(HighRiskOrder)。
+//      用 OWL 表达：OrderSubmittedByBlacklisted ≡ submittedBy some BlacklistedBuyer，
+//      且 OrderSubmittedByBlacklisted ⊑ HighRiskOrder。OWL 2 RL 的 cls-svf1 规则
+//      可由 someValuesFrom 限制自动推出实例归类，无需手工挂中间类型。
+//   4. 一致性约束：高风险订单 与 可信订单(TrustedOrder) 互斥（disjointWith）。
+//      若同一订单既是高风险又是可信，则本体不一致，风控系统应报警。
+//
+// 【用到的 OWL 2 能力】
+//   rdfs:subClassOf (cax-sco) / rdf:type 实例分类 (cax-eqc) /
+//   owl:someValuesFrom + owl:onProperty (cls-svf1) / owl:equivalentClass /
+//   owl:disjointWith 冲突检测 (cax-dw) / OWL2RLReasoner.materialize
+//
+// 【预期结果】
+//   - ord-001（黑名单买家下单）被自动推导为 OrderSubmittedByBlacklisted → HighRiskOrder。
+//   - 把 ord-001 同时声明为 TrustedOrder 后，reasoner.isConsistent() = false。
+// ===========================================================================
+
+// 引入推理引擎核心组件
+const { TripleStore } = require('../src/inference/TripleStore');      // 三元组存储：存放 RDF 主谓宾
+const { OWL2RLReasoner } = require('../src/inference/OWL2RLReasoner'); // OWL 2 RL 推理机：执行规则物化
+const { ReasonerQueries } = require('../src/inference/ReasonerQueries'); // 查询接口：读取推理结果
+const { NS } = require('../src/inference/rdf');                        // 命名空间常量：RDF/RDFS/OWL/XSD
+
+// 简化命名空间引用，后面拼接 IRI 用
+const RDF = NS.RDF, RDFS = NS.RDFS, OWL = NS.OWL;
+// 本案例统一前缀：http://shop.example.com/risk#
+const ex = (s) => 'http://shop.example.com/risk#' + s;
+
+// 构建知识图谱（TBox 类层级 + ABox 实例 + OWL 限制）
+function buildStore() {
+  const s = new TripleStore();
+
+  // ========== TBox：类层级与约束 ==========
+  // 预售订单是订单的子类
+  s.add(ex('PreOrder'), RDFS + 'subClassOf', ex('Order'));
+  // 批发订单是订单的子类
+  s.add(ex('WholesaleOrder'), RDFS + 'subClassOf', ex('Order'));
+  // 黑名单买家是买家的子类
+  s.add(ex('BlacklistedBuyer'), RDFS + 'subClassOf', ex('Buyer'));
+  // 高风险订单是订单的子类
+  s.add(ex('HighRiskOrder'), RDFS + 'subClassOf', ex('Order'));
+  // 高风险订单 与 可信订单 互斥（disjointWith）
+  s.add(ex('HighRiskOrder'), OWL + 'disjointWith', ex('TrustedOrder'));
+
+  // ========== ABox：实例数据 ==========
+  // 黑名单买家实例
+  s.add(ex('buyer-bad-9'), RDF + 'type', ex('BlacklistedBuyer'));
+  // ord-001 是一笔预售订单
+  s.add(ex('ord-001'), RDF + 'type', ex('PreOrder'));
+  // ord-001 由黑名单买家提交
+  s.add(ex('ord-001'), ex('submittedBy'), ex('buyer-bad-9'));
+
+  // ========== OWL 限制：业务规则形式化 ==========
+  // 核心规则：凡 submittedBy 指向某 BlacklistedBuyer 的订单 → 高风险
+  // 用 OWL someValuesFrom 表达：OrderSubmittedByBlacklisted ≡ submittedBy some BlacklistedBuyer
+  s.add(ex('OrderSubmittedByBlacklisted'), OWL + 'equivalentClass', ex('_restr_submittedByBlacklisted'));
+  // 限制：存在 submittedBy 指向 BlacklistedBuyer
+  s.add(ex('_restr_submittedByBlacklisted'), OWL + 'someValuesFrom', ex('BlacklistedBuyer'));
+  // 限制作用在 submittedBy 属性上
+  s.add(ex('_restr_submittedByBlacklisted'), OWL + 'onProperty', ex('submittedBy'));
+  // 被黑名单提交的订单 是 高风险订单 的子类
+  s.add(ex('OrderSubmittedByBlacklisted'), RDFS + 'subClassOf', ex('HighRiskOrder'));
+
+  // 一笔正常订单对照：批发订单，由普通买家提交
+  s.add(ex('ord-002'), RDF + 'type', ex('WholesaleOrder'));
+  s.add(ex('ord-002'), ex('submittedBy'), ex('buyer-good-1'));
+  s.add(ex('buyer-good-1'), RDF + 'type', ex('Buyer'));
+
+  return s;
+}
+
+// 执行推理并返回业务结论
+function run() {
+  // 构建知识图谱
+  const store = buildStore();
+
+  // 保存原始输入三元组快照（推理前），供打印输入区使用
+  const inputTriples = store.match(null, null, null).map(t => [t[0], t[1], t[2]]);
+
+  // 创建 OWL 2 RL 推理机并执行物化（把所有能推出的三元组都算出来）
+  const reasoner = new OWL2RLReasoner(store);
+  reasoner.materialize();
+
+  // 创建查询接口，读取推理结果
+  const q = new ReasonerQueries(reasoner);
+
+  // 1) ord-001 应被归类为 HighRiskOrder（经由 someValuesFrom → OrderSubmittedByBlacklisted ⊑ HighRiskOrder）
+  const isHighRisk = q.getTypes(ex('ord-001')).includes(ex('HighRiskOrder'));
+
+  // 2) ord-001 同时是 Order（PreOrder ⊑ Order，且 HighRiskOrder ⊑ Order）
+  const isOrder = q.getTypes(ex('ord-001')).includes(ex('Order'));
+
+  // 3) 正常订单 ord-002 不应是 HighRiskOrder（对照组）
+  const ord2HighRisk = q.getTypes(ex('ord-002')).includes(ex('HighRiskOrder'));
+
+  // 4) 黑名单买家被归类为 Buyer（BlacklistedBuyer ⊑ Buyer）
+  const badIsBuyer = q.getTypes(ex('buyer-bad-9')).includes(ex('Buyer'));
+
+  // 5) 一致性检查：此时本体应当一致（没有把 ord-001 同时声明为 TrustedOrder）
+  const consistentBefore = reasoner.isConsistent();
+
+  // 6) 制造冲突：把 ord-001 错误地标为 TrustedOrder → 应触发 disjoint 冲突
+  store.add(ex('ord-001'), RDF + 'type', ex('TrustedOrder'));
+  const r2 = new OWL2RLReasoner(store);   // 重建推理机（因 store 已改）
+  r2.materialize();
+  const consistentAfter = r2.isConsistent(); // 现在应不一致
+
+  // 返回所有业务结论 + 查询接口 + 原始输入快照
+  return { isHighRisk, isOrder, ord2HighRisk, badIsBuyer, consistentBefore, consistentAfter, q, store, inputTriples };
+}
+
+// 导出供测试与复用
+module.exports = { run, buildStore, ex };
+
+// ===========================================================================
+// 直接运行时（node sample/case1-ecommerce-risk.js）打印详细输入/输出
+// ===========================================================================
+if (require.main === module) {
+  const r = run();
+
+  // 本案例命名空间前缀，用于缩短打印
+  const EX = 'http://shop.example.com/risk#';
+  // 把完整 IRI 缩成 ex:ClassName 形式
+  const short = (iri) => (typeof iri === 'string' ? iri.replace(EX, 'ex:') : iri);
+  // 只保留业务相关三元组：过滤掉推理机自动生成的 sameAs 噪音
+  const bizOnly = ([s, p, o]) =>
+    [s, p, o].every(x => typeof x === 'string') &&   // 三元组都是字符串
+    (s.startsWith(EX) || o.startsWith(EX)) &&         // 主语或宾语在本案例命名空间
+    !p.includes('sameAs');                            // 排除 sameAs 自反噪音
+
+  // ========== 打印输入：TBox + ABox 原始三元组 ==========
+  console.log('================ 输入（TBox 类层级 + ABox 实例）================');
+  for (const [s, p, o] of r.inputTriples) {
+    if (bizOnly([s, p, o])) {
+      // 把命名空间缩写成常用前缀
+      const pp = p.replace('http://www.w3.org/1999/02/22-rdf-syntax-ns#', 'rdf:')
+                  .replace('http://www.w3.org/2000/01/rdf-schema#', 'rdfs:')
+                  .replace('http://www.w3.org/2002/07/owl#', 'owl:');
+      console.log('  ', short(s), pp, short(o));
+    }
+  }
+
+  // ========== 打印推理后：各实例被归类的类型 ==========
+  console.log('\n================ 推理后：各实例被归类的类型 ================');
+  for (const inst of ['ord-001', 'ord-002', 'buyer-bad-9', 'buyer-good-1']) {
+    // 只保留本案例命名空间的类型，过滤掉 owl:Thing 等顶层噪音
+    const types = r.q.getTypes(ex(inst)).filter(t => t.startsWith(EX)).map(short);
+    console.log('  ', short(ex(inst)), '→', types.join(', '));
+  }
+
+  // ========== 打印业务结论 ==========
+  console.log('\n================ 业务结论 ================');
+  console.log('ord-001 被识别为高风险订单 :', r.isHighRisk);       // true
+  console.log('ord-001 仍是合法订单       :', r.isOrder);          // true
+  console.log('ord-002 被误判为高风险     :', r.ord2HighRisk, '(应为 false)'); // false
+  console.log('黑名单买家被归类为 Buyer   :', r.badIsBuyer);       // true
+  console.log('冲突前本体一致             :', r.consistentBefore); // true
+  console.log('误标可信后触发不一致告警   :', !r.consistentAfter); // true（取反后）
+}

package/sample/case10-ecommerce-customer-service.js

@@ -0,0 +1,454 @@
+'use strict';
+
+// ===========================================================================
+// 业务案例 10：电商客服智能工单分派 —— 真实 BFO/IAO 本体 + SWRL 技能路由
+// ---------------------------------------------------------------------------
+// 【业务背景】
+//   某电商平台客服中心每天收到数千条客户工单（退换货/物流投诉/支付问题），
+//   需要按「问题类型 + 客户等级 + 时效要求」自动分派到合适的客服技能组，
+//   并自动生成处理 SLA 承诺（金牌客户 4 小时响应、普通客户 24 小时响应）。
+//   本案例把客服业务实体挂到真实公开标准本体上：
+//     - Customer / ServiceAgent / ServiceOrder（客户/客服/工单）
+//       → BFO_0000040 material entity（物质实体）
+//     - RoutingPlan（分派方案）→ IAO_0000104 plan specification（计划规范）
+//     - SLASpecification（时效承诺）→ IAO_0000033 directive information entity
+//     - RoutingLog（分派日志）→ IAO_0000310 document（文档）
+//     - IssueCategory / SkillGroup（问题分类/技能组）→ BFO_0000031 GDC
+//   SWRL 规则把「金牌客户 + 高优先级工单」自动路由到「金牌客服组」，
+//   RL 推理沿 BFO 层级把工单归因为 material entity。
+//
+// 【业务规则】
+//   1. 客户分级：金牌客户(GoldCustomer) / 普通客户(RegularCustomer)。
+//   2. 工单分类：退换货(ReturnExchange) / 物流(Logistics) / 支付(Payment)。
+//   3. 技能组：金牌客服组(GoldTeam) / 通用客服组(GeneralTeam)。
+//   4. SWRL 路由：GoldCustomer(?c) ∧ submitOrder(?c,?o) ∧ Priority(?o,high)
+//      ⇒ routeTo(?o, GoldTeam)。
+//   5. RL 归因：工单/客户/客服沿 BFO 层级归为 material entity。
+//   6. 一致性：同一工单不能同时 routeTo GoldTeam 与 GeneralTeam（disjoint）。
+//
+// 【扩展场景：知识图谱在电商客服中的深度应用】
+//   除基础工单分类/路由外，本案例还覆盖以下真实业务场景：
+//
+//   场景A 根因分析（Root Cause Analysis）：
+//     工单→订单→SKU→批次→供应商，当某批次商品集中投诉时，沿图谱边
+//     批量圈出所有受影响工单，定位质量根因并触发下架整改。
+//     SWRL规则：Ticket(?t) ∧ hasRootCause(?t,?batch) ∧ DefectBatch(?batch)
+//              ⇒ BatchAlert(?t)。
+//
+//   场景B 投诉升级预测（Escalation Risk Prediction）：
+//     高价值客户+情绪激动+重复进线+敏感问题类型 → 预测升级为舆情/监管投诉，
+//     自动触发危机预案并升级专家组。SWRL规则：GoldCustomer(?c) ∧ Angry(?c)
+//     ∧ RepeatTicket(?t) ∧ SensitiveType(?t) ⇒ EscalationRisk(?t)。
+//
+//   场景C 跨渠道问题关联（Cross-Channel Issue Linking）：
+//     同一客户在App/电话/微博多渠道反复反馈同一问题，经OneID实体对齐
+//     串成一条问题主线，客服可看到完整时间线，实现「问题只描述一次」。
+//     OWL2RL transitive：sameIssueAs传递关联跨渠道同源工单。
+//
+// 【用到的 OWL 2 能力】
+//   真实 BFO/IAO 本体加载（parseRDFXML）/ SWRL 技能路由规则（ClassAtom +
+//   ObjectPropertyAtom + BuiltInAtom）/ SWRL 根因分析规则 / SWRL 升级预测规则 /
+//   OWL 2 RL disjoint 一致性 (cax-dw) / OWL 2 RL transitive (prp-trp) /
+//   writeRDFXML 导出工单分派记录 / RO-core has_participant 关联
+//
+// 【预期结果】
+//   - 金牌客户工单被 SWRL 路由到 GoldTeam，普通客户到 GeneralTeam。
+//   - 工单沿 BFO 层级归因为 material entity；分派方案归为 IAO plan specification。
+//   - 误标 GoldTeam+GeneralTeam 的工单触发 disjoint 不一致告警。
+//   - 批次缺陷工单一键圈出（场景A根因分析）。
+//   - 高危投诉自动标记升级风险（场景B升级预测）。
+//   - 跨渠道同源工单传递关联（场景C问题关联）。
+// ===========================================================================
+
+// 引入解析器、推理机与 SWRL 模型组件
+const fs = require('fs');                                          // 文件系统：读取真实 OWL 文件
+const path = require('path');                                      // 路径处理
+const { parseRDFXML } = require('../src/io/RDFXMLParser');         // RDF/XML 解析器：加载 BFO/IAO
+const { writeRDFXML } = require('../src/io/RDFXMLWriter');         // RDF/XML 序列化器：导出工单记录
+const { TurtleParser } = require('../src/io/TurtleParser');        // Turtle 解析器：解析客服数据
+const { triplesToOntology } = require('../src/io/RDFGraphToOntology'); // TripleStore → OWLOntology
+const { TripleStore } = require('../src/inference/TripleStore');   // 三元组存储
+const { OWL2RLReasoner } = require('../src/inference/OWL2RLReasoner'); // OWL 2 RL 推理机
+const { SWRLReasoner } = require('../src/inference/SWRLReasoner'); // SWRL 前向链推理机
+const {
+  SWRLRule, SWRLClassAtom, SWRLObjectPropertyAtom, SWRLDataPropertyAtom,
+  SWRLBuiltInAtom, SWRLVariable
+} = require('../src/model/SWRL');                                  // SWRL 规则模型
+const { OWLClass, OWLObjectProperty, OWLDataProperty, OWLNamedIndividual } = 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;
+// 真实 OWL 文件所在目录：sample/ontologies/
+const ONT_DIR = path.join(__dirname, 'ontologies');
+// 本案例统一前缀：http://ecommerce.example.com/cs#
+const ex = (s) => 'http://ecommerce.example.com/cs#' + s;
+// BFO 标准类 IRI（顶层本体）
+const BFO_MATERIAL_ENTITY = 'http://purl.obolibrary.org/obo/BFO_0000040'; // material entity
+const BFO_GDC = 'http://purl.obolibrary.org/obo/BFO_0000031';            // generically dependent continuant
+// IAO 标准类 IRI（信息构件本体）
+const IAO_PLAN_SPEC = 'http://purl.obolibrary.org/obo/IAO_0000104';      // plan specification
+const IAO_DIE = 'http://purl.obolibrary.org/obo/IAO_0000033';            // directive information entity
+const IAO_DOCUMENT = 'http://purl.obolibrary.org/obo/IAO_0000310';       // document
+// RO-core 标准关系 IRI
+const RO_HAS_PARTICIPANT = 'http://purl.obolibrary.org/obo/RO_0000057';  // has participant
+
+// 加载真实本体的类层级到 TripleStore
+function loadHierarchy(ontPath) {
+  const ont = parseRDFXML(fs.readFileSync(ontPath, 'utf8'));
+  const store = new TripleStore();
+  for (const ax of ont.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')) {
+        store.add(sub, RDFS + 'subClassOf', sup);
+      }
+    }
+  }
+  return store;
+}
+
+// 电商客服业务数据（挂到真实 BFO/IAO 标准父类）
+function buildCSStore() {
+  const s = new TripleStore();
+
+  // 加载真实 BFO 类层级
+  const bfoStore = loadHierarchy(path.join(ONT_DIR, 'bfo.owl'));
+  for (const [sub, p, sup] of bfoStore.match(null, RDFS + 'subClassOf', null)) {
+    s.add(sub, p, sup);
+  }
+
+  // ========== TBox：客服业务类（含标准本体对齐） ==========
+  // 客户 ⊑ BFO material entity
+  s.add(ex('Customer'), RDFS + 'subClassOf', BFO_MATERIAL_ENTITY);
+  // 金牌客户 ⊑ 客户
+  s.add(ex('GoldCustomer'), RDFS + 'subClassOf', ex('Customer'));
+  // 普通客户 ⊑ 客户
+  s.add(ex('RegularCustomer'), RDFS + 'subClassOf', ex('Customer'));
+  // 客服 ⊑ BFO material entity
+  s.add(ex('ServiceAgent'), RDFS + 'subClassOf', BFO_MATERIAL_ENTITY);
+  // 工单 ⊑ BFO material entity
+  s.add(ex('ServiceOrder'), RDFS + 'subClassOf', BFO_MATERIAL_ENTITY);
+  // 问题分类 ⊑ BFO GDC（分类是一种信息实体）
+  s.add(ex('IssueCategory'), RDFS + 'subClassOf', BFO_GDC);
+  // 技能组 ⊑ BFO GDC
+  s.add(ex('SkillGroup'), RDFS + 'subClassOf', BFO_GDC);
+  // 分派方案 ⊑ IAO plan specification
+  s.add(ex('RoutingPlan'), RDFS + 'subClassOf', IAO_PLAN_SPEC);
+  // SLA 承诺 ⊑ IAO directive information entity
+  s.add(ex('SLASpecification'), RDFS + 'subClassOf', IAO_DIE);
+  // 分派日志 ⊑ IAO document
+  s.add(ex('RoutingLog'), RDFS + 'subClassOf', IAO_DOCUMENT);
+  // 批次告警标记类（场景A根因分析用）
+  s.add(ex('BatchAlert'), RDF + 'type', OWL + 'Class');
+  s.add(ex('BatchAlert'), RDFS + 'subClassOf', BFO_GDC);
+
+  // 金牌客服组工单 与 通用客服组工单 互斥（同一工单不能同时属于两类）
+  s.add(ex('GoldTeamOrder'), OWL + 'disjointWith', ex('GeneralTeamOrder'));
+  s.add(ex('GoldTeamOrder'), RDFS + 'subClassOf', ex('ServiceOrder'));
+  s.add(ex('GeneralTeamOrder'), RDFS + 'subClassOf', ex('ServiceOrder'));
+
+  // 对象属性
+  s.add(ex('submitOrder'), RDF + 'type', OWL + 'ObjectProperty');
+  s.add(ex('routeTo'), RDF + 'type', OWL + 'ObjectProperty');
+  s.add(ex('hasIssue'), RDF + 'type', OWL + 'ObjectProperty');
+  s.add(ex('belongsToTeam'), RDF + 'type', OWL + 'ObjectProperty');
+  // 场景A/B/C 扩展属性
+  s.add(ex('hasRootCause'), RDF + 'type', OWL + 'ObjectProperty');   // 工单→根因批次
+  s.add(ex('suppliedBy'), RDF + 'type', OWL + 'ObjectProperty');     // 批次→供应商
+  s.add(ex('fromChannel'), RDF + 'type', OWL + 'ObjectProperty');    // 工单→渠道
+  s.add(ex('sameIssueAs'), RDF + 'type', OWL + 'ObjectProperty');    // 工单→同源工单
+  // 数据属性：优先级（gold=1, normal=2）
+  s.add(ex('priority'), RDF + 'type', OWL + 'DatatypeProperty');
+
+  // ========== ABox：客户/工单/技能组实例 ==========
+  // 金牌客户
+  s.add(ex('cust-gold-001'), RDF + 'type', ex('GoldCustomer'));
+  // 普通客户
+  s.add(ex('cust-normal-002'), RDF + 'type', ex('RegularCustomer'));
+  // 金牌客户提交的工单（优先级 1=高）
+  s.add(ex('order-gold-001'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('cust-gold-001'), ex('submitOrder'), ex('order-gold-001'));
+  s.add(ex('order-gold-001'), ex('priority'), '"1"^^<' + XSD + 'integer>');
+  // 普通客户提交的工单（优先级 2=普通）
+  s.add(ex('order-normal-002'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('cust-normal-002'), ex('submitOrder'), ex('order-normal-002'));
+  s.add(ex('order-normal-002'), ex('priority'), '"2"^^<' + XSD + 'integer>');
+  // 技能组实例
+  s.add(ex('team-gold'), RDF + 'type', ex('GoldTeam'));
+  s.add(ex('team-general'), RDF + 'type', ex('GeneralTeam'));
+  // 客服属于技能组
+  s.add(ex('agent-alice'), ex('belongsToTeam'), ex('team-gold'));
+  s.add(ex('agent-bob'), ex('belongsToTeam'), ex('team-general'));
+  // RO-core 关联：分派过程 has participant 客服
+  s.add(ex('routing-process-001'), RO_HAS_PARTICIPANT, ex('agent-alice'));
+
+  // ========== 场景A：根因分析（批次→供应商→受影响工单） ==========
+  // 缺陷批次类
+  s.add(ex('DefectBatch'), RDF + 'type', OWL + 'Class');
+  s.add(ex('DefectBatch'), RDFS + 'subClassOf', BFO_GDC);
+  // 批次实例
+  s.add(ex('batch-2024-08'), RDF + 'type', ex('DefectBatch'));
+  // 工单根因：ticket → batch
+  s.add(ex('ticket-rc-001'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('ticket-rc-001'), ex('hasRootCause'), ex('batch-2024-08'));
+  s.add(ex('ticket-rc-002'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('ticket-rc-002'), ex('hasRootCause'), ex('batch-2024-08'));
+  s.add(ex('ticket-rc-003'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('ticket-rc-003'), ex('hasRootCause'), ex('batch-normal-01')); // 正常批次
+  // 批次→供应商
+  s.add(ex('supplier-x'), RDF + 'type', BFO_MATERIAL_ENTITY);
+  s.add(ex('batch-2024-08'), ex('suppliedBy'), ex('supplier-x'));
+
+  // ========== 场景B：投诉升级预测（情绪+重复+敏感+高价值） ==========
+  // 情绪标签
+  s.add(ex('Angry'), RDF + 'type', OWL + 'Class');
+  // 敏感问题类型
+  s.add(ex('SensitiveType'), RDF + 'type', OWL + 'Class');
+  s.add(ex('SensitiveType'), RDFS + 'subClassOf', ex('IssueCategory'));
+  // 升级风险标记
+  s.add(ex('EscalationRisk'), RDF + 'type', OWL + 'Class');
+  s.add(ex('EscalationRisk'), RDFS + 'subClassOf', BFO_GDC);
+  // 高危客户：金牌+情绪激动
+  s.add(ex('cust-vip-angry'), RDF + 'type', ex('GoldCustomer'));
+  s.add(ex('cust-vip-angry'), RDF + 'type', ex('Angry'));
+  // 重复进线工单（7天内第3次）
+  s.add(ex('ticket-esc-001'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('cust-vip-angry'), ex('submitOrder'), ex('ticket-esc-001'));
+  s.add(ex('ticket-esc-001'), ex('priority'), '"1"^^<' + XSD + 'integer>');
+  s.add(ex('ticket-esc-001'), ex('hasIssue'), ex('sensitive-food'));
+  s.add(ex('sensitive-food'), RDF + 'type', ex('SensitiveType'));
+  // 重复工单标记（sameIssueAs 传递关联）
+  s.add(ex('ticket-esc-001'), ex('sameIssueAs'), ex('ticket-esc-002'));
+  s.add(ex('ticket-esc-002'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('ticket-esc-002'), ex('sameIssueAs'), ex('ticket-esc-003'));
+  s.add(ex('ticket-esc-003'), RDF + 'type', ex('ServiceOrder'));
+
+  // ========== 场景C：跨渠道问题关联（OneID + sameIssueAs传递） ==========
+  // 渠道
+  s.add(ex('channel-app'), RDF + 'type', BFO_GDC);
+  s.add(ex('channel-phone'), RDF + 'type', BFO_GDC);
+  s.add(ex('channel-weibo'), RDF + 'type', BFO_GDC);
+  // 同一客户多渠道工单
+  s.add(ex('ticket-app-001'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('ticket-app-001'), ex('fromChannel'), ex('channel-app'));
+  s.add(ex('ticket-app-001'), ex('sameIssueAs'), ex('ticket-phone-001'));
+  s.add(ex('ticket-phone-001'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('ticket-phone-001'), ex('fromChannel'), ex('channel-phone'));
+  s.add(ex('ticket-phone-001'), ex('sameIssueAs'), ex('ticket-weibo-001'));
+  s.add(ex('ticket-weibo-001'), RDF + 'type', ex('ServiceOrder'));
+  s.add(ex('ticket-weibo-001'), ex('fromChannel'), ex('channel-weibo'));
+  // sameIssueAs 声明为传递属性（OWL 2 RL prp-trp）
+  s.add(ex('sameIssueAs'), RDF + 'type', OWL + 'TransitiveProperty');
+
+  return s;
+}
+
+// SWRL 路由规则：金牌客户 + 高优先级工单 → 路由到金牌客服组
+function routingRules() {
+  const cls = (s) => new OWLClass(IRI.create(ex(s)));
+  const op = (s) => new OWLObjectProperty(IRI.create(ex(s)));
+  const dp = (s) => new OWLDataProperty(IRI.create(ex(s)));
+  const ind = (s) => new OWLNamedIndividual(IRI.create(ex(s)));
+  const v = (n) => new SWRLVariable(IRI.create('urn:swrl:var:' + n));
+  const intLit = (n) => ({ lexicalValue: String(n), datatype: { iri: IRI.create(XSD + 'integer') } });
+  const SWRLB = 'http://www.w3.org/2003/11/swrlb#';
+
+  // 规则1：金牌客户 + 优先级=1 → 路由到金牌客服组
+  // body: GoldCustomer(?c) ∧ submitOrder(?c,?o) ∧ priority(?o,1)
+  // head: routeTo(?o, team-gold)
+  const goldRoute = new SWRLRule(
+    [
+      new SWRLClassAtom(cls('GoldCustomer'), v('c')),
+      new SWRLObjectPropertyAtom(op('submitOrder'), v('c'), v('o')),
+      new SWRLDataPropertyAtom(dp('priority'), v('o'), intLit(1))
+    ],
+    [new SWRLObjectPropertyAtom(op('routeTo'), v('o'), ind('team-gold'))]
+  );
+
+  // 规则2：普通客户 + 优先级>=2 → 路由到通用客服组
+  // body: RegularCustomer(?c) ∧ submitOrder(?c,?o) ∧ priority(?o,?p) ∧ greaterThanOrEqual(?p,2)
+  // head: routeTo(?o, team-general)
+  const normalRoute = new SWRLRule(
+    [
+      new SWRLClassAtom(cls('RegularCustomer'), v('c')),
+      new SWRLObjectPropertyAtom(op('submitOrder'), v('c'), v('o')),
+      new SWRLDataPropertyAtom(dp('priority'), v('o'), v('p')),
+      new SWRLBuiltInAtom(IRI.create(SWRLB + 'greaterThanOrEqual'), [v('p'), intLit(2)])
+    ],
+    [new SWRLObjectPropertyAtom(op('routeTo'), v('o'), ind('team-general'))]
+  );
+
+  return [goldRoute, normalRoute];
+}
+
+// SWRL 根因分析规则：批次缺陷 → 批量圈出受影响工单
+function rootCauseRules() {
+  const cls = (s) => new OWLClass(IRI.create(ex(s)));
+  const op = (s) => new OWLObjectProperty(IRI.create(ex(s)));
+  const v = (n) => new SWRLVariable(IRI.create('urn:swrl:var:' + n));
+
+  // 规则3：工单根因是缺陷批次 → 标记为批次告警
+  // body: ServiceOrder(?t) ∧ hasRootCause(?t,?b) ∧ DefectBatch(?b)
+  // head: BatchAlert(?t)
+  const batchAlert = new SWRLRule(
+    [
+      new SWRLClassAtom(cls('ServiceOrder'), v('t')),
+      new SWRLObjectPropertyAtom(op('hasRootCause'), v('t'), v('b')),
+      new SWRLClassAtom(cls('DefectBatch'), v('b'))
+    ],
+    [new SWRLClassAtom(cls('BatchAlert'), v('t'))]
+  );
+
+  return [batchAlert];
+}
+
+// SWRL 升级预测规则：高价值+情绪+重复+敏感 → 升级风险
+function escalationRules() {
+  const cls = (s) => new OWLClass(IRI.create(ex(s)));
+  const op = (s) => new OWLObjectProperty(IRI.create(ex(s)));
+  const v = (n) => new SWRLVariable(IRI.create('urn:swrl:var:' + n));
+
+  // 规则4：金牌客户 ∧ 情绪激动 ∧ 重复工单 ∧ 敏感类型 → 升级风险
+  // body: GoldCustomer(?c) ∧ Angry(?c) ∧ submitOrder(?c,?t) ∧
+  //       sameIssueAs(?t,?t2) ∧ hasIssue(?t,?issue) ∧ SensitiveType(?issue)
+  // head: EscalationRisk(?t)
+  const escalation = new SWRLRule(
+    [
+      new SWRLClassAtom(cls('GoldCustomer'), v('c')),
+      new SWRLClassAtom(cls('Angry'), v('c')),
+      new SWRLObjectPropertyAtom(op('submitOrder'), v('c'), v('t')),
+      new SWRLObjectPropertyAtom(op('sameIssueAs'), v('t'), v('t2')),
+      new SWRLObjectPropertyAtom(op('hasIssue'), v('t'), v('issue')),
+      new SWRLClassAtom(cls('SensitiveType'), v('issue'))
+    ],
+    [new SWRLClassAtom(cls('EscalationRisk'), v('t'))]
+  );
+
+  // 规则5：关联工单也传递升级风险（sameIssueAs 对称）
+  // body: EscalationRisk(?t1) ∧ sameIssueAs(?t1,?t2)
+  // head: EscalationRisk(?t2)
+  const escalatePropagate = new SWRLRule(
+    [
+      new SWRLClassAtom(cls('EscalationRisk'), v('t1')),
+      new SWRLObjectPropertyAtom(op('sameIssueAs'), v('t1'), v('t2'))
+    ],
+    [new SWRLClassAtom(cls('EscalationRisk'), v('t2'))]
+  );
+
+  return [escalation, escalatePropagate];
+}
+
+// 执行真实本体加载、SWRL 路由、RL 推理与导出
+function run() {
+  const store = buildCSStore();
+
+  // 1) SWRL 路由：金牌/普通客户工单分派到对应技能组
+  const swrl = new SWRLReasoner(store);
+  const newFacts = swrl.run(routingRules());
+
+  // 验证路由结果
+  const goldRouted = store.has(ex('order-gold-001'), ex('routeTo'), ex('team-gold'));     // 金牌工单→金牌组
+  const normalRouted = store.has(ex('order-normal-002'), ex('routeTo'), ex('team-general')); // 普通工单→通用组
+
+  // 2) RL 推理：沿 BFO 层级归因
+  const rl = new OWL2RLReasoner(store);
+  rl.materialize();
+  const orderIsMaterialEntity = store.has(ex('order-gold-001'), RDF + 'type', BFO_MATERIAL_ENTITY); // 工单→material entity
+  const custIsMaterialEntity = store.has(ex('cust-gold-001'), RDF + 'type', BFO_MATERIAL_ENTITY);   // 客户→material entity
+  const planIsPlanSpec = store.has(ex('RoutingPlan'), RDFS + 'subClassOf', IAO_PLAN_SPEC);          // 分派方案→plan specification
+  const slaIsDIE = store.has(ex('SLASpecification'), RDFS + 'subClassOf', IAO_DIE);                 // SLA→directive information entity
+  const logIsDocument = store.has(ex('RoutingLog'), RDFS + 'subClassOf', IAO_DOCUMENT);             // 日志→document
+
+  // 3) 一致性：初始应一致；同一工单同时标记为金牌组和通用组工单触发 disjoint 冲突
+  const consistentBefore = rl.isConsistent();
+  // 制造冲突：order-gold-001 已归为 GoldTeamOrder，再误标为 GeneralTeamOrder
+  store.add(ex('order-gold-001'), RDF + 'type', ex('GoldTeamOrder'));
+  store.add(ex('order-gold-001'), RDF + 'type', ex('GeneralTeamOrder'));
+  const r2 = new OWL2RLReasoner(store);
+  r2.materialize();
+  const consistentAfter = r2.isConsistent();
+  const conflictFound = r2.inconsistencies.length > 0;
+
+  // 4) 场景A：根因分析 —— SWRL 规则圈出缺陷批次工单
+  const rcSwrl = new SWRLReasoner(store);
+  rcSwrl.run(rootCauseRules());
+  const rcAlert1 = store.has(ex('ticket-rc-001'), RDF + 'type', ex('BatchAlert'));  // 缺陷批次工单应告警
+  const rcAlert2 = store.has(ex('ticket-rc-002'), RDF + 'type', ex('BatchAlert'));  // 同批次也应告警
+  const rcAlert3 = store.has(ex('ticket-rc-003'), RDF + 'type', ex('BatchAlert'));  // 正常批次不应告警
+  const rcSupplierLinked = store.has(ex('batch-2024-08'), ex('suppliedBy'), ex('supplier-x')); // 批次→供应商关联
+
+  // 5) 场景B：升级预测 —— SWRL 规则标记高危工单
+  const escSwrl = new SWRLReasoner(store);
+  escSwrl.run(escalationRules());
+  const escRisk = store.has(ex('ticket-esc-001'), RDF + 'type', ex('EscalationRisk')); // 高危工单应标记升级风险
+  const escNotRisk = store.has(ex('ticket-esc-002'), RDF + 'type', ex('EscalationRisk')); // 关联工单也应传递风险
+
+  // 6) 场景C：跨渠道关联 —— RL transitive 传递 sameIssueAs
+  const ccRl = new OWL2RLReasoner(store);
+  ccRl.materialize();
+  const crossChannelLinked = store.has(ex('ticket-app-001'), ex('sameIssueAs'), ex('ticket-weibo-001')); // 传递关联
+  const appChannel = store.has(ex('ticket-app-001'), ex('fromChannel'), ex('channel-app'));
+  const weiboChannel = store.has(ex('ticket-weibo-001'), ex('fromChannel'), ex('channel-weibo'));
+
+  // 7) 导出工单分派记录为 RDF/XML
+  const ont = triplesToOntology(store);
+  const xmlOut = writeRDFXML(ont);
+  const exported = xmlOut.trim().startsWith('<?xml');
+
+  return {
+    newFacts, goldRouted, normalRouted,
+    orderIsMaterialEntity, custIsMaterialEntity,
+    planIsPlanSpec, slaIsDIE, logIsDocument,
+    consistentBefore, consistentAfter, conflictFound,
+    // 场景A：根因分析
+    rcAlert1, rcAlert2, rcAlert3, rcSupplierLinked,
+    // 场景B：升级预测
+    escRisk, escNotRisk,
+    // 场景C：跨渠道关联
+    crossChannelLinked, appChannel, weiboChannel,
+    exported, store
+  };
+}
+
+// 导出供测试与复用
+module.exports = { run, buildCSStore, routingRules, rootCauseRules, escalationRules, ex };
+
+// 直接运行时打印业务结论
+if (require.main === module) {
+  const r = run();
+  console.log('================ SWRL 工单分派 ================');
+  console.log('SWRL 推理新增事实数        :', r.newFacts);              // > 0
+  console.log('金牌工单路由到金牌客服组   :', r.goldRouted);           // true
+  console.log('普通工单路由到通用客服组   :', r.normalRouted);         // true
+  console.log('');
+  console.log('================ BFO/IAO 层级归因 ================');
+  console.log('工单归为 BFO material entity:', r.orderIsMaterialEntity); // true
+  console.log('客户归为 BFO material entity:', r.custIsMaterialEntity);  // true
+  console.log('分派方案归为 IAO plan spec  :', r.planIsPlanSpec);        // true
+  console.log('SLA 归为 IAO directive info :', r.slaIsDIE);             // true
+  console.log('分派日志归为 IAO document   :', r.logIsDocument);         // true
+  console.log('');
+  console.log('================ 场景A：根因分析 ================');
+  console.log('缺陷批次工单1告警          :', r.rcAlert1);            // true
+  console.log('缺陷批次工单2告警          :', r.rcAlert2);            // true
+  console.log('正常批次工单不告警         :', !r.rcAlert3);           // true
+  console.log('批次→供应商关联            :', r.rcSupplierLinked);    // true
+  console.log('');
+  console.log('================ 场景B：投诉升级预测 ================');
+  console.log('高危工单标记升级风险       :', r.escRisk);             // true
+  console.log('关联工单传递升级风险       :', r.escNotRisk);          // true
+  console.log('');
+  console.log('================ 场景C：跨渠道问题关联 ================');
+  console.log('App→微博传递关联           :', r.crossChannelLinked);  // true
+  console.log('App渠道工单                :', r.appChannel);          // true
+  console.log('微博渠道工单               :', r.weiboChannel);        // true
+  console.log('');
+  console.log('================ 一致性与导出 ================');
+  console.log('初始本体一致性             :', r.consistentBefore);     // true
+  console.log('误标两组后一致性           :', r.consistentAfter);      // false
+  console.log('推理机报告冲突             :', r.conflictFound);        // true
+  console.log('分派记录可导出为 RDF/XML   :', r.exported);             // true
+}