kumi 0.0.18 → 0.0.19

data/golden/multirank_hoisting/expected/lir_04_loop_invcm.txt

@@ -0,0 +1,109 @@
+(LIR
+  (Declaration global_offset_plus
+    %t1 = load_input "global_offset" :: float
+    %t2 = const 1.0 :: float
+    %t3 = call core.add(%t1, %t2) :: float
+    yield %t3
+  )
+  (Declaration batch_bias
+    %t4 = load_input "batch" :: array
+    %t54 = load_input "global_offset" :: float
+    %t55 = const 1.0 :: float
+    %t56 = call core.add(%t54, %t55) :: float
+    loop batch id=L1 in %t4 as el=%batch_el_5, idx=%batch_i_6
+      %t7 = load_field batch_el_5["mean"] :: float
+      %t9 = call core.add(%t7, %t56) :: float
+      yield %t9
+    end_loop
+  )
+  (Declaration row_scale2
+    %t10 = load_input "batch" :: array
+    %t17 = const 2.0 :: float
+    loop batch id=L2 in %t10 as el=%batch_el_11, idx=%batch_i_12
+      %t13 = load_field batch_el_11["row"] :: any
+      loop row id=L3 in %t13 as el=%row_el_14, idx=%row_i_15
+        %t16 = load_field row_el_14["scale"] :: float
+        %t18 = call core.mul(%t16, %t17) :: float
+        yield %t18
+      end_loop
+    end_loop
+  )
+  (Declaration elem_affine
+    %t19 = load_input "batch" :: array
+    %t81 = load_input "global_offset" :: float
+    %t82 = const 1.0 :: float
+    %t60 = const 2.0 :: float
+    %t83 = call core.add(%t81, %t82) :: float
+    loop batch id=L4 in %t19 as el=%batch_el_20, idx=%batch_i_21
+      %t22 = load_field batch_el_20["row"] :: any
+      %t64 = load_field batch_el_20["mean"] :: float
+      %t65 = call core.add(%t64, %t83) :: float
+      loop row id=L5 in %t22 as el=%row_el_23, idx=%row_i_24
+        %t25 = load_field row_el_23["col"] :: any
+        %t59 = load_field row_el_23["scale"] :: float
+        %t61 = call core.mul(%t59, %t60) :: float
+        loop col id=L6 in %t25 as el=%col_el_26, idx=%col_i_27
+          %t28 = load_field col_el_26["val"] :: float
+          %t30 = call core.mul(%t28, %t61) :: float
+          %t32 = call core.add(%t30, %t65) :: float
+          yield %t32
+        end_loop
+      end_loop
+    end_loop
+  )
+  (Declaration row_sum_affine
+    %t33 = load_input "batch" :: array
+    %t87 = const 2.0 :: float
+    %t90 = load_input "global_offset" :: float
+    %t91 = const 1.0 :: float
+    %t92 = call core.add(%t90, %t91) :: float
+    loop batch id=L7 in %t33 as el=%batch_el_34, idx=%batch_i_35
+      %t36 = load_field batch_el_34["row"] :: any
+      %t93 = load_field batch_el_34["mean"] :: float
+      %t94 = call core.add(%t93, %t92) :: float
+      loop row id=L8 in %t36 as el=%row_el_37, idx=%row_i_38
+        %acc_39 = decl_acc :: float
+        %t40 = load_field row_el_37["col"] :: any
+        %t86 = load_field row_el_37["scale"] :: float
+        %t88 = call core.mul(%t86, %t87) :: float
+        loop col id=L9 in %t40 as el=%col_el_41, idx=%col_i_42
+          %t69 = load_field col_el_41["val"] :: float
+          %t71 = call core.mul(%t69, %t88) :: float
+          %t73 = call core.add(%t71, %t94) :: float
+          %acc_39 = acc_add agg.sum(%acc_39, %t73) :: float
+        end_loop
+        %t44 = acc_load %acc_39 :: float
+        yield %t44
+      end_loop
+    end_loop
+  )
+  (Declaration batch_total_affine
+    %t45 = load_input "batch" :: array
+    %t110 = load_input "global_offset" :: float
+    %t111 = const 1.0 :: float
+    %t101 = const 2.0 :: float
+    %t112 = call core.add(%t110, %t111) :: float
+    loop batch id=L10 in %t45 as el=%batch_el_46, idx=%batch_i_47
+      %acc_48 = decl_acc :: float
+      %t49 = load_field batch_el_46["row"] :: any
+      %t105 = load_field batch_el_46["mean"] :: float
+      %t106 = call core.add(%t105, %t112) :: float
+      loop row id=L11 in %t49 as el=%row_el_50, idx=%row_i_51
+        %acc77 = decl_acc :: float
+        %t78 = load_field row_el_50["col"] :: any
+        %t100 = load_field row_el_50["scale"] :: float
+        %t102 = call core.mul(%t100, %t101) :: float
+        loop col id=L12 in %t78 as el=%col_el_41, idx=%col_i_42
+          %t107 = load_field col_el_41["val"] :: float
+          %t108 = call core.mul(%t107, %t102) :: float
+          %t109 = call core.add(%t108, %t106) :: float
+          %acc77 = acc_add agg.sum(%acc77, %t109) :: float
+        end_loop
+        %t80 = acc_load %acc77 :: float
+        %acc_48 = acc_add agg.sum(%acc_48, %t80) :: float
+      end_loop
+      %t53 = acc_load %acc_48 :: float
+      yield %t53
+    end_loop
+  )
+)

