kumi 0.0.9 → 0.0.10

data/lib/kumi/core/compiler/path_traversal_compiler.rb

@@ -0,0 +1,158 @@
+module Kumi
+  module Core
+    module Compiler
+      module PathTraversalCompiler
+        private
+
+        def compile_element_field_reference(expr)
+          path = expr.path
+
+          # Check if we have nested paths metadata for this path
+          nested_paths = @analysis.state[:broadcasts]&.dig(:nested_paths)
+          unless nested_paths && nested_paths[path]
+            raise Errors::CompilationError, "Missing nested path metadata for #{path.inspect}. This indicates an analyzer bug."
+          end
+
+          # Determine operation mode based on context
+          operation_mode = determine_operation_mode_for_path(path)
+          path_metadata = nested_paths[path]
+          lambda do |ctx|
+            traverse_nested_path(ctx, path, operation_mode, path_metadata)
+          end
+
+          # ERROR: All nested paths should have metadata from the analyzer
+          # If we reach here, it means the BroadcastDetector didn't process this path
+        end
+
+        # Metadata-driven nested array traversal using the traversal algorithm from our design
+        def traverse_nested_path(data, path, operation_mode, path_metadata = nil)
+          access_mode = path_metadata&.dig(:access_mode) || :object
+
+          # Use specialized traversal for element access mode
+          result = if access_mode == :element
+                     traverse_element_path(data, path, operation_mode)
+                   else
+                     traverse_path_recursive(data, path, operation_mode, access_mode)
+                   end
+
+          # Post-process result based on operation mode
+          case operation_mode
+          when :flatten
+            # Completely flatten nested arrays for aggregation
+            flatten_completely(result)
+          else
+            result
+          end
+        end
+
+        # Specialized traversal for element access mode
+        # In element access, we need to extract the specific field from EvaluationWrapper
+        # then apply progressive traversal based on path depth
+        def traverse_element_path(data, path, _operation_mode)
+          # Handle EvaluationWrapper by extracting the specific field
+          if data.is_a?(Core::EvaluationWrapper)
+            field_name = path.first
+            array_data = data[field_name]
+
+            # Always apply progressive traversal based on path depth
+            # This gives us the structure at the correct nesting level for both
+            # broadcast operations and structure operations
+            if array_data.is_a?(Array) && path.length > 1
+              # Flatten exactly (path_depth - 1) levels to get the desired nesting level
+              array_data.flatten(path.length - 1)
+            else
+              array_data
+            end
+          else
+            data
+          end
+        end
+
+        def traverse_path_recursive(data, path, operation_mode, access_mode = :object, original_path_length = nil)
+          # Track original path length to determine traversal depth
+          original_path_length ||= path.length
+          current_depth = original_path_length - path.length
+
+          return data if path.empty?
+
+          field = path.first
+          remaining_path = path[1..]
+
+          if remaining_path.empty?
+            # Final field - extract based on operation mode
+            case operation_mode
+            when :broadcast, :flatten
+              # Extract field preserving array structure
+              extract_field_preserving_structure(data, field, access_mode, current_depth)
+            else
+              # Simple field access
+              if data.is_a?(Array)
+                data.map do |item|
+                  access_field(item, field, access_mode, current_depth)
+                end
+              else
+                access_field(data, field, access_mode, current_depth)
+              end
+            end
+          elsif data.is_a?(Array)
+            # Intermediate step - traverse deeper
+            # Array of items - traverse each item
+            data.map do |item|
+              traverse_path_recursive(access_field(item, field, access_mode, current_depth), remaining_path, operation_mode, access_mode,
+                                      original_path_length)
+            end
+          else
+            # Single item - traverse directly
+            traverse_path_recursive(access_field(data, field, access_mode, current_depth), remaining_path, operation_mode, access_mode,
+                                    original_path_length)
+          end
+        end
+
+        def extract_field_preserving_structure(data, field, access_mode = :object, depth = 0)
+          if data.is_a?(Array)
+            data.map { |item| extract_field_preserving_structure(item, field, access_mode, depth) }
+          else
+            access_field(data, field, access_mode, depth)
+          end
+        end
+
+        def access_field(data, field, access_mode, _depth = 0)
+          case access_mode
+          when :element
+            # Element access mode - for nested arrays, we need to traverse one level deeper
+            # This enables progressive path traversal like input.cube.layer.row.value
+            if data.is_a?(Core::EvaluationWrapper)
+              data[field]
+            elsif data.is_a?(Array)
+              # For element access, flatten one level to traverse deeper into nested structure
+              data.flatten(1)
+            else
+              # If not an array, return as-is (leaf level)
+              data
+            end
+          when :object
+            # Object access mode - normal hash/object field access
+            data[field]
+          else
+            # Default to object access
+            data[field]
+          end
+        end
+
+        def flatten_completely(data)
+          result = []
+          flatten_recursive(data, result)
+          result
+        end
+
+        def flatten_recursive(data, result)
+          if data.is_a?(Array)
+            data.each { |item| flatten_recursive(item, result) }
+          else
+            result << data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/compiler/reference_compiler.rb

