第48章　RuleEngine

Rule 是“规定逻辑”，而 RuleEngine 是“管理、检查、匹配并执行规则的运行机制”。

在 ICAI 中，Reasoning 负责推理，Rule 负责描述逻辑，而 RuleEngine 负责让这些规则真正进入运行过程：

Fact
  ↓
Condition
  ↓
RuleEngine
  ├── 条件检查
  ├── 条件组合
  ├── 优先级判断
  ├── 冲突检查
  ├── 规则选择
  ├── 规则执行
  └── 结果记录
  ↓
RuleResult
  ↓
Reasoning / Decision

RuleEngine 不负责产生规则之外的内容，也不等于 Reasoning。它的核心任务是：按照已经定义的规则和当前认知状态进行确定性的规则运行。

1. RuleEngine

1.1 RuleEngine 定义

RuleEngine 是 ICAI 中负责规则运行的核心 Engine。

它接收：

当前对象
属性
状态
事实
条件
关系
当前环境
Rule

经过条件检查、规则匹配、优先级判断、冲突检查后执行符合条件的规则。

基本结构：

RuleEngine
{
    rules
    context
    condition_checker
    priority_manager
    conflict_manager
    executor
    result
}

核心输入：

Current Context + Rules

核心输出：

RuleResult

1.2 RuleEngine 与 Rule 的关系

二者不能混淆：

Rule
    = 规则定义

RuleEngine
    = 规则运行机制

例如：

Rule:

IF battery.level < 30
THEN device.state = needs_charge

RuleEngine 则负责：

读取 Rule
↓
读取 Battery.level
↓
检查 battery.level < 30
↓
条件成立
↓
执行 Action
↓
修改 Device.state
↓
生成 RuleResult

因此：

Rule ≠ RuleEngine

1.3 RuleEngine 的基本结构

可以抽象为：

Input
 ↓
Context
 ↓
Rule Loading
 ↓
Condition Check
 ↓
Condition Combination
 ↓
Priority
 ↓
Conflict Check
 ↓
Rule Selection
 ↓
Action Execution
 ↓
Result

这构成 RuleEngine 的基本运行链。

2. 条件检查

RuleEngine 执行规则之前，首先必须检查 RuleCondition。

上一章中的条件结构：

RuleCondition
{
    object
    property
    operator
    value
}

例如：

RuleCondition
{
    object: "Battery_A",
    property: "level",
    operator: "<",
    value: 30
}

如果当前事实：

Battery_A.level = 20

则：

20 < 30

成立。

结果：

TRUE

2.1 条件状态

RuleEngine 至少需要处理：

TRUE
FALSE
UNKNOWN
CONFLICT

例如：

条件	当前数据	结果
level < 30	20	TRUE
level < 30	50	FALSE
level < 30	未知	UNKNOWN
level < 30	数据冲突	CONFLICT

RuleEngine 不能把：

UNKNOWN

错误地当成：

TRUE

也不能把：

CONFLICT

直接当成：

FALSE

因为这会破坏规则运行的可靠性。

2.2 操作符检查

条件检查需要处理基本操作符：

=
!=
>
<
>=
<=
IN
NOT IN
CONTAINS
EXISTS

例如：

temperature > 40

当前：

temperature = 45

则：

45 > 40
→ TRUE

2.3 条件检查过程

Condition
 ↓
读取 Object
 ↓
读取 Property
 ↓
获取 Current Value
 ↓
Operator
 ↓
Compare
 ↓
Condition Result

例如：

Battery_A
    level = 20

Condition:
level < 30

运行：

20 < 30
→ TRUE

3. 条件组合

一个 Rule 通常不只有一个条件。

例如：

IF
    Battery.level < 30
AND
    Device.state = active
THEN
    Device.state = needs_charge

这里存在两个 Condition：

Condition_1
Condition_2

以及一个组合关系：

AND

3.1 AND

