第223章　MemoryExperienceRepository

223.1 MemoryExperienceRepository定义

前面已经建立：

$Execution→Result→ExecutionHistoryExecution \rightarrow Result \rightarrow ExecutionHistory$

执行历史记录系统过去真实发生过什么。

但是，如果所有历史数据都只是原样保存，系统每次进行认知计算时都必须重新处理大量历史事实。

因此 ICAI 需要进一步建立：

History
 ↓
Memory
 ↓
Experience

其中：

History：实际发生过的历史事实；
Memory：从历史中保留下来的、未来可以检索和使用的信息；
Experience：从多条历史、Memory、条件和结果中形成的结构化经验模式。

因此建立：

$MemoryExperienceRepositoryMemoryExperienceRepository$

核心模型：

$MER=(M,E,H,Q,P,R,T)MER=(M,E,H,Q,P,R,T)$

其中：

$MM$ ：Memory；
$EE$ ：Experience；
$HH$ ：History；
$QQ$ ：Query；
$PP$ ：Persistence；
$RR$ ：Relation；
$TT$ ：Time。

因此：

$MemoryExperienceRepository=Memory+Experience+History+Query\boxed{ MemoryExperienceRepository = Memory + Experience + History + Query }$

本 Repository 的核心作用不是“思考”，而是让已经形成的认知数据能够：

保存
读取
查询
更新
追踪
关联

因此：

$MemoryExperienceRepository≠MemoryEngine\boxed{ MemoryExperienceRepository \neq MemoryEngine }$ $MemoryExperienceRepository≠ExperienceEngine\boxed{ MemoryExperienceRepository \neq ExperienceEngine }$

223.2 Memory领域对象

第164章已经定义 Memory：

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

其中：

$II$ ：Information；
$CC$ ：Context；
$WW$ ：Weight；
$TT$ ：Time；
$RR$ ：Relation。

Memory表示：

$值得保留并可以再次调用的信息\boxed{值得保留并可以再次调用的信息}$

例如一次执行产生：

Object-A
State = Ready
Action-A1
Result = Success

经过处理后，可以形成：

Memory-M1

记录：

Object-A 在某条件下执行 Action-A1 成功

但 Memory 并不是原始执行记录。

因此：

$Memory≠HistoryMemory\neq History$

223.3 Experience领域对象

Experience模型：

$E=(H,M,C,R,P)E=(H,M,C,R,P)$

其中：

$HH$ ：History；
$MM$ ：Memory；
$CC$ ：Condition；
$RR$ ：Result；
$PP$ ：Pattern。

Experience表示：

$过去事实中形成的可重复利用结构模式\boxed{过去事实中形成的可重复利用结构模式}$

例如：

Condition:
Resource >= 2

Method:
M1

Result:
Success

经过多次历史验证后，可以形成：

Experience-E1

表达：

$Resource≥2→M1→SuccessResource\geq2 \rightarrow M1 \rightarrow Success$

Experience不是简单的“成功次数”。

223.4 History领域对象

History记录实际发生的事实。

基本形式：

$H={h1,h2,…,hn}H=\{h_1,h_2,\ldots,h_n\}$

单条历史：

$h=(T,O,A,R,S)h=(T,O,A,R,S)$

其中：

$TT$ ：时间；
$OO$ ：对象；
$AA$ ：动作；
$RR$ ：结果；
$SS$ ：状态。

执行历史还可以采用第222章的模型：

$EH=(Ex,B,A,Sb,Sa,R,T)EH=(E_x,B,A,S_b,S_a,R,T)$

因此：

$HistoryHistory$

可以来自：

Execution History
Behavior History
Decision History
State History
Method History
Feedback History

223.5 三者之间的关系

核心关系：

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

但是这不是简单的数据复制。

实际过程是：

History
 ↓
筛选
 ↓
Memory
 ↓
比较
 ↓
关系建立
 ↓
Pattern
 ↓
Experience

因此：

$History≠Memory≠Experience\boxed{ History\neq Memory\neq Experience }$

三者承担不同职责。

223.6 History：记录发生过什么

History关注：

$事实\boxed{事实}$

例如：

2026-09-11 10:00
Action A1
Result = Failed

这是历史事实。

Repository应该原样保存这一事实。

Repository不应该因为某次失败就自行推断：

