@cannbot-plugin/cannbot-harness 0.0.0-stage → 0.1.4

package/assets/ops-direct-invoke/skills/ops-spec-gen/examples/add/spec.yaml

@@ -0,0 +1,161 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+
+# ============================================================
+# add — L0 数学约束 spec
+# 教学点：最简元素级算子 + numpy 广播 + 双输入 dtype promote + 代数性质 invariant
+# ============================================================
+schema_version: 1
+
+op:
+  name: add
+  version: "1.0"
+  description: "Broadcast element-wise addition with numpy broadcasting rules"
+  category: Broadcast
+  paradigms: [Broadcast]
+  lifecycle: stable
+  error_codes:
+    - null_input
+    - shape_mismatch
+  platform_constraints:
+    supported_chips: [Ascend910B]
+    requires_hccl: false
+
+inputs:
+  - name: x
+    description: "公式中的左操作数"
+    role: tensor
+    dtype_set: [float16, float32, bfloat16, int32]
+    rank_range: [0, 8]
+    layout: ND
+    shape:
+      symbolic: ["...a"]
+  - name: y
+    description: "公式中的右操作数；与 x 按 numpy 规则广播"
+    role: tensor
+    dtype_set: [float16, float32, bfloat16, int32]
+    rank_range: [0, 8]
+    layout: ND
+    shape:
+      symbolic: ["...b"]
+
+attributes: []
+
+outputs:
+  - name: z
+    description: "x 与 y 元素级相加；shape 为两侧 broadcast 结果"
+    shape_rule_kind: numpy_expr
+    shape_rule: |
+      z.shape = np.broadcast_shapes(x.shape, y.shape)
+    dtype_rule_kind: numpy_expr
+    dtype_rule: |
+      z.dtype = np.promote_types(x.dtype, y.dtype)
+    layout: ND
+    aliasing: none
+
+shape_constraints:
+  symbols: {}
+  global_constraints:
+    - "rank(broadcast(x, y)) <= 8"
+
+dtype_policy:
+  promotion: numpy_promote
+  supported_combinations:
+    - {inputs: {x: float16, y: float16}, outputs: {z: float16}}
+    - {inputs: {x: float32, y: float32}, outputs: {z: float32}}
+    - {inputs: {x: bfloat16, y: bfloat16}, outputs: {z: bfloat16}}
+    - {inputs: {x: int32, y: int32}, outputs: {z: int32}}
+    - {inputs: {x: float16, y: float32}, outputs: {z: float32}}
+    - {inputs: {x: bfloat16, y: float32}, outputs: {z: float32}}
+
+broadcast:
+  kind: numpy
+
+math_semantics:
+  formula_kind: numpy_expr
+  formula: |
+    z = x + y
+
+  reference_oracle:
+    framework: torch
+    api: torch.add
+    kwargs: {}
+    available_for_dtype: [float16, float32, bfloat16, int32]
+    absent: false
+
+  invariants:
+    # algebraic 组示例：交换律——不依赖 oracle，靠两次调用对拍即可
+    - name: commutativity
+      kind: equals_under_swap
+      swap: [x, y]
+    # algebraic 组示例：加法零元——一侧为 0 时输出 == 另一侧
+    - name: identity_zero
+      kind: equals_input_when_other_is_zero
+      identity_input: x
+      zero_input: y
+
+numerical_stability:
+  required: false
+  techniques: []
+  affects_invariants: false
+
+numerical_tolerance:
+  source: "ops-precision-standard/float_compute_community.md"
+  per_dtype:
+    float32:  {rtol: 1.0e-6, atol: 1.0e-6, metric: max_relative}
+    float16:  {rtol: 1.0e-3, atol: 1.0e-3, metric: max_relative}
+    bfloat16: {rtol: 4.0e-3, atol: 4.0e-3, metric: max_relative}
+    int32:    {rtol: 0,      atol: 0,      metric: bitwise_equal}
+
+boundary_conditions:
+  - case: "shape 完全相同（无广播）"
+    synthesize: {x.shape: "[2, 3]", y.shape: "[2, 3]"}
+    machine_check: {kind: matches_oracle}
+  - case: "广播：标量 + tensor"
+    synthesize: {x.shape: "[]", y.shape: "[2, 3]"}
+    machine_check: {kind: matches_oracle}
+  - case: "广播：[1, N] + [M, N]"
+    synthesize: {x.shape: "[1, 4]", y.shape: "[3, 4]"}
+    machine_check: {kind: matches_oracle}
+  - case: "空 Tensor + 空 Tensor"
+    synthesize: {x.shape: "[0, 3]", y.shape: "[0, 3]"}
+    machine_check: {kind: returns_empty}
+  - case: "广播不合法 → 报错"
+    synthesize: {x.shape: "[2, 3]", y.shape: "[2, 4]"}
+    machine_check: {kind: raises_error, error_type: shape_mismatch}
+
+extreme_inputs:
+  # 注意 patterns[] 数组写法（多 target 时一条 case 可挂多个 pattern）
+  - case: "x 含 NaN，输出该位置应为 NaN"
+    synthesize:
+      shapes: {x: "[8]", y: "[8]"}
+      patterns:
+        - {pattern: inject_nan_one_element, target: x}
+    machine_check: {kind: nan_propagates, along_axis: -1}
+
+  - case: "+inf + -inf → NaN"
+    synthesize:
+      shapes: {x: "[1]", y: "[1]"}
+      patterns:
+        - {pattern: single_pos_inf, target: x}
+        - {pattern: single_neg_inf, target: y}
+    machine_check: {kind: produces_nan, scope: "整张量"}
+
+  - case: "fp16 上溢边界"
+    synthesize:
+      shapes: {x: "[1]", y: "[1]"}
+      patterns:
+        - {pattern: "all_same(60000.0)", target: x}
+        - {pattern: "all_same(60000.0)", target: y}
+      dtype: {x: float16, y: float16}
+    machine_check: {kind: matches_oracle}     # 与框架对齐：返回 +inf
+
+determinism:
+  required: true
+  accumulation_order: none
+  bitwise_reproducible: true

