kumi 0.0.24 → 0.0.26

data/lib/kumi/core/analyzer/passes/normalize_to_nast_pass.rb

@@ -75,14 +75,18 @@ module Kumi
 
           def normalize_call_expression(node, errors)
             begin
-              fn_name = FnAliases::MAP[node.fn_name] || node.fn_name
-              func = @registry.function(fn_name)
+              fn_alias = FnAliases::MAP[node.fn_name] || node.fn_name
+
+              # Try to get the function to check if it's expandable
+              # For expandable functions, we need to resolve now
+              # For regular functions, we defer resolution to NASTDimensionalAnalyzerPass
+              func = @registry.function(fn_alias) rescue nil
             rescue StandardError
               # puts "MISSING_FUNCTION: #{node.fn_name.inspect}"
               raise
             end
 
-            if func.expand
+            if func && func.expand
               # 1. Normalize the arguments FIRST.
               normalized_args = node.args.map { |arg| normalize_expr(arg, errors) }
 
@@ -91,8 +95,9 @@ module Kumi
               MacroExpander.expand(func, normalized_args, node.loc, errors)
             else
               # Regular, non-expandable function call.
+              # Keep the alias, don't resolve yet - let NASTDimensionalAnalyzerPass handle overload resolution
               args = node.args.map { |a| normalize_expr(a, errors) }
-              NAST::Call.new(fn: func.id.to_sym, args: args, opts: node.opts, loc: node.loc)
+              NAST::Call.new(fn: fn_alias.to_sym, args: args, opts: node.opts, loc: node.loc)
             end
           end
 

data/lib/kumi/core/analyzer/passes/snast_pass.rb

@@ -174,7 +174,9 @@ module Kumi
             # regular elementwise
             args = n.args.map { _1.accept(self) }
             m    = meta_for(n)
-            out  = n.class.new(id: n.id, fn: @registry.resolve_function(n.fn), args:, opts: n.opts, loc: n.loc)
+            # Use the function ID from metadata (already resolved with type awareness in NASTDimensionalAnalyzerPass)
+            fn_id = m[:function] || @registry.resolve_function(n.fn)
+            out  = n.class.new(id: n.id, fn: fn_id.to_sym, args:, opts: n.opts, loc: n.loc)
             stamp!(out, m[:result_scope], m[:result_type])
           end
 

data/lib/kumi/core/analyzer/passes/unsat_detector.rb

@@ -4,40 +4,41 @@ module Kumi
   module Core
     module Analyzer
       module Passes
-        # RESPONSIBILITY: Detect unsatisfiable constraints and analyze cascade mutual exclusion
-        # DEPENDENCIES: :declarations from NameIndexer, :input_metadata from InputCollector
+        # RESPONSIBILITY: Detect unsatisfiable constraints using formal constraint semantics
+        # DEPENDENCIES: :declarations, :input_metadata, :registry, SNAST representation
         # INTERFACE: new(schema, state).run(errors)
+        #
+        # Detects when constraints are clearly unsatisfiable using constraint propagation:
+        # 1. Same variable with contradicting equality values (v == 5 AND v == 10)
+        # 2. Values violating input domain constraints
+        # 3. Constraints derived through arithmetic operations that violate domains
         class UnsatDetector < VisitorPass
           include Syntax
 
           COMPARATORS = %i[> < >= <= == !=].freeze
-          Atom        = Kumi::Core::AtomUnsatSolver::Atom
 
           def run(errors)
-            return state
             definitions = get_state(:declarations)
-            @input_meta = get_state(:input_metadata) || {}
-            @definitions = definitions
-            @evaluator = UnsatConstantEvaluator.new(definitions)
+            input_meta = get_state(:input_metadata) || {}
+            registry = get_state(:registry)
+
+            @propagator = FormalConstraintPropagator.new(schema, state)
 
             each_decl do |decl|