Method invalid

更不能直接修改 Capability。

223.7 Memory：保存什么值得再次使用

Memory关注：

$可检索的信息\boxed{可检索的信息}$

例如：

Memory M1

Object-A
Condition-X
Result = Success

未来需要类似信息时，可以查询：

$Query(Context)→MemoryQuery(Context)\rightarrow Memory$

然后将 Memory 提供给 MemoryEngine / ExperienceEngine / DecisionEngine。

223.8 Experience：过去形成了什么模式

Experience关注：

$可重复利用的经验结构\boxed{可重复利用的经验结构}$

例如：

Condition X
 +
Method M1
 +
Capability C1
 →
Success

经过多次历史验证以后，可以形成：

$ExperienceExperience$

它可以参与：

Risk计算
Decision计算
Method选择
Capability判断
Learning计算

但 ExperienceRepository 本身不负责这些计算。

223.9 Memory的保存

Memory保存：

$Save(M)→Validate→Map→Persist→VerifySave(M) \rightarrow Validate \rightarrow Map \rightarrow Persist \rightarrow Verify$

有效 Memory 至少应该包含：

Memory ID
Information
Context
Weight
Time
Relation
State

这里的 Weight 不是神经网络参数。

而是确定性的 Memory 权重。

例如：

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

其中：

$II$ ：重要性；
$RR$ ：相关性；
$TT$ ：时间因素；
$VV$ ：验证状态。

223.10 Memory查询

MemoryRepository最重要的职责之一是查询。

例如：

$findMemoryById(ID)findMemoryById(ID)$

或者：

$findMemoriesByObject(O)findMemoriesByObject(O)$

还可以：

$findMemoriesByContext(C)findMemoriesByContext(C)$ $findMemoriesByType(T)findMemoriesByType(T)$ $findMemoriesByState(S)findMemoriesByState(S)$ $findRecentMemories(T)findRecentMemories(T)$

因此：

Context
 ↓
MemoryRepository
 ↓
Candidate Memories
 ↓
MemoryEngine
 ↓
Relevant Memories

Repository负责：

$QueryQuery$

MemoryEngine负责：

$RelevanceCalculationRelevanceCalculation$

223.11 查询不等于记忆计算

这是本章最重要的 Repository 边界之一。

例如：

$findMemoriesByObject(O)findMemoriesByObject(O)$

只表示：

找到与 Object O 关联的 Memory

并不代表：

这些Memory全部适用于当前情况

因此：

$Query≠Relevance\boxed{ Query\neq Relevance }$

正确流程：

Context
 ↓
Repository Query
 ↓
Memory Candidates
 ↓
MemoryEngine
 ↓
Relevance Calculation
 ↓
Recall Result

223.12 Memory Relation

Memory之间可以存在关系。

定义：

$MR=(M1,T,M2,C)MR=(M_1,T,M_2,C)$

其中：

$M1M_1$ ：Memory A；
$TT$ ：Relation Type；
$M2M_2$ ：Memory B；
$CC$ ：Relation Condition。

例如：

M1
 ↓ supports
M2

或者：

M1
 ↓ conflicts_with
M2

还可以：

same_as
similar_to
before
after
cause
effect
part_of
contains
used_with
derived_from

Repository负责保存和查询这些关系。

MemoryEngine负责使用这些关系进行认知计算。

223.13 Experience保存

Experience保存：

$Save(E)→Validate→Map→Persist→VerifySave(E) \rightarrow Validate \rightarrow Map \rightarrow Persist \rightarrow Verify$

基本结构：

Experience ID
History
Memory
Condition
Result
Pattern
State
Time

例如：

$E1=(H1,H2,H3,M1,M2,C,R,P)E_1= (H_1,H_2,H_3,M_1,M_2,C,R,P)$

表达多次历史事实经过比较以后形成的结构模式。

223.14 Experience查询

ExperienceRepository可以提供：

findExperienceById()
findExperiencesByCondition()
findExperiencesByObject()
findExperiencesByMethod()
findExperiencesByCapability()
findExperiencesByResult()
findExperiencesByState()
findRecentExperiences()

例如：

$Query(C)→{E1,E2,…,En}Query(C) \rightarrow \{E_1,E_2,\ldots,E_n\}$

然后：

$ExperienceEngineExperienceEngine$

