第一章 执行理论
1.1 执行的提出
在结构智能中,认知、能力、决策和方法都属于解决问题的重要结构,但这些结构本身并不等于现实中的行为。
认知解决:
当前是什么。
能力解决:
能够完成什么。
决策解决:
当前选择什么。
方法解决:
应该怎样完成。
而执行解决:
已经确定的方法如何真正被运行,并产生实际结果。
因此,执行是从方法结构进入实际处理过程的关键环节。
基本关系为:
Decision→Method→ExecutionDecision \rightarrow Method \rightarrow Execution
其中:
DecisionDecision
确定执行方向;
MethodMethod
确定执行结构;
ExecutionExecution
则按照方法结构真正进行处理。
因此,执行可以定义为:
执行是将已经确定的方法结构实例化为当前具体执行过程,并按照对象、参数、条件、规则、能力和操作之间的结构关系逐步运行,使方法产生实际结果的过程。
执行不是方法的另一个名称。
Execution≠MethodExecution\neq Method
方法是结构,执行是过程。
因此:
Method=执行应该怎样组织Method=\text{执行应该怎样组织} Execution=按照这个组织实际进行Execution=\text{按照这个组织实际进行}
1.2 方法与执行的根本区别
方法属于相对稳定的结构。
例如:
MethodComparePriceMethod_{ComparePrice}
表示:
对两个对象的价格进行比较。
它规定:
ObjectAObject_A ObjectBObject_B
以及:
PriceAPrice_A PriceBPrice_B
然后调用:
Compare()Compare()
但是方法本身并没有真正完成比较。
只有执行:
Compare(29.99,39.99)Compare(29.99,39.99)
以后,才产生:
Result=TrueResult=True
因此:
Method→Execution→ResultMethod \rightarrow Execution \rightarrow Result
方法规定:
怎么做。
执行完成:
正在做、已经做了什么。
所以:
Method≠ExecutionMethod\neq Execution
1.3 执行的基本结构
一个完整执行过程至少包含:
Execution={Method,Object,Input,Parameter,Condition,State,Operation,Result,Validation}Execution= \{ Method, Object, Input, Parameter, Condition, State, Operation, Result, Validation \}
其中:
- Method:执行依据的方法;
- Object:实际处理对象;
- Input:输入;
- Parameter:参数;
- Condition:执行条件;
- State:当前状态;
- Operation:具体操作;
- Result:产生结果;
- Validation:结果验证。
因此:
Execution=Method+Binding+Condition+Operation+Result+ValidationExecution = Method + Binding + Condition + Operation + Result + Validation
这说明执行不是一个瞬间动作,而是一个具有内部结构的过程。
1.4 执行的起点
执行不能脱离方法。
完整关系为:
Decision→Method→ExecutionDecision \rightarrow Method \rightarrow Execution
决策完成以后,首先确定执行目标。
例如:
Decision=Select(ProductA)Decision=Select(Product_A)
那么执行目标可能是:
ExecutionGoal=Process(ProductA)ExecutionGoal=Process(Product_A)
然后系统根据执行目标找到对应的方法:
ExecutionGoal→MethodExecutionGoal \rightarrow Method
如果方法已经存在:
ExistingMethod→ExecutionExistingMethod \rightarrow Execution
如果没有现成方法:
MethodGap→MethodFormation→ExecutionMethodGap \rightarrow MethodFormation \rightarrow Execution
因此:
执行以已经确定的方法结构为直接依据,而不是直接从原始信息开始。
1.5 方法实例化是执行的前置条件
抽象方法不能直接处理现实对象。
例如:
Method=ComparePriceMethod=ComparePrice
只是一个通用方法。
真正执行时必须知道:
ObjectAObject_A
和:
ObjectBObject_B
以及:
PriceAPrice_A
和:
PriceBPrice_B
因此:
Method→MethodInstanceMethod \rightarrow MethodInstance
方法实例化以后:
MethodInstance=ComparePrice(ProductA,ProductB,29.99,39.99)MethodInstance = ComparePrice( Product_A, Product_B, 29.99, 39.99 )
此时才具有当前执行对象。
因此:
Method→Instantiation→ExecutionMethod \rightarrow Instantiation \rightarrow Execution
1.6 对象绑定
执行首先需要确定:
对什么对象执行。
对象来自认知结果、决策结果、知识结构或者前一步执行结果。
因此:
ObjectBinding=f(Cognition,Decision,Knowledge,PreviousResult)ObjectBinding = f( Cognition, Decision, Knowledge, PreviousResult )
例如:
Decision=Operate(DeviceA)Decision=Operate(Device_A)
则:
Object=DeviceAObject=Device_A
方法:
Method=StartDeviceMethod=StartDevice
经过对象绑定:
StartDevice(DeviceA)StartDevice(Device_A)
形成具体执行对象。
对象绑定是抽象结构进入具体执行的重要转换。
1.7 属性绑定
对象确定以后,还可能需要读取或修改对象属性。
对象结构:
Object→Attribute→ValueObject \rightarrow Attribute \rightarrow Value
例如:
DeviceA→Temperature→20Device_A \rightarrow Temperature \rightarrow 20
如果方法要求:
Temperature=25Temperature=25
那么执行过程需要:
DeviceA.Temperature→25Device_A.Temperature \rightarrow 25
因此执行可以包含:
ReadAttributeReadAttribute
和:
WriteAttributeWriteAttribute
两类基本过程。
读取:
Object→Attribute→ValueObject\rightarrow Attribute\rightarrow Value
修改:
Object→Attribute→NewValueObject\rightarrow Attribute\rightarrow NewValue
这使执行能够真正作用于对象状态。
1.8 参数绑定
执行不仅需要对象,还需要参数。
参数可以来自:
RequirementRequirement DecisionDecision KnowledgeKnowledge Object.AttributeObject.Attribute PreviousResultPreviousResult SceneStateSceneState
例如:
Method=SetTemperatureMethod=SetTemperature
对象:
DeviceADevice_A
参数:
Temperature=25Temperature=25
则:
SetTemperature(DeviceA,25)SetTemperature(Device_A,25)
形成具体执行实例。
因此:
Method→ObjectBinding→ParameterBinding→ExecutionMethod \rightarrow ObjectBinding \rightarrow ParameterBinding \rightarrow Execution
1.9 执行条件
方法并不是在任何状态下都可以执行。
执行必须检查当前条件。
例如:
Device.Power=TrueDevice.Power=True
可能是某个方法执行的必要条件。
又例如:
Door=ClosedDoor=Closed
可能是启动设备的必要条件。
因此:
ConditionCheckConditionCheck
是执行的重要组成部分。
基本关系:
Method→ConditionCheck→ExecutionMethod \rightarrow ConditionCheck \rightarrow Execution
如果:
Condition=TrueCondition=True
则继续执行。
如果:
Condition=FalseCondition=False
则不能直接执行。
可能进入:
ConditionFalse→MethodSelectionConditionFalse \rightarrow MethodSelection
或者:
ConditionFalse→ReDecisionConditionFalse \rightarrow ReDecision
或者:
ConditionFalse→MethodReformationConditionFalse \rightarrow MethodReformation
1.10 当前状态对执行的影响
执行不是脱离环境的固定过程。
同一个方法,在不同状态下可能产生不同执行结果。
因此:
Execution=f(Method,Object,Parameter,State)Execution = f(Method,Object,Parameter,State)
例如:
Method=StartDeviceMethod=StartDevice
如果:
Power=TruePower=True
设备可能已经处于运行状态。
此时继续执行:
StartStart
可能没有必要。
如果:
Power=FalsePower=False
则可以正常执行。
因此:
MethodSelectionMethodSelection
和:
ExecutionExecution
都必须考虑当前状态。
1.11 执行条件与约束
除了条件之外,执行还受到约束。
例如:
Temperature≤30Temperature\leq30
或者:
Budget≤100Budget\leq100
或者:
Speed≤MaximumSpeedSpeed\leq MaximumSpeed
因此执行前必须进行:
ConstraintCheckConstraintCheck
完整关系:
Method→ConditionCheck→ConstraintCheck→ExecutionMethod \rightarrow ConditionCheck \rightarrow ConstraintCheck \rightarrow Execution
如果约束不满足:
ConstraintFailureConstraintFailure
则执行必须停止、改变参数或者重新选择方法。
1.12 执行结构
方法可以由多个执行单元组成。
例如:
Method={Step1,Step2,Step3}Method = \{ Step_1, Step_2, Step_3 \}
执行过程为:
Step1→Step2→Step3Step_1 \rightarrow Step_2 \rightarrow Step_3
但是,结构智能中的执行并不仅仅是顺序步骤。
执行结构可以包含:
SequenceSequence BranchBranch LoopLoop SubMethodSubMethod CapabilityCallCapabilityCall OperationOperation
因此:
ExecutionStructure=Sequence+Branch+Loop+Call+OperationExecutionStructure = Sequence + Branch + Loop + Call + Operation
1.13 顺序执行
最基本的执行形式是顺序执行。
例如:
A→B→CA \rightarrow B \rightarrow C
其中:
Output(A)→Input(B)Output(A)\rightarrow Input(B) Output(B)→Input(C)Output(B)\rightarrow Input(C)
例如:
ReadPrice→ComparePrice→SelectProductReadPrice \rightarrow ComparePrice \rightarrow SelectProduct
前一步的结果成为后一步的输入。
因此:
ExecutionChain=E1→E2→…→EnExecutionChain = E_1\rightarrow E_2\rightarrow…\rightarrow E_n
1.14 条件执行
执行过程可以根据当前结果决定下一步。
例如:
Condition→{ExecutionA,TrueExecutionB,FalseCondition \rightarrow \begin{cases} Execution_A,&True\\ Execution_B,&False \end{cases}
例如:
Price≤30Price\leq30
成立:
SelectCandidateSelectCandidate
否则:
RejectCandidateRejectCandidate
因此执行不是固定路径,而可以根据当前结构状态动态变化。
1.15 循环执行
当存在多个对象或者多个候选结果时,需要重复执行。
例如:
Candidate1→CompareCandidate_1 \rightarrow Compare Candidate2→CompareCandidate_2 \rightarrow Compare Candidate3→CompareCandidate_3 \rightarrow Compare
直到:
AllCandidatesProcessed=TrueAllCandidatesProcessed=True
因此:
Execution→LoopExecution \rightarrow Loop
循环可以由:
- 对象数量;
- 候选数量;
- 状态;
- 条件;
- 目标完成情况;
决定。
1.16 子方法执行
一个复杂方法可以包含多个子方法。
例如:
MethodA→MethodB→MethodCMethod_A \rightarrow Method_B \rightarrow Method_C
其中:
MethodAMethod_A
是高层问题解决方法,
MethodBMethod_B
是其中一个子方法,
MethodCMethod_C
又可以调用更底层的方法。
因此:
Method→SubMethod→SubMethodMethod \rightarrow SubMethod \rightarrow SubMethod
形成方法执行层次。
1.17 能力在执行过程中的作用
执行过程中可能需要调用能力。
例如:
MethodProductSelectionMethod_{ProductSelection}
需要:
CapabilityMatchingCapability_{Matching}
和:
CapabilityComparisonCapability_{Comparison}
因此:
Execution→Method→CapabilityExecution \rightarrow Method \rightarrow Capability
能力完成具体任务后返回结果:
Capability→Result→MethodCapability \rightarrow Result \rightarrow Method
然后方法继续执行。
因此:
Method→Capability→Result→MethodMethod \rightarrow Capability \rightarrow Result \rightarrow Method
形成方法内部的能力调用循环。
1.18 类方法执行
结构智能继承并扩展面向对象的结构逻辑。
基本结构:
Class={Attribute,Method}Class = \{ Attribute, Method \}
实例化:
Class→ObjectClass \rightarrow Object
对象调用方法:
Object→ClassMethodObject \rightarrow ClassMethod
例如:
ProductA.comparePrice()Product_A.comparePrice()
类方法处理具体对象属性:
Object→Attribute→ValueObject \rightarrow Attribute \rightarrow Value
然后执行操作:
ClassMethod→OperationClassMethod \rightarrow Operation
因此完整关系:
ProblemSolvingMethod→Capability→Object→ClassMethod→OperationProblemSolvingMethod \rightarrow Capability \rightarrow Object \rightarrow ClassMethod \rightarrow Operation
这使高层解决问题过程和对象级执行过程连接起来。
1.19 操作执行
方法负责组织执行结构,操作负责进行具体处理。
例如:
Compare()Compare() Compute()Compute() Match()Match() Judge()Judge() Filter()Filter() Sort()Sort() Verify()Verify()
都属于可以被方法调用的具体操作。
因此:
Method→OperationMethod \rightarrow Operation
操作对输入进行处理:
Operation(Input,Parameter)→ResultOperation(Input,Parameter) \rightarrow Result
例如:
Compare(29.99,39.99)→TrueCompare(29.99,39.99) \rightarrow True
因此:
Execution→Operation→ResultExecution \rightarrow Operation \rightarrow Result
1.20 执行状态
执行本身也具有状态。
可以定义:
ExecutionStateExecutionState
例如:
- Pending
- Ready
- Running
- Waiting
- Completed
- Failed
- Cancelled
其基本变化为:
Pending→Ready→Running→CompletedPending \rightarrow Ready \rightarrow Running \rightarrow Completed
如果出现问题:
Running→FailedRunning \rightarrow Failed
如果条件暂时不能满足:
Running→WaitingRunning \rightarrow Waiting
因此,执行不是一个无状态过程。
1.21 执行上下文
同一个方法在不同执行环境下可能产生不同结果。
因此需要执行上下文:
ExecutionContext={Object,State,Scene,Parameter,Condition,Constraint,Knowledge,Environment}ExecutionContext = \{ Object, State, Scene, Parameter, Condition, Constraint, Knowledge, Environment \}
执行过程根据上下文确定具体行为。
因此:
Execution=f(Method,ExecutionContext)Execution = f(Method,ExecutionContext)
这意味着方法虽然可以复用,但执行实例必须根据当前上下文重新绑定。
1.22 执行中的输入与输出
执行必须形成明确的输入输出关系。
基本结构:
Input→Execution→OutputInput \rightarrow Execution \rightarrow Output
但复杂方法可能具有多个输入和多个输出:
{Input1,Input2,…,Inputn}→Execution→{Output1,Output2,…,Outputm}\{Input_1,Input_2,…,Input_n\} \rightarrow Execution \rightarrow \{Output_1,Output_2,…,Output_m\}
前一个执行的输出可以成为下一个执行的输入:
Output(E1)→Input(E2)Output(E_1) \rightarrow Input(E_2)
因此可以形成执行链。
1.23 执行中的数据传递
执行不是孤立步骤的集合。
不同执行单元之间必须传递结构化数据。
例如:
E1→Result1E_1 \rightarrow Result_1
然后:
Result1→E2Result_1 \rightarrow E_2
因此:
E1→E2E_1\rightarrow E_2
真正建立的是:
Output(E1)→Input(E2)Output(E_1)\rightarrow Input(E_2)
这种结构化数据传递使复杂方法可以连续执行。
1.24 执行中的中间结果
复杂问题往往不能一步得到最终结果。
因此执行过程中会产生:
IntermediateResultIntermediateResult
例如:
ReadPrice→PriceReadPrice \rightarrow Price Price→Compare→ComparisonResultPrice \rightarrow Compare \rightarrow ComparisonResult ComparisonResult→Filter→CandidateComparisonResult \rightarrow Filter \rightarrow Candidate Candidate→Select→FinalResultCandidate \rightarrow Select \rightarrow FinalResult
因此:
Execution=IntermediateResults+FinalResultExecution = IntermediateResults + FinalResult
中间结果也是后续执行的重要输入。
1.25 执行中的错误
执行可能失败。
错误可能发生在不同层次。
对象错误
ObjectNotFoundObjectNotFound
属性错误
AttributeNotFoundAttributeNotFound
参数错误
ParameterInvalidParameterInvalid
条件错误
ConditionFalseConditionFalse
约束错误
ConstraintFailureConstraintFailure
方法错误
MethodFailureMethodFailure
操作错误
OperationFailureOperationFailure
环境错误
EnvironmentFailureEnvironmentFailure
因此:
ExecutionFailureExecutionFailure
必须进一步定位错误结构。
1.26 执行错误处理
错误发生以后不能简单结束整个智能过程。
执行系统需要根据错误类型决定处理方式。
例如:
ObjectNotFound→ObjectRecognitionObjectNotFound \rightarrow ObjectRecognition KnowledgeMissing→KnowledgeAcquisitionKnowledgeMissing \rightarrow KnowledgeAcquisition MethodMissing→MethodFormationMethodMissing \rightarrow MethodFormation ParameterMissing→ParameterAcquisitionParameterMissing \rightarrow ParameterAcquisition ConditionFalse→ReDecisionConditionFalse \rightarrow ReDecision OperationFailure→OperationRetryOperationFailure \rightarrow OperationRetry
因此:
ExecutionFailure→FailureAnalysis→Correction→ReExecutionExecutionFailure \rightarrow FailureAnalysis \rightarrow Correction \rightarrow ReExecution
形成执行恢复机制。
1.27 执行与验证
执行产生结果以后,必须进行验证。
Execution→Result→ValidationExecution \rightarrow Result \rightarrow Validation
验证不是执行本身的一部分结果,而是对执行结果的判断。
例如:
GoalSatisfiedGoalSatisfied
判断目标是否完成;
ConstraintSatisfiedConstraintSatisfied
判断约束是否满足;
StateChangedAsExpectedStateChangedAsExpected
判断对象状态是否按照预期改变。
因此:
Validation=f(Result,Goal,Condition,Constraint,ExpectedState)Validation = f(Result,Goal,Condition,Constraint,ExpectedState)
1.28 内部执行与外部行动
执行可以分为两个基本层次。
内部执行
主要处理:
- 数据;
- 知识;
- 对象;
- 属性;
- 规则;
- 方法;
- 运算。
例如:
Compare()Compare() Compute()Compute() Match()Match() Judge()Judge()
属于内部执行。
其结果可能直接形成:
ResultResult
而不产生外部世界变化。
外部行动
当执行需要作用于设备或现实对象时:
Execution→ActionExecution \rightarrow Action
例如:
SetTemperature→DeviceActionSetTemperature \rightarrow DeviceAction
最终:
Action→WorldChangeAction \rightarrow WorldChange
因此:
InternalExecution≠ExternalActionInternalExecution\neq ExternalAction
但:
InternalExecution→ActionInternalExecution \rightarrow Action
可以形成连续关系。
1.29 执行与设备
在结构智能体系中,设备是执行作用于现实世界的重要载体。
完整关系:
Method→Execution→Device→ActionMethod \rightarrow Execution \rightarrow Device \rightarrow Action
设备接收到执行指令以后改变状态:
DeviceState→NewDeviceStateDeviceState \rightarrow NewDeviceState
于是:
Action→WorldChangeAction \rightarrow WorldChange
这使方法不再局限于信息处理,而可以进入现实世界。
1.30 执行结果与世界状态
如果执行改变了对象状态,则必须记录变化。
例如:
ObjectStateoldObjectState_{old}
经过执行:
ExecutionExecution
变为:
ObjectStatenewObjectState_{new}
因此:
Execution→StateChangeExecution \rightarrow StateChange
状态变化可以表示为:
ΔState=Statenew−Stateold\Delta State = State_{new}-State_{old}
在非数值状态中,则表示为:
Stateold→StatenewState_{old} \rightarrow State_{new}
例如:
Device=Off→Device=OnDevice=Off \rightarrow Device=On
1.31 执行结果反馈
执行结束以后,结果必须返回智能结构。
因此:
Execution→Result→FeedbackExecution \rightarrow Result \rightarrow Feedback
反馈可能包括:
- 成功;
- 失败;
- 新状态;
- 新数据;
- 环境变化;
- 异常;
- 用户反馈。
这些信息可以进入:
ReCognitionReCognition
从而更新当前认知。
1.32 执行与再认知
执行可能改变原来的场景。
例如:
ScenetScene_t
执行:
ActionAction
以后:
Scenet+1Scene_{t+1}
因此:
Scenet→Action→Scenet+1Scene_t \rightarrow Action \rightarrow Scene_{t+1}
原来的认知:
CognitiontCognition_t
可能已经不再适用。
所以必须:
Scenet+1→ReCognitionScene_{t+1} \rightarrow ReCognition
形成:
Execution→WorldChange→Feedback→ReCognitionExecution \rightarrow WorldChange \rightarrow Feedback \rightarrow ReCognition
这使执行进入持续智能循环。
1.33 执行不是一次性的终点
传统意义上的执行容易被理解为:
接收指令 → 完成动作。
但结构智能中的执行不是如此简单。
执行具有:
Start→Process→Result→Validation→FeedbackStart \rightarrow Process \rightarrow Result \rightarrow Validation \rightarrow Feedback
如果结果不正确:
Feedback→ReDecisionFeedback \rightarrow ReDecision
如果环境已经发生变化:
Feedback→ReCognitionFeedback \rightarrow ReCognition
如果知识不足:
Feedback→LearningFeedback \rightarrow Learning
因此:
ExecutionExecution
本身就是智能循环中的一个动态环节。
1.34 执行与学习
执行是学习的重要验证机制。
知识可以在理论结构中成立,但只有进入执行以后,才能验证其是否能够产生正确结果。
因此:
Knowledge→Method→Execution→ValidationKnowledge \rightarrow Method \rightarrow Execution \rightarrow Validation
如果执行成功:
Validation=TrueValidation=True
则说明当前知识、能力、方法和决策之间形成了有效关系。
如果失败:
Validation=FalseValidation=False
则可能暴露:
KnowledgeGapKnowledgeGap CapabilityGapCapabilityGap DecisionGapDecisionGap MethodGapMethodGap OperationGapOperationGap
因此:
Execution→Validation→LearningExecution \rightarrow Validation \rightarrow Learning
1.35 执行形成经验结构
一次执行完成以后,如果执行过程经过验证,可以形成执行记录:
ExecutionRecord={Requirement,Decision,Method,Object,Parameter,Operation,Result,Validation}ExecutionRecord= \{ Requirement, Decision, Method, Object, Parameter, Operation, Result, Validation \}
如果同类执行不断重复:
Execution1Execution_1 Execution2Execution_2 Execution3Execution_3
系统可以比较这些执行过程。
如果发现结构稳定:
Execution1≈Execution2≈Execution3Execution_1 \approx Execution_2 \approx Execution_3
则可以形成稳定的方法执行模式:
StableExecutionPatternStableExecutionPattern
进一步:
StableExecutionPattern→ReusableMethodStableExecutionPattern \rightarrow ReusableMethod
因此,执行不仅使用方法,也可以反过来帮助形成更加稳定的方法。
1.36 执行的可复用性
一个成熟的方法执行过程应当能够从具体对象中抽象出来。
例如:
第一次:
Method(ProductA)→ResultAMethod(Product_A) \rightarrow Result_A
第二次:
Method(ProductB)→ResultBMethod(Product_B) \rightarrow Result_B
如果两次执行使用相同结构:
Method(ProductA)Method(Product_A)
和:
Method(ProductB)Method(Product_B)
则说明方法具有对象独立性。
即:
Method+ObjectAMethod+Object_A
和:
Method+ObjectBMethod+Object_B
都可以形成不同方法实例。
因此:
ReusableMethod+NewObject→NewExecutionReusableMethod + NewObject \rightarrow NewExecution
这也是结构智能方法能够迁移到新对象的基础。
1.37 执行的结构稳定性
方法可以重复使用,但并不意味着每次执行都完全相同。
因为:
ObjectObject
可能不同;
StateState
可能不同;
ParameterParameter
可能不同;
SceneScene
可能不同。
因此:
MethodMethod
保持相对稳定,而:
ExecutionExecution
随着上下文变化。
可以表示为:
Method=StableStructureMethod=StableStructure Execution=ContextDependentProcessExecution=ContextDependentProcess
这一区分使结构智能既能够保持方法复用,又能够适应现实变化。
1.38 执行与时间
执行具有时间顺序。
例如:
E1→E2→E3E_1 \rightarrow E_2 \rightarrow E_3
因此:
t1<t2<t3t_1<t_2<t_3
执行结果可能影响后续执行。
Result1→E2Result_1 \rightarrow E_2 Result2→E3Result_2 \rightarrow E_3
所以:
ExecutionExecution
具有过程性,而:
MethodMethod
主要具有结构性。
1.39 执行与状态变化
执行过程可以改变:
- 对象状态;
- 属性值;
- 场景状态;
- 设备状态;
- 系统状态。
因此:
Execution→StateUpdateExecution \rightarrow StateUpdate
例如:
Battery=20%Battery=20\%
执行充电:
ChargeCharge
得到:
Battery=80%Battery=80\%
因此:
Attribute.Valueold→Operation→Attribute.ValuenewAttribute.Value_{old} \rightarrow Operation \rightarrow Attribute.Value_{new}
这也是执行作用于现实结构的重要表现。
1.40 执行理论的统一结构
至此,可以将执行统一为:
Method→Instantiation→Binding→ConditionCheck→Execution→Operation→Result→Validation\boxed{ Method \rightarrow Instantiation \rightarrow Binding \rightarrow ConditionCheck \rightarrow Execution \rightarrow Operation \rightarrow Result \rightarrow Validation }
如果存在外部世界作用:
Execution→Action→Device→WorldChange\boxed{ Execution \rightarrow Action \rightarrow Device \rightarrow WorldChange }
然后:
WorldChange→Feedback→SceneUpdate→ReCognition\boxed{ WorldChange \rightarrow Feedback \rightarrow SceneUpdate \rightarrow ReCognition }
最终形成:
Decision→Method→Execution→Result→Validation→Action→WorldChange→Feedback→ReCognition\boxed{ Decision \rightarrow Method \rightarrow Execution \rightarrow Result \rightarrow Validation \rightarrow Action \rightarrow WorldChange \rightarrow Feedback \rightarrow ReCognition }
1.41 执行理论的形式化表达
设:
MM
为方法,
OO
为对象,
PP
为参数,
SS
为当前状态,
CC
为条件。
方法实例为:
Mi=Instantiate(M,O,P,S,C)M_i=Instantiate(M,O,P,S,C)
执行过程为:
E=Execute(Mi)E=Execute(M_i)
结果为:
R=Result(E)R=Result(E)
验证为:
V=Validate(R,Mi)V=Validate(R,M_i)
因此:
E=Execute(Instantiate(M,O,P,S,C))\boxed{ E= Execute( Instantiate( M,O,P,S,C ) ) }
进一步:
V=Validate(Result(E),Goal,Condition,Constraint)\boxed{ V= Validate( Result(E), Goal, Condition, Constraint ) }
如果:
V=TrueV=True
则:
ExecutionSuccessExecutionSuccess
如果:
V=FalseV=False
则:
ExecutionFailure→Feedback→CorrectionExecutionFailure \rightarrow Feedback \rightarrow Correction
1.42 执行与结构智能的关系
执行不是结构智能体系之外的附加功能。
它本身就是结构智能的重要组成部分。
因为结构智能必须能够完成:
Structure→Matching→Binding→Operation→ResultStructure \rightarrow Matching \rightarrow Binding \rightarrow Operation \rightarrow Result
而执行正是这一过程的动态实现。
因此:
StructuralIntelligence→ExecutionStructuralIntelligence \rightarrow Execution
意味着结构不仅能够被保存和理解,还能够被运行。
从这个角度看:
结构如果不能执行,只是静态结构;结构能够根据目标、条件、对象和参数被调用并产生结果,才形成可运行的结构智能。
1.43 执行与“智能”的关系
执行本身并不等于智能。
一个固定程序也可以执行。
因此:
Execution≠IntelligenceExecution\neq Intelligence
结构智能中的执行之所以具有智能属性,是因为执行之前存在:
CognitionCognition CapabilityCapability DecisionDecision MethodMethod
并且执行结果还可以:
Feedback→ReCognitionFeedback \rightarrow ReCognition
因此完整智能过程是:
Cognition→Capability→Decision→Method→Execution→FeedbackCognition \rightarrow Capability \rightarrow Decision \rightarrow Method \rightarrow Execution \rightarrow Feedback
执行只是智能结构进入现实过程的一个关键阶段。
1.44 从方法到实际世界
如果只停留在:
MethodMethod
系统仍然处于内部结构层。
只有:
Method→ExecutionMethod \rightarrow Execution
以后,方法才开始实际运行。
如果执行进一步作用于设备:
Execution→DeviceExecution \rightarrow Device
再产生:
ActionAction
最终:
Action→WorldChangeAction \rightarrow WorldChange
于是:
InternalStructure→Execution→ExternalWorldInternalStructure \rightarrow Execution \rightarrow ExternalWorld
形成结构智能与现实世界之间的连接。
1.45 本章结论
本章研究的核心问题是:
方法如何转化为实际执行过程。
其基本关系不是:
Method=ExecutionMethod=Execution
而是:
Method→Instantiation→Binding→ConditionCheck→Execution\boxed{ Method \rightarrow Instantiation \rightarrow Binding \rightarrow ConditionCheck \rightarrow Execution }
方法首先通过对象、属性、参数、状态和条件完成实例化,然后按照方法内部定义的能力、子方法、类方法和操作结构进行实际运行。
因此:
Method→Capability→ClassMethod→Operation→ResultMethod \rightarrow Capability \rightarrow ClassMethod \rightarrow Operation \rightarrow Result
执行完成以后必须进行:
Result→ValidationResult \rightarrow Validation
如果成功:
Validation=TrueValidation=True
则可以进入:
ActionAction
如果失败:
Validation=FalseValidation=False
则进入:
FailureAnalysis→Correction→ReExecutionFailureAnalysis \rightarrow Correction \rightarrow ReExecution
如果执行改变现实对象:
Action→WorldChangeAction \rightarrow WorldChange
然后:
WorldChange→Feedback→SceneUpdate→ReCognitionWorldChange \rightarrow Feedback \rightarrow SceneUpdate \rightarrow ReCognition
因此,执行理论最终形成:
方法→方法实例化→对象绑定→参数绑定→条件检查→执行→运算→结果→验证→行动→世界变化→反馈→再认知\boxed{ 方法 \rightarrow 方法实例化 \rightarrow 对象绑定 \rightarrow 参数绑定 \rightarrow 条件检查 \rightarrow 执行 \rightarrow 运算 \rightarrow 结果 \rightarrow 验证 \rightarrow 行动 \rightarrow 世界变化 \rightarrow 反馈 \rightarrow 再认知 }
由此,WSaiOS-SI中的执行不再只是“运行一个程序”,而是:
将已经形成的解决问题方法,根据当前对象、状态、条件和参数实例化,并通过能力、类方法和操作使其真正运行,在产生结果后进行验证,再根据结果和现实状态变化形成反馈的动态结构过程。
最终形成:
需求→知识→认知→能力→决策→方法→执行→结果→验证→行动→世界变化→反馈→再认知\boxed{ 需求 \rightarrow 知识 \rightarrow 认知 \rightarrow 能力 \rightarrow 决策 \rightarrow 方法 \rightarrow 执行 \rightarrow 结果 \rightarrow 验证 \rightarrow 行动 \rightarrow 世界变化 \rightarrow 反馈 \rightarrow 再认知 }
这使“方法”真正成为连接决策结构与现实执行结构的中间层,使 WSaiOS-SI 从知识、认知和决策进一步进入可运行、可验证、可反馈的智能过程。