kumi 0.0.25 → 0.0.26

data/docs/UNSAT_DETECTION.md

@@ -0,0 +1,83 @@
+# UNSAT Detection & Constraint Analysis
+
+Kumi includes static analysis to detect **unsatisfiable constraints**—impossible conditions that can never be true given input domains.
+
+## How It Works
+
+### Direct Contradictions
+Kumi detects when the same variable is constrained to multiple different values:
+
+```ruby
+schema do
+  input { integer :x }
+
+  # ✓ Detected as UNSAT: x cannot be both 5 and 10
+  trait :impossible, fn(:and, input.x == 5, input.x == 10)
+end
+```
+
+### Domain Violations
+Kumi checks when constraints violate input domains:
+
+```ruby
+schema do
+  input { integer :age, domain: 0..150 }
+
+  # ✓ Detected as UNSAT: age can never be 200
+  trait :impossible_age, input.age == 200
+end
+```
+
+### Constraint Propagation (Phase 2)
+Kumi propagates constraints through operations to detect derived impossibilities:
+
+```ruby
+schema do
+  input { integer :x, domain: 0..10 }
+
+  value :doubled, fn(:mul, input.x, 2)  # doubled ∈ [0, 20]
+
+  # ✓ Detected as UNSAT: doubled can never be 50
+  trait :impossible_doubled, doubled == 50
+end
+```
+
+**Reverse propagation** derives input constraints from output constraints:
+
+```ruby
+schema do
+  input { integer :x, domain: 0..10 }
+
+  value :result, fn(:add, input.x, 100)  # result ∈ [100, 110]
+
+  # ✓ Detected as UNSAT: result == 50 would require x == -50 (outside domain)
+  trait :impossible_result, result == 50
+end
+```
+
+## Error Messages
+
+Impossible constraints raise `Kumi::Core::Errors::SemanticError`:
+
+```
+conjunction `impossible_doubled` is impossible
+```
+
+This message appears at schema compilation time, catching bugs before execution.
+
+## When UNSAT Detection Runs
+
+UNSAT detection is performed during the **HIR-to-LIR compilation phase**, after:
+- Function IDs are resolved
+- Type information is inferred
+- Dimensional metadata is computed
+
+This ensures detection has access to complete operation semantics.
+
+## Future Enhancements
+
+- **Multi-level propagation**: Chain constraints through multiple operations
+- **Inequality constraints**: Handle `<`, `>`, `<=`, `>=` constraints
+- **Combined constraints**: Detect contradictions across multiple traits
+
+See `spec/integration/unsat_with_propagation_spec.rb` for examples and pending tests.

data/golden/array_element/expected/nast.txt

