第202章　MemoryEngine

202.1 MemoryEngine概述

在 ICAI 个体认知系统中，Memory（记忆）不是简单的数据存储，也不是 MySQL 中某一张数据表的直接等价物。Memory 表示个体经过历史事件、反馈、状态变化、验证和筛选之后，仍然具有后续认知使用价值的信息。

第164章已经定义了 Memory：

$M=(I,C,W,T,R)M=(I,C,W,T,R)$

其中：

$MM$ ：Memory，记忆对象；
$II$ ：Information，记忆信息；
$CC$ ：Context，记忆形成时的上下文；
$WW$ ：Weight，记忆权重；
$TT$ ：Time，记忆时间；
$RR$ ：Relation，记忆关系。

MemoryEngine 的任务不是简单地“保存记忆”，而是对已有记忆进行计算、读取、筛选、匹配、排序、更新和状态判断。

因此，本章将 MemoryEngine 定义为：

$MemoryEngine=MemoryCalculation+MemoryReading+MemoryUpdatingMemoryEngine = MemoryCalculation + MemoryReading + MemoryUpdating$

即：

MemoryEngine 是 ICAI 中负责记忆信息计算、记忆读取与记忆更新的确定性认知计算引擎。

其核心问题包括：

当前事件是否应该形成记忆；
已有信息是否具有记忆价值；
当前认知过程需要读取哪些记忆；
哪些记忆与当前对象、状态、目标或场景相关；
多个记忆之间如何排序；
新事实是否需要更新已有记忆；
新事实与旧记忆是否发生冲突；
记忆是否仍然有效；
记忆是否应该弱化、归档或者重新验证。

因此：

$MemoryEngine=计算+读取+匹配+排序+更新+验证MemoryEngine = 计算 + 读取 + 匹配 + 排序 + 更新 + 验证$

MemoryEngine 不负责数据库底层持久化，不负责完整业务流程，也不直接决定最终行为。

其核心职责是：

根据当前认知上下文和已有记忆，计算“应该记住什么、应该读取什么、应该如何更新”。

202.2 Memory与MemoryEngine的区别

Memory 是认知对象。

MemoryEngine 是计算机制。

二者不能混淆。

可以表示为：

$Memory≠MemoryEngineMemory \neq MemoryEngine$

Memory 表示：

已经被系统保留下来的认知信息。

MemoryEngine 表示：

对这些认知信息进行计算、读取、匹配和更新的机制。

例如，一个个体过去执行某个方法：

方法 M1 在状态 S1 下执行成功。

这属于 Memory：

$M1=(I,C,W,T,R)M_1=(I,C,W,T,R)$

而当系统当前再次面对：

对象 O1，状态 S1，目标 G1。

MemoryEngine 需要计算：

$Match(M1,CurrentContext)Match(M_1,CurrentContext)$

然后判断：

$MatchedMatched$

或者：

$PartialPartial$

或者：

$UnmatchedUnmatched$

因此：

Memory 是过去形成的信息，MemoryEngine 是当前对过去信息进行认知计算的机制。

202.3 MemoryEngine核心模型

MemoryEngine 可以定义为：

$ME=(M,O,S,G,C,K,R,H,E,V,T)ME=(M,O,S,G,C,K,R,H,E,V,T)$

其中：

$MEME$ ：MemoryEngine；
$MM$ ：Memory，已有记忆；
$OO$ ：Object，当前对象；
$SS$ ：State，当前状态；
$GG$ ：Goal，当前目标；
$CC$ ：Condition，当前条件；
$KK$ ：Knowledge，相关知识；
$RR$ ：Relation，记忆关系；
$HH$ ：History，历史记录；
$EE$ ：Experience，经验；
$VV$ ：Verification，验证信息；
$TT$ ：Time，当前时间。

MemoryEngine 的输入不是单一 Memory，而是：

$InputM=(M,O,S,G,C,K,R,H,E,V,T)Input_{M} = (M,O,S,G,C,K,R,H,E,V,T)$

输出则可以表示为：

$OutputM=(Mc,Mr,Mu,V,S,T)Output_{M} = (M_c,M_r,M_u,V,S,T)$

其中：

$McM_c$ ：Memory Calculation，记忆计算结果；
$MrM_r$ ：Memory Reading，记忆读取结果；
$MuM_u$ ：Memory Update Candidate，记忆更新候选；
$VV$ ：验证结果；
$SS$ ：记忆状态；
$TT$ ：计算时间。

因此完整关系为：

$CurrentContext→MemoryCalculation→MemoryReading→MemoryMatching→MemoryRanking→MemoryUpdate→VerificationCurrentContext \rightarrow MemoryCalculation \rightarrow MemoryReading \rightarrow MemoryMatching \rightarrow MemoryRanking \rightarrow MemoryUpdate \rightarrow Verification$

202.4 记忆计算