-              if decl.expression.is_a?(CascadeExpression)
-                check_cascade_expression(decl, definitions, errors)
-              elsif decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
-                impossible = check_or_expression(decl.expression, definitions, errors)
-                report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
-              else
-                atoms = gather_atoms(decl.expression, definitions, Set.new)
-                next if atoms.empty?
-
-                result = if definitions && !definitions.empty?
-                           Kumi::Core::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
-                         else
-                           Kumi::Core::AtomUnsatSolver.unsat?(atoms)
-                         end
-                impossible = result
-
-                report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
+              # Only check trait declarations for obvious contradictions
+              next unless decl.is_a?(TraitDeclaration)
+
+              atoms = extract_equality_atoms(decl.expression, definitions)
+              next if atoms.empty?
+
+              # Check for formal, obvious contradictions
+              if contradicting_equalities?(atoms) || domain_violations?(atoms, input_meta) ||
+                 propagated_violations?(atoms, definitions, input_meta, registry)
+                report_error(
+                  errors,
+                  "conjunction `#{decl.name}` is impossible",
+                  location: decl.loc
+                )
               end
             end
 
@@ -46,221 +47,194 @@ module Kumi
 
           private
 
-          def check_or_expression(or_expr, definitions, _errors)
-            # For OR expressions: A | B is impossible only if BOTH A AND B are impossible
-            # If either side is satisfiable, the OR is satisfiable
-            left_side, right_side = or_expr.args
-
-            # Check if left side is impossible
-            left_atoms = gather_atoms(left_side, definitions, Set.new)
-            left_impossible = if left_atoms.empty?
-                                false
-                              elsif definitions && !definitions.empty?
-                                Kumi::Core::ConstraintRelationshipSolver.unsat?(left_atoms, definitions, input_meta: @input_meta)
-                              else
-                                Kumi::Core::AtomUnsatSolver.unsat?(left_atoms)
-                              end
-
-            # Check if right side is impossible
-            right_atoms = gather_atoms(right_side, definitions, Set.new)
-            right_impossible = if right_atoms.empty?
-                                 false
-                               elsif definitions && !definitions.empty?
-                                 Kumi::Core::ConstraintRelationshipSolver.unsat?(right_atoms, definitions, input_meta: @input_meta)
-                               else
-                                 Kumi::Core::AtomUnsatSolver.unsat?(right_atoms)
-                               end
-
-            # OR is impossible only if BOTH sides are impossible
-            left_impossible && right_impossible
-          end
-
-          def gather_atoms(node, defs, visited, list = [])
-            return list unless node
-
-            # Use iterative approach with stack to avoid SystemStackError on deep graphs
-            stack = [node]
+          # Extract equality constraints from expression
+          # Returns array of {op: :==, lhs: symbol, rhs: value} hashes
+          def extract_equality_atoms(expr, definitions)
+            atoms = []
+            stack = [expr]
+            visited = Set.new
 
             until stack.empty?
               current = stack.pop
               next unless current
 
-              if current.is_a?(CallExpression) && COMPARATORS.include?(current.fn_name)
-                lhs, rhs = current.args
-
-                list << if impossible_constraint?(lhs, rhs, current.fn_name)
-                          Atom.new(:==, :__impossible__, true)
-                        else
-                          Atom.new(current.fn_name, term(lhs, defs), term(rhs, defs))
-                        end
-              elsif current.is_a?(CallExpression) && current.fn_name == :or
-                next
-              elsif current.is_a?(CallExpression) && current.fn_name == :cascade_and
-                current.args.each { |arg| stack << arg }
-              elsif current.is_a?(ArrayExpression)
-                current.elements.each { |elem| stack << elem }
-              elsif current.is_a?(DeclarationReference)
-                name = current.name
-                unless visited.include?(name)
-                  visited << name
-                  stack << defs[name].expression if defs.key?(name)
+              case current
+              when CallExpression
+                if current.fn_name == :==
+                  lhs, rhs = current.args
+                  lhs_val = extract_term(lhs, definitions)
+                  rhs_val = extract_term(rhs, definitions)
+                  atoms << { op: :==, lhs: lhs_val, rhs: rhs_val } if lhs_val && rhs_val
+                elsif current.fn_name == :and
+                  current.args.each { |arg| stack << arg }
+                end
+              when DeclarationReference
+                unless visited.include?(current.name)
+                  visited << current.name
+                  stack << definitions[current.name]&.expression
                 end
               end
-
-              current.children.each { |child| stack << child } if current.respond_to?(:children) && !current.is_a?(CascadeExpression)
             end
 
-            list
+            atoms
           end
 