@@ -0,0 +1,46 @@
+module Kumi
+  module Core
+    module Compiler
+      module ReferenceCompiler
+        private
+
+        def compile_literal(expr)
+          v = expr.value
+          ->(_ctx) { v }
+        end
+
+        def compile_field_node(expr)
+          compile_field(expr)
+        end
+
+        def compile_binding_node(expr)
+          name = expr.name
+          # Handle forward references in cycles by deferring binding lookup to runtime
+          lambda do |ctx|
+            fn = @bindings[name].last
+            fn.call(ctx)
+          end
+        end
+
+        def compile_field(node)
+          name = node.name
+          loc  = node.loc
+          lambda do |ctx|
+            return ctx[name] if ctx.respond_to?(:key?) && ctx.key?(name)
+
+            raise Errors::RuntimeError,
+                  "Key '#{name}' not found at #{loc}. Available: #{ctx.respond_to?(:keys) ? ctx.keys.join(', ') : 'N/A'}"
+          end
+        end
+
+        def compile_declaration(decl)
+          @current_declaration = decl.name
+          kind = decl.is_a?(Kumi::Syntax::TraitDeclaration) ? :trait : :attr
+          fn = compile_expr(decl.expression)
+          @bindings[decl.name] = [kind, fn]
+          @current_declaration = nil
+        end
+      end
+    end
+  end
+end

