simple-graph-query 2.1.4 → 2.2.1

package/dist/ForgeExprEvaluator.d.ts

@@ -17,13 +17,17 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     private freeVariables;
     private cachedResults;
     private instanceData;
+    private relationCache;
+    private relationIndexCache;
     constructor(datum: IDataInstance);
+    private buildRelationCache;
     private updateFreeVariables;
     private constructFreeVariableKey;
     private getLabelForValue;
     private getLabelAsString;
     private getLabelAsBoolean;
     private getLabelAsNumber;
+    private dotJoin;
     private cacheResult;
     private getIden;
     protected aggregateResult(aggregate: EvalResult, nextResult: EvalResult): EvalResult;

package/dist/NumericConstraintOptimizer.d.ts

@@ -0,0 +1,39 @@
+import { ExprContext } from "./forge-antlr/ForgeParser";
+import { Tuple } from "./ForgeExprEvaluator";
+/**
+ * Analyzes set comprehension constraints to detect simple numeric comparison patterns
+ * that can be optimized by generating only valid combinations instead of filtering.
+ */
+export interface NumericConstraintPattern {
+    type: 'less_than' | 'greater_than' | 'less_equal' | 'greater_equal' | 'not_equal' | 'none';
+    leftVar: string;
+    rightVar: string;
+}
+/**
+ * Detects if a constraint expression is a simple numeric comparison between two variables.
+ * Currently detects patterns like: a < b, a > b, a <= b, a >= b, a != b
+ *
+ * Note: Uses string matching on expression text which is simple but may miss expressions
+ * with extra whitespace or parentheses. This is intentionally conservative - we prefer
+ * to fall back to the standard approach rather than risk incorrect optimization.
+ *
+ * @param constraintExpr The constraint expression to analyze
+ * @param varNames The variable names in scope
+ * @returns Pattern info if detected, null otherwise
+ */
+export declare function detectNumericComparisonPattern(constraintExpr: ExprContext, varNames: string[]): NumericConstraintPattern | null;
+/**
+ * Checks if all values in the sets are numbers (or tuples containing single numbers).
+ * This is required for numeric comparison optimization to be applicable.
+ */
+export declare function areAllNumericSets(sets: Tuple[][]): boolean;
+/**
+ * Generates optimized combinations for numeric comparison constraints.
+ * Instead of generating all combinations and filtering, generates only valid ones.
+ *
+ * @param varNames Variable names in order
+ * @param quantifiedSets The sets each variable ranges over
+ * @param pattern The detected numeric comparison pattern
+ * @returns Only the tuples that satisfy the constraint
+ */
+export declare function generateOptimizedNumericCombinations(varNames: string[], quantifiedSets: Tuple[][], pattern: NumericConstraintPattern): Tuple[];

package/dist/simple-graph-query.bundle.js

@@ -48441,6 +48441,7 @@ exports.areTupleArraysEqual = areTupleArraysEqual;
 const AbstractParseTreeVisitor_1 = __webpack_require__(/*! antlr4ts/tree/AbstractParseTreeVisitor */ "./node_modules/antlr4ts/tree/AbstractParseTreeVisitor.js");
 const lodash_1 = __webpack_require__(/*! lodash */ "./node_modules/lodash/lodash.js");
 const ForgeExprFreeVariableFinder_1 = __webpack_require__(/*! ./ForgeExprFreeVariableFinder */ "./src/ForgeExprFreeVariableFinder.ts");