进一步判断：

$Applicable(E,C)Applicable(E,C)$

因此：

$Repository→CandidateExperiencesRepository \rightarrow Candidate Experiences$

而不是：

$Repository→FinalExperienceDecisionRepository \rightarrow Final Experience Decision$

223.15 Experience调用

Experience调用过程：

Current Context
 ↓
ExperienceRepository
 ↓
Candidate Experience
 ↓
ExperienceEngine
 ↓
Condition Matching
 ↓
Pattern Matching
 ↓
Applicability
 ↓
Experience Result

可以表示为：

$Recall(E,C)→ERRecall(E,C)\rightarrow ER$

其中：

$EE$ ：Experience；
$CC$ ：Current Context；
$ERER$ ：Experience Recall Result。

Repository只是提供候选经验。

223.16 History查询

History不是只能按ID查询。

可以按照：

Individual
Object
Behavior
Action
Execution
Result
Method
Decision
Time
State

查询。

例如：

$findExecutionHistory(Ex)findExecutionHistory(E_x)$

或者：

$findHistoryByObject(O)findHistoryByObject(O)$

或者：

$findHistoryByTime(T1,T2)findHistoryByTime(T_1,T_2)$

形成：

$Query(H,C)→{H1,…,Hn}Query(H,C)\rightarrow\{H_1,\ldots,H_n\}$

然后交给 MemoryEngine / ExperienceEngine 进行后续计算。

223.17 History不能被修改成Memory

历史必须保持事实性。

例如：

History H1
Result = Failed

后来系统修复成功：

History H2
Result = Success

不能把：

H1 = Failed

直接改成：

H1 = Success

应该：

$H1→H2H_1\rightarrow H_2$

保留两个事实。

因此：

$History必须可追溯\boxed{ History必须可追溯 }$

223.18 Memory可以更新

Memory与History不同。

Memory可以根据新的验证事实更新：

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

例如：

Memory M1
Weight = 0.6

经过新的验证：

Weight = 0.9

可以形成：

Memory Update

同时保留 Memory History。

因此建议：

memories
memory_history

分开保存。

223.19 Experience可以修订

Experience也不是永久不变。

例如：

Experience E1

Condition X
→
Method M1
→
Success

后来发现：

Condition X + Resource < 2
→
Failure

那么原 Experience 的适用条件可能需要修订。

形成：

$Et+ΔE→Et+1E_t+\Delta E\rightarrow E_{t+1}$

并记录：

Experience History

因此：

$ExperienceUpdate≠ExperienceOverwriteExperienceUpdate \neq ExperienceOverwrite$

223.20 Memory History

定义：

$MH=(M,Mb,Ma,Δ,R,T)MH=(M,M_b,M_a,\Delta,R,T)$

其中：

$MM$ ：Memory；
$MbM_b$ ：修改前；
$MaM_a$ ：修改后；
$Δ\Delta$ ：变化；
$RR$ ：原因；
$TT$ ：时间。

例如：

Memory M1

Before:
Weight = 0.6

After:
Weight = 0.9

Reason:
New verified evidence

这样可以追踪 Memory 为什么发生变化。

223.21 Experience History

定义：

$EH=(E,Eb,Ea,Δ,R,T)EH=(E,E_b,E_a,\Delta,R,T)$

其中：

$EbE_b$ ：更新前 Experience；
$EaE_a$ ：更新后 Experience；
$Δ\Delta$ ：变化；
$RR$ ：变化原因；
$TT$ ：变化时间。

这样：

$Experience→ExperienceHistoryExperience \rightarrow ExperienceHistory$

成为完整的经验演化轨迹。

223.22 Memory与Experience关系查询

Repository还需要查询：

$Memory→ExperienceMemory\rightarrow Experience$

例如：

$findExperiencesByMemoryId(M)findExperiencesByMemoryId(M)$

以及：

$findMemoriesByExperienceId(E)findMemoriesByExperienceId(E)$

形成：

Memory M1
 ↓
supports
 ↓
Experience E1

或者：

Memory M2
 ↓
conflicts_with
 ↓
Experience E2

这些关系必须显式保存，而不能依靠程序猜测。

223.23 History → Memory

History到Memory的形成：

History
 ↓
Importance
 ↓
Relevance
 ↓