所有条件必须成立：

A = TRUE
B = TRUE

A AND B
→ TRUE

例如：

Battery.level < 30
AND
Device.state = active

当前：

Battery.level = 20
Device.state = active

结果：

TRUE AND TRUE
→ TRUE

规则可以执行。

3.2 OR

只需要一个条件成立：

A = TRUE
B = FALSE

A OR B
→ TRUE

例如：

Battery.level < 30
OR
Device.temperature > 80

只要其中一个条件成立，RuleEngine 就可以进入下一阶段。

3.3 NOT

对条件进行反向判断：

NOT A

例如：

Device.state != active

可以理解为：

NOT(Device.state = active)

3.4 条件树

复杂规则可以形成条件树：

表示：

A AND (B OR C)

RuleEngine 必须按照条件结构进行计算，而不能简单按照条件出现顺序执行。

3.5 条件组合结果

最终：

ConditionSet
→ TRUE
→ FALSE
→ UNKNOWN
→ CONFLICT

只有满足 Rule 定义要求时，才能进入规则执行阶段。

4. 优先级

多个 Rule 可能同时满足条件。

例如：

Rule_A
Rule_B
Rule_C

同时：

Rule_A = TRUE
Rule_B = TRUE
Rule_C = TRUE

这时 RuleEngine 需要确定运行顺序。

因此 Rule 具有：

priority

例如：

Rule_A priority = 10
Rule_B priority = 30
Rule_C priority = 20

运行顺序：

Rule_B
↓
Rule_C
↓
Rule_A

4.1 优先级不是智能程度

必须明确：

Priority ≠ Intelligence

优先级只是：

执行顺序控制

例如：

Priority 100

并不意味着这个 Rule “更聪明”。

它只是表示：

在多个可执行规则中优先处理。

4.2 优先级判断

基本过程：

Matched Rules
 ↓
读取 Priority
 ↓
排序
 ↓
得到 Execution Order

例如：

Rule_001 = 20
Rule_002 = 80
Rule_003 = 50

得到：

Rule_002
Rule_003
Rule_001

5. 规则冲突

规则冲突是 RuleEngine 的重要安全机制。

例如：

Rule_A:
IF temperature > 80
THEN Device.state = shutdown

同时：

Rule_B:
IF temperature > 80
THEN Device.state = active

当前：

temperature = 90

两个 Rule 都成立：

Rule_A → shutdown
Rule_B → active

出现：

CONFLICT

5.1 冲突不能随机处理

RuleEngine 不能：

随机选择 Rule_A

也不能：

随机选择 Rule_B

否则系统行为不可预测。

5.2 冲突处理

可以按照以下顺序处理：

Conflict Detection
        ↓
Priority Check
        ↓
Condition Specificity
        ↓
Source / Validity Check
        ↓
Conflict Resolution

例如：

Rule_A priority = 100
Rule_B priority = 50

如果系统规定高优先级可以解决该类冲突：

Rule_A
→ selected

如果优先级仍然不能合法解决：

RuleResult = CONFLICT

系统停止该组冲突规则的执行。

5.3 冲突结果

RuleEngine 应明确记录：

Conflict
{
    rule_a
    rule_b
    object
    property
    action_a
    action_b
    reason
    state
}

例如：

Conflict
{
    rule_a: "Rule_Shutdown",
    rule_b: "Rule_Active",
    object: "Device_A",
    property: "state",
    action_a: "shutdown",
    action_b: "active",
    reason: "same_condition_different_action",
    state: "CONFLICT"
}

这样后续 Reasoning 或 Self-Maintenance 系统才可以继续处理。

6. 规则执行

当 RuleEngine 完成：

Condition Check
↓
Condition Combination
↓
Priority
↓
Conflict Check

之后，符合条件的 Rule 才进入执行阶段。

6.1 Rule Action

Rule Action 可以是：

