relationalai 0.12.7__py3-none-any.whl → 0.12.8__py3-none-any.whl

relationalai/semantics/reasoners/graph/core.py

@@ -2368,7 +2368,8 @@ class Graph():
         """Returns a binary relationship containing the degree of each node.
 
         For directed graphs, a node's degree is the sum of its indegree and
-        outdegree.
+        outdegree. For undirected graphs, a self-loop contributes +2 to the
+        node's degree.
 
         Parameters
         ----------
@@ -2392,17 +2393,17 @@ class Graph():
 
         Supported Graph Types
         ---------------------
-        | Graph Type | Supported | Notes                |
-        | :--------- | :-------- | :------------------- |
-        | Undirected | Yes       |                      |
-        | Directed   | Yes       |                      |
-        | Weighted   | Yes       | Weights are ignored. |
+        | Graph Type | Supported | Notes                          |
+        | :--------- | :-------- | :----------------------------- |
+        | Undirected | Yes       | A self-loop contributes +2.    |
+        | Directed   | Yes       |                                |
+        | Weighted   | Yes       | Weights are ignored.           |
 
         Examples
         --------
         **Undirected Graph Example**
 
-        >>> from relationalai.semantics import Model, define, select, where
+        >>> from relationalai.semantics import Model, define, select, where, Integer, union
         >>> from relationalai.semantics.reasoners.graph import Graph
         >>>
         >>> # 1. Set up an undirected graph
@@ -2428,7 +2429,7 @@ class Graph():
            id  node_degree
         0   1            1
         1   2            3
-        2   3            2
+        2   3            3
         3   4            1
 
         >>> # 4. Use 'of' parameter to constrain the set of nodes to compute degree of
@@ -2443,7 +2444,7 @@ class Graph():
         ▰▰▰▰ Setup complete
            id  node_degree
         0   2            3
-        1   3            2
+        1   3            3
 
         **Directed Graph Example**
 
@@ -2533,6 +2534,7 @@ class Graph():
     def _create_degree_relationship(self, *, node_subset: Optional[Relationship]):
         _degree_rel = self._model.Relationship(f"{{node:{self._NodeConceptStr}}} has degree {{count:Integer}}")
 
+        node = self.Node.ref()
         if self.directed:
             # For directed graphs, degree is the sum of indegree and outdegree.
             if node_subset is None:
@@ -2544,22 +2546,35 @@ class Graph():
 
             incount, outcount = Integer.ref(), Integer.ref()
             where(
-                indegree_rel(self.Node, incount),
-                outdegree_rel(self.Node, outcount),
-            ).define(_degree_rel(self.Node, incount + outcount))
+                indegree_rel(node, incount),
+                outdegree_rel(node, outcount),
+            ).define(_degree_rel(node, incount + outcount))
         else:
-            # For undirected graphs, degree is the count of neighbors.
+            # For undirected graphs, degree counts each non-loop edge once and each
+            # self-loop twice. Self-loops can be computed as the difference between
+            # count_neighbor and degree_no_self, where degree_no_self counts neighbors
+            # excluding self-loops.
+
+            # _self_loop_count := _neighbor_count - _degree_no_self
+            # _degree := _degree_no_self + 2 * _self_loop_count
+            # Therefore:
+            # _degree := 2 * _neighbor_count - _degree_no_self
+
             if node_subset is None:
-                node_set = self.Node
                 count_neighbor_rel = self._count_neighbor
+                degree_no_self_rel = self._degree_no_self
             else:
-                node_set = node_subset
                 count_neighbor_rel = self._count_neighbor_of(node_subset)
+                degree_no_self_rel = self._degree_no_self_of(node_subset)
 
+            _degree_no_self = Integer.ref()
             where(
-                node_set(self.Node), # Necessary given the match on the following line.
-                _degree := where(count_neighbor_rel(self.Node, Integer)).select(Integer) | 0,
-            ).define(_degree_rel(self.Node, _degree))
+                # No explicit node constraint needed here, as `_degree_no_self_of`
+                # relation is constrained to `node_subset`.
+                _neighbor_count := where(count_neighbor_rel(node, Integer)).select(Integer) | 0,
+                degree_no_self_rel(node, _degree_no_self),
+                _degree := 2 * _neighbor_count - _degree_no_self
+            ).define(_degree_rel(node, _degree))
 
         return _degree_rel
 
@@ -2569,7 +2584,8 @@ class Graph():
         """Returns a binary relationship containing the indegree of each node.
 
         A node's indegree is the number of incoming edges. For undirected
