第198章　DecisionEngine

198.1 DecisionEngine概述

在 ICAI（Individual Cognitive AI）体系中，DecisionEngine 是连接“可行候选”与“实际执行”的核心计算引擎。

前面的 MatchingEngine 负责判断候选是否满足要求，MethodEngine 负责计算方法及其适用条件，RiskEngine 负责计算风险，ConflictEngine 负责计算冲突，而 DecisionEngine 则在这些计算结果基础上回答一个核心问题：

当前条件下，应该选择哪个候选方案？

因此：

DecisionEngine = 候选方案 + 条件计算 + 决策计算 + 决策输出

可以表示为：

$DE=(C,G,O,S,M,K,R,F,D,Ot)DE=(C,G,O,S,M,K,R,F,D,O_t)$

其中：

$CC$ ：Candidate，候选方案；
$GG$ ：Goal，目标；
$OO$ ：Object，对象；
$SS$ ：State，当前状态；
$MM$ ：Method，可执行方法；
$KK$ ：Knowledge，知识；
$RR$ ：Rule，决策规则；
$FF$ ：Factor，决策因素；
$DD$ ：Decision Calculation，决策计算；
$OtO_t$ ：Output，决策输出。

DecisionEngine 不负责执行最终方案。

完整关系是：

候选方案 → 条件计算 → 决策计算 → 决策输出 → DecisionService → Behavior → Action → Execution

因此：

$DecisionEngine≠BehaviorEngineDecisionEngine \neq BehaviorEngine$ $DecisionEngine≠ActionEngineDecisionEngine \neq ActionEngine$ $DecisionEngine≠ExecutionEngineDecisionEngine \neq ExecutionEngine$

DecisionEngine 只负责完成“选择”。

198.2 Decision的基本定义

Decision 的中文含义是“决策”。

在 ICAI 中，Decision 不是简单的 Boolean 判断，也不是随机选择。

Decision 是在多个候选方案中，根据当前目标、状态、条件、能力、资源、风险、冲突、优先级和规则进行确定性计算后形成的选择结果。

可以定义：

$Decision=(C,Co,R,H)Decision=(C,Co,R,H)$

其中：

$CC$ ：Candidate，候选方案集合；
$CoCo$ ：Condition，决策条件；
$RR$ ：Result，决策结果；
$HH$ ：History，决策历史。

DecisionEngine 的任务则是：

$DecisionEngine(C,Co,R)→DecisionResultDecisionEngine(C,Co,R)\rightarrow DecisionResult$

198.3 候选方案

198.3.1 Candidate定义

Candidate 的中文含义是“候选方案”。

候选方案是已经进入当前决策范围、具备被比较和选择资格的对象。

候选方案可以是：

Method；
Capability；
Behavior；
Action；
Object；
Resource；
Route；
Strategy；
Protection；
Repair；
Goal；
其他经过合法注册的决策对象。

因此：

$Candidate={C1,C2,…,Cn}Candidate=\{C_1,C_2,\ldots,C_n\}$

其中：

$n≥0n\geq0$

特别重要的是：

候选数量可以为0。

如果没有任何候选满足当前条件，DecisionEngine 不应该强制选择一个方案。

198.4 候选方案的结构

一个完整 Candidate 可以定义为：

$Ci=(I,T,S,Co,R,E)C_i=(I,T,S,Co,R,E)$

其中：

$II$ ：候选对象 ID；
$TT$ ：候选类型；
$SS$ ：候选当前状态；
$CoCo$ ：候选条件；
$RR$ ：候选所需资源；
$EE$ ：候选证据。

例如一个 Method Candidate：

$C1=(MethodID,MethodType,Ready,Condition,Resource,Evidence)C_1= (MethodID, MethodType, Ready, Condition, Resource, Evidence)$

DecisionEngine 不应该只拿一个 ID 进行选择。

它必须知道：

这个候选是什么、当前能不能执行、为什么能够执行、需要什么资源、有什么限制。

198.5 候选方案的来源

DecisionEngine 通常不会自己创建所有候选方案。

候选可以来自：

MethodEngine → Method Candidates

MatchingEngine → Matched Candidates

CapabilityEngine → Available Capabilities

