第二章 执行结果
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 }
执行结果因此不仅是一个最终值,而是一个新的结构状态。
执行产生的结果至少可以包括:
- 运算结果;
- 判断结果;
- 匹配结果;
- 筛选结果;
- 对象属性变化;
- 对象状态变化;
- 场景变化;
- 环境变化;
- 新产生的信息;
- 对执行过程本身的验证结果。
所以:
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 认知 }
不断循环的动态智能机制。
这也进一步说明,结构智能并不是只研究“如何计算一个结果”,而是研究结构如何作用于对象,执行如何改变状态,变化如何产生新信息,以及新信息如何重新进入智能结构。