Recurrence
 ↓
Verification
 ↓
Memory Candidate
 ↓
MemoryEngine
 ↓
Memory
 ↓
MemoryRepository

这里：

$MemoryCandidateMemoryCandidate$

是计算结果。

Repository只负责最终保存。

因此：

$MemoryEngine决定记忆计算\boxed{ MemoryEngine决定记忆计算 }$ $MemoryRepository决定记忆持久化\boxed{ MemoryRepository决定记忆持久化 }$

223.24 Memory → Experience

经验形成：

Memory
 ↓
Condition
 ↓
History Comparison
 ↓
Relation
 ↓
Pattern
 ↓
Experience Candidate
 ↓
ExperienceEngine
 ↓
Experience
 ↓
ExperienceRepository

公式：

$Experience=f(H,M,C,R,P)Experience = f(H,M,C,R,P)$

其中：

$HH$ ：历史；
$MM$ ：记忆；
$CC$ ：条件；
$RR$ ：结果；
$PP$ ：模式。

223.25 Repository不负责Experience生成

不能设计：

ExperienceRepository
    ↓
自动分析
    ↓
Experience

正确：

History
 ↓
ExperienceEngine
 ↓
Experience Candidate
 ↓
Verification
 ↓
ExperienceRepository
 ↓
MySQL

这样可以保持：

$Engine=CalculationEngine=Calculation$ $Repository=PersistenceRepository=Persistence$

223.26 PHP接口

可以建立：

<?php

interface MemoryExperienceRepositoryInterface
{
    public function findMemoryById($id);

    public function findMemoriesByObjectId($objectId);

    public function findMemoriesByContext($context);

    public function findMemoriesByState($state);

    public function findRecentMemories($limit);

    public function saveMemory($memory);

    public function updateMemory($memory);

    public function saveMemoryHistory($history);

    public function findMemoryHistory($memoryId);

    public function findExperienceById($id);

    public function findExperiencesByCondition($condition);

    public function findExperiencesByObjectId($objectId);

    public function findExperiencesByMethodId($methodId);

    public function findExperiencesByCapabilityId($capabilityId);

    public function findRecentExperiences($limit);

    public function saveExperience($experience);

    public function updateExperience($experience);

    public function saveExperienceHistory($history);

    public function findExperienceHistory($experienceId);

    public function findHistoryByObjectId($objectId);

    public function findHistoryByTimeRange($start,$end);

    public function saveMemoryRelation($relation);

    public function findMemoryRelations($memoryId);

    public function saveExperienceRelation($relation);

    public function findExperienceRelations($experienceId);
}

223.27 MemoryMapper

class MemoryMapper
{
    public function toPersistence($memory)
    {
        return array(
            'id' => $memory->getId(),
            'information' => $memory->getInformation(),
            'context_data' => $memory->getContext(),
            'weight' => $memory->getWeight(),
            'memory_time' => $memory->getTime(),
            'state' => $memory->getState()
        );
    }

    public function toDomain($data)
    {
        $memory = new Memory();

        $memory->setId($data['id']);
        $memory->setInformation(
            $data['information']
        );
        $memory->setContext(
            $data['context_data']
        );
        $memory->setWeight(
            $data['weight']
        );
        $memory->setTime(
            $data['memory_time']
        );
        $memory->setState(
            $data['state']
        );

        return $memory;
    }
}

223.28 ExperienceMapper

class ExperienceMapper
{
    public function toPersistence($experience)
    {
        return array(
            'id' => $experience->getId(),
            'history_data' => $experience->getHistory(),
            'memory_data' => $experience->getMemory(),
            'condition_data' => $experience->getCondition(),
            'result_data' => $experience->getResult(),
            'pattern_data' => $experience->getPattern(),
            'state' => $experience->getState()
        );
    }

    public function toDomain($data)
    {
        $experience = new Experience();

        $experience->setId($data['id']);
        $experience->setHistory(
            $data['history_data']
        );
        $experience->setMemory(
            $data['memory_data']
        );
        $experience->setCondition(
            $data['condition_data']
        );
        $experience->setResult(
            $data['result_data']
        );
        $experience->setPattern(
            $data['pattern_data']
        );
        $experience->setState(
            $data['state']
        );

        return $experience;
    }
}

223.29 HistoryMapper