RiskEngine → Handling Candidates

ConflictEngine → Conflict Handling Candidates

DiagnosisEngine → Repair Candidates

因此：

$CandidateSource={Method,Matching,Capability,Risk,Conflict,Diagnosis}CandidateSource= \{ Method, Matching, Capability, Risk, Conflict, Diagnosis \}$

DecisionEngine 将这些候选统一进入决策计算。

198.6 候选方案预过滤

在进入正式决策计算之前，需要先排除明显不具备选择资格的候选。

可以定义：

$Eligible(Ci)=State∧Condition∧Capability∧Resource∧ValidityEligible(C_i)= State \land Condition \land Capability \land Resource \land Validity$

如果：

$Eligible(Ci)=falseEligible(C_i)=false$

则：

$Ci∉CvalidC_i\notin C_{valid}$

因此：

$Cvalid={Ci∣Eligible(Ci)=true}C_{valid} = \{C_i\mid Eligible(C_i)=true\}$

这一步可以由 MatchingEngine、MethodEngine 等提前完成，也可以由 DecisionEngine 再次进行最终条件检查。

198.7 候选状态

Candidate 必须具有明确状态。

基础状态可以定义为：

Unknown；
Available；
Unavailable；
Blocked；
Eligible；
Selected；
Rejected；
Failed；
Expired；
Conflicted。

状态变化可以表示：

$Unknown→Evaluated→Eligible→SelectedUnknown \rightarrow Evaluated \rightarrow Eligible \rightarrow Selected$

或者：

$Evaluated→RejectedEvaluated \rightarrow Rejected$

以及：

$Eligible→BlockedEligible \rightarrow Blocked$

Candidate State 与 Decision Result 必须分离。

候选本身可以是 Available，但最终不一定被选择。

因此：

$Available≠SelectedAvailable \neq Selected$

198.8 条件计算

198.8.1 Decision Condition

Decision Condition 是决策计算时使用的条件集合。

可以定义：

$DC=(G,C,M,O,E,R,P)DC=(G,C,M,O,E,R,P)$

其中：

$GG$ ：Goal；
$CC$ ：Current Condition；
$MM$ ：Method；
$OO$ ：Object；
$EE$ ：Environment；
$RR$ ：Resource；
$PP$ ：Priority。

DecisionEngine 根据这些条件判断候选方案是否满足当前决策要求。

198.9 条件计算与方法条件的区别

必须区分：

Method Condition

回答：

“这个方法能不能执行？”

Decision Condition

回答：

“当前多个可执行方案中，应该如何比较和选择？”

例如：

Method A 要求：

$Temperature<20Temperature<20$

这是 Method Condition。

如果 Method A 和 Method B 都满足执行条件，而：

Method A 成本低；

Method B 风险低；

那么比较成本和风险就是 Decision Condition / Decision Factor。

因此：

$MethodCondition≠DecisionConditionMethodCondition \neq DecisionCondition$

198.10 条件计算过程

DecisionEngine 可以按照以下过程进行条件计算：

Load Candidate

↓

Load Goal

↓

Load Current State

↓

Load Capability

↓

Load Method

↓

Load Resource

↓

Load Risk

↓

Load Conflict

↓

Load Rule

↓

Evaluate Condition

↓

Candidate Eligibility

↓

Decision Factors

↓

Decision Calculation

这样可以确保决策不是脱离 Runtime 的静态选择。

198.11 条件结果

条件计算不能只返回 true / false。

可以定义：

$ConditionResult=(C,V,R,E,S,T)ConditionResult=(C,V,R,E,S,T)$

其中：

$CC$ ：Condition；
$VV$ ：Value；
$RR$ ：Comparison Result；
$EE$ ：Evidence；
$SS$ ：Status；
$TT$ ：Time。

条件结果可以为：

Pass；
Partial；
Fail；
Unknown；
Blocked；
Conflicted；
Expired。

例如：

$Cost<100→PassCost<100 \rightarrow Pass$ $ResourceAvailable=false→FailResourceAvailable=false \rightarrow Fail$ $CurrentState=Unknown→UnknownCurrentState=Unknown \rightarrow Unknown$

如果关键条件为 Unknown，则不能强行认为候选可用。

