04元序规则

元序 WorldScript 语言规则手册

版本

WorldScript Language Specification v1.0
定位

元序是一门以世界系统规则为底层逻辑的声明式因果语种，不以顺序执行为基础，而以状态连续、因果涌现、尺度嵌套、容错存续、无间断自演化为核心公理。
本手册性质

元序的正式语言规则定义，涵盖词法、语法、语义、运行时机制与标准库。

第一章总则

1.1 设计公理（不可违背的语言基石）

元序的所有语法与语义规则均派生自以下五大公理，任何语言特性不得与之冲突：

编号	公理	核心约束
A1	容错存续公理	语言中不存在 Error/Exception 概念，只有 Deviation（偏差）；局部偏差不中断全局运行
A2	因果涌现公理	执行流不由语句顺序决定，而由因果条件的满足度与权重决定；多因叠加自动加权
A3	尺度嵌套公理	语言原生支持微观 — 中观 — 宏观三级域，域间双向自动耦合，无需手动传参
A4	无间断自演化公理	规则、权重、阈值可在线热修改，系统永不停止；支持规则自迭代
A5	状态连续公理	以连续量为一等公民（归一化到[0,1]），支持量纲标注与自动归一化；跨量纲运算需显式声明，不静默混合

1.2 语言范式

范式: 声明式因果语言（Declarative Causal Language）
执行模型: 并行因果匹配 + 涌现执行 + Tick 循环
类型系统: 带量纲的连续量系统（Dimensioned Continuous Quantities）。所有运行时值归一化到[0,1]，字段可声明量纲（如温度、速度、概率），跨量纲运算默认报错，可显式声明融合关系
作用域: 层级域（Scale Domain），非传统词法作用域
错误处理: 偏差流（Deviation Flow），非异常捕获
迭代模型: 在线自演化（Online Evolution），非版本发布

1.3 程序结构

一个元序程序由零或多个以下顶层声明组成，声明之间无顺序依赖：

\<program> ::= { \<state\_decl> | \<when\_decl> | \<track\_decl> | \<link\_decl> | \<evolve\_decl> }\*

元序程序没有 main 函数，没有入口点。程序加载后，运行时自动进入 Tick 循环，所有声明并行生效。

第二章词法规则

2.1 字符集

源文件采用 UTF-8 编码
标识符与关键字可使用 中文、英文、数字、下划线
元序鼓励使用自然语言命名（如 城市交通、森林火险），不强制英文
换行符：\n 或 \r\n，语义等价

2.2 注释

注释类型	语法	说明
单行注释	`// 注释内容`	从 `//` 到行尾
块注释	`/* 注释内容 */`	可跨行，不可嵌套

注释不参与编译与运行，仅用于文档说明。

2.3 标识符

\<identifier> ::= \<id\_start> { \<id\_continue> }\*

\<id\_start>   ::= <中文> | <英文字母> | \_

\<id\_continue> ::= \<id\_start> | <数字>

规则：

标识符区分中英文，但不区分大小写（英文部分）
标识符可包含中文词组，如 综合干燥度、全域拥堵指数
保留字不可用作标识符（见 2.5）
标识符长度上限：64 个字符

合法示例：

温度

city\_traffic

\_内部状态

森林火险等级

user\_23

非法示例：

2温度       // 不能以数字开头

when       // 保留字

温度@等级   // 含特殊字符

2.4 字面量

元序没有传统的 int/float/bool/str 离散类型。所有运行时值均为归一化到[0,1]的连续标量，但字段可携带量纲标注（如摄氏度、km/h、概率），用于静态检查和自动归一化。文本标签仅用于元数据，不参与连续运算。

字面量	语法	说明
数值	`[0-9]+(\.[0-9]+)?`	连续标量，无整数 / 浮点数区分
百分比	`[0-9]+(\.[0-9]+)?%`	数值的语义糖，等价于除以 100
区间	`[数值, 数值]`	连续区间，表示状态的可能范围
向量	`(数值, 数值, ...)`	多维连续状态投影
文本标签	`"文本内容"`	仅用于偏差分类、经验标签等元数据，不参与连续运算

示例：

0.85           // 连续标量

75%            // 等价于 0.75

\[0.3, 0.7]     // 连续区间

(25.5, 60, 0.8) // 三维状态投影

"干旱胁迫"     // 文本标签

2.5 保留字

以下为元序全部保留字，不可用作标识符：

类别	保留字
声明关键字	`State`, `When`, `Track`, `Link`, `Evolve`
因果操作	`涌现`, `延迟→`, `反馈→`, `持续`, `聚合→`, `约束→`
逻辑连接	`&`, `或`, `非`, `且`
比较操作	`>`, `<`, `>=`, `<=`, `==`, `!=`, `在`, `不在`
偏差关键字	`偏差`, `收敛`, `扩散半径`, `优先级`
演化关键字	`迭代`, `修正`, `沉淀`, `经验库`
域关键字	`微域`, `中域`, `宏域`, `域`
其他	`当`, `则`, `若`, `否则`（语义糖，映射到 When）

注：中文保留字与英文保留字等价，可混用。如

When

与

当

完全等价。

第三章状态场规则（State）

3.1 状态场声明

状态场是元序唯一的数据形态，取代传统语言的所有变量与类型。

\<state\_decl> ::= "State" \<identifier> "\[" \<field\_list> "]" \["=" \<state\_expr>]

\<field\_list> ::= \<identifier> { "," \<identifier> }\*