data/golden/multirank_hoisting/expected/lir_06_const_prop.txt

@@ -0,0 +1,109 @@
+(LIR
+  (Declaration global_offset_plus
+    %t1 = load_input "global_offset" :: float
+    %t2 = const 1.0 :: float
+    %t3 = call core.add(%t1, %t2) :: float
+    yield %t3
+  )
+  (Declaration batch_bias
+    %t4 = load_input "batch" :: array
+    %t54 = load_input "global_offset" :: float
+    %t55 = const 1.0 :: float
+    %t56 = call core.add(%t54, %t55) :: float
+    loop batch id=L1 in %t4 as el=%batch_el_5, idx=%batch_i_6
+      %t7 = load_field batch_el_5["mean"] :: float
+      %t9 = call core.add(%t7, %t56) :: float
+      yield %t9
+    end_loop
+  )
+  (Declaration row_scale2
+    %t10 = load_input "batch" :: array
+    %t17 = const 2.0 :: float
+    loop batch id=L2 in %t10 as el=%batch_el_11, idx=%batch_i_12
+      %t13 = load_field batch_el_11["row"] :: any
+      loop row id=L3 in %t13 as el=%row_el_14, idx=%row_i_15
+        %t16 = load_field row_el_14["scale"] :: float
+        %t18 = call core.mul(%t16, %t17) :: float
+        yield %t18
+      end_loop
+    end_loop
+  )
+  (Declaration elem_affine
+    %t19 = load_input "batch" :: array
+    %t81 = load_input "global_offset" :: float
+    %t82 = const 1.0 :: float
+    %t60 = const 2.0 :: float
+    %t83 = call core.add(%t81, %t82) :: float
+    loop batch id=L4 in %t19 as el=%batch_el_20, idx=%batch_i_21
+      %t22 = load_field batch_el_20["row"] :: any
+      %t64 = load_field batch_el_20["mean"] :: float
+      %t65 = call core.add(%t64, %t83) :: float
+      loop row id=L5 in %t22 as el=%row_el_23, idx=%row_i_24
+        %t25 = load_field row_el_23["col"] :: any
+        %t59 = load_field row_el_23["scale"] :: float
+        %t61 = call core.mul(%t59, %t60) :: float
+        loop col id=L6 in %t25 as el=%col_el_26, idx=%col_i_27
+          %t28 = load_field col_el_26["val"] :: float
+          %t30 = call core.mul(%t28, %t61) :: float
+          %t32 = call core.add(%t30, %t65) :: float
+          yield %t32
+        end_loop
+      end_loop
+    end_loop
+  )
+  (Declaration row_sum_affine
+    %t33 = load_input "batch" :: array
+    %t87 = const 2.0 :: float
+    %t90 = load_input "global_offset" :: float
+    %t91 = const 1.0 :: float
+    %t92 = call core.add(%t90, %t91) :: float
+    loop batch id=L7 in %t33 as el=%batch_el_34, idx=%batch_i_35
+      %t36 = load_field batch_el_34["row"] :: any
+      %t93 = load_field batch_el_34["mean"] :: float
+      %t94 = call core.add(%t93, %t92) :: float
+      loop row id=L8 in %t36 as el=%row_el_37, idx=%row_i_38
+        %acc_39 = decl_acc :: float
+        %t40 = load_field row_el_37["col"] :: any
+        %t86 = load_field row_el_37["scale"] :: float
+        %t88 = call core.mul(%t86, %t87) :: float
+        loop col id=L9 in %t40 as el=%col_el_41, idx=%col_i_42
+          %t69 = load_field col_el_41["val"] :: float
+          %t71 = call core.mul(%t69, %t88) :: float
+          %t73 = call core.add(%t71, %t94) :: float
+          %acc_39 = acc_add agg.sum(%acc_39, %t73) :: float
+        end_loop
+        %t44 = acc_load %acc_39 :: float
+        yield %t44
+      end_loop
+    end_loop
+  )
+  (Declaration batch_total_affine
+    %t45 = load_input "batch" :: array
+    %t110 = load_input "global_offset" :: float
+    %t111 = const 1.0 :: float
+    %t101 = const 2.0 :: float
+    %t112 = call core.add(%t110, %t111) :: float
+    loop batch id=L10 in %t45 as el=%batch_el_46, idx=%batch_i_47
+      %acc_48 = decl_acc :: float
+      %t49 = load_field batch_el_46["row"] :: any
+      %t105 = load_field batch_el_46["mean"] :: float
+      %t106 = call core.add(%t105, %t112) :: float
+      loop row id=L11 in %t49 as el=%row_el_50, idx=%row_i_51
+        %acc77 = decl_acc :: float
+        %t78 = load_field row_el_50["col"] :: any
+        %t100 = load_field row_el_50["scale"] :: float
+        %t102 = call core.mul(%t100, %t101) :: float
+        loop col id=L12 in %t78 as el=%col_el_41, idx=%col_i_42
+          %t107 = load_field col_el_41["val"] :: float
+          %t108 = call core.mul(%t107, %t102) :: float
+          %t109 = call core.add(%t108, %t106) :: float
+          %acc77 = acc_add agg.sum(%acc77, %t109) :: float
+        end_loop
+        %t80 = acc_load %acc77 :: float
+        %acc_48 = acc_add agg.sum(%acc_48, %t80) :: float
+      end_loop
+      %t53 = acc_load %acc_48 :: float
+      yield %t53
+    end_loop
+  )
+)

