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

第十三卷 第一章 执行理论

第一章 执行理论

1.1 执行的定义

在结构智能系统中,方法解决的是:

如何完成一个目标。

但是,一个方法即使已经形成,也仍然只是一个结构。

例如:

Method={Goal,Input,Object,Condition,Knowledge,Capability,Rule,Operation,Step,Output,Validation}Method= \{ Goal, Input, Object, Condition, Knowledge, Capability, Rule, Operation, Step, Output, Validation \}

这个方法说明了解决问题所需要的目标、对象、知识、能力、条件、规则、运算和步骤,但它还没有真正作用于当前的对象。

只有当方法被放入当前具体场景,与当前对象、属性、值、参数、状态和条件建立绑定,并按照方法规定的结构路径运行以后,才真正形成执行过程。

因此,WSaiOS-SI将执行定义为:

执行是将已经确定的方法结构实例化为当前具体执行过程,并按照对象、参数、条件、规则、能力和操作之间的结构关系逐步运行,使方法产生实际结果的过程。

因此:

Method→Execution\boxed{ Method\rightarrow Execution }

并不是简单的“调用”。

更完整地表示为:

Method→MethodInstantiation→ObjectBinding→ParameterBinding→ConditionCheck→Operation→Result\boxed{ Method \rightarrow MethodInstantiation \rightarrow ObjectBinding \rightarrow ParameterBinding \rightarrow ConditionCheck \rightarrow Operation \rightarrow Result }

执行是方法从结构状态进入运行状态的过程。


1.2 方法与执行的区别

方法和执行必须明确区分。

方法

方法回答:

应该怎样完成这个任务?

例如:

M=Step1→Step2→Step3M= Step_1 \rightarrow Step_2 \rightarrow Step_3

这是一个解决路径。

执行

执行回答:

这个方法现在如何作用于当前对象,并实际运行出结果?

例如:

M(ObjectA,ParameterA,ConditionA)→ExecutionAM(Object_A,Parameter_A,Condition_A) \rightarrow Execution_A

因此:

Method≠ExecutionMethod\neq Execution

方法是抽象的执行结构。

执行是方法在具体对象、具体参数和具体场景中的运行实例。

可以表示为:

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


1.3 方法到执行的转化

方法转化为执行,需要经过实例化。

设:

MM

为方法结构。

当前对象为:

OO

参数为:

PP

当前状态为:

SS

当前条件为:

CC

则:

MethodInstance=Instantiate(M,O,P,S,C)MethodInstance = Instantiate(M,O,P,S,C)

于是:

M→MiM \rightarrow M_i

其中:

MiM_i

是当前任务的具体方法实例。

进一步:

Mi→ExecutionM_i\rightarrow Execution

因此:

Execution=Execute(Instantiate(Method,Object,Parameter,State,Condition))\boxed{ Execution = Execute(Instantiate(Method,Object,Parameter,State,Condition)) }

这说明执行不是重新产生一个方法,而是将已经形成的方法具体化并运行。


1.4 执行的基本组成

执行过程不是单一动作,而是多个结构共同作用的结果。

可以定义:

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+Validation\boxed{ Execution = Method + Binding + Condition + Operation + Result + Validation }


1.5 执行的起点

执行不是从信息直接开始的。

在完整的结构智能过程中,执行之前已经经历:

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

因此执行的直接输入是:

MethodMethod

但方法本身又来自:

DecisionDecision

决策确定:

选择什么解决方向。

方法确定:

按什么路径解决。

执行确定:

现在如何把这条路径真正运行起来。

因此:

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

这是结构智能中决策进入实际行动的重要转换链。


1.6 执行目标

每一次执行都必须具有目标。

设:

GoalGoal

为执行目标。

执行过程不能只表示:

OperationOperation

而必须回答:

Operation→Goal?Operation \rightarrow Goal?

也就是说,执行中的每一步操作都应当能够在方法结构中找到自己的作用。

因此:

ExecutionGoal=MethodGoalExecutionGoal = MethodGoal

或者在复杂方法中:

ExecutionGoali⊆MethodGoalExecutionGoal_i \subseteq MethodGoal

执行的最终结果必须能够回到目标进行验证。

因此:

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


1.7 对象绑定

方法形成时,对象可能只是一个结构中的对象类型。

真正执行时,必须确定当前具体对象。

例如:

Class=ElectricToothbrushClass=ElectricToothbrush

经过实例化以后:

Object=ElectricToothbrushAObject=ElectricToothbrush_A

如果方法是:

CheckPrice()CheckPrice()

则执行时必须确定:

CheckPrice(ElectricToothbrushA)CheckPrice(ElectricToothbrush_A)

因此:

Class→Object→MethodInstance→ExecutionClass \rightarrow Object \rightarrow MethodInstance \rightarrow Execution

对象绑定可以表示为:

ObjectBinding=f(Cognition,Decision,Knowledge,PreviousResult)ObjectBinding= f(Cognition,Decision,Knowledge,PreviousResult)

即当前对象可以来自:

  • 当前认知结果;
  • 决策结果;
  • 知识结构;
  • 前一步执行结果;
  • 当前场景。

1.8 属性绑定

对象确定以后,还需要确定具体属性。

例如:

Object=ProductAObject=Product_A

具有:

PricePrice FunctionFunction CertificationCertification

如果当前方法要求:

PricePrice

则执行必须绑定:

ProductA.PriceProduct_A.Price

得到:

Value=29.99Value=29.99

因此:

Object→Attribute→Value\boxed{ Object\rightarrow Attribute\rightarrow Value }

是执行获取具体数据的基本结构。

方法并不是直接对抽象属性名称进行运算,而是最终必须获得当前对象的具体属性值。


1.9 参数绑定

方法通常包含参数。

例如:

Compare(Price,Limit)Compare(Price,Limit)

其中:

Price=29.99Price=29.99 Limit=30Limit=30

因此执行前需要:

ParameterBindingParameterBinding

形成:

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

参数可以来自:

需求

Requirement→ParameterRequirement\rightarrow Parameter

决策

Decision→ParameterDecision\rightarrow Parameter

对象属性

Object.Attribute→ParameterObject.Attribute\rightarrow Parameter

知识

Knowledge→ParameterKnowledge\rightarrow Parameter

前一步结果

Resulti→Parameteri+1Result_i\rightarrow Parameter_{i+1}

场景状态

SceneState→ParameterSceneState\rightarrow Parameter

因此:

Parameter=Requirement+Knowledge+Object+Decision+PreviousResult+Scene\boxed{ Parameter = Requirement + Knowledge + Object + Decision + PreviousResult + Scene }


1.10 条件绑定

方法不能脱离条件执行。

例如:

MethodAMethod_A

只在:

ConditionA=TrueCondition_A=True

时执行。

因此:

ConditionCheckConditionCheck

是执行的重要步骤。

基本结构:

Condition→Check→{Execute,TrueStop/Branch,FalseCondition \rightarrow Check \rightarrow \begin{cases} Execute,&True\\ Stop/Branch,&False \end{cases}

如果条件不满足:

Condition=FalseCondition=False

则方法不能继续按照原路径执行。

此时可能:

StopStop

或者:

AlternativeMethodAlternativeMethod

或者:

ReDecisionReDecision

因此:

Condition→ExecutionPath\boxed{ Condition \rightarrow ExecutionPath }


1.11 约束检查

执行不仅受到条件约束,还受到目标和约束限制。

设:

ConstraintConstraint

例如:

Price<100Price<100

或者:

Certification=RequiredCertification=Required

执行过程中必须检查:

ConstraintCheckConstraintCheck

如果:

Constraint=TrueConstraint=True

继续执行。

如果:

Constraint=FalseConstraint=False

则:

ExecutionFailureExecutionFailure

或者:

ReDecisionReDecision

因此:

Execution=ConditionCheck+ConstraintCheck+Operation\boxed{ Execution = ConditionCheck + ConstraintCheck + Operation }


1.12 执行状态

执行不是瞬间完成的。

执行可以具有不同状态:

ExecutionState∈{Pending,Ready,Running,Waiting,Completed,Failed,Cancelled}ExecutionState \in \{ Pending, Ready, Running, Waiting, Completed, Failed, Cancelled \}

Pending

方法已经确定,但尚未满足执行条件。

Ready

对象、参数和条件已经准备完成,可以执行。

Running

执行正在进行。

Waiting

等待输入、条件、设备或其他结构。

Completed

执行完成并产生结果。

Failed

执行失败。

Cancelled

执行被取消。

因此:

Pending→Ready→Running→CompletedPending \rightarrow Ready \rightarrow Running \rightarrow Completed

也可能:

Running→FailedRunning \rightarrow Failed

或者:

Running→Waiting→RunningRunning \rightarrow Waiting \rightarrow Running

这说明执行本身也是具有状态变化的结构过程。


1.13 执行顺序

方法可以包含多个步骤。

例如:

M={Step1,Step2,Step3}M= \{ Step_1, Step_2, Step_3 \}

执行形成:

E1→E2→E3E_1 \rightarrow E_2 \rightarrow E_3

其中:

Result(E1)→Input(E2)Result(E_1) \rightarrow Input(E_2)

以及:

Result(E2)→Input(E3)Result(E_2) \rightarrow Input(E_3)

因此:

ExecutionSequence=E1→E2→…→En\boxed{ ExecutionSequence = E_1\rightarrow E_2\rightarrow…\rightarrow E_n }

这使复杂方法可以通过多个执行单元连续完成。


1.14 顺序执行

最基本的执行方式是顺序执行。

Step1→Step2→Step3Step_1 \rightarrow Step_2 \rightarrow Step_3

例如:

ObjectIdentify→PriceRead→Compare→JudgeObjectIdentify \rightarrow PriceRead \rightarrow Compare \rightarrow Judge

每一步的结果可以成为下一步的输入。

因此:

R1→I2R_1\rightarrow I_2 R2→I3R_2\rightarrow I_3

最终:

Rn=ExecutionResultR_n=ExecutionResult


1.15 条件执行

复杂方法通常包含条件。

例如:

Condition→{MethodA,TrueMethodB,FalseCondition \rightarrow \begin{cases} Method_A,&True\\ Method_B,&False \end{cases}

执行过程:

CheckCondition→SelectPath→ExecuteCheckCondition \rightarrow SelectPath \rightarrow Execute

条件本身也可以由对象属性和知识计算产生。

例如:

Price=29.99Price=29.99 Limit=30Limit=30

执行:

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

得到:

TrueTrue

于是进入:

MethodAMethod_A

因此:

Operation→ConditionResult→ExecutionPath\boxed{ Operation \rightarrow ConditionResult \rightarrow ExecutionPath }


1.16 循环执行

某些方法需要重复执行。

例如:

Step→ConditionCheck→Step→ConditionCheck→…Step \rightarrow ConditionCheck \rightarrow Step \rightarrow ConditionCheck \rightarrow …

直到:

Condition=FalseCondition=False

或者:

GoalCompleted=TrueGoalCompleted=True

形成:

ExecutionLoop\boxed{ ExecutionLoop }

循环不是无限重复,而是由结构条件控制。

例如:

while Condition=Truewhile\ Condition=True

其结构可以表示为:

Condition→Execution→Result→ConditionUpdateCondition \rightarrow Execution \rightarrow Result \rightarrow ConditionUpdate

然后再次判断。


1.17 子方法执行

复杂方法可以调用其他方法。

例如:

MethodAMethod_A

内部包含:

MethodBMethod_B

则:

MethodA→MethodB→Result→MethodAMethod_A \rightarrow Method_B \rightarrow Result \rightarrow Method_A

因此:

Method→SubMethod→Operation\boxed{ Method \rightarrow SubMethod \rightarrow Operation }

子方法完成以后,其结果返回上层方法。

这使复杂问题可以分解为多个结构层次。


1.18 能力调用与执行

方法执行过程中可以调用能力。

注意:

Capability≠MethodCapability\neq Method

能力回答:

当前能够完成什么任务。

方法回答:

当前按照什么路径完成任务。

因此执行可能出现:

Method→Capability→MethodMethod \rightarrow Capability \rightarrow Method

例如:

MethodAMethod_A

需要:

CapabilityBCapability_B

则:

MethodA→CapabilityB→Result→MethodAMethod_A \rightarrow Capability_B \rightarrow Result \rightarrow Method_A

能力执行结果返回以后,方法继续运行。

因此:

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


1.19 类与对象的方法执行

结构智能中的类具有属性和方法:

Class={Attribute,Method}Class= \{ Attribute, Method \}

类实例化以后:

Class→ObjectClass \rightarrow Object

对象拥有具体属性值:

Object→Attribute→ValueObject \rightarrow Attribute \rightarrow Value

类中的方法则可以作用于对象。

因此:

ClassMethod(Object)ClassMethod(Object)

形成:

Object→ClassMethod→Operation→ResultObject \rightarrow ClassMethod \rightarrow Operation \rightarrow Result

例如:

Product.ComparePrice()Product.ComparePrice()

实际上是:

ProductObject→ComparePrice→PriceValue→Compare()→ResultProductObject \rightarrow ComparePrice \rightarrow PriceValue \rightarrow Compare() \rightarrow Result

这体现了结构智能对面向对象逻辑的吸收。


1.20 方法实例化与类方法实例化

类方法:

ClassMethodClassMethod

是抽象结构。

对象:

ObjectObject

是具体实例。

当方法作用于对象时:

ClassMethod+Object→MethodInstanceClassMethod + Object \rightarrow MethodInstance

进一步:

MethodInstance→ExecutionMethodInstance \rightarrow Execution

因此:

Class→Object→ClassMethod→MethodInstance→Execution\boxed{ Class \rightarrow Object \rightarrow ClassMethod \rightarrow MethodInstance \rightarrow Execution }

这里的核心不是程序语言本身,而是:

抽象结构必须通过具体对象实例化以后,才能作用于当前对象。


1.21 运算是执行的基本动作

方法负责组织执行结构,而运算负责具体处理。

例如:

Compare()Compare() Compute()Compute() Judge()Judge() Match()Match() Filter()Filter() Sort()Sort() Verify()Verify()

这些属于具体操作。

因此:

Method≠OperationMethod\neq Operation

方法可以包含:

Operation1→Operation2→Operation3Operation_1 \rightarrow Operation_2 \rightarrow Operation_3

例如:

Method→Compare()→Judge()→Verify()Method \rightarrow Compare() \rightarrow Judge() \rightarrow Verify()

所以:

Method=Organization of Operations\boxed{ Method = Organization\ of\ Operations }


1.22 执行中的数据流

执行过程中的数据并不是静态的。

例如:

Input1→Operation1→Result1Input_1 \rightarrow Operation_1 \rightarrow Result_1

然后:

Result1→Operation2→Result2Result_1 \rightarrow Operation_2 \rightarrow Result_2

继续:

Result2→Operation3→Result3Result_2 \rightarrow Operation_3 \rightarrow Result_3

因此:

Input→Operation→Result→NextInput\boxed{ Input \rightarrow Operation \rightarrow Result \rightarrow NextInput }

复杂方法的执行本质上可以理解为结构化的数据和状态流动。


1.23 执行上下文

同一个方法在不同场景中执行,可能得到不同结果。

因此执行必须具有上下文。

定义:

ExecutionContext={Object,State,Scene,Parameter,Condition,Constraint,Knowledge,Environment}ExecutionContext= \{ Object, State, Scene, Parameter, Condition, Constraint, Knowledge, Environment \}

执行结果:

Result=f(Method,ExecutionContext)Result=f(Method,ExecutionContext)

即:

Result=f(Method,Object,State,Parameter,Condition,Knowledge,Scene,Environment)\boxed{ Result = f( Method, Object, State, Parameter, Condition, Knowledge, Scene, Environment ) }

这说明:

方法相同,并不意味着执行结果一定相同。

因为:

ContextA≠ContextBContext_A\neq Context_B

所以:

ResultA≠ResultBResult_A\neq Result_B


1.24 当前状态对执行的影响

对象的当前状态会影响方法执行。

例如:

ObjectState=AvailableObjectState=Available

可以执行:

MethodAMethod_A

但如果:

ObjectState=UnavailableObjectState=Unavailable

则:

MethodAMethod_A

可能无法执行。

因此:

State→Condition→ExecutionState \rightarrow Condition \rightarrow Execution

状态本身可能成为方法的输入。

于是:

ExecutionInput={Object,Attribute,Value,State}ExecutionInput= \{ Object, Attribute, Value, State \}


1.25 环境对执行的影响

如果执行需要外部环境:

EnvironmentEnvironment

则环境也是执行上下文的一部分。

例如:

Environment=NormalEnvironment=Normal

与:

Environment=AbnormalEnvironment=Abnormal

可能产生不同执行路径。

因此:

Environment→Condition→ExecutionPathEnvironment \rightarrow Condition \rightarrow ExecutionPath

如果环境在执行过程中发生变化:

Environmentt→Environmentt+1Environment_t \rightarrow Environment_{t+1}

则当前执行也可能需要调整。

因此执行具有动态性。


1.26 执行中的错误

执行并不保证一定成功。

错误可能来自:

对象错误

ObjectNotFoundObjectNotFound

属性错误

AttributeNotFoundAttributeNotFound

参数错误

ParameterInvalidParameterInvalid

条件错误

ConditionFalseConditionFalse

约束错误

ConstraintFailureConstraintFailure

方法错误

MethodFailureMethodFailure

运算错误

OperationFailureOperationFailure

环境错误

EnvironmentFailureEnvironmentFailure

因此:

ExecutionFailureExecutionFailure

本身也是执行结果的一种。


1.27 执行失败的处理

执行失败以后不能简单地认为整个智能过程结束。

必须首先确定失败原因。

ExecutionFailure→FailureAnalysisExecutionFailure \rightarrow FailureAnalysis

然后判断:

KnowledgeGap?KnowledgeGap? ObjectGap?ObjectGap? AttributeGap?AttributeGap? CapabilityGap?CapabilityGap? MethodGap?MethodGap? ParameterError?ParameterError? EnvironmentChange?EnvironmentChange?

根据不同原因采取不同处理。

例如:

KnowledgeGap→LearningKnowledgeGap \rightarrow Learning

或者:

MethodGap→MethodCorrectionMethodGap \rightarrow MethodCorrection

或者:

ParameterError→ParameterCorrectionParameterError \rightarrow ParameterCorrection

然后:

Correction→ReExecutionCorrection \rightarrow ReExecution

形成:

ExecutionFailure→FailureAnalysis→Correction→ReExecution\boxed{ ExecutionFailure \rightarrow FailureAnalysis \rightarrow Correction \rightarrow ReExecution }


1.28 执行与验证

执行产生结果以后,不能立即认为目标已经完成。

必须验证:

ResultResult

是否符合:

GoalGoal

以及:

ConditionCondition

和:

ConstraintConstraint

因此:

Execution→Result→ValidationExecution \rightarrow Result \rightarrow Validation

验证结构:

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

如果:

Validation=TrueValidation=True

说明执行结果满足当前要求。

如果:

Validation=FalseValidation=False

则:

FeedbackFeedback

产生。

因此:

Execution→Result→Validation→Feedback\boxed{ Execution \rightarrow Result \rightarrow Validation \rightarrow Feedback }


1.29 执行结果

执行结果不只是一个简单的输出值。

结果可以包括:

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

例如执行一个方法以后可能:

  • 得到一个计算值;
  • 修改对象属性;
  • 改变对象状态;
  • 改变场景;
  • 产生新的信息;
  • 验证一个规则;
  • 发现方法错误。

因此:

Execution→ResultExecution\rightarrow Result

是一个结构变化过程。


1.30 执行与对象状态变化

如果执行作用于对象:

ObjectStateoldObjectState_{old}

可能变为:

ObjectStatenewObjectState_{new}

因此:

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

例如:

State=PendingState=Pending

执行以后:

State=CompletedState=Completed

或者:

State=AvailableState=Available

变为:

State=UnavailableState=Unavailable

执行因此成为对象状态变化的重要原因。


1.31 执行与场景变化

对象不是孤立存在的。

场景可以表示为:

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

执行可能改变:

ObjectObject

也可能改变:

RelationRelation

还可能改变:

StateState

或者:

ConditionCondition

因此:

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

这意味着执行不仅改变对象,也可能改变整个场景。


1.32 执行与外部行动

执行必须与行动区分。

内部执行:

InternalExecutionInternalExecution

可以发生在结构和计算层。

例如:

Compare()Compare() Compute()Compute() Judge()Judge()

这些属于内部执行。

而:

ActionAction

是执行产生的实际行为。

因此:

InternalExecution≠ExternalAction\boxed{ InternalExecution\neq ExternalAction }

完整关系为:

Method→Execution→Result→ActionMethod \rightarrow Execution \rightarrow Result \rightarrow Action

如果需要设备:

Method→Execution→Device→ActionMethod \rightarrow Execution \rightarrow Device \rightarrow Action


1.33 设备执行

当结构智能需要作用于现实世界时,方法最终可能需要通过设备执行。

例如:

DeviceDevice

接受:

ExecutionCommandExecutionCommand

形成:

Device→ActionDevice \rightarrow Action

因此:

Method→Execution→Device→Action\boxed{ Method \rightarrow Execution \rightarrow Device \rightarrow Action }

设备不是方法本身。

设备只是方法执行进入现实世界的一种执行载体。


1.34 世界变化

行动可能改变外部世界。

因此:

Action→WorldChangeAction \rightarrow WorldChange

例如:

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

或者:

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

因此完整过程为:

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


1.35 世界变化产生反馈

现实世界发生变化以后,系统需要重新获得信息。

因此:

WorldChange→FeedbackWorldChange \rightarrow Feedback

更完整:

Action→WorldChange→NewInformation→ReCognitionAction \rightarrow WorldChange \rightarrow NewInformation \rightarrow ReCognition

于是:

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

这使执行进入结构智能的闭环。


1.36 执行与再认知

执行以后,原场景可能已经发生变化。

因此原来的认知结果:

CognitiontCognition_t

不能永久作为当前认知。

执行产生:

Scenet+1Scene_{t+1}

以后需要:

ReCognitionReCognition

即:

Scenet→Execution→Scenet+1→ReCognitionScene_t \rightarrow Execution \rightarrow Scene_{t+1} \rightarrow ReCognition

因此:

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

这使结构智能具有连续的动态认知能力。


1.37 执行记录

为了使执行能够被验证、学习和重复使用,需要形成执行记录。

定义:

ExecutionRecord={Requirement,Decision,Method,Object,Parameter,Condition,Operation,Result,Validation}ExecutionRecord= \{ Requirement, Decision, Method, Object, Parameter, Condition, Operation, Result, Validation \}

执行记录不是简单日志。

它保存的是:

这一次问题是为什么执行、使用了什么方法、作用于什么对象、使用了什么参数、经过什么运算、产生什么结果,以及结果是否有效。

因此:

ExecutionRecord→FeedbackExecutionRecord \rightarrow Feedback

以及:

ExecutionRecord→LearningExecutionRecord \rightarrow Learning


1.38 执行与学习

执行是学习的重要现实来源。

因为只有执行以后才能知道:

ExpectedExpected

与:

ActualActual

是否一致。

因此:

Execution→Result→Feedback→LearningExecution \rightarrow Result \rightarrow Feedback \rightarrow Learning

如果执行成功:

Success→ValidPatternSuccess \rightarrow ValidPattern

如果执行失败:

Failure→CauseAnalysisFailure \rightarrow CauseAnalysis

两者都可以进入学习。

因此:

Execution→Learning\boxed{ Execution \rightarrow Learning }

但这里的学习并不是直接把执行记录全部当成知识,而是:

Execution→Result→Validation→Feedback→LearningExecution \rightarrow Result \rightarrow Validation \rightarrow Feedback \rightarrow Learning


1.39 执行与方法形成

如果同一种执行路径不断重复,并且产生稳定结果:

Execution1Execution_1 Execution2Execution_2 Execution3Execution_3

如果它们具有共同结构:

CommonPatternCommonPattern

则可以抽象为:

ReusableMethodReusableMethod

因此:

RepeatedExecution→PatternExtraction→MethodFormation\boxed{ RepeatedExecution \rightarrow PatternExtraction \rightarrow MethodFormation }

这说明方法不仅可以先于执行形成,也可以从执行经验中进一步形成和完善。


1.40 执行与能力形成

同样,执行过程可以验证能力是否真正存在。

能力结构可能理论上能够完成:

TaskTask

但只有执行以后:

Capability→Execution→ResultCapability \rightarrow Execution \rightarrow Result

才能确认能力是否真正有效。

如果连续执行成功:

Capability→StableCapabilityCapability \rightarrow StableCapability

如果失败:

CapabilityFailure→CapabilityGapCapabilityFailure \rightarrow CapabilityGap

因此:

Capability→Execution→Validation→CapabilityUpdate\boxed{ Capability \rightarrow Execution \rightarrow Validation \rightarrow CapabilityUpdate }


1.41 执行的递归结构

复杂执行可以包含执行。

例如:

ExecutionAExecution_A

内部需要:

ExecutionBExecution_B

则:

ExecutionA→ExecutionB→ResultB→ExecutionAExecution_A \rightarrow Execution_B \rightarrow Result_B \rightarrow Execution_A

因此执行本身可以形成层级结构:

Execution→SubExecution→OperationExecution \rightarrow SubExecution \rightarrow Operation

这使复杂方法能够被分解为多个可管理的执行单元。


1.42 执行的组合

多个执行可以组成更高层执行过程:

E1+E2+E3→CompositeExecutionE_1+E_2+E_3 \rightarrow CompositeExecution

如果:

Output(E1)→Input(E2)Output(E_1)\rightarrow Input(E_2)

并且:

Output(E2)→Input(E3)Output(E_2)\rightarrow Input(E_3)

则形成:

E1→E2→E3E_1\rightarrow E_2\rightarrow E_3

这种结构对应复杂方法的实际运行。

因此:

MethodComposition→ExecutionComposition\boxed{ MethodComposition \rightarrow ExecutionComposition }


1.43 执行中的参数传递

复杂方法执行时,一个步骤的结果可能成为另一个步骤的参数。

例如:

E1→R1E_1 \rightarrow R_1

然后:

R1→P2R_1 \rightarrow P_2

再:

P2→E2P_2 \rightarrow E_2

所以:

Resulti→Parameteri+1\boxed{ Result_i \rightarrow Parameter_{i+1} }

这使执行形成连续的数据和结构流。


1.44 执行中的状态传递

不仅参数可以传递,状态也可以传递。

例如:

State0State_0

执行:

E1E_1

以后:

State1State_1

然后:

E2E_2

作用于:

State1State_1

产生:

State2State_2

于是:

State0→E1→State1→E2→State2\boxed{ State_0 \rightarrow E_1 \rightarrow State_1 \rightarrow E_2 \rightarrow State_2 }

复杂执行实际上是状态连续变化的过程。


1.45 执行与目标完成

执行不是为了“运行步骤”本身。

执行的最终目标是实现:

GoalGoal

因此:

Execution→ResultExecution \rightarrow Result

必须进一步判断:

Result→?GoalResult\stackrel{?}{\rightarrow}Goal

如果:

Result⊨GoalResult\models Goal

则:

GoalCompleted=TrueGoalCompleted=True

如果:

Result⊭GoalResult\not\models Goal

则:

GoalCompleted=FalseGoalCompleted=False

可能需要:

ReExecutionReExecution

或者:

MethodCorrectionMethodCorrection

或者:

ReDecisionReDecision


1.46 执行与反馈循环

执行完成以后形成:

ResultResult

结果与预期比较:

Expected↔ActualExpected\leftrightarrow Actual

得到:

DifferenceDifference

形成:

FeedbackFeedback

于是:

Execution→Result→Difference→Feedback\boxed{ Execution \rightarrow Result \rightarrow Difference \rightarrow Feedback }

反馈又可以进入:

ReCognitionReCognition ReDecisionReDecision MethodCorrectionMethodCorrection

以及:

LearningLearning

因此:

Execution→Feedback→ReCognition→ReDecision→Method→ReExecution\boxed{ Execution \rightarrow Feedback \rightarrow ReCognition \rightarrow ReDecision \rightarrow Method \rightarrow ReExecution }

形成执行闭环。


1.47 执行的统一过程

综合前面的理论,执行可以统一表示为:

Decision→Method→MethodInstantiation→ObjectBinding→ParameterBinding→ConditionCheck→ConstraintCheck→Execution→Operation→Result→Validation\boxed{ Decision \rightarrow Method \rightarrow MethodInstantiation \rightarrow ObjectBinding \rightarrow ParameterBinding \rightarrow ConditionCheck \rightarrow ConstraintCheck \rightarrow Execution \rightarrow Operation \rightarrow Result \rightarrow Validation }

如果结果需要作用于现实世界:

Validation→Action→Device→WorldChange→Feedback\boxed{ Validation \rightarrow Action \rightarrow Device \rightarrow WorldChange \rightarrow Feedback }

然后:

Feedback→ReCognition→ReDecision→MethodCorrection→ReExecution\boxed{ Feedback \rightarrow ReCognition \rightarrow ReDecision \rightarrow MethodCorrection \rightarrow ReExecution }


1.48 执行的形式化表达

定义方法:

MM

对象:

OO

参数:

PP

状态:

SS

条件:

CC

约束:

XX

则方法实例化:

Mi=Instantiate(M,O,P,S,C)M_i=Instantiate(M,O,P,S,C)

执行:

E=Execute(Mi,X)E=Execute(M_i,X)

产生结果:

R=Result(E)R=Result(E)

验证:

V=Validate(R,Mi,X)V=Validate(R,M_i,X)

因此:

Mi=Instantiate(M,O,P,S,C)\boxed{ M_i=Instantiate(M,O,P,S,C) } E=Execute(Mi,X)\boxed{ E=Execute(M_i,X) } R=Result(E)\boxed{ R=Result(E) } V=Validate(R,Mi,X)\boxed{ V=Validate(R,M_i,X) }

如果:

V=TrueV=True

则执行成功。

如果:

V=FalseV=False

则:

FeedbackFeedback

进入后续的修正、再决策或学习过程。


1.49 执行理论的完整结构链

将执行理论放入整个结构智能体系:

Information→Element→Object→Relation→State→SceneInformation \rightarrow Element \rightarrow Object \rightarrow Relation \rightarrow State \rightarrow Scene →Cognition→Knowledge→Capability→Decision\rightarrow Cognition \rightarrow Knowledge \rightarrow Capability \rightarrow Decision →Method→MethodInstantiation→ObjectBinding\rightarrow Method \rightarrow MethodInstantiation \rightarrow ObjectBinding →ParameterBinding→ConditionCheck→ConstraintCheck\rightarrow ParameterBinding \rightarrow ConditionCheck \rightarrow ConstraintCheck →Execution→Operation→Result\rightarrow Execution \rightarrow Operation \rightarrow Result →Validation→Action→WorldChange\rightarrow Validation \rightarrow Action \rightarrow WorldChange →Feedback→SceneUpdate→ReCognition\rightarrow Feedback \rightarrow SceneUpdate \rightarrow ReCognition

因此:

信息→认知→能力→决策→方法→执行→结果→行动→世界变化→反馈→再认知\boxed{ 信息 \rightarrow 认知 \rightarrow 能力 \rightarrow 决策 \rightarrow 方法 \rightarrow 执行 \rightarrow 结果 \rightarrow 行动 \rightarrow 世界变化 \rightarrow 反馈 \rightarrow 再认知 }


1.50 执行理论的核心边界

本章需要明确几个基本边界。

第一,方法不是执行

Method≠ExecutionMethod\neq Execution

方法是解决路径,执行是该路径在当前条件下的实际运行。

第二,能力不是执行

Capability≠ExecutionCapability\neq Execution

能力表示能够完成什么任务,执行表示实际完成过程。

第三,操作不是方法

Operation≠MethodOperation\neq Method

操作是具体处理,方法组织多个操作形成解决路径。

第四,结果不是执行

Result≠ExecutionResult\neq Execution

执行是过程,结果是过程产生的输出、状态变化和新信息。

第五,行动不是执行本身

Action≠ExecutionAction\neq Execution

内部执行可以产生行动,行动进一步作用于外部世界。

第六,反馈不是结果

Feedback≠ResultFeedback\neq Result

结果描述实际发生了什么,反馈描述实际结果与预期目标之间的关系和差异。

因此可以建立完整边界:

Capability≠Method≠Execution≠Result≠Feedback\boxed{ Capability \neq Method \neq Execution \neq Result \neq Feedback }


1.51 执行理论的核心模型

执行理论最终可以压缩为:

Method→Instantiation→Binding→Condition→Execution→Operation→Result→Validation\boxed{ Method \rightarrow Instantiation \rightarrow Binding \rightarrow Condition \rightarrow Execution \rightarrow Operation \rightarrow Result \rightarrow Validation }

如果进入现实世界:

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

如果产生新的学习:

Feedback→Learning→Update→NewMethod→ReExecution\boxed{ Feedback \rightarrow Learning \rightarrow Update \rightarrow NewMethod \rightarrow ReExecution }

因此,执行不是结构智能的终点。

它是:

MethodMethod

进入现实过程的开始,也是:

ResultResult

产生:

FeedbackFeedback

并进一步推动:

LearningLearning

和:

EvolutionEvolution

的重要环节。


1.52 本章结论

执行理论研究的核心问题,是解决:

方法如何从抽象的解决结构转化为当前具体对象、当前具体条件和当前具体参数下真实运行的过程。

方法形成以后,并不能直接等同于执行。

必须经过:

Method→MethodInstantiationMethod \rightarrow MethodInstantiation

然后建立:

ObjectBindingObjectBinding ParameterBindingParameterBinding ConditionCheckConditionCheck ConstraintCheckConstraintCheck

再进入:

ExecutionExecution

执行过程中按照方法规定的:

SequenceSequence BranchBranch LoopLoop SubMethodSubMethod CapabilityCallCapabilityCall

以及:

OperationOperation

运行。

最终:

Execution→ResultExecution \rightarrow Result

结果经过:

ValidationValidation

判断是否达到:

GoalGoal

如果执行作用于现实世界,则进一步:

Execution→Action→WorldChangeExecution \rightarrow Action \rightarrow WorldChange

世界变化产生:

FeedbackFeedback

反馈又进入:

ReCognitionReCognition ReDecisionReDecision MethodCorrectionMethodCorrection

以及:

LearningLearning

从而形成:

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 }

因此,在WSaiOS-SI结构智能理论中:

执行是连接方法结构与现实结果的中间结构,是将抽象方法通过对象绑定、参数绑定、条件检查、规则调用和具体运算转化为实际运行过程的机制。

最终形成:

方法→方法实例化→对象绑定→参数绑定→条件检查→约束检查→执行→运算→结果→验证→行动→世界变化→反馈→再认知\boxed{ 方法 \rightarrow 方法实例化 \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小时技术值守