simple-graph-query 2.5.0 → 2.5.2

package/dist/SelectorSynthesizer.d.ts

@@ -8,7 +8,7 @@ export type BinaryRelationExample = {
     pairs: Set<AtomPair>;
     datum: IDataInstance;
 };
-type ExpressionNode = {
+export type ExpressionNode = {
     kind: "identifier";
     name: string;
 } | {
@@ -22,6 +22,41 @@ type ExpressionNode = {
 } | {
     kind: "closure";
     child: ExpressionNode;
+} | {
+    kind: "reflexive-closure";
+    child: ExpressionNode;
+} | {
+    kind: "transpose";
+    child: ExpressionNode;
+} | {
+    kind: "comprehension";
+    varName: string;
+    domain: ExpressionNode;
+    body: ExpressionNode;
+} | {
+    kind: "all" | "some" | "no" | "one" | "lone";
+    varName: string;
+    domain: ExpressionNode;
+    body: ExpressionNode;
+} | {
+    kind: "and" | "or" | "implies" | "iff";
+    left: ExpressionNode;
+    right: ExpressionNode;
+} | {
+    kind: "not";
+    child: ExpressionNode;
+} | {
+    kind: "in" | "eq" | "neq";
+    left: ExpressionNode;
+    right: ExpressionNode;
+} | {
+    kind: "lt" | "gt" | "lte" | "gte";
+    left: ExpressionNode;
+    right: ExpressionNode;
+} | {
+    kind: "box-join";
+    base: ExpressionNode;
+    args: ExpressionNode[];
 };
 export type WhyNode = {
     kind: ExpressionNode["kind"];
@@ -45,4 +80,3 @@ export type SynthesisWhy = {
 };
 export declare function synthesizeSelectorWithWhy(examples: AtomSelectionExample[], maxDepth?: number): SynthesisWhy;
 export declare function synthesizeBinaryRelationWithWhy(examples: BinaryRelationExample[], maxDepth?: number): SynthesisWhy;
-export {};

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

@@ -49080,6 +49080,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                         this.cacheResult(ctx, freeVarsKey, value);
                         return value;
                     }
+                    if (multExpr.TWO_TOK() && result.length > 2) {
+                        this.environmentStack.pop();
+                        const value = false;
+                        this.cacheResult(ctx, freeVarsKey, value);
+                        return value;
+                    }
                 }
             }
             this.environmentStack.pop();
@@ -49111,7 +49117,9 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return value;
                 }
                 else if (multExpr.TWO_TOK()) {
-                    throw new Error("**NOT IMPLEMENTING FOR NOW** Two (`two`)");
+                    const value = result.length === 2;
+                    this.cacheResult(ctx, freeVarsKey, value);
+                    return value;
                 }
             }
             // TODO: don't have support for SUM_TOK yet
@@ -49205,12 +49213,27 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             if (!isBoolean(leftChildValue)) {
                 throw new Error("IMP operator expected 2 boolean operands!");
             }
+            const expr3Values = ctx.expr3() ?? [];
+            const thenExpr = expr3Values[0];
+            const elseExpr = expr3Values[1];
+            if (ctx.ELSE_TOK()) {
+                if (!thenExpr || !elseExpr) {
+                    throw new Error("Expected the ELSE operator to have 2 operands!");
+                }
+                const branchValue = this.visit(leftChildValue ? thenExpr : elseExpr);
+                if (!isBoolean(branchValue)) {
+                    throw new Error("IMP operator expected 2 boolean operands!");
+                }
+                return branchValue;
+            }
             if (!leftChildValue) {
                 // short circuit if the antecedent is false
                 return true;
             }
-            const rightChildValue = this.visit(ctx.expr3()[0]);
-            // TODO: add support for ELSE_TOK over here
+            if (!thenExpr) {
+                throw new Error("Expected the IMP operator to have a consequent expression!");
+            }
+            const rightChildValue = this.visit(thenExpr);
             if (!isBoolean(rightChildValue)) {
                 throw new Error("IMP operator expected 2 boolean operands!");
             }
@@ -49426,37 +49449,31 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     results = leftNum >= rightNum;
                     break;
                 case "in":