package/assets/ops-direct-invoke/skills/ops-spec-gen/examples/complex/spec.yaml

@@ -0,0 +1,154 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+
+# ============================================================
+# complex — L0 数学约束 spec
+# 教学点：layout_transform + 复数 dtype（两路 fp32/64 交错装成 complex64/128，
+#         本质是 layout 重组，无算术），不是 kernel fusion
+#         + structural invariant shape_equals_macro（对 broadcast 结果做检查）
+#         + 多 input 不同 dtype（real/imag 各为 fp32 / fp64）+ IfExp dtype_rule（fp→complex）
+# ============================================================
+schema_version: 1
+
+op:
+  name: complex
+  version: "1.0"
+  description: "Construct complex tensor from real and imag parts (with numpy broadcast)"
+  category: LayoutTransform
+  paradigms: [Broadcast, LayoutTransform]
+  lifecycle: stable
+  error_codes: [null_input, shape_mismatch]
+  platform_constraints:
+    supported_chips: [Ascend910B]
+    requires_hccl: false
+
+inputs:
+  - name: real
+    role: tensor
+    dtype_set: [float32, float64]
+    rank_range: [0, 8]
+    layout: ND
+    shape:
+      symbolic: ["...real"]
+  - name: imag
+    role: tensor
+    dtype_set: [float32, float64]
+    rank_range: [0, 8]
+    layout: ND
+    shape:
+      symbolic: ["...imag"]
+
+attributes: []
+
+outputs:
+  - name: out
+    shape_rule_kind: numpy_expr
+    shape_rule: |
+      out.shape = np.broadcast_shapes(real.shape, imag.shape)
+    dtype_rule_kind: numpy_expr
+    dtype_rule: |
+      # real/imag 必为同 dtype（见 supported_combinations）；fp32→c64, fp64→c128，fp16/bf16→c64
+      out.dtype = np.complex64 if real.dtype == np.float32 else (np.complex128 if real.dtype == np.float64 else np.complex64)
+    layout: ND
+    aliasing: none
+
+shape_constraints:
+  symbols: {}
+  global_constraints:
+    - "rank(broadcast(real, imag)) <= 8"
+  notes:
+    - "real 和 imag 必须是浮点（float32 或 float64），不能本身是复数"
+
+dtype_policy:
+  promotion: numpy_promote
+  supported_combinations:
+    - {inputs: {real: float32, imag: float32}, outputs: {out: complex64}}
+    - {inputs: {real: float64, imag: float64}, outputs: {out: complex128}}
+
+broadcast:
+  kind: numpy
+
+math_semantics:
+  formula_kind: numpy_expr
+  formula: |
+    # 先 broadcast 再构造 complex；用分量赋值避免 1j*inf 触发 0*inf=NaN（与 torch.complex 分歧）
+    r, i = np.broadcast_arrays(real, imag)
+    dt = np.complex64 if r.dtype == np.float32 else np.complex128
+    out = np.zeros(r.shape, dtype=dt)
+    out.real = r
+    out.imag = i
+
+  reference_oracle:
+    framework: torch
+    api: torch.complex
+    kwargs: {}
+    available_for_dtype: [float32, float64]
+    absent: false
+
+  invariants:
+    # structural 组：shape 必须等于 broadcast 结果
+    - name: shape_contract
+      kind: shape_equals_macro
+      macro: broadcast
+      tolerance_inherit: false
+
+numerical_stability:
+  required: false
+  techniques: []
+  affects_invariants: false
+
+numerical_tolerance:
+  source: "ops-precision-standard/float_compute_community.md"
+  per_dtype:
+    float32:    {rtol: 1.0e-6,  atol: 1.0e-6,  metric: max_relative}
+    float64:    {rtol: 1.0e-12, atol: 1.0e-12, metric: max_relative}
+    complex64:  {rtol: 1.0e-6,  atol: 1.0e-6,  metric: max_relative}
+    complex128: {rtol: 1.0e-12, atol: 1.0e-12, metric: max_relative}
+
+boundary_conditions:
+  - case: "shape 完全相同（无广播）"
+    synthesize: {real.shape: "[2, 3]", imag.shape: "[2, 3]"}
+    machine_check: {kind: matches_oracle}
+  - case: "广播：标量 real + tensor imag"
+    synthesize: {real.shape: "[]", imag.shape: "[2, 3]"}
+    machine_check: {kind: matches_oracle}
+  - case: "广播：[1, N] + [M, N]"
+    synthesize: {real.shape: "[1, 4]", imag.shape: "[3, 4]"}
+    machine_check: {kind: matches_oracle}
+  - case: "空 Tensor + 空 Tensor"
+    synthesize: {real.shape: "[0, 3]", imag.shape: "[0, 3]"}
+    machine_check: {kind: returns_empty}
+  - case: "广播不合法 → 报错"
+    synthesize: {real.shape: "[2, 3]", imag.shape: "[2, 4]"}
+    machine_check: {kind: raises_error, error_type: shape_mismatch}
+
+extreme_inputs:
+  - case: "real 含 NaN"
+    synthesize:
+      shapes: {real: "[8]", imag: "[8]"}
+      patterns:
+        - {pattern: inject_nan_one_element, target: real}
+    machine_check: {kind: nan_propagates}   # NaN 按位置传播，非整张量
+  - case: "imag 含 +inf"
+    synthesize:
+      shapes: {real: "[1]", imag: "[1]"}
+      patterns:
+        - {pattern: single_pos_inf, target: imag}
+    machine_check: {kind: matches_oracle}
+  - case: "全零（零复数）"
+    synthesize:
+      shapes: {real: "[16]", imag: "[16]"}
+      patterns:
+        - {pattern: all_zero, target: real}
+        - {pattern: all_zero, target: imag}
+    machine_check: {kind: matches_oracle}
+
+determinism:
+  required: true
+  accumulation_order: none
+  bitwise_reproducible: true