data/lib/kumi/core/compiler_base.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Kumi
+  module Core
+    # Base compiler class with shared compilation logic between Ruby and JS compilers
+    class CompilerBase
+      # Map node classes to compiler methods
+      DISPATCH = {
+        Kumi::Syntax::Literal => :compile_literal,
+        Kumi::Syntax::InputReference => :compile_field_node,
+        Kumi::Syntax::InputElementReference => :compile_element_field_reference,
+        Kumi::Syntax::DeclarationReference => :compile_binding_node,
+        Kumi::Syntax::ArrayExpression => :compile_list,
+        Kumi::Syntax::CallExpression => :compile_call,
+        Kumi::Syntax::CascadeExpression => :compile_cascade
+      }.freeze
+
+      def initialize(syntax_tree, analyzer_result)
+        @schema = syntax_tree
+        @analysis = analyzer_result
+      end
+
+      # Shared compilation logic
+
+      def build_index
+        @index = {}
+        @schema.attributes.each { |a| @index[a.name] = a }
+        @schema.traits.each     { |t| @index[t.name] = t }
+      end
+
+      def determine_operation_mode_for_path(_path)
+        # Use pre-computed operation mode from analysis
+        compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, @current_declaration)
+        compilation_meta&.dig(:operation_mode) || :broadcast
+      end
+
+      def vectorized_operation?(expr)
+        # Use pre-computed vectorization decision from analysis
+        compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, @current_declaration)
+        return false unless compilation_meta
+
+        # Check if current declaration is vectorized
+        if compilation_meta[:is_vectorized]
+          # For vectorized declarations, check if this specific operation should be vectorized
+          vectorized_ops = @analysis.state[:broadcasts][:vectorized_operations] || {}
+          current_decl_info = vectorized_ops[@current_declaration]
+
+          # For cascade declarations, check individual operations within them
+          return true if current_decl_info && current_decl_info[:operation] == expr.fn_name
+
+          # For cascade_with_vectorized_conditions_or_results, allow nested operations
+          return true if current_decl_info && current_decl_info[:source] == :cascade_with_vectorized_conditions_or_results
+
+          # Check if this is a direct vectorized operation
+          return true if current_decl_info && current_decl_info[:operation]
+        end
+
+        # Fallback: Reduction functions are NOT vectorized operations - they consume arrays
+        return false if Kumi::Registry.reducer?(expr.fn_name)
+
+        # Use pre-computed vectorization context for remaining cases
+        compilation_meta.dig(:vectorization_context, :needs_broadcasting) || false
+      end
+
+      def is_cascade_vectorized?(_expr)
+        # Use metadata to determine if this cascade is vectorized
+        broadcast_meta = @analysis.state[:broadcasts]
+        cascade_info = @current_declaration && broadcast_meta&.dig(:vectorized_operations, @current_declaration)
+        cascade_info && cascade_info[:source] == :cascade_with_vectorized_conditions_or_results
+      end
+
+      def get_cascade_compilation_metadata
+        compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, @current_declaration)
+        cascade_info = compilation_meta&.dig(:cascade_info) || {}
+        [compilation_meta, cascade_info]
+      end
+
+      def get_cascade_strategy
+        @analysis.state[:broadcasts][:cascade_strategies][@current_declaration]
+      end
+
+      def get_function_call_strategy
+        compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, @current_declaration)
+        compilation_meta&.dig(:function_call_strategy) || {}
+      end
+
+      def needs_flattening?
+        function_strategy = get_function_call_strategy
+        function_strategy[:flattening_required]
+      end
+
+      def get_flattening_info
+        @analysis.state[:broadcasts][:flattening_declarations][@current_declaration]
+      end
+
+      def get_flatten_argument_indices
+        compilation_meta = @analysis.state[:broadcasts]&.dig(:compilation_metadata, @current_declaration)
+        compilation_meta&.dig(:function_call_strategy, :flatten_argument_indices) || []
+      end
+
+      # Dispatch to the appropriate compile_* method
+      def compile_expr(expr)
+        method = DISPATCH.fetch(expr.class)
+        send(method, expr)
+      end
+
+      # Abstract methods to be implemented by subclasses
+      def compile_literal(expr)
+        raise NotImplementedError, "Subclasses must implement compile_literal"
+      end
+
+      def compile_field_node(expr)
+        raise NotImplementedError, "Subclasses must implement compile_field_node"
+      end
+
+      def compile_element_field_reference(expr)
+        raise NotImplementedError, "Subclasses must implement compile_element_field_reference"
+      end
+
+      def compile_binding_node(expr)
+        raise NotImplementedError, "Subclasses must implement compile_binding_node"
+      end
+
+      def compile_list(expr)
+        raise NotImplementedError, "Subclasses must implement compile_list"
+      end
+
+      def compile_call(expr)
+        raise NotImplementedError, "Subclasses must implement compile_call"
+      end
+
+      def compile_cascade(expr)
+        raise NotImplementedError, "Subclasses must implement compile_cascade"
+      end
+    end
+  end
+end

data/lib/kumi/core/explain.rb

@@ -8,11 +8,11 @@ module Kumi
           @analyzer_result = analyzer_result
           @inputs = EvaluationWrapper.new(inputs)
           @definitions = analyzer_result.definitions
-          @compiled_schema = Compiler.compile(syntax_tree, analyzer: analyzer_result)
+          @compiled_schema = Kumi::Compiler.compile(syntax_tree, analyzer: analyzer_result)
 
           # TODO: REFACTOR QUICK!
           # Set up compiler once for expression evaluation
-          @compiler = Compiler.new(syntax_tree, analyzer_result)
+          @compiler = Kumi::Compiler.new(syntax_tree, analyzer_result)
           @compiler.send(:build_index)
 
           # Populate bindings from the compiled schema

data/lib/kumi/core/function_registry/collection_functions.rb

