第161章　Decision类

161.1 提出背景

在前面的章节中，个体已经建立了Need、Goal、Capability和Method等认知工程对象。

其中：

Need解决“为什么需要”。

Goal解决“需要达到什么目标”。

Capability解决“是否具有完成目标的能力”。

Method解决“可以采用什么方法完成”。

但是，当系统同时存在多个可用的Capability、Method或者Behavior时，仅仅知道“可以做什么”以及“可以怎么做”仍然不够。

个体还必须解决一个新的问题：

“在多个可能方案中，现在应该选择哪一个？”

例如，一个个体需要完成“移动杯子”这个Goal，系统可能存在：

Method A → 直接移动
Method B → 分阶段移动
Method C → 绕开障碍物移动

三个Method都可能具有执行条件。

此时系统不能简单地将三个Method全部执行，而必须经过：

Candidate → Condition → Comparison → Selection → Result

这个过程就是Decision。

因此，Decision（决策）是个体从多个可能候选方案中，根据当前条件进行判断并确定一个执行选择的认知工程对象。

本章建立：

Decision
├── Candidate
├── Condition
├── Result
└── History

形成完整的决策对象。

---

161.2 Decision概念定义

Decision（决策）是个体针对某一Goal，在当前Condition下，对多个Candidate进行判断、比较和选择，并形成确定Result的认知过程。

可以定义：

Decision=Candidate+Condition+Result+HistoryDecision = Candidate + Condition + Result + History

进一步表示为：

D=(C,Co,R,H)D=(C,Co,R,H)

其中：

• D：Decision，决策；
• C：Candidate，候选项；
• Co：Condition，决策条件；
• R：Result，决策结果；
• H：History，决策历史。

Decision的核心不是“拥有候选项”，而是：

在一定条件下，对候选项进行判断，并产生选择结果。

因此：

Candidate
    ↓
Condition
    ↓
Comparison
    ↓
Selection
    ↓
Result
    ↓
History

形成一个完整的离散决策过程。

---

161.3 Decision与Method的关系

Method解决“采用什么方法”。

Decision解决“多个方法中选择哪一个”。

例如：

Goal
 ↓
Capability
 ↓
Methods
 ├── Method A
 ├── Method B
 └── Method C

此时：

Method A
Method B
Method C

都是Candidate。

Decision负责：

Candidate A
Candidate B
Candidate C
        ↓
Condition
        ↓
Comparison
        ↓
Decision
        ↓
Selected Method

因此：

Method是决策对象之一，Decision不是Method本身。

可以表示为：

Decision→MethodDecision \rightarrow Method

但不能反过来认为：

Method=DecisionMethod = Decision

---

161.4 Candidate

Candidate（候选项）是进入决策范围、具有被判断和选择可能性的对象。

Candidate可以是：

Capability
Method
Behavior
Action
Object
Route
Strategy

具体由Decision的类型决定。

例如：

Decision Type = Method Selection

则Candidate：

Method A
Method B
Method C

如果：

Decision Type = Object Selection

则Candidate可能是：

Object A
Object B
Object C

因此：

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

其中：

• C1C_1：候选项1；
• C2C_2：候选项2；
• CnC_n：候选项n。

Candidate本身不是最终结果。

只有经过Decision之后，其中一个或多个Candidate才能成为Selected Candidate。

---

161.5 Candidate对象化

Candidate应该成为独立的工程对象，而不是直接使用字符串。

例如：

class Candidate
{
    protected $id;
    protected $type;
    protected $object;
    protected $state;
    protected $conditions;

    public function __construct($id, $type, $object)
    {
        $this->id = $id;
        $this->type = $type;
        $this->object = $object;
        $this->state = 'available';
        $this->conditions = array();
    }

    public function getId()
    {
        return $this->id;
    }

    public function getType()
    {
        return $this->type;
    }

    public function getObject()
    {
        return $this->object;
    }

    public function setState($state)
    {
        $this->state = $state;
    }

    public function getState()
    {
        return $this->state;
    }

    public function addCondition($condition)
    {
        $this->conditions[] = $condition;
    }

    public function getConditions()
    {
        return $this->conditions;
    }
}

这样系统得到：

Candidate
├── ID
├── Type
├── Object
├── State
└── Conditions

Candidate因此可以被Decision统一管理。

---

161.6 Candidate状态

候选项不是全部都可以进入最终选择。

Candidate可能具有不同状态：

unknown
available
unavailable
blocked
selected
rejected
failed