语义：声明一个命名的连续状态集合，包含若干状态维度。每个维度都是一个连续变化的标量，取值范围隐含为 [0, 1]（归一化连续谱），但可通过语义标注扩展。

示例：

State 城市交通 \[拥堵指数, 平均车速, 车流密度, 公交负载]

State 林区环境 \[温度, 湿度, 风速, 降水强度, 光照]

3.2 状态维度的访问

\<state\_access> ::= \<state\_identifier> "." \<field\_identifier>

示例：

城市交通.拥堵指数

林区环境.温度

3.3 状态场初始化与连续融合

状态场可通过 连续融合 从其他状态派生，无需手动编写计算公式。运行时根据维度间的语义关系自动建立连续映射。

\<state\_expr> ::= "连续融合" "(" \<state\_access> { "," \<state\_access> }\* ")"

&#x20;             \|  \<numeric\_literal>

&#x20;             \|  \<state\_access>

规则：

连续融合 接受多个状态维度，输出一个连续标量
融合权重由运行时根据语义相关性自动分配，可通过 Evolve 迭代修正
融合结果始终是连续的，不存在阶跃

示例：

State 综合干燥度 = 连续融合(林区环境.温度↑, 林区环境.湿度↓, 林区环境.风速↑, 林区环境.降水强度↓)

上式中 ↑ 和 ↓ 是方向标注：

↑ 表示该维度上升时融合结果上升（正相关）
↓ 表示该维度上升时融合结果下降（负相关）

方向标注语法：

\<direction\_annotated> ::= \<state\_access> ("↑" | "↓")?

3.4 状态场的连续性约束

无离散跳变：任何状态维度在相邻 Tick 间的变化量不得超过 Δmax（默认 0.3，可配置）。若外部输入导致跳变，运行时自动平滑为连续过渡。
量纲检查：同量纲的状态维度可自由运算；跨量纲运算（如 温度 + 满意度）默认报错，需通过 连续融合() 或显式映射声明融合关系。这防止无意义的数值混合，同时保留连续状态的灵活性。
全域渗透：任意状态场的变化可通过 Link 或因果规则影响任意其他状态场，不存在访问隔离。

3.4.1 量纲系统规则

量纲是元序的轻量级类型系统，用于防止无意义的数值混合，同时保留连续状态的灵活性。

规则	说明	示例
同量纲可运算	相同量纲的字段可直接比较、加减	`温度:摄氏度 < 目标温度:摄氏度` ✅
跨量纲需声明	不同量纲的字段运算需通过 `连续融合()` 或显式映射	`连续融合(温度↑, 湿度↓)` ✅
跨量纲默认报错	未声明融合关系的跨量纲运算产生量纲偏差	`温度 + 满意度` ❌ → 量纲偏差
无量纲可通用	标注为 `无量纲` 的字段可与任意量纲运算	`权重:无量纲 × 温度:摄氏度` ✅
概率量纲	标注为 `概率` 的字段取值被约束在[0,1]，且有特殊语义	`降水概率:概率`
自动归一化	带量纲的原始值（如 25℃）自动归一化到[0,1]	`归一化(温度, -20, 50)`

量纲偏差：跨量纲运算未声明融合关系时，不中断程序，而是产生 量纲偏差 事件，记录违规运算并按默认策略（取第一个操作数的量纲）继续执行。这符合容错存续公理，但在 --strict 模式下可升级为错误。

设计说明：元序不采用传统的 int/float/str 类型系统，因为现实世界的状态本质是连续的。但完全无类型会导致 温度 + 满意度 这种无意义运算静默通过。量纲系统是两者的平衡：运行时值连续，但语义上有量纲边界。

3.5 状态场的域归属

每个状态场声明时可指定所属层级域，不指定时默认为当前上下文域。

\<state\_decl> ::= \["微域" | "中域" | "宏域"] "State" \<identifier> "\[" \<field\_list> "]"
\<field\_list> ::= \<field> ("," \<field>)*
\<field> ::= \<identifier> [":" \<dimension>] ["=" \<number>]
\<dimension> ::= \<identifier>   // 量纲名，如 摄氏度、km/h、概率、无量纲

字段支持可选的量纲标注（字段:量纲）和初始值（=数值）。量纲用于跨字段运算的静态检查。

示例：

微域 State 单车 [车速:km/h=0.4, 位置:无量纲, 耐心值:概率=0.8]
中域 State 环境 [温度:摄氏度=0.3, 目标温度:摄氏度=0.7]

中域 State 路段 \[车流密度, 平均车速, 排队长度]

宏域 State 城市 \[拥堵指数, 空气质量, 满意度]

域归属决定了该状态场在层级耦合中的默认方向（见第六章）。

第四章因果规则（When）

4.1 因果规则声明

When 是元序的核心执行单元，取代传统语言的 if/else/switch/for/while/function。

\<when\_decl> ::= "When" \<condition\_expr> ":"

&#x20;               \<newline>

&#x20;               \<indent> \<action\_block>

\<action\_block> ::= { \<action> }+

\<action> ::= \<emerge\_action> | \<state\_modify> | \<delay\_action> | \<feedback\_action> | \<deviation\_record>

语义：当条件表达式的因果强度超过涌现阈值时，执行动作块。所有 When 规则在每个 Tick 并行评估，无先后顺序。

4.2 条件表达式

\<condition\_expr> ::= \<condition> { ("&" | "且" | "或") \<condition> }\*

\<condition> ::= \<state\_access> \<comparator> \<value\_expr>