data/golden/multirank_hoisting/expected/nast.txt

@@ -0,0 +1,39 @@
+(NAST
+  (VALUE global_offset_plus
+    (Call :"core.add"
+    (InputRef [:global_offset])
+    (Const 1.0)
+  )
+  )
+  (VALUE batch_bias
+    (Call :"core.add"
+    (InputRef [:batch, :b, :mean])
+    (Ref global_offset_plus)
+  )
+  )
+  (VALUE row_scale2
+    (Call :"core.mul"
+    (InputRef [:batch, :b, :row, :r, :scale])
+    (Const 2.0)
+  )
+  )
+  (VALUE elem_affine
+    (Call :"core.add"
+    (Call :"core.mul"
+      (InputRef [:batch, :b, :row, :r, :col, :c, :val])
+      (Ref row_scale2)
+    )
+    (Ref batch_bias)
+  )
+  )
+  (VALUE row_sum_affine
+    (Call :"agg.sum"
+    (Ref elem_affine)
+  )
+  )
+  (VALUE batch_total_affine
+    (Call :"agg.sum"
+    (Ref row_sum_affine)
+  )
+  )
+)

data/golden/multirank_hoisting/expected/schema_javascript.mjs

@@ -0,0 +1,128 @@
+export function _global_offset_plus(input) {
+  let t1 = input["global_offset"];
+  const t2 = 1.0;
+  let t3 = t1 + t2;
+  return t3;
+}
+
+export function _batch_bias(input) {
+  let out = [];
+  let t4 = input["batch"];
+  let t54 = input["global_offset"];
+  const t55 = 1.0;
+  let t56 = t54 + t55;
+  t4.forEach((batch_el_5, batch_i_6) => {
+    let t7 = batch_el_5["mean"];
+    let t9 = t7 + t56;
+    out.push(t9);
+  });
+  return out;
+}
+
+export function _row_scale2(input) {
+  let out = [];
+  let t10 = input["batch"];
+  const t17 = 2.0;
+  t10.forEach((batch_el_11, batch_i_12) => {
+    let out_1 = [];
+    let t13 = batch_el_11["row"];
+    t13.forEach((row_el_14, row_i_15) => {
+      let t16 = row_el_14["scale"];
+      let t18 = t16 * t17;
+      out_1.push(t18);
+    });
+    out.push(out_1);
+  });
+  return out;
+}
+
+export function _elem_affine(input) {
+  let out = [];
+  let t19 = input["batch"];
+  let t81 = input["global_offset"];
+  const t82 = 1.0;
+  const t60 = 2.0;
+  let t83 = t81 + t82;
+  t19.forEach((batch_el_20, batch_i_21) => {
+    let out_1 = [];
+    let t22 = batch_el_20["row"];
+    let t64 = batch_el_20["mean"];
+    let t65 = t64 + t83;
+    t22.forEach((row_el_23, row_i_24) => {
+      let out_2 = [];
+      let t25 = row_el_23["col"];
+      let t59 = row_el_23["scale"];
+      let t61 = t59 * t60;
+      t25.forEach((col_el_26, col_i_27) => {
+        let t28 = col_el_26["val"];
+        let t30 = t28 * t61;
+        let t32 = t30 + t65;
+        out_2.push(t32);
+      });
+      out_1.push(out_2);
+    });
+    out.push(out_1);
+  });
+  return out;
+}
+
+export function _row_sum_affine(input) {
+  let out = [];
+  let t33 = input["batch"];
+  const t87 = 2.0;
+  let t90 = input["global_offset"];
+  const t91 = 1.0;
+  let t92 = t90 + t91;
+  t33.forEach((batch_el_34, batch_i_35) => {
+    let out_1 = [];
+    let t36 = batch_el_34["row"];
+    let t93 = batch_el_34["mean"];
+    let t94 = t93 + t92;
+    t36.forEach((row_el_37, row_i_38) => {
+      let acc_39 = 0.0;
+      let t40 = row_el_37["col"];
+      let t86 = row_el_37["scale"];
+      let t88 = t86 * t87;
+      t40.forEach((col_el_41, col_i_42) => {
+        let t69 = col_el_41["val"];
+        let t71 = t69 * t88;
+        let t73 = t71 + t94;
+        acc_39 += t73;
+      });
+      out_1.push(acc_39);
+    });
+    out.push(out_1);
+  });
+  return out;
+}
+
+export function _batch_total_affine(input) {
+  let out = [];
+  let t45 = input["batch"];
+  let t110 = input["global_offset"];
+  const t111 = 1.0;
+  const t101 = 2.0;
+  let t112 = t110 + t111;
+  t45.forEach((batch_el_46, batch_i_47) => {
+    let acc_48 = 0.0;
+    let t49 = batch_el_46["row"];
+    let t105 = batch_el_46["mean"];
+    let t106 = t105 + t112;
+    t49.forEach((row_el_50, row_i_51) => {
+      let acc77 = 0.0;
+      let t78 = row_el_50["col"];
+      let t100 = row_el_50["scale"];
+      let t102 = t100 * t101;
+      t78.forEach((col_el_41, col_i_42) => {
+        let t107 = col_el_41["val"];
+        let t108 = t107 * t102;
+        let t109 = t108 + t106;
+        acc77 += t109;
+      });
+      acc_48 += acc77;
+    });
+    out.push(acc_48);
+  });
+  return out;
+}
+

