@skaterqiang/protege-js 0.1.0

package/sample/case9-real-manufacturing-iao.js

@@ -0,0 +1,360 @@
+'use strict';
+
+// ===========================================================================
+// 业务案例 9：发动机缸体生产工艺执行与质量追溯 —— 真实 BFO + IAO + 工艺数据
+// ---------------------------------------------------------------------------
+// 【业务背景】
+//   某汽车零部件企业生产发动机缸体（EngineBlock），需要把「工艺路线 →
+//   具体工序 → 设备/刀具/参数 → 质量检验 → 批记录」全流程数据挂到真实
+//   IAO 标准本体上，实现：
+//     1. 工艺规程（IAO directive information entity）指导生产执行
+//     2. 每道工序的加工参数（转速/进给/切削深度）实时采集
+//     3. 质量检验结果与工艺参数关联，支持追溯分析
+//     4. 批生产记录（IAO document）归档，供 MES/QMS 消费
+//
+// 【业务规则】
+//   1. 产品层级：EngineBlock（发动机缸体）⊑ Product
+//   2. 工艺路线：Casting（铸造）→ RoughMachining（粗加工）→
+//      FinishMachining（精加工）→ Cleaning（清洗）→ Assembly（装配）→ Testing（测试）
+//   3. 工序与资源：RoughMachining requiresResource CNC-Machine + MillingCutter
+//   4. 工艺参数：RoughMachining 的切削参数 = {spindleSpeed: 800rpm, feedRate: 200mm/min}
+//   5. 质量检验：FinishMachining 后执行 DimensionInspection（尺寸检验）
+//   6. 推理：批记录 BR-20240901-001 应沿 IAO 层级归因到
+//      directive information entity → information content entity → BFO GDC
+//
+// 【用到的 OWL 2 能力】
+//   真实 IAO/BFO 类层级复用 / OWL 2 RL cax-sco 类层级归因 /
+//   owl:someValuesFrom（工序需要资源）/ writeRDFXML 导出批记录
+//
+// 【预期结果】
+//   - 缸体工艺路线各环节正确关联
+//   - 批记录实例沿真实 IAO 层级完整归因
+//   - 工艺参数与检验结果可追溯
+// ===========================================================================
+
+// 引入 Node 内置模块与解析器/序列化器/推理机
+const fs = require('fs');                                    // 文件系统：读取本地 OWL 文件
+const path = require('path');                                // 路径处理：拼接 ontologies 目录
+const { parseRDFXML } = require('../src/io/RDFXMLParser');   // RDF/XML 解析器：加载真实 OWL 文件
+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 { NS } = require('../src/inference/rdf');                        // 命名空间常量
+
+// 简化命名空间引用
+const RDF = NS.RDF, RDFS = NS.RDFS;
+// 真实 OWL 文件所在目录：sample/ontologies/
+const ONT_DIR = path.join(__dirname, 'ontologies');
+// rdfs:label 完整 IRI（用于过滤 label 注解）
+const RDFS_LABEL = RDFS + 'label';
+// 真实标准类 IRI（来自 OBO Foundry IAO/BFO 发布文件）
+const IAO_ICE = 'http://purl.obolibrary.org/obo/IAO_0000030';   // information content entity
+const IAO_DIE = 'http://purl.obolibrary.org/obo/IAO_0000033';   // directive information entity
+const IAO_DOC = 'http://purl.obolibrary.org/obo/IAO_0000310';   // document
+const IAO_PLAN = 'http://purl.obolibrary.org/obo/IAO_0000104';  // plan specification
+const BFO_GDC = 'http://purl.obolibrary.org/obo/BFO_0000031';   // generically dependent continuant
+
+// 从实体/类表达式中取 IRI 字符串（模型中 iri 为 {_iri} 嵌套对象）
+function iriOf(x) {
+  if (!x) return null;                    // 空值直接返回
+  if (typeof x === 'string') return x;    // 已经是字符串 IRI
+  const i = x.iri;                        // 取嵌套的 iri 字段
+  if (typeof i === 'string') return i;    // iri 本身是字符串
+  if (i && typeof i._iri === 'string') return i._iri; // iri 是 {_iri} 对象
+  if (typeof x._iri === 'string') return x._iri;      // 兜底：x 本身是 {_iri} 对象
+  return null;                            // 无法提取
+}
+
+// 真实本体的类层级 + rdfs:label → IRI 映射
+function extractOntologyFacts(onts) {
+  const store = new TripleStore();        // 存放类层级边
+  const label2iri = {};                   // label 文本 → 类 IRI 映射
+  let edges = 0;                          // 统计层级边数
+  for (const ont of onts) {               // 遍历每个本体
+    for (const ax of ont.getAxioms()) {   // 遍历每条公理
+      const t = ax.constructor && ax.constructor.name; // 公理类型名
+      if (t === 'OWLSubClassOfAxiom') {   // SubClassOf 公理
+        const sub = iriOf(ax.subClass);   // 子类 IRI
+        const sup = iriOf(ax.superClass); // 父类 IRI
+        if (sub && sup && sub.startsWith('http') && sup.startsWith('http')) {
+          store.add(sub, RDFS + 'subClassOf', sup); // 写入 TripleStore
+          edges++;                        // 边数 +1
+        }
+      } else if (t === 'OWLAnnotationAssertionAxiom') { // 注解断言公理
+        const p = ax.property && iriOf(ax.property); // 注解属性 IRI
+        const s = typeof ax.subject === 'string' ? ax.subject : iriOf(ax.subject); // 主体 IRI
+        const v = ax.value && ax.value.lexicalValue; // label 文本
+        // 只保留 rdfs:label，且首次出现（避免同名 label 覆盖）
+        if (p === RDFS_LABEL && s && v && !(v in label2iri)) label2iri[v] = s;
+      }
+    }
+  }
+  return { store, label2iri, edges };     // 返回层级存储、label 映射、边数
+}
+
+// 发动机缸体生产工艺数据（挂到真实 IAO 标准父类）
+function buildEngineBlockProcessTurtle() {
+  return [
+    '@prefix mfg: <http://factory.example.com/engineblock#> .',          // 定义 mfg 前缀（发动机缸体产线）
+    '@prefix owl: <http://www.w3.org/2002/07/owl#> .',                    // 定义 owl 前缀
+    '@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .',            // 定义 rdfs 前缀
+    '@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .',                 // 定义 xsd 前缀（数据类型）
+    '@prefix obo: <http://purl.obolibrary.org/obo/> .',                   // 定义 obo 前缀（OBO 标准 IRI）
+    '',
+
+    '# ========== 产品定义 ==========',
+    'mfg:EngineBlock a owl:Class ; rdfs:subClassOf mfg:Product .',       // 发动机缸体 ⊑ 产品
+    'mfg:Product a owl:Class .',                                          // 产品顶层类
+    '',
+
+    '# ========== 工艺路线（工序顺序） ==========',
+    'mfg:Casting a owl:Class ; rdfs:subClassOf mfg:Process .',           // 铸造 ⊑ 工艺
+    'mfg:RoughMachining a owl:Class ; rdfs:subClassOf mfg:Process .',    // 粗加工 ⊑ 工艺
+    'mfg:FinishMachining a owl:Class ; rdfs:subClassOf mfg:Process .',   // 精加工 ⊑ 工艺
+    'mfg:Cleaning a owl:Class ; rdfs:subClassOf mfg:Process .',          // 清洗 ⊑ 工艺
+    'mfg:Assembly a owl:Class ; rdfs:subClassOf mfg:Process .',          // 装配 ⊑ 工艺
+    'mfg:Testing a owl:Class ; rdfs:subClassOf mfg:Process .',           // 测试 ⊑ 工艺
+    'mfg:Process a owl:Class .',                                          // 工艺顶层类
+    'mfg:precedes a owl:ObjectProperty , owl:TransitiveProperty .',       // 工序顺序（传递）
+    '',
+
+    '# ========== 设备与资源 ==========',
+    'mfg:Equipment a owl:Class ; rdfs:subClassOf mfg:Resource .',        // 设备 ⊑ 资源
+    'mfg:Tooling a owl:Class ; rdfs:subClassOf mfg:Resource .',          // 刀具 ⊑ 资源
+    'mfg:Material a owl:Class ; rdfs:subClassOf mfg:Resource .',         // 物料 ⊑ 资源
+    'mfg:Resource a owl:Class .',                                         // 资源顶层类
+    'mfg:requiresResource a owl:ObjectProperty ; rdfs:domain mfg:Process ; rdfs:range mfg:Resource .', // 工艺→资源
+    '',
+
+    '# ========== 具体设备实例 ==========',
+    'mfg:CNC-Machine-001 a mfg:Equipment ; rdfs:label "数控加工中心-001" .',      // 数控加工中心
+    'mfg:MillingCutter-D50 a mfg:Tooling ; rdfs:label "Φ50铣刀" .',             // Φ50铣刀（局部名用ASCII兼容字符）
+    'mfg:DrillBit-D10 a mfg:Tooling ; rdfs:label "Φ10钻头" .',                  // Φ10钻头（局部名用ASCII兼容字符）
+    'mfg:CastIron-HT250 a mfg:Material ; rdfs:label "HT250铸铁毛坯" .',          // HT250铸铁毛坯
+    '',
+
+    '# ========== 工艺参数定义 ==========',
+    'mfg:ProcessParameter a owl:Class .',                                   // 工艺参数类
+    'mfg:hasParameter a owl:ObjectProperty ; rdfs:domain mfg:Process ; rdfs:range mfg:ProcessParameter .', // 工艺→参数
+    'mfg:spindleSpeed a owl:DatatypeProperty ; rdfs:domain mfg:ProcessParameter ; rdfs:range xsd:integer .', // 主轴转速(rpm)
+    'mfg:feedRate a owl:DatatypeProperty ; rdfs:domain mfg:ProcessParameter ; rdfs:range xsd:integer .',     // 进给速度(mm/min)
+    'mfg:cuttingDepth a owl:DatatypeProperty ; rdfs:domain mfg:ProcessParameter ; rdfs:range xsd:decimal .', // 切削深度(mm)
+    '',
+
+    '# ========== 质量检验定义 ==========',
+    'mfg:QualityInspection a owl:Class ; rdfs:subClassOf mfg:Process .',   // 质量检验 ⊑ 工艺
+    'mfg:DimensionInspection a owl:Class ; rdfs:subClassOf mfg:QualityInspection .', // 尺寸检验 ⊑ 质量检验
+    'mfg:SurfaceRoughnessInspection a owl:Class ; rdfs:subClassOf mfg:QualityInspection .', // 表面粗糙度检验 ⊑ 质量检验
+    'mfg:hasInspectionResult a owl:ObjectProperty ; rdfs:domain mfg:QualityInspection ; rdfs:range mfg:InspectionResult .', // 检验→结果
+    'mfg:InspectionResult a owl:Class .',                                   // 检验结果类
+    'mfg:inspectionValue a owl:DatatypeProperty ; rdfs:domain mfg:InspectionResult ; rdfs:range xsd:decimal .', // 检验值
+    'mfg:inspectionUnit a owl:DatatypeProperty ; rdfs:domain mfg:InspectionResult ; rdfs:range xsd:string .',  // 检验单位
+    'mfg:inspectionPass a owl:DatatypeProperty ; rdfs:domain mfg:InspectionResult ; rdfs:range xsd:boolean .', // 是否合格
+    '',
+
+    '# ========== 批生产记录（挂到真实 IAO 标准父类） ==========',
+    'mfg:BatchRecord a owl:Class ; rdfs:subClassOf obo:IAO_0000310 .',     // 批生产记录 ⊑ document
+    'mfg:ProcessSpecification a owl:Class ; rdfs:subClassOf obo:IAO_0000033 .', // 工艺规程 ⊑ directive information entity
+    'mfg:OperationInstruction a owl:Class ; rdfs:subClassOf obo:IAO_0000104 .', // 作业指导书 ⊑ plan specification
+    '',
+
+    '# ========== 具体实例：发动机缸体 EB-2024-001 的生产工艺 ==========',
+    '# 产品实例',
+    'mfg:EB-2024-001 a mfg:EngineBlock ; rdfs:label "发动机缸体-2024-001" .',
+    '',
+    '# 铸造工序',
+    'mfg:Casting-EB001 a mfg:Casting ;',                                    // 铸造工序实例
+    '  mfg:requiresResource mfg:CastIron-HT250 ;',                          // 需要 HT250 铸铁毛坯
+    '  mfg:precedes mfg:RoughMachining-EB001 .',                            // 铸造 → 粗加工
+    '',
+    '# 粗加工工序（含工艺参数）',
+    'mfg:RoughMachining-EB001 a mfg:RoughMachining ;',                      // 粗加工工序实例
+    '  mfg:requiresResource mfg:CNC-Machine-001 ;',                         // 需要数控加工中心
+    '  mfg:requiresResource mfg:MillingCutter-D50 ;',                       // 需要 Φ50 铣刀
+    '  mfg:hasParameter mfg:RP-EB001 ;',                                    // 关联工艺参数
+    '  mfg:precedes mfg:FinishMachining-EB001 .',                           // 粗加工 → 精加工
+    '',
+    '# 粗加工工艺参数实例',
+    'mfg:RP-EB001 a mfg:ProcessParameter ;',                                // 工艺参数实例
+    '  mfg:spindleSpeed "800"^^xsd:integer ;',                              // 主轴转速 800 rpm
+    '  mfg:feedRate "200"^^xsd:integer ;',                                  // 进给速度 200 mm/min
+    '  mfg:cuttingDepth "2.5"^^xsd:decimal .',                              // 切削深度 2.5 mm
+    '',
+    '# 精加工工序',
+    'mfg:FinishMachining-EB001 a mfg:FinishMachining ;',                    // 精加工工序实例
+    '  mfg:requiresResource mfg:CNC-Machine-001 ;',                         // 需要数控加工中心
+    '  mfg:requiresResource mfg:DrillBit-D10 ;',                            // 需要 Φ10 钻头
+    '  mfg:precedes mfg:Cleaning-EB001 .',                                  // 精加工 → 清洗
+    '',
+    '# 清洗工序',
+    'mfg:Cleaning-EB001 a mfg:Cleaning ;',                                  // 清洗工序实例
+    '  mfg:precedes mfg:Assembly-EB001 .',                                  // 清洗 → 装配
+    '',
+    '# 装配工序',
+    'mfg:Assembly-EB001 a mfg:Assembly ;',                                  // 装配工序实例
+    '  mfg:precedes mfg:Testing-EB001 .',                                   // 装配 → 测试
+    '',
+    '# 测试工序（含质量检验）',
+    'mfg:Testing-EB001 a mfg:Testing ;',                                    // 测试工序实例
+    '  mfg:precedes mfg:DimInsp-EB001 .',                                   // 测试 → 尺寸检验
+    '',
+    '# 尺寸检验工序',
+    'mfg:DimInsp-EB001 a mfg:DimensionInspection ;',                        // 尺寸检验实例
+    '  mfg:hasInspectionResult mfg:IR-EB001 .',                             // 关联检验结果
+    '',
+    '# 检验结果实例',
+    'mfg:IR-EB001 a mfg:InspectionResult ;',                                // 检验结果实例
+    '  mfg:inspectionValue "49.98"^^xsd:decimal ;',                         // 检验值 49.98
+    '  mfg:inspectionUnit "mm" ;',                                          // 单位 mm
+    '  mfg:inspectionPass "true"^^xsd:boolean .',                           // 合格
+    '',
+    '# 批生产记录实例（关联整个工艺执行）',
+    'mfg:BR-20240901-001 a mfg:BatchRecord ;',                              // 批记录实例
+    '  rdfs:label "发动机缸体EB-2024-001批生产记录-20240901" ;',               // 批记录标签
+    '  mfg:recordsProduct mfg:EB-2024-001 ;',                               // 记录的产品
+    '  mfg:recordsProcess mfg:Casting-EB001 ;',                             // 记录的铸造工序
+    '  mfg:recordsProcess mfg:RoughMachining-EB001 ;',                      // 记录的粗加工工序
+    '  mfg:recordsProcess mfg:FinishMachining-EB001 ;',                     // 记录的精加工工序
+    '  mfg:recordsProcess mfg:Testing-EB001 ;',                             // 记录的测试工序
+    '  mfg:recordsInspection mfg:DimInsp-EB001 .',                          // 记录的检验工序
+    '',
+    '# 批记录与产品/工序的关联属性',
+    'mfg:recordsProduct a owl:ObjectProperty ; rdfs:domain mfg:BatchRecord ; rdfs:range mfg:Product .', // 批记录→产品
+    'mfg:recordsProcess a owl:ObjectProperty ; rdfs:domain mfg:BatchRecord ; rdfs:range mfg:Process .',   // 批记录→工艺
+    'mfg:recordsInspection a owl:ObjectProperty ; rdfs:domain mfg:BatchRecord ; rdfs:range mfg:QualityInspection .', // 批记录→检验
+    ''
+  ].join('\n');
+}
+
+// 执行真实本体加载、工艺数据合并、RL 推理与导出
+function run() {
+  // 1) 加载真实公开本体
+  const bfo = parseRDFXML(fs.readFileSync(path.join(ONT_DIR, 'bfo.owl'), 'utf8')); // BFO 顶层本体
+  const iao = parseRDFXML(fs.readFileSync(path.join(ONT_DIR, 'iao.owl'), 'utf8')); // IAO 信息构件本体
+  const counts = { bfo: bfo.getAxiomCount(), iao: iao.getAxiomCount() }; // 统计公理数
+
+  // 2) 提取真实类层级 + label 映射；校验 IAO 标准类
+  const { store, label2iri, edges } = extractOntologyFacts([bfo, iao]);
+  const iaoStdClasses = {
+    'information content entity': label2iri['information content entity'] || null,
+    'directive information entity': label2iri['directive information entity'] || null,
+    'document': label2iri['document'] || null,
+    'plan specification': label2iri['plan specification'] || null,
+    'generically dependent continuant': label2iri['generically dependent continuant'] || null
+  };
+  const hasStdClasses =
+    iaoStdClasses['directive information entity'] === IAO_DIE &&
+    iaoStdClasses['document'] === IAO_DOC &&
+    iaoStdClasses['plan specification'] === IAO_PLAN &&
+    iaoStdClasses['generically dependent continuant'] === BFO_GDC;
+
+  // 3) 真实层级 + 发动机缸体工艺数据合并 → RL 物化
+  //    TripleStore.match 返回三元组数组 [subject, predicate, object]
+  const mfgStore = new TurtleParser().parse(buildEngineBlockProcessTurtle()); // 解析工艺数据 Turtle
+  for (const [s, p, o] of mfgStore.match(null, null, null)) { // 遍历工艺数据三元组
+    store.add(s, p, o);                                       // 合并到真实本体 store
+  }
+  const reasoner = new OWL2RLReasoner(store);
+  reasoner.materialize(); // 执行 RL 物化
+
+  // 4) 批记录 IAO 层级归因验证
+  const BR = 'http://factory.example.com/engineblock#BR-20240901-001'; // 批记录实例 IRI
+  const m = 'http://factory.example.com/engineblock#';                     // 企业前缀
+  const isBatchRecord = store.has(BR, RDF + 'type', m + 'BatchRecord'); // 归为 BatchRecord
+  const isDoc = store.has(BR, RDF + 'type', IAO_DOC);                   // 归为 document（IAO_0000310）
+  const isICE = store.has(BR, RDF + 'type', IAO_ICE);                   // 归为 information content entity
+  const isGDC = store.has(BR, RDF + 'type', BFO_GDC);                   // 归为 BFO generically dependent continuant
+  const attributed = isBatchRecord && isDoc && isICE && isGDC;          // 完整归因链（BatchRecord⊑document⊑ICE⊑GDC）
+
+  // 5) 工艺执行与质量追溯验证
+  const eb = 'http://factory.example.com/engineblock#EB-2024-001';      // 发动机缸体实例
+  const isEngineBlock = store.has(eb, RDF + 'type', m + 'EngineBlock'); // 归为 EngineBlock
+  const isProduct = store.has(eb, RDF + 'type', m + 'Product');         // 归为 Product
+
+  // 工艺顺序传递验证：铸造 precedes 精加工（经由粗加工）
+  const castingPrecedesFinish = store.has(
+    'http://factory.example.com/engineblock#Casting-EB001',
+    m + 'precedes',
+    'http://factory.example.com/engineblock#FinishMachining-EB001'
+  );
+
+  // 粗加工资源关联验证
+  const roughMachining = 'http://factory.example.com/engineblock#RoughMachining-EB001';
+  const requiresCNC = store.has(roughMachining, m + 'requiresResource', m + 'CNC-Machine-001'); // 需要数控加工中心
+  const requiresCutter = store.has(roughMachining, m + 'requiresResource', m + 'MillingCutter-D50'); // 需要 Φ50 铣刀
+
+  // 工艺参数关联验证
+  const hasParameter = store.has(roughMachining, m + 'hasParameter', m + 'RP-EB001'); // 粗加工关联参数
+  const paramSpeed = store.has(m + 'RP-EB001', m + 'spindleSpeed', '"800"^^<http://www.w3.org/2001/XMLSchema#integer>'); // 转速 800
+
+  // 质量检验关联验证
+  const dimInsp = 'http://factory.example.com/engineblock#DimInsp-EB001';
+  const hasInspectionResult = store.has(dimInsp, m + 'hasInspectionResult', m + 'IR-EB001'); // 检验关联结果
+  const inspectionPass = store.has(m + 'IR-EB001', m + 'inspectionPass', '"true"^^<http://www.w3.org/2001/XMLSchema#boolean>'); // 检验合格
+
+  // 批记录追溯验证
+  const recordsProduct = store.has(BR, m + 'recordsProduct', eb); // 批记录关联产品
+  const recordsRoughMachining = store.has(BR, m + 'recordsProcess', roughMachining); // 批记录关联粗加工
+
+  const consistent = reasoner.isConsistent();                         // 本体一致性
+
+  // 6) 导出批记录本体为 RDF/XML
+  const mfgOnt = triplesToOntology(new TurtleParser().parse(buildEngineBlockProcessTurtle())); // 桥接为 OWLOntology
+  const xmlOut = writeRDFXML(mfgOnt);                             // 导出 RDF/XML
+  const exported = xmlOut.trim().startsWith('<?xml');             // 是合法 XML
+
+  return {
+    counts, edges, iaoStdClasses, hasStdClasses,
+    isBatchRecord, isDoc, isICE, isGDC, attributed,
+    isEngineBlock, isProduct,
+    castingPrecedesFinish,
+    requiresCNC, requiresCutter,
+    hasParameter, paramSpeed,
+    hasInspectionResult, inspectionPass,
+    recordsProduct, recordsRoughMachining,
+    consistent, exported
+  };
+}
+
+// 导出供测试与复用
+module.exports = { run };
+
+// 直接运行时打印业务结论
+if (require.main === module) {
+  const r = run();
+  console.log('================ 真实标准本体加载 ================');
+  console.log('BFO 公理数                       :', r.counts.bfo);           // > 0
+  console.log('IAO 公理数                       :', r.counts.iao);           // > 0
+  console.log('真实类层级边数                   :', r.edges);                // > 100
+  console.log('含全部 IAO 工艺标准类            :', r.hasStdClasses);        // true
+  console.log('');
+  console.log('================ 批记录 IAO 层级归因 ================');
+  console.log('批记录归为 BatchRecord           :', r.isBatchRecord);       // true
+  console.log('  → document                     :', r.isDoc);               // true
+  console.log('  → information content entity   :', r.isICE);               // true
+  console.log('  → BFO generically dependent cont:', r.isGDC);              // true
+  console.log('沿真实 IAO 层级完整归因          :', r.attributed);          // true
+  console.log('');
+  console.log('================ 产品与工艺执行 ================');
+  console.log('EB-2024-001 归为 EngineBlock     :', r.isEngineBlock);       // true
+  console.log('EB-2024-001 归为 Product         :', r.isProduct);           // true
+  console.log('铸造 precedes 精加工（传递）      :', r.castingPrecedesFinish); // true
+  console.log('粗加工需要数控加工中心           :', r.requiresCNC);          // true
+  console.log('粗加工需要Φ50铣刀               :', r.requiresCutter);       // true
+  console.log('');
+  console.log('================ 工艺参数与质量追溯 ================');
+  console.log('粗加工关联工艺参数               :', r.hasParameter);        // true
+  console.log('参数：主轴转速800rpm             :', r.paramSpeed);           // true
+  console.log('尺寸检验关联检验结果             :', r.hasInspectionResult);  // true
+  console.log('检验结果：合格                   :', r.inspectionPass);       // true
+  console.log('');
+  console.log('================ 批记录追溯 ================');
+  console.log('批记录关联产品EB-2024-001        :', r.recordsProduct);       // true
+  console.log('批记录关联粗加工工序             :', r.recordsRoughMachining); // true
+  console.log('');
+  console.log('================ 一致性与导出 ================');
+  console.log('本体一致性                       :', r.consistent);          // true
+  console.log('扩展本体可导出为 RDF/XML         :', r.exported);            // true
+}