+                case "ni": {
+                    let membershipResult;
                     // this should be true if the left value is equal to the right value,
                     // or a subset of it
                     if (isTupleArray(leftChildValue) && isTupleArray(rightChildValue)) {
                         if (areTupleArraysEqual(leftChildValue, rightChildValue)) {
-                            results = true;
+                            membershipResult = true;
                         }
                         else {
                             // check if left is subset of right
-                            results = isTupleArraySubset(leftChildValue, rightChildValue);
+                            membershipResult = isTupleArraySubset(leftChildValue, rightChildValue);
                         }
                     }
                     else if (isTupleArray(rightChildValue)) {
-                        results = rightChildValue.some((tuple) => tuple.length === 1 && tuple[0] === leftChildValue);
+                        membershipResult = rightChildValue.some((tuple) => tuple.length === 1 && tuple[0] === leftChildValue);
                     }
                     else {
                         // left is a tuple array but right is a single value, so false
-                        results = false;
+                        membershipResult = false;
                     }
+                    results = ctx.compareOp()?.text === "ni" ? !membershipResult : membershipResult;
                     break;
+                }
                 case "is":
                     throw new Error("**NOT IMPLEMENTING FOR NOW** Type Check (`is`)");
-                case "ni":
-                    results.push(["**UNIMPLEMENTED** Set Non-Membership (`ni`)"]);
-                    // TODO: implement this using leftValue and rightValue
-                    //       for now, just returning over here. what we need to do instead
-                    //       is to implement this, set the value of results to what we get
-                    //       from this, and then call break (so that we can negate before
-                    //       returning the final value, if required)
-                    return results;
-                    // removed by dead control flow
-{} // redundant, but it won't be once we implement the TODO above
                 default:
                     throw new Error(`Unexpected compare operator provided: ${ctx.compareOp()?.text}`);
             }