-          def check_cascade_expression(decl, definitions, errors)
-            # Analyze each cascade branch condition independently
-            # This is the correct behavior: each 'on' condition should be checked separately
-            # since only ONE will be evaluated at runtime (they're mutually exclusive by design)
-
-            # DEBUG: Add detailed logging for hierarchical broadcasting debugging
-            if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-              puts "DEBUG UNSAT CASCADE: Checking cascade '#{decl.name}' at #{decl.loc}"
-              puts "  Total cases: #{decl.expression.cases.length}"
+          # Extract value from AST node
+          # Returns symbol for variables, literal values for constants
+          def extract_term(node, definitions)
+            case node
+            when Literal
+              node.value
+            when DeclarationReference
+              val = evaluate_to_literal(node, definitions)
+              val == :unknown ? node.name : val
+            when InputReference
+              node.name
+            else
+              nil
             end
+          end
 
-            decl.expression.cases.each_with_index do |when_case, index|
-              if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                puts "  Case #{index}: condition=#{when_case.condition.inspect}"
-              end
+          # Try to evaluate a declaration to a literal constant
+          def evaluate_to_literal(decl_ref, definitions)
+            definition = definitions[decl_ref.name]
+            return :unknown unless definition&.expression.is_a?(Literal)
 
-              next if when_case.condition.is_a?(Literal) && when_case.condition.value == true
+            definition.expression.value
+          end
 
-              next if when_case.condition.is_a?(CallExpression) && %i[any? none?].include?(when_case.condition.fn_name)
+          # FORMAL RULE 1: Contradicting equalities
+          # IF: same_variable == value1 AND same_variable == value2 AND value1 != value2
+          # THEN: unsatisfiable
+          def contradicting_equalities?(atoms)
+            by_lhs = atoms.group_by { |a| a[:lhs] }
 
-              if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :cascade_and && (when_case.condition.args.size == 1)
-                next
-              end
+            by_lhs.each do |_lhs, constraints|
+              rhs_values = constraints.map { |c| c[:rhs] }.uniq
+              return true if rhs_values.size > 1
+            end
 
-              condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
+            false
+          end
 
-              if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                puts "    Condition atoms: #{condition_atoms.map(&:inspect)}"
-              end
+          # FORMAL RULE 2: Domain violations
+          # IF: variable is input field AND domain constraint exists AND value outside domain
+          # THEN: unsatisfiable
+          def domain_violations?(atoms, input_meta)
+            atoms.each do |atom|
+              variable = atom[:lhs]
+              value = atom[:rhs]
 
-              if definitions && !definitions.empty?
-                result = Kumi::Core::ConstraintRelationshipSolver.unsat?(condition_atoms, definitions, input_meta: @input_meta)
-                if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                  puts "    Enhanced solver result: #{result}"
-                end
-              else
-                result = Kumi::Core::AtomUnsatSolver.unsat?(condition_atoms)
-                if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                  puts "    Basic solver result: #{result}"
-                end
-              end
-              impossible = result
-              next unless !condition_atoms.empty? && impossible
-
-              if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :cascade_and
-                trait_bindings = when_case.condition.args
-
-                if trait_bindings.all?(DeclarationReference)
-                  traits = trait_bindings.map(&:name).join(" AND ")
-                  if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                    puts "    -> FLAGGING AS IMPOSSIBLE CASCADE CONDITION: #{traits}"
-                  end
-                  report_error(errors, "conjunction `#{traits}` is impossible", location: decl.loc)
-                  next
-                end
-              end
-              if ENV["DEBUG_UNSAT"] || decl.loc&.to_s&.include?("hierarchical_broadcasting_spec.rb:257")
-                puts "    -> FLAGGING AS IMPOSSIBLE CASCADE: #{decl.name}"
-              end
-              report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc)
-            end
-          end
+              next unless value.is_a?(Numeric)
 
-          def term(node, _defs)
-            case node
-            when InputReference, DeclarationReference
-              val = @evaluator.evaluate(node)
-              val == :unknown ? node.name : val
-            when InputElementReference
-              path_identifier = node.path.join(".").to_s
-              path_identifier.to_sym
-            when Literal
-              node.value
-            else
-              :unknown
+              metadata = input_meta[variable]
+              next unless metadata&.dig(:domain)
+
+              domain = metadata[:domain]
+              return true unless domain.include?(value)
             end
+
+            false
           end
 
-          def violates_domain?(value, domain)
-            case domain
-            when Range, Array
-              !domain.include?(value)
-            else
-              false
-            end
+          # FORMAL RULE 3: Propagated constraint violations
+          # Propagate constraints through operations to derive hidden impossibilities
+          def propagated_violations?(atoms, definitions, input_meta, registry)
+            propagated = propagate_constraints(atoms, definitions, registry)
+            return false if propagated.empty?
+
+            propagated_domain_violations?(propagated, input_meta)
           end
 