+const NumericConstraintOptimizer_1 = __webpack_require__(/*! ./NumericConstraintOptimizer */ "./src/NumericConstraintOptimizer.ts");
 ///// HELPER FUNCTIONS /////
 function isSingleValue(value) {
     return (typeof value === "string" ||
@@ -48570,38 +48571,6 @@ function transitiveClosure(pairs) {
     // convert the result back to a Tuple[] and return
     return Array.from(transitiveClosureSet).map((pair) => JSON.parse(pair));
 }
-function dotJoin(left, right) {
-    const leftExpr = isSingleValue(left) ? [[left]] : left;
-    const rightExpr = isSingleValue(right) ? [[right]] : right;
-    // Optimize join using a Map for O(n+m) instead of O(n*m) lookup
-    // Group right tuples by their first element for fast lookup
-    const rightIndex = new Map();
-    for (const rightTuple of rightExpr) {
-        const key = rightTuple[0];
-        if (!rightIndex.has(key)) {
-            rightIndex.set(key, []);
-        }
-        rightIndex.get(key).push(rightTuple);
-    }
-    const result = [];
-    for (const leftTuple of leftExpr) {
-        const joinKey = leftTuple[leftTuple.length - 1];
-        const matchingRightTuples = rightIndex.get(joinKey);
-        if (matchingRightTuples) {
-            for (const rightTuple of matchingRightTuples) {
-                result.push([
-                    ...leftTuple.slice(0, leftTuple.length - 1),
-                    ...rightTuple.slice(1),
-                ]);
-            }
-        }
-    }
-    if (result.some(tuple => tuple.length === 0)) {
-        throw new Error("Join would create a relation of arity 0");
-    }
-    // Deduplicate results to ensure set semantics
-    return deduplicateTuples(result);
-}
 function bitwidthWraparound(value, bitwidth) {
     const modulus = Math.pow(2, bitwidth); // total number of Int values
     const halfValue = Math.pow(2, bitwidth - 1); // halfway point
@@ -48632,11 +48601,61 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         // NOTE: strings will be of the format "<var-name>=<value>|..." sorted in
         // increasing lexicographic order of variable names
         this.cachedResults = new Map();
+        // Cache for relation lookups to avoid O(n) scans
+        this.relationCache = null;
+        // Index for relations: Map<relationName, Map<firstElement, Tuple[]>>
+        // This allows O(1) lookup for patterns like atom.field
+        this.relationIndexCache = null;
         this.instanceData = datum;
         this.environmentStack = [];
         this.freeVariableFinder = new ForgeExprFreeVariableFinder_1.ForgeExprFreeVariableFinder(datum);
         this.freeVariables = new Map();
     }
+    // helper function to build relation cache and indexes
+    buildRelationCache() {
+        if (this.relationCache !== null) {
+            return; // already built
+        }
+        this.relationCache = new Map();
+        this.relationIndexCache = new Map();
+        const relations = this.instanceData.getRelations();
+        const isConvertibleToNumber = (value) => {
+            return typeof value === "string" && !isNaN(Number(value));
+        };
+        const isConvertibleToBoolean = (value) => {
+            if (typeof value === "boolean")
+                return false; // already boolean
+            return value === "true" || value === "#t" || value === "false" || value === "#f";
+        };
+        const convertToBoolean = (value) => {
+            if (typeof value === "boolean")
+                return value;
+            if (value === "true" || value === "#t")
+                return true;
+            if (value === "false" || value === "#f")
+                return false;
+            throw new Error(`Cannot convert ${value} to boolean`);
+        };
+        for (const relation of relations) {
+            let relationAtoms = relation.tuples.map((tuple) => tuple.atoms);
+            // Convert numeric and boolean strings to their actual types
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToBoolean(value) ? convertToBoolean(value) : value));
+            this.relationCache.set(relation.name, relationAtoms);
+            // Build index for this relation: first element -> all tuples starting with that element
+            const relationIndex = new Map();
+            for (const tuple of relationAtoms) {
+                if (tuple.length > 0) {
+                    const key = tuple[0];
+                    if (!relationIndex.has(key)) {
+                        relationIndex.set(key, []);
+                    }
+                    relationIndex.get(key).push(tuple);
+                }
+            }
+            this.relationIndexCache.set(relation.name, relationIndex);
+        }
+    }
     //helper function
     updateFreeVariables(freeVars) {
         if (this.freeVariables.size === 0) {
@@ -48732,6 +48751,45 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         }
         return labelNum;
     }