例如：

Method A → available
Method B → blocked
Method C → available

Decision首先需要过滤：

Candidate
    ↓
State Check
    ↓
Available Candidates

因此：

All Candidates
        ↓
Condition
        ↓
State
        ↓
Eligible Candidates

只有满足基本条件的Candidate才进入进一步比较。

---

161.7 Condition

Condition（决策条件）是Decision进行判断时所依据的当前事实、状态和约束。

Decision不是无条件产生的。

同样的Candidate，在不同Condition下可能产生不同的Decision。

例如：

Condition A:
distance < 10

可能选择：

Method A

而：

Condition B:
distance >= 10

可能选择：

Method B

因此：

Decision=f(Candidate,Condition)Decision=f(Candidate,Condition)

Decision结果不是固定值，而是当前候选项与当前条件共同计算产生的结果。

---

161.8 Decision Condition与Method Condition的区别

Decision Condition与Method Condition不能混淆。

Method Condition：

判断某个Method是否可以执行。

Decision Condition：

判断多个Candidate中应该选择哪个。

例如：

Method A Condition
object_visible = true

说明Method A可以执行。

而Decision Condition：

distance < 10

可能决定：

Method A

优先于：

Method B

因此：

Decision
   ↓
选择Method
   ↓
Method Condition
   ↓
确认Method可以执行

形成两个不同层次：

Decision Condition
    ↓
Candidate Selection

Method Condition
    ↓
Method Execution

---

161.9 Condition对象化

可以建立通用Condition对象：

class DecisionCondition
{
    protected $type;
    protected $operator;
    protected $value;

    public function __construct($type, $operator, $value)
    {
        $this->type = $type;
        $this->operator = $operator;
        $this->value = $value;
    }

    public function check($context)
    {
        if (!isset($context[$this->type])) {
            return false;
        }

        switch ($this->operator) {

            case '=':
                return $context[$this->type] == $this->value;

            case '!=':
                return $context[$this->type] != $this->value;

            case '>':
                return $context[$this->type] > $this->value;

            case '<':
                return $context[$this->type] < $this->value;

            case '>=':
                return $context[$this->type] >= $this->value;

            case '<=':
                return $context[$this->type] <= $this->value;
        }

        return false;
    }
}

运行过程：

Context
   ↓
DecisionCondition
   ↓
Operator
   ↓
Comparison
   ↓
true / false

由此，Condition成为真正可以参与Decision计算的工程对象。

---

161.10 Candidate比较

Decision的核心过程是Candidate Comparison（候选比较）。

例如：

Candidate A
Candidate B
Candidate C

系统需要分别判断：

A是否满足条件？
B是否满足条件？
C是否满足条件？

形成：

A → Condition → true
B → Condition → false
C → Condition → true

得到：

Eligible Candidates:
A
C

然后继续进行选择。

因此：

Eligible(Ci)=Condition(Ci)Eligible(C_i)=Condition(C_i)

只有：

Eligible(Ci)=trueEligible(C_i)=true

的Candidate才能进入选择集合。

---

161.11 Candidate Selection

Candidate Selection（候选选择）是Decision从有效Candidate中确定最终选择对象的过程。

例如：

Candidate A
Candidate B
Candidate C

经过Condition：

A → true
B → false
C → true

剩余：

A
C

然后根据明确的规则继续比较。

例如：

Rule 1：距离更近
Rule 2：状态更稳定
Rule 3：历史验证通过

最后：

Selected Candidate = A

因此：

Candidates
    ↓
Condition
    ↓
Eligible Candidates
    ↓
Comparison Rules
    ↓
Selected Candidate

---

161.12 Decision Result

Result（决策结果）是Decision完成判断后产生的实际选择结果。

例如：

Decision
    ↓
Selected Candidate
    ↓
Method A

则：

Decision Result = Method A

Result可以包含：

selected_candidate
decision_state
reason
condition_state

例如：

$result = array(
    'status' => 'selected',
    'candidate_id' => 'method_01',
    'reason' => 'condition_matched'
);

因此Result不应该只有：

true

而应该记录：

选择了谁、为什么选择、决策是否完成。

---

161.13 Decision Result对象化

可以建立：

class DecisionResult
{
    protected $status;
    protected $candidate;
    protected $reason;

    public function __construct($status, $candidate, $reason)
    {
        $this->status = $status;
        $this->candidate = $candidate;
        $this->reason = $reason;
    }

    public function getStatus()
    {
        return $this->status;
    }