-          def impossible_constraint?(lhs, rhs, operator)
-            # Case 1: InputReference compared against value outside its domain
-            if lhs.is_a?(InputReference) && rhs.is_a?(Literal)
-              return field_literal_impossible?(lhs, rhs, operator)
-            elsif rhs.is_a?(InputReference) && lhs.is_a?(Literal)
-              return field_literal_impossible?(rhs, lhs, flip_operator(operator))
-            end
+          # Propagate constraints through operation definitions
+          def propagate_constraints(atoms, definitions, registry)
+            propagated = []
 
-            # Case 2: DeclarationReference that evaluates to literal compared against impossible value
-            if lhs.is_a?(DeclarationReference) && rhs.is_a?(Literal)
-              return binding_literal_impossible?(lhs, rhs, operator)
-            elsif rhs.is_a?(DeclarationReference) && lhs.is_a?(Literal)
-              return binding_literal_impossible?(rhs, lhs, flip_operator(operator))
+            atoms.each do |atom|
+              variable = atom[:lhs]
+              value = atom[:rhs]
+
+              next unless value.is_a?(Numeric)
+
+              definition = definitions[variable]
+              next unless definition&.is_a?(ValueDeclaration)
+
+              propagated.concat(propagate_through_operation(definition, variable, value, registry, definitions))
             end
 
-            false
+            propagated
           end
 
-          def field_literal_impossible?(field_ref, literal, operator)
-            field_meta = @input_meta[field_ref.name]
-            return false unless field_meta&.dig(:domain)
+          # Propagate a single constraint through an operation
+          def propagate_through_operation(decl, variable, value, registry, definitions)
+            expr = decl.expression
+            return [] unless expr.is_a?(CallExpression)
 
-            domain = field_meta[:domain]
-            literal_value = literal.value
+            fn_id = registry.resolve_function(expr.fn_name)
+            return [] unless fn_id
 
-            case operator
-            when :==
-              violates_domain?(literal_value, domain)
-            when :!=
-              false
-            else
-              false
-            end
+            operation = registry.function(fn_id)
+            return [] unless operation
+
+            operand_map = build_operand_map(expr, definitions)
+            constraint = { variable: variable, op: :==, value: value }
+
+            propagated_constraint = @propagator.propagate_reverse_through_operation(
+              constraint,
+              operation,
+              operand_map
+            )
+
+            propagated_constraint ? [propagated_constraint] : []
           end
 
-          def binding_literal_impossible?(binding, literal, operator)
-            # Check if binding evaluates to a literal that conflicts with the comparison
-            evaluated_value = @evaluator.evaluate(binding)
-            return false if evaluated_value == :unknown
+          # Build operand map for an operation expression
+          def build_operand_map(expr, definitions)
+            args = expr.args
+            map = {}
 
-            literal_value = literal.value
+            if args.size >= 2
+              left_val = extract_operand_value(args[0], definitions)
+              right_val = extract_operand_value(args[1], definitions)
 
-            case operator
-            when :==
-              evaluated_value != literal_value
-            else
-              false
+              map[:left_operand] = left_val
+              map[:right_operand] = right_val
             end
+
+            map
           end
 
-          def flip_operator(operator)
-            case operator
-            when :> then :<
-            when :>= then :<=
-            when :< then :>
-            when :<= then :>=
-            when :== then :==
-            when :!= then :!=
-            else operator
+          # Extract operand value (symbol for variable, numeric for constant)
+          def extract_operand_value(node, _definitions)
+            case node
+            when Literal
+              node.value
+            when DeclarationReference
+              node.name
+            when InputReference
+              node.name
             end
           end
+
+          # Check if propagated constraints violate input domain
+          def propagated_domain_violations?(propagated, input_meta)
+            propagated.each do |constraint|
+              next unless constraint[:op] == :==
+
+              variable = constraint[:variable]
+              value = constraint[:value]
+
+              next unless value.is_a?(Numeric)
+
+              metadata = input_meta[variable]
+              next unless metadata&.dig(:domain)
+
+              domain = metadata[:domain]
+              return true unless domain.include?(value)
+            end
+
+            false
+          end
         end
       end
     end

data/lib/kumi/core/error_reporter.rb