-        graphs, a node's indegree is identical to its degree.
+        graphs, a node's indegree is identical to its degree, except self-loops
+        contribute only +1 to a node's indegree.
 
         Parameters
         ----------
@@ -2593,11 +2609,11 @@ class Graph():
 
         Supported Graph Types
         ---------------------
-        | Graph Type | Supported | Notes                   |
-        | :--------- | :-------- | :---------------------- |
-        | Undirected | Yes       | Identical to `degree`.  |
-        | Directed   | Yes       |                         |
-        | Weighted   | Yes       | Weights are ignored.    |
+        | Graph Type | Supported | Notes                                         |
+        | :--------- | :-------- | :-------------------------------------------- |
+        | Undirected | Yes       | Identical to `degree`, except for self-loops. |
+        | Directed   | Yes       |                                               |
+        | Weighted   | Yes       | Weights are ignored.                          |
 
         Examples
         --------
@@ -2752,7 +2768,8 @@ class Graph():
         """Returns a binary relationship containing the outdegree of each node.
 
         A node's outdegree is the number of outgoing edges. For undirected
-        graphs, a node's outdegree is identical to its degree.
+        graphs, a node's outdegree is identical to its degree, except self-loops
+        contribute only +1 to a node's outdegree.
 
         Parameters
         ----------
@@ -2776,11 +2793,11 @@ class Graph():
 
         Supported Graph Types
         ---------------------
-        | Graph Type | Supported | Notes                   |
-        | :--------- | :-------- | :---------------------- |
-        | Undirected | Yes       | Identical to `degree`.  |
-        | Directed   | Yes       |                         |
-        | Weighted   | Yes       | Weights are ignored.    |
+        | Graph Type | Supported | Notes                                         |
+        | :--------- | :-------- | :-------------------------------------------- |
+        | Undirected | Yes       | Identical to `degree`, except for self-loops. |
+        | Directed   | Yes       |                                               |
+        | Weighted   | Yes       | Weights are ignored.                          |
 
         Examples
         --------
@@ -2937,8 +2954,9 @@ class Graph():
 
         A node's weighted degree is the sum of the weights of all edges
         connected to it. For directed graphs, this is the sum of the weights
-        of both incoming and outgoing edges. For unweighted graphs, all edge
-        weights are considered to be 1.0.
+        of both incoming and outgoing edges. For undirected graphs, the weights
+        of self-loops contribute twice to the node's weighted degree. For
+        unweighted graphs, all edge weights are considered to be 1.0.
 
         Parameters
         ----------
@@ -2962,11 +2980,11 @@ class Graph():
 
         Supported Graph Types
         ---------------------
-        | Graph Type   | Supported | Notes                              |
-        | :----------- | :-------- | :--------------------------------- |
-        | Undirected   | Yes       |                                    |
-        | Directed     | Yes       |                                    |
-        | Weighted     | Yes       |                                    |
+        | Graph Type   | Supported | Notes                                  |
+        | :----------- | :-------- | :------------------------------------- |
+        | Undirected   | Yes       | A self-loop contributes twice.         |
+        | Directed     | Yes       |                                        |
+        | Weighted     | Yes       |                                        |
         | Unweighted   | Yes       | Edge weights are considered to be 1.0. |
 
         Examples
@@ -2984,7 +3002,7 @@ class Graph():
         >>> define(n1, n2, n3)
         >>> define(
         ...     Edge.new(src=n1, dst=n2, weight=1.0),
-        ...     Edge.new(src=n2, dst=n1, weight=-1.0),
+        ...     Edge.new(src=n2, dst=n1, weight=0.0),
         ...     Edge.new(src=n2, dst=n3, weight=1.0),
         ... )
         >>>
@@ -2998,8 +3016,8 @@ class Graph():
         ... ).inspect()
         ▰▰▰▰ Setup complete
             id  node_weighted_degree
-        0   1                   0.0
-        1   2                   1.0
+        0   1                   1.0
+        1   2                   2.0
         2   3                   1.0
         >>>
         >>> # 4. Use 'of' parameter to constrain the set of nodes to compute weighted degree of
@@ -3014,7 +3032,7 @@ class Graph():
         ... ).inspect()
         ▰▰▰▰ Setup complete
             id  node_weighted_degree
-        0   2                   1.0
+        0   2                   2.0
         1   3                   1.0
 
         Notes
@@ -3076,19 +3094,26 @@ class Graph():
                 weighted_outdegree_rel(self.Node, outweight),
             ).define(_weighted_degree_rel(self.Node, inweight + outweight))
         elif not self.directed:
-            # Choose the appropriate node set
+            # For undirected graphs, weighted degree counts each non-loop edge weight once
+            # and each self-loop edge weight twice.
+            node, neighbor, weight = self.Node.ref(), self.Node.ref(), Float.ref()
+
             if node_subset is None:
-                # No constraint - use all nodes
-                node_set = self.Node
+                node_constraint = node  # No constraint on nodes.
             else:
-                # Constrained to nodes in the subset
-                node_set = node_subset
+                node_constraint = node_subset(node)  # Nodes constrained to given subset.
 
-            dst, weight = self.Node.ref(), Float.ref()
             where(
-                node_set(self.Node),
-                _weighted_degree := sum(dst, weight).per(self.Node).where(self._weight(self.Node, dst, weight)) | 0.0,
-            ).define(_weighted_degree_rel(self.Node, _weighted_degree))
+                node_constraint,
+                weighted_degree_no_loops := sum(neighbor, weight).per(node).where(
+                    self._weight(node, neighbor, weight),
+                    node != neighbor,
+                ) | 0.0,
+                weighted_degree_self_loops := sum(neighbor, weight).per(node).where(
+                    self._weight(node, neighbor, weight),
+                    node == neighbor,
+                ) | 0.0,
+            ).define(_weighted_degree_rel(node, weighted_degree_no_loops + 2 * weighted_degree_self_loops))
 
         return _weighted_degree_rel
 
@@ -3098,8 +3123,10 @@ class Graph():
         """Returns a binary relationship containing the weighted indegree of each node.
 
         A node's weighted indegree is the sum of the weights of all incoming