data/golden/multirank_hoisting/expected/schema_ruby.rb

@@ -0,0 +1,162 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_871501c6e1786defd4537fee6faface2ada1916adf1b700898c08ee292662c42
+  def self.from(input_data = nil)
+    instance = Object.new
+    instance.extend(self)
+    instance.instance_variable_set(:@input, input_data)
+    instance
+  end
+
+  def self.__kumi_executable__
+    instance = Object.new
+    instance.extend(self)
+    instance
+  end
+
+  def update(input_data)
+    @input = @input.merge(input_data)
+    self
+  end
+
+  def [](name)
+    case name
+    when :global_offset_plus then _global_offset_plus
+    when :batch_bias then _batch_bias
+    when :row_scale2 then _row_scale2
+    when :elem_affine then _elem_affine
+    when :row_sum_affine then _row_sum_affine
+    when :batch_total_affine then _batch_total_affine
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _global_offset_plus(input = @input)
+    t1 = input["global_offset"] || input[:global_offset]
+    t2 = 1.0
+    t1 + t2
+  end
+
+  def _batch_bias(input = @input)
+    out = []
+    t4 = input["batch"] || input[:batch]
+    t54 = input["global_offset"] || input[:global_offset]
+    t55 = 1.0
+    t56 = t54 + t55
+    t4.each_with_index do |batch_el_5, batch_i_6|
+      t7 = batch_el_5["mean"] || batch_el_5[:mean]
+      t9 = t7 + t56
+      out << t9
+    end
+    out
+  end
+
+  def _row_scale2(input = @input)
+    out = []
+    t10 = input["batch"] || input[:batch]
+    t17 = 2.0
+    t10.each_with_index do |batch_el_11, batch_i_12|
+      out_1 = []
+      t13 = batch_el_11["row"] || batch_el_11[:row]
+      t13.each_with_index do |row_el_14, row_i_15|
+        t16 = row_el_14["scale"] || row_el_14[:scale]
+        t18 = t16 * t17
+        out_1 << t18
+      end
+      out << out_1
+    end
+    out
+  end
+
+  def _elem_affine(input = @input)
+    out = []
+    t19 = input["batch"] || input[:batch]
+    t81 = input["global_offset"] || input[:global_offset]
+    t82 = 1.0
+    t60 = 2.0
+    t83 = t81 + t82
+    t19.each_with_index do |batch_el_20, batch_i_21|
+      out_1 = []
+      t22 = batch_el_20["row"] || batch_el_20[:row]
+      t64 = batch_el_20["mean"] || batch_el_20[:mean]
+      t65 = t64 + t83
+      t22.each_with_index do |row_el_23, row_i_24|
+        out_2 = []
+        t25 = row_el_23["col"] || row_el_23[:col]
+        t59 = row_el_23["scale"] || row_el_23[:scale]
+        t61 = t59 * t60
+        t25.each_with_index do |col_el_26, col_i_27|
+          t28 = col_el_26["val"] || col_el_26[:val]
+          t30 = t28 * t61
+          t32 = t30 + t65
+          out_2 << t32
+        end
+        out_1 << out_2
+      end
+      out << out_1
+    end
+    out
+  end
+
+  def _row_sum_affine(input = @input)
+    out = []
+    t33 = input["batch"] || input[:batch]
+    t87 = 2.0
+    t90 = input["global_offset"] || input[:global_offset]
+    t91 = 1.0
+    t92 = t90 + t91
+    t33.each_with_index do |batch_el_34, batch_i_35|
+      out_1 = []
+      t36 = batch_el_34["row"] || batch_el_34[:row]
+      t93 = batch_el_34["mean"] || batch_el_34[:mean]
+      t94 = t93 + t92
+      t36.each_with_index do |row_el_37, row_i_38|
+        acc_39 = 0.0
+        t40 = row_el_37["col"] || row_el_37[:col]
+        t86 = row_el_37["scale"] || row_el_37[:scale]
+        t88 = t86 * t87
+        t40.each_with_index do |col_el_41, col_i_42|
+          t69 = col_el_41["val"] || col_el_41[:val]
+          t71 = t69 * t88
+          t73 = t71 + t94
+          acc_39 += t73
+        end
+        t44 = acc_39
+        out_1 << t44
+      end
+      out << out_1
+    end
+    out
+  end
+
+  def _batch_total_affine(input = @input)
+    out = []
+    t45 = input["batch"] || input[:batch]
+    t110 = input["global_offset"] || input[:global_offset]
+    t111 = 1.0
+    t101 = 2.0
+    t112 = t110 + t111
+    t45.each_with_index do |batch_el_46, batch_i_47|
+      acc_48 = 0.0
+      t49 = batch_el_46["row"] || batch_el_46[:row]
+      t105 = batch_el_46["mean"] || batch_el_46[:mean]
+      t106 = t105 + t112
+      t49.each_with_index do |row_el_50, row_i_51|
+        acc77 = 0.0
+        t78 = row_el_50["col"] || row_el_50[:col]
+        t100 = row_el_50["scale"] || row_el_50[:scale]
+        t102 = t100 * t101
+        t78.each_with_index do |col_el_41, col_i_42|
+          t107 = col_el_41["val"] || col_el_41[:val]
+          t108 = t107 * t102
+          t109 = t108 + t106
+          acc77 += t109
+        end
+        t80 = acc77
+        acc_48 += t80
+      end
+      t53 = acc_48
+      out << t53
+    end
+    out
+  end
+end

