kumi 0.0.5 → 0.0.7

data/README.md

@@ -3,7 +3,7 @@
 [![CI](https://github.com/amuta/kumi/workflows/CI/badge.svg)](https://github.com/amuta/kumi/actions)
 [![Gem Version](https://badge.fury.io/rb/kumi.svg)](https://badge.fury.io/rb/kumi)
 
-Kumi is a computational rules engine for Ruby (plus static validation, dependency tracking, and more)
+Kumi is a Declarative logic and rules engine framework with static analysis for Ruby.
 
 It is well-suited for scenarios with complex, interdependent calculations, enforcing validation and consistency across your business rules while maintaining performance.
 
@@ -11,7 +11,7 @@ It is well-suited for scenarios with complex, interdependent calculations, enfor
 
 ## What can you build?
 
-Calculate U.S. federal taxes in 30 lines of validated, readable code:
+Calculate U.S. federal taxes:
 
 ```ruby
 module FederalTax2024
@@ -62,7 +62,7 @@ result[:after_tax]   # => 78,509.00
 
 Real tax calculation with brackets, deductions, and FICA caps. Validation happens during schema definition.
 
-Is is well-suited for scenarios with complex, interdependent calculations, enforcing ...
+Kumi is well-suited for scenarios with complex, interdependent calculations, enforcing validation and consistency across your business rules while maintaining performance.
 
 ## Installation
 
@@ -74,17 +74,19 @@ gem install kumi
 
 ## Core Features
 
-Here's a concise "Key Concepts" section for your README:
+<details>
+<summary><strong>📊 Schema Primitives</strong> - Four building blocks for business logic</summary>
 
-## Key Concepts
+### Schema Primitives
 
-Kumi schemas are built from four simple primitives that compose into powerful business logic:
+Kumi schemas are built from four primitives:
 
 **Inputs** define the data flowing into your schema with built-in validation:
 ```ruby
 input do
   float :price, domain: 0..1000.0      # Validates range
-  string :category, domain: %w[standard premium]  # Validates inclusion
+  integer :quantity, domain: 1..10000   # Validates range
+  string :tier, domain: %w[standard premium]  # Validates inclusion
 end
 ```
 
@@ -101,7 +103,7 @@ trait :bulk_order, input.quantity >= 100
 trait :premium_customer, input.tier == "premium"
 
 value :discount do
-  on bulk_order & premium_customer, 0.25  # 25% for bulk premium orders
+  on bulk_order, premium_customer, 0.25  # 25% for bulk premium orders
   on bulk_order, 0.15                     # 15% for bulk orders
   on premium_customer, 0.10               # 10% for premium customers
   base 0.0                                # No discount otherwise
@@ -114,73 +116,185 @@ end
 value :final_price, [subtotal - discount_amount, 0].max
 value :monthly_payment, fn(:pmt, rate: 0.05/12, nper: 36, pv: -loan_amount)
 ```
-Note: You can find a list all core functions [FUNCTIONS.md](documents/FUNCTIONS.md)
+Note: You can find a list all core functions in [docs/FUNCTIONS.md](docs/FUNCTIONS.md)
 
+These primitives are statically analyzed during schema definition to catch logical errors before runtime.
 
-These primitives are statically analyzed during schema definition, catching logical errors before runtime and ensuring your business rules are internally consistent.
+</details>
 
+<details>
+<summary><strong>🔍 Static Analysis</strong> - Catch business logic errors at definition time</summary>
 
 ### Static Analysis
 
-Kumi catches real business logic errors during schema definition:
+Kumi catches business logic errors that cause runtime failures or silent bugs:
 
 ```ruby
-module CommissionCalculator
+module InsurancePolicyPricer
   extend Kumi::Schema
   
   schema do
     input do
-      float :sales_amount, domain: 0..Float::INFINITY
+      integer :age, domain: 18..80
+      string :risk_category, domain: %w[low medium high]
+      float :coverage_amount, domain: 50_000..2_000_000
       integer :years_experience, domain: 0..50
-      string :region, domain: %w[east west north south]
+      boolean :has_claims
     end
     
-    # Commission tiers based on experience
-    trait :junior, input.years_experience < 2
-    trait :senior, input.years_experience >= 5
-    trait :veteran, input.years_experience >= 10
-    
-    # Base commission rates
-    value :base_rate do
-      on veteran, 0.08
-      on senior, 0.06
-      on junior, 0.04
-      base 0.05
+    # Risk assessment with subtle interdependencies
+    trait :young_driver, input.age < 25
+    trait :experienced, input.years_experience >= 5
+    trait :high_risk, input.risk_category == "high"
+    trait :senior_driver, input.age >= 65
+    
+    # Base premium calculation
+    value :base_premium, input.coverage_amount * 0.02
+    
+    # Experience adjustment with subtle circular reference
+    value :experience_factor do
+      on experienced & young_driver, experience_discount * 0.8  # ❌ Uses experience_discount before it's defined
+      on experienced, 0.85
+      on young_driver, 1.25
+      base 1.0
     end
     
-    # Regional multipliers
-    value :regional_bonus do
-      on input.region == "west", 1.2  # West coast bonus
-      on input.region == "east", 1.1  # East coast bonus
+    # Risk multipliers that create impossible combinations
+    value :risk_multiplier do
+      on high_risk & experienced, 1.5    # High risk but experienced
+      on high_risk, 2.0                  # Just high risk
+      on low_risk & young_driver, 0.9    # ❌ low_risk is undefined (typo for input.risk_category)
       base 1.0
     end
     
-    # Problem: Veteran bonus conflicts with senior cap
-    value :experience_bonus do
-      on veteran, 2.0      # Veterans get 2x bonus
-      on senior, 1.5       # Seniors get 1.5x bonus  
+    # Claims history impact
+    trait :claims_free, fn(:not, input.has_claims)
+    trait :perfect_record, claims_free & experienced & fn(:not, young_driver)
+    
+    # Discount calculation with type error
+    value :experience_discount do
+      on perfect_record, input.years_experience + "%" # ❌ String concatenation with integer
+      on claims_free, 0.95
       base 1.0
     end
     
-    value :total_rate, base_rate * regional_bonus * experience_bonus
+    # Premium calculation chain
+    value :adjusted_premium, base_premium * experience_factor * risk_multiplier
     
-    # Business rule error: Veterans (10+ years) are also seniors (5+ years)
-    # This creates impossible logic in commission caps
-    trait :capped_senior, :senior & (total_rate <= 0.10)  # Senior cap
-    trait :uncapped_veteran, :veteran & (total_rate > 0.10)  # Veteran override
+    # Age-based impossible logic
+    trait :mature_professional, senior_driver & experienced & young_driver  # ❌ Can't be senior AND young
     
-    value :final_commission do
-      on capped_senior & uncapped_veteran, "Impossible!"  # Can't be both
-      on uncapped_veteran, input.sales_amount * total_rate
-      on capped_senior, input.sales_amount * 0.10
-      base input.sales_amount * total_rate
+    # Final premium with self-referencing cascade
+    value :final_premium do
+      on mature_professional, adjusted_premium * 0.8
+      on senior_driver, adjusted_premium * senior_adjustment  # ❌ senior_adjustment undefined
+      base final_premium * 1.1  # ❌ Self-reference in base case
+    end
+    
+    # Monthly payment calculation with function arity error
+    value :monthly_payment, fn(:divide, final_premium)  # ❌ divide needs 2 arguments, got 1
+  end
+end
+
+# Static analysis catches these errors:
+# ❌ Circular reference: experience_factor → experience_discount → experience_factor
+# ❌ Undefined reference: low_risk (should be input.risk_category == "low")
+# ❌ Type mismatch: integer + string in experience_discount
+# ❌ Impossible conjunction: senior_driver & young_driver
+# ❌ Undefined reference: senior_adjustment
+# ❌ Self-reference cycle: final_premium references itself in base case
+# ❌ Function arity error: divide expects 2 arguments, got 1
+```
+
+**Bounded Recursion**: Kumi allows mutual recursion when cascade conditions are mutually exclusive:
+
+```ruby
+trait :is_forward, input.operation == "forward"
+trait :is_reverse, input.operation == "reverse"
+
+# Safe mutual recursion - conditions are mutually exclusive
+value :forward_processor do
+  on is_forward, input.value * 2        # Direct calculation
+  on is_reverse, reverse_processor + 10  # Delegates to reverse (safe)
+  base "invalid operation"
+end
+
+value :reverse_processor do
+  on is_forward, forward_processor - 5   # Delegates to forward (safe) 
+  on is_reverse, input.value / 2         # Direct calculation
+  base "invalid operation"
+end
+
+# Usage examples:
+# operation="forward", value=10  => forward: 20, reverse: 15
+# operation="reverse", value=10  => forward: 15, reverse: 5  
+# operation="unknown", value=10  => both: "invalid operation"
+```
+
+This compiles because `operation` can only be "forward" or "reverse", never both. Each recursion executes one step before hitting a direct calculation.
+
+</details>
+
+<details>
+<summary><strong>🔍 Array Broadcasting</strong> - Automatic vectorization over array fields</summary>
+
+### Array Broadcasting
+
+Kumi broadcasts operations over array fields for element-wise computation:
+
+```ruby
+schema do
+  input do
+    array :line_items do
+      float   :price
+      integer :quantity
+      string  :category
     end
+    float :tax_rate
   end
+
+  # Element-wise computation - broadcasts over each item
+  value :subtotals, input.line_items.price * input.line_items.quantity
+  
+  # Element-wise traits - applied to each item
+  trait :is_taxable, (input.line_items.category != "digital")
+  
+  # Aggregation operations - consume arrays to produce scalars
+  value :total_subtotal, fn(:sum, subtotals)
+  value :item_count, fn(:size, input.line_items)
 end
+```
 
-# => conjunction `capped_senior AND uncapped_veteran` is impossible
+**Dimension Mismatch Detection**: Operations across different arrays generate error messages:
+
+```ruby
+schema do
+  input do
+    array :items do
+      string :name
+    end
+    array :logs do  
+      string :user_name
+    end
+  end
+
+  # This generates an error
+  trait :same_name, input.items.name == input.logs.user_name
+end
+
+# Error:
+# Cannot broadcast operation across arrays from different sources: items, logs. 
+# Problem: Multiple operands are arrays from different sources:
+#   - Operand 1 resolves to array(string) from array 'items'
+#   - Operand 2 resolves to array(string) from array 'logs'
+# Direct operations on arrays from different sources is ambiguous and not supported.
 ```
 
+</details>
+
+<details>
+<summary><strong>💾 Automatic Memoization</strong> - Each value computed exactly once</summary>
+
 ### Automatic Memoization
 
 Each value is computed exactly once:
@@ -189,16 +303,21 @@ Each value is computed exactly once:
 runner = FederalTax2024.from(income: 250_000, filing_status: "married_joint")
 
 # First access computes full dependency chain
-runner[:total_tax]     # => 52,937.50
+runner[:total_tax]     # => 53,155.20
 
 # Subsequent access uses cached values
-runner[:fed_tax]       # => 37,437.50 (cached)
-runner[:after_tax]     # => 197,062.50 (cached)
+runner[:fed_tax]       # => 39,077.00 (cached)
+runner[:after_tax]     # => 196,844.80 (cached)
 ```
 
+</details>
+
+<details>
+<summary><strong>🔍 Introspection</strong> - See exactly how values are calculated</summary>
+
 ### Introspection
 
-See exactly how any value was calculated:
+Show how values are calculated:
 
 ```ruby
 Kumi::Explain.call(FederalTax2024, :fed_tax, inputs: {income: 100_000, filing_status: "single"})
@@ -209,10 +328,44 @@ Kumi::Explain.call(FederalTax2024, :fed_tax, inputs: {income: 100_000, filing_st
 #    = 15,099.50
 ```
 
-## Suggested Use Cases
+</details>
+
+<details>
+<summary><strong>📋 Schema Metadata</strong> - Extract structured information for tooling</summary>
+
+### Schema Metadata
+
+Access structured metadata for building tools like form generators and dependency analyzers:
+
+```ruby
+metadata = FederalTax2024.schema_metadata
+
+# Processed metadata (tool-friendly)
+metadata.inputs           # Input field types and domains  
+metadata.values           # Value declarations with dependencies
+metadata.traits           # Trait conditions and metadata
+metadata.functions        # Function registry information
+
+# Raw analyzer state (advanced usage)
+metadata.dependencies     # Dependency graph between declarations
+metadata.evaluation_order # Topologically sorted computation order
+metadata.inferred_types   # Type inference results
+metadata.declarations     # Raw AST declaration nodes
+
+# Export formats
+metadata.to_h             # Serializable hash for JSON/APIs
+metadata.to_json_schema   # JSON Schema for input validation
+```
+
+The SchemaMetadata interface provides both processed metadata for tool development and raw analyzer state for advanced use cases. Complete documentation available in the SchemaMetadata class and [docs/schema_metadata.md](docs/schema_metadata.md).
+
+</details>
+
+## Usage
 
+**Suitable for:**
 - Complex interdependent business rules
-- Tax calculation engines (as demonstrated)
+- Tax calculation engines
 - Insurance premium calculators
 - Loan amortization schedules
 - Commission structures with complex tiers
@@ -233,7 +386,7 @@ Benchmarks on Linux with Ruby 3.3.8 on a Dell Latitude 7450:
 
 ## Learn More
 
-- [DSL Syntax Reference](documents/SYNTAX.md)
+- [DSL Syntax Reference](docs/SYNTAX.md)
 - [Examples](examples/)/
 
 ## Contributing
@@ -242,4 +395,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/amuta/
 
 ## License
 
-MIT License. See [LICENSE](LICENSE).
+MIT License. See [LICENSE](LICENSE).

data/{documents → docs}/AST.md

@@ -7,22 +7,22 @@
 Root = Struct.new(:inputs, :attributes, :traits)
 ```
 
-**FieldDecl**: Input field metadata  
+**InputDeclaration**: Input field metadata  
 ```ruby
-FieldDecl = Struct.new(:name, :domain, :type)
-# DSL: integer :age, domain: 18..65 → FieldDecl(:age, 18..65, :integer)
+InputDeclaration = Struct.new(:name, :domain, :type)
+# DSL: integer :age, domain: 18..65 → InputDeclaration(:age, 18..65, :integer)
 ```
 
-**Trait**: Boolean predicate
+**TraitDeclaration**: Boolean predicate
 ```ruby  
-Trait = Struct.new(:name, :expression)
-# DSL: trait :adult, (input.age >= 18) → Trait(:adult, CallExpression(...))
+TraitDeclaration = Struct.new(:name, :expression)
+# DSL: trait :adult, (input.age >= 18) → TraitDeclaration(:adult, CallExpression(...))
 ```
 
-**Attribute**: Computed value
+**ValueDeclaration**: Computed value
 ```ruby
-Attribute = Struct.new(:name, :expression)  
-# DSL: value :total, fn(:add, a, b) → Attribute(:total, CallExpression(:add, [...]))
+ValueDeclaration = Struct.new(:name, :expression)  
+# DSL: value :total, fn(:add, a, b) → ValueDeclaration(:total, CallExpression(:add, [...]))
 ```
 
 ## Expression Nodes
@@ -33,18 +33,18 @@ CallExpression = Struct.new(:fn_name, :args)
 def &(other) = CallExpression.new(:and, [self, other])  # Enable chaining
 ```
 
-**FieldRef**: Field access (`input.field_name`)
+**InputReference**: Field access (`input.field_name`)
 ```ruby
-FieldRef = Struct.new(:name)
+InputReference = Struct.new(:name)
 # Has operator methods: >=, <=, >, <, ==, != that create CallExpression nodes
 ```
 
-**Binding**: References to other declarations
+**DeclarationReference**: References to other declarations
 ```ruby
-Binding = Struct.new(:name)
+DeclarationReference = Struct.new(:name)
 # Created by: ref(:name) OR bare identifier (trait_name) in composite traits
-# DSL: ref(:adult) → Binding(:adult)
-# DSL: adult & verified → CallExpression(:and, [Binding(:adult), Binding(:verified)])
+# DSL: ref(:adult) → DeclarationReference(:adult)
+# DSL: adult & verified → CallExpression(:and, [DeclarationReference(:adult), DeclarationReference(:verified)])
 ```
 
 **Literal**: Constants (`18`, `"text"`, `true`) 
@@ -52,9 +52,9 @@ Binding = Struct.new(:name)
 Literal = Struct.new(:value)
 ```
 
-**ListExpression**: Arrays (`[1, 2, 3]`)
+**ArrayExpression**: Arrays (`[1, 2, 3]`)
 ```ruby
-ListExpression = Struct.new(:elements)
+ArrayExpression = Struct.new(:elements)
 ```
 
 ## Cascade Expressions (Conditional Values)
@@ -64,9 +64,9 @@ ListExpression = Struct.new(:elements)
 CascadeExpression = Struct.new(:cases)
 ```
 
-**WhenCaseExpression**: Individual conditions
+**CaseExpression**: Individual conditions
 ```ruby
-WhenCaseExpression = Struct.new(:condition, :result)
+CaseExpression = Struct.new(:condition, :result)
 ```
 
 **Case type mappings**:
@@ -76,7 +76,7 @@ WhenCaseExpression = Struct.new(:condition, :result)
 
 ## Key Nuances
 
-**Operator methods on FieldRef**: Enable `input.age >= 18` syntax by defining operators that create `CallExpression` nodes
+**Operator methods on InputReference**: Enable `input.age >= 18` syntax by defining operators that create `CallExpression` nodes
 
 **CallExpression `&` method**: Enables expression chaining like `(expr1) & (expr2)`
 
@@ -92,14 +92,14 @@ WhenCaseExpression = Struct.new(:condition, :result)
 
 **Simple**: `(input.age >= 18)`
 ```
-CallExpression(:>=, [FieldRef(:age), Literal(18)])
+CallExpression(:>=, [InputReference(:age), Literal(18)])
 ```
 
 **Chained AND**: `(input.age >= 21) & (input.verified == true)`  
 ```
 CallExpression(:and, [
-  CallExpression(:>=, [FieldRef(:age), Literal(21)]),
-  CallExpression(:==, [FieldRef(:verified), Literal(true)])
+  CallExpression(:>=, [InputReference(:age), Literal(21)]),
+  CallExpression(:==, [InputReference(:verified), Literal(true)])
 ])
 ```
 
@@ -107,10 +107,10 @@ CallExpression(:and, [
 ```
 CallExpression(:and, [
   CallExpression(:and, [
-    Binding(:adult),
-    Binding(:verified)
+    DeclarationReference(:adult),
+    DeclarationReference(:verified)
   ]),
-  Binding(:high_income)
+  DeclarationReference(:high_income)
 ])
 ```
 
@@ -118,9 +118,9 @@ CallExpression(:and, [
 ```
 CallExpression(:and, [
   CallExpression(:and, [
-    Binding(:adult),
-    CallExpression(:>, [FieldRef(:score), Literal(80)])
+    DeclarationReference(:adult),
+    CallExpression(:>, [InputReference(:score), Literal(80)])
   ]),
-  Binding(:verified)
+  DeclarationReference(:verified)
 ])
 ```

data/{documents → docs}/SYNTAX.md

@@ -10,6 +10,7 @@ This document provides a comprehensive comparison of Kumi's DSL syntax showing b
 - [Trait Declarations](#trait-declarations)
 - [Expressions](#expressions)
 - [Functions](#functions)
+- [Array Broadcasting](#array-broadcasting)
 - [Cascade Logic](#cascade-logic)
 - [References](#references)
 
@@ -130,13 +131,8 @@ trait :needs_review, fn(:and, needs_improvement, fn(:>, input.attempts, 2))
 ### String Operations
 
 ```ruby
-# With Sugar  
-trait :long_name, input.name.length > 20
-trait :starts_with_a, input.name.start_with?("A")
-trait :contains_space, input.name.include?(" ")
-
-# Sugar-Free
-trait :long_name, fn(:>, fn(:string_length, input.name), 20)
+# All string operations use function syntax
+trait :long_name, fn(:string_length, input.name) >  20
 trait :starts_with_a, fn(:start_with?, input.name, "A")
 trait :contains_space, fn(:contains?, input.name, " ")
 ```
@@ -187,7 +183,7 @@ value :sorted_scores, fn(:sort, input.score_array)
 
 ### Built-in Functions Available
 
-See [FUNCTIONS.md](documents/FUNCTIONS.md)
+See [FUNCTIONS.md](FUNCTIONS.md)
 
 | Category | Sugar | Sugar-Free |
 |----------|-------|------------|
@@ -210,6 +206,97 @@ value :clamped_score, fn(:clamp, input.raw_score, 0, 1600)
 value :formatted_name, fn(:add, fn(:add, input.first_name, " "), input.last_name)
 ```
 
+## Array Broadcasting
+
+Array broadcasting enables element-wise operations on array fields with automatic vectorization.
+
+### Array Input Declarations
+
+```ruby
+input do
+  array :line_items do
+    float   :price
+    integer :quantity
+    string  :category
+  end
+  
+  array :orders do
+    array :items do
+      hash :product do
+        string :name
+        float  :base_price
+      end
+      integer :quantity
+    end
+  end
+end
+```
+
+### Element-wise Operations
+
+```ruby
+# With Sugar - Automatic Broadcasting
+value :subtotals, input.line_items.price * input.line_items.quantity
+trait :is_taxable, (input.line_items.category != "digital")
+value :discounted_prices, input.line_items.price * 0.9
+
+# Sugar-Free - Explicit Broadcasting  
+value :subtotals, fn(:multiply, input.line_items.price, input.line_items.quantity)
+trait :is_taxable, fn(:!=, input.line_items.category, "digital")
+value :discounted_prices, fn(:multiply, input.line_items.price, 0.9)
+```
+
+### Aggregation Operations
+
+```ruby
+# With Sugar - Automatic Aggregation Detection
+value :total_subtotal, fn(:sum, subtotals)
+value :avg_price, fn(:avg, input.line_items.price)
+value :max_quantity, fn(:max, input.line_items.quantity)
+value :item_count, fn(:size, input.line_items)
+
+# Sugar-Free - Same Syntax
+value :total_subtotal, fn(:sum, subtotals)
+value :avg_price, fn(:avg, input.line_items.price)
+value :max_quantity, fn(:max, input.line_items.quantity)
+value :item_count, fn(:size, input.line_items)
+```
+
+### Nested Array Access
+
+```ruby
+# With Sugar - Deep Field Access
+value :all_product_names, input.orders.items.product.name
+value :total_values, input.orders.items.product.base_price * input.orders.items.quantity
+
+# Sugar-Free - Same Deep Access
+value :all_product_names, input.orders.items.product.name
+value :total_values, fn(:multiply, input.orders.items.product.base_price, input.orders.items.quantity)
+```
+
+### Mixed Operations
+
+```ruby
+# With Sugar - Element-wise then Aggregation
+value :line_totals, input.items.price * input.items.quantity
+value :order_total, fn(:sum, line_totals)
+value :avg_line_total, fn(:avg, line_totals)
+trait :has_expensive, fn(:any?, expensive_items)
+
+# Sugar-Free - Same Pattern
+value :line_totals, fn(:multiply, input.items.price, input.items.quantity)
+value :order_total, fn(:sum, line_totals)
+value :avg_line_total, fn(:avg, line_totals)
+trait :has_expensive, fn(:any?, expensive_items)
+```
+
+### Broadcasting Type Inference
+
+The type system automatically infers appropriate types:
+- `input.items.price` (float array) → inferred as `:float` per element
+- `input.items.price * input.items.quantity` → element-wise `:float` result
+- `fn(:sum, input.items.price)` → scalar `:float` result
+
 ## Cascade Logic
 
 Cascades are similar to Ruby when case, where each case is one of more trait reference and finally the value if that branch is true.

data/docs/features/README.md

@@ -0,0 +1,45 @@
+# Features
+
+## Core Features
+
+### [Unsatisfiability Detection](analysis-unsat-detection.md)
+Analyzes rule combinations to detect logical impossibilities across dependency chains.
+
+- Detects impossible combinations at compile-time
+- Validates domain constraints
+- Reports multiple errors
+
+### [Cascade Mutual Exclusion](analysis-cascade-mutual-exclusion.md)
+Enables safe mutual recursion when cascade conditions are mutually exclusive.
+
+- Allows mathematically sound recursive patterns
+- Detects mutually exclusive conditions
+- Prevents unsafe cycles while enabling safe ones
+
+### [Type Inference](analysis-type-inference.md)  
+Determines types from expressions and propagates them through dependencies.
+
+- Infers types from literals and function calls
+- Propagates types through dependency graph
+- Validates function arguments
+
+### [Input Declarations](input-declaration-system.md)
+Defines expected inputs with types and constraints.
+
+- Type-specific declaration methods
+- Domain validation at runtime
+- Separates input metadata from business logic
+
+### [Performance](performance.md)
+TODO: Add benchmark data
+Processes large schemas with optimized algorithms.
+
+- Result caching
+- Selective evaluation
+
+## Integration
+
+- Type inference uses input declarations
+- Unsatisfiability detection uses type information for validation
+- Cascade mutual exclusion integrates with dependency analysis and cycle detection
+- Performance optimizations apply to all analysis passes