-        edges. For undirected graphs, this is identical to `weighted_degree`.
-        For unweighted graphs, all edge weights are considered to be 1.0.
+        edges. For undirected graphs, this is identical to `weighted_degree`,
+        except for self-loops. For weighted graphs, we assume edge weights are
+        non-negative. For unweighted graphs, all edge weights are considered
+        to be 1.0.
 
         Parameters
         ----------
@@ -3123,12 +3150,12 @@ class Graph():
 
         Supported Graph Types
         ---------------------
-        | Graph Type   | Supported | Notes                                  |
-        | :----------- | :-------- | :------------------------------------- |
-        | Undirected   | Yes       | Identical to `weighted_degree`.        |
-        | Directed     | Yes       |                                        |
-        | Weighted     | Yes       |                                        |
-        | Unweighted   | Yes       | Edge weights are considered to be 1.0. |
+        | Graph Type   | Supported | Notes                                                  |
+        | :----------- | :-------- | :----------------------------------------------------- |
+        | Undirected   | Yes       | Identical to `weighted_degree`, except for self-loops. |
+        | Directed     | Yes       |                                                        |
+        | Weighted     | Yes       | Assumes non-negative weights.                          |
+        | Unweighted   | Yes       | Edge weights are considered to be 1.0.                 |
 
         Examples
         --------