+    // Optimized dotJoin that can use pre-built relation indexes
+    dotJoin(left, right, rightRelationName) {
+        const leftExpr = isSingleValue(left) ? [[left]] : left;
+        const rightExpr = isSingleValue(right) ? [[right]] : right;
+        // Try to use pre-built index if available
+        let rightIndex;
+        if (rightRelationName && this.relationIndexCache) {
+            rightIndex = this.relationIndexCache.get(rightRelationName);
+        }
+        // If no pre-built index, build one on the fly
+        if (!rightIndex) {
+            rightIndex = new Map();
+            for (const rightTuple of rightExpr) {
+                const key = rightTuple[0];
+                if (!rightIndex.has(key)) {
+                    rightIndex.set(key, []);
+                }
+                rightIndex.get(key).push(rightTuple);
+            }
+        }
+        const result = [];
+        for (const leftTuple of leftExpr) {
+            const joinKey = leftTuple[leftTuple.length - 1];
+            const matchingRightTuples = rightIndex.get(joinKey);
+            if (matchingRightTuples) {
+                for (const rightTuple of matchingRightTuples) {
+                    result.push([
+                        ...leftTuple.slice(0, leftTuple.length - 1),
+                        ...rightTuple.slice(1),
+                    ]);
+                }
+            }
+        }
+        if (result.some(tuple => tuple.length === 0)) {
+            throw new Error("Join would create a relation of arity 0");
+        }
+        // Deduplicate results to ensure set semantics
+        return deduplicateTuples(result);
+    }
     // helper function
     cacheResult(ctx, freeVarsKey, result) {
         if (!this.cachedResults.has(ctx)) {
@@ -48862,9 +48920,6 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         if (foundAllVars && this.cachedResults.has(ctx)) {
             if (this.cachedResults.get(ctx).has(freeVarsKey)) {
                 // cache hit!
-                // console.log('cache hit for ctx:', ctx.text);
-                // console.log('freeVarsKey:', freeVarsKey);
-                // console.log('cachedResults:', this.cachedResults.get(ctx));
                 return this.cachedResults.get(ctx).get(freeVarsKey);
             }
         }
@@ -48905,7 +48960,26 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 varNames.push(varName);
                 quantifiedSets.push(varQuantifiedSets[varName]);
             }
-            const product = getCombinations(quantifiedSets);
+            // Try to optimize numeric comparisons
+            let product;
+            let useOptimizedPath = false;
+            if (!isDisjoint && varNames.length >= 2 && (0, NumericConstraintOptimizer_1.areAllNumericSets)(quantifiedSets)) {
+                // Try to detect and optimize numeric comparison patterns
+                const pattern = (0, NumericConstraintOptimizer_1.detectNumericComparisonPattern)(barExpr, varNames);
+                if (pattern && pattern.type !== 'none') {
+                    // Use optimized combination generation
+                    product = (0, NumericConstraintOptimizer_1.generateOptimizedNumericCombinations)(varNames, quantifiedSets, pattern);
+                    useOptimizedPath = true;
+                }
+                else {
+                    // Fall back to standard cartesian product
+                    product = getCombinations(quantifiedSets);
+                }
+            }
+            else {
+                // Fall back to standard cartesian product
+                product = getCombinations(quantifiedSets);
+            }
             const result = [];
             let foundTrue = false;
             let foundFalse = false;
@@ -48936,10 +49010,19 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 for (let j = 0; j < varNames.length; j++) {
                     quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                // now, we want to evaluate the barExpr
-                const barExprValue = this.visit(barExpr);
-                if (!isBoolean(barExprValue)) {
-                    throw new Error("Expected the expression after the bar to be a boolean!");
+                // If we used the optimized path, we can skip constraint evaluation
+                // since the combinations already satisfy the constraint
+                let barExprValue;
+                if (useOptimizedPath) {
+                    barExprValue = true;
+                }
+                else {
+                    // now, we want to evaluate the barExpr
+                    const evalResult = this.visit(barExpr);
+                    if (!isBoolean(evalResult)) {
+                        throw new Error("Expected the expression after the bar to be a boolean!");
+                    }
+                    barExprValue = evalResult;
                 }
                 if (barExprValue) {
                     result.push(tuple);
@@ -49634,7 +49717,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 }
             }
             // Box join: <expr-a>[<expr-b>] == <expr-b> . <expr-a>
-            return dotJoin(insideBracesExprs, beforeBracesExpr);
+            return this.dotJoin(insideBracesExprs, beforeBracesExpr);
         }
         return this.visitChildren(ctx);
     }
@@ -49647,9 +49730,20 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             }
             const beforeDotExpr = this.visit(ctx.expr15());
             const afterDotExpr = this.visit(ctx.expr16());