    public function getCandidate()
    {
        return $this->candidate;
    }

    public function getReason()
    {
        return $this->reason;
    }
}

例如：

$result = new DecisionResult(
    'selected',
    $candidate,
    'condition_matched'
);

系统得到：

DecisionResult
├── Status
├── Candidate
└── Reason

---

161.14 History

History（历史）用于保存过去已经发生的Decision。

决策不能只保存当前结果。

如果系统过去曾经做出：

Method A

后来又选择：

Method C

系统应该能够知道：

过去选择了什么？
当时条件是什么？
为什么选择？
最终产生了什么结果？

因此：

History={D1,D2,…,Dn}History=\{D_1,D_2,…,D_n\}

其中：

• D1D_1：第一次决策；
• D2D_2：第二次决策；
• DnD_n：第n次决策。

History使Decision具有时间维度。

---

161.15 Decision History结构

一个Decision History可以保存：

array(
    'candidate' => 'method_01',
    'conditions' => array(
        'distance' => 5,
        'object_visible' => true
    ),
    'result' => 'selected',
    'time' => '2026-09-08 10:00:00'
)

因此：

Decision History
├── Candidate
├── Condition
├── Result
└── Time

历史记录可以用于后续Experience：

Decision
   ↓
Result
   ↓
History
   ↓
Experience

---

161.16 History与Experience的区别

History与Experience相关，但不能混淆。

History主要回答：

“过去发生过什么决策？”

Experience主要回答：

“从过去发生的事情中形成了什么经验？”

例如：

History:
Method A was selected.
Result = failed.

这是历史事实。

经过系统分析：

Method A
+
distance > 10
+
Repeated Failure

可以形成：

Experience:
Method A is unsuitable when distance > 10.

因此：

History → Experience

但：

History ≠ Experience

History保存事实，Experience保存经过整理后的运行经验。

---

161.17 Decision类

根据上述模型，可以建立基础Decision类：

class Decision
{
    protected $candidates;
    protected $conditions;
    protected $result;
    protected $history;
    protected $state;

    public function __construct()
    {
        $this->candidates = array();
        $this->conditions = array();
        $this->result = null;
        $this->history = array();
        $this->state = 'pending';
    }

    public function addCandidate($candidate)
    {
        $this->candidates[] = $candidate;
    }

    public function addCondition($condition)
    {
        $this->conditions[] = $condition;
    }

    public function setResult($result)
    {
        $this->result = $result;
    }

    public function getResult()
    {
        return $this->result;
    }

    public function setState($state)
    {
        $this->state = $state;
    }

    public function getState()
    {
        return $this->state;
    }

    public function addHistory($history)
    {
        $this->history[] = $history;
    }

    public function getHistory()
    {
        return $this->history;
    }
}

形成：

Decision
├── Candidates
├── Conditions
├── Result
├── History
└── State

---

161.18 Decision执行

Decision需要一个明确的执行过程。

可以建立：

public function decide($context)
{
    foreach ($this->candidates as $candidate) {

        $valid = true;

        foreach ($this->conditions as $condition) {

            if (!$condition->check($context)) {
                $valid = false;
                break;
            }
        }

        if ($valid) {
            $this->result = new DecisionResult(
                'selected',
                $candidate,
                'condition_matched'
            );

            $this->state = 'completed';

            return $candidate;
        }
    }

    $this->state = 'failed';

    return null;
}

基本运行逻辑：

Decision Start
      ↓
Load Candidates
      ↓
Check Conditions
      ↓
Candidate Valid?
      ↓
Yes
      ↓
Select Candidate
      ↓
Create Result
      ↓
Save History
      ↓
Decision Complete

如果没有候选项满足条件：

Decision Start
      ↓
Check Candidates
      ↓
No Candidate
      ↓
Decision Failed

---

161.19 Decision不是随机选择

Decision的一个重要工程原则是：

决策必须具有明确的规则依据。

例如不能直接：

$candidate = $candidates[0];

就认为这是一个合理Decision。

因为数组第一个Candidate并不代表它最适合当前Goal。

应该建立：

Candidate
   ↓
Condition
   ↓
State
   ↓
Range
   ↓
Verification
   ↓
Comparison
   ↓
Selection

因此Decision是一个可解释的离散判断过程。

---

161.20 Decision Rule

为了实现多个Candidate之间的比较，可以建立Decision Rule（决策规则）。

例如：

Rule 1:
Condition必须满足。

Rule 2:
Candidate必须处于available状态。