@@ -3249,8 +3276,9 @@ class Graph():
         """Returns a binary relationship containing the weighted outdegree of each node.
 
         A node's weighted outdegree is the sum of the weights of all outgoing
-        edges. For undirected graphs, this is identical to `weighted_degree`.
-        For unweighted graphs, all edge weights are considered to be 1.0.
+        edges. For undirected graphs, this is identical to `weighted_degree`,
+        except for self-loops. For unweighted graphs, all edge weights are
+        considered to be 1.0.
 
         Parameters
         ----------
@@ -3274,12 +3302,12 @@ class Graph():
 
         Supported Graph Types
         ---------------------
-        | Graph Type   | Supported | Notes                                  |
-        | :----------- | :-------- | :------------------------------------- |
-        | Undirected   | Yes       | Identical to `weighted_degree`.        |
-        | Directed     | Yes       |                                        |
-        | Weighted     | Yes       |                                        |
-        | Unweighted   | Yes       | Edge weights are considered to be 1.0. |
+        | Graph Type   | Supported | Notes                                                  |
+        | :----------- | :-------- | :----------------------------------------------------- |
+        | Undirected   | Yes       | Identical to `weighted_degree`, except for self-loops. |
+        | Directed     | Yes       |                                                        |
+        | Weighted     | Yes       |                                                        |
+        | Unweighted   | Yes       | Edge weights are considered to be 1.0.                 |
 
         Examples
         --------
@@ -3399,7 +3427,7 @@ class Graph():
         degree (or weighted degree for weighted graphs) divided by the number
         of other nodes in the graph.
 
-        For unewighted graphs without self-loops, this value will be at most 1.0;
+        For unweighted graphs without self-loops, this value will be at most 1.0;
         unweighted graphs with self-loops might have nodes with a degree centrality
         greater than 1.0. Weighted graphs may have degree centralities
         greater than 1.0 as well.
@@ -3436,7 +3464,7 @@ class Graph():
         --------
         **Unweighted Graph Example**
 
-        >>> from relationalai.semantics import Model, define, select, Float
+        >>> from relationalai.semantics import Model, define, select, Float, where, union
         >>> from relationalai.semantics.reasoners.graph import Graph
         >>>
         >>> # 1. Set up an unweighted graph
@@ -3463,7 +3491,7 @@ class Graph():
         0   1   0.333333
         1   2   1.000000
         2   3   1.000000
-        3   4   0.666667
+        3   4   0.333333
 
         >>> # 4. Use 'of' parameter to constrain the set of nodes to compute degree centrality of
         >>> # Define a subset containing only nodes 2 and 3
@@ -4816,7 +4844,7 @@ class Graph():
     def _degree_no_self(self):
         """
         Lazily define and cache the self._degree_no_self relationship,
-        a non-public helper for local_clustering_coefficient.
+        a non-public helper for degree and local_clustering_coefficient.
         """
         return self._create_degree_no_self_relationship(node_subset=None)
 

relationalai/semantics/reasoners/optimization/__init__.py

@@ -1,23 +1,68 @@
-__version__ = "0.0.0"
+"""Optimization and constraint programming solver interfaces.
 