198.12 决策因素

DecisionEngine 可以将多个因素转换为离散计算指标。

例如：

Goal Priority；
Capability Match；
Method Validity；
Resource Availability；
Risk；
Conflict；
Cost；
Time；
Reliability；
Historical Experience；
Verification；
State Compatibility。

可以定义：

$F={F1,F2,…,Fn}F=\{F_1,F_2,\ldots,F_n\}$

每个因素都必须具有明确来源和计算方式。

例如：

$Frisk=RiskScoreF_{risk}=RiskScore$ $Fpriority=GoalPriorityF_{priority}=GoalPriority$ $Fresource=ResourceAvailabilityF_{resource}=ResourceAvailability$

这样决策结果能够解释“为什么选择”。

198.13 决策计算

决策计算是 DecisionEngine 的核心。

其基本模型为：

$D(C1,C2,…,Cn,F,R)→DrD(C_1,C_2,\ldots,C_n,F,R)\rightarrow D_r$

其中：

$CiC_i$ ：候选方案；
$FF$ ：决策因素；
$RR$ ：决策规则；
$DrD_r$ ：Decision Result。

在确定性系统中，可以使用离散规则和加权计算。

例如：

$Score(Ci)=∑j=1mWjVijScore(C_i) = \sum_{j=1}^{m}W_jV_{ij}$

其中：

$WjW_j$ ：第 $jj$ 个因素的权重；
$VijV_{ij}$ ：候选 $CiC_i$ 在因素 $jj$ 上的评价值；
$mm$ ：因素数量。

这些权重不是神经网络权重。

它们是：

人工定义、规则定义、配置定义或经过明确统计验证的离散决策参数。

198.14 决策计算示例

假设存在三个候选：

$C1,C2,C3C_1,C_2,C_3$

考虑三个因素：

Goal Priority；
Risk；
Resource Availability。

可以定义：

$Score(Ci)=WpPi+WrRi+WaAiScore(C_i) = W_pP_i + W_rR_i + W_aA_i$

其中：

$PiP_i$ ：优先级值；
$RiR_i$ ：风险评价值；
$AiA_i$ ：资源可用性值。

如果：

$Score(C1)=82Score(C_1)=82$ $Score(C2)=74Score(C_2)=74$ $Score(C3)=61Score(C_3)=61$

则：

$C1>C2>C3C_1>C_2>C_3$

但还不能直接输出 C1。

因为还必须检查：

$Eligible(C1)=trueEligible(C_1)=true$

如果 C1 当前被 Blocked，那么即使 Score 最高，也不能选择。

因此：

$SelectedCandidate=argmax(Score(Ci))SelectedCandidate = argmax(Score(C_i))$

必须建立在：

$Ci∈CvalidC_i\in C_{valid}$

的基础上。

198.15 决策不是单纯最高分

ICAI 的 DecisionEngine 不应该把所有决策简化成：

$HighestScore=SelectedHighestScore=Selected$

因为某些条件属于硬约束。

例如：

$Safety=falseSafety=false$

即使：

$Score=100Score=100$

也不能选择。

因此决策可以分成：

第一层：硬条件

必须满足：

$HardCondition(Ci)=trueHardCondition(C_i)=true$

第二层：软因素

在满足硬条件的候选中比较：

$SoftScore(Ci)SoftScore(C_i)$

最终：

$Selected=argmax(SoftScore(Ci))Selected = argmax \left( SoftScore(C_i) \right)$

其中：

$Ci∈Chard−validC_i\in C_{hard-valid}$

这样可以避免“高分覆盖硬约束”的错误。

198.16 决策优先级

DecisionEngine 可以建立多层优先级：

合法性

→

安全性

→

目标满足程度

→

资源可用性

→

风险

→

成本

→

时间

→

历史经验

具体优先级必须由系统规则定义，而不能由 Engine 自行产生。

因此：

$PriorityRule→DecisionEnginePriorityRule \rightarrow DecisionEngine$

而不是：

$DecisionEngine→RandomPriorityDecisionEngine \rightarrow RandomPriority$

198.17 无候选决策

一个成熟的决策系统必须允许：