&#x20;            \| \<state\_access> "在" \<interval>

&#x20;            \| "非" \<condition>

&#x20;            \| "(" \<condition\_expr> ")"

\<comparator> ::= ">" | "<" | ">=" | "<=" | "==" | "!="

\<value\_expr> ::= \<numeric\_literal> | \<state\_access> | \<arithmetic\_expr>

逻辑连接符语义：

& / 且：逻辑与，但在元序中是因果叠加—— 多条件同时满足时，因果强度为各条件强度的加权和，而非简单布尔与
或：逻辑或，因果强度取各条件中的最大值
非：逻辑非，因果强度取反

关键区别：传统语言中 A & B 是布尔运算（真 / 假），元序中是因果强度叠加。每个条件满足度是 0~1 的连续值，叠加后得到总因果强度。

示例：

When 温度 > 30 & 湿度 < 40% & 风速 > 15:

&#x20;   涌现 高温干燥预警

4.3 因果强度计算

每个条件的满足度（Satisfaction）计算：

对于条件 状态 > 阈值:

&#x20;   满足度 = clamp((状态 - 阈值) / (参考范围), 0, 1)

对于条件 状态 < 阈值:

&#x20;   满足度 = clamp((阈值 - 状态) / (参考范围), 0, 1)

对于多条件叠加 (A & B & C):

&#x20;   因果强度 = w\_A × sat(A) + w\_B × sat(B) + w\_C × sat(C)

&#x20;   其中 w\_A + w\_B + w\_C = 1，权重由运行时自动分配或 Evolve 迭代

涌现阈值：默认 0.6，可全局配置或单规则指定。因果强度 ≥ 阈值时，规则涌现执行。

4.4 涌现动作（emerge）

\<emerge\_action> ::= "涌现" \<identifier> \["(" \<param\_list> ")"]

语义：生成一个命名的涌现事件。涌现事件是系统中的一等对象，可被其他规则引用、被偏差引擎追踪、被演化引擎学习。

示例：

When 路段.车流密度 > 0.85 & 路段.平均车速 < 15:

&#x20;   涌现 路段拥堵事件(路段ID, 拥堵等级=高)

4.5 状态修改动作

\<state\_modify> ::= \<state\_access> \<modifier> \<value\_expr>

\<modifier> ::= "提升" | "降低" | "设置为" | "×" | "+" | "-"

规则：

状态修改是连续渐变的，不在单个 Tick 内完成，而是在后续若干 Tick 内平滑过渡
修改量受 Δmax 约束，防止状态跳变
提升/降低 为相对修改，设置为 为绝对目标值

示例：

&#x20;   提升 路段.信号灯绿灯时长 +20%

&#x20;   降低 核心区.准入权重 ×0.7

&#x20;   设置为 系统.预警等级 = 橙色

4.6 延迟因果动作

\<delay\_action> ::= "延迟→" \<state\_modify> "(" "延迟" "=" \<delay\_spec> \[, "强度" "=" \<numeric\_literal>] ")"

\<delay\_spec> ::= \<numeric\_literal> \["\~" \<numeric\_literal>] "Tick"

语义：在指定延迟后生效的因果动作。延迟可以是确定值或区间（随机分布）。这是元序处理长因果链的核心机制。

规则：

延迟动作排入运行时的时间轴队列，到期自动生效
延迟期间可被其他规则修改或取消（因果可塑）
强度参数控制该动作的因果权重，默认 1.0

示例：

When 政策.利率下调 > 0.25%:

&#x20;   涌现 降息事件

&#x20;   延迟→ 金融.融资成本降低 (延迟=1\~2Tick, 强度=0.8)

&#x20;   延迟→ 企业.投资意愿上升 (延迟=4\~6Tick, 强度=0.5)

&#x20;   延迟→ 就业.失业率下降 (延迟=8\~12Tick, 强度=0.3)

4.7 反馈动作

\<feedback\_action> ::= "反馈→" \<state\_modify>

语义：将动作效果反馈回条件本身或相关状态，形成反馈回路。运行时自动检测正反馈 / 负反馈，并在系统不稳定时启动收敛。

示例：

When 消费.意愿 > 0.7 & 企业.利润预期 > 0.6:

&#x20;   涌现 经济正向循环

&#x20;   反馈→ 企业.投资意愿 +0.1

&#x20;   反馈→ 社会.信心指数 +0.08

4.8 偏差记录动作

\<deviation\_record> ::= "偏差" "\[" \<identifier> "]" \<deviation\_attr>\*

\<deviation\_attr> ::= "类型" "=" \<text\_literal>

&#x20;                  \| "等级" "=" ("低" | "中" | "高" | "最高")

&#x20;                  \| "扩散半径" "=" \<numeric\_literal>

&#x20;                  \| "优先级" "=" ("低" | "中" | "高" | "最高")

语义：记录一个系统偏差。偏差不是错误，不中断运行，而是进入偏差流被观测、收敛、学习。

示例：

&#x20;   偏差\[拥堵偏差] 类型="交通拥堵", 等级=中, 扩散半径=2, 优先级=高

4.9 因果规则的并行与冲突

同一 Tick 内多个 When 规则可同时涌现
多个规则修改同一状态时，修改量叠加（加权平均或求和，由运行时根据因果强度决定）
若两个规则的修改方向相反（一个提升、一个降低），运行时计算净效果，不报错、不中断
因果强度高的规则在叠加中占更大权重

第五章趋势跟踪规则（Track）

5.1 趋势跟踪声明