package/assets/ops-direct-invoke/skills/ops-spec-gen/examples/cumsum/spec.yaml

@@ -0,0 +1,176 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+
+# ============================================================
+# cumsum — L0 数学约束 spec
+# 教学点：recurrence category（Recurrence 范式：inter-iteration 顺序依赖）
+#         determinism.accumulation_order = sequential（不可并行化最内层）
+#         formula 极简（y = np.cumsum(x, axis=dim)）；oracle 直接可用
+# ============================================================
+schema_version: 1
+
+op:
+  name: cumsum
+  version: "1.0"
+  description: "Cumulative sum along an axis; y[i] = sum(x[0..i])"
+  category: Recurrence
+  paradigms: [Recurrence]
+  lifecycle: stable
+  error_codes: [null_input, attribute_value_out_of_range]
+  platform_constraints:
+    supported_chips: [Ascend910B]
+    requires_hccl: false
+
+inputs:
+  - name: x
+    role: tensor
+    dtype_set: [float16, bfloat16, float32, float64, int32, int64]
+    rank_range: [1, 8]
+    layout: ND
+    data_distribution: normal
+    shape:
+      symbolic: ["...d"]
+
+attributes:
+  - name: dim
+    type: int64
+    default: 0
+    semantics: "累加轴；负值按 Python 风格折算"
+    machine_constraint:
+      kind: int_in_range_relative_to_rank
+      target: x
+      lower_inclusive: "-rank(x)"
+      upper_exclusive: "rank(x)"
+
+outputs:
+  - name: y
+    shape_rule_kind: numpy_expr
+    shape_rule: |
+      y.shape = x.shape
+    dtype_rule_kind: numpy_expr
+    dtype_rule: |
+      y.dtype = x.dtype
+    layout: ND
+    aliasing: none
+
+shape_constraints:
+  symbols: {}
+  global_constraints:
+    - "rank(x) >= 1"
+  notes:
+    - "输出 shape 与输入完全相同"
+    - "Recurrence 范式：y[i] 依赖 y[i-1]（沿 dim 有顺序依赖）"
+
+dtype_policy:
+  promotion: same_as_first_input
+  supported_combinations:
+    - {inputs: {x: float16},  outputs: {y: float16}}
+    - {inputs: {x: bfloat16}, outputs: {y: bfloat16}}
+    - {inputs: {x: float32},  outputs: {y: float32}}
+    - {inputs: {x: float64},  outputs: {y: float64}}
+    - {inputs: {x: int32},    outputs: {y: int32}}
+    - {inputs: {x: int64},    outputs: {y: int64}}
+
+broadcast:
+  kind: none
+
+math_semantics:
+  formula_kind: numpy_expr
+  formula: |
+    # +0.0 规整 -0.0 → +0.0，对齐 torch.cumsum 的零符号约定（避免 stage 10 zero_sign_divergence）
+    y = np.cumsum(x, axis=dim) + 0.0
+
+  reference_oracle:
+    framework: torch
+    api: torch.cumsum
+    kwargs: {dim: "${attr.dim}"}
+    available_for_dtype: [float16, bfloat16, float32, float64, int32, int64]
+    absent: false
+
+  invariants:
+    # value 组：最后一个元素 == reduce_sum 全轴
+    - name: last_elem_eq_sum
+      kind: reduce_equals
+      reducer: sum
+      axis: dim
+      value: "y[..., -1]"              # 概念性描述（stage 2 不 eval 这个字面量）
+      tolerance_inherit: true
+    # algebraic 组：累加律——cum(x+y) = cum(x) + cum(y)（浮点精度内）
+    # （暂不声明；只做单条 reduce_equals 即够覆盖）
+
+numerical_stability:
+  required: true
+  techniques:
+    - name: kahan_compensated_sum
+      applies_to: "fp16/bf16 长轴累加时建议 Kahan 补偿求和"
+      rationale: "防止长轴累积误差超 tolerance（逐元素误差叠 N 次）"
+      anti_pattern_id: AP-007
+  affects_invariants: false
+
+numerical_tolerance:
+  source: "ops-precision-standard/float_compute_community.md"
+  per_dtype:
+    float16:  {rtol: 2.0e-2, atol: 2.0e-2, metric: max_relative}    # 累加误差放宽
+    bfloat16: {rtol: 3.0e-2, atol: 3.0e-2, metric: max_relative}
+    float32:  {rtol: 1.0e-4, atol: 1.0e-4, metric: max_relative}
+    float64:  {rtol: 1.0e-12, atol: 1.0e-12, metric: max_relative}
+    int32:    {rtol: 0,      atol: 0,      metric: bitwise_equal}
+    int64:    {rtol: 0,      atol: 0,      metric: bitwise_equal}
+
+boundary_conditions:
+  - case: "dim=0 单元素轴（累加退化为恒等）"
+    synthesize: {x.shape: "[1, 4]", attr.dim: 0}
+    machine_check: {kind: equals_input}
+  - case: "rank=1 最简 cumsum"
+    synthesize: {x.shape: "[8]", attr.dim: 0}
+    machine_check: {kind: matches_oracle}
+  - case: "负 dim"
+    synthesize: {x.shape: "[3, 4]", attr.dim: -1}
+    machine_check: {kind: matches_oracle}
+  - case: "dim 越界 → 报错"
+    synthesize: {x.shape: "[3, 4]", attr.dim: 2}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+  - case: "dim 越界负 → 报错"
+    synthesize: {x.shape: "[3, 4]", attr.dim: -3}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+
+extreme_inputs:
+  - case: "全零 → 输出全零"
+    synthesize:
+      shapes: {x: "[16]"}
+      patterns:
+        - {pattern: all_zero, target: x}
+    machine_check: {kind: equals, value: 0.0}
+
+  - case: "含 NaN（NaN 后面所有位置都变 NaN）"
+    synthesize:
+      shapes: {x: "[8]"}
+      patterns:
+        - {pattern: inject_nan_one_element, target: x}
+    machine_check: {kind: produces_nan, scope: "从 NaN 位置起的尾部"}
+
+  - case: "长轴累加 + fp16（验证补偿求和）"
+    synthesize:
+      shapes: {x: "[65536]"}
+      patterns:
+        - {pattern: "all_same(0.001)", target: x}
+      attrs: {dim: 0}
+      dtype: float16
+    machine_check: {kind: matches_oracle}
+
+  - case: "全相同值 → 线性递增"
+    synthesize:
+      shapes: {x: "[16]"}
+      patterns:
+        - {pattern: "all_same(1.0)", target: x}
+    machine_check: {kind: matches_oracle}
+
+determinism:
+  required: true
+  accumulation_order: sequential              # Recurrence 范式核心约束
+  bitwise_reproducible: true                  # 顺序固定 + 同 dtype → 应 bitwise 一致