$∣Cvalid∣=0|C_{valid}|=0$

即：

没有任何合法候选方案。

此时不能强行选择。

Decision Result 应输出：

$DecisionStatus=NoCandidateDecisionStatus=NoCandidate$

并说明：

为什么没有候选；
哪些条件失败；
哪些候选被 Blocked；
是否存在 Conflict；
是否存在 Risk；
是否需要重新生成 Method；
是否需要修改 Goal；
是否需要人工介入。

因此：

$NoCandidateNoCandidate$

也是一个合法决策结果。

198.18 候选并列

如果：

$Score(C1)=Score(C2)Score(C_1)=Score(C_2)$

不能随机选择。

系统必须进一步使用确定性规则。

例如：

$TieBreak=Priority→Risk→Cost→Time→IDTieBreak= Priority \rightarrow Risk \rightarrow Cost \rightarrow Time \rightarrow ID$

最后使用唯一 ID 作为稳定排序条件。

因此：

$Tie→DeterministicTieBreakTie \rightarrow DeterministicTieBreak$

而不是：

$Tie→RandomChoiceTie \rightarrow RandomChoice$

这样可以保证同样输入得到稳定结果。

198.19 决策输出

198.19.1 DecisionResult

DecisionEngine 的最终输出可以定义为：

$DR=(D,C,S,R,F,E,T)DR=(D,C,S,R,F,E,T)$

其中：

$DD$ ：Decision ID；
$CC$ ：Selected Candidate；
$SS$ ：Decision Status；
$RR$ ：Reason；
$FF$ ：Factors；
$EE$ ：Evidence；
$TT$ ：Time。

Decision Result 至少应包含：

Decision ID；
Candidate List；
Selected Candidate；
Candidate State；
Decision Conditions；
Calculation；
Reason；
Evidence；
Risk；
Conflict；
Decision Status；
Time。

198.20 决策状态

Decision 本身也应该拥有生命周期。

可以定义：

$Created→Evaluating→Calculated→Selected→ConfirmedCreated \rightarrow Evaluating \rightarrow Calculated \rightarrow Selected \rightarrow Confirmed$

异常情况下：

$Evaluating→FailedEvaluating \rightarrow Failed$

或者：

$Calculated→NoCandidateCalculated \rightarrow NoCandidate$

也可以：

$Selected→BlockedSelected \rightarrow Blocked$

因为候选在选择之后仍然可能由于 Runtime 变化而失效。

因此：

$Selected≠ExecutedSelected \neq Executed$ $Executed≠SuccessfulExecuted \neq Successful$ $Successful≠VerifiedSuccessful \neq Verified$

198.21 决策输出与执行的边界

DecisionEngine 输出：

选择什么。

BehaviorEngine 负责：

如何组织执行。

ActionEngine 负责：

具体执行什么动作。

ExecutionEngine 负责：

实际运行。

因此完整关系为：

$Decision→Behavior→Action→ExecutionDecision \rightarrow Behavior \rightarrow Action \rightarrow Execution$

例如 DecisionEngine 输出：

$SelectedMethod=M3SelectedMethod=M_3$

并不意味着 M3 已经执行。

必须经过：

DecisionEngine → DecisionService → BehaviorService → BehaviorEngine → ActionEngine → ExecutionEngine

才能进入实际执行。

198.22 决策证据

DecisionEngine 必须具有可解释性。

决策结果应该能够回答：

为什么选择这个方案？

因此：

$DecisionEvidence=Condition+Candidate+Calculation+Rule+ResultDecisionEvidence= Condition + Candidate + Calculation + Rule + Result$

例如：

Candidate: Method-003
Condition: Capability available
Resource: Available
Risk: Low
Conflict: None
Goal Priority: High
Score: 86
Decision: Selected
Reason: Highest valid score under current constraints

这样决策可以被 History、Memory、Experience 和 LearningEngine 使用。

198.23 DecisionEngine与MatchingEngine

MatchingEngine 和 DecisionEngine 的边界必须明确。

MatchingEngine：

这个候选是否匹配要求？

DecisionEngine：

多个匹配候选中选择哪个？

因此：

$MatchingEngine→MatchedCandidatesMatchingEngine \rightarrow MatchedCandidates$