\<track\_decl> ::= "Track" \<state\_access> "持续" \<numeric\_literal> "个Tick" ":"

&#x20;                \<newline>

&#x20;                \<indent> \<track\_action\_block>

语义：对指定状态维度进行时间窗口内的连续演化分析，包括趋势拟合、速率计算、加速度计算、拐点识别、未来推演。

5.2 趋势分析动作

动作	语法	语义
拟合曲线	`拟合 <identifier>`	对时间窗口内的数据拟合连续曲线
计算速率	`计算 <identifier>变化速率`	计算一阶导数（变化速度）
计算加速度	`计算 <identifier>加速度`	计算二阶导数（变化趋势的变化）
识别拐点	`识别 <identifier>拐点`	识别趋势方向改变的临界点
推演未来	`推演 <numeric_literal>个Tick走势`	基于当前趋势外推未来状态
预测临界	`若预测 <condition>: <action>`	当预测将满足某条件时提前执行

示例：

Track 综合干燥度 持续12个Tick:

&#x20;   拟合 干燥度变化曲线

&#x20;   计算 干燥度变化速率

&#x20;   计算 干燥度加速度

&#x20;   若预测 干燥度 > 0.75:

&#x20;       提前2个Tick升级响应等级

&#x20;       标记 "火险快速攀升期"

5.3 趋势跟踪的运行时机制

Track 规则维护一个滑动时间窗口，每个 Tick 移入新数据、移出旧数据
趋势分析在每个 Tick 末尾执行，结果写入状态场的趋势投影
趋势投影可被 When 规则引用（作为条件），实现「预判式因果」
趋势预测的置信度随推演距离衰减，运行时自动标注

5.4 趋势投影的访问

\<trend\_projection> ::= \<state\_access> ".趋势" \["." \<trend\_attr>]

\<trend\_attr> ::= "速率" | "加速度" | "预测值" | "置信度" | "拐点"

示例：

When 干燥度.趋势.加速度 > 0.01:

&#x20;   涌现 干燥加速预警

第六章层级联动规则（Link）

6.1 层级联动声明

\<link\_decl> ::= "Link" \<link\_side> \<link\_direction> \<link\_side>

\<link\_side> ::= \<state\_access> | \<domain\_ref>

\<link\_direction> ::= "聚合→" | "约束→" | "↔"

\<domain\_ref> ::= ("微域" | "中域" | "宏域") \["." \<identifier>]

6.2 聚合方向（微→中→宏）

\<link\_aggregate> ::= \<micro\_state> "聚合→" \<macro\_state>

语义：微观状态自动向上聚合为中观 / 宏观状态。聚合方式由运行时根据语义自动选择（求和、平均、加权、密度估计等）。

规则：

聚合是自动连续的，每个 Tick 自动更新，无需手动调用
聚合权重可通过 Evolve 迭代
多个微观状态可聚合到同一个宏观状态

示例：

Link 单车.车速 聚合→ 路段.平均车速

Link 路段.排队长度 聚合→ 城市.拥堵指数

6.3 约束方向（宏→中→微）

\<link\_constraint> ::= \<macro\_state> "约束→" \<micro\_state>

语义：宏观状态自动向下约束微观状态的行为空间。约束不是强制赋值，而是改变微观状态的演化倾向。

规则：

约束是软约束，微观状态可在约束范围内自主演化
约束强度与宏观状态的因果强度成正比
约束可被微观层面的强因果突破（如紧急事件）

示例：

Link 城市.拥堵指数 约束→ 单车.路径偏好

Link 宏观.政策导向 约束→ 企业.投资决策

6.4 双向耦合

\<link\_bidirectional> ::= \<state\_a> "↔" \<state\_b>

语义：同时建立聚合与约束，形成双向耦合。等价于同时声明两条单向 Link。

示例：

Link 个体.出行行为 ↔ 城市.交通态势

6.5 层级域的三级定义

域	定义	典型对象
微域	系统最小可分辨单元	个体、车辆、单点、细胞
中域	微域的聚合体，具有局部结构	路段、片区、组织、群体
宏域	系统全局，最高层级	城市、生态、社会、经济体

规则：

一个状态场只能属于一个域（声明时指定，默认中域）
聚合只能从低级域指向高级域（微→中→宏），不可越级聚合（微→宏需经过中域）
约束只能从高级域指向低级域（宏→中→微），不可越级约束
跨域状态访问无需特殊语法，运行时自动解析层级路径

第七章自演化规则（Evolve）

7.1 自演化声明

\<evolve\_decl> ::= "Evolve" \<evolve\_target> \<evolve\_schedule> ":"

&#x20;                 \<newline>

&#x20;                 \<indent> \<evolve\_action\_block>

\<evolve\_target> ::= \<identifier>  // 要演化的规则/参数/模型名

\<evolve\_schedule> ::= "每" \<numeric\_literal> "个Tick迭代"

&#x20;                    \| "持续迭代"

&#x20;                    \| "当" \<condition\_expr> "时迭代"

语义：声明一个在线自演化机制。系统在运行过程中根据历史数据与偏差反馈，自动修改规则权重、阈值、参数，无需停机、无需重新编译。

7.2 演化动作