@@ -9,8 +9,8 @@ module Kumi
           {
             # Collection queries (these are reducers - they reduce arrays to scalars)
             empty?: FunctionBuilder.collection_unary(:empty?, "Check if collection is empty", :empty?, reducer: true),
-            size: FunctionBuilder.collection_unary(:size, "Get collection size", :size, return_type: :integer, reducer: true),
-            length: FunctionBuilder.collection_unary(:length, "Get collection length", :length, return_type: :integer, reducer: true),
+            size: FunctionBuilder.collection_unary(:size, "Get collection size", :size, return_type: :integer, reducer: false,
+                                                                                        structure_function: true),
 
             # Element access
             first: FunctionBuilder::Entry.new(
@@ -98,7 +98,26 @@ module Kumi
               arity: 1,
               param_types: [Kumi::Core::Types.array(:any)],
               return_type: Kumi::Core::Types.array(:any),
-              description: "Flatten nested arrays into a single array"
+              description: "Flatten nested arrays into a single array",
+              structure_function: true
+            ),
+
+            flatten_one: FunctionBuilder::Entry.new(
+              fn: ->(array) { array.flatten(1) },
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Flatten nested arrays by one level only",
+              structure_function: true
+            ),
+
+            flatten_deep: FunctionBuilder::Entry.new(
+              fn: lambda(&:flatten),
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: Kumi::Core::Types.array(:any),
+              description: "Recursively flatten all nested arrays (alias for flatten)",
+              structure_function: true
             ),
 
             # Mathematical transformation functions
@@ -193,6 +212,70 @@ module Kumi
               param_types: [Kumi::Core::Types.array(:any)],
               return_type: Kumi::Core::Types.array(:integer),
               description: "Generate array of indices for the collection"
+            ),
+
+            # Conditional aggregation functions
+            count_if: FunctionBuilder::Entry.new(
+              fn: ->(condition_array) { condition_array.count(true) },
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:boolean)],
+              return_type: :integer,
+              description: "Count number of true values in boolean array",
+              reducer: true
+            ),
+
+            sum_if: FunctionBuilder::Entry.new(
+              fn: lambda { |value_array, condition_array|
+                value_array.zip(condition_array).sum { |value, condition| condition ? value : 0 }
+              },
+              arity: 2,
+              param_types: [Kumi::Core::Types.array(:float), Kumi::Core::Types.array(:boolean)],
+              return_type: :float,
+              description: "Sum values where corresponding condition is true",
+              reducer: true
+            ),
+
+            avg_if: FunctionBuilder::Entry.new(
+              fn: lambda { |value_array, condition_array|
+                pairs = value_array.zip(condition_array)
+                true_values = pairs.filter_map { |value, condition| value if condition }
+                return 0.0 if true_values.empty?
+
+                true_values.sum.to_f / true_values.size
+              },
+              arity: 2,
+              param_types: [Kumi::Core::Types.array(:float), Kumi::Core::Types.array(:boolean)],
+              return_type: :float,
+              description: "Average values where corresponding condition is true",
+              reducer: true
+            ),
+
+            # Flattening utilities for hierarchical data
+            any_across: FunctionBuilder::Entry.new(
+              fn: ->(nested_array) { nested_array.flatten.any? },
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: :boolean,
+              description: "Check if any element is truthy across all nested levels",
+              reducer: true
+            ),
+
+            all_across: FunctionBuilder::Entry.new(
+              fn: ->(nested_array) { nested_array.flatten.all? },
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: :boolean,
+              description: "Check if all elements are truthy across all nested levels",
+              reducer: true
+            ),
+
+            count_across: FunctionBuilder::Entry.new(
+              fn: ->(nested_array) { nested_array.flatten.size },
+              arity: 1,
+              param_types: [Kumi::Core::Types.array(:any)],
+              return_type: :integer,
+              description: "Count total elements across all nested levels",
+              reducer: true
             )
           }
         end

data/lib/kumi/core/function_registry/function_builder.rb

@@ -5,7 +5,8 @@ module Kumi
     module FunctionRegistry
       # Utility class to reduce repetition in function definitions
       class FunctionBuilder
-        Entry = Struct.new(:fn, :arity, :param_types, :return_type, :description, :inverse, :reducer, keyword_init: true)
+        Entry = Struct.new(:fn, :arity, :param_types, :return_type, :description, :inverse, :reducer, :structure_function,
+                           keyword_init: true)
 
         def self.comparison(_name, description, operation)
           Entry.new(
@@ -79,14 +80,15 @@ module Kumi
           )
         end
 
