首页 理论 架构 工程 规划 文档 白皮书 著作 研究 规范 下载 博客 关于 联系 开始使用 →

第十二卷 第二章 执行结果

第二章 执行结果

2.1 执行结果的定义

执行不是以方法运行结束作为终点。

在结构智能中,一个方法经过实例化、对象绑定、参数绑定、条件检查和具体运算以后,必然会产生某种结果。这个结果可能表现为计算值、判断结果、匹配结果、对象属性变化、对象状态变化、环境变化,也可能产生新的信息。

因此,执行结果是执行过程作用于对象、属性、状态、场景和环境以后形成的结构性输出,以及由这些输出产生的状态变化和新信息。

可以表示为:

Execution→ResultExecution\rightarrow Result

但完整关系并不是简单的:

Execution→ResultExecution\rightarrow Result

而是:

Execution→Result→StateChange→NewInformation→Feedback\boxed{ Execution \rightarrow Result \rightarrow StateChange \rightarrow NewInformation \rightarrow Feedback }

执行结果因此不仅是一个最终值,而是一个新的结构状态。

执行产生的结果至少可以包括:

  1. 运算结果;
  2. 判断结果;
  3. 匹配结果;
  4. 筛选结果;
  5. 对象属性变化;
  6. 对象状态变化;
  7. 场景变化;
  8. 环境变化;
  9. 新产生的信息;
  10. 对执行过程本身的验证结果。

所以:

Result=Value+StateChange+NewInformation+ValidationResult = Value+StateChange+NewInformation+Validation

这里的“+”不是简单的数据相加,而是表示这些结构成分共同构成执行结果。


2.2 执行结果不是单一数据

传统程序通常将执行结果理解为函数返回值。

例如:

Compute(10,20)→30Compute(10,20)\rightarrow30

其中:

Result=30Result=30

这种结果是正确的,但对于结构智能而言,这只是执行结果的一种最基本形式。

结构智能需要处理的是现实对象和结构关系。

例如,一个产品对象:

ProductProduct

具有:

Price=29.99Price=29.99

执行:

Compare(Price,30)Compare(Price,30)

得到:

Result=TrueResult=True

这里的 True 只是运算结果。

进一步根据规则:

Price<30→LowPricePrice<30\rightarrow LowPrice

则可以形成:

State=LowPriceState=LowPrice

于是执行过程产生的不再只是:

TrueTrue

而是:

Price=29.99Price=29.99

对应的新的状态认知:

State=LowPriceState=LowPrice

因此:

OperationResult≠CompleteExecutionResultOperationResult\neq CompleteExecutionResult

更准确地说:

OperationResult→Interpretation→StateChangeOperationResult \rightarrow Interpretation \rightarrow StateChange

这说明执行结果必须放在完整结构中理解。


2.3 执行结果的结构

执行结果可以定义为:

Result={Output,ObjectState,SceneState,NewInformation,Validation}Result= \{ Output, ObjectState, SceneState, NewInformation, Validation \}

其中:

Output

表示直接产生的输出。

例如:

Compute(10,20)→30Compute(10,20)\rightarrow30

则:

Output=30Output=30

ObjectState

表示执行以后对象自身的状态。

例如:

Battery.Level=20Battery.Level=20

执行充电方法:

Charge(Battery,80)Charge(Battery,80)

执行后:

Battery.Level=80Battery.Level=80

于是:

ObjectStateold→ObjectStatenewObjectState_{old} \rightarrow ObjectState_{new}

SceneState

表示对象所在场景发生的变化。

例如:

Room.Temperature=20Room.Temperature=20

设备执行加热:

Heat(Room)Heat(Room)

执行后:

Room.Temperature=25Room.Temperature=25

于是:

SceneStateold→SceneStatenewSceneState_{old} \rightarrow SceneState_{new}

NewInformation

表示执行过程中或者执行以后产生的新的信息。

例如:

执行检测方法:

Check(Device)Check(Device)

原来不知道:

Battery.Status=?Battery.Status=?

检测以后获得:

Battery.Status=NormalBattery.Status=Normal

因此:

Unknown→KnownUnknown\rightarrow Known

这就是新信息。

Validation

表示执行结果是否满足预期。

例如:

ExpectedTemperature=25ExpectedTemperature=25

执行后:

ActualTemperature=25ActualTemperature=25

验证:

Verify(Actual,Expected)→TrueVerify(Actual,Expected)\rightarrow True

则:

Validation=TrueValidation=True

因此完整执行结果可以表示为:

Result={Output,ObjectState,SceneState,NewInformation,Validation}\boxed{ Result= \{ Output, ObjectState, SceneState, NewInformation, Validation \} }