-            // console.log('beforeExpr:', beforeDotExpr);
-            // console.log('afterExpr:', afterDotExpr);
-            return dotJoin(beforeDotExpr, afterDotExpr);
+            // Try to extract the relation name if the right side is a simple identifier/relation name
+            let rightRelationName;
+            // Simple heuristic: check if it's a tuple array (likely a relation)
+            // and if so, try to find which relation it matches
+            if (isTupleArray(afterDotExpr) && this.relationCache) {
+                // Check if this matches any cached relation
+                for (const [relName, relTuples] of this.relationCache.entries()) {
+                    if (relTuples === afterDotExpr) {
+                        rightRelationName = relName;
+                        break;
+                    }
+                }
+            }
+            return this.dotJoin(beforeDotExpr, afterDotExpr, rightRelationName);
         }
         if (ctx.LEFT_SQUARE_TOK()) {
             const beforeBracesName = this.visit(ctx.name());
@@ -49908,7 +50002,28 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 varNames.push(varName);
                 quantifiedSets.push(varQuantifiedSets[varName]);
             }
-            const product = getCombinations(quantifiedSets);
+            // Try to optimize numeric comparisons (same optimization as in quantifiers)
+            // Note: Set comprehensions don't support the 'disj' keyword, so we don't check for it here.
+            // Quantifiers do support 'disj', so they check !isDisjoint before optimizing.
+            let product;
+            let useOptimizedPath = false;
+            if (varNames.length >= 2 && (0, NumericConstraintOptimizer_1.areAllNumericSets)(quantifiedSets)) {
+                // Try to detect and optimize numeric comparison patterns
+                const pattern = (0, NumericConstraintOptimizer_1.detectNumericComparisonPattern)(barExpr, varNames);
+                if (pattern && pattern.type !== 'none') {
+                    // Use optimized combination generation
+                    product = (0, NumericConstraintOptimizer_1.generateOptimizedNumericCombinations)(varNames, quantifiedSets, pattern);
+                    useOptimizedPath = true;
+                }
+                else {
+                    // Fall back to standard cartesian product
+                    product = getCombinations(quantifiedSets);
+                }
+            }
+            else {
+                // Fall back to standard cartesian product
+                product = getCombinations(quantifiedSets);
+            }
             const result = [];
             // Optimize: create environment once and reuse it
             const quantDeclEnv = {
@@ -49922,10 +50037,19 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 for (let j = 0; j < varNames.length; j++) {
                     quantDeclEnv.env[varNames[j]] = tuple[j];
                 }
-                // now, we want to evaluate the barExpr
-                const barExprValue = this.visit(barExpr);
-                if (!isBoolean(barExprValue)) {
-                    throw new Error("Expected the expression after the bar to be a boolean value!");
+                // If we used the optimized path, we can skip constraint evaluation
+                // since the combinations already satisfy the constraint
+                let barExprValue;
+                if (useOptimizedPath) {
+                    barExprValue = true;
+                }
+                else {
+                    // now, we want to evaluate the barExpr
+                    const evalResult = this.visit(barExpr);
+                    if (!isBoolean(evalResult)) {
+                        throw new Error("Expected the expression after the bar to be a boolean value!");
+                    }
+                    barExprValue = evalResult;
                 }
                 if (barExprValue) {
                     // will error if not boolean val, which we want
@@ -50092,15 +50216,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             throw new Error(`Cannot convert ${value} to boolean`);
         };
         // end of 3 helper functions
-        // check if it is a relation
-        const relations = this.instanceData.getRelations();
-        for (const relation of relations) {
-            if (relation.name === identifier) {
-                let relationAtoms = relation.tuples.map((tuple) => tuple.atoms);
-                relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
-                relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => isConvertibleToBoolean(value) ? convertToBoolean(value) : value));
-                return relationAtoms;
-            }
+        // check if it is a relation - use cache for faster lookups
+        this.buildRelationCache();
+        if (this.relationCache.has(identifier)) {
+            return this.relationCache.get(identifier);
         }
         if (result !== undefined) {
             result = result.map((tuple) => tuple.map((value) => isConvertibleToNumber(value) ? Number(value) : value));
@@ -50386,6 +50505,9 @@ class ForgeExprFreeVariableFinder extends AbstractParseTreeVisitor_1.AbstractPar
             const quantDeclListVars = this.getQuantDeclListVarNames(ctx.quantDeclList());
             // we need to get all the vars referenced here other than the vars
             // bound by the quantifier (in quantDeclListVars)
+            // First, get free variables from the quantDeclList itself
+            // (e.g., in "some p2 : c.parent | ...", c is a free variable)
+            const quantDeclListFreeVars = this.visit(ctx.quantDeclList());
             const blockOrBar = ctx.blockOrBar();
             if (blockOrBar === undefined) {
                 throw new Error("expected to quantify over something!");
@@ -50394,13 +50516,15 @@ class ForgeExprFreeVariableFinder extends AbstractParseTreeVisitor_1.AbstractPar
                 blockOrBar.expr() === undefined) {
                 throw new Error("Expected the quantifier to have a bar followed by an expr!");
             }
-            let allFreeVars;
+            let barExprFreeVars;
             if (blockOrBar.block() !== undefined) {
-                allFreeVars = this.visit(blockOrBar.block());
+                barExprFreeVars = this.visit(blockOrBar.block());
             }
             else {
-                allFreeVars = this.visit(blockOrBar.expr());
+                barExprFreeVars = this.visit(blockOrBar.expr());
             }
+            // Merge free variables from quantDeclList and barExpr
+            const allFreeVars = this.aggregateResult(barExprFreeVars, quantDeclListFreeVars);
             // the context node for the quantifier as a whole shouldn't have _all_ of these
             // free vars; specifically, it should not include the vars that are being
             // bound by the quantifier
@@ -50592,6 +50716,200 @@ class ForgeExprFreeVariableFinder extends AbstractParseTreeVisitor_1.AbstractPar
 exports.ForgeExprFreeVariableFinder = ForgeExprFreeVariableFinder;
 
 
+/***/ }),
+
+/***/ "./src/NumericConstraintOptimizer.ts":
+/*!*******************************************!*\
+  !*** ./src/NumericConstraintOptimizer.ts ***!
+  \*******************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.detectNumericComparisonPattern = detectNumericComparisonPattern;
+exports.areAllNumericSets = areAllNumericSets;
+exports.generateOptimizedNumericCombinations = generateOptimizedNumericCombinations;
+/**
+ * Detects if a constraint expression is a simple numeric comparison between two variables.
+ * Currently detects patterns like: a < b, a > b, a <= b, a >= b, a != b
+ *
+ * Note: Uses string matching on expression text which is simple but may miss expressions
+ * with extra whitespace or parentheses. This is intentionally conservative - we prefer
+ * to fall back to the standard approach rather than risk incorrect optimization.
+ *
+ * @param constraintExpr The constraint expression to analyze
+ * @param varNames The variable names in scope
+ * @returns Pattern info if detected, null otherwise
+ */
+function detectNumericComparisonPattern(constraintExpr, varNames) {
+    // Parse the expression text to look for simple comparison patterns
+    const exprText = constraintExpr.text;
+    // Check if this is a simple binary comparison between two variables
+    // Pattern: <varName1><compareOp><varName2> (no whitespace in text representation)
+    // Note: The AST text property concatenates tokens without whitespace
+    // Try to extract comparison operator and operands
+    for (const leftVar of varNames) {
+        for (const rightVar of varNames) {
+            if (leftVar === rightVar)
+                continue;
+            // Check for different comparison operators (whitespace already removed in text)
+            if (exprText === `${leftVar}<${rightVar}`) {
+                return { type: 'less_than', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}>${rightVar}`) {
+                return { type: 'greater_than', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}<=${rightVar}`) {
+                return { type: 'less_equal', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}>=${rightVar}`) {
+                return { type: 'greater_equal', leftVar, rightVar };
+            }
+            if (exprText === `${leftVar}!=${rightVar}`) {
+                return { type: 'not_equal', leftVar, rightVar };
+            }
+            // Also check for negated equality: not a = b
+            if (exprText === `not${leftVar}=${rightVar}`) {
+                return { type: 'not_equal', leftVar, rightVar };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Checks if all values in the sets are numbers (or tuples containing single numbers).
+ * This is required for numeric comparison optimization to be applicable.
+ */
+function areAllNumericSets(sets) {
+    for (const set of sets) {
+        for (const tuple of set) {
+            if (tuple.length !== 1)
+                return false;
+            if (typeof tuple[0] !== 'number')
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Extracts numbers from tuples that contain single numbers.
+ * Precondition: This should only be called after areAllNumericSets validation.
+ */
+function extractNumbers(tuples) {
+    return tuples.map(t => t[0]);
+}
+/**
+ * Generates optimized combinations for numeric comparison constraints.
+ * Instead of generating all combinations and filtering, generates only valid ones.
+ *
+ * @param varNames Variable names in order
+ * @param quantifiedSets The sets each variable ranges over
+ * @param pattern The detected numeric comparison pattern
+ * @returns Only the tuples that satisfy the constraint
+ */
+function generateOptimizedNumericCombinations(varNames, quantifiedSets, pattern) {
+    // Map variable names to their indices and value sets
+    const varIndexMap = new Map();
+    varNames.forEach((name, idx) => {
+        varIndexMap.set(name, idx);
+    });
+    const leftIdx = varIndexMap.get(pattern.leftVar);
+    const rightIdx = varIndexMap.get(pattern.rightVar);
+    if (leftIdx === undefined || rightIdx === undefined) {
+        // Pattern variables don't match our variable set - this shouldn't happen
+        // if detectNumericComparisonPattern is working correctly, but throw an error
+        // to prevent incorrect results (caller should have validated pattern matches variables)
+        throw new Error(`Internal error: Pattern variables ${pattern.leftVar}, ${pattern.rightVar} not found in variable list`);
+    }
+    // Extract numeric values
+    const leftNumbers = extractNumbers(quantifiedSets[leftIdx]);
+    const rightNumbers = extractNumbers(quantifiedSets[rightIdx]);
+    // For other variables, we still need all combinations
+    const otherVars = [];
+    const otherSets = [];
+    for (let i = 0; i < varNames.length; i++) {
+        if (i !== leftIdx && i !== rightIdx) {
+            otherVars.push(i);
+            otherSets.push(extractNumbers(quantifiedSets[i]));
+        }
+    }
+    const result = [];
+    // Generate combinations based on the comparison type
+    const generatePairs = (compareFunc) => {
+        for (const leftVal of leftNumbers) {
+            for (const rightVal of rightNumbers) {
+                if (compareFunc(leftVal, rightVal)) {
+                    // This pair satisfies the constraint
+                    // Now combine with all other variables if any
+                    if (otherVars.length === 0) {
+                        // Simple case: only two variables
+                        const tuple = new Array(varNames.length);
+                        tuple[leftIdx] = leftVal;
+                        tuple[rightIdx] = rightVal;
+                        result.push(tuple);
+                    }
+                    else {
+                        // Need to generate cartesian product with other variables
+                        const otherCombos = cartesianProduct(otherSets);
+                        for (const otherCombo of otherCombos) {
+                            const tuple = new Array(varNames.length);
+                            tuple[leftIdx] = leftVal;
+                            tuple[rightIdx] = rightVal;
+                            for (let i = 0; i < otherVars.length; i++) {
+                                tuple[otherVars[i]] = otherCombo[i];
+                            }
+                            result.push(tuple);
+                        }
+                    }
+                }
+            }
+        }
+    };
+    switch (pattern.type) {
+        case 'less_than':
+            generatePairs((a, b) => a < b);
+            break;
+        case 'greater_than':
+            generatePairs((a, b) => a > b);
+            break;
+        case 'less_equal':
+            generatePairs((a, b) => a <= b);
+            break;
+        case 'greater_equal':
+            generatePairs((a, b) => a >= b);
+            break;
+        case 'not_equal':
+            generatePairs((a, b) => a !== b);
+            break;
+        default:
+            // Unknown pattern, return empty (will fall back to standard approach)
+            return [];
+    }
+    return result;
+}
+/**
+ * Helper to generate cartesian product of number arrays
+ */
+function cartesianProduct(arrays) {
+    if (arrays.length === 0)
+        return [[]];
+    if (arrays.some(arr => arr.length === 0))
+        return [];
+    let result = [[]];
+    for (const arr of arrays) {
+        const newResult = [];
+        for (const existing of result) {
+            for (const value of arr) {
+                newResult.push([...existing, value]);
+            }
+        }
+        result = newResult;
+    }
+    return result;
+}
+
+
 /***/ }),
 
 /***/ "./src/errorListener.ts":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-graph-query",
-  "version": "2.1.4",
+  "version": "2.2.1",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",