202.4.1 记忆计算定义

MemoryCalculation 是 MemoryEngine 对当前事实、历史、反馈、经验和上下文进行计算，以判断哪些信息具有记忆价值。

其基本形式：

$Mc=Calculate(I,C,H,E,V,T)M_c=Calculate(I,C,H,E,V,T)$

其中：

$McM_c$ ：记忆计算结果；
$II$ ：Information，候选信息；
$CC$ ：Context，上下文；
$HH$ ：History，历史；
$EE$ ：Experience，经验；
$VV$ ：Verification，验证；
$TT$ ：Time，时间。

记忆计算不是“把所有发生过的事情全部保存”。

因为：

$History≠MemoryHistory \neq Memory$

History 记录发生过什么。

Memory 保存以后仍然可能具有认知价值的信息。

因此需要：

$History→Evaluation→MemoryCandidateHistory \rightarrow Evaluation \rightarrow MemoryCandidate$

202.4.2 记忆候选

记忆候选可以定义为：

$MC=(I,C,V,W,T,R)MC=(I,C,V,W,T,R)$

其中：

$II$ ：候选信息；
$CC$ ：形成该信息时的上下文；
$VV$ ：验证状态；
$WW$ ：计算出的记忆权重；
$TT$ ：形成时间；
$RR$ ：相关关系。

系统可以从以下来源形成 Memory Candidate：

$Result→Feedback→History→MemoryCandidateResult \rightarrow Feedback \rightarrow History \rightarrow MemoryCandidate$

也可以来自：

$StateChange→History→MemoryCandidateStateChange \rightarrow History \rightarrow MemoryCandidate$

或者：

$Experience→MemoryCandidateExperience \rightarrow MemoryCandidate$

但是候选记忆并不等于正式记忆。

必须经过验证：

$MemoryCandidate→Validation→MemoryMemoryCandidate \rightarrow Validation \rightarrow Memory$

202.5 记忆价值计算

不是所有历史事实都具有相同的记忆价值。

因此 MemoryEngine 可以计算：

$Wm=f(I,R,V,F,T)W_m=f(I,R,V,F,T)$

其中：

$WmW_m$ ：Memory Weight，记忆权重；
$II$ ：Information Importance，信息重要性；
$RR$ ：Relevance，当前相关性；
$VV$ ：Verification，验证程度；
$FF$ ：Frequency，出现频率；
$TT$ ：Time，时间因素。

这里的 Weight 是确定性认知计算权重，不是机器学习模型中的神经网络参数，也不是训练得到的参数。

例如：

$Wm=Wi+Wr+Wv+Wf-WtW_m = W_i+W_r+W_v+W_f-W_t$

其中：

$WiW_i$ ：重要性权重；
$WrW_r$ ：相关性权重；
$WvW_v$ ：验证权重；
$WfW_f$ ：重复出现权重；
$WtW_t$ ：时间衰减影响。

具体权重可以由系统规则配置。

因此：

$MemoryWeight≠AIModelWeightMemoryWeight \neq AIModelWeight$

202.6 时间衰减

记忆并不是永久保持相同强度。

可以定义时间衰减：

$Wt=W0×D(t)W_t=W_0\times D(t)$

其中：

$W0W_0$ ：初始记忆权重；
$D(t)D(t)$ ：时间衰减函数；
$tt$ ：距离记忆形成的时间。

例如可以使用离散衰减：

$D(t)=11+λtD(t)=\frac{1}{1+\lambda t}$

其中：

$λ\lambda$ ：时间衰减系数；
$tt$ ：经过的时间单位。

也可以采用规则区间：

$t<T1→D1t<T_1 \rightarrow D_1$ $T1≤t<T2→D2T_1\leq t<T_2 \rightarrow D_2$ $t≥T2→D3t\geq T_2 \rightarrow D_3$

这种方式特别适合早期 ICAI 工程，因为规则明确、计算可追踪。

202.7 记忆状态

Memory 必须具有自己的状态。

可以定义：

$SM∈{Created,Stored,Verified,Recalled,Updated,Weakened,Conflicted,Outdated,Archived}S_M \in \{ Created, Stored, Verified, Recalled, Updated, Weakened, Conflicted, Outdated, Archived \}$

主要状态含义如下：

Created

记忆刚刚形成。

Stored

记忆已经进入持久化系统。

Verified

记忆经过事实、结果或证据验证。

Recalled

记忆被当前认知过程读取。

Updated

记忆已经被新事实更新。

Weakened

记忆权重降低。

Conflicted

新旧事实之间存在冲突。

Outdated

记忆已经不再适用于当前条件。

Archived

记忆不再参与普通读取，但历史仍然保留。

因此：

$MemoryState≠ObjectStateMemoryState \neq ObjectState$

也不等于：

$MemoryState≠IndividualStateMemoryState \neq IndividualState$