-        def self.collection_unary(_name, description, operation, return_type: :boolean, reducer: false)
+        def self.collection_unary(_name, description, operation, return_type: :boolean, reducer: false, structure_function: false)
           Entry.new(
             fn: proc(&operation),
             arity: 1,
             param_types: [Kumi::Core::Types.array(:any)],
             return_type: return_type,
             description: description,
-            reducer: reducer
+            reducer: reducer,
+            structure_function: structure_function
           )
         end
       end

data/lib/kumi/core/function_registry/logical_functions.rb

@@ -5,6 +5,146 @@ module Kumi
     module FunctionRegistry
       # Logical operations and boolean functions
       module LogicalFunctions
+        def self.element_wise_and(a, b)
+          if ENV["DEBUG_CASCADE"]
+            puts "DEBUG element_wise_and called with:"
+            puts "  a: #{a.inspect} (depth: #{array_depth(a)})"
+            puts "  b: #{b.inspect} (depth: #{array_depth(b)})"
+          end
+
+          case [a.class, b.class]
+          when [Array, Array]
+            # Both are arrays - handle hierarchical broadcasting
+            if hierarchical_broadcasting_needed?(a, b)
+              puts "  -> Using hierarchical broadcasting" if ENV["DEBUG_CASCADE"]
+              result = perform_hierarchical_and(a, b)
+              puts "  -> Hierarchical result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
+            else
+              # Same structure - use zip for element-wise operations
+              puts "  -> Using same-structure zip" if ENV["DEBUG_CASCADE"]
+              result = a.zip(b).map { |elem_a, elem_b| element_wise_and(elem_a, elem_b) }
+              puts "  -> Zip result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
+            end
+            result
+          when [Array, Object], [Object, Array]
+            # One is array, one is scalar - broadcast scalar
+            puts "  -> Broadcasting scalar to array" if ENV["DEBUG_CASCADE"]
+            result = if a.is_a?(Array)
+                       a.map { |elem| element_wise_and(elem, b) }
+                     else
+                       b.map { |elem| element_wise_and(a, elem) }
+                     end
+            puts "  -> Broadcast result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
+            result
+          else
+            # Both are scalars - simple AND
+            puts "  -> Simple scalar AND: #{a} && #{b} = #{a && b}" if ENV["DEBUG_CASCADE"]
+            a && b
+          end
+        end
+
+        def self.hierarchical_broadcasting_needed?(a, b)
+          # Check if arrays have different nesting depths (hierarchical broadcasting)
+          depth_a = array_depth(a)
+          depth_b = array_depth(b)
+          depth_a != depth_b
+        end
+
+        def self.array_depth(arr)
+          return 0 unless arr.is_a?(Array)
+          return 1 if arr.empty? || !arr.first.is_a?(Array)
+
+          1 + array_depth(arr.first)
+        end
+
+        def self.perform_hierarchical_and(a, b)
+          # Determine which is the higher dimension and which is lower
+          depth_a = array_depth(a)
+          depth_b = array_depth(b)
+
+          puts "    perform_hierarchical_and: depth_a=#{depth_a}, depth_b=#{depth_b}" if ENV["DEBUG_CASCADE"]
+
+          if depth_a > depth_b
+            # a is deeper (child level), b is shallower (parent level)
+            # Broadcast b values to match a's structure - PRESERVE a's structure
+            puts "    -> Broadcasting b (parent) to match a (child) structure" if ENV["DEBUG_CASCADE"]
+            broadcast_parent_to_child_structure(a, b)
+          else
+            # b is deeper (child level), a is shallower (parent level)
+            # Broadcast a values to match b's structure - PRESERVE b's structure
+            puts "    -> Broadcasting a (parent) to match b (child) structure" if ENV["DEBUG_CASCADE"]
+            broadcast_parent_to_child_structure(b, a)
+          end
+        end
+
+        def self.broadcast_parent_to_child_structure(child_array, parent_array)
+          # Broadcast parent array values to match child array structure, preserving child structure
+          if ENV["DEBUG_CASCADE"]
+            puts "      broadcast_parent_to_child_structure:"
+            puts "        child_array: #{child_array.inspect}"
+            puts "        parent_array: #{parent_array.inspect}"
+            puts "        child depth: #{array_depth(child_array)}, parent depth: #{array_depth(parent_array)}"
+          end
+
+          # Use child array structure as template and broadcast parent values
+          map_with_parent_broadcasting(child_array, parent_array, [])
+        end
+
+        def self.map_with_parent_broadcasting(child_structure, parent_structure, indices)
+          if child_structure.is_a?(Array)
+            child_structure.map.with_index do |child_elem, index|
+              new_indices = indices + [index]
+
+              # Navigate parent structure with fewer indices (broadcasting)
+              parent_depth = array_depth(parent_structure)
+              parent_indices = new_indices[0, parent_depth]
+              parent_value = navigate_indices(parent_structure, parent_indices)
+
+              if child_elem.is_a?(Array)
+                # Recurse deeper into child structure
+                map_with_parent_broadcasting(child_elem, parent_structure, new_indices)
+              else
+                # Leaf level - apply AND operation
+                result = child_elem && parent_value
+                if ENV["DEBUG_CASCADE"]
+                  puts "          Leaf: child=#{child_elem}, parent=#{parent_value} (indices #{new_indices.inspect}) -> #{result}"
+                end
+                result
+              end
+            end
+          else
+            # Non-array child - just AND with parent
+            child_structure && parent_structure
+          end
+        end
+
+        def self.navigate_indices(structure, indices)
+          return structure if indices.empty?
+          return structure unless structure.is_a?(Array)
+          return nil if indices.first >= structure.length
+
+          navigate_indices(structure[indices.first], indices[1..])
+        end
+
+        def self.broadcast_to_match_structure(child_array, parent_array)
+          # Legacy method - keeping for backward compatibility
+          if ENV["DEBUG_CASCADE"]
+            puts "      broadcast_to_match_structure (LEGACY):"
+            puts "        child_array: #{child_array.inspect}"
+            puts "        parent_array: #{parent_array.inspect}"
+            puts "        child_array.length: #{child_array.length}"
+            puts "        parent_array.length: #{parent_array.length}"
+          end
+
+          result = child_array.zip(parent_array).map do |child_elem, parent_elem|
+            puts "        Combining child_elem: #{child_elem.inspect} with parent_elem: #{parent_elem.inspect}" if ENV["DEBUG_CASCADE"]
+            element_wise_and(child_elem, parent_elem)
+          end
+
+          puts "        broadcast result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
+          result
+        end
+
         def self.definitions
           {
             # Basic logical operations
@@ -35,7 +175,37 @@ module Kumi
             # Collection logical operations
             all?: FunctionBuilder.collection_unary(:all?, "Check if all elements in collection are truthy", :all?),
             any?: FunctionBuilder.collection_unary(:any?, "Check if any element in collection is truthy", :any?),
-            none?: FunctionBuilder.collection_unary(:none?, "Check if no elements in collection are truthy", :none?)
+            none?: FunctionBuilder.collection_unary(:none?, "Check if no elements in collection are truthy", :none?),
+
+            # Element-wise AND for cascades - works on arrays with same structure
+            cascade_and: FunctionBuilder::Entry.new(
+              fn: lambda do |*conditions|
+                if ENV["DEBUG_CASCADE"]
+                  puts "DEBUG cascade_and called with #{conditions.length} conditions:"
+                  conditions.each_with_index do |cond, i|
+                    puts "  condition[#{i}]: #{cond.inspect}"
+                  end
+                end
+
+                return false if conditions.empty?
+                return conditions.first if conditions.length == 1
+
+                # Element-wise AND for arrays with same nested structure
+                result = conditions.first
+                conditions[1..].each_with_index do |condition, i|
+                  puts "  Combining result with condition[#{i + 1}]" if ENV["DEBUG_CASCADE"]
+                  result = LogicalFunctions.element_wise_and(result, condition)
+                  puts "  Result after combining: #{result.inspect}" if ENV["DEBUG_CASCADE"]
+                end
+
+                puts "  Final cascade_and result: #{result.inspect}" if ENV["DEBUG_CASCADE"]
+                result
+              end,
+              arity: -1,
+              param_types: [:boolean],
+              return_type: :boolean,
+              description: "Element-wise AND for arrays with same nested structure"
+            )
           }
         end
       end