动作	语法	语义
修正权重	`修正 <target>权重 ±<value>`	根据偏差反馈调整因果权重
修正阈值	`修正 <target>阈值 ±<value>`	调整涌现阈值
修正系数	`修正 <target>系数 ±<value>`	调整融合 / 聚合 / 延迟系数
沉淀经验	`沉淀 <经验描述> 到经验库`	将有效策略存入经验库
新增规则	`新增规则 <when_decl_snippet>`	基于经验生成新因果规则
淘汰规则	`淘汰 <规则名>`	移除长期无效的规则
适配场景	`适配 <场景描述>`	根据场景切换参数集

示例：

Evolve 信号灯配时规则 每10个Tick迭代:

&#x20;   根据历史拥堵偏差修正各路段绿灯权重

&#x20;   适配 工作日/节假日/天气变化

&#x20;   沉淀高效配时方案到经验库

Evolve 火险响应阈值 持续迭代:

&#x20;   当 误报率 > 0.1: 修正阈值 +0.02

&#x20;   当 漏报率 > 0.05: 修正阈值 -0.02

&#x20;   沉淀 不同季节的最优阈值集

7.3 演化的约束与安全

演化边界：每次演化的参数修改量不得超过 εmax（默认 0.05），防止剧烈震荡
演化验证：新参数需在「影子模式」下运行至少 1 个 Tick，验证不导致系统偏差扩大后才正式生效
演化回滚：若演化后系统偏差率上升超过 20%，自动回滚到上一稳定参数集
演化审计：所有演化操作记录到演化日志，可追溯、可回放
不可演化公理：五大公理（A1-A5）本身不可被演化修改，它们是元序的元规则
MVP 阶段限制（v1.1 新增）：
- 只允许 修正权重、修正阈值、修正系数 三类参数调优动作
- 新增规则、淘汰规则 在 MVP 阶段禁用（M3 阶段开放，需额外安全验证）
- 偏差持续 N 个 Tick（默认15）不收敛时触发告警，告警包含偏差来源规则
- 存在告警偏差时，暂停演化并自动回滚最近一次演化操作
- 只有显式注册在「可演化参数注册表」中的参数可被演化修改

设计说明：元宝和 Trae 的评审均指出 Evolve 是最危险的部分——「无 Error + 自演化 + 自动收敛」叠加会导致错误被静默固化。MVP 阶段的安全限制确保系统在可控范围内演化，审计日志和偏差告警是永久保留的安全基础设施。

7.4 经验库

经验库是元序系统的长期记忆，存储经过验证的有效策略。

<经验条目> ::= {

&#x20;   场景描述: \<text>,

&#x20;   触发条件: \<condition\_expr>,

&#x20;   执行策略: \<action\_block>,

&#x20;   效果评分: \<numeric>,

&#x20;   使用次数: \<integer>,

&#x20;   最后验证: \<tick>

}

经验库条目可被 When 规则直接引用：使用经验 "<经验名>"
经验库条目按效果评分排序，高评分经验优先被演化引擎采用
经验库可跨程序复用（导入外部经验库文件）

第八章偏差流规则

8.1 偏差的定义

偏差（Deviation）是元序中唯一的「异常」概念，但它不是错误，而是系统状态偏离预期的连续度量。

<偏差> ::= {

&#x20;   ID: \<identifier>,

&#x20;   类型: \<text>,

&#x20;   源: \<state\_access>,

&#x20;   等级: 低|中|高|最高,

&#x20;   强度: \<numeric 0\~1>,

&#x20;   扩散半径: \<numeric>,

&#x20;   优先级: 低|中|高|最高,

&#x20;   状态: 观测中|收敛中|已收敛|已消除,

&#x20;   溯源: <因果链>,

&#x20;   产生Tick: \<integer>,

&#x20;   收敛Tick: \<integer>?,

}

8.2 偏差的生命周期

产生 → 观测 → 扩散 → 收敛 → 消除

&#x20; │      │      │      │      │

&#x20; │      │      │      │      └→ 偏差强度降至0，记录到演化库

&#x20; │      │      │      └→ 收敛引擎启动修复策略

&#x20; │      │      └→ 偏差影响沿因果链扩散

&#x20; │      └→ 偏差引擎持续观测强度变化

&#x20; └→ 由 When 规则或运行时自动检测产生

8.3 偏差的自动检测

运行时在每个 Tick 自动检测以下偏差：

偏差类型	检测条件
状态跳变	单 Tick 状态变化 > Δmax
因果失效	When 规则条件满足但未产生预期效果
趋势异常	Track 检测到加速度超过安全阈值
层级失配	聚合结果与宏观观测偏差 > 15%
演化震荡	参数连续 3 次演化方向反转
系统临界	稳定性指数 < 0.3

8.4 偏差收敛策略

偏差引擎根据偏差类型与等级自动选择收敛策略：

等级	收敛策略
低	记录观测，不干预，等待自然恢复
中	启动局部收敛：调整相关状态的修改方向
高	启动全局收敛：临时降低相关规则的因果权重
最高	启动系统保护：切换到保守模式，冻结非关键演化

8.5 偏差与容错的核心规则

偏差不中断：任何等级的偏差都不会导致程序终止或 Tick 循环停止
偏差可叠加：多个偏差同时存在时，收敛引擎按优先级依次处理
偏差可学习：已收敛的偏差自动成为演化引擎的训练数据
无除零 / 无空引用：状态场永远有值（默认 0.5 中性态），不存在空状态
偏差透明：所有偏差可通过 偏差流 状态场实时查询

第九章运算符与表达式

9.1 算术运算符

运算符	语法	语义	备注
加	`+`	连续值相加	结果自动归一化
减	`-`	连续值相减
乘	`×` 或 `*`	连续值相乘
除	`÷` 或 `/`	连续值相除	除数趋近 0 时结果趋近无穷大，但不报错
幂	`^`	连续值幂运算