202.8 记忆读取

202.8.1 MemoryReading定义

MemoryReading 是 MemoryEngine 根据当前认知上下文，从已有记忆中读取具有相关性的记忆。

基本形式：

$Mr=Read(M,C,O,S,G,T)M_r=Read(M,C,O,S,G,T)$

其中：

$MM$ ：记忆集合；
$CC$ ：当前条件；
$OO$ ：当前对象；
$SS$ ：当前状态；
$GG$ ：当前目标；
$TT$ ：当前时间；
$MrM_r$ ：读取结果。

读取并不是简单：

SELECT * FROM memories

而是：

$MemoryStore→Condition→Matching→Filtering→Ranking→RecallMemoryStore \rightarrow Condition \rightarrow Matching \rightarrow Filtering \rightarrow Ranking \rightarrow Recall$

因此数据库负责提供数据，MemoryEngine 负责认知计算。

202.9 记忆匹配

记忆读取首先需要进行匹配。

可以定义：

$Match(M,C)=MrMatch(M,C)=M_r$

匹配维度包括：

Object；
Attribute；
State；
Goal；
Condition；
Relation；
Time；
Experience；
Verification。

因此：

$MemoryMatch=Object+State+Goal+Condition+Relation+TimeMemoryMatch = Object + State + Goal + Condition + Relation + Time$

例如：

当前：

$O=ElectricMotorO=ElectricMotor$ $S=HighTemperatureS=HighTemperature$ $G=ReduceTemperatureG=ReduceTemperature$

历史记忆：

在 HighTemperature 状态下，降低负载后温度下降。

MemoryEngine 可以判断：

$Match=MatchedMatch=Matched$

如果对象相同但状态不同：

$Match=PartialMatch=Partial$

如果没有足够证据：

$Match=UnknownMatch=Unknown$

如果条件明确冲突：

$Match=ConflictedMatch=Conflicted$

因此 MemoryEngine 不应该只返回：

$true/falsetrue/false$

而应该返回结构化结果。

202.10 MemoryMatchResult

可以定义：

$MMR=(M,O,S,G,C,R,V,T)MMR=(M,O,S,G,C,R,V,T)$

其中：

$MM$ ：被匹配的 Memory；
$OO$ ：对象匹配结果；
$SS$ ：状态匹配结果；
$GG$ ：目标匹配结果；
$CC$ ：条件匹配结果；
$RR$ ：关系匹配结果；
$VV$ ：验证状态；
$TT$ ：计算时间。

匹配结果可以是：

$MatchedMatched$ $PartialPartial$ $UnmatchedUnmatched$ $UnknownUnknown$ $ConflictedConflicted$ $OutdatedOutdated$ $BlockedBlocked$

这样可以保留完整的认知计算过程。

202.11 记忆读取排序

当系统找到多个相关 Memory 时，需要进行排序。

可以定义：

$Score(Mi)=WrRi+WvVi+WtTi+WcCi+WoOiScore(M_i) = W_rR_i + W_vV_i + W_tT_i + W_cC_i + W_oO_i$

其中：

$RiR_i$ ：当前相关性；
$ViV_i$ ：验证程度；
$TiT_i$ ：时间有效性；
$CiC_i$ ：条件匹配程度；
$OiO_i$ ：对象匹配程度；
$Wr,Wv,Wt,Wc,WoW_r,W_v,W_t,W_c,W_o$ ：对应权重。

最终：

$M1,M2,…,Mn→Score→Sort→RecallM_1,M_2,\ldots,M_n \rightarrow Score \rightarrow Sort \rightarrow Recall$

但是必须强调：

MemoryEngine 的排序不是最终 Decision。

它只能告诉系统：

哪些记忆与当前问题更相关。

最终是否采用某个记忆影响行为，需要由 KnowledgeEngine、DecisionEngine、MethodEngine 等共同处理。

202.12 记忆读取与当前事实

一个非常重要的 ICAI 原则是：

$CurrentFact>MemoryCurrentFact > Memory$

即：

当前经过验证的实际事实，优先于过去的记忆。

例如过去记忆：

Object A 的状态为 Ready。

但当前 StateEngine 已经计算并验证：

$State(A)=BlockedState(A)=Blocked$

那么 MemoryEngine 不能因为过去记忆而继续认为：

$A=ReadyA=Ready$

正确关系应该是：

$Memory→ReferenceMemory \rightarrow Reference$

而不是：

$Memory→OverrideCurrentStateMemory \rightarrow OverrideCurrentState$

因此：

Memory 可以辅助当前认知，但不能覆盖当前经过验证的事实。

202.13 记忆更新

202.13.1 MemoryUpdating定义

MemoryUpdating 是 MemoryEngine 根据新事实、反馈、验证结果和当前状态，对已有记忆进行新增、修改、弱化、冲突标记、过期处理或者归档。

