kumi 0.0.4 → 0.0.6

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

@@ -3,6 +3,10 @@
 module Kumi
   module Analyzer
     module Passes
+      # RESPONSIBILITY: Detect unsatisfiable constraints and analyze cascade mutual exclusion
+      # DEPENDENCIES: :definitions from NameIndexer, :input_meta from InputCollector
+      # PRODUCES: :cascade_metadata - Hash of cascade mutual exclusion analysis results
+      # INTERFACE: new(schema, state).run(errors)
       class UnsatDetector < VisitorPass
         include Syntax
 
@@ -11,24 +15,150 @@ module Kumi
 
         def run(errors)
           definitions = get_state(:definitions)
+          @input_meta = get_state(:input_meta) || {}
+          @definitions = definitions
           @evaluator = ConstantEvaluator.new(definitions)
 
+          # First pass: analyze cascade conditions for mutual exclusion
+          cascade_metadata = {}
+          each_decl do |decl|
+            cascade_metadata[decl.name] = analyze_cascade_mutual_exclusion(decl, definitions) if decl.expression.is_a?(CascadeExpression)
+          end
+
+          # Store cascade metadata for later passes
+
+          # Second pass: check for unsatisfiable constraints
           each_decl do |decl|
             if decl.expression.is_a?(CascadeExpression)
               # Special handling for cascade expressions
               check_cascade_expression(decl, definitions, errors)
+            elsif decl.expression.is_a?(CallExpression) && decl.expression.fn_name == :or
+              # Check for OR expressions which need special disjunctive handling
+              impossible = check_or_expression(decl.expression, definitions, errors)
+              report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
             else
               # Normal handling for non-cascade expressions
               atoms = gather_atoms(decl.expression, definitions, Set.new)
               next if atoms.empty?
 
-              add_error(errors, decl.loc, "conjunction `#{decl.name}` is impossible") if Kumi::AtomUnsatSolver.unsat?(atoms)
+              # Use enhanced solver that can detect cross-variable mathematical constraints
+              impossible = if definitions && !definitions.empty?
+                             Kumi::ConstraintRelationshipSolver.unsat?(atoms, definitions, input_meta: @input_meta)
+                           else
+                             Kumi::AtomUnsatSolver.unsat?(atoms)
+                           end
+
+              report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc) if impossible
             end
           end
+          state.with(:cascade_metadata, cascade_metadata)
         end
 
         private
 
+        def analyze_cascade_mutual_exclusion(decl, definitions)
+          conditions = []
+          condition_traits = []
+
+          # Extract all cascade conditions (except base case)
+          decl.expression.cases[0...-1].each do |when_case|
+            next unless when_case.condition
+
+            next unless when_case.condition.fn_name == :all?
+
+            when_case.condition.args.each do |arg|
+              next unless arg.is_a?(ArrayExpression)
+
+              arg.elements.each do |element|
+                next unless element.is_a?(DeclarationReference)
+
+                trait_name = element.name
+                trait = definitions[trait_name]
+                if trait
+                  conditions << trait.expression
+                  condition_traits << trait_name
+                end
+              end
+            end
+            # end
+          end
+
+          # Check mutual exclusion for all pairs
+          total_pairs = conditions.size * (conditions.size - 1) / 2
+          exclusive_pairs = 0
+
+          if conditions.size >= 2
+            conditions.combination(2).each do |cond1, cond2|
+              exclusive_pairs += 1 if conditions_mutually_exclusive?(cond1, cond2)
+            end
+          end
+
+          all_mutually_exclusive = (total_pairs > 0) && (exclusive_pairs == total_pairs)
+
+          {
+            condition_traits: condition_traits,
+            condition_count: conditions.size,
+            all_mutually_exclusive: all_mutually_exclusive,
+            exclusive_pairs: exclusive_pairs,
+            total_pairs: total_pairs
+          }
+        end
+
+        def conditions_mutually_exclusive?(cond1, cond2)
+          if cond1.is_a?(CallExpression) && cond1.fn_name == :== &&
+             cond2.is_a?(CallExpression) && cond2.fn_name == :==
+
+            c1_field, c1_value = cond1.args
+            c2_field, c2_value = cond2.args
+
+            # Same field, different values = mutually exclusive
+            return true if same_field?(c1_field, c2_field) && different_values?(c1_value, c2_value)
+          end
+
+          false
+        end
+
+        def same_field?(field1, field2)
+          return false unless field1.is_a?(InputReference) && field2.is_a?(InputReference)
+
+          field1.name == field2.name
+        end
+
+        def different_values?(val1, val2)
+          return false unless val1.is_a?(Literal) && val2.is_a?(Literal)
+
+          val1.value != val2.value
+        end
+
+        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::ConstraintRelationshipSolver.unsat?(left_atoms, definitions, input_meta: @input_meta)
+                            else
+                              Kumi::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::ConstraintRelationshipSolver.unsat?(right_atoms, definitions, input_meta: @input_meta)
+                             else
+                               Kumi::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
 