Rule 3:
Candidate必须满足Range。

Rule 4:
Candidate必须通过必要Verification。

Rule 5:
如果多个Candidate均满足，则按照预先定义的比较规则选择。

可以表示为：

Select(Ci)=Conditioni∧Statei∧Rangei∧VerificationiSelect(C_i)= Condition_i \land State_i \land Range_i \land Verification_i

如果：

Select(C_i)=true

则Candidate进入有效集合。

---

161.21 多Candidate决策

当多个Candidate都有效时，Decision必须继续比较。

例如：

Method A
    distance = 5
    verified = true

Method B
    distance = 8
    verified = true

Method C
    distance = 12
    verified = false

首先：

C → rejected

剩余：

A
B

再根据：

distance smaller

进行比较：

A = 5
B = 8

最终：

Selected = A

完整过程：

A B C
 ↓
Condition
 ↓
A B
 ↓
Verification
 ↓
A B
 ↓
Comparison
 ↓
A
 ↓
Decision Result

---

161.22 Decision与Priority的关系

前面的Goal已经存在Priority。

Decision也可以利用Priority，但不能将二者混淆。

Priority回答：

“哪个Goal更重要？”

Decision回答：

“对于当前Goal，哪个Candidate应该被选择？”

例如：

Goal A Priority = high
Goal B Priority = low

系统首先可能选择：

Goal A

然后针对Goal A：

Method A
Method B
Method C

再进行Decision。

因此：

Need
 ↓
Goal
 ↓
Priority
 ↓
Decision
 ↓
Candidate Selection

Priority影响决策上下文，但Decision本身负责候选选择。

---

161.23 Decision与Capability的关系

Capability提供可行能力。

例如：

Capability A = grasp
Capability B = move
Capability C = release

如果Goal要求：

move cup

系统首先匹配Capability：

Goal
 ↓
Capability Matching
 ↓
Available Capability

然后：

Capability
 ↓
Method Candidates
 ↓
Decision

因此：

Capability → Method Candidates → Decision

Decision不会凭空产生Method。

它是在已有能力和已有方法结构的基础上进行选择。

---

161.24 Decision与Method的完整关系

可以建立完整执行结构：

Goal
   ↓
Capability
   ↓
Method Candidates
   ↓
Decision
   ↓
Selected Method
   ↓
Method Condition
   ↓
Process
   ↓
Action
   ↓
Result

因此Decision位于：

Capability与Method实际执行之间。

它解决：

“多个可行Method中，现在应该选择哪个？”

---

161.25 Decision History闭环

Decision产生以后，结果必须保存。

完整过程：

Candidate
   ↓
Condition
   ↓
Comparison
   ↓
Selection
   ↓
Decision Result
   ↓
History

之后实际执行：

Selected Method
   ↓
Process
   ↓
Action
   ↓
Execution Result

再反馈：

Execution Result
   ↓
Decision History
   ↓
Experience
   ↓
Future Decision

于是形成：

Past Decision
      ↓
History
      ↓
Experience
      ↓
Future Candidate Evaluation
      ↓
New Decision

这使Decision具有连续性。

---

161.26 Decision失败

Decision也可能失败。

例如：

Candidate A → Condition Failed
Candidate B → Condition Failed
Candidate C → Verification Failed

此时：

No Valid Candidate

系统不能强制选择。

应该产生：

Decision Result = failed

并记录：

History
    reason = no_valid_candidate

随后可以反馈到Goal层：

Decision Failed
      ↓
Goal Cannot Continue
      ↓
Goal State Update

或者返回Capability层：

Decision Failed
      ↓
Capability Recheck
      ↓
New Method Candidates

因此Decision失败也是一种有效的认知结果。

---

161.27 Decision状态

Decision本身也需要状态。

例如：

pending
evaluating
selected
failed
cancelled
completed

运行过程：

Pending
   ↓
Evaluating
   ↓
Candidate Comparison
   ↓
Selected
   ↓
Completed

失败：

Evaluating
   ↓
No Valid Candidate
   ↓
Failed

因此Decision本身也是具有生命周期的对象。

---

161.28 Decision数据库映射

Decision可以建立数据库表：

CREATE TABLE decisions (
    id INT NOT NULL AUTO_INCREMENT,
    decision_type VARCHAR(100) NOT NULL,
    decision_state VARCHAR(50) NOT NULL,
    result_status VARCHAR(50),
    selected_candidate_id INT,
    created_at DATETIME,
    updated_at DATETIME,
    PRIMARY KEY (id)
);