package/assets/ops-direct-invoke/skills/ops-spec-gen/examples/dropout/spec.yaml

@@ -0,0 +1,170 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+
+# ============================================================
+# dropout — L0 数学约束 spec
+# 教学点：random_sampling category（RandomSampling 范式）+ Stateful（training/eval 状态）
+#         seed 属性自动注入；rate 属性范围约束；invariant 演示输出可重现性
+# ============================================================
+schema_version: 1
+
+op:
+  name: dropout
+  version: "1.0"
+  description: "Inverted-dropout: training 时随机置零 + 1/(1-p) 缩放；eval 时恒等"
+  category: RandomSampling
+  paradigms: [RandomSampling]
+  lifecycle: stable
+  error_codes: [null_input, attribute_value_out_of_range]
+  platform_constraints:
+    supported_chips: [Ascend910B]
+    requires_hccl: false
+
+inputs:
+  - name: x
+    role: tensor
+    dtype_set: [float16, bfloat16, float32]
+    rank_range: [0, 8]
+    layout: ND
+    shape:
+      symbolic: ["...d"]
+
+attributes:
+  - name: rate
+    type: float32
+    default: 0.5
+    semantics: "丢弃概率 p ∈ [0, 1)；按 1/(1-p) 缩放保留元素的期望"
+    machine_constraint: {kind: float_in_range, lower_inclusive: 0.0, upper_exclusive: 1.0}
+  - name: seed
+    type: int64
+    default: 0
+    semantics: "RandomSampling 范式必含；固定 seed → 输出确定性"
+    machine_constraint: {kind: int_in_range, lower_inclusive: 0, upper_inclusive: 9223372036854775807}
+  - name: training
+    type: bool
+    default: true
+    semantics: "true 时执行随机丢弃；false 时恒等映射（推理路径）"
+    machine_constraint: {kind: bool}
+
+outputs:
+  - name: y
+    shape_rule_kind: numpy_expr
+    shape_rule: |
+      y.shape = x.shape
+    dtype_rule_kind: numpy_expr
+    dtype_rule: |
+      y.dtype = x.dtype
+    layout: ND
+    aliasing: none
+
+shape_constraints:
+  symbols: {}
+  global_constraints: []
+  notes:
+    - "shape 与输入完全相同；rate / training / seed 是标量不影响 shape"
+
+dtype_policy:
+  promotion: same_as_first_input
+  supported_combinations:
+    - {inputs: {x: float16},  outputs: {y: float16}}
+    - {inputs: {x: bfloat16}, outputs: {y: bfloat16}}
+    - {inputs: {x: float32},  outputs: {y: float32}}
+
+broadcast:
+  kind: none
+
+math_semantics:
+  formula_kind: numpy_expr
+  formula: |
+    rng = np.random.default_rng(seed)
+    keep = (rng.random(x.shape) >= rate).astype(x.dtype)
+    scale_factor = 1.0 / (1.0 - rate) if rate < 1.0 else 0.0
+    training_out = (x * keep * scale_factor).astype(x.dtype)
+    y = training_out if training else x
+
+  # composition oracle：dropout 没有干净的单 callable（torch.nn.functional.dropout
+  # 在 eval 模式下需 training=False，不像我们想要的 oracle 那样无副作用）。
+  # 用 absent + 签字，下游测试以 spec.formula 作 ground truth + invariant 兜底。
+  reference_oracle:
+    framework: torch
+    api: torch.nn.functional.dropout      # 占位（absent=true 时 stage 9 早 SKIP）
+    kwargs: {}
+    available_for_dtype: [float16, bfloat16, float32]
+    absent: true
+
+  invariants:
+    # value 组：rate=0 或 training=false 时 y == x（恒等）—— 但 invariant DSL 还无法
+    # 表达条件分支，留给 boundary case 验证。
+    # structural 组：shape 严格等于输入 shape（没有 macro，用 same_as 当 invariant）
+    - name: shape_contract
+      kind: shape_equals_macro
+      macro: same_as
+      tolerance_inherit: false
+
+numerical_stability:
+  required: false
+  techniques: []
+  affects_invariants: false
+
+numerical_tolerance:
+  source: "ops-precision-standard/float_compute_community.md"
+  per_dtype:
+    float16:  {rtol: 1.0e-3, atol: 1.0e-3, metric: max_relative}
+    bfloat16: {rtol: 4.0e-3, atol: 4.0e-3, metric: max_relative}
+    float32:  {rtol: 1.0e-6, atol: 1.0e-6, metric: max_relative}
+
+boundary_conditions:
+  - case: "rate=0（不丢弃 → 恒等）"
+    synthesize: {x.shape: "[8]", attr.rate: 0.0}
+    machine_check: {kind: equals_input}
+  - case: "training=false（推理路径 → 恒等）"
+    synthesize: {x.shape: "[8]", attr.training: false}
+    machine_check: {kind: equals_input}
+  - case: "rank=0 标量"
+    synthesize: {x.shape: "[]", attr.rate: 0.5, attr.training: true, attr.seed: 42}
+    machine_check: {kind: matches_invariant, name: shape_contract}
+  - case: "空 Tensor（含 0 维）"
+    synthesize: {x.shape: "[0, 4]"}
+    machine_check: {kind: returns_empty}
+  - case: "rate 越界 (>=1) → 报错"
+    synthesize: {x.shape: "[4]", attr.rate: 1.0}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+  - case: "rate 越界 (<0) → 报错"
+    synthesize: {x.shape: "[4]", attr.rate: -0.1}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+
+extreme_inputs:
+  - case: "固定 seed 下输出确定性（同输入 + 同 seed → 同输出）"
+    tags: [deterministic_with_seed]      # 命中 RandomSampling.deterministic_with_seed
+    synthesize:
+      shapes: {x: "[16]"}
+      patterns:
+        - {pattern: "all_same(1.0)", target: x}
+      attrs: {rate: 0.5, seed: 42, training: true}
+    machine_check: {kind: matches_invariant, name: shape_contract}
+
+  - case: "rate=0.999 极端丢弃（几乎全零）"
+    synthesize:
+      shapes: {x: "[1024]"}
+      patterns:
+        - {pattern: "all_same(1.0)", target: x}
+      attrs: {rate: 0.999, seed: 42, training: true}
+    machine_check: {kind: matches_invariant, name: shape_contract}
+
+  - case: "含 NaN（NaN 应原样传播或被丢弃）"
+    synthesize:
+      shapes: {x: "[8]"}
+      patterns:
+        - {pattern: inject_nan_one_element, target: x}
+      attrs: {rate: 0.0, seed: 42, training: true}    # rate=0 简化为恒等，避开 NaN×0 歧义
+    machine_check: {kind: equals_input}
+
+determinism:
+  required: true
+  accumulation_order: none                  # elementwise 无累加
+  bitwise_reproducible: true                # 同 seed 同设备同 dtype 应 bitwise 一致