基本模型：

$Mt+1=Update(Mt,ΔF,V,C,T)M_{t+1} = Update(M_t,\Delta F,V,C,T)$

其中：

$MtM_t$ ：当前记忆；
$ΔF\Delta F$ ：新事实变化；
$VV$ ：验证；
$CC$ ：条件；
$TT$ ：时间；
$Mt+1M_{t+1}$ ：更新后的记忆。

202.14 记忆更新类型

MemoryEngine 至少支持以下更新类型：

1. Create

没有对应记忆：

$∅→Mnew\varnothing \rightarrow M_{new}$

2. Modify

已有记忆发生变化：

$Mt+ΔF→Mt+1M_t+\Delta F \rightarrow M_{t+1}$

3. Strengthen

新事实重复验证已有记忆：

$Mt→IncreaseWeightM_t \rightarrow IncreaseWeight$

4. Weaken

长期没有验证或者相关性降低：

$Mt→DecreaseWeightM_t \rightarrow DecreaseWeight$

5. Conflict

新事实与旧记忆冲突：

$Mt+ΔF→ConflictM_t+\Delta F \rightarrow Conflict$

6. Outdate

记忆已经不适用：

$Mt→OutdatedM_t \rightarrow Outdated$

7. Archive

记忆退出普通认知读取：

$Mt→ArchivedM_t \rightarrow Archived$

因此：

$MemoryUpdate=Create+Modify+Strengthen+Weaken+Conflict+Outdate+ArchiveMemoryUpdate = Create + Modify + Strengthen + Weaken + Conflict + Outdate + Archive$

202.15 记忆冲突

记忆更新不能简单覆盖旧值。

例如已有：

$M1:Temperature=20M_1: Temperature=20$

新的经过验证事实：

$F:Temperature=80F: Temperature=80$

系统首先需要判断：

$Conflict(M1,F)Conflict(M_1,F)$

而不是直接：

20 → 80

因为可能存在：

时间不同；
对象不同；
场景不同；
条件不同；
测量方式不同；
状态不同。

因此：

$Conflict=Difference+SameObject+SameCondition+SameScopeConflict = Difference + SameObject + SameCondition + SameScope$

只有在确认属于同一事实范围时，才能形成真正的记忆更新。

202.16 记忆更新验证

记忆更新必须经过验证。

定义：

$ValidMemoryUpdate=Evidence∧ActualFact∧Condition∧VerificationValidMemoryUpdate = Evidence \land ActualFact \land Condition \land Verification$

其中：

Evidence：存在证据；
ActualFact：来自实际事实；
Condition：适用条件明确；
Verification：已经验证。

因此：

$CandidateUpdate≠ValidUpdateCandidateUpdate \neq ValidUpdate$

只有：

$CandidateUpdate→Validate→Verify→UpdateCandidateUpdate \rightarrow Validate \rightarrow Verify \rightarrow Update$

才能正式修改记忆。

202.17 记忆更新最小原则

MemoryEngine 应遵循：

最小记忆更新原则。

即：

$ΔM=MinimalVerifiedChange\Delta M = MinimalVerifiedChange$

如果新事实只证明一个属性发生变化，则只更新这个属性。

例如：

原记忆：

$M=(O,State=Ready,Method=M1,Time=T1)M=(O,State=Ready,Method=M1,Time=T1)$

新事实只证明：

$State=BlockedState=Blocked$

则：

$Mt+1=(O,State=Blocked,Method=M1,Time=T2)M_{t+1} = (O,State=Blocked,Method=M1,Time=T2)$

而不是重新生成整个 Memory 对象。

这样可以降低错误传播。

202.18 MemoryEngine与History

History 记录实际发生过的过程。

Memory 保存具有后续使用价值的信息。

关系为：

$History→Evaluation→MemoryCandidate→Verification→MemoryHistory \rightarrow Evaluation \rightarrow MemoryCandidate \rightarrow Verification \rightarrow Memory$

因此：

$History≠MemoryHistory\neq Memory$

例如：

History:
2026-09-10 10:01
Action A1 executed
Result success

只是历史事实。

经过分析后：

Memory:
在 Condition C1 下，Action A1 曾成功。

才形成具有后续检索价值的记忆。

202.19 MemoryEngine与ExperienceEngine

Memory 与 Experience 也不能混淆。

Memory：

保存过去的重要认知信息。

Experience：

从多个历史与记忆中形成的结构化模式。

关系：

$History→Memory→Comparison→Pattern→ExperienceHistory \rightarrow Memory \rightarrow Comparison \rightarrow Pattern \rightarrow Experience$

因此：

$Memory≠ExperienceMemory\neq Experience$

MemoryEngine 负责记忆。

ExperienceEngine 负责经验计算。

二者可以形成：

$MemoryEngine↔ExperienceEngineMemoryEngine \leftrightarrow ExperienceEngine$