注：元序中算术运算的结果始终被约束在连续状态场的有效范围内，溢出自动饱和（clamp），不产生无穷大或 NaN。

9.2 比较运算符

运算符	语法	返回
大于	`>`	满足度（0~1 连续值）
小于	`<`	满足度
大于等于	`>=`	满足度
小于等于	`<=`	满足度
等于	`==`	接近度（差值的倒数，连续）
不等于	`!=`	1 - 接近度
在区间内	`在 [a, b]`	区间隶属度

关键：比较运算不返回布尔值（true/false），而返回 满足度（0~1 的连续值）。这是元序状态连续公理的直接体现。

9.3 逻辑运算符

运算符	语法	语义
与	`&` 或 `且`	因果叠加（加权和）
或	`或`	因果取大（max）
非	`非`	因果取反（1 - x）

9.4 方向标注

标注	语义
`↑`	正相关（该维度上升时，融合 / 聚合结果上升）
`↓`	负相关（该维度上升时，融合 / 聚合结果下降）
`→`	因果方向（从因到果）
`↔`	双向耦合

9.5 内置函数

函数	语法	语义
连续融合	`连续融合(a↑, b↓, ...)`	多维度连续融合为单一状态
归一化	`归一化(x, min, max)`	将值归一化到 [0,1]
平滑	`平滑(x, 窗口大小)`	对状态进行滑动平均平滑
饱和	`饱和(x, min, max)`	约束值在区间内
距离	`距离(a, b)`	两状态间的连续距离
相似度	`相似度(a, b)`	两状态的相似度（0~1）
经验查询	`使用经验("名称")`	从经验库加载策略
偏差查询	`偏差流.查询(类型, 等级)`	查询当前活跃偏差

第十章运行时语义

10.1 Tick 循环

元序程序的执行以 Tick 为基本单位。每个 Tick 的完整流程：

┌──────────────────────────────────────────────────────────┐

│  Tick N                                                   │

│                                                            │

│  阶段1: 状态更新                                           │

│    - 处理外部输入（传感器、用户事件、API调用）              │

│    - 应用上一 Tick 的状态修改（平滑过渡）                   │

│    - 到期的延迟因果动作生效                                 │

│                                                            │

│  阶段2: 因果匹配                                           │

│    - 并行评估所有 When 规则的条件满足度                     │

│    - 计算每条规则的因果强度                                 │

│    - 筛选因果强度 ≥ 阈值的规则                              │

│                                                            │

│  阶段3: 涌现执行                                           │

│    - 按因果强度排序                                        │

│    - 执行涌现动作、状态修改、反馈动作                       │

│    - 叠加冲突修改（加权）                                   │

│    - 记录偏差                                              │

│                                                            │

│  阶段4: 层级耦合                                           │

│    - 微→中→宏 聚合更新                                     │

│    - 宏→中→微 约束下发                                     │

│    - 检测层级失配偏差                                      │

│                                                            │

│  阶段5: 趋势分析                                           │

│    - 所有 Track 规则更新滑动窗口                           │

│    - 计算趋势投影（速率、加速度、预测值）                   │

│    - 触发预判式因果                                        │

│                                                            │

│  阶段6: 偏差收敛                                           │

│    - 观测所有活跃偏差的强度变化                             │

│    - 启动/调整收敛策略                                     │

│    - 消除已收敛偏差，记录到演化库                           │

│                                                            │

│  阶段7: 演化                                               │

│    - 检查 Evolve 规则的调度条件                            │

│    - 在影子模式下验证参数修改                               │

│    - 应用通过验证的演化                                    │

│    - 回滚导致偏差扩大的演化                                │

│                                                            │

│  阶段8: 输出与持久化                                       │

│    - 输出系统快照（可选）                                  │

│    - 持久化状态场与经验库（可选）                           │

│                                                            │

│  → 进入 Tick N+1（永不停止，除非外部终止）                  │

└──────────────────────────────────────────────────────────┘

10.2 因果权重的自动分配

当一条 When 规则有多个条件时，运行时按以下原则分配权重：

初始权重：平均分配（n 个条件各 1/n）
语义相关性：与涌现事件语义更相关的条件获得更高权重
历史有效性：过去预测准确率高的条件获得更高权重
Evolve 修正：演化引擎可根据偏差反馈持续调整权重
权重归一化：所有权重之和始终为 1

10.3 优先级与冲突消解

当多个规则同时修改同一状态时：

净修改量 = Σ (规则i.因果强度 × 规则i.修改量) / Σ(规则i.因果强度)

即加权平均，因果强度高的规则话语权更大。

特殊情况：

若存在 优先级=最高 的偏差相关规则，该规则的修改量直接覆盖其他规则
若修改方向完全相反且强度接近，运行时标记为「因果对抗」，降低双方修改量的 50%，并记录偏差

10.4 系统终止

元序程序设计为永不停止。仅在以下情况终止：

外部信号（用户终止、系统关闭）
演化引擎检测到系统进入不可逆的崩溃态（稳定性指数持续 50 Tick < 0.1），此时输出最终快照后终止 —— 这是元序唯一的「停机」场景，且属于系统自我保护而非错误

10.5 时间模型

元序的时间是逻辑时间（Tick），不直接绑定物理时间
可配置 Tick 与物理时间的映射（如 1 Tick = 5 分钟 / 1 小时 / 1 天）
延迟因果中的 Tick 均指逻辑 Tick
趋势跟踪的窗口也是逻辑 Tick