然后：

$MatchedCandidates→DecisionEngineMatchedCandidates \rightarrow DecisionEngine$

例如：

三个 Method：

$M1,M2,M3M_1,M_2,M_3$

MatchingEngine 得到：

$M1=MatchedM_1=Matched$ $M2=MatchedM_2=Matched$ $M3=PartialM_3=Partial$

DecisionEngine 再在符合决策条件的候选中进行选择。

所以：

$Matching≠DecisionMatching \neq Decision$

198.24 DecisionEngine与MethodEngine

MethodEngine 可以计算：

方法结构；
方法条件；
方法过程；
Action；
Capability；
Resource；
Expected Result；
Method Verification。

DecisionEngine 则比较多个 Method。

因此：

$MethodEngine→MethodCandidatesMethodEngine \rightarrow MethodCandidates$ $DecisionEngine→SelectedMethodDecisionEngine \rightarrow SelectedMethod$

MethodEngine 不应该因为某个方法 Score 高就直接执行。

198.25 DecisionEngine与RiskEngine

RiskEngine 提供：

$RiskScoreRiskScore$

DecisionEngine 使用：

$RiskScoreRiskScore$

参与候选比较。

例如：

$Risk(C1)=20Risk(C_1)=20$ $Risk(C2)=60Risk(C_2)=60$

如果其他条件相近，则 C1 可能具有更高决策优先级。

但：

$RiskEngine≠DecisionEngineRiskEngine \neq DecisionEngine$

RiskEngine 只计算风险。

DecisionEngine 决定如何使用风险结果。

198.26 DecisionEngine与ConflictEngine

ConflictEngine 提供：

Conflict Type；
Conflict Level；
Blocking State；
Handling Candidate。

DecisionEngine 决定：

是否改变方案；
是否暂停；
是否重新排序；
是否更换 Method；
是否重新规划；
是否人工介入。

因此：

$ConflictEngine→HandlingCandidatesConflictEngine \rightarrow HandlingCandidates$ $DecisionEngine→SelectedHandlingDecisionEngine \rightarrow SelectedHandling$

198.27 DecisionEngine与KnowledgeEngine

KnowledgeEngine 提供经过验证的知识。

DecisionEngine 使用这些知识作为条件或证据。

例如：

$Knowledge:ResourceX→ExclusiveKnowledge: Resource_X \rightarrow Exclusive$

DecisionEngine 可以据此判断两个候选是否可以同时执行。

但：

$KnowledgeEngine≠DecisionEngineKnowledgeEngine \neq DecisionEngine$

KnowledgeEngine 计算知识。

DecisionEngine 使用知识进行决策计算。

198.28 DecisionEngine与Memory、Experience

Memory 和 Experience 可以提供历史依据。

例如：

历史记录显示：

$M1M_1$

在某类条件下曾经成功完成。

Experience 可以形成：

$Condition_X \rightarrow Method_M_1$

DecisionEngine 可以把这种经验作为一个因素。

但是：

$Experience≠DecisionExperience \neq Decision$

过去成功不能保证当前一定成功。

当前 Runtime、State、Condition 和 Verification 仍然具有优先权。

198.29 决策重新计算

Decision 不是一次永久结果。

当 Runtime 发生变化时：

$Runtimet≠Runtimet+1Runtime_t\neq Runtime_{t+1}$

原来的 Decision 可能失效。

因此：

$Decisiont→StateChange→Recalculate→Decisiont+1Decision_t \rightarrow StateChange \rightarrow Recalculate \rightarrow Decision_{t+1}$

例如：

原来：

$M1=SelectedM_1=Selected$

随后：

$ResourceX=UnavailableResource_X=Unavailable$

则：

$M1=BlockedM_1=Blocked$

DecisionEngine 必须重新计算候选：

$M2,M3M_2,M_3$

形成新的：

$Decisiont+1Decision_{t+1}$

这就是动态决策。

198.30 决策历史

每一次决策都必须保存历史。

Decision History 可以定义为：

$DH=(D,C,F,R,S,T)DH=(D,C,F,R,S,T)$

其中：