但不能将二者合并成一个没有边界的模块。

202.20 MemoryEngine与KnowledgeEngine

Memory 和 Knowledge 也不同。

Memory 表示：

个体过去保留下来的认知信息。

Knowledge 表示：

当前系统可验证、可计算、可应用的知识结构。

因此：

$Memory→KnowledgeCandidate→Verification→KnowledgeMemory \rightarrow KnowledgeCandidate \rightarrow Verification \rightarrow Knowledge$

MemoryEngine 可以为 KnowledgeEngine 提供历史参考。

但是：

$Memory≠KnowledgeMemory \neq Knowledge$

一个历史记忆存在，并不代表它自动成为有效知识。

202.21 MemoryEngine与DecisionEngine

MemoryEngine 不负责最终决策。

关系为：

$MemoryEngine→RelevantMemory→DecisionEngineMemoryEngine \rightarrow RelevantMemory \rightarrow DecisionEngine$

DecisionEngine 再结合：

Goal；
Capability；
Method；
Risk；
Conflict；
State；
Knowledge；
Memory；
Experience。

进行最终决策。

因此：

$MemoryReading≠DecisionMemoryReading \neq Decision$

MemoryEngine 负责回答：

过去哪些信息与当前问题有关？

DecisionEngine 负责回答：

当前应该选择什么？

202.22 MemoryEngine完整计算流程

完整记忆计算流程可以表示为：

$History→MemoryCandidate→MemoryCalculation→Validation→MemoryStorageHistory \rightarrow MemoryCandidate \rightarrow MemoryCalculation \rightarrow Validation \rightarrow MemoryStorage$

记忆读取：

$CurrentContext→MemoryLoad→MemoryMatching→MemoryFiltering→MemoryRanking→MemoryRecallCurrentContext \rightarrow MemoryLoad \rightarrow MemoryMatching \rightarrow MemoryFiltering \rightarrow MemoryRanking \rightarrow MemoryRecall$

记忆更新：

$NewFact→MemoryComparison→ConflictDetection→UpdateCandidate→Verification→MemoryUpdateNewFact \rightarrow MemoryComparison \rightarrow ConflictDetection \rightarrow UpdateCandidate \rightarrow Verification \rightarrow MemoryUpdate$

完整闭环：

$Result→Feedback→History→Memory→Recall→Decision→Behavior→Execution→ResultResult \rightarrow Feedback \rightarrow History \rightarrow Memory \rightarrow Recall \rightarrow Decision \rightarrow Behavior \rightarrow Execution \rightarrow Result$

由此形成 ICAI 的记忆闭环。

202.23 MemoryEngine运行时模型

MemoryEngine 必须基于当前 Runtime 工作。

Runtime 可以表示：

$Runtime=(I,O,S,G,C,T)Runtime=(I,O,S,G,C,T)$

其中：

$II$ ：Individual；
$OO$ ：Object；
$SS$ ：State；
$GG$ ：Goal；
$CC$ ：Condition；
$TT$ ：Time。

因此：

$MemoryResult=f(M,Runtime,Rule,Verification)MemoryResult = f(M,Runtime,Rule,Verification)$

同一个 Memory，在不同 Runtime 下可能产生不同读取结果。

例如：

$M1M_1$

过去与：

$O1,S1O_1,S_1$

高度相关。

当前变为：

$O2,S2O_2,S_2$

则：

$Match(M1,Runtime2)Match(M_1,Runtime_2)$

可能变成：

$PartialPartial$

甚至：

$UnmatchedUnmatched$

所以：

记忆本身可以稳定存在，但记忆与当前场景之间的关系是动态计算的。

202.24 MemoryEngine工程边界

MemoryEngine 不应该承担以下职责：

不负责数据库操作

SQL 和持久化由 Repository 完成。

不负责完整业务流程

业务流程由 Service 编排。

不负责最终决策

最终选择由 DecisionEngine / DecisionService 完成。

不负责实际行为执行

行为由 BehaviorEngine、ActionEngine、ExecutionEngine 完成。

不负责诊断

问题原因由 DiagnosisEngine 计算。

不负责修复

RepairEngine 负责修复方案计算。

不负责知识最终确认

KnowledgeEngine 和 VerificationService 负责知识计算与验证。

不负责经验形成

ExperienceEngine 负责经验计算。

因此：

$MemoryEngine=MemoryCalculation+MemoryReading+MemoryUpdatingMemoryEngine = MemoryCalculation + MemoryReading + MemoryUpdating$

而不是一个无限扩张的“总认知引擎”。

202.25 MemoryEngine与Service层

MemoryEngine 与 MemoryService 的职责必须保持清晰。

MemoryService：

负责调用、流程协调、对象加载、保存、事务和结果组装。

MemoryEngine：

负责记忆计算。

结构：