Set Property
Change State
Create Fact
Create Object
Create Relation
Delete Relation
Call Method
Trigger Rule

例如：

Action
{
    object: "Device_A",
    property: "state",
    value: "needs_charge"
}

6.2 执行过程

Selected Rule
 ↓
Read Action
 ↓
Validate Action
 ↓
Find Target Object
 ↓
Execute Method
 ↓
Update Property / State / Relation
 ↓
Record Result

例如：

Device_A.state = active
Battery_A.level = 20

规则：

IF Battery_A.level < 30
AND Device_A.state = active
THEN Device_A.state = needs_charge

执行：

20 < 30
→ TRUE

active = active
→ TRUE

TRUE AND TRUE
→ TRUE

Action
→ Device_A.state = needs_charge

最终：

Device_A.state
active
    ↓
needs_charge

7. 规则结果

RuleEngine 执行之后必须产生明确的 RuleResult。

基本结构：

RuleResult
{
    rule_id
    conditions
    condition_result
    action
    execution_state
    result
    timestamp
}

7.1 SUCCESS

规则成功执行：

Condition = TRUE
Action = executed
Result = SUCCESS

7.2 FAILED

条件满足，但 Action 执行失败：

Condition = TRUE
Action = failed
Result = FAILED

例如目标对象不存在：

Device_A not found

7.3 SKIPPED

规则没有执行：

Condition = FALSE

或者因为优先级/冲突机制没有被选中：

Result = SKIPPED

7.4 UNKNOWN

条件无法判断：

Battery_A.level = UNKNOWN

因此：

Condition = UNKNOWN
RuleResult = UNKNOWN

7.5 CONFLICT

存在无法解决的规则冲突：

Rule_A → shutdown
Rule_B → active

最终：

RuleResult = CONFLICT

7.6 规则结果不是最终决策

必须保持 ICAI 各层职责：

RuleEngine
    ↓
RuleResult
    ↓
Reasoning
    ↓
Conclusion
    ↓
Decision
    ↓
Action

因此：

RuleResult ≠ Decision

RuleEngine 可以改变认知对象的状态，也可以产生事实，但是否形成最终决策，要由后续认知流程决定。

8. 完整运行案例

下面使用一个完整案例说明 RuleEngine。

8.1 当前事实

系统当前获得：

Battery_A.level = 20
Device_A.state = active
Device_A.temperature = 45

形成事实：

Fact_001
Battery_A.level = 20

Fact_002
Device_A.state = active

Fact_003
Device_A.temperature = 45

8.2 Rule 1

Rule_001
{
    id: 1001,

    conditions: [
        {
            object: "Battery_A",
            property: "level",
            operator: "<",
            value: 30
        },
        {
            object: "Device_A",
            property: "state",
            operator: "=",
            value: "active"
        }
    ],

    operator: "AND",

    action: {
        object: "Device_A",
        property: "state",
        value: "needs_charge"
    },

    priority: 20,
    state: "ACTIVE"
}

8.3 RuleEngine 检查

Condition 1

Battery_A.level = 20

20 < 30
→ TRUE

Condition 2

Device_A.state = active

active = active
→ TRUE

条件组合

TRUE AND TRUE
→ TRUE

所以：

Rule_001 = MATCHED

8.4 Rule 2

同时存在另一条规则：

Rule_002
{
    id: 1002,

    conditions: [
        {
            object: "Device_A",
            property: "temperature",
            operator: ">",
            value: 40
        }
    ],

    operator: "AND",

    action: {
        object: "Device_A",
        property: "state",
        value: "warning"
    },

    priority: 50,
    state: "ACTIVE"
}

当前：

Device_A.temperature = 45

所以：

45 > 40
→ TRUE

得到：

Rule_002 = MATCHED

8.5 优先级

当前两个规则都满足：

Rule_001 priority = 20
Rule_002 priority = 50

因此：

Rule_002
    ↓
Rule_001

8.6 冲突检查