第十一章完整语法范式（BNF）

\<program>           ::= { \<declaration> }\*

\<declaration>       ::= \<state\_decl> | \<when\_decl> | \<track\_decl> | \<link\_decl> | \<evolve\_decl>

\<!-- 状态场 -->

\<state\_decl>        ::= \[\<domain\_prefix>] "State" \<identifier> "\[" \<field\_list> "]" \["=" \<state\_expr>]

\<domain\_prefix>     ::= "微域" | "中域" | "宏域"

\<field\_list>        ::= \<identifier> { "," \<identifier> }\*

\<state\_expr>        ::= "连续融合" "(" \<annotated\_state> { "," \<annotated\_state> }\* ")"

&#x20;                     \| \<numeric\_literal> | \<state\_access>

\<annotated\_state>   ::= \<state\_access> \["↑" | "↓"]

\<!-- 因果规则 -->

\<when\_decl>         ::= "When" \<condition\_expr> ":" \<newline> \<indent> \<action\_block>

\<condition\_expr>    ::= \<condition> { ("&" | "且" | "或") \<condition> }\*

\<condition>         ::= \<state\_access> \<comparator> \<value\_expr>

&#x20;                     \| \<state\_access> "在" \<interval>

&#x20;                     \| "非" \<condition> | "(" \<condition\_expr> ")"

\<comparator>        ::= ">" | "<" | ">=" | "<=" | "==" | "!="

\<action\_block>      ::= { \<action> }+

\<action>            ::= \<emerge\_action> | \<state\_modify> | \<delay\_action>

&#x20;                     \| \<feedback\_action> | \<deviation\_record> | \<use\_experience>

\<emerge\_action>     ::= "涌现" \<identifier> \["(" \<param\_list> ")"]

\<state\_modify>      ::= \<state\_access> \<modifier> \<value\_expr>

\<modifier>          ::= "提升" | "降低" | "设置为" | "×" | "+" | "-"

\<delay\_action>      ::= "延迟→" \<state\_modify> "(" "延迟" "=" \<delay\_spec> \[, "强度" "=" \<numeric>] ")"

\<delay\_spec>        ::= \<numeric> \["\~" \<numeric>] "Tick"

\<feedback\_action>   ::= "反馈→" \<state\_modify>

\<deviation\_record>  ::= "偏差" "\[" \<identifier> "]" { \<deviation\_attr> }\*

\<deviation\_attr>    ::= "类型" "=" \<text> | "等级" "=" \<level> | "扩散半径" "=" \<numeric> | "优先级" "=" \<level>

\<use\_experience>    ::= "使用经验" "(" \<text> ")"

\<!-- 趋势跟踪 -->

\<track\_decl>        ::= "Track" \<state\_access> "持续" \<numeric> "个Tick" ":" \<newline> \<indent> \<track\_block>

\<track\_block>       ::= { \<track\_action> }+

\<track\_action>      ::= "拟合" \<identifier> | "计算" \<identifier> ("变化速率" | "加速度")

&#x20;                     \| "识别" \<identifier> "拐点" | "推演" \<numeric> "个Tick走势"

&#x20;                     \| "若预测" \<condition\_expr> ":" \<action\_block>

\<!-- 层级联动 -->

\<link\_decl>         ::= "Link" \<link\_side> \<link\_direction> \<link\_side>

\<link\_side>         ::= \<state\_access> | \<domain\_ref>

\<link\_direction>    ::= "聚合→" | "约束→" | "↔"

\<!-- 自演化 -->

\<evolve\_decl>       ::= "Evolve" \<identifier> \<evolve\_schedule> ":" \<newline> \<indent> \<evolve\_block>

\<evolve\_schedule>   ::= "每" \<numeric> "个Tick迭代" | "持续迭代" | "当" \<condition\_expr> "时迭代"

\<evolve\_block>      ::= { \<evolve\_action> }+

\<evolve\_action>     ::= "修正" \<target> ("权重" | "阈值" | "系数") ("+" | "-" | "×") \<numeric>

&#x20;                     \| "沉淀" \<text> "到经验库"

&#x20;                     \| "新增规则" \<when\_decl>

&#x20;                     \| "淘汰" \<identifier>

&#x20;                     \| "适配" \<text>

\<!-- 基础 -->

\<state\_access>      ::= \<identifier> "." \<identifier> { "." \<identifier> }\*

\<value\_expr>        ::= \<numeric> | \<state\_access> | \<arithmetic\_expr>

\<arithmetic\_expr>   ::= \<value\_expr> ("+" | "-" | "×" | "÷" | "^") \<value\_expr>

\<numeric>           ::= \[0-9]+ ("." \[0-9]+)? \["%"]

\<interval>          ::= "\[" \<numeric> "," \<numeric> "]"

\<text>              ::= '"' { \<utf8\_char> }\* '"'

\<level>             ::= "低" | "中" | "高" | "最高"

\<identifier>        ::= \<id\_start> { \<id\_continue> }\*

第十二章标准库与内置能力

12.1 内置状态场

状态场	维度	说明
`系统`	稳定性指数，运行 Tick, 偏差总数，演化次数	元序运行时的自描述状态
`偏差流`	活跃偏差数，平均偏差强度，收敛率，最大偏差等级	全局偏差流的聚合视图
`时间`	当前 Tick, 物理时间映射，时间缩放因子	时间状态
`经验库`	条目数，平均效果评分，高频经验 TOP10	经验库状态