class HistoryMapper
{
    public function toPersistence($history)
    {
        return array(
            'object_id' =>
                $history->getObjectId(),
            'behavior_id' =>
                $history->getBehaviorId(),
            'action_id' =>
                $history->getActionId(),
            'execution_id' =>
                $history->getExecutionId(),
            'result_data' =>
                $history->getResult(),
            'before_state' =>
                $history->getBeforeState(),
            'after_state' =>
                $history->getAfterState(),
            'history_time' =>
                $history->getTime()
        );
    }
}

223.30 MySQL数据结构

Memory：

CREATE TABLE memories (
    id INT NOT NULL AUTO_INCREMENT,
    information TEXT NOT NULL,
    context_data TEXT,
    weight DECIMAL(12,6),
    memory_time DATETIME NOT NULL,
    state VARCHAR(50),
    created_at DATETIME NOT NULL,
    updated_at DATETIME,
    PRIMARY KEY (id)
);

Memory History：

CREATE TABLE memory_history (
    id INT NOT NULL AUTO_INCREMENT,
    memory_id INT NOT NULL,
    before_data TEXT,
    after_data TEXT,
    change_data TEXT,
    reason TEXT,
    changed_at DATETIME NOT NULL,
    PRIMARY KEY (id)
);

Experience：

CREATE TABLE experiences (
    id INT NOT NULL AUTO_INCREMENT,
    condition_data TEXT,
    result_data TEXT,
    pattern_data TEXT,
    state VARCHAR(50),
    created_at DATETIME NOT NULL,
    updated_at DATETIME,
    PRIMARY KEY (id)
);

Experience History：

CREATE TABLE experience_history (
    id INT NOT NULL AUTO_INCREMENT,
    experience_id INT NOT NULL,
    before_data TEXT,
    after_data TEXT,
    change_data TEXT,
    reason TEXT,
    changed_at DATETIME NOT NULL,
    PRIMARY KEY (id)
);

Memory Relation：

CREATE TABLE memory_relations (
    id INT NOT NULL AUTO_INCREMENT,
    memory_id INT NOT NULL,
    relation_type VARCHAR(50) NOT NULL,
    target_memory_id INT NOT NULL,
    condition_data TEXT,
    state VARCHAR(50),
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id)
);

Experience Relation：

CREATE TABLE experience_relations (
    id INT NOT NULL AUTO_INCREMENT,
    experience_id INT NOT NULL,
    relation_type VARCHAR(50) NOT NULL,
    target_experience_id INT NOT NULL,
    condition_data TEXT,
    state VARCHAR(50),
    created_at DATETIME NOT NULL,
    PRIMARY KEY (id)
);

以上 SQL 是体系设计示例。正式实施时仍需要根据实际数据库版本、已有表结构、索引和关联关系进行验证。

223.31 查询条件模型

Repository查询可以形成结构化 Query：

$Q=(O,C,S,T,R,L)Q=(O,C,S,T,R,L)$

其中：

$OO$ ：Object；
$CC$ ：Context；
$SS$ ：State；
$TT$ ：Time；
$RR$ ：Relation；
$LL$ ：Limit。

例如：

$query = array(
    'object_id' => 10,
    'state' => 'verified',
    'start_time' => '2026-01-01 00:00:00',
    'end_time' => '2026-09-11 23:59:59',
    'limit' => 20
);

Repository根据 Query 返回候选数据。

223.32 Memory查询与排序

Repository可以先返回：

M1
M2
M3
M4

然后 MemoryEngine 计算：

$Score(Mi)Score(M_i)$

例如：

$Score(Mi)=WrRi+WvVi+WtTi+WiIiScore(M_i) = W_rR_i + W_vV_i + W_tT_i + W_iI_i$

其中：

$RiR_i$ ：相关性；
$ViV_i$ ：验证程度；
$TiT_i$ ：时间因素；
$IiI_i$ ：重要性；
$Wr,Wv,Wt,WiW_r,W_v,W_t,W_i$ ：对应权重。

这里的排序属于 MemoryEngine，不属于 Repository。

因此：

$Repository负责查询候选\boxed{ Repository负责查询候选 }$ $MemoryEngine负责计算相关性\boxed{ MemoryEngine负责计算相关性 }$

223.33 Experience查询与适用性

Repository返回：