@@ -1,6 +1,6 @@
 (NAST
   (VALUE v_sum_y
-    (Call :"agg.sum"
+    (Call :sum
     (InputRef [:x, :y, :v])
   )
   )

data/golden/array_element/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_9728a32b2ef1c73739b44f006d54b23230821bda76275eb804cd9ec4c91c3089
+module Kumi::Compiled::KUMI_1cd98cf56c50f763cab5055e1275d07ac58aaee708cbd081d7773ac43c8d9d33
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/array_index/expected/nast.txt

@@ -1,12 +1,12 @@
 (NAST
   (VALUE W
-    (Call :"core.array_size"
+    (Call :array_size
     (InputRef [:x, :y])
   )
   )
   (VALUE box
-    (Call :"core.add"
-    (Call :"core.mul"
+    (Call :add
+    (Call :multiply
       #<struct Kumi::Core::NAST::IndexRef id=83, loc=nil, meta={}>
       (Ref W)
     )
@@ -14,10 +14,10 @@
   )
   )
   (VALUE col_major
-    (Call :"core.add"
-    (Call :"core.mul"
+    (Call :add
+    (Call :multiply
       #<struct Kumi::Core::NAST::IndexRef id=91, loc=nil, meta={}>
-      (Call :"core.array_size"
+      (Call :array_size
         (InputRef [:x])
       )
     )
@@ -25,7 +25,7 @@
   )
   )
   (VALUE sum_ij
-    (Call :"core.add"
+    (Call :add
     #<struct Kumi::Core::NAST::IndexRef id=100, loc=nil, meta={}>
     #<struct Kumi::Core::NAST::IndexRef id=102, loc=nil, meta={}>
   )

data/golden/array_index/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_b0b7f061a7a0eedb52d282a806e7e102921f6ab3042667bd6fc6fc7f3a1018e2
+module Kumi::Compiled::KUMI_f0ed06608ce6a4d5050abd38d6642055bd22c10f7ed1ba5c5b32a1c61c78736d
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/array_operations/expected/nast.txt

@@ -1,12 +1,12 @@
 (NAST
   (VALUE subtotals
-    (Call :"core.mul"
+    (Call :multiply
     (InputRef [:items, :item, :price])
     (InputRef [:items, :item, :quantity])
   )
   )
   (VALUE discounted_price
-    (Call :"core.mul"
+    (Call :multiply
     (InputRef [:items, :item, :price])
     (Const 0.9)
   )

data/golden/array_operations/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_f6e8984aaae6be8cee0041865907ace29c189473e461ccf9db4a6bec97465dab
+module Kumi::Compiled::KUMI_98624b0772f11031b22df384c3c7f33db6dd17485e3f9cf2f69c17ad1d79a9d9
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/array_operations/expected/snast.txt

@@ -11,19 +11,19 @@
       (Const 0.9) :: [] -> float
     ) :: [items] -> float
   ) :: [items] -> float
-  (TRAIT is_valid_quantity
+  (VALUE is_valid_quantity
     (Call :core.gt
       (InputRef items.item.quantity key_chain=[]) :: [items] -> integer
       (Const 0) :: [] -> integer
     ) :: [items] -> boolean
   ) :: [items] -> boolean
-  (TRAIT expensive_items
+  (VALUE expensive_items
     (Call :core.gt
       (InputRef items.item.price key_chain=[]) :: [items] -> float
       (Const 100.0) :: [] -> float
     ) :: [items] -> boolean
   ) :: [items] -> boolean
-  (TRAIT electronics
+  (VALUE electronics
     (Call :core.eq
       (InputRef items.item.category key_chain=[]) :: [items] -> string
       (Const "electronics") :: [] -> string

data/golden/cascade_logic/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_68bc018c477a94cdfe07ac690bfacdebc9208a590b464f22d499aee7aafafd19
+module Kumi::Compiled::KUMI_a359b484890e040a5fdd419b92800fddad006edffc49f277f28525eef4e3d9bd
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/cascade_logic/expected/snast.txt

@@ -1,11 +1,11 @@
 (SNAST
-  (TRAIT y_positive
+  (VALUE y_positive
     (Call :core.gt
       (InputRef y key_chain=[]) :: [] -> integer
       (Const 0) :: [] -> integer
     ) :: [] -> boolean
   ) :: [] -> boolean
-  (TRAIT x_positive
+  (VALUE x_positive
     (Call :core.gt
       (InputRef x key_chain=[]) :: [] -> integer
       (Const 0) :: [] -> integer

data/golden/chained_fusion/expected/nast.txt

@@ -1,6 +1,6 @@
 (NAST
   (VALUE total_payroll
-    (Call :"agg.sum"
+    (Call :sum
     (InputRef [:departments, :dept, :employees, :emp, :salary])
   )
   )
@@ -29,7 +29,7 @@
   )
   )
   (VALUE max_salary
-    (Call :"agg.max"
+    (Call :max
     (InputRef [:departments, :dept, :employees, :emp, :salary])
   )
   )

data/golden/chained_fusion/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_d345f8b5098b438aa322a7ee8d0a4d26f7c84aa9e453db79a0466b672d60fe36
+module Kumi::Compiled::KUMI_e5b30cb23c39d5d7959274f41cf2d6a7e4ec0016dc7e19c0bef5c08d67ee1933
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/element_arrays/expected/nast.txt

@@ -27,8 +27,8 @@
   )
   )
   (VALUE count_over_limit
-    (Call :"agg.sum"
-    (Call :"agg.sum"
+    (Call :sum
+    (Call :sum
       (Call :sum
         (Call :__select__
           (Ref cell_over_limit)

data/golden/element_arrays/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_2861f5d1d1e2c819036f9450880c9c966a10cf904bae70971a4845415ebaacf9
+module Kumi::Compiled::KUMI_a2c21afb35a86d67d51bfe12d6bb29d2ef5886500b42431cad974924e3677fa3
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/element_arrays/expected/snast.txt

@@ -11,7 +11,7 @@
   (VALUE cell
     (InputRef cube.layer.row.cell key_chain=[]) :: [cube, layer, row] -> integer
   ) :: [cube, layer, row] -> integer
-  (TRAIT cell_over_limit
+  (VALUE cell_over_limit
     (Call :core.gt
       (InputRef cube.layer.row.cell key_chain=[]) :: [cube, layer, row] -> integer
       (Const 100) :: [] -> integer

data/golden/empty_and_null_inputs/expected/nast.txt

@@ -1,16 +1,16 @@
 (NAST
   (VALUE regional_sales
-    (Call :"agg.sum"
+    (Call :sum
     (InputRef [:regions, :region, :sales, :sale, :amount])
   )
   )
   (VALUE total_sales
-    (Call :"agg.sum"
+    (Call :sum
     (Ref regional_sales)
   )
   )
   (VALUE adjusted_total
-    (Call :"core.add"
+    (Call :add
     (Ref total_sales)
     (InputRef [:adjustment])
   )

data/golden/empty_and_null_inputs/expected/schema_ruby.rb

@@ -1,5 +1,5 @@
 # Autogenerated by Kumi Codegen
-module Kumi::Compiled::KUMI_948ef2383d338bae98f165855c5c82984da1d3f936bcaca00b80221e19f34c6a
+module Kumi::Compiled::KUMI_ad6e7ee5524d611f2ec03728b7e9f8c097e1308dbaf49da390610067b59c4145
   def self.from(input_data = nil)
     instance = Object.new
     instance.extend(self)

data/golden/function_overload/expected/ast.txt

@@ -0,0 +1,29 @@
+(Root
+  inputs: [
+    (InputDeclaration :name :string)
+    (InputDeclaration :items :array
+      [
+        (InputDeclaration :value :integer)
+      ]
+    )
+  ]
+  values: [
+    (ValueDeclaration :name_len
+      (CallExpression :size
+        (InputReference :name)
+      )
+    )
+    (ValueDeclaration :items_count
+      (CallExpression :size
+        (InputReference :items)
+      )
+    )
+    (ValueDeclaration :summary
+      (HashExpression
+        ((Literal :name_length) (DeclarationReference :name_len))
+        ((Literal :item_count) (DeclarationReference :items_count))
+      )
+    )
+  ]
+  traits: []
+)

data/golden/function_overload/expected/input_plan.txt

@@ -0,0 +1,4 @@
+name: string
+items: array (array) access_mode=element
+  └─> value: element_access
+  value: integer

data/golden/function_overload/expected/lir_00_unoptimized.txt

@@ -0,0 +1,18 @@
+(LIR
+  (Declaration name_len
+    %t1 = load_input "name" :: string
+    %t2 = call core.length(%t1) :: integer
+    yield %t2
+  )
+  (Declaration items_count
+    %t3 = load_input "items" :: array
+    %t4 = call core.array_size(%t3) :: integer
+    yield %t4
+  )
+  (Declaration summary
+    %t5 = load_decl name_len :: integer
+    %t6 = load_decl items_count :: integer
+    %t7 = make_object{name_length: %t5, item_count: %t6} :: object
+    yield %t7
+  )
+)

data/golden/function_overload/expected/lir_01_hoist_scalar_references.txt

@@ -0,0 +1,18 @@
+(LIR
+  (Declaration name_len
+    %t1 = load_input "name" :: string
+    %t2 = call core.length(%t1) :: integer
+    yield %t2
+  )
+  (Declaration items_count
+    %t3 = load_input "items" :: array
+    %t4 = call core.array_size(%t3) :: integer
+    yield %t4
+  )
+  (Declaration summary
+    %t5 = load_decl name_len :: integer
+    %t6 = load_decl items_count :: integer
+    %t7 = make_object{name_length: %t5, item_count: %t6} :: object
+    yield %t7
+  )
+)

data/golden/function_overload/expected/lir_02_inlined.txt

@@ -0,0 +1,20 @@
+(LIR
+  (Declaration name_len
+    %t1 = load_input "name" :: string
+    %t2 = call core.length(%t1) :: integer
+    yield %t2
+  )
+  (Declaration items_count
+    %t3 = load_input "items" :: array
+    %t4 = call core.array_size(%t3) :: integer
+    yield %t4
+  )
+  (Declaration summary
+    %t8 = load_input "name" :: string
+    %t9 = call core.length(%t8) :: integer
+    %t10 = load_input "items" :: array
+    %t11 = call core.array_size(%t10) :: integer
+    %t7 = make_object{name_length: %t9, item_count: %t11} :: object
+    yield %t7
+  )
+)

data/golden/function_overload/expected/lir_03_cse.txt

@@ -0,0 +1,20 @@
+(LIR
+  (Declaration name_len
+    %t1 = load_input "name" :: string
+    %t2 = call core.length(%t1) :: integer
+    yield %t2
+  )
+  (Declaration items_count
+    %t3 = load_input "items" :: array
+    %t4 = call core.array_size(%t3) :: integer
+    yield %t4
+  )
+  (Declaration summary
+    %t8 = load_input "name" :: string
+    %t9 = call core.length(%t8) :: integer
+    %t10 = load_input "items" :: array
+    %t11 = call core.array_size(%t10) :: integer
+    %t7 = make_object{name_length: %t9, item_count: %t11} :: object
+    yield %t7
+  )
+)

data/golden/function_overload/expected/lir_04_1_loop_fusion.txt

@@ -0,0 +1,20 @@
+(LIR
+  (Declaration name_len
+    %t1 = load_input "name" :: string
+    %t2 = call core.length(%t1) :: integer
+    yield %t2
+  )
+  (Declaration items_count
+    %t3 = load_input "items" :: array
+    %t4 = call core.array_size(%t3) :: integer
+    yield %t4
+  )
+  (Declaration summary
+    %t8 = load_input "name" :: string
+    %t9 = call core.length(%t8) :: integer
+    %t10 = load_input "items" :: array
+    %t11 = call core.array_size(%t10) :: integer
+    %t7 = make_object{name_length: %t9, item_count: %t11} :: object
+    yield %t7
+  )
+)

data/golden/function_overload/expected/lir_04_loop_invcm.txt

@@ -0,0 +1,20 @@
+(LIR
+  (Declaration name_len
+    %t1 = load_input "name" :: string
+    %t2 = call core.length(%t1) :: integer
+    yield %t2
+  )
+  (Declaration items_count
+    %t3 = load_input "items" :: array
+    %t4 = call core.array_size(%t3) :: integer
+    yield %t4
+  )
+  (Declaration summary
+    %t8 = load_input "name" :: string
+    %t9 = call core.length(%t8) :: integer
+    %t10 = load_input "items" :: array
+    %t11 = call core.array_size(%t10) :: integer
+    %t7 = make_object{name_length: %t9, item_count: %t11} :: object
+    yield %t7
+  )
+)

data/golden/function_overload/expected/lir_06_const_prop.txt

@@ -0,0 +1,20 @@
+(LIR
+  (Declaration name_len
+    %t1 = load_input "name" :: string
+    %t2 = call core.length(%t1) :: integer
+    yield %t2
+  )
+  (Declaration items_count
+    %t3 = load_input "items" :: array
+    %t4 = call core.array_size(%t3) :: integer
+    yield %t4
+  )
+  (Declaration summary
+    %t8 = load_input "name" :: string
+    %t9 = call core.length(%t8) :: integer
+    %t10 = load_input "items" :: array
+    %t11 = call core.array_size(%t10) :: integer
+    %t7 = make_object{name_length: %t9, item_count: %t11} :: object
+    yield %t7
+  )
+)

data/golden/function_overload/expected/nast.txt

@@ -0,0 +1,22 @@
+(NAST
+  (VALUE name_len
+    (Call :size
+    (InputRef [:name])
+  )
+  )
+  (VALUE items_count
+    (Call :size
+    (InputRef [:items])
+  )
+  )
+  (VALUE summary
+    (Hash
+    (Pair name_length 
+      (Ref name_len)
+    )
+    (Pair item_count 
+      (Ref items_count)
+    )
+  )
+  )
+)

data/golden/function_overload/expected/schema_javascript.mjs

@@ -0,0 +1,12 @@
+export function _summary(input) {
+  let t8 = input["name"];
+  let t9 = t8.length;
+  let t10 = input["items"];
+  let t11 = t10.length;
+  let t7 = {
+    "name_length": t9,
+    "item_count": t11
+  };
+  return t7;
+}
+

data/golden/function_overload/expected/schema_ruby.rb

@@ -0,0 +1,39 @@
+# Autogenerated by Kumi Codegen
+module Kumi::Compiled::KUMI_fc278e6d9fc513388aad074ca6f0853cd6bfc39df05818173f50fb354060cd30
+  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 :summary then _summary
+    else raise KeyError, "Unknown declaration"
+    end
+  end
+
+  def _summary(input = @input)
+    t8 = input["name"] || input[:name]
+    t9 = t8.length
+    t10 = input["items"] || input[:items]
+    t11 = t10.length
+    t7 = {
+      "name_length" => t9,
+      "item_count" => t11
+    }
+    t7
+  end
+end

data/golden/function_overload/expected/snast.txt

@@ -0,0 +1,22 @@
+(SNAST
+  (VALUE name_len
+    (Call :core.length
+      (InputRef name key_chain=[]) :: [] -> string
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE items_count
+    (Call :core.array_size
+      (InputRef items key_chain=[]) :: [] -> array
+    ) :: [] -> integer
+  ) :: [] -> integer
+  (VALUE summary
+    (Hash
+      (Pair name_length
+        (Ref name_len) :: [] -> integer
+      ) :: [] -> pair
+      (Pair item_count
+        (Ref items_count) :: [] -> integer
+      ) :: [] -> pair
+    ) :: [] -> hash
+  ) :: [] -> hash
+)

data/golden/function_overload/input.json

@@ -0,0 +1,8 @@
+{
+  "name": "test",
+  "items": [
+    { "value": 1 },
+    { "value": 2 },
+    { "value": 3 }
+  ]
+}

data/golden/function_overload/schema.kumi

@@ -0,0 +1,19 @@
+schema do
+  input do
+    string :name
+    array :items do
+      integer :value
+    end
+  end
+
+  # Should resolve to core.length (string -> integer)
+  let :name_len, fn(:size, input.name)
+
+  # Should resolve to core.array_size (array -> integer)
+  let :items_count, fn(:size, input.items)
+
+  value :summary, {
+    name_length: name_len,
+    item_count: items_count
+  }
+end

data/golden/game_of_life/expected/lir_00_unoptimized.txt

@@ -267,8 +267,8 @@
         %t240 = load_decl ne axes=[rows, col] :: integer
         %t241 = load_decl sw axes=[rows, col] :: integer
         %t242 = load_decl se axes=[rows, col] :: integer
-        %t243 = make_tuple(%t235, %t236, %t237, %t238, %t239, %t240, %t241, %t242) :: tuple<integer>
-        %t244 = fold %t243 fn="agg.sum" :: 
+        %t243 = make_tuple(%t235, %t236, %t237, %t238, %t239, %t240, %t241, %t242) :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
+        %t244 = fold %t243 fn="agg.sum" :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
         yield %t244
       end_loop
     end_loop
@@ -288,7 +288,7 @@
     %t253 = load_input "rows" :: array
     loop rows id=L23 in %t253 as el=%rows_el_254, idx=%rows_i_255
       loop col id=L24 in %rows_el_254 as el=%col_el_256, idx=%col_i_257
-        %t258 = load_decl neighbors axes=[rows, col] :: 
+        %t258 = load_decl neighbors axes=[rows, col] :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
         %t259 = const 3 :: integer
         %t260 = call core.eq(%t258, %t259) :: boolean
         yield %t260
@@ -299,7 +299,7 @@
     %t261 = load_input "rows" :: array
     loop rows id=L25 in %t261 as el=%rows_el_262, idx=%rows_i_263
       loop col id=L26 in %rows_el_262 as el=%col_el_264, idx=%col_i_265
-        %t266 = load_decl neighbors axes=[rows, col] :: 
+        %t266 = load_decl neighbors axes=[rows, col] :: tuple<integer, integer, integer, integer, integer, integer, integer, integer>
         %t267 = const 2 :: integer
         %t268 = call core.eq(%t266, %t267) :: boolean
         yield %t268