@@ -41,8 +171,26 @@ module Kumi
 
             if current.is_a?(CallExpression) && COMPARATORS.include?(current.fn_name)
               lhs, rhs = current.args
-              list << Atom.new(current.fn_name, term(lhs, defs), term(rhs, defs))
-            elsif current.is_a?(Binding)
+
+              # Check for domain constraint violations before creating atom
+              list << if impossible_constraint?(lhs, rhs, current.fn_name)
+                        # Create a special impossible atom that will always trigger unsat
+                        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
+              # Special handling for OR expressions - they are disjunctive, not conjunctive
+              # We should NOT add OR children to the stack as they would be treated as AND
+              # OR expressions need separate analysis in the main run() method
+              next
+            elsif current.is_a?(CallExpression) && current.fn_name == :all?
+              # For all? function, add all trait arguments to the stack
+              current.args.each { |arg| stack << arg }
+            elsif current.is_a?(ArrayExpression)
+              # For ArrayExpression, add all elements to the stack
+              current.elements.each { |elem| stack << elem }
+            elsif current.is_a?(DeclarationReference)
               name = current.name
               unless visited.include?(name)
                 visited << name
@@ -51,7 +199,10 @@ module Kumi
             end
 
             # Add children to stack for processing
-            current.children.each { |child| stack << child } if current.respond_to?(:children)
+            # IMPORTANT: Skip CascadeExpression children to avoid false positives
+            # Cascades are handled separately by check_cascade_expression() and are disjunctive,
+            # but gather_atoms() treats all collected atoms as conjunctive
+            current.children.each { |child| stack << child } if current.respond_to?(:children) && !current.is_a?(CascadeExpression)
           end
 
           list
@@ -66,33 +217,63 @@ module Kumi
             # Skip the base case (it's typically a literal true condition)
             next if when_case.condition.is_a?(Literal) && when_case.condition.value == true
 
+            # Skip non-conjunctive conditions (any?, none?) as they are disjunctive
+            next if when_case.condition.is_a?(CallExpression) && %i[any? none?].include?(when_case.condition.fn_name)
+
             # Skip single-trait 'on' branches: trait-level unsat detection covers these
             if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-              list = when_case.condition.args.first
-              next if list.is_a?(ListExpression) && list.elements.size < 2
+              # Handle both ArrayExpression (old format) and multiple args (new format)
+              if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
+                list = when_case.condition.args.first
+                next if list.elements.size == 1
+              elsif when_case.condition.args.size == 1
+                # Multiple args format
+                next
+              end
             end
             # Gather atoms from this individual condition only
             condition_atoms = gather_atoms(when_case.condition, definitions, Set.new, [])
+            # DEBUG
+            # if when_case.condition.is_a?(CallExpression) && [:all?, :any?, :none?].include?(when_case.condition.fn_name)
+            #   puts "  Args: #{when_case.condition.args.inspect}"
+            #   puts "  Atoms found: #{condition_atoms.inspect}"
+            # end
 
             # Only flag if this individual condition is impossible
-            next unless !condition_atoms.empty? && Kumi::AtomUnsatSolver.unsat?(condition_atoms)
+            # if !condition_atoms.empty?
+            #   is_unsat = Kumi::AtomUnsatSolver.unsat?(condition_atoms)
+            #   puts "  Is unsat? #{is_unsat}"
+            # end
+            # Use enhanced solver for cascade conditions too
+            impossible = if definitions && !definitions.empty?
+                           Kumi::ConstraintRelationshipSolver.unsat?(condition_atoms, definitions, input_meta: @input_meta)
+                         else
+                           Kumi::AtomUnsatSolver.unsat?(condition_atoms)
+                         end
+            next unless !condition_atoms.empty? && impossible
 
             # For multi-trait on-clauses, report the trait names rather than the value name
             if when_case.condition.is_a?(CallExpression) && when_case.condition.fn_name == :all?