两个规则都修改：

Device_A.state

但是目标不同：

Rule_002 → warning
Rule_001 → needs_charge

因此产生潜在冲突：

Device_A.state
warning
vs
needs_charge

如果系统规定：

Rule_002 priority = 50
Rule_001 priority = 20

且高优先级规则可以覆盖低优先级规则，则：

Rule_002
→ execute

Rule_001
→ SKIPPED

最终：

Device_A.state = warning

如果系统规定这类状态冲突必须人工/上层认知处理，则：

Rule_001 + Rule_002
→ CONFLICT

RuleEngine 不应该擅自选择。

8.7 完整运行链

整个过程可以表示为：

                    Current Facts
                         │
                         ▼
                    RuleEngine
                         │
             ┌───────────┴───────────┐
             ▼                       ▼
       Rule_001                  Rule_002
             │                       │
             ▼                       ▼
       Condition Check         Condition Check
             │                       │
           TRUE                    TRUE
             │                       │
             └───────────┬───────────┘
                         ▼
                      Priority
                         │
                         ▼
                   Conflict Check
                         │
              ┌──────────┴──────────┐
              ▼                     ▼
           Selected              Skipped
              │
              ▼
          Action Execute
              │
              ▼
          RuleResult
              │
              ▼
        Updated Cognitive State

RuleEngine 核心模型

RuleEngine 可以归纳为：

RuleEngine
=
Condition Check
+
Condition Combination
+
Priority
+
Conflict Detection
+
Rule Selection
+
Action Execution
+
Result Recording

完整运行公式：

Current Context
+
Rules
↓
Condition Check
↓
Condition Combination
↓
Matched Rules
↓
Priority
↓
Conflict Check
↓
Rule Selection
↓
Action
↓
RuleResult

Rule、RuleEngine、Reasoning 三者关系

这一点非常重要：

Rule
    ↓
规定“什么条件下做什么”

RuleEngine
    ↓
负责“检查并运行规则”

Reasoning
    ↓
负责“利用事实、规则、关系、经验形成推理结论”

因此：

Rule = 规定逻辑
RuleEngine = 执行逻辑
Reasoning = 使用逻辑形成结论

三者连接起来：

Fact
+
Object
+
Relation
+
Experience
+
Rule
        ↓
    RuleEngine
        ↓
   RuleResult
        ↓
    Reasoning
        ↓
   Conclusion
        ↓
    Decision
        ↓
     Action
        ↓
   Experience
        ↓
     Learning

这使 RuleEngine 成为 ICAI 从静态规则定义走向实际认知运行的关键 Engine，同时仍然保持完全的对象、属性、关系、条件、规则和离散逻辑运行机制。

第48章 RuleEngine

第48章 RuleEngine

1. RuleEngine

1.1 RuleEngine 定义

1.2 RuleEngine 与 Rule 的关系

1.3 RuleEngine 的基本结构

2. 条件检查

2.1 条件状态

2.2 操作符检查

2.3 条件检查过程

3. 条件组合

3.1 AND

3.2 OR

3.3 NOT

3.4 条件树

3.5 条件组合结果

4. 优先级

4.1 优先级不是智能程度

4.2 优先级判断

5. 规则冲突

5.1 冲突不能随机处理

5.2 冲突处理

5.3 冲突结果

6. 规则执行

6.1 Rule Action

6.2 执行过程

7. 规则结果

7.1 SUCCESS

7.2 FAILED

7.3 SKIPPED

7.4 UNKNOWN

7.5 CONFLICT

7.6 规则结果不是最终决策

8. 完整运行案例

8.1 当前事实

8.2 Rule 1

8.3 RuleEngine 检查

Condition 1

Condition 2

条件组合

8.4 Rule 2

8.5 优先级

8.6 冲突检查

8.7 完整运行链

RuleEngine 核心模型

Rule、RuleEngine、Reasoning 三者关系