2.4 结果与对象的关系

结构智能中的执行通常不是对孤立数据进行处理,而是对结构中的对象进行处理。

因此:

Execution→ObjectExecution\rightarrow Object

执行可能读取对象:

Object→Attribute→ValueObject\rightarrow Attribute\rightarrow Value

也可能修改对象:

Object→Attribute→NewValueObject\rightarrow Attribute\rightarrow NewValue

于是:

Valueold→Operation→ValuenewValue_{old} \rightarrow Operation \rightarrow Value_{new}

例如:

Product.Price=30Product.Price=30

执行价格修改:

SetPrice(Product,25)SetPrice(Product,25)

得到:

Product.Price=25Product.Price=25

于是对象结构发生变化:

Objectold→ObjectnewObject_{old} \rightarrow Object_{new}

但是这里并不是产生了一个完全不同的对象。

更准确地说:

ObjectObject

仍然是同一个对象,其属性状态发生了变化。

因此:

ObjectIdentity=StableObjectIdentity=Stable

而:

ObjectState=ChangedObjectState=Changed

这一点对于结构智能非常重要。


2.5 属性值变化

对象状态变化通常首先表现为属性值变化。

基本结构:

Object→Attribute→ValueObject\rightarrow Attribute\rightarrow Value

执行以后:

Object→Attribute→NewValueObject\rightarrow Attribute\rightarrow NewValue

因此:

Attribute:Valueold→ValuenewAttribute: Value_{old}\rightarrow Value_{new}

例如:

Car.Speed=20Car.Speed=20

执行:

Accelerate(Car,50)Accelerate(Car,50)

以后:

Car.Speed=50Car.Speed=50

形成:

Speed:20→50Speed:20\rightarrow50

属性值变化本身就是一种执行结果。

因此:

AttributeChange⊂ResultAttributeChange \subset Result

但是属性值变化还可能进一步导致状态变化。


2.6 属性变化产生状态变化

结构智能不能将属性值和状态简单等同。

属性是结构中的描述维度,状态是根据当前属性值、关系、条件和规则形成的当前情况。

例如:

Battery.Level=20Battery.Level=20

根据规则:

Level<30→LowPowerLevel<30\rightarrow LowPower

可以形成:

Battery.State=LowPowerBattery.State=LowPower

执行充电:

Charge(Battery,80)Charge(Battery,80)

得到:

Battery.Level=80Battery.Level=80

重新进行状态判断:

Level>70→NormalPowerLevel>70\rightarrow NormalPower

于是:

Battery.State:LowPower→NormalPowerBattery.State: LowPower\rightarrow NormalPower

因此执行形成了完整的变化:

AttributeValueChange→StateChange\boxed{ AttributeValueChange \rightarrow StateChange }

进一步可以表示为:

Execution→AttributeChange→StateReevaluation→StateChangeExecution \rightarrow AttributeChange \rightarrow StateReevaluation \rightarrow StateChange

这说明执行结果并不只是记录“改了什么”,还需要确定“改变以后意味着什么”。


2.7 对象状态变化

对象状态是执行结果的重要组成部分。

定义:

对象状态是对象在当前条件、属性值、关系和环境下所处的结构情况。

因此:

State=f(Object,Attribute,Value,Relation,Condition,Environment)State=f(Object,Attribute,Value,Relation,Condition,Environment)

执行以后:

Stateold→Execution→StatenewState_{old} \rightarrow Execution \rightarrow State_{new}

例如,一个设备:

DeviceDevice

初始状态:

State=OffState=Off

执行:

PowerOn(Device)PowerOn(Device)

得到:

State=OnState=On

因此:

Off→OnOff\rightarrow On

但是状态变化不一定由单一属性直接决定。

例如:

Temperature=80Temperature=80

同时:

Pressure=HighPressure=High

再结合:

Environment=ClosedEnvironment=Closed

可能形成:

State=RiskState=Risk

所以状态可能来自多个结构成分的组合:

State=f(Attribute,Value,Relation,Condition,Scene)State = f(Attribute,Value,Relation,Condition,Scene)

这使执行结果能够进入更高层次的认知。


2.8 场景状态变化

对象不是孤立存在的。

多个对象之间存在关系,并共同构成当前场景。

因此:

Scene={Object,Relation,State,Condition}Scene= \{Object,Relation,State,Condition\}

当执行作用于某个对象时,可能改变整个场景。

例如:

RoomRoom

包含:

PersonPerson

和:

AirConditionerAirConditioner

执行:

TurnOn(AirConditioner)TurnOn(AirConditioner)

