{
  "fixtureArrays": {
    "ort_3d_axis1_reverse_input_x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
  },
  "cases": [
    {
      "name": "f16_splitk_vec4_rows_axis0",
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float16",
          "shape": [8192, 4],
          "data": {
            "kind": "cycle",
            "values": [0.125, -0.0625, 0.03125, -0.015625, -0.125, 0.0625, -0.03125, 0.015625]
          }
        }
      },
      "outputs": { "y": { "dtype": "float16", "shape": [8192, 4], "tolerance": 0 } }
    },
    {
      "name": "dispatch_cliff_thread_row_scan_f32",
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [1, 16777216], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 16777216], "tolerance": 0 } }
    },
    {
      "name": "axis1_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestAxis1"
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 4],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 10.0, 20.0, 30.0, 40.0] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 4] } }
    },
    {
      "name": "ort_2d_axis0_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestAxis0"
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_2d_axis1_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestAxis1"
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3], "tolerance": 0.000001 } }
    },
    {
      "name": "f32_ordered_prefix_cancellation_workgroup_scan_no_subgroups",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTest",
        "notes": "CumSum is an ordered prefix operation. The no-subgroups workgroup tree scan may regroup 1e20 + -1e20 + 1 and lose the finite residual."
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [1, 33],
          "data": {
            "kind": "values",
            "values": [100000000000000000000.0, -100000000000000000000.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
          }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 33], "tolerance": 0 } }
    },
    {
      "name": "f32_ordered_reverse_exclusive_cancellation_workgroup_scan_no_subgroups",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestReverseExclusive",
        "notes": "Reverse+exclusive CumSum is still an ordered prefix operation. The no-subgroups workgroup tree scan may regroup 1 + -1e20 + 1e20 and lose the finite residual."
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [1, 33],
          "data": {
            "kind": "values",
            "values": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, -100000000000000000000.0, 100000000000000000000.0]
          }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 33], "tolerance": 0 } }
    },
    {
      "name": "f32_subnormal_axis1_accumulation_gpu_gap",
      "skipGpu": {
        "category": "permanent",
        "reason": "Portable WGSL floating-point semantics do not guarantee preservation of the subnormal values required by this fixture. Backend evidence: WebGPU/Metal flushes subnormals to zero in f32; bit-exact subnormal preservation is unattainable on GPU."
      },
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestAxis1",
        "notes": "Cumulative sums of finite subnormal values remain valid float32 outputs; flushing any step loses the entire running total."
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3],
          "data": { "kind": "values", "values": [1e-40, 1e-40, 1e-40, -1e-40, -1e-40, -1e-40] }
        }
      },
      "outputs": {
        "y": {
          "dtype": "float32",
          "shape": [2, 3],
          "tolerance": 0,
          "data": { "kind": "values", "values": [1e-40, 2e-40, 3e-40, -1e-40, -2e-40, -3e-40] }
        }
      }
    },
    {
      "name": "f32_subnormal_axis0_forward_accumulation_gpu_gap",
      "skipGpu": {
        "category": "permanent",
        "reason": "Portable WGSL floating-point semantics do not guarantee preservation of the subnormal values required by this fixture. Backend evidence: WebGPU/Metal flushes subnormals to zero in f32; bit-exact subnormal preservation is unattainable on GPU."
      },
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestAxis0",
        "notes": "Finite subnormal cumulative sums along axis 0 exercise the non-contiguous scan path."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [3, 2],
          "data": { "kind": "values", "values": [1e-40, -1e-40, 2e-40, -2e-40, 3e-40, -3e-40] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [3, 2], "tolerance": 0 } }
    },
    {
      "name": "f32_subnormal_axis1_reverse_exclusive_accumulation_gpu_gap",
      "skipGpu": {
        "category": "permanent",
        "reason": "Portable WGSL floating-point semantics do not guarantee preservation of the subnormal values required by this fixture. Backend evidence: WebGPU/Metal flushes subnormals to zero in f32; bit-exact subnormal preservation is unattainable on GPU."
      },
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestReverseExclusive",
        "notes": "Reverse+exclusive CumSum accumulates from the far end of the axis; valid subnormal residuals should survive each shifted prefix."
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [1, 4],
          "data": { "kind": "values", "values": [1e-40, 2e-40, 3e-40, 4e-40] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 4], "tolerance": 0 } }
    },
    {
      "name": "f32_subnormal_axis0_reverse_accumulation_gpu_gap",
      "skipGpu": {
        "category": "permanent",
        "reason": "Portable WGSL floating-point semantics do not guarantee preservation of the subnormal values required by this fixture. Backend evidence: WebGPU/Metal flushes subnormals to zero in f32; bit-exact subnormal preservation is unattainable on GPU."
      },
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestAxis0",
        "notes": "Reverse CumSum along axis 0 exercises subnormal residual propagation through the non-last-axis scan path."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [4, 1],
          "data": { "kind": "values", "values": [1e-40, 2e-40, 3e-40, 4e-40] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [4, 1], "tolerance": 0 } }
    },
    {
      "name": "f32_subnormal_workgroup_scan_accumulation_gpu_gap",
      "skipGpu": {
        "category": "permanent",
        "reason": "Portable WGSL floating-point semantics do not guarantee preservation of the subnormal values required by this fixture. Backend evidence: WebGPU/Metal flushes subnormals to zero in f32; bit-exact subnormal preservation is unattainable on GPU."
      },
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestAxis1",
        "notes": "Dim > 32 selects the workgroup row-scan variant; finite subnormal running totals should survive the chunked scan."
      },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "float32", "shape": [1, 33], "data": { "kind": "constant", "value": 1e-40 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 33], "tolerance": 0 } }
    },
    {
      "name": "axis0_exclusive_reverse_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis0ReverseExclusive"
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [3, 2],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [3, 2] } }
    },
    {
      "name": "negative_axis_uint32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestNegAxis"
      },
      "args": { "axis": -1 },
      "inputs": {
        "x": { "dtype": "uint32", "shape": [2, 3], "data": { "kind": "values", "values": [1, 2, 3, 4, 5, 6] } }
      },
      "outputs": { "y": { "dtype": "uint32", "shape": [2, 3] } }
    },
    {
      "name": "axis1_f16",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestFloat16"
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float16",
          "shape": [2, 3],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, -1.0, -2.0, -3.0] }
        }
      },
      "outputs": { "y": { "dtype": "float16", "shape": [2, 3] } },
      "tolerance": 0.001
    },
    {
      "name": "onnx_1d_exclusive",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestExclusive"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [5], "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.000001 } }
    },
    {
      "name": "onnx_1d_reverse",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestReverse"
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [5], "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.000001 } }
    },
    {
      "name": "onnx_1d_reverse_exclusive",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestReverseExclusive"
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [5], "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.000001 } }
    },
    {
      "name": "exclusive_singleton_axis_forward",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestExclusiveAxisHasSingleValue"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [1, 2], "data": { "kind": "values", "values": [1.0, 2.0] } } },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 2], "tolerance": 0 } }
    },
    {
      "name": "ort_exclusive_singleton_axis_reverse",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestExclusiveAxisHasSingleValue"
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [1, 2], "data": { "kind": "values", "values": [1.0, 2.0] } } },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 2], "tolerance": 0 } }
    },
    {
      "name": "ort_3d_axis1_reverse",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis1Reverse"
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis2_reverse_exclusive",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis2ReverseExclusive"
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 2 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_exclusive_axis_dim_one_forward",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestExclusiveAxisHasSingleValue"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [1, 2], "data": { "kind": "values", "values": [1.0, 2.0] } } },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 2], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_exclusive_axis_dim_one_reverse",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestExclusiveAxisHasSingleValue"
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [1, 2], "data": { "kind": "values", "values": [1.0, 2.0] } } },
      "outputs": { "y": { "dtype": "float32", "shape": [1, 2], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_1d_int32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestInt32"
      },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "int32", "shape": [5], "data": { "kind": "values", "values": [1, 2, 3, 4, 5] } } },
      "outputs": { "y": { "dtype": "int32", "shape": [5], "tolerance": 0 } }
    },
    {
      "name": "ort_1d_f32_default",
      "provenance": { "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc", "test": "CumSumTest._1DTest" },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [5], "data": { "kind": "linspace", "start": 1.0, "end": 5.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_1d_negative_axis_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestNegAxis"
      },
      "args": { "axis": -1 },
      "inputs": { "x": { "dtype": "float32", "shape": [5], "data": { "kind": "linspace", "start": 1.0, "end": 5.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_2d_exclusive_axis0_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestExclusiveAxis0"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [2, 3], "data": { "kind": "linspace", "start": 1.0, "end": 6.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_2d_exclusive_axis1_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._2DTestExclusiveAxis1"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [2, 3], "data": { "kind": "linspace", "start": 1.0, "end": 6.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis0_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis0"
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [2, 3, 4], "data": { "kind": "linspace", "start": 1.0, "end": 24.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis2_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis2"
      },
      "args": { "axis": 2 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [2, 3, 4], "data": { "kind": "linspace", "start": 1.0, "end": 24.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis0_reverse_exclusive_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis0ReverseExclusive"
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [2, 3, 4], "data": { "kind": "linspace", "start": 1.0, "end": 24.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis1_reverse_exclusive_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis1ReverseExclusive"
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [2, 3, 4], "data": { "kind": "linspace", "start": 1.0, "end": 24.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "onnx_backend_cumsum_1d_f32_projection",
      "provenance": {
        "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_1d",
        "notes": "The official ONNX backend fixture uses float64; this case preserves its values in supported float32 storage."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [5], "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.00001 } }
    },
    {
      "name": "onnx_backend_cumsum_1d_exclusive_f32_projection",
      "provenance": {
        "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_1d_exclusive",
        "notes": "The official ONNX backend fixture uses float64; this case preserves its values in supported float32 storage."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [5], "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.00001 } },
      "attrs": { "exclusive": 1 }
    },
    {
      "name": "onnx_backend_cumsum_1d_int32_exclusive",
      "provenance": { "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive" },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "int32", "shape": [5], "data": { "kind": "values", "values": [1, 2, 3, 4, 5] } } },
      "outputs": { "y": { "dtype": "int32", "shape": [5], "tolerance": 0 } },
      "attrs": { "exclusive": 1 }
    },
    {
      "name": "onnx_backend_cumsum_1d_reverse_f32_projection",
      "provenance": {
        "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_1d_reverse",
        "notes": "The official ONNX backend fixture uses float64; this case preserves its values in supported float32 storage."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [5], "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.00001 } },
      "attrs": { "reverse": 1 }
    },
    {
      "name": "onnx_backend_cumsum_1d_reverse_exclusive_f32_projection",
      "provenance": {
        "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive",
        "notes": "The official ONNX backend fixture uses float64; this case preserves its values in supported float32 storage."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [5], "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [5], "tolerance": 0.00001 } },
      "attrs": { "exclusive": 1, "reverse": 1 }
    },
    {
      "name": "onnx_backend_cumsum_2d_axis_0_f32_projection",
      "provenance": {
        "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_2d_axis_0",
        "notes": "The official ONNX backend fixture uses float64; this case preserves its values in supported float32 storage."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3], "tolerance": 0.00001 } }
    },
    {
      "name": "onnx_backend_cumsum_2d_axis_1_f32_projection",
      "provenance": {
        "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_2d_axis_1",
        "notes": "The official ONNX backend fixture uses float64; this case preserves its values in supported float32 storage."
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3], "tolerance": 0.00001 } }
    },
    {
      "name": "onnx_backend_cumsum_2d_int32",
      "provenance": { "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_2d_int32" },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "int32", "shape": [2, 3], "data": { "kind": "values", "values": [1, 2, 3, 4, 5, 6] } }
      },
      "outputs": { "y": { "dtype": "int32", "shape": [2, 3], "tolerance": 0 } }
    },
    {
      "name": "onnx_backend_cumsum_2d_negative_axis_f32_projection",
      "provenance": {
        "source": "cmake/external/onnx/onnx/backend/test/data/node/test_cumsum_2d_negative_axis",
        "notes": "The official ONNX backend fixture uses float64; this case preserves its values in supported float32 storage."
      },
      "args": { "axis": -1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3],
          "data": { "kind": "values", "values": [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3], "tolerance": 0.00001 } }
    },
    {
      "name": "ort_3d_axis1_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis1"
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis0_exclusive_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis0Exclusive"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis1_exclusive_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis1Exclusive"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis2_exclusive_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis2Exclusive"
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 2 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis0_reverse_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis0Reverse"
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_3d_axis2_reverse_f32",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._3DTestAxis2Reverse"
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 2 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 3, 4],
          "data": { "kind": "values", "values": { "$ref": "#/fixtureArrays/ort_3d_axis1_reverse_input_x" } }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 3, 4], "tolerance": 0.000001 } }
    },
    {
      "name": "ort_long_int32_axis0_compact",
      "provenance": {
        "source": "onnxruntime/test/providers/cpu/math/cumsum_test.cc",
        "test": "CumSumTest._1DTestLong",
        "notes": "Compact projection of ORT's 100000-element all-ones int32 scan; keeps runtime practical while exercising long-axis indexing."
      },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "int32", "shape": [1024], "data": { "kind": "constant", "value": 1 } } },
      "outputs": { "y": { "dtype": "int32", "shape": [1024], "tolerance": 0 } }
    },
    {
      "name": "wg_scan_axis1_f32_len200",
      "provenance": {
        "notes": "Integer-valued f32 (exact under any summation order) exercising the workgroup row-scan variant with a partial chunk."
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [16, 200], "data": { "kind": "linspace", "start": 1.0, "end": 3200.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [16, 200], "tolerance": 0 } }
    },
    {
      "name": "wg_scan_axis1_exclusive_f32",
      "provenance": {
        "notes": "An exclusive workgroup row scan over integer-valued float32 data has exact cumulative sums."
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [8, 64], "data": { "kind": "linspace", "start": 1.0, "end": 512.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [8, 64], "tolerance": 0 } }
    },
    {
      "name": "wg_scan_axis1_reverse_f32",
      "provenance": {
        "notes": "A reverse workgroup row scan over integer-valued float32 data has exact cumulative sums."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [8, 64], "data": { "kind": "linspace", "start": 1.0, "end": 512.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [8, 64], "tolerance": 0 } }
    },
    {
      "name": "wg_scan_reverse_exclusive_partial_chunk_f32",
      "provenance": { "notes": "Reverse+exclusive workgroup row-scan with a non-multiple-of-256 axis length." },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [4, 100], "data": { "kind": "linspace", "start": 1.0, "end": 400.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [4, 100], "tolerance": 0 } }
    },
    {
      "name": "wg_scan_multichunk_f32",
      "provenance": {
        "notes": "Axis length 1000 forces the chunk-carry path (4 chunks of 256) in the workgroup row-scan."
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [4, 1000], "data": { "kind": "linspace", "start": 1.0, "end": 4000.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [4, 1000], "tolerance": 0 } }
    },
    {
      "name": "wg_scan_axis1_f16_ones",
      "provenance": { "notes": "f16 workgroup row-scan; all-ones cumsum (1..64) is exact in f16." },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "float16", "shape": [2, 64], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float16", "shape": [2, 64], "tolerance": 0 } }
    },
    {
      "name": "wg_scan_axis1_u32_cycle",
      "provenance": {
        "notes": "A uint32 workgroup row scan remains exact because modulo-2^32 addition is associative."
      },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "uint32", "shape": [3, 48], "data": { "kind": "cycle", "values": [1, 2, 3] } } },
      "outputs": { "y": { "dtype": "uint32", "shape": [3, 48], "tolerance": 0 } }
    },
    {
      "name": "thread_rows_axis0_f32",
      "provenance": {
        "notes": "Wide-inner axis-0 scan exercising the thread-per-row serial variant (bit-identical accumulation order to the fallback)."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [8, 4096], "data": { "kind": "linspace", "start": 1.0, "end": 32768.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [8, 4096], "tolerance": 0 } }
    },
    {
      "name": "thread_rows_axis1_3d_reverse_exclusive_f32",
      "provenance": {
        "notes": "A three-dimensional middle-axis scan exercises reverse and exclusive handling in the thread-per-row path."
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [4, 16, 512], "data": { "kind": "linspace", "start": 1.0, "end": 32768.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [4, 16, 512], "tolerance": 0 } }
    },
    {
      "name": "thread_rows_axis0_int32_ones",
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "int32", "shape": [4, 2048], "data": { "kind": "constant", "value": 1 } } },
      "outputs": { "y": { "dtype": "int32", "shape": [4, 2048], "tolerance": 0 } }
    },
    {
      "name": "empty_input_zero_dim",
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "float32", "shape": [0, 4], "data": { "kind": "values", "values": [] } } },
      "outputs": { "y": { "dtype": "float32", "shape": [0, 4], "tolerance": 0 } }
    },
    {
      "name": "wg_strided_axis0_f32_multichunk",
      "provenance": {
        "notes": "Workgroup strided row-scan (inner>1, dim>256): few rows + long non-innermost axis. constant-1 input keeps f32 exact across the cross-chunk carry."
      },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [512, 32], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [512, 32], "tolerance": 0 } }
    },
    {
      "name": "wg_strided_axis0_exclusive_f32",
      "provenance": { "notes": "An exclusive workgroup strided scan over constant-one data has exact cumulative sums." },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [512, 8], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [512, 8], "tolerance": 0 } }
    },
    {
      "name": "wg_strided_axis1_3d_reverse_f32",
      "provenance": { "notes": "Workgroup strided row-scan reverse, 3D non-innermost axis (inner=16, dim=512)." },
      "attrs": { "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "float32", "shape": [2, 512, 16], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 512, 16], "tolerance": 0 } }
    },
    {
      "name": "wg_strided_axis1_3d_reverse_exclusive_f32",
      "provenance": { "notes": "Workgroup strided row-scan reverse+exclusive cross-chunk path." },
      "attrs": { "reverse": 1, "exclusive": 1 },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "float32", "shape": [2, 512, 16], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 512, 16], "tolerance": 0 } }
    },
    {
      "name": "wg_strided_axis0_int32_ones",
      "provenance": { "notes": "Workgroup strided row-scan int32 (integer wrap is associative -> exact)." },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "int32", "shape": [512, 8], "data": { "kind": "constant", "value": 1 } } },
      "outputs": { "y": { "dtype": "int32", "shape": [512, 8], "tolerance": 0 } }
    },
    {
      "name": "wg_strided_axis0_f16_ones",
      "provenance": {
        "notes": "Workgroup strided row-scan f16 storage; f32 accumulation matches the serial kernel for small integer values."
      },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float16", "shape": [300, 4], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float16", "shape": [300, 4], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_forward_ones",
      "provenance": {
        "notes": "Split-K row scan (f32, dim>=8192, few rows): long axis 0 split across SPLIT segments x rows workgroups. dim=8192 -> 4 segments, 2048-long each (8 WG-chunks/segment), exercising both the cross-segment carry and the intra-segment chunk carry. constant-1 keeps f32 exact (max total 8192 << 2^24)."
      },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [8192, 8], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [8192, 8], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_exclusive_ones",
      "provenance": {
        "notes": "An exclusive split-K row scan over constant-one data exercises exact cross-segment carry handling."
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [8192, 8], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [8192, 8], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_reverse_ones",
      "provenance": {
        "notes": "Split-K row scan reverse: segment 0 owns the last axis slices, so the segment index still runs in scan order. constant-1 stays exact."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [8192, 8], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [8192, 8], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_reverse_exclusive_ones",
      "provenance": {
        "notes": "A reverse exclusive split-K row scan over constant-one data exercises exact cross-segment carry handling."
      },
      "attrs": { "reverse": 1, "exclusive": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [8192, 8], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [8192, 8], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_partial_segment_ones",
      "provenance": {
        "notes": "Split-K with a non-power-of-WG axis (dim=10000, ceilDiv(10000,2048)=5 -> 8 segments, last segment shorter): exercises the partial-segment and partial-chunk tails."
      },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [10000, 6], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [10000, 6], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_single_row_inner1",
      "provenance": {
        "notes": "Split-K with inner=1 (innermost axis, rows=1): one row split into SPLIT segments. Confirms the carry chain across segments for a single lane."
      },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [16384, 1], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [16384, 1], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_varying_crosscheck",
      "provenance": {
        "notes": "A varying positive float32 linspace exercises split-K segment and chunk carries. Monotone running totals avoid catastrophic cancellation, so reassociated accumulation differs from input-order accumulation only by a small relative rounding error."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [8192, 4], "data": { "kind": "linspace", "start": 0.5, "end": 1.5 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [8192, 4], "tolerance": 0.001, "relTolerance": 0.001 } }
    },
    {
      "name": "rank4_middle_axis_f32_thread_rows",
      "provenance": {
        "notes": "For shape [3,5,7,4] reduced along axis 2, outer=15 and inner=4 are both greater than one. Integer-valued float32 inputs keep every seven-element row scan exact while exercising outer/axis/inner coordinate flattening."
      },
      "args": { "axis": 2 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [3, 5, 7, 4], "data": { "kind": "linspace", "start": 1.0, "end": 420.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [3, 5, 7, 4], "tolerance": 0 } }
    },
    {
      "name": "rank5_middle_axis_reverse_exclusive_int32",
      "provenance": {
        "notes": "Rank-5 reverse+exclusive non-last axis (axis=2: outer=4, dim=3, inner=8). Confirms the reverse + shift-right exclusive index math and the outer/inner flattening at rank 5. int32 wraps mod 2^32, exact vs ORT."
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 2 },
      "inputs": {
        "x": { "dtype": "int32", "shape": [2, 2, 3, 2, 4], "data": { "kind": "cycle", "values": [1, 2, 3, 4, 5] } }
      },
      "outputs": { "y": { "dtype": "int32", "shape": [2, 2, 3, 2, 4], "tolerance": 0 } }
    },
    {
      "name": "uint32_running_sum_wraps_2pow32_axis1",
      "provenance": {
        "notes": "uint32 cumulative sum driven past 2^32 so the running total wraps (64 * 2^28 = 2^34). u32 addition wraps mod 2^32 in WGSL (accType=u32, no f32 promotion), so the wrapped prefix must match exactly. Confirms the int path is NOT silently accumulating in f32. inner=1, dim>32 -> wg_row_scan."
      },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "uint32", "shape": [4, 64], "data": { "kind": "constant", "value": 268435456 } } },
      "outputs": { "y": { "dtype": "uint32", "shape": [4, 64], "tolerance": 0 } }
    },
    {
      "name": "int32_large_mixed_axis0_strided",
      "provenance": {
        "notes": "int32 strided scan (inner=8, dim=300>256 -> wg_strided_row_scan) with large mixed +/- values that stay within i32 range but produce large-magnitude running totals. Verifies the wg_strided int path accumulates in i32 (not f32, which would lose low bits past 2^24)."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": {
          "dtype": "int32",
          "shape": [300, 8],
          "data": { "kind": "cycle", "values": [1000000, -500000, 750000, -250000] }
        }
      },
      "outputs": { "y": { "dtype": "int32", "shape": [300, 8], "tolerance": 0 } }
    },
    {
      "name": "f16_varied_axis1_wg_row",
      "provenance": {
        "notes": "Varied float16 values along a 256-element contiguous axis exercise float32 workgroup accumulation followed by float16 storage. Running totals remain small and finite."
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float16", "shape": [4, 256], "data": { "kind": "cycle", "values": [0.5, 1.5, -0.5, 2.0] } }
      },
      "outputs": { "y": { "dtype": "float16", "shape": [4, 256], "tolerance": 0.01, "relTolerance": 0.01 } }
    },
    {
      "name": "splitk_axis0_f32_reverse_varying_crosscheck",
      "provenance": {
        "notes": "A reverse split-K scan over a varying positive linspace makes segment order and reverse indexing observable while keeping reassociation drift within tolerance."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [8192, 4], "data": { "kind": "linspace", "start": 0.5, "end": 2.5 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [8192, 4], "tolerance": 0.01, "relTolerance": 0.001 } }
    },
    {
      "name": "splitk_axis0_f32_reverse_exclusive_varying_crosscheck",
      "provenance": {
        "notes": "A reverse exclusive split-K scan over a varying positive linspace exercises the shift at segment boundaries and reverse cross-segment carry while keeping reassociation drift within tolerance."
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [8192, 4], "data": { "kind": "linspace", "start": 0.5, "end": 2.5 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [8192, 4], "tolerance": 0.01, "relTolerance": 0.001 } }
    },
    {
      "name": "wg_strided_axis0_reverse_exclusive_varying_offmultiple",
      "provenance": {
        "notes": "A 300-element reverse exclusive strided scan comprises one full 256-element chunk and a 44-element tail. Varying positive values make partial-chunk masking and the exclusive boundary shift observable."
      },
      "attrs": { "exclusive": 1, "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [300, 8], "data": { "kind": "linspace", "start": 0.25, "end": 4.0 } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [300, 8], "tolerance": 0.001, "relTolerance": 0.001 } }
    },
    {
      "name": "int32_splitk_axis0_reverse_varying_exact",
      "provenance": {
        "notes": "An 8,192-element int32 reverse split-K scan uses varying cyclic values, making segment order observable. Associative integer addition keeps the expected result exact and all magnitudes remain in range."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "int32", "shape": [8192, 4], "data": { "kind": "cycle", "values": [7, -3, 11, -5, 2] } }
      },
      "outputs": { "y": { "dtype": "int32", "shape": [8192, 4], "tolerance": 0 } }
    },
    {
      "name": "wg_row_scan_vec4_dim_multiple4_exclusive_varying",
      "provenance": {
        "notes": "A contiguous 256-element exclusive scan over varying integer-valued float32 data exercises vec4 register-blocked lane offsets. Every cumulative sum is exact under any accumulation order."
      },
      "attrs": { "exclusive": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [4, 256], "data": { "kind": "cycle", "values": [1.0, 2.0, 3.0, -1.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [4, 256], "tolerance": 0 } }
    },
    {
      "name": "rank7_last_axis",
      "args": { "axis": -1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 1, 2, 1, 2, 1, 3],
          "data": { "kind": "cycle", "values": [1.0, -0.5, 2.0, 0.25] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 1, 2, 1, 2, 1, 3], "tolerance": 0.000001 } }
    },
    {
      "name": "int32_rows2_dim64_wg_row_scan_vec4",
      "provenance": {
        "source": "synthetic",
        "notes": "Two 64-element int32 rows select the parallel vectorized row scan. Integer addition remains exact under the scan's reassociation."
      },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "int32", "shape": [2, 64], "data": { "kind": "cycle", "values": [3, -1, 7, 2] } } },
      "outputs": { "y": { "dtype": "int32", "shape": [2, 64], "tolerance": 0 } }
    },
    {
      "name": "int32_rows2_dim64_reverse_wg_row_scan",
      "provenance": {
        "source": "synthetic",
        "notes": "A reverse integer row scan selects the scalar workgroup engine because the vec4 engine requires forward order."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": { "x": { "dtype": "int32", "shape": [2, 64], "data": { "kind": "cycle", "values": [3, -1, 7, 2] } } },
      "outputs": { "y": { "dtype": "int32", "shape": [2, 64], "tolerance": 0 } }
    },
    {
      "name": "float32_rows2_dim1536_splitk_mid_fallback",
      "provenance": {
        "source": "synthetic",
        "notes": "A width-1536 float row exercises the mid-size scan policy: devices without an ordered subgroup scan use split-K, while compatible fixed-width subgroups may use a workgroup scan. Integer-valued data keeps either accumulation order exact."
      },
      "args": { "axis": 1 },
      "inputs": {
        "x": { "dtype": "float32", "shape": [2, 1536], "data": { "kind": "cycle", "values": [1.0, 2.0, -1.0, 3.0] } }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 1536], "tolerance": 0 } }
    },
    {
      "name": "rank8_last_axis",
      "args": { "axis": -1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [2, 1, 2, 1, 2, 1, 2, 3],
          "data": { "kind": "cycle", "values": [1.0, -0.5, 2.0, 0.25] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [2, 1, 2, 1, 2, 1, 2, 3], "tolerance": 0.000001 } }
    },
    {
      "name": "wg_strided_axis0_uint32_cycle",
      "provenance": {
        "notes": "A uint32 workgroup strided scan exercises the unsigned identity and wrapping-addition path. Modulo-2^32 addition is associative, so reassociation preserves the exact result."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "uint32", "shape": [512, 8], "data": { "kind": "cycle", "values": [3, 11, 7, 5, 13] } }
      },
      "outputs": { "y": { "dtype": "uint32", "shape": [512, 8], "tolerance": 0 } }
    },
    {
      "name": "uint32_splitk_axis0_varying_exact",
      "provenance": {
        "notes": "uint32 split-K (dim=8192 selects the splitk_row_scan scalar path). The accumulator is now the native integer type rather than f32, so unsigned wraparound is representable and the split-K reassociation is bit-exact."
      },
      "args": { "axis": 0 },
      "inputs": {
        "x": { "dtype": "uint32", "shape": [8192, 4], "data": { "kind": "cycle", "values": [7, 3, 11, 5, 2] } }
      },
      "outputs": { "y": { "dtype": "uint32", "shape": [8192, 4], "tolerance": 0 } }
    },
    {
      "name": "splitk_axis0_f32_reverse_scalar_rung_ones",
      "provenance": {
        "notes": "Reverse scan on the scalar split-K path uses an inner extent of six, which is not vec4-aligned. A non-power-of-workgroup axis also checks the partial final segment."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 0 },
      "inputs": { "x": { "dtype": "float32", "shape": [10000, 6], "data": { "kind": "constant", "value": 1.0 } } },
      "outputs": { "y": { "dtype": "float32", "shape": [10000, 6], "tolerance": 0 } }
    },
    {
      "name": "splitk_reverse_last_axis_8192_f32",
      "provenance": {
        "notes": "A reverse scan over an 8,192-element innermost axis exercises the minimum split-K length. Every value is a multiple of 0.25 and every partial stays below 2^10, so chunked and input-order accumulation agree exactly."
      },
      "attrs": { "reverse": 1 },
      "args": { "axis": 1 },
      "inputs": {
        "x": {
          "dtype": "float32",
          "shape": [3, 8192],
          "data": { "kind": "cycle", "values": [1.0, -1.0, 0.5, -0.5, 0.25] }
        }
      },
      "outputs": { "y": { "dtype": "float32", "shape": [3, 8192], "tolerance": 0 } }
    }
  ]
}