E1
E2
E3

ExperienceEngine进一步计算：

$Applicable(Ei,C)Applicable(E_i,C)$

可能结果：

E1 = Applicable
E2 = Partial
E3 = Unmatched

因此：

$ExperienceRepository≠ExperienceEngineExperienceRepository \neq ExperienceEngine$

223.34 查询历史与时间

Memory、Experience都具有时间属性。

因此查询必须支持时间范围：

$T1≤T≤T2T_1\leq T\leq T_2$

例如：

过去30天
过去100次执行
最近20条Memory
最近10条Experience

时间过滤属于 Repository Query。

时间影响权重属于 MemoryEngine / ExperienceEngine。

这两个职责必须分离。

223.35 当前事实与历史记忆

Repository读取到的 Memory 是过去信息。

不能直接覆盖当前事实。

例如：

Memory:
Object-A = Ready

当前：

Current State:
Object-A = Blocked

那么：

$CurrentState≠MemoryStateCurrentState \neq MemoryState$

当前 State 应由 StateEngine / StateRepository 提供。

Memory只能作为辅助认知依据。

因此：

$CurrentFact>HistoricalMemory\boxed{ CurrentFact > HistoricalMemory }$

这里的“大于”表示当前实际事实具有更高的当前状态优先级，而不是数值大小。

223.36 Memory与Experience查询边界

可以建立：

Memory Query
 ↓
MemoryRepository

和：

Experience Query
 ↓
ExperienceRepository

也可以提供：

MemoryExperienceRepository

进行统一查询。

但是内部仍然应该保持：

Memory
Experience
History

三个独立 Domain Object。

因此：

$UnifiedRepository≠UnifiedDomainObject\boxed{ UnifiedRepository \neq UnifiedDomainObject }$

223.37 Repository与事务

Memory与Experience更新可能来自同一个 Learning 过程：

Learning
 ↓
Memory Update
 ↓
Experience Update

可以由 Service / TransactionManager 协调：

Begin
 ↓
Save Memory
 ↓
Save Memory History
 ↓
Save Experience
 ↓
Save Experience History
 ↓
Verify
 ↓
Commit

Repository参与持久化。

但：

$MemoryExperienceRepository≠TransactionManagerMemoryExperienceRepository \neq TransactionManager$

223.38 完整认知数据流

从执行阶段开始：

Behavior
 ↓
Action
 ↓
Execution
 ↓
Result
 ↓
Execution History
 ↓
Memory
 ↓
Experience
 ↓
Learning
 ↓
Update

Repository对应：

Execution
 ↓
ExecutionRepository

Result
 ↓
ResultRepository

History
 ↓
HistoryRepository

Memory
 ↓
MemoryRepository

Experience
 ↓
ExperienceRepository

协作层：

$MemoryExperienceRepositoryMemoryExperienceRepository$

负责 Memory、Experience、History 的联合持久化和查询。

223.39 与第222章连接

第222章：

$Behavior→Action→Execution→Result→ExecutionHistoryBehavior \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow ExecutionHistory$

第223章继续：

$ExecutionHistory→Memory→ExperienceExecutionHistory \rightarrow Memory \rightarrow Experience$

因此形成：

$Behavior→Action→Execution→Result→History→Memory→Experience\boxed{ Behavior \rightarrow Action \rightarrow Execution \rightarrow Result \rightarrow History \rightarrow Memory \rightarrow Experience }$

这已经从执行系统进入长期认知数据系统。

223.40 与LearningEngine连接

Experience形成后：

Experience
 ↓
LearningEngine
 ↓
Learning Candidate
 ↓
UpdateEngine
 ↓
Knowledge / Capability / Method / Individual

完整关系：

$History→Memory→Experience→Learning→UpdateHistory \rightarrow Memory \rightarrow Experience \rightarrow Learning \rightarrow Update$

Repository在这里承担的是数据边界：

History
 ↕
Repository

Memory
 ↕
Repository

Experience
 ↕
Repository

而计算仍由：

MemoryEngine
ExperienceEngine
LearningEngine
UpdateEngine

分别完成。

223.41 PHP工程结构

223.42 完整查询流程

Memory查询：

Request
 ↓
MemoryExperienceService
 ↓
MemoryExperienceRepository
 ↓
MySQL
 ↓