data/golden/multirank_hoisting/expected/snast.txt

@@ -0,0 +1,39 @@
+(SNAST
+  (VALUE global_offset_plus
+    (Call :core.add
+      (InputRef global_offset key_chain=[]) :: [] -> float
+      (Const 1.0) :: [] -> float
+    ) :: [] -> float
+  ) :: [] -> float
+  (VALUE batch_bias
+    (Call :core.add
+      (InputRef batch.b.mean key_chain=[]) :: [batch] -> float
+      (Ref global_offset_plus) :: [] -> float
+    ) :: [batch] -> float
+  ) :: [batch] -> float
+  (VALUE row_scale2
+    (Call :core.mul
+      (InputRef batch.b.row.r.scale key_chain=[]) :: [batch, row] -> float
+      (Const 2.0) :: [] -> float
+    ) :: [batch, row] -> float
+  ) :: [batch, row] -> float
+  (VALUE elem_affine
+    (Call :core.add
+      (Call :core.mul
+        (InputRef batch.b.row.r.col.c.val key_chain=[]) :: [batch, row, col] -> float
+        (Ref row_scale2) :: [batch, row] -> float
+      ) :: [batch, row, col] -> float
+      (Ref batch_bias) :: [batch] -> float
+    ) :: [batch, row, col] -> float
+  ) :: [batch, row, col] -> float
+  (VALUE row_sum_affine
+    (Reduce :agg.sum over [col]
+      (Ref elem_affine) :: [batch, row, col] -> float
+    ) :: [batch, row] -> float
+  ) :: [batch, row] -> float
+  (VALUE batch_total_affine
+    (Reduce :agg.sum over [row]
+      (Ref row_sum_affine) :: [batch, row] -> float
+    ) :: [batch] -> float
+  ) :: [batch] -> float
+)