首先改变:

AirConditioner.StateAirConditioner.State

随后可能改变:

Room.TemperatureRoom.Temperature

最终形成:

SceneStateold→SceneStatenewSceneState_{old} \rightarrow SceneState_{new}

因此:

ObjectChange→RelationChange→SceneChange\boxed{ ObjectChange \rightarrow RelationChange \rightarrow SceneChange }

并不是所有对象状态变化都会产生场景变化,但当对象状态影响其他对象或环境时,就会形成场景变化。


2.9 关系变化

执行还可能改变对象之间的关系。

例如:

PersonPerson

与:

DeviceDevice

原来没有:

Controls(Person,Device)Controls(Person,Device)

执行授权操作以后:

Controls(Person,Device)=TrueControls(Person,Device)=True

于是关系发生变化:

Relationold→RelationnewRelation_{old} \rightarrow Relation_{new}

又例如:

OrderOrder

与:

ProductProduct

原来:

Order→PendingOrder\rightarrow Pending

完成支付以后:

Order→PaidOrder\rightarrow Paid

其关系和状态结构都可能发生变化。

因此完整结果可以包含:

Result={ValueChange,AttributeChange,RelationChange,StateChange,SceneChange}Result= \{ ValueChange, AttributeChange, RelationChange, StateChange, SceneChange \}


2.10 执行产生新信息

执行不仅改变已有结构,还可能产生执行以前不存在的信息。

这是执行结果进入认知和学习系统的重要原因。

例如:

系统原来只有:

DeviceDevice

但是不知道:

Temperature=?Temperature=?

执行检测:

MeasureTemperature(Device)MeasureTemperature(Device)

得到:

Temperature=35Temperature=35

于是:

Unknown→KnownUnknown\rightarrow Known

形成:

NewInformation={Temperature=35}NewInformation=\{Temperature=35\}

因此:

Execution→NewInformation\boxed{ Execution\rightarrow NewInformation }

新信息可以来自:

  • 测量;
  • 检测;
  • 计算;
  • 比较;
  • 判断;
  • 匹配;
  • 分类;
  • 状态变化;
  • 环境反馈;
  • 用户反馈;
  • 设备反馈;
  • 执行失败;
  • 执行成功。

2.11 运算结果形成新信息

最简单的新信息来自运算。

例如:

Price=29.99Price=29.99

执行:

Compare(29.99,30)Compare(29.99,30)

得到:

29.99<3029.99<30

这个关系以前可能并未存储。

因此:

NewInformation={Price<30}NewInformation= \{Price<30\}

再根据规则:

Price<30→LowPricePrice<30\rightarrow LowPrice

形成:

NewInformation={Price<30,State=LowPrice}NewInformation= \{ Price<30, State=LowPrice \}

所以:

Knowledge+Operation→NewInformationKnowledge + Operation \rightarrow NewInformation

这说明运算不是单纯改变数字,而可以产生新的结构关系。


2.12 判断结果形成新信息

判断同样能够形成新的信息。

例如:

Battery.Level=80Battery.Level=80

执行:

Judge(Level>70)Judge(Level>70)

得到:

TrueTrue

于是产生:

Battery.State=NormalBattery.State=Normal

因此:

Judge→Result→StateInformationJudge \rightarrow Result \rightarrow StateInformation

判断结果如果经过验证,就可以进入知识结构或者当前场景结构。


2.13 匹配结果形成新信息

匹配也是结构智能的重要运算。

例如需求:

Requirement={Object=ElectricToothbrush,Function=Charging}Requirement= \{ Object=ElectricToothbrush, Function=Charging \}

知识中存在:

ProductA.Function=ChargingProductA.Function=Charging

执行:

Match(Requirement,ProductA)Match(Requirement,ProductA)

得到:

Match=TrueMatch=True

这个结果说明:

ProductAProductA

满足当前需求中的指定结构。

因此:

MatchResult→NewInformationMatchResult \rightarrow NewInformation

进一步可以形成:

Candidate=ProductACandidate=ProductA

所以:

Knowledge→Match→CandidateInformationKnowledge \rightarrow Match \rightarrow CandidateInformation


2.14 执行失败也是结果

执行结果不能只记录成功。

如果:

ExecutionExecution

没有完成预定目标,也会产生结果。

例如:

Charge(Battery,80)Charge(Battery,80)

执行失败:

Result=FalseResult=False

但:

FalseFalse

本身不是完整结果。

系统还需要知道失败发生在哪里。

例如:

BatteryNotFoundBatteryNotFound

或者:

MethodFailureMethodFailure

或者:

ParameterInvalidParameterInvalid