Memory Data
 ↓
MemoryMapper
 ↓
Memory Domain Object
 ↓
MemoryEngine
 ↓
Recall Result

Experience查询：

Request
 ↓
MemoryExperienceService
 ↓
MemoryExperienceRepository
 ↓
MySQL
 ↓
Experience Data
 ↓
ExperienceMapper
 ↓
Experience Domain Object
 ↓
ExperienceEngine
 ↓
Applicable Experience

Repository始终位于持久化边界。

223.43 完整保存流程

Memory：

$Memory→Validate→Map→Repository→MySQLMemory \rightarrow Validate \rightarrow Map \rightarrow Repository \rightarrow MySQL$

Experience：

$Experience→Validate→Map→Repository→MySQLExperience \rightarrow Validate \rightarrow Map \rightarrow Repository \rightarrow MySQL$

History：

$History→Validate→Map→Repository→MySQLHistory \rightarrow Validate \rightarrow Map \rightarrow Repository \rightarrow MySQL$

三个对象分别保存，但可以由同一个 Service 统一协调。

223.44 本章核心公式

Memory：

$M=(I,C,W,T,R)\boxed{ M=(I,C,W,T,R) }$

Experience：

$E=(H,M,C,R,P)\boxed{ E=(H,M,C,R,P) }$

History：

$H={h1,h2,…,hn}\boxed{ H=\{h_1,h_2,\ldots,h_n\} }$

单条History：

$h=(T,O,A,R,S)\boxed{ h=(T,O,A,R,S) }$

Memory History：

$MH=(M,Mb,Ma,Δ,R,T)\boxed{ MH=(M,M_b,M_a,\Delta,R,T) }$

Experience History：

$EH=(E,Eb,Ea,Δ,R,T)\boxed{ EH=(E,E_b,E_a,\Delta,R,T) }$

Memory Relation：

$MR=(M1,T,M2,C)\boxed{ MR=(M_1,T,M_2,C) }$

Experience Relation：

$ER=(E1,T,E2,C)\boxed{ ER=(E_1,T,E_2,C) }$

Memory更新：

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

Experience更新：

$Et+ΔE→Et+1\boxed{ E_t+\Delta E\rightarrow E_{t+1} }$

核心认知链：

$History→Memory→Experience\boxed{ History \rightarrow Memory \rightarrow Experience }$

Repository查询：

$Query(Context)→Candidates\boxed{ Query(Context)\rightarrow Candidates }$

而最终适用性判断：

$Candidates→MemoryEngine/ExperienceEngine→CognitiveResult\boxed{ Candidates \rightarrow MemoryEngine/ExperienceEngine \rightarrow CognitiveResult }$

223.45 本章核心原则

原则一：History、Memory、Experience必须分离

$History≠Memory≠ExperienceHistory\neq Memory\neq Experience$

原则二：History记录事实

$History=PastFactsHistory=PastFacts$

原则三：Memory保存可再次使用的信息

$Memory=RetainedInformationMemory=RetainedInformation$

原则四：Experience保存结构化模式

$Experience=StructuredPatternExperience=StructuredPattern$

原则五：Repository负责保存与查询

$Repository=Persistence+QueryRepository=Persistence+Query$

原则六：MemoryEngine负责记忆计算

$MemoryEngine=Calculation+Recall+UpdateEvaluationMemoryEngine=Calculation+Recall+UpdateEvaluation$

原则七：ExperienceEngine负责经验计算

$ExperienceEngine=Calculation+Invocation+UpdateEvaluationExperienceEngine=Calculation+Invocation+UpdateEvaluation$

原则八：查询不等于认知判断

$Query≠RelevanceQuery\neq Relevance$ $Query≠ApplicabilityQuery\neq Applicability$

原则九：历史不能被最终结果覆盖

$H1≠H2H_1\neq H_2$

即使第二次执行成功，也不能删除第一次失败历史。

原则十：当前事实优先于历史记忆

$CurrentFact>HistoricalMemoryCurrentFact > HistoricalMemory$

Memory不能覆盖当前 State。

原则十一：Memory和Experience的更新必须可追溯

$Update→HistoryUpdate \rightarrow History$

原则十二：Repository不能代替Engine

$Repository≠MemoryEngineRepository\neq MemoryEngine$ $Repository≠ExperienceEngineRepository\neq ExperienceEngine$