data/golden/multirank_hoisting/expected.json

@@ -0,0 +1,15 @@
+{
+    "global_offset_plus": 1.5,
+    "batch_bias": [11.5, 101.5],
+    "row_scale2": [[2.0, 1.0], [4.0]],
+    "elem_affine": [
+      [[13.5, 15.5], [14.5, 15.5, 16.5]],
+      [[107.5]]
+    ],
+    "row_sum_affine": [
+      [29.0, 46.5],
+      [107.5]
+    ],
+    "batch_total_affine": [75.5, 107.5]
+  }
+  

data/golden/multirank_hoisting/input.json

@@ -0,0 +1,19 @@
+{
+    "batch": [
+      {
+        "mean": 10.0,
+        "row": [
+          { "scale": 1.0, "col": [ { "val": 1.0 }, { "val": 2.0 } ] },
+          { "scale": 0.5, "col": [ { "val": 3.0 }, { "val": 4.0 }, { "val": 5.0 } ] }
+        ]
+      },
+      {
+        "mean": 100.0,
+        "row": [
+          { "scale": 2.0, "col": [ { "val": 1.5 } ] }
+        ]
+      }
+    ],
+    "global_offset": 0.5
+  }
+  

data/golden/multirank_hoisting/schema.kumi

@@ -0,0 +1,38 @@
+schema do
+  input do
+    array :batch do
+      hash :b do
+        float :mean
+        array :row do
+          hash :r do
+            float :scale
+            array :col do
+              hash :c do
+                float :val
+              end
+            end
+          end
+        end
+      end
+    end
+    float :global_offset
+  end
+
+  # Depth 0 ([])
+  value :global_offset_plus, input.global_offset + 1.0
+
+  # Depth 1 ([:batch]) — hoisted per batch
+  value :batch_bias, input.batch.b.mean + global_offset_plus
+
+  # Depth 2 ([:batch, :row]) — hoisted per (batch,row)
+  value :row_scale2, input.batch.b.row.r.scale * 2.0
+
+  # Depth 3 ([:batch, :row, :col]) — uses both hoisted values
+  value :elem_affine, input.batch.b.row.r.col.c.val * row_scale2 + batch_bias
+
+  # Reduce col → rank-2 ([:batch, :row])
+  value :row_sum_affine, fn(:sum, elem_affine)
+
+  # Reduce row → rank-1 ([:batch])
+  value :batch_total_affine, fn(:sum, row_sum_affine)
+end

data/golden/nested_hash/expected/ast.txt

@@ -0,0 +1,22 @@
+(Root
+  inputs: [
+    (InputDeclaration :x :hash
+      [
+        (InputDeclaration :y :hash
+          [
+            (InputDeclaration :z :integer)
+          ]
+        )
+      ]
+    )
+  ]
+  values: [
+    (ValueDeclaration :double
+      (CallExpression :multiply
+        (InputElementReference x.y.z)
+        (Literal 2)
+      )
+    )
+  ]
+  traits: []
+)

data/golden/nested_hash/expected/input_plan.txt

@@ -0,0 +1,5 @@
+x: hash (hash)
+  └─> y: property_access
+  y: hash (hash)
+    └─> z: property_access
+    z: integer