-              list = when_case.condition.args.first
-              if list.is_a?(ListExpression) && list.elements.all?(Binding)
-                traits = list.elements.map(&:name).join(" AND ")
-                add_error(errors, decl.loc, "conjunction `#{traits}` is impossible")
+              # Handle both ArrayExpression (old format) and multiple args (new format)
+              trait_bindings = if when_case.condition.args.size == 1 && when_case.condition.args.first.is_a?(ArrayExpression)
+                                 when_case.condition.args.first.elements
+                               else
+                                 when_case.condition.args
+                               end
+
+              if trait_bindings.all?(DeclarationReference)
+                traits = trait_bindings.map(&:name).join(" AND ")
+                report_error(errors, "conjunction `#{traits}` is impossible", location: decl.loc)
                 next
               end
             end
-            add_error(errors, decl.loc, "conjunction `#{decl.name}` is impossible")
+            report_error(errors, "conjunction `#{decl.name}` is impossible", location: decl.loc)
           end
         end
 
         def term(node, _defs)
           case node
-          when FieldRef, Binding
+          when InputReference, DeclarationReference
             val = @evaluator.evaluate(node)
             val == :unknown ? node.name : val
           when Literal
@@ -101,6 +282,124 @@ module Kumi
             :unknown
           end
         end
+
+        def check_domain_constraints(node, definitions, errors)
+          case node
+          when InputReference
+            # Check if InputReference points to a field with domain constraints
+            field_meta = @input_meta[node.name]
+            nil unless field_meta&.dig(:domain)
+
+            # For InputReference, the constraint comes from trait conditions
+            # We don't flag here since the InputReference itself is valid
+          when DeclarationReference
+            # Check if this binding evaluates to a value that violates domain constraints
+            definition = definitions[node.name]
+            return unless definition
+
+            if definition.expression.is_a?(Literal)
+              literal_value = definition.expression.value
+              check_value_against_domains(node.name, literal_value, errors, definition.loc)
+            end
+          end
+        end
+
+        def check_value_against_domains(_var_name, value, _errors, _location)
+          # Check if this value violates any input domain constraints
+          @input_meta.each_value do |field_meta|
+            domain = field_meta[:domain]
+            next unless domain
+
+            if violates_domain?(value, domain)
+              # This indicates a constraint that can never be satisfied
+              # Rather than flagging the cascade, flag the impossible condition
+              return true
+            end
+          end
+          false
+        end
+
+        def violates_domain?(value, domain)
+          case domain
+          when Range
+            !domain.include?(value)
+          when Array
+            !domain.include?(value)
+          when Proc
+            # For Proc domains, we can't statically analyze
+            false
+          else
+            false
+          end
+        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)
+            # Reverse case: literal compared to field
+            return field_literal_impossible?(rhs, lhs, flip_operator(operator))
+          end
+
+          # 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))
+          end
+
+          false
+        end
+
+        def field_literal_impossible?(field_ref, literal, operator)
+          field_meta = @input_meta[field_ref.name]
+          return false unless field_meta&.dig(:domain)
+
+          domain = field_meta[:domain]
+          literal_value = literal.value
+
+          case operator
+          when :==
+            # field == value where value is not in domain
+            violates_domain?(literal_value, domain)
+          when :!=
+            # field != value where value is not in domain is always true (not impossible)
+            false
+          else
+            # For other operators, we'd need more sophisticated analysis
+            false
+          end
+        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
+
+          literal_value = literal.value
+
+          case operator
+          when :==
+            # binding == value where binding evaluates to different value
+            evaluated_value != literal_value
+          else
+            # For other operators, we could add more sophisticated checking
+            false
+          end
+        end
+
+        def flip_operator(operator)
+          case operator
+          when :> then :<
+          when :>= then :<=
+          when :< then :>
+          when :<= then :>=
+          when :== then :==
+          when :!= then :!=
+          else operator
+          end
+        end
       end
     end
   end

data/lib/kumi/analyzer/passes/visitor_pass.rb

@@ -3,7 +3,8 @@
 module Kumi
   module Analyzer
     module Passes