于是:

ExecutionFailure={Type,Cause,Context,State,AvailableInformation}ExecutionFailure= \{ Type, Cause, Context, State, AvailableInformation \}

因此:

ExecutionFailure⊂ResultExecutionFailure \subset Result

失败结果能够形成新的信息:

Failure→FailureInformationFailure \rightarrow FailureInformation

例如:

MethodAMethodA

无法处理:

ObjectBObjectB

可以形成:

MethodGapMethodGap

或者:

KnowledgeGapKnowledgeGap

因此:

执行失败→问题信息→缺口识别→再学习\boxed{ 执行失败 \rightarrow 问题信息 \rightarrow 缺口识别 \rightarrow 再学习 }

执行失败并不是智能过程的终止,而是新的信息来源。


2.15 结果与验证

执行产生结果以后,不能立即认为执行成功。

必须进行验证:

Execution→Result→ValidationExecution \rightarrow Result \rightarrow Validation

验证需要将实际结果与目标、条件、约束以及预期状态进行比较。

可以表示为:

Validation=f(Result,Goal,Condition,Constraint,ExpectedState)Validation= f(Result,Goal,Condition,Constraint,ExpectedState)

例如目标:

Goal=Temperature=25Goal=Temperature=25

执行以后:

ActualTemperature=25ActualTemperature=25

则:

Validation=TrueValidation=True

如果:

ActualTemperature=30ActualTemperature=30

则:

Validation=FalseValidation=False

因此:

Result≠SuccessResult\neq Success

更加准确:

Result→Validation→Success/Failure\boxed{ Result \rightarrow Validation \rightarrow Success/Failure }

结果是执行产生的事实,验证是对这个事实是否满足目标进行判断。


2.16 结果验证产生新的信息

验证本身也能够产生新信息。

例如:

Expected=25Expected=25 Actual=25Actual=25

验证:

Verify(Actual,Expected)→TrueVerify(Actual,Expected)\rightarrow True

产生:

ExecutionSuccessful=TrueExecutionSuccessful=True

如果:

Actual=30Actual=30

则:

Verify(30,25)→FalseVerify(30,25)\rightarrow False

进一步可以产生:

ExecutionDeviation=5ExecutionDeviation=5

因此:

Validation→NewInformationValidation \rightarrow NewInformation

完整过程:

Execution→Result→Validation→ValidationInformationExecution \rightarrow Result \rightarrow Validation \rightarrow ValidationInformation

这类信息对于后续决策和学习非常重要。


2.17 执行结果进入认知

执行完成以后,现实世界或者对象结构已经发生变化。

因此原来的认知可能已经不再适用。

例如:

执行以前:

Battery.Level=20Battery.Level=20

认知:

Battery.State=LowPowerBattery.State=LowPower

执行:

Charge(Battery)Charge(Battery)

执行以后:

Battery.Level=80Battery.Level=80

此时原来的:

State=LowPowerState=LowPower

已经失效。

系统必须重新认识当前对象:

NewState=NormalPowerNewState=NormalPower

因此:

ExecutionResult→SceneUpdate→ReCognitionExecutionResult \rightarrow SceneUpdate \rightarrow ReCognition

这就是结构智能中的结果闭环。


2.18 执行结果进入反馈

执行结果不仅改变当前结构,还要向系统反馈。

基本关系:

Execution→Result→FeedbackExecution \rightarrow Result \rightarrow Feedback

反馈内容可以包括:

Feedback={Result,StateChange,NewInformation,Validation,Error,EnvironmentChange}Feedback= \{ Result, StateChange, NewInformation, Validation, Error, EnvironmentChange \}

反馈不是简单的“成功/失败”。

反馈真正提供的是:

执行以后,当前结构发生了什么变化,以及实际结果与预期之间存在什么关系。

因此:

Feedback=ActualChange+Validation+NewInformationFeedback = ActualChange+Validation+NewInformation


2.19 执行结果更新场景

执行以后,场景必须根据实际结果进行更新。

Sceneold→Execution→ScenenewScene_{old} \rightarrow Execution \rightarrow Scene_{new}

例如:

初始:

Scene1={Room.Temperature=20,AirConditioner=Off}Scene_1= \{ Room.Temperature=20, AirConditioner=Off \}

执行:

TurnOn(AirConditioner)TurnOn(AirConditioner)

经过一段执行过程以后:

Scene2={Room.Temperature=25,AirConditioner=On}Scene_2= \{ Room.Temperature=25, AirConditioner=On \}

于是:

Scene1→Scene2Scene_1\rightarrow Scene_2

场景更新并不是简单覆盖旧数据,而是形成新的当前结构状态。