$DD$ ：Decision；
$CC$ ：Candidates；
$FF$ ：Factors；
$RR$ ：Result；
$SS$ ：Status；
$TT$ ：Time。

History 保存的是：

当时发生了什么决策。

Experience 保存的是：

从多个历史中形成了什么结构性经验。

因此：

$DecisionHistory≠ExperienceDecisionHistory \neq Experience$

198.31 PHP OOP工程实现

DecisionEngine 不应该直接操作数据库。

基础结构可以定义：

class DecisionEngine extends Engine
{
    public function calculate($input)
    {
        $candidates = $this->getCandidates($input);
        $eligible = array();

        foreach ($candidates as $candidate) {
            $condition = $this->calculateCondition(
                $candidate,
                $input
            );

            if ($condition['status'] === 'Pass') {
                $eligible[] = $candidate;
            }
        }

        if (count($eligible) === 0) {
            return new EngineResult(
                $input,
                null,
                array(
                    'status' => 'NoCandidate'
                ),
                'decision_calculation'
            );
        }

        $calculated = array();

        foreach ($eligible as $candidate) {
            $calculated[] = $this->calculateCandidateScore(
                $candidate,
                $input
            );
        }

        $selected = $this->selectBestCandidate(
            $calculated,
            $input
        );

        return new EngineResult(
            $input,
            $selected,
            $calculated,
            'decision_calculation'
        );
    }

    protected function getCandidates($input)
    {
        return isset($input['candidates'])
            ? $input['candidates']
            : array();
    }

    protected function calculateCondition($candidate, $input)
    {
        return array(
            'status' => 'Pass'
        );
    }

    protected function calculateCandidateScore($candidate, $input)
    {
        return array(
            'candidate' => $candidate,
            'score' => 0
        );
    }

    protected function selectBestCandidate($candidates, $input)
    {
        $best = null;

        foreach ($candidates as $candidate) {
            if ($best === null ||
                $candidate['score'] > $best['score']) {
                $best = $candidate;
            }
        }

        return $best;
    }
}

这个结构体现的是 DecisionEngine 的工程职责：

输入候选 → 条件计算 → 候选计算 → 选择 → EngineResult

其中具体项目中的条件、评分、权重、约束和验证规则必须由实际系统规则实现，不能把示例代码中的默认值直接视为已经完成的生产规则。

198.32 DecisionService与DecisionEngine

DecisionService 负责流程组织。

DecisionEngine 负责计算。

可以定义：

$DecisionService=OrchestrationDecisionService=Orchestration$ $DecisionEngine=ComputationDecisionEngine=Computation$

例如：

class DecisionService
{
    protected $engine;
    protected $repository;

    public function __construct($engine, $repository)
    {
        $this->engine = $engine;
        $this->repository = $repository;
    }

    public function decide($context)
    {
        $result = $this->engine->calculate($context);

        $this->repository->save($result);

        return $result;
    }
}

调用关系：

Controller → DecisionService → DecisionEngine → EngineResult → DecisionRepository → MySQL

198.33 数据库结构

DecisionEngine 的计算结果可以通过 Repository 保存。

基础表可以包括：

decisions

保存决策主体：

id
individual_id
goal_id
selected_candidate_id
selected_candidate_type
status
reason
created_at
updated_at

decision_candidates

保存参与决策的候选：

id
decision_id
candidate_id
candidate_type
state
eligibility
score
rank
reason

decision_conditions

保存决策条件：

id
decision_id
condition_type
condition_value
result
evidence
created_at

decision_results

保存最终结果：

id
decision_id
selected_candidate_id
result_status
calculation
reason
verification
created_at

decision_history

保存决策生命周期：

id
decision_id
old_state
new_state
reason
created_at

数据库负责保存事实和历史。

DecisionEngine 负责计算。

198.34 决策完整工程流程

DecisionEngine 的完整流程可以表示为：

Load Runtime

↓

Load Goal

↓

Load Current State

↓

Load Candidates

↓

Load Capability

↓

Load Method

↓

Load Resource

↓

Load Knowledge

↓

Load Risk

↓

Load Conflict

↓

Load Decision Rules

↓

Candidate Validation

↓

Condition Calculation

↓

Eligibility Calculation

↓

Factor Calculation

↓