@@ -12,16 +12,51 @@ module Kumi
     # 4. Support both immediate raising and error accumulation patterns
     module ErrorReporter
       # Standard error structure for internal use
-      ErrorEntry = Struct.new(:location, :message, :type, :context, :backtrace, keyword_init: true) do
+      # Provides clean access to location components (file, line, column)
+      class ErrorEntry
+        attr_reader :location, :message, :type, :context, :backtrace
+
+        def initialize(location:, message:, type: :semantic, context: {}, backtrace: nil)
+          @location = location
+          @message = message
+          @type = type
+          @context = context
+          @backtrace = backtrace
+        end
+
         def to_s
           location_str = format_location(location)
           "#{location_str}: #{message}"
         end
 
+        # Check if location information is present
         def location?
           location && !location.is_a?(Symbol)
         end
 
+        # Extract location components cleanly
+        def file
+          location.is_a?(Syntax::Location) ? location.file : nil
+        end
+
+        def line
+          location.is_a?(Syntax::Location) ? location.line : nil
+        end
+
+        def column
+          location.is_a?(Syntax::Location) ? location.column : nil
+        end
+
+        # Alias for consistency
+        def path
+          file
+        end
+
+        # Check if location is valid (has file and line)
+        def valid_location?
+          !!(location? && file && line && line > 0)
+        end
+
         private
 
         def format_location(loc)

data/lib/kumi/core/errors.rb

@@ -13,9 +13,41 @@ module Kumi
           @location = location
         end
 
+        # Extract location components cleanly
+        def location_file
+          @location&.file
+        end
+
+        def location_line
+          @location&.line
+        end
+
+        def location_column
+          @location&.column
+        end
+
+        # Aliases for convenient access
+        alias path location_file
+        alias line location_line
+        alias column location_column
+
+        # Check if location information is present and valid
+        def has_location?
+          @location && @location.file && @location.line && @location.line > 0
+        end
+
+        # Format location for error messages
+        def format_location
+          if @location
+            "at #{@location.file}:#{@location.line}:#{@location.column}"
+          else
+            "at ?"
+          end
+        end
+
         def to_s
           if @location
-            "#{super} at #{@location.file}:#{@location.line}:#{@location.column}"
+            "#{super} #{format_location}"
           else
             super
           end

data/lib/kumi/core/functions/function_spec.rb

@@ -5,10 +5,11 @@ module Kumi
     module Functions
       # Minimal function specification for NAST dimensional analysis
       FunctionSpec = Struct.new(
-        :id,              # "core.add"
-        :kind,            # :elementwise, :reduce, :constructor
-        :parameter_names, # [:left_operand, :right_operand]
-        :dtype_rule,      # "promote(left_operand,right_operand)" or proc
+        :id,                       # "core.add"
+        :kind,                     # :elementwise, :reduce, :constructor
+        :parameter_names,          # [:left_operand, :right_operand]
+        :dtype_rule,               # "promote(left_operand,right_operand)" or proc
+        :constraint_semantics,     # formal constraint metadata (hash or nil)
         keyword_init: true
       )
     end

data/lib/kumi/core/functions/loader.rb

@@ -33,14 +33,30 @@ module Kumi
           function_kind = fn_hash.fetch("kind").to_sym
           parameter_names = (fn_hash["params"] || []).map { |p| p["name"].to_sym }
           dtype_rule_fn = TypeRules.compile_dtype_rule(fn_hash.fetch("dtype"), parameter_names)
+          constraint_semantics = parse_constraint_semantics(fn_hash["constraint_semantics"])
 
           Functions::FunctionSpec.new(
             id: function_id,
             kind: function_kind,
             parameter_names: parameter_names,
-            dtype_rule: dtype_rule_fn
+            dtype_rule: dtype_rule_fn,
+            constraint_semantics: constraint_semantics
           )
         end
+
+        def parse_constraint_semantics(semantics_hash)
+          return nil unless semantics_hash
+
+          {
+            domain_effect: semantics_hash["domain_effect"]&.to_sym,
+            pure_combiner: semantics_hash["pure_combiner"],
+            commutativity: semantics_hash["commutativity"],
+            associativity: semantics_hash["associativity"],
+            identity: semantics_hash["identity"],
+            forward_propagation: semantics_hash["forward_propagation"],
+            reverse_propagation: semantics_hash["reverse_propagation"]
+          }
+        end
       end
     end
   end