223.46 本章总结

第223章建立了 ICAI 长期认知数据的重要 Repository 边界：

$MemoryExperienceRepository=Memory+Experience+History+Query\boxed{ MemoryExperienceRepository = Memory + Experience + History + Query }$

其中：

History：

$记录实际发生的事实\boxed{记录实际发生的事实}$

Memory：

$保存未来可以重新调用的信息\boxed{保存未来可以重新调用的信息}$

Experience：

$从历史与记忆中形成可重复利用的结构化模式\boxed{从历史与记忆中形成可重复利用的结构化模式}$

三者形成：

$History→Memory→Experience\boxed{ History \rightarrow Memory \rightarrow Experience }$

Repository负责：

Save
Load
Update
Query
Relation
History

MemoryEngine负责：

Memory Calculation
Memory Recall
Memory Update Evaluation

ExperienceEngine负责：

Experience Calculation
Experience Invocation
Experience Update Evaluation

LearningEngine继续负责：

Experience
 ↓
Learning Candidate

UpdateEngine负责：

Learning Candidate
 ↓
Verified Update

因此完整链条形成：

$Execution→Result→History→Memory→Experience→Learning→Update\boxed{ Execution \rightarrow Result \rightarrow History \rightarrow Memory \rightarrow Experience \rightarrow Learning \rightarrow Update }$

再返回：

$Update→Knowledge/Capability/Method/Individual\boxed{ Update \rightarrow Knowledge / Capability / Method / Individual }$

最终重新进入：

$CognitiveEngine→Goal→Capability→Matching→Method→Decision→Behavior→Action→Execution\boxed{ CognitiveEngine \rightarrow Goal \rightarrow Capability \rightarrow Matching \rightarrow Method \rightarrow Decision \rightarrow Behavior \rightarrow Action \rightarrow Execution }$

由此形成一个完整的、可以持续保存过去事实、调用过去信息、形成经验、产生学习变化并更新未来认知计算基础的 ICAI 数据闭环。

整个体系仍然基于符号对象、离散数据、规则、条件、关系、历史、记忆、经验和确定性计算，不依赖 LLM、Transformer、Embedding、Vector Search、Prompt Engineering、神经网络或 LLM API。

第223章 MemoryExperienceRepository

第223章 MemoryExperienceRepository

223.1 MemoryExperienceRepository定义

223.2 Memory领域对象

223.3 Experience领域对象

223.4 History领域对象

223.5 三者之间的关系

223.6 History：记录发生过什么

223.7 Memory：保存什么值得再次使用

223.8 Experience：过去形成了什么模式

223.9 Memory的保存

223.10 Memory查询

223.11 查询不等于记忆计算

223.12 Memory Relation

223.13 Experience保存

223.14 Experience查询

223.15 Experience调用

223.16 History查询

223.17 History不能被修改成Memory

223.18 Memory可以更新

223.19 Experience可以修订

223.20 Memory History

223.21 Experience History

223.22 Memory与Experience关系查询

223.23 History → Memory

223.24 Memory → Experience

223.25 Repository不负责Experience生成

223.26 PHP接口

223.27 MemoryMapper

223.28 ExperienceMapper

223.29 HistoryMapper

223.30 MySQL数据结构

223.31 查询条件模型

223.32 Memory查询与排序

223.33 Experience查询与适用性

223.34 查询历史与时间

223.35 当前事实与历史记忆

223.36 Memory与Experience查询边界

223.37 Repository与事务

223.38 完整认知数据流

223.39 与第222章连接

223.40 与LearningEngine连接

223.41 PHP工程结构

223.42 完整查询流程

223.43 完整保存流程

223.44 本章核心公式

223.45 本章核心原则

原则一：History、Memory、Experience必须分离

原则二：History记录事实

原则三：Memory保存可再次使用的信息

原则四：Experience保存结构化模式

原则五：Repository负责保存与查询

原则六：MemoryEngine负责记忆计算

原则七：ExperienceEngine负责经验计算

原则八：查询不等于认知判断

原则九：历史不能被最终结果覆盖

原则十：当前事实优先于历史记忆

原则十一：Memory和Experience的更新必须可追溯

原则十二：Repository不能代替Engine

223.46 本章总结