Candidate Scoring

↓

Candidate Ranking

↓

Tie Breaking

↓

Candidate Selection

↓

Decision Verification

↓

DecisionResult

↓

DecisionService

↓

BehaviorService

↓

BehaviorEngine

↓

ActionEngine

↓

ExecutionEngine

198.35 决策完整闭环

DecisionEngine 的动态闭环可以表示为：

$Goal→Candidate→Condition→Calculation→Selection→Decision→Behavior→Action→Execution→Result→Feedback→StateUpdate→ReDecisionGoal \rightarrow Candidate \rightarrow Condition \rightarrow Calculation \rightarrow Selection \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow Feedback \rightarrow StateUpdate \rightarrow ReDecision$

如果执行成功：

$Decision→Execution→Result→VerificationDecision \rightarrow Execution \rightarrow Result \rightarrow Verification$

如果执行失败：

$Decision→Failure→Diagnosis→Repair→Verification→ReDecisionDecision \rightarrow Failure \rightarrow Diagnosis \rightarrow Repair \rightarrow Verification \rightarrow ReDecision$

如果执行过程中出现新的风险：

$Decision→Risk→Handling→ReDecisionDecision \rightarrow Risk \rightarrow Handling \rightarrow ReDecision$

如果出现新的冲突：

$Decision→Conflict→ConflictHandling→ReDecisionDecision \rightarrow Conflict \rightarrow ConflictHandling \rightarrow ReDecision$

因此 DecisionEngine 是 ICAI 动态认知循环中的重要重新计算节点。

198.36 决策的确定性原则

ICAI 的 DecisionEngine 必须满足确定性原则。

相同输入：

$Inputt=Inputt+1Input_t=Input_{t+1}$

以及相同：

$Rulet=Rulet+1Rule_t=Rule_{t+1}$

则：

$Decisiont=Decisiont+1Decision_t=Decision_{t+1}$

除非时间、状态、环境或其他显式输入发生变化。

因此：

$SameInput+SameRule→SameDecisionSameInput+SameRule \rightarrow SameDecision$

而不是：

$SameInput→RandomDecisionSameInput \rightarrow RandomDecision$

这也是 ICAI 与基于生成式模型的随机输出机制的重要工程区别。

198.37 决策计算的可解释性

任何最终决策都应该能够回溯：

$Decision→Candidate→Condition→Factor→Rule→Calculation→EvidenceDecision \rightarrow Candidate \rightarrow Condition \rightarrow Factor \rightarrow Rule \rightarrow Calculation \rightarrow Evidence$

因此系统能够回答：

为什么没有选择 Candidate A？

为什么选择 Candidate B？

Candidate C 为什么被阻塞？

哪个条件导致 Candidate A 失效？

哪个风险降低了 Candidate B 的优先级？

哪个冲突导致 Candidate C 被排除？

这种可追溯结构是 ICAI 工程认知系统的重要基础。

198.38 DecisionEngine的工程边界

DecisionEngine 必须保持明确职责。

第一，负责候选方案计算。

第二，负责决策条件计算。

第三，负责候选比较。

第四，负责决策评分或规则计算。

第五，负责候选排序。

第六，负责最终决策结果生成。

第七，负责输出决策理由和证据。

但 DecisionEngine：

不直接执行 Action。

不直接运行 Behavior。

不直接修改外部对象。

不负责数据库持久化。

不负责诊断实际故障。

不负责修复故障。

不负责生成知识。

不负责经验学习。

它只负责：

$Candidate→Condition→Calculation→DecisionCandidate \rightarrow Condition \rightarrow Calculation \rightarrow Decision$

198.39 DecisionEngine核心公式

本章可以将 DecisionEngine 的核心计算归纳为：

候选集合

$C={C1,C2,…,Cn}C=\{C_1,C_2,\ldots,C_n\}$

候选有效性

$Eligible(Ci)=State∧Condition∧Capability∧Resource∧ValidityEligible(C_i) = State \land Condition \land Capability \land Resource \land Validity$

有效候选集合

$Cv={Ci∣Eligible(Ci)=true}C_v= \{C_i\mid Eligible(C_i)=true\}$

决策评分