-      # Base class for analyzer passes that need to traverse the AST using the visitor pattern
+      # Base class for analyzer passes that need to traverse the AST using the visitor pattern.
+      # Inherits the new immutable state interface from PassBase.
       class VisitorPass < PassBase
         # Visit a node and all its children using depth-first traversal
         # @param node [Syntax::Node] The node to visit
@@ -19,7 +20,7 @@ module Kumi
 
         # Helper to visit each declaration's expression tree
         # @param errors [Array] Error accumulator
-        # @yield [Syntax::Node, Syntax::Declarations::Base] Each node and its containing declaration
+        # @yield [Syntax::Node, Syntax::Base] Each node and its containing declaration
         def visit_all_expressions(errors)
           each_decl do |decl|
             visit(decl.expression) { |node| yield(node, decl, errors) }
@@ -29,7 +30,7 @@ module Kumi
         # Helper to visit only specific node types
         # @param node_types [Array<Class>] Node types to match
         # @param errors [Array] Error accumulator
-        # @yield [Syntax::Node, Syntax::Declarations::Base] Matching nodes and their declarations
+        # @yield [Syntax::Node, Syntax::Base] Matching nodes and their declarations
         def visit_nodes_of_type(*node_types, errors:)
           visit_all_expressions(errors) do |node, decl, errs|
             yield(node, decl, errs) if node_types.any? { |type| node.is_a?(type) }

data/lib/kumi/analyzer.rb

@@ -7,40 +7,57 @@ module Kumi
     module_function
 
     DEFAULT_PASSES = [
-      Passes::NameIndexer,            # 1. Finds all names and checks for duplicates.
-      Passes::InputCollector,         # 2. Collects field metadata from input declarations.
-      Passes::DefinitionValidator,    # 3. Checks the basic structure of each rule.
-      Passes::DependencyResolver,     # 4. Builds the dependency graph.
-      Passes::UnsatDetector,          # 5. Detects unsatisfiable constraints in rules.
-      Passes::Toposorter,             # 6. Creates the final evaluation order.
-      Passes::TypeInferencer,         # 7. Infers types for all declarations (pure annotation).
-      Passes::TypeConsistencyChecker, # 8. Validates declared vs inferred type consistency.
-      Passes::TypeChecker             # 9. Validates types using inferred information.
+      Passes::NameIndexer,                     # 1. Finds all names and checks for duplicates.
+      Passes::InputCollector,                  # 2. Collects field metadata from input declarations.
+      Passes::DeclarationValidator,            # 3. Checks the basic structure of each rule.
+      Passes::SemanticConstraintValidator,     # 4. Validates DSL semantic constraints at AST level.
+      Passes::DependencyResolver,              # 5. Builds the dependency graph with conditional dependencies.
+      Passes::UnsatDetector,                   # 6. Detects unsatisfiable constraints and analyzes cascade mutual exclusion.
+      Passes::Toposorter,                      # 7. Creates the final evaluation order, allowing safe cycles.
+      Passes::BroadcastDetector, # 8. Detects which operations should be broadcast over arrays (must run before type inference).
+      Passes::TypeInferencer,                  # 9. Infers types for all declarations (uses vectorization metadata).
+      Passes::TypeConsistencyChecker,          # 10. Validates declared vs inferred type consistency.
+      Passes::TypeChecker                      # 11. Validates types using inferred information.
     ].freeze
 
     def analyze!(schema, passes: DEFAULT_PASSES, **opts)
-      analysis_state = { opts: opts }
+      state = AnalysisState.new(opts)
       errors = []
 
-      passes.each { |klass| klass.new(schema, analysis_state).run(errors) }
+      state = run_analysis_passes(schema, passes, state, errors)
+      handle_analysis_errors(errors) unless errors.empty?
+      create_analysis_result(state)
+    end
+
+    def self.run_analysis_passes(schema, passes, state, errors)
+      passes.each do |pass_class|
+        pass_instance = pass_class.new(schema, state)
+        begin
+          state = pass_instance.run(errors)
+        rescue StandardError => e
+          errors << ErrorReporter.create_error(e.message, location: nil, type: :semantic)
+        end
+      end
+      state
+    end
 
-      unless errors.empty?
-        # Check if we have type-specific errors to raise more specific exception
-        type_errors = errors.select { |e| e.type == :type }
-        first_error_location = errors.first.location
+    def self.handle_analysis_errors(errors)
+      type_errors = errors.select { |e| e.type == :type }
+      first_error_location = errors.first.location
 
