simple-graph-query 2.2.0 → 2.3.0

package/dist/ForgeExprEvaluator.d.ts

@@ -27,6 +27,9 @@ export declare class ForgeExprEvaluator extends AbstractParseTreeVisitor<EvalRes
     private getLabelAsString;
     private getLabelAsBoolean;
     private getLabelAsNumber;
+    private isConvertibleToNumber;
+    private isConvertibleToBoolean;
+    private convertToBoolean;
     private dotJoin;
     private cacheResult;
     private getIden;

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" ||
@@ -48618,28 +48619,11 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         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));
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToNumber(value) ? Number(value) : value));
+            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToBoolean(value) ? this.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();
@@ -48750,6 +48734,39 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         }
         return labelNum;
     }
+    // Helper function to check if a value can be converted to a number
+    isConvertibleToNumber(value) {
+        if (typeof value === "number") {
+            return true;
+        }
+        if (typeof value === "string") {
+            return !isNaN(Number(value));
+        }
+        return false;
+    }
+    // Helper function to check if a value can be converted to a boolean
+    isConvertibleToBoolean(value) {
+        if (typeof value === "boolean") {
+            return true;
+        }
+        if (typeof value === "string") {
+            return (value === "true" || value === "#t" || value === "false" || value === "#f");
+        }
+        return false;
+    }
+    // Helper function to convert a value to boolean
+    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`);
+    }
     // Optimized dotJoin that can use pre-built relation indexes
     dotJoin(left, right, rightRelationName) {
         const leftExpr = isSingleValue(left) ? [[left]] : left;
@@ -48959,7 +48976,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;
@@ -48990,10 +49026,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);
@@ -49924,6 +49969,42 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 // }
                 return value;
             }
+            // Handle iden (identity relation)
+            if (constant.IDEN_TOK() !== undefined) {
+                // The identity relation contains tuples (x, x) for every atom x in the universe
+                const atoms = this.instanceData.getAtoms();
+                const idenRelation = [];
+                for (const atom of atoms) {
+                    let atomValue = atom.id;
+                    // Convert numeric and boolean strings to their actual types
+                    if (this.isConvertibleToNumber(atomValue)) {
+                        atomValue = Number(atomValue);
+                    }
+                    else if (this.isConvertibleToBoolean(atomValue)) {
+                        atomValue = this.convertToBoolean(atomValue);
+                    }
+                    idenRelation.push([atomValue, atomValue]);
+                }
+                return idenRelation;
+            }
+            // Handle univ (universal relation - all atoms)
+            if (constant.UNIV_TOK() !== undefined) {
+                // The universal relation contains all atoms as unary tuples
+                const atoms = this.instanceData.getAtoms();
+                const univRelation = [];
+                for (const atom of atoms) {
+                    let atomValue = atom.id;
+                    // Convert numeric and boolean strings to their actual types
+                    if (this.isConvertibleToNumber(atomValue)) {
+                        atomValue = Number(atomValue);
+                    }
+                    else if (this.isConvertibleToBoolean(atomValue)) {
+                        atomValue = this.convertToBoolean(atomValue);
+                    }
+                    univRelation.push([atomValue]);
+                }
+                return univRelation;
+            }
             // Handle boolean constants
             if (constant.text === 'true') {
                 return true;
@@ -49973,7 +50054,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 = {
@@ -49987,10 +50089,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
@@ -50125,46 +50236,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 }
             }
         }
-        // defining 3 helper functions here; not for use elsewhere
-        const isConvertibleToNumber = (value) => {
-            if (typeof value === "number") {
-                return true;
-            }
-            if (typeof value === "string") {
-                return !isNaN(Number(value));
-            }
-            return false;
-        };
-        const isConvertibleToBoolean = (value) => {
-            if (typeof value === "boolean") {
-                return true;
-            }
-            if (typeof value === "string") {
-                return (value === "true" || value === "#t" || value === "false" || value === "#f");
-            }
-            return false;
-        };
-        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`);
-        };
-        // end of 3 helper functions
+        // end of type search
         // 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));
-            result = result.map((tuple) => tuple.map((value) => isConvertibleToBoolean(value) ? convertToBoolean(value) : value));
+            result = result.map((tuple) => tuple.map((value) => this.isConvertibleToNumber(value) ? Number(value) : value));
+            result = result.map((tuple) => tuple.map((value) => this.isConvertibleToBoolean(value) ? this.convertToBoolean(value) : value));
             return result;
         }
         // return identifier;
@@ -50657,6 +50737,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.2.0",
+  "version": "2.3.0",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",