$Controller→MemoryService→MemoryEngine→Repository→MySQLController \rightarrow MemoryService \rightarrow MemoryEngine \rightarrow Repository \rightarrow MySQL$

更完整的调用关系：

$MemoryService→LoadMemory→MemoryEngine→Calculate→Validate→Result→MemoryService→RepositoryMemoryService \rightarrow LoadMemory \rightarrow MemoryEngine \rightarrow Calculate \rightarrow Validate \rightarrow Result \rightarrow MemoryService \rightarrow Repository$

因此：

$Service=OrchestrationService=Orchestration$ $Engine=CalculationEngine=Calculation$ $Repository=PersistenceRepository=Persistence$

202.26 MemoryEngine与其他Engine关系

MemoryEngine 位于认知系统中间层。

其主要关系为：

$HistoryEngine→MemoryEngineHistoryEngine \rightarrow MemoryEngine$ $FeedbackEngine→MemoryEngineFeedbackEngine \rightarrow MemoryEngine$ $MemoryEngine→ExperienceEngineMemoryEngine \rightarrow ExperienceEngine$ $MemoryEngine→KnowledgeEngineMemoryEngine \rightarrow KnowledgeEngine$ $MemoryEngine→DecisionEngineMemoryEngine \rightarrow DecisionEngine$

同时：

$StateEngine→MemoryEngineStateEngine \rightarrow MemoryEngine$

因为当前状态决定记忆是否适用。

完整关系：

$ObjectEngine→StateEngine→SceneEngine→KnowledgeEngine→MemoryEngine→ExperienceEngine→DecisionEngineObjectEngine \rightarrow StateEngine \rightarrow SceneEngine \rightarrow KnowledgeEngine \rightarrow MemoryEngine \rightarrow ExperienceEngine \rightarrow DecisionEngine$

但实际运行中这些 Engine 并不是严格单向串行，而是根据 ServiceContext 和当前认知任务进行调用。

202.27 PHP OOP工程结构

在 PHP OOP 中，可以建立：

abstract class Engine
{
    public function calculate($input)
    {
        return array();
    }
}

MemoryEngine：

class MemoryEngine extends Engine
{
    public function calculate($input)
    {
        $calculation = $this->calculateMemory($input);

        $reading = $this->readMemory($input);

        $update = $this->calculateUpdate($input);

        return array(
            'calculation' => $calculation,
            'reading' => $reading,
            'update' => $update
        );
    }

    protected function calculateMemory($input)
    {
        return array(
            'status' => 'calculated'
        );
    }

    protected function readMemory($input)
    {
        return array(
            'status' => 'read'
        );
    }

    protected function calculateUpdate($input)
    {
        return array(
            'status' => 'update_candidate'
        );
    }
}

上述代码表达的是 Engine 的职责结构。

真正生产环境中的 MemoryEngine 应继续拆分为：

MemoryEngine
├── MemoryCalculationEngine
├── MemoryMatchingEngine
├── MemoryReadingEngine
├── MemoryRankingEngine
├── MemoryUpdateEngine
└── MemoryVerificationEngine

这样可以避免 MemoryEngine 成为一个过度集中的巨型类。

202.28 Memory领域对象

建议 Memory 领域对象保持独立：

class Memory
{
    protected $id;
    protected $information;
    protected $context;
    protected $weight;
    protected $time;
    protected $relations;
    protected $state;
}

MemoryRelation：

class MemoryRelation
{
    protected $memoryId;
    protected $relationType;
    protected $targetMemoryId;
    protected $condition;
    protected $state;
}

MemoryCalculationResult：

class MemoryCalculationResult
{
    protected $candidate;
    protected $weight;
    protected $reason;
    protected $evidence;
    protected $state;
}

MemoryReadingResult：

class MemoryReadingResult
{
    protected $memories;
    protected $matchResults;
    protected $ranking;
    protected $time;
}

MemoryUpdateResult：

class MemoryUpdateResult
{
    protected $before;
    protected $after;
    protected $change;
    protected $reason;
    protected $verification;
}

202.29 数据库映射

MemoryEngine 本身不直接承担数据库职责。

Repository 可以对应：

memories
memory_relations
memory_history
memory_verifications
memory_calculations
memory_reads
memory_updates

例如：

memories

保存：

id；
individual_id；
information；
context；
weight；
state；
created_at；
updated_at。

memory_relations

保存：

memory_id；
relation_type；
target_memory_id；
condition；
state。

memory_history

保存：

memory_id；
previous_state；
new_state；
change_type；
reason；
created_at。

memory_verifications

保存：

memory_id；
evidence；
verification_status；
verification_time。

数据库保存事实和计算结果。

MemoryEngine 负责：

$Calculate→Match→Read→UpdateCalculate \rightarrow Match \rightarrow Read \rightarrow Update$

202.30 记忆完整生命周期

Memory 生命周期可以定义为：