-# NOTE(coey) using Solver class from old solvers library to avoid code duplication
-from relationalai.experimental.solvers import Solver, Provider
+This package provides solver model interfaces for defining and solving
+mathematical optimization and constraint programming problems using
+RelationalAI's solver infrastructure.
+"""
 
-from .common import make_name, all_different, implies
-from .solvers_pb import SolverModelPB
+from __future__ import annotations
+
+from typing import Union
+import warnings
+
+from relationalai.experimental.solvers import Provider, Solver
+from relationalai.semantics.internal import Model
+
+from .common import all_different, implies, make_name, special_ordered_set_type_2
 from .solvers_dev import SolverModelDev
+from .solvers_pb import SolverModelPB
+
+__version__ = "0.0.0"
+
+
+# Copied from graphs library:
+# warn on import that this package is at an early stage of development.
+warnings.warn(
+    (
+        "\n\nThis library is still in early stages of development and is intended "
+        "for internal use only. Among other considerations, interfaces will change, "
+        "and performance is appropriate only for relatively small problems. Please "
+        "see this package's README for additional information.\n\n"
+        "If you are an internal user seeing this, please also contact "
+        "the symbolic reasoning team such that we can track usage, get "
+        "feedback, and help you through breaking changes.\n"
+    ),
+    FutureWarning,
+    stacklevel=2
+)
+
+
+def SolverModel(
+    model: Model, num_type: str, use_pb: bool = True
+) -> Union[SolverModelPB, SolverModelDev]:
+    """Create a solver model for an optimization or constraint programming problem.
+
+    Args:
+        model: The RelationalAI model to attach the solver to.
+        num_type: Numeric type for decision variables ('cont' or 'int').
+        use_pb: Whether to use protobuf format (True) or development format (False).
+            Defaults to True. Note: protobuf format will be deprecated in favor
+            of the development format.
+
+    Returns:
+        A SolverModelPB or SolverModelDev instance.
+    """
+    return (SolverModelPB if use_pb else SolverModelDev)(model, num_type)
 
-def SolverModel(model, num_type: str, use_pb: bool = True):
-    if use_pb:
-        return SolverModelPB(model, num_type)
-    else:
-        return SolverModelDev(model, num_type)
 
 __all__ = [
     "Solver",
     "Provider",
     "SolverModel",
+    "SolverModelPB",
+    "SolverModelDev",
     "make_name",
     "all_different",
     "implies",
+    "special_ordered_set_type_2",
 ]

relationalai/semantics/reasoners/optimization/common.py

@@ -1,10 +1,32 @@
+"""Common utilities for solver models.
+
+This module provides shared helper functions and constraint constructors used
+across solver model implementations (both protobuf and development versions).
+"""
+
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Optional, Union
+
 from relationalai.semantics import std
-from relationalai.semantics.internal.internal import Relationship, Expression, Aggregate
+from relationalai.semantics.internal import internal as b
+
+
+# =============================================================================
+# Utilities
+# =============================================================================
 
-def make_name(*args, sep: str | None = "_"):
+
+def make_name(*args, sep: Optional[str] = "_") -> Union[str, b.Expression]:
+    """Construct a name by concatenating arguments into a string expression.
+
+    Args:
+        *args: Arguments to concatenate (strings, numbers, or lists).
+        sep: Separator between arguments. Defaults to "_", use None for no separator.
+
+    Returns:
+        A string or expression representing the concatenated name.
+    """
     if not args:
         raise ValueError("No arguments provided to `make_name`")
     elif len(args) == 1:
@@ -25,9 +47,42 @@ def make_name(*args, sep: str | None = "_"):
         str_args = map(std.strings.string, args)
     return std.strings.concat(*str_args)
 
-# TODO move to std? need to support normal logical evaluation.
-def all_different(*args: Any) -> Aggregate:
-    return Aggregate(Relationship.builtins["all_different"], *args)
 
-def implies(left, right) -> Expression:
-    return Expression(Relationship.builtins["implies"], left, right)
+# =============================================================================
+# Constraint Constructors
+# =============================================================================
+
+
+def all_different(*args: Any) -> b.Aggregate:
+    """Create an all_different constraint requiring all arguments to have distinct values.
+
+    Args:
+        *args: Variables or expressions that must all have different values.
+    """
+    return b.Aggregate(b.Relationship.builtins["all_different"], *args)
+
+
+def implies(left: Any, right: Any) -> b.Expression:
+    """Create a logical implication constraint (left => right).
+
+    Args:
+        left: The antecedent (condition) of the implication.
+        right: The consequent (result) of the implication.
+    """
+    return b.Expression(b.Relationship.builtins["implies"], left, right)
+
+
+def special_ordered_set_type_2(rank: Any, variables: Any) -> b.Aggregate:
+    """Create a special ordered set type 2 (SOS2) constraint.
+
+    In an SOS2 constraint, at most two variables can be non-zero, and they
+    must be consecutive in the given order. This is useful for piecewise-linear
+    approximations where the variables represent weights on ordered breakpoints.
+
+    Args:
+        rank: An expression that specifies the order/rank of each variable.
+            Variables are ordered by their rank values to determine which pairs
+            are consecutive.
+        variables: The decision variables that form the special ordered set.
+    """
+    return b.Aggregate(b.Relationship.builtins["special_ordered_set_type_2"], rank, variables)

relationalai/semantics/reasoners/optimization/solvers_dev.py

@@ -6,7 +6,7 @@ import time
 
 from relationalai.semantics.snowflake import Table
 from relationalai.semantics import std
-from relationalai.semantics.internal import internal as b # TODO(coey) change b name or remove b.?
+from relationalai.semantics.internal import internal as b
 from relationalai.semantics.rel.executor import RelExecutor
 from relationalai.semantics.lqp.executor import LQPExecutor
 from relationalai.tools.constants import DEFAULT_QUERY_TIMEOUT_MINS
@@ -57,18 +57,29 @@ class SolverModelDev:
         # self.objective_values = model.Relationship(f"point {{i:int}} has objective value {{val:{data_type}}}", short_name=_name("objective_values"))
         # self.primal_statuses = model.Relationship("point {i:int} has primal status {status:str}", short_name=_name("primal_statuses"))
 
+        self._model_info = {
+            "num_variables": self.variables,
+            "num_constraints": self.constraints,
+            "num_min_objectives": self.min_objectives,
+            "num_max_objectives": self.max_objectives,
+        }
+
     # TODO(coey) assert that it is a property? not just a relationship.
-    def solve_for(self, expr: b.Relationship | b.Fragment, populate: bool = True, **kwargs):
-        where = []
+    def solve_for(self, expr, where: list = [], populate: bool = True, **kwargs):
         if isinstance(expr, b.Fragment):
-            assert expr._select and len(expr._select) == 1 and expr._where, "Fragment input for `solve_for` must have exactly one select and a where clause"
-            rel = expr._select[0]
-            where.extend(expr._where)
+            # TODO(coey) remove in future
+            raise ValueError("select fragment argument to `solve_for` is deprecated; instead use `where = [conditions...]` kwarg to specify optional grounding conditions")
+        elif isinstance(expr, b.Expression):
+            # must be of the form rel(a, ..., x) where the last element is the decision variable
+            rel = expr._op
+            assert isinstance(rel, b.Relationship)
+            params = expr._params
         elif isinstance(expr, b.Relationship):
             rel = expr
+            params = [b.field_to_type(self._model, f) for f in rel._fields]
         else:
-            raise ValueError(f"Invalid expression type {type(expr)} for `solve_for`; must be a Relationship or Fragment")
-        assert rel._parent and rel._short_name, "Relationship for `solve_for` must have a parent and a short name"
+            raise ValueError(f"Invalid expression type {type(expr)} for `solve_for`")
+        assert len(params) == len(rel._fields)
         assert rel not in self._variable_relationships
 
         self._variable_relationships.add(rel)
@@ -81,7 +92,7 @@ class SolverModelDev:
             new_kwargs["type"] = "cont" if self._data_type == "float" else "int"
         for (key, val) in new_kwargs.items():
             if key == "name":
-                assert isinstance(val, (_Any, list)), f"Expected {key} to be a value or list, got {type(val)}"
+                assert isinstance(val, _Any) or isinstance(val, list), f"Expected {key} to be a value or list, got {type(val)}"
                 defs.append(self.variable_name(node, make_name(val)))
             elif key == "type":
                 assert val in ("cont", "int", "bin"), f"Unsupported variable type {val} for `solve_for`; must be cont, int, or bin"
@@ -96,9 +107,7 @@ class SolverModelDev:
                     self.satisfy(b.require(b.Expression(b.Relationship.builtins[op], rel, val)).where(*where))
             else:
                 raise ValueError(f"Invalid keyword argument {key} for `solve_for`")
-
-        where.append(_make_hash((rel._short_name, rel._parent), node))
-        b.define(*defs).where(*where)
+        b.define(*defs).where(*where, _make_hash((rel._short_name, rel._parent or 0), node))
 
         if populate:
             # get variable values from the result point (populated by the solver)
@@ -108,12 +117,10 @@ class SolverModelDev:
 
         return None
 
-    def minimize(self, expr: _Number, name: _String | list | None = None):
-        assert isinstance(expr, _Number)
+    def minimize(self, expr, name: _String | list | None = None):
         return self._handle_expr(self.min_objectives, expr, name)
 
-    def maximize(self, expr: _Number, name: _String | list | None = None):
-        assert isinstance(expr, _Number)
+    def maximize(self, expr, name: _String | list | None = None):
         return self._handle_expr(self.max_objectives, expr, name)
 
     def satisfy(self, expr: b.Fragment, check: bool = False, name: _String | list | None = None):
@@ -351,18 +358,10 @@ class SolverModelDev:
     # get scalar information
     def __getattr__(self, name: str):
         df = None
-        # model info
-        if name in {"num_variables", "num_constraints", "num_min_objectives", "num_max_objectives"}:
-            map = {
-                "num_variables": self.variables,
-                "num_constraints": self.constraints,
-                "num_min_objectives": self.min_objectives,
-                "num_max_objectives": self.max_objectives,
-            }
+        if name in self._model_info:
             node = b.Hash.ref()
-            df = b.select(b.count(node).where(map[name](node)) | 0).to_df()
-        # result info
-        if name in {"error", "termination_status", "solver_version", "printed_model", "solve_time_sec", "objective_value", "result_count"}:
+            df = b.select(b.count(node).where(self._model_info[name](node)) | 0).to_df()
+        elif name in {"error", "termination_status", "solver_version", "printed_model", "solve_time_sec", "objective_value", "result_count"}:
             val = b.String.ref()
             df = b.select(val).where(self.result_info(name, val)).to_df()
         if df is not None:
@@ -404,7 +403,7 @@ def _rewrite(expr: b.Producer | b.Fragment, ctx: ExprContext):
     elif isinstance(expr, (b.Relationship, b.RelationshipRef, b.RelationshipFieldRef)):
         rel = expr if isinstance(expr, b.Relationship) else expr._relationship
         if rel in ctx.solver_model._variable_relationships:
-            return std.hash(rel._short_name, expr._parent)
+            return std.hash(rel._short_name, expr._parent or 0)
         return None
 
     elif isinstance(expr, b.Union):
@@ -465,11 +464,18 @@ def _rewrite(expr: b.Producer | b.Fragment, ctx: ExprContext):
         subctx = ExprContext(sm)
         ctx.subcontext.append(subctx)
         subctx.where.extend(expr._where._where)
-        arg_hash = b.Hash.ref()
-        subctx.where.append(_make_hash((sm._expr_id, *pre_args), arg_hash)) # TODO also add sym_arg here?
         sm._expr_id += 1
         subctx.define.append(sm.operator(node, op))
-        subctx.define.append(sm.unordered_args_hash(node, arg_hash, sym_arg)) # TODO what if some values are data not hashes?
+
+        # special_ordered_set_type_2 has two ordered arguments: rank and variables
+        if op == "special_ordered_set_type_2":
+            assert len(pre_args) == 1, "special_ordered_set_type_2 expects exactly 2 arguments (rank, variables)"
+            subctx.define.append(sm.ordered_args_hash(node, pre_args[0], sym_arg))
+        else:
+            # other aggregate operators use unordered args
+            arg_hash = b.Hash.ref()
+            subctx.where.append(_make_hash((sm._expr_id, *pre_args), arg_hash))
+            subctx.define.append(sm.unordered_args_hash(node, arg_hash, sym_arg))
         return node
 
     elif isinstance(expr, b.Fragment):
@@ -502,7 +508,7 @@ def _expr_strings_rec(x, names_dict, ops_dict, args_dict):
             s = f"({s})"
         arg_strs.append(s)
 
-    if op in agg_ops:
+    if op in agg_ops and not op == "special_ordered_set_type_2":
         # sort unordered args to improve determinism
         arg_strs.sort()
 
@@ -522,7 +528,7 @@ infix_ops = set(["+", "-", "*", "/", "^"])
 infix_comps = set(["=", "!=", "<", "<=", ">", ">=", "implies"])
 infixs = infix_ops.union(infix_comps)
 prefix_ops = set(["abs", "log", "exp"])
-agg_ops = set(["sum", "count", "min", "max", "all_different"])
+agg_ops = set(["sum", "count", "min", "max", "all_different", "special_ordered_set_type_2"])
 
 # _variable_types = {
 #     "cont": 40,