12.2 配置参数

元序运行时可通过配置文件或启动参数调整以下全局参数：

参数	默认值	说明
`涌现阈值`	0.6	When 规则触发的最低因果强度
`Δmax`	0.3	单 Tick 最大状态变化量
`εmax`	0.05	单次演化最大参数修改量
`Tick物理映射`	1 秒	1 Tick 对应的物理时间
`收敛灵敏度`	0.5	偏差收敛引擎的干预灵敏度
`演化影子期`	1 Tick	新参数影子验证时长
`崩溃阈值`	0.1	系统稳定性指数低于此值持续 50Tick 则保护性终止

12.3 程序间互操作

导入经验库：导入经验库 "路径/经验库.json"
导出状态快照：运行时可在任意 Tick 导出完整状态场快照
外部输入：通过 外部输入.<名称> 访问传感器 / API / 用户事件数据
外部输出：涌现事件可配置为触发外部 Webhook / 消息通知

第十三章语言边界与禁止事项

13.1 元序不支持的特性

以下特性在元序中不存在，且永远不会被引入（因为违背五大公理）：

禁止特性	原因
整数 / 浮点数 / 布尔 / 字符串等离散类型	违背状态连续公理
if/else/switch 分支语句	违背因果涌现公理（分支是人为切割因果）
for/while 循环	违背因果涌现公理（循环是顺序执行的残留）
函数 / 方法 / 返回值	元序无调用栈，涌现事件取代函数
try/catch/throw 异常	违背容错存续公理（偏差取代异常）
变量赋值（=）	状态场是连续演化的，不可被强制赋值（`设置为`是渐变目标，非瞬时赋值）
goto / 跳转 /break/continue	违背因果涌现公理
类 / 对象 / 继承	元序的组织单元是状态场 + 域，非类
线程 / 进程 / 锁	元序天然并行，由运行时调度，无需手动并发控制
编译 / 链接 / 部署停机	违背无间断自演化公理
null/undefined/None	状态场永远有值，无空状态
除零错误 / 溢出错误	连续运算自动饱和，不产生错误

13.2 元序不适用的场景

元序是为世界系统建模设计的，以下场景更适合传统编程语言：

精确数值计算：如密码学、高精度数学运算（元序的连续状态会损失精度）
硬实时系统：如汽车 ECU、航空电子（元序的 Tick 模型不保证微秒级确定性）
底层系统编程：如操作系统内核、驱动程序（元序不直接操作内存 / 寄存器）
UI 渲染管线：如游戏引擎的每帧渲染（元序的涌现模型不适合逐像素控制）
纯算法题：如排序、搜索（元序的声明式范式反而增加复杂度）

附录 A：元序程序最小示例

// 最小元序程序：一个温度自调节系统

State 环境 \[温度, 目标温度]

State 加热器 \[功率, 状态]

When 环境.温度 < 环境.目标温度:

&#x20;   涌现 加热需求

&#x20;   提升 加热器.功率 +0.1

&#x20;   偏差\[温度偏差] 类型=过冷, 等级=低

When 环境.温度 > 环境.目标温度:

&#x20;   涌现 散热需求

&#x20;   降低 加热器.功率 -0.1

&#x20;   偏差\[温度偏差] 类型=过热, 等级=低

Track 环境.温度 持续6个Tick:

&#x20;   拟合 温度变化曲线

&#x20;   若预测 温度 > 目标温度 + 0.2:

&#x20;       提前降低加热器功率

Evolve 温控规则 每10个Tick迭代:

&#x20;   根据温度偏差修正功率调整步长

&#x20;   沉淀稳定控制参数到经验库

这个 15 行的程序实现了一个带预测、自学习、容错的温度控制系统。
等价的传统语言实现（含 PID 控制、预测算法、异常处理、参数持久化）约需 200+ 行。

附录 B：术语对照表

元序术语	传统语言等价概念	本质区别
状态场 (State)	变量 / 对象 / 结构体	连续量、带量纲、全域渗透
因果规则 (When)	if / 函数 / 事件处理器	并行匹配、因果加权、无返回值
涌现 (Emerge)	函数调用 / 事件触发	多因叠加、强度连续、可观测
趋势跟踪 (Track)	轮询 / 监听器 / 观察者	连续拟合、预判式、加速度感知
层级联动 (Link)	作用域 / 继承 / 消息传递	双向自动耦合、无需手动传参
自演化 (Evolve)	热更新 / 在线学习 / A/B 测试	原生支持、安全验证、经验沉淀
偏差 (Deviation)	异常 / 错误 / 告警	不中断、可收敛、可学习
Tick	帧 / 时钟周期 / 事件循环	因果驱动、非顺序指令
域 (Domain)	命名空间 / 模块 / 作用域	三级嵌套、双向约束、语义层级
经验库	数据库 / 缓存 / 模型文件	效果评分、自动复用、跨程序

文档结束
本规则手册定义了元序 WorldScript v1.1 的全部语言特性。
v1.1 修订：类型系统从「无类型」修正为「带量纲的连续量系统」，State 字段支持量纲标注，新增 3.4.1 量纲系统规则。
元序的定位是面向复杂现实系统的声明式建模与推演 DSL，其设计哲学源于「世界是连续、混沌、嵌套、容错、自演化的」五大公理。

posted @ 2026-09-03 16:22 新哲阅读(3) 评论(0) 收藏举报

刷新页面返回顶部

新哲