因此:

SceneUpdate=f(Result,WorldChange)SceneUpdate= f(Result,WorldChange)


2.20 结果驱动再认知

场景变化以后,系统必须重新进行认知。

完整关系:

Execution→Result→Feedback→SceneUpdate→ReCognitionExecution \rightarrow Result \rightarrow Feedback \rightarrow SceneUpdate \rightarrow ReCognition

再认知过程再次使用知识结构:

NewScene→Element→KnowledgeMatching→KnowledgeSemanticUnderstanding→CognitionResultNewScene \rightarrow Element \rightarrow KnowledgeMatching \rightarrow KnowledgeSemanticUnderstanding \rightarrow CognitionResult

于是:

旧认知→执行→新结果→新场景→新认知旧认知 \rightarrow 执行 \rightarrow 新结果 \rightarrow 新场景 \rightarrow 新认知

这说明认知不是一次性的。

认知是随着现实状态变化而不断更新的结构过程。


2.21 执行结果与知识更新

如果执行结果经过验证,并且具有稳定的结构意义,就可以进入知识更新过程。

例如原知识:

Product.Price=30Product.Price=30

执行检测得到:

ActualPrice=28ActualPrice=28

经过验证:

Verify(28)→TrueVerify(28) \rightarrow True

那么知识结构可以更新:

Price:30→28Price:30\rightarrow28

于是:

ExecutionResult→ValidatedInformation→KnowledgeUpdateExecutionResult \rightarrow ValidatedInformation \rightarrow KnowledgeUpdate

但并不是所有执行结果都立即成为长期知识。

必须区分:

ResultResult

和:

KnowledgeKnowledge

执行结果是当前执行产生的事实。

知识则是经过结构化、验证并能够被后续认知、能力和决策调用的结构信息。

因此:

Result≠KnowledgeResult \neq Knowledge

而是:

Result→Validation→KnowledgeCandidate→KnowledgeUpdate\boxed{ Result \rightarrow Validation \rightarrow KnowledgeCandidate \rightarrow KnowledgeUpdate }


2.22 执行结果与能力更新

执行结果还可以反映能力是否有效。

例如一个能力:

CapabilityACapability_A

调用方法:

MethodAMethod_A

连续多次执行成功:

Success1,Success2,…,SuccessnSuccess_1,Success_2,\ldots,Success_n

说明:

CapabilityACapability_A

已经形成稳定的解决问题结构。

反之,如果连续执行失败:

Failure1,Failure2,…Failure_1,Failure_2,\ldots

则可能说明:

CapabilityGapCapabilityGap

或者:

MethodGapMethodGap

因此:

ExecutionResult→CapabilityEvaluationExecutionResult \rightarrow CapabilityEvaluation

进一步:

CapabilityEvaluation→CapabilityUpdateCapabilityEvaluation \rightarrow CapabilityUpdate


2.23 执行结果与方法更新

方法是解决问题的执行结构。

如果执行结果表明:

MethodMethod

可以稳定达到目标,则该方法可以被保留。

如果执行结果反复表明某一步存在问题:

Stepi→FailureStep_i\rightarrow Failure

则可以重新检查:

KnowledgeKnowledge CapabilityCapability ConditionCondition ParameterParameter OperationOperation

以及:

MethodStructureMethodStructure

因此:

ExecutionResult→MethodEvaluation→MethodCorrectionExecutionResult \rightarrow MethodEvaluation \rightarrow MethodCorrection

如果一个执行过程经过多次验证以后形成稳定结构:

StableExecutionPattern→ReusableMethodStableExecutionPattern \rightarrow ReusableMethod

所以执行结果不仅是方法的输出,也可以反过来修正方法。


2.24 结果的时间结构

执行结果还具有时间上的结构。

执行之前:

Statet0State_{t0}

执行:

ExecutiontExecution_t

执行以后:

Statet1State_{t1}

因此:

Statet0→Executiont→Statet1State_{t0} \rightarrow Execution_t \rightarrow State_{t1}

如果继续执行:

Statet1→Executiont+1→Statet2State_{t1} \rightarrow Execution_{t+1} \rightarrow State_{t2}

于是形成连续变化:

State0→State1→State2→State3→⋯State_0 \rightarrow State_1 \rightarrow State_2 \rightarrow State_3 \rightarrow\cdots

这使结构智能能够描述动态对象,而不是只能描述静态知识。


2.25 结果的因果结构

执行结果还应保存产生结果的结构原因。

例如:

Price=29.99Price=29.99

不是一个孤立数字。

它可能来自:

Source→Object→Attribute→ValueSource \rightarrow Object \rightarrow Attribute \rightarrow Value

同样:

State=LowPriceState=LowPrice

可能来自:

Price=29.99Price=29.99

以及:

Rule:Price<30→LowPriceRule: Price<30\rightarrow LowPrice

因此:

Result=Cause+Process+OutputResult = Cause+Process+Output

可以进一步表示:

ExecutionResult={Input,Condition,Method,Operation,Output,StateChange,Validation}ExecutionResult= \{ Input, Condition, Method, Operation, Output, StateChange, Validation \}

这样,系统不仅知道“结果是什么”,还知道:

为什么产生这个结果。


2.26 结果可以成为下一次执行的输入

执行结果并不一定是整个过程的终点。

一个方法的输出可以成为下一个方法的输入:

MethodA→ResultA→MethodBMethod_A \rightarrow Result_A \rightarrow Method_B

或者:

ExecutionA→OutputA→ExecutionBExecution_A \rightarrow Output_A \rightarrow Execution_B

例如:

Compare(Product.Price,30)→TrueCompare(Product.Price,30) \rightarrow True

然后:

True→Select(Product)True \rightarrow Select(Product)

再:

Select(Product)→Order(Product)Select(Product) \rightarrow Order(Product)

因此:

Resulti→Inputi+1\boxed{ Result_i\rightarrow Input_{i+1} }

多个执行结果连接以后,可以形成完整的问题解决过程。


2.27 中间结果

复杂执行通常不会一次产生最终结果。

而是:

E1→R1E_1\rightarrow R_1 R1→E2→R2R_1\rightarrow E_2\rightarrow R_2 R2→E3→R3R_2\rightarrow E_3\rightarrow R_3

最终:

Rn=FinalResultR_n=FinalResult

其中:

R1,R2,…,Rn−1R_1,R_2,\ldots,R_{n-1}

都是中间结果。

中间结果可以用于:

  • 参数传递;
  • 条件判断;
  • 分支选择;
  • 方法调用;
  • 能力调用;
  • 状态更新;
  • 下一步执行。

因此:

Execution=E1+E2+⋯+EnExecution = E_1+E_2+\cdots+E_n

而:

Result=R1+R2+⋯+RnResult = R_1+R_2+\cdots+R_n

最终结果由整个执行链形成。


2.28 执行结果的结构层次

执行结果可以形成多个层次:

第一层:操作结果

Operation→OutputOperation\rightarrow Output

例如:

10+20→3010+20\rightarrow30

第二层:方法结果

多个操作形成方法结果:

Method→ResultMethod\rightarrow Result

第三层:能力结果

能力调用方法完成任务:

Capability→ResultCapability\rightarrow Result

第四层:决策结果

多个候选结果经过评价以后:

Candidates→DecisionCandidates\rightarrow Decision

第五层:世界结果

执行行动以后:

Action→WorldChangeAction\rightarrow WorldChange

因此:

OperationResult→MethodResult→CapabilityResult→DecisionResult→WorldResult\boxed{ OperationResult \rightarrow MethodResult \rightarrow CapabilityResult \rightarrow DecisionResult \rightarrow WorldResult }

这些不是互相独立的结果,而是同一个结构执行链中的不同层次。


2.29 结果与世界变化

如果执行只发生在系统内部,那么结果可能只是内部结构变化。

例如:

Compute()Compute()

只产生:

ValueValue

但是当执行作用于外部设备或者现实对象时,就可能产生实际世界变化:

Execution→Device→Action→WorldChangeExecution \rightarrow Device \rightarrow Action \rightarrow WorldChange

例如:

SetTemperature(Device,25)SetTemperature(Device,25)

执行以后:

Device.State=25Device.State=25

进一步:

Room.Temperature=25Room.Temperature=25

这就是从内部结构执行到外部世界变化。

因此:

InternalResult→Action→ExternalResult→WorldChangeInternalResult \rightarrow Action \rightarrow ExternalResult \rightarrow WorldChange


2.30 世界变化产生新的信息

现实世界发生变化以后,又会产生新的信息。

例如:

Action→Device→WorldChangeAction \rightarrow Device \rightarrow WorldChange

设备执行以后产生:

Temperature=25Temperature=25

系统再次获取:

SensorDataSensorData

得到:

Temperature=25Temperature=25

于是:

WorldChange→Perception→InformationWorldChange \rightarrow Perception \rightarrow Information

形成:

Execution→WorldChange→NewInformation\boxed{ Execution \rightarrow WorldChange \rightarrow NewInformation }

这使执行与感知、认知形成闭环。


2.31 执行结果闭环