Candidate：

CREATE TABLE decision_candidates (
    id INT NOT NULL AUTO_INCREMENT,
    decision_id INT NOT NULL,
    candidate_type VARCHAR(100) NOT NULL,
    candidate_id INT NOT NULL,
    candidate_state VARCHAR(50),
    PRIMARY KEY (id)
);

Condition：

CREATE TABLE decision_conditions (
    id INT NOT NULL AUTO_INCREMENT,
    decision_id INT NOT NULL,
    condition_type VARCHAR(100) NOT NULL,
    operator VARCHAR(20) NOT NULL,
    condition_value VARCHAR(255),
    PRIMARY KEY (id)
);

History：

CREATE TABLE decision_history (
    id INT NOT NULL AUTO_INCREMENT,
    decision_id INT NOT NULL,
    candidate_id INT,
    result_status VARCHAR(50),
    reason VARCHAR(255),
    created_at DATETIME,
    PRIMARY KEY (id)
);

形成：

decisions
   ↓
decision_candidates
   ↓
decision_conditions
   ↓
decision_history

对应PHP对象：

Decision
Candidate
DecisionCondition
DecisionResult
DecisionHistory

---

161.29 Decision核心模型

综合本章内容，可以建立Decision核心模型：

D=F(C,Co)D=F(C,Co)

其中：

• D：Decision；
• C：Candidate集合；
• Co：Condition集合；
• F：离散决策规则。

如果进一步加入候选状态：

D=F(C,Co,S)D=F(C,Co,S)

其中：

• S：Candidate State。

如果加入历史验证：

D=F(C,Co,S,V,H)D=F(C,Co,S,V,H)

其中：

• V：Verification；
• H：History。

因此，一个更加完整的Decision过程可以表示为：

Candidate → Condition → State → Verification → Comparison → Selection → Result → History

---

161.30 Decision运行模型

最终建立个体决策运行模型：

Need
   ↓
Goal
   ↓
Priority
   ↓
Capability
   ↓
Method Candidates
   ↓
Decision
   ↓
Condition
   ↓
Candidate Comparison
   ↓
Selected Candidate
   ↓
Method
   ↓
Process
   ↓
Action
   ↓
Execution
   ↓
Result
   ↓
Decision History
   ↓
Experience

这里需要特别注意：

Decision并不执行Method。

Decision只负责确定：

“选择哪个Candidate。”

选择完成以后：

Selected Method
        ↓
Method Execution

才进入第160章建立的Method → Process → Action → Result执行结构。

---

161.31 Decision的工程职责

为了避免系统对象职责混乱，可以明确各对象职责：

Goal
    ↓
定义目标

Capability
    ↓
判断能力

Method
    ↓
定义方法

Decision
    ↓
选择方法

Process
    ↓
定义执行顺序

Action
    ↓
执行具体动作

Result
    ↓
记录实际结果

History
    ↓
保存历史过程

因此形成明确的职责分离。

Decision不能承担Method的工作。

Method不能承担Decision的工作。

Process不能代替Action。

Result不能代替History。

每个对象承担自己的认知工程职责。

---

161.32 本章总结

Decision类建立了个体“如何在多个可能方案中作出选择”的工程表达。

本章建立五个核心结构：

Decision
├── Candidate
├── Condition
├── Result
└── History

其中：

Decision表示完整的决策过程。

Candidate表示进入选择范围的候选对象。

Condition表示决策成立和候选比较所依据的条件。

Result表示最终产生的决策结果。

History保存过去的决策事实和过程。

Decision的核心运行关系为：

Candidate → Condition → Comparison → Selection → Result → History

与前面章节连接以后形成：

Goal → Capability → Method Candidates → Decision → Selected Method → Process → Action → Result

再通过历史形成反馈：

Result → History → Experience → Future Decision

因此，个体认知系统在第159章建立Capability、第160章建立Method之后，第161章正式建立了从能力、方法到选择的决策层。

最终形成：

Need → Goal → Capability → Method → Decision → Process → Action → Result

其中：

• Need决定需求；
• Goal确定目标；
• Capability判断能否完成；
• Method提供可行方法；
• Decision选择当前方案；
• Process组织执行过程；
• Action执行具体动作；
• Result记录实际结果。

Decision由此成为个体认知系统中连接认知判断与执行选择的核心对象，并为后续Behavior、Action Execution、Feedback以及Decision Learning等工程结构提供基础。