$Score(Ci)=∑j=1mWjVijScore(C_i) = \sum_{j=1}^{m}W_jV_{ij}$

候选选择

$Selected=argmaxCi∈CvScore(Ci)Selected = argmax_{C_i\in C_v} Score(C_i)$

无候选

$∣Cv∣=0⇒DecisionStatus=NoCandidate|C_v|=0 \Rightarrow DecisionStatus=NoCandidate$

决策输出

$DecisionResult=Selected+Reason+Condition+Calculation+Evidence+StatusDecisionResult = Selected + Reason + Condition + Calculation + Evidence + Status$

最终形成：

$Candidate→Condition→Calculation→Ranking→Selection→DecisionOutputCandidate \rightarrow Condition \rightarrow Calculation \rightarrow Ranking \rightarrow Selection \rightarrow DecisionOutput$

198.40 本章总结

DecisionEngine 是 ICAI 中负责候选方案、条件计算、决策计算和决策输出的核心 Engine。

它不是简单的“选择器”，而是建立在 Object、State、Goal、Capability、Method、Knowledge、Resource、Risk、Conflict、Memory、Experience 和 Rule 等结构化信息之上的确定性计算机制。

其核心流程是：

候选方案 → 条件计算 → 有效性判断 → 决策因素 → 决策计算 → 候选排序 → 最终选择 → 决策输出

DecisionEngine 必须允许：

有多个候选。

只有一个候选。

没有候选。

多个候选并列。

候选被阻塞。

候选条件未知。

候选之间存在冲突。

这些情况都必须通过明确状态和规则进行处理，而不能通过随机选择解决。

在 ICAI 的完整工程体系中：

MatchingEngine 判断是否匹配。

MethodEngine 计算方法。

RiskEngine 计算风险。

ConflictEngine 计算冲突。

DecisionEngine 负责最终选择。

随后：

Decision → Behavior → Action → Execution → Result → Feedback → State Update → ReDecision

由此形成动态决策闭环。

DecisionEngine 的核心原则可以归纳为：

候选必须可解释，条件必须可计算，选择必须有依据，结果必须可追溯，没有合法候选时必须允许“不决策”，决策完成后必须经过实际执行与结果验证。

最终：

$ICAI Decision=Candidate+Condition+Calculation+Selection+OutputICAI\ Decision = Candidate + Condition + Calculation + Selection + Output$

这使 DecisionEngine 成为 ICAI 从“能够识别对象、状态和方法”进一步进入“能够在当前条件下进行确定性选择”的核心认知计算层。

第198章 DecisionEngine

第198章 DecisionEngine

198.1 DecisionEngine概述

198.2 Decision的基本定义

198.3 候选方案

198.3.1 Candidate定义

198.4 候选方案的结构

198.5 候选方案的来源

198.6 候选方案预过滤

198.7 候选状态

198.8 条件计算

198.8.1 Decision Condition

198.9 条件计算与方法条件的区别

198.10 条件计算过程

198.11 条件结果

198.12 决策因素

198.13 决策计算

198.14 决策计算示例

198.15 决策不是单纯最高分

第一层：硬条件

第二层：软因素

198.16 决策优先级

198.17 无候选决策

198.18 候选并列

198.19 决策输出

198.19.1 DecisionResult

198.20 决策状态

198.21 决策输出与执行的边界

198.22 决策证据

198.23 DecisionEngine与MatchingEngine

198.24 DecisionEngine与MethodEngine

198.25 DecisionEngine与RiskEngine

198.26 DecisionEngine与ConflictEngine

198.27 DecisionEngine与KnowledgeEngine

198.28 DecisionEngine与Memory、Experience

198.29 决策重新计算

198.30 决策历史

198.31 PHP OOP工程实现

198.32 DecisionService与DecisionEngine

198.33 数据库结构

decisions

decision_candidates

decision_conditions

decision_results

decision_history

198.34 决策完整工程流程

198.35 决策完整闭环

198.36 决策的确定性原则

198.37 决策计算的可解释性

198.38 DecisionEngine的工程边界

198.39 DecisionEngine核心公式

候选集合

候选有效性

有效候选集合

决策评分

候选选择

无候选

决策输出

198.40 本章总结