结构智能中的完整执行闭环可以表示为:

Method→Execution→Result→Validation→Feedback→SceneUpdate→ReCognition\boxed{ Method \rightarrow Execution \rightarrow Result \rightarrow Validation \rightarrow Feedback \rightarrow SceneUpdate \rightarrow ReCognition }

如果产生新的需求:

ReCognition→RequirementReCognition \rightarrow Requirement

然后重新进入:

Requirement→Knowledge→Capability→Decision→MethodRequirement \rightarrow Knowledge \rightarrow Capability \rightarrow Decision \rightarrow Method

因此:

Requirement→Knowledge→Cognition→Capability→Decision→Method→Execution→Result→Validation→Feedback→ReCognition\boxed{ Requirement \rightarrow Knowledge \rightarrow Cognition \rightarrow Capability \rightarrow Decision \rightarrow Method \rightarrow Execution \rightarrow Result \rightarrow Validation \rightarrow Feedback \rightarrow ReCognition }

这不是一个单向流程,而是一个可以持续运行的结构循环。


2.32 执行结果与再学习

执行结果最终还可以进入学习过程。

如果结果成功:

SuccessfulResult→Validation→StableStructureSuccessfulResult \rightarrow Validation \rightarrow StableStructure

可以形成:

KnowledgeUpdateKnowledgeUpdate CapabilityStrengtheningCapabilityStrengthening MethodReuseMethodReuse

如果结果失败:

FailedResult→FailureAnalysisFailedResult \rightarrow FailureAnalysis

可能发现:

KnowledgeGapKnowledgeGap CapabilityGapCapabilityGap DecisionGapDecisionGap MethodGapMethodGap OperationGapOperationGap

然后:

Gap→LearningRequirement→KnowledgeAcquisition→StructureUpdate→CapabilityUpdate→MethodUpdateGap \rightarrow LearningRequirement \rightarrow KnowledgeAcquisition \rightarrow StructureUpdate \rightarrow CapabilityUpdate \rightarrow MethodUpdate

因此:

ExecutionResult→Evaluation→Learning\boxed{ ExecutionResult \rightarrow Evaluation \rightarrow Learning }

执行结果成为学习系统的重要输入。


2.33 执行结果不是答案,而是结构变化的记录

结构智能必须特别区分:

AnswerAnswer

与:

ExecutionResultExecutionResult

答案通常是最终需要返回给用户的结果。

执行结果则记录:

  • 执行了什么;
  • 使用了什么方法;
  • 作用于什么对象;
  • 使用了什么参数;
  • 产生了什么输出;
  • 对象发生了什么变化;
  • 场景发生了什么变化;
  • 得到了什么新信息;
  • 是否满足目标;
  • 是否产生异常;
  • 下一步应该如何处理。

因此:

Answer⊆ResultAnswer\subseteq Result

但:

Result≠AnswerResult\neq Answer

结果是更完整的结构。


2.34 执行结果的形式化表示

可以将执行结果统一定义为:

ER={ExecutionID,Method,Object,Input,Parameter,Condition,Operation,Output,AttributeChange,RelationChange,StateChange,SceneChange,NewInformation,Validation,Feedback}\boxed{ ER= \{ ExecutionID, Method, Object, Input, Parameter, Condition, Operation, Output, AttributeChange, RelationChange, StateChange, SceneChange, NewInformation, Validation, Feedback \} }

其中:

ER=ExecutionResultER=ExecutionResult

如果只需要表达核心结构,可以简化为:

ER={Output,StateChange,NewInformation,Validation,Feedback}\boxed{ ER= \{ Output, StateChange, NewInformation, Validation, Feedback \} }

执行结果因此不是单一返回值,而是一个完整的结构结果。


2.35 执行结果与下一阶段执行

执行结果可以成为后续决策、方法选择和执行的输入。

因此:

Result→CognitionResult \rightarrow Cognition Cognition→CapabilityCognition \rightarrow Capability Capability→DecisionCapability \rightarrow Decision Decision→MethodDecision \rightarrow Method

最终:

Method→ExecutionMethod \rightarrow Execution

于是形成:

Executiont→Resultt→Cognitiont+1→Decisiont+1→Methodt+1→Executiont+1\boxed{ Execution_t \rightarrow Result_t \rightarrow Cognition_{t+1} \rightarrow Decision_{t+1} \rightarrow Method_{t+1} \rightarrow Execution_{t+1} }

这就是结构智能持续运行的基础。


2.36 执行结果的统一理论关系

到这里,可以将本章的全部关系统一为:

Execution→Output→AttributeChange→StateChange→SceneChange→NewInformation→Validation→Feedback\boxed{ Execution \rightarrow Output \rightarrow AttributeChange \rightarrow StateChange \rightarrow SceneChange \rightarrow NewInformation \rightarrow Validation \rightarrow Feedback }

如果产生外部行动:

Execution→Action→WorldChange→Feedback\boxed{ Execution \rightarrow Action \rightarrow WorldChange \rightarrow Feedback }

如果反馈改变了当前认知:

Feedback→SceneUpdate→ReCognition\boxed{ Feedback \rightarrow SceneUpdate \rightarrow ReCognition }

如果反馈暴露了结构缺口:

Feedback→GapDetection→Learning→KnowledgeUpdate→CapabilityUpdate→MethodUpdate\boxed{ Feedback \rightarrow GapDetection \rightarrow Learning \rightarrow KnowledgeUpdate \rightarrow CapabilityUpdate \rightarrow MethodUpdate }

最终形成:

Knowledge→Cognition→Capability→Decision→Method→Execution→Result→Validation→Feedback→ReCognition→Learning\boxed{ Knowledge \rightarrow Cognition \rightarrow Capability \rightarrow Decision \rightarrow Method \rightarrow Execution \rightarrow Result \rightarrow Validation \rightarrow Feedback \rightarrow ReCognition \rightarrow Learning }


2.37 执行结果在结构智能中的理论意义

执行结果使结构智能从静态结构进入动态结构。

如果没有执行:

KnowledgeKnowledge

只是知识结构;

CapabilityCapability

只是能力结构;

MethodMethod

只是方法结构。

只有当方法真正执行以后:

Method→ExecutionMethod \rightarrow Execution

结构才开始作用于当前对象和现实场景。

执行产生:

ResultResult

结果形成:

StateChangeStateChange

状态变化形成:

NewInformationNewInformation

新信息进入:

FeedbackFeedback

反馈推动:

ReCognitionReCognition

再认知又可以进入:

DecisionDecision

因此,执行结果是连接方法、现实、认知和学习的重要结构节点。


2.38 本章核心结论

本章建立了执行结果理论。

执行结果不是简单的函数返回值,而是方法执行以后形成的综合结构变化。

其核心关系为:

Method→Execution→Result\boxed{ Method \rightarrow Execution \rightarrow Result }

结果进一步表现为:

Result=Output+StateChange+SceneChange+NewInformation+Validation\boxed{ Result = Output + StateChange + SceneChange + NewInformation + Validation }

对象层面:

ObjectStateold→Execution→ObjectStatenew\boxed{ ObjectState_{old} \rightarrow Execution \rightarrow ObjectState_{new} }

场景层面:

Sceneold→Execution→Scenenew\boxed{ Scene_{old} \rightarrow Execution \rightarrow Scene_{new} }

信息层面:

Unknown→Execution→NewInformation\boxed{ Unknown \rightarrow Execution \rightarrow NewInformation }

验证层面:

Result→Validation→Success/Failure\boxed{ Result \rightarrow Validation \rightarrow Success/Failure }

反馈层面:

Result→Feedback→SceneUpdate→ReCognition\boxed{ Result \rightarrow Feedback \rightarrow SceneUpdate \rightarrow ReCognition }

学习层面:

ExecutionResult→Evaluation→Learning\boxed{ ExecutionResult \rightarrow Evaluation \rightarrow Learning }

最终,执行结果理论将执行过程与动态世界连接起来:

方法→执行→结果→状态变化→新信息→反馈→再认知\boxed{ 方法 \rightarrow 执行 \rightarrow 结果 \rightarrow 状态变化 \rightarrow 新信息 \rightarrow 反馈 \rightarrow 再认知 }

因此,在 WSaiOS结构智能(WSaiOS-SI) 中,执行并不是方法的终点,执行结果也不是简单的数据返回。

执行结果是方法作用于对象、场景和环境以后形成的新结构;状态变化是执行对已有结构产生的改变;新信息是执行过程中获得的新的可认知结构;反馈则把执行结果重新送回认知、决策、学习和方法形成过程。

由此,结构智能形成了从:

结构→方法→执行→结果→变化→新信息→认知\boxed{ 结构 \rightarrow 方法 \rightarrow 执行 \rightarrow 结果 \rightarrow 变化 \rightarrow 新信息 \rightarrow 认知 }

不断循环的动态智能机制。

这也进一步说明,结构智能并不是只研究“如何计算一个结果”,而是研究结构如何作用于对象,执行如何改变状态,变化如何产生新信息,以及新信息如何重新进入智能结构。

Leave a Reply

Your email address will not be published. Required fields are marked *

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守