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

第十二卷 第一章 执行理论

第一章 执行理论

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 从知识、认知和决策进一步进入可运行、可验证、可反馈的智能过程。

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小时技术值守