$Created→Validated→Stored→Recalled→Updated→Weakened→Outdated→ArchivedCreated \rightarrow Validated \rightarrow Stored \rightarrow Recalled \rightarrow Updated \rightarrow Weakened \rightarrow Outdated \rightarrow Archived$

其中并不是每个 Memory 都必须经过全部状态。

例如：

$Created→Validated→StoredCreated \rightarrow Validated \rightarrow Stored$

之后长期没有使用：

$Stored→WeakenedStored \rightarrow Weakened$

如果条件发生变化：

$Weakened→OutdatedWeakened \rightarrow Outdated$

如果需要保留历史：

$Outdated→ArchivedOutdated \rightarrow Archived$

202.31 记忆系统的完整认知闭环

ICAI 的记忆机制最终可以形成：

$Perception→Object→State→Behavior→Action→Execution→Result→Feedback→History→MemoryPerception \rightarrow Object \rightarrow State \rightarrow Behavior \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow Feedback \rightarrow History \rightarrow Memory$

然后：

$CurrentContext→MemoryReading→RelevantMemory→DecisionCurrentContext \rightarrow MemoryReading \rightarrow RelevantMemory \rightarrow Decision$

形成：

$Memory→Recall→Decision→Behavior→Execution→Result→Feedback→MemoryMemory \rightarrow Recall \rightarrow Decision \rightarrow Behavior \rightarrow Execution \rightarrow Result \rightarrow Feedback \rightarrow Memory$

这就是 ICAI 的记忆闭环。

202.32 记忆计算的确定性原则

MemoryEngine 必须保持确定性。

对于相同：

$Input+Rule+Condition+MemoryInput+Rule+Condition+Memory$

在相同时间条件下，应得到相同计算结果：

$f(X)=Yf(X)=Y$

不能通过随机生成内容改变结果。

也就是说：

$MemoryEngine≠GenerativeModelMemoryEngine \neq GenerativeModel$

不使用：

LLM；
Transformer；
Embedding；
Vector Search；
Prompt Engineering；
Neural Network；
LLM API。

MemoryEngine 采用：

$Object+State+Relation+Rule+Condition+History+Experience+VerificationObject + State + Relation + Rule + Condition + History + Experience + Verification$

完成记忆计算。

202.33 MemoryEngine的可解释性

每一次 MemoryEngine 计算都应该能够回答：

为什么形成这条记忆？
来源是什么？
什么事实支持它？
为什么读取这条记忆？
为什么这条记忆排名较高？
为什么更新这条记忆？
为什么降低它的权重？
为什么标记为冲突？
为什么标记为过期？

因此可以形成：

$Input→Rule→Calculation→Evidence→ResultInput \rightarrow Rule \rightarrow Calculation \rightarrow Evidence \rightarrow Result$

例如：

Input:
Object = O1
State = S1
Goal = G1

Memory:
M1

Matching:
Object = Matched
State = Matched
Goal = Partial

Verification:
Verified

Result:
Partial Match

Reason:
Historical condition is similar but not identical.

这种结果可以被后续 DecisionEngine 继续使用。

202.34 MemoryEngine完整架构

最终，MemoryEngine 可以形成：

                    ┌────────────────────┐
                    │    MemoryEngine    │
                    └─────────┬──────────┘
                              │
          ┌───────────────────┼───────────────────┐
          ↓                   ↓                   ↓
 MemoryCalculation      MemoryReading       MemoryUpdating
          │                   │                   │
          ↓                   ↓                   ↓
 Candidate              Matching             Comparison
          │                   │                   │
          ↓                   ↓                   ↓
 Validation             Filtering            Conflict
          │                   │                   │
          ↓                   ↓                   ↓
 Weight                 Ranking              Verification
          │                   │                   │
          └───────────────────┼───────────────────┘
                              ↓
                         Memory Result
                              │
             ┌────────────────┼────────────────┐
             ↓                ↓                ↓
        KnowledgeEngine   ExperienceEngine  DecisionEngine

因此 MemoryEngine 并不是一个简单的 CRUD 模块，而是一个真正参与 ICAI 认知循环的计算 Engine。

202.35 与前面Engine体系的统一关系

截至本章，ICAI Engine 层已经形成明显的层次：

$ObjectEngine→StateEngine→RelationEngine→SceneEngineObjectEngine \rightarrow StateEngine \rightarrow RelationEngine \rightarrow SceneEngine$

负责基础对象、状态、关系和场景计算。

继续：

$KnowledgeEngine→CapabilityEngine→MatchingEngine→MethodEngineKnowledgeEngine \rightarrow CapabilityEngine \rightarrow MatchingEngine \rightarrow MethodEngine$

负责知识、能力、匹配和方法计算。

继续：

$RiskEngine→ConflictEngine→DecisionEngineRiskEngine \rightarrow ConflictEngine \rightarrow DecisionEngine$