-        raise Errors::TypeError.new(format_errors(errors), first_error_location) if type_errors.any?
+      raise Errors::TypeError.new(format_errors(errors), first_error_location) if type_errors.any?
 
-        raise Errors::SemanticError.new(format_errors(errors), first_error_location)
-      end
+      raise Errors::SemanticError.new(format_errors(errors), first_error_location)
+    end
 
+    def self.create_analysis_result(state)
       Result.new(
-        definitions: analysis_state[:definitions].freeze,
-        dependency_graph: analysis_state[:dependency_graph].freeze,
-        leaf_map: analysis_state[:leaf_map].freeze,
-        topo_order: analysis_state[:topo_order].freeze,
-        decl_types: analysis_state[:decl_types].freeze,
-        state: analysis_state.freeze
+        definitions: state[:definitions],
+        dependency_graph: state[:dependency_graph],
+        leaf_map: state[:leaf_map],
+        topo_order: state[:topo_order],
+        decl_types: state[:decl_types],
+        state: state.to_h
       )
     end
 

data/lib/kumi/atom_unsat_solver.rb

@@ -38,6 +38,9 @@ module Kumi
     # @param debug [Boolean] enable debug output
     # @return [Boolean] true if constraints are unsatisfiable
     def unsat?(atoms, debug: false)
+      # Pass 0: Check for special impossible atoms (domain violations, etc.)
+      return true if impossible_atoms_exist?(atoms, debug: debug)
+
       # Pass 1: Check numerical bound contradictions (symbol vs numeric)
       return true if numerical_contradiction?(atoms, debug: debug)
 
@@ -51,6 +54,21 @@ module Kumi
       StrictInequalitySolver.cycle?(edges, debug: debug)
     end
 
+    # Pass 0: Detects special impossible atoms (domain violations, etc.)
+    # These atoms are created by UnsatDetector when it finds statically impossible constraints
+    #
+    # @param atoms [Array<Atom>] constraint atoms
+    # @param debug [Boolean] enable debug output
+    # @return [Boolean] true if impossible atoms exist
+    def impossible_atoms_exist?(atoms, debug: false)
+      impossible_found = atoms.any? do |atom|
+        atom.lhs == :__impossible__ || atom.rhs == :__impossible__
+      end
+
+      puts "impossible atom detected (domain violation or static impossibility)" if impossible_found && debug
+      impossible_found
+    end
+
     # Pass 1: Detects numerical bound contradictions using interval analysis
     # Handles cases like x > 5 AND x < 3 (contradictory bounds)
     # Also detects always-false comparisons like 100 < 100 or 5 > 5
@@ -99,6 +117,7 @@ module Kumi
       equal_pairs, strict_pairs = collect_equality_pairs(atoms)
 
       return true if direct_equality_contradiction?(equal_pairs, strict_pairs, debug)
+      return true if conflicting_equalities?(atoms, debug: debug)
 
       transitive_equality_contradiction?(equal_pairs, strict_pairs, debug)
     end
@@ -210,6 +229,32 @@ module Kumi
       true
     end
 
+    # Checks for conflicting equalities (x == a AND x == b where a != b)
+    # @param atoms [Array<Atom>] constraint atoms
+    # @param debug [Boolean] enable debug output
+    # @return [Boolean] true if conflicting equalities exist
+    def conflicting_equalities?(atoms, debug: false)
+      equalities = atoms.select { |atom| atom.op == :== }
+
+      # Group equalities by their left-hand side
+      by_lhs = equalities.group_by(&:lhs)
+
+      # Check each variable for conflicting equality constraints
+      by_lhs.each do |lhs, atoms_for_lhs|
+        next if atoms_for_lhs.size < 2
+
+        # Get all values this variable is constrained to equal
+        values = atoms_for_lhs.map(&:rhs).uniq
+
+        if values.size > 1
+          puts "conflicting equalities detected: #{lhs} == #{values.join(" AND #{lhs} == ")}" if debug
+          return true
+        end
+      end
+
+      false
+    end
+
     # Checks for transitive equality contradictions using union-find
     # @param equal_pairs [Set] equality constraint pairs
     # @param strict_pairs [Set] strict inequality pairs