@@ -49479,13 +49496,13 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         const childrenResults = this.visit(ctx.expr8());
         //console.log('childrenResults:', childrenResults);
         if (ctx.SET_TOK()) {
-            throw new Error("**NOT IMPLEMENTING FOR NOW** Set (`set`)");
+            return childrenResults;
         }
         if (ctx.ONE_TOK()) {
             return isTupleArray(childrenResults) && childrenResults.length === 1;
         }
         if (ctx.TWO_TOK()) {
-            throw new Error("**NOT IMPLEMENTING FOR NOW** Two (`two`)");
+            return isTupleArray(childrenResults) && childrenResults.length === 2;
         }
         if (ctx.NO_TOK()) {
             return isTupleArray(childrenResults) && childrenResults.length === 0;
@@ -50955,10 +50972,20 @@ function nodeToString(node) {
     switch (node.kind) {
         case "identifier":
             return node.name;
+        // Unary relational operators
         case "closure": {
             const inner = nodeToString(node.child);
             return `^${wrapForPrefix(inner)}`;
         }
+        case "reflexive-closure": {
+            const inner = nodeToString(node.child);
+            return `*${wrapForPrefix(inner)}`;
+        }
+        case "transpose": {
+            const inner = nodeToString(node.child);
+            return `~${wrapForPrefix(inner)}`;
+        }
+        // Binary relational operators
         case "join": {
             const left = wrapForJoin(node.left);
             const right = wrapForJoin(node.right);
@@ -50970,10 +50997,59 @@ function nodeToString(node) {
             return `(${nodeToString(node.left)} & ${nodeToString(node.right)})`;
         case "difference":
             return `(${nodeToString(node.left)} - ${nodeToString(node.right)})`;
+        // Set comprehension
+        case "comprehension":
+            return `{${node.varName}: ${nodeToString(node.domain)} | ${nodeToString(node.body)}}`;
+        // Quantified expressions
+        case "all":
+            return `(all ${node.varName}: ${nodeToString(node.domain)} | ${nodeToString(node.body)})`;
+        case "some":
+            return `(some ${node.varName}: ${nodeToString(node.domain)} | ${nodeToString(node.body)})`;
+        case "no":
+            return `(no ${node.varName}: ${nodeToString(node.domain)} | ${nodeToString(node.body)})`;
+        case "one":
+            return `(one ${node.varName}: ${nodeToString(node.domain)} | ${nodeToString(node.body)})`;
+        case "lone":
+            return `(lone ${node.varName}: ${nodeToString(node.domain)} | ${nodeToString(node.body)})`;
+        // Logical operators
+        case "and":
+            return `(${nodeToString(node.left)} and ${nodeToString(node.right)})`;
+        case "or":
+            return `(${nodeToString(node.left)} or ${nodeToString(node.right)})`;
+        case "implies":
+            return `(${nodeToString(node.left)} => ${nodeToString(node.right)})`;
+        case "iff":
+            return `(${nodeToString(node.left)} <=> ${nodeToString(node.right)})`;
+        case "not":
+            return `!${wrapForPrefix(nodeToString(node.child))}`;
+        // Relational comparison
+        case "in":
+            return `(${nodeToString(node.left)} in ${nodeToString(node.right)})`;
+        case "eq":
+            return `(${nodeToString(node.left)} = ${nodeToString(node.right)})`;
+        case "neq":
+            return `(${nodeToString(node.left)} != ${nodeToString(node.right)})`;
+        // Numeric comparison
+        case "lt":
+            return `(${nodeToString(node.left)} < ${nodeToString(node.right)})`;
+        case "gt":
+            return `(${nodeToString(node.left)} > ${nodeToString(node.right)})`;
+        case "lte":
+            return `(${nodeToString(node.left)} <= ${nodeToString(node.right)})`;
+        case "gte":
+            return `(${nodeToString(node.left)} >= ${nodeToString(node.right)})`;
+        // Box join
+        case "box-join":
+            return `${nodeToString(node.base)}[${node.args.map(nodeToString).join(", ")}]`;
     }
 }
 function wrapForJoin(node) {
-    if (node.kind === "identifier" || node.kind === "closure") {
+    // Identifiers and prefix unary operators don't need wrapping
+    if (node.kind === "identifier" ||
+        node.kind === "closure" ||
+        node.kind === "reflexive-closure" ||
+        node.kind === "transpose" ||
+        node.kind === "box-join") {
         return nodeToString(node);
     }
     return `(${nodeToString(node)})`;
@@ -50997,10 +51073,16 @@ function normalizeUnaryResult(result) {
             return null;
         }
         const value = tuple[0];
-        if (typeof value !== "string") {
+        // Accept strings or numbers (integers are often returned as numbers)
+        if (typeof value === "string") {
+            ids.add(value);
+        }
+        else if (typeof value === "number") {
+            ids.add(String(value));
+        }
+        else {
             return null;
         }
-        ids.add(value);
     }
     return ids;
 }
@@ -51015,10 +51097,13 @@ function normalizeBinaryResult(result) {
             return null;
         }
         const [first, second] = tuple;
-        if (typeof first !== "string" || typeof second !== "string") {
+        // Accept strings or numbers for both elements
+        const firstStr = typeof first === "string" ? first : typeof first === "number" ? String(first) : null;
+        const secondStr = typeof second === "string" ? second : typeof second === "number" ? String(second) : null;
+        if (firstStr === null || secondStr === null) {
             return null;
         }
-        ids.add(`${first}\u0000${second}`);
+        ids.add(`${firstStr}\u0000${secondStr}`);
     }
     return ids;
 }
@@ -51068,6 +51153,99 @@ function classifyIdentifier(name, datums) {
     }
     return "other";
 }
+// Build semantically meaningful join candidates based on type-relation compatibility.
+// For a relation with types [T1, T2, ...], we generate joins like T1.relation
+// which projects the relation to its range. This helps synthesize expressions
+// like "Node.key" when selecting integer values that are keys of nodes.
+function buildSemanticJoinCandidates(datums) {
+    const candidates = [];
+    const seenExpressions = new Set();
+    // Get relations and types that exist across all datums
+    const sharedRelationNames = new Set();
+    const sharedTypeIds = new Set();
+    if (datums.length === 0)
+        return candidates;
+    // Initialize with first datum
+    const firstDatum = datums[0];
+    firstDatum.getRelations().forEach((r) => sharedRelationNames.add(r.name));
+    firstDatum.getTypes().forEach((t) => sharedTypeIds.add(t.id));
+    // Intersect with remaining datums
+    for (let i = 1; i < datums.length; i++) {
+        const datum = datums[i];
+        const datumRelations = new Set(datum.getRelations().map((r) => r.name));
+        const datumTypes = new Set(datum.getTypes().map((t) => t.id));
+        for (const name of sharedRelationNames) {
+            if (!datumRelations.has(name))
+                sharedRelationNames.delete(name);
+        }
+        for (const id of sharedTypeIds) {
+            if (!datumTypes.has(id))
+                sharedTypeIds.delete(id);
+        }
+    }
+    // For each shared relation, check if its domain type is also shared
+    // and create Type.relation join candidates
+    for (const relationName of sharedRelationNames) {
+        // Get the relation's type signature from the first datum (should be consistent)
+        const relation = firstDatum.getRelations().find((r) => r.name === relationName);
+        if (!relation || relation.types.length < 2)
+            continue;
+        const domainType = relation.types[0];
+        // Check if the domain type (or a compatible type) is available
+        // We look for types in the hierarchy that could be the domain
+        for (const typeId of sharedTypeIds) {
+            const typeObj = firstDatum.getTypes().find((t) => t.id === typeId);
+            if (!typeObj)
+                continue;
+            // Check if this type is compatible with the relation's domain
+            // Either the type itself matches, or it's in the type hierarchy
+            const isCompatible = typeId === domainType ||
+                typeObj.types.includes(domainType) ||
+                // Also check if the domain type is a subtype of this type
+                firstDatum.getTypes().find((t) => t.id === domainType)?.types.includes(typeId);
+            if (isCompatible) {
+                const joinNode = {
+                    kind: "join",
+                    left: { kind: "identifier", name: typeId },
+                    right: { kind: "identifier", name: relationName },
+                };
+                const exprString = nodeToString(joinNode);
+                if (!seenExpressions.has(exprString)) {
+                    seenExpressions.add(exprString);
+                    candidates.push(joinNode);
+                }
+            }
+        }
+    }
+    // Also add relation.Type joins for inverse projections (getting domain values)
+    for (const relationName of sharedRelationNames) {
+        const relation = firstDatum.getRelations().find((r) => r.name === relationName);
+        if (!relation || relation.types.length < 2)
+            continue;
+        const rangeType = relation.types[relation.types.length - 1];
+        for (const typeId of sharedTypeIds) {
+            const typeObj = firstDatum.getTypes().find((t) => t.id === typeId);
+            if (!typeObj)
+                continue;
+            const isCompatible = typeId === rangeType ||
+                typeObj.types.includes(rangeType) ||
+                firstDatum.getTypes().find((t) => t.id === rangeType)?.types.includes(typeId);
+            if (isCompatible) {
+                const joinNode = {
+                    kind: "join",
+                    left: { kind: "identifier", name: relationName },
+                    right: { kind: "identifier", name: typeId },
+                };
+                const exprString = nodeToString(joinNode);
+                if (!seenExpressions.has(exprString)) {
+                    seenExpressions.add(exprString);
+                    candidates.push(joinNode);
+                }
+            }
+        }
+    }
+    return candidates;
+}
 function buildBaseNodes(datums) {
     const baseNames = intersectNames(datums);
     // Always include standard top-level identifiers when present in the language
@@ -51125,11 +51303,20 @@ function synthesizeExpressionNode(examples, normalizer, maxDepth = 3) {
     if (baseNodes.length === 0) {
         throw new SelectorSynthesisError("No shared identifiers available across provided data instances");
     }
+    // Check base identifiers first
     for (const node of baseNodes) {
         if (matchesTargets(node, evaluatedExamples, normalizer)) {
             return node;
         }
     }
+    // Check semantic join candidates early - these are type-aware joins like Node.key
+    // that are likely to be what the user wants when selecting relation ranges/domains
+    const semanticJoins = buildSemanticJoinCandidates(datums);
+    for (const node of semanticJoins) {
+        if (matchesTargets(node, evaluatedExamples, normalizer)) {
+            return node;
+        }
+    }
     const queue = [];
     const queued = new Set();
     const visited = new Set();
@@ -51141,6 +51328,10 @@ function synthesizeExpressionNode(examples, normalizer, maxDepth = 3) {
         queue.push({ node, depth });
         queued.add(key);
     };
+    // Mark semantic joins as already visited so we don't re-check them
+    for (const node of semanticJoins) {
+        visited.add(nodeToString(node));
+    }
     baseNodes.forEach((node) => enqueue(node, 0));
     while (queue.length > 0) {
         const current = queue.shift();
@@ -51156,18 +51347,69 @@ function synthesizeExpressionNode(examples, normalizer, maxDepth = 3) {
         if (current.depth >= maxDepth) {
             continue;
         }
-        // Unary expansions
+        // Unary relational expansions
         enqueue({ kind: "closure", child: current.node }, current.depth + 1);
+        enqueue({ kind: "reflexive-closure", child: current.node }, current.depth + 1);
+        enqueue({ kind: "transpose", child: current.node }, current.depth + 1);
         for (const other of combinationPool) {
             const leftKey = nodeToString(current.node);
             const rightKey = nodeToString(other);
+            // Set operations (commutative, so canonicalize order)
             const [unionLeft, unionRight] = leftKey < rightKey ? [current.node, other] : [other, current.node];
             enqueue({ kind: "union", left: unionLeft, right: unionRight }, current.depth + 1);
             const [interLeft, interRight] = leftKey < rightKey ? [current.node, other] : [other, current.node];
             enqueue({ kind: "intersection", left: interLeft, right: interRight }, current.depth + 1);
+            // Difference is not commutative
+            enqueue({ kind: "difference", left: current.node, right: other }, current.depth + 1);
+            if (leftKey !== rightKey) {
+                enqueue({ kind: "difference", left: other, right: current.node }, current.depth + 1);
+            }
+            // Join is not commutative
             enqueue({ kind: "join", left: current.node, right: other }, current.depth + 1);
             enqueue({ kind: "join", left: other, right: current.node }, current.depth + 1);
         }
+        // Generate set comprehensions: {v: domain | body}
+        // For each type, try comprehensions with simple membership conditions
+        // This allows synthesizing expressions like {n: Node | n.key in SomeSet}
+        if (current.depth + 2 <= maxDepth) {
+            for (const domainNode of combinationPool) {
+                // Only use types as comprehension domains
+                if (domainNode.kind !== "identifier")
+                    continue;
+                const domainName = domainNode.name;
+                const classification = classifyIdentifier(domainName, datums);
+                if (classification !== "type")
+                    continue;
+                const varName = "v"; // Use a simple variable name
+                // Try: {v: Domain | v in current.node}
+                const varNode = { kind: "identifier", name: varName };
+                enqueue({
+                    kind: "comprehension",
+                    varName,
+                    domain: domainNode,
+                    body: { kind: "in", left: varNode, right: current.node },
+                }, current.depth + 2);
+                // Try: {v: Domain | v.relation in SomeSet} for relations
+                for (const relNode of combinationPool) {
+                    if (relNode.kind !== "identifier")
+                        continue;
+                    if (classifyIdentifier(relNode.name, datums) !== "relation")
+                        continue;
+                    const joinExpr = {
+                        kind: "join",
+                        left: varNode,
+                        right: relNode,
+                    };
+                    // {v: Domain | v.relation in current.node}
+                    enqueue({
+                        kind: "comprehension",
+                        varName,
+                        domain: domainNode,
+                        body: { kind: "in", left: joinExpr, right: current.node },
+                    }, current.depth + 2);
+                }
+            }
+        }
     }
     throw new SelectorSynthesisError("Unable to synthesize an expression matching all examples");
 }
@@ -51195,14 +51437,31 @@ function buildWhyNode(node, evaluator, normalizer) {
         result,
     };
     switch (node.kind) {
+        // Leaves
         case "identifier":
             return base;
+        // Unary operators
         case "closure":
+        case "reflexive-closure":
+        case "transpose":
+        case "not":
             return { ...base, children: [buildWhyNode(node.child, evaluator, normalizer)] };
+        // Binary operators
         case "join":
         case "union":
         case "intersection":
         case "difference":
+        case "and":
+        case "or":
+        case "implies":
+        case "iff":
+        case "in":
+        case "eq":
+        case "neq":
+        case "lt":
+        case "gt":
+        case "lte":
+        case "gte":
             return {
                 ...base,
                 children: [
@@ -51210,6 +51469,29 @@ function buildWhyNode(node, evaluator, normalizer) {
                     buildWhyNode(node.right, evaluator, normalizer),
                 ],
             };
+        // Quantified and comprehension expressions
+        case "all":
+        case "some":
+        case "no":
+        case "one":
+        case "lone":
+        case "comprehension":
+            return {
+                ...base,
+                children: [
+                    buildWhyNode(node.domain, evaluator, normalizer),
+                    buildWhyNode(node.body, evaluator, normalizer),
+                ],
+            };
+        // Box join
+        case "box-join":
+            return {
+                ...base,
+                children: [
+                    buildWhyNode(node.base, evaluator, normalizer),
+                    ...node.args.map((arg) => buildWhyNode(arg, evaluator, normalizer)),
+                ],
+            };
         default:
             return base;
     }

package/package.json

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