负责风险、冲突和决策计算。

继续：

$BehaviorEngine→ActionEngine→ExecutionEngine→FeedbackEngineBehaviorEngine \rightarrow ActionEngine \rightarrow ExecutionEngine \rightarrow FeedbackEngine$

负责行为、动作、执行和反馈。

而本章：

$MemoryEngineMemoryEngine$

负责：

$MemoryCalculation+MemoryReading+MemoryUpdatingMemoryCalculation + MemoryReading + MemoryUpdating$

并与：

$ExperienceEngine+KnowledgeEngine+DecisionEngine+LearningEngineExperienceEngine + KnowledgeEngine + DecisionEngine + LearningEngine$

共同构成 ICAI 的长期认知闭环。

202.36 本章总结

MemoryEngine 的核心不是“存储记忆”，而是对记忆进行认知计算。

其核心模型为：

$MemoryEngine=MemoryCalculation+MemoryReading+MemoryUpdatingMemoryEngine = MemoryCalculation + MemoryReading + MemoryUpdating$

记忆计算：

$History→Candidate→Calculation→Validation→MemoryHistory \rightarrow Candidate \rightarrow Calculation \rightarrow Validation \rightarrow Memory$

记忆读取：

$CurrentContext→Matching→Filtering→Ranking→RecallCurrentContext \rightarrow Matching \rightarrow Filtering \rightarrow Ranking \rightarrow Recall$

记忆更新：

$NewFact→Comparison→ConflictDetection→UpdateCandidate→Verification→MemoryUpdateNewFact \rightarrow Comparison \rightarrow ConflictDetection \rightarrow UpdateCandidate \rightarrow Verification \rightarrow MemoryUpdate$

核心原则可以归纳为：

$History≠MemoryHistory\neq Memory$ $Memory≠ExperienceMemory\neq Experience$ $Memory≠KnowledgeMemory\neq Knowledge$ $MemoryReading≠DecisionMemoryReading\neq Decision$ $Memory≠CurrentFactMemory\neq CurrentFact$

最终：

由此，MemoryEngine 将过去发生过的事实转化为可以被当前认知过程读取、比较、验证和更新的结构化记忆，使 ICAI 从单次计算系统进一步形成具有历史连续性的个体认知系统。

其工程原则保持不变：

$Service=OrchestrationService=Orchestration$ $Engine=CalculationEngine=Calculation$ $DomainObject=Data/CognitiveObjectDomainObject=Data/CognitiveObject$ $Repository=PersistenceRepository=Persistence$ $Runtime=CurrentActualContextRuntime=CurrentActualContext$

最终形成：

$ICAI=Service+Engine+DomainObject+Runtime+RepositoryICAI = Service + Engine + DomainObject + Runtime + Repository$

而 MemoryEngine 则承担其中“过去信息如何进入当前认知计算”的核心工程职责。

第202章 MemoryEngine

第202章 MemoryEngine

202.1 MemoryEngine概述

202.2 Memory与MemoryEngine的区别

202.3 MemoryEngine核心模型

202.4 记忆计算

202.4.1 记忆计算定义

202.4.2 记忆候选

202.5 记忆价值计算

202.6 时间衰减

202.7 记忆状态

Created

Stored

Verified

Recalled

Updated

Weakened

Conflicted

Outdated

Archived

202.8 记忆读取

202.8.1 MemoryReading定义

202.9 记忆匹配

202.10 MemoryMatchResult

202.11 记忆读取排序

202.12 记忆读取与当前事实

202.13 记忆更新

202.13.1 MemoryUpdating定义

202.14 记忆更新类型

1. Create

2. Modify

3. Strengthen

4. Weaken

5. Conflict

6. Outdate

7. Archive

202.15 记忆冲突

202.16 记忆更新验证

202.17 记忆更新最小原则

202.18 MemoryEngine与History

202.19 MemoryEngine与ExperienceEngine

202.20 MemoryEngine与KnowledgeEngine

202.21 MemoryEngine与DecisionEngine

202.22 MemoryEngine完整计算流程

202.23 MemoryEngine运行时模型

202.24 MemoryEngine工程边界

不负责数据库操作

不负责完整业务流程

不负责最终决策

不负责实际行为执行

不负责诊断

不负责修复

不负责知识最终确认

不负责经验形成

202.25 MemoryEngine与Service层

202.26 MemoryEngine与其他Engine关系

202.27 PHP OOP工程结构

202.28 Memory领域对象

202.29 数据库映射

memories

memory_relations

memory_history

memory_verifications

202.30 记忆完整生命周期

202.31 记忆系统的完整认知闭环

202.32 记忆计算的确定性原则

202.33 MemoryEngine的可解释性

202.34 MemoryEngine完整架构

202.35 与前面Engine体系的统一关系

202.36 本章总结