relationalai 0.13.0.dev0__py3-none-any.whl → 0.13.2__py3-none-any.whl

relationalai/early_access/dsl/core/constraints/scalar.py

@@ -0,0 +1,310 @@
+from relationalai.early_access.dsl.core.constraints import Constraint, TrueConstraint, FalseConstraint
+
+class ScalarConstraint(Constraint):
+
+    def __init__(self, x, y, z):
+        self.op = y
+        if y == "=" and x.grounded():
+            self.left = z
+            self.right = x
+        else:
+            self.left = x
+            self.right = z
+
+    # A binding is a definition in which the right-hand side of the equality
+    # comparison is grounded and so will evaluate to a constant (e.g., "x == 20")
+    #
+    def binding(self):
+        return self.definition() and self.right.grounded()
+
+    def commutative_definition(self):
+        return self.definition() and self.right.variable()
+
+    def commute(self):
+        if not self.commutative_definition():
+            raise Exception(f"Cannot commute non-commutative definition {self.pprint()}")
+        return ScalarConstraint( self.right, '=', self.left )
+
+    # A definition is a left var ScalarConstraint of the form that involves an
+    # equality operator (e.g., "x == 20", or "x == y + 5" )
+    #
+    def definition(self):
+        return self.left.variable() and self.equality()
+
+    def equality(self):
+        return self.op == "="
+
+    def negate(self):
+        left = self.left
+        right = self.right
+        if self.op == "=":
+            return ScalarConstraint(left, "!=", right)
+        if self.op == "!=":
+            return ScalarConstraint(left, "=", right)
+        if self.op == "<=":
+            return ScalarConstraint(left, ">", right)
+        if self.op == "<":
+            return ScalarConstraint(left, ">=", right)
+        if self.op == ">=":
+            return ScalarConstraint(left, "<", right)
+        if self.op == ">":
+            return ScalarConstraint(left, "<=", right)
+
+        raise Exception(f"Cannot negate constraint {self.pprint()}")
+
+    # Emit this schema to a textual output using the Z display style
+    #
+    def pprint(self):
+
+        left = self.left
+        right = self.right
+        result = []
+
+        if hasattr(left, "display"):
+            result.append(left.display())
+        else:
+            result.append(left)
+
+        if self.op == "=":
+            result.append("==")
+        else:
+            result.append(self.op)
+
+        if hasattr(right, "display"):
+            result.append(right.display())
+        else:
+            result.append(right)
+
+        return " ".join(result)
+
+    def rel_formula(self):
+        return f"{self.left.display()} {self.op} {self.right.display()}"
+
+    def grounded(self):
+        return self.left.grounded() and self.right.grounded()
+
+    def grounds(self, v, groundings):
+        if self.equality():
+            lv = self.left
+            if lv.variable():
+                if lv.entityid() == v.entityid():
+                    return self.right.grounded_using(groundings)
+                else:
+                    rv = self.right
+                    if rv.variable() and rv.entityid() == v.entityid():
+                        return self.left.grounded_using(groundings)
+        return False
+
+    def scalar_refs(self):
+        dic = self.left.scalar_refs()
+        rdict = self.right.scalar_refs()
+        for v in rdict:
+            if v not in dic:
+                dic[v] = rdict[v]
+        return dic
+
+    def refersto(self, varname: str) -> bool:
+        return self.left.refersto(varname) or self.right.refersto(varname)
+
+    def relational(self) -> bool:
+        return self.left.relational() or self.right.relational()
+
+    def rename(self, renaming):
+        return ScalarConstraint(self.left.rename(renaming),
+                                self.op,
+                                self.right.rename(renaming))
+
+    def revar(self, vmap):
+        return ScalarConstraint(self.left.revar(vmap),
+                                self.op,
+                                self.right.revar(vmap))
+
+    # Report out the propositional variables that are used in this constraint as
+    # an extension to the bindings dictionary that is provided.
+    #
+    def report_propositional_variable_usage(self, bindings):
+        uses = self.scalar_refs()
+
+        if len(bindings) == 0:
+            return uses
+        else:
+            bdgs = bindings.copy()
+            for v in uses:
+                if v not in bindings:
+                    bdgs[v] = uses[v]
+
+            return bdgs
+
+    def simplify(self):
+        if self.grounded():
+            exec(f"self.x = {self.pprint()}")
+            if self.x: # type: ignore
+                return TrueConstraint()
+            else:
+                return FalseConstraint()
+        else:
+            left = self.left.simplify()
+            right = self.right.simplify()
+            if left.grounded() and self.equality():
+                return ScalarConstraint(right, self.op, left)
+            else:
+                return ScalarConstraint(left, self.op, right)
+
+    def substitute(self, bindings):
+        x = self.left.substitute(bindings)
+        y = self.right.substitute(bindings)
+        return ScalarConstraint(x, self.op, y)
+
+    def map_builder(self, builder):
+        x = self.left.map_builder(builder)
+        y = self.right.map_builder(builder)
+        return ScalarConstraint(x, self.op, y)
+
+    def entityid(self):
+        return hash((self.op,
+                     self.left.entityid(),
+                     self.right.entityid()))
+
+
+# Given a dictionary 'props' of ScalarConstraints, return the dictionary
+# containing that subset of props that are binding definitions
+#
+def binding_definitions_of(props):
+    return {c.entityid(): c for c in props.values() if c.binding()}
+
+
+# Given a set props of ScalarConstraints, partition props into
+# (bcons, other) where bcons are binding definitions, and return
+# (bdgs, bcons, other) where bdgs is a binding dictionary used to
+# apply constraints from bcons.
+#
+def bindings_from(props):
+    bdgs = {}
+    bcons = {}
+    other = []
+
+    bprops = binding_definitions_of(props)
+
+    # Partition props into a dictionary of substitution bindings (bdgs)
+    # that derive from the binding definitions in props and any other
+    # (non-binding) constraints in props.
+    #
+    for chash in props:
+        c = props[chash]
+        if chash in bprops:
+            v = c.left.display()
+            if v in bdgs:
+                # Then we have (at least 2) constraints of the form:
+                #    v == expr1
+                #    v == expr2
+                # for expressions expr1 and expr2. In this case, we
+                # need to add the equality constraint `expr1 == expr2`
+                # to other.
+                #
+                expr1 = bdgs[v]
+                expr2 = c.right
+                if expr2.variable():
+                    # Prefer to put the variable on the LHS when possible
+                    #
+                    other.append(ScalarConstraint(expr2, "=", expr1))
+                else:
+                    other.append(ScalarConstraint(expr1, "=", expr2))
+            else:
+                bdgs[v] = c.right
+                bcons[chash] = c
+        else:
+            other.append(c)
+
+    return bdgs, bcons, other
+
+def commutative_definitions_from(props):
+    defns = {}
+    cdcons = {}
+    other = []
+
+    cdefs = commutative_definitions_of(props)
+
+    # Partition props into a dictionary of commutative definitions (defns)
+    # that derive from the binding definitions in props and any other
+    # (non-binding) constraints in props.
+    #
+    for chash in props:
+        c = props[chash]
+        if chash in cdefs and c.commute().entityid() not in defns:
+            # Add {chash: c} to defns if its commuted equivalent not already there!
+            defns[c.left.display()] = c.right
+            cdcons[chash] = c
+        else:
+            other.append(c)
+
+    return defns, cdcons, other
+
+def definitions_of(props):
+    return {c.entityid(): c for c in props.values() if c.definition()}
+
+def commutative_definitions_of(props):
+    return {c.entityid(): c for c in props.values() if c.commutative_definition()}
+
+# Given a set (comps, atoms) of ScalarConstraints and AtomicConstraints respectively,
+# find any binding constraints in comps and use them to do constant folding within
+# (comps, atoms), returning that set of constraints that is equivalent following
+# one or more rounds of constant folding.
+#
+def fold_constants(comps, atoms):
+    (bdgs, newcomps, other) = bindings_from(comps)
+    blen = 0
+
+    if len(bdgs) == 0:
+        return comps, atoms
+
+    # Otherwise, there is at least one binding to try to apply.
+
+    while blen < len(bdgs):
+        # Note that len(bdgs) is non-decreasing with each iteration
+        #
+        blen = len(bdgs)
+
+        # We have not yet applied all bindings. So try to fold
+        # any bound value into other constraints, simplifying
+        # where possible.
+        #
+        for c in other:
+            cprime = c.substitute(bdgs).simplify()
+            if isinstance(cprime, FalseConstraint):
+                # Signal that the whole set of constraints is unsatisfiable
+                return {1: cprime}, {}
+            if not isinstance(cprime, TrueConstraint):
+                newcomps[cprime.entityid()] = cprime
+
+        comps = newcomps
+        (bdgs, newcomps, other) = bindings_from(comps)
+
+    newatoms = {}
+    for c in atoms:
+        cprime = atoms[c].substitute(bdgs).simplify()
+        newatoms[cprime.entityid()] = cprime
+
+    return comps, newatoms
+
+
+# Given a set (comps, atoms) of ScalarConstraints and AtomicConstraints respectively,
+# find any commutative-definition constraints in comps and propagatge them within
+# (comps, atoms), returning that set of constraints that is equivalent following
+# one or more rounds of propagation.
+#
+def propagate_definitions(comps, atoms):
+
+    (cdefs, newcomps, other) = commutative_definitions_from(comps)
+
+    if len(cdefs) == 0:
+        return comps, atoms
+    for c in other:
+        cprime = c.substitute(cdefs)
+        newcomps[cprime.entityid()] = cprime
+
+    newatoms = {}
+    for c in atoms:
+        cprime = atoms[c].substitute(cdefs)
+        newatoms[cprime.entityid()] = cprime
+
+    return newcomps, newatoms

relationalai/early_access/dsl/core/context.py

@@ -0,0 +1,13 @@
+from relationalai.early_access.dsl.core.stack import Stack
+
+
+class ContextStack(Stack):
+
+    def __init__(self):
+        super().__init__()
+
+    def root_context(self):
+        ctx = self.top()
+        if ctx is None:
+            raise Exception('Context stack is empty')
+        return ctx

relationalai/early_access/dsl/core/cset.py

@@ -0,0 +1,132 @@
+from relationalai.early_access.dsl.core.constraints import FalseConstraint, TrueConstraint
+from relationalai.early_access.dsl.core.constraints.predicate.atomic import AtomicConstraint
+from relationalai.early_access.dsl.core.constraints.scalar import ScalarConstraint, fold_constants
+
+
+# A ConstraintSet is a stable collection of constraints that can be composed
+# into a conjunctive datalog query. These are useful for structuring declarative
+# specifications of types, formulae, and more abstract schemas, as well as
+# forming the basis for Rel rules.
+#
+# One interesting problem concerns the construction of stable constraints, as
+# we may need to create UnstableConstraintSets before all of the constraints
+# stabilize and then generate the ConstraintSet once they do
+#
+
+class AbstractConstraintSet:
+
+    def __init__(self):
+        self._atoms = {}
+        self._sconstraints = {}
+
+    def add_atomic_constraint(self, c): pass
+
+    def add_scalar_constraint(self, c): pass
+
+    # Returns a ConstraintSet that stabilizes the constraints declared in this set by
+    # replacing object ids in the dictionaries with (now stable) constraint entityids.
+    #
+    def stabilize(self):
+        cset = ConstraintSet()
+        cset._sconstraints = {c.entityid(): c for c in self._sconstraints.values()}
+        cset._atoms = {c.entityid(): c for c in self._atoms.values()}
+        return cset
+
+
+class ConstraintSet(AbstractConstraintSet):
+
+    def __init__(self):
+        super().__init__()
+
+    def add_scalar_constraint(self, c):
+        cv = c.entityid()
+        if not isinstance(c, ScalarConstraint):
+            raise Exception(f"Attempt to add {c.pprint()} as a scalar constraint")
+
+        if cv not in self._sconstraints:
+            self._sconstraints[cv] = c
+
+    def add_atomic_constraint(self, c):
+        cv = c.entityid()
+        if not isinstance(c, AtomicConstraint):
+            raise Exception(f"Attempt to add {c.pprint()} as an atomic constraint")
+
+        if cv not in self._atoms:
+            self._atoms[cv] = c
+
+    # Partially evaluate this ConstraintSet by substituting values
+    # for its scalar variables, simplifying where possible.
+    #
+    # Returns None if the result of evaluation is infeasible
+    #
+    def evaluate(self, bdgs):
+
+        # First we evaluate each constraint with bdgs
+        #
+        comps = {}
+        for c in self._sconstraints.values():
+            cprime = c.substitute(bdgs).simplify()
+            if isinstance(cprime, FalseConstraint):
+                return None
+            else:
+                if not isinstance(cprime, TrueConstraint):
+                    comps[cprime.entityid()] = cprime
+
+        atoms = {}
+        for c in self._atoms.values():
+            cprime = c.substitute(bdgs).simplify()
+            atoms[cprime.entityid()] = cprime
+
+        (comps, atoms) = fold_constants(comps, atoms)
+
+        if 1 in comps and isinstance(comps[1], FalseConstraint):
+            return None
+        else:
+            s = ConstraintSet()
+            s._sconstraints = comps
+            s._atoms = atoms
+            return s
+
+    def propositional_constraints(self):
+        return self._sconstraints | self._atoms
+
+    # Textual representation of a Rel formula that represents the body of a rule by
+    # conjoining the propsitional constraints of this Schema
+    #
+    def rel_formula(self):
+        props = [f"    {c.rel_formula()}" for c in self._sconstraints.values()]
+        for c in self._atoms.values():
+            props.append(f"    {c.rel_formula()}")
+        return " and\n".join(props)
+
+
+# In uses like value-type construction, constraints must be added before the
+# constraints stabilize -- meaning the constraints exist and refer to variables,
+# but the name or other identifying information about the variables has yet to
+# be assigned. Because ConstraintSets assume stable constraints, we have to
+# implement such use cases using UnstableConstraintSets that can be stabilized
+# to produce ConstraintSets.
+#
+# These unstable sets cannot rely on stable constraint entityids to manage the
+# sets and instead use simple object ids.
+#
+class UnstableConstraintSet(AbstractConstraintSet):
+
+    def __init__(self):
+        super().__init__()
+
+    def add_scalar_constraint(self, c):
+        cv = id(c)
+        if not isinstance(c, ScalarConstraint):
+            raise Exception(f"Attempt to add {c.pprint()} as a scalar constraint")
+
+        if cv not in self._sconstraints:
+            self._sconstraints[cv] = c
+
+    def add_atomic_constraint(self, c):
+        cv = id(c)
+        if not isinstance(c, AtomicConstraint):
+            raise Exception(f"Attempt to add {c.pprint()} as an atomic constraint")
+
+        if cv not in self._atoms:
+            self._atoms[cv] = c

relationalai/early_access/dsl/core/exprs/__init__.py

@@ -0,0 +1,116 @@
+# Copyright 2024 RelationalAI, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# This module defines generic expressions (Exprs). These are
+# extended for use in Schema and Type constraints in other
+# modules.
+#
+from abc import abstractmethod
+
+from relationalai.early_access.dsl.core.context import ContextStack
+
+contextStack = ContextStack()
+
+
+class Expr:
+
+    # We can assert equality (==) between any pair of Exprs, though the
+    # meaning varies depending on whether self is an ScalarExpr or
+    # a RelationExpr
+    #
+    def __eq__(self, other): # type: ignore
+        contextStack.root_context().build_comparison(self, "=", other)
+
+    # Returns a printable form of this Expr.
+    #
+    @abstractmethod
+    def display(self) -> str: pass
+
+    # Returns a copy of this Expr with renaming applied to replace
+    # any variable that occurs in the renaming dictionary, which is
+    # keyed by the names of the variables to rename. For instance,
+    # if expr had the form (x + 2), then:
+    #
+    #    expr.rename({"x": y})
+    #
+    # would have the form (y + 2)
+    #
+    @abstractmethod
+    def rename(self, renaming) -> 'Expr': pass
+
+    # Returns a copy of this Expr with vmap applied to replace
+    # any variable that occurs in the vmap dictionary, which is
+    # keyed by the identifier of the variables to revar. For
+    # instance, if expr had the form (x + 2) and the entityid
+    # of x was 100, then:
+    #
+    #    expr.revar({100: y})
+    #
+    # would have the form (y + 2)
+    #
+    @abstractmethod
+    def revar(self, vmap) -> 'Expr': pass
+
+    # Returns a dictionary of ScalarVariables referenced by this Expr,
+    # with variable names (strings) as keys
+    #
+    def scalar_refs(self): return {}
+
+    # Returns an integer (hash) that identifies this Expr, allowing us
+    # to treat Exprs sort of like entity types for which we had declared
+    # a preferred identifier so as to allow different physical objects
+    # to unify to the same entity. Contrast this with the "id" method
+    # which would not allow us to do this unification.
+    #
+    @abstractmethod
+    def entityid(self) -> int: pass
+
+    # This predicate returns True if this Expr refers to a variable
+    # with this varname and False otherwise.
+    #
+    @abstractmethod
+    def refersto(self, varname: str) -> bool: pass
+
+    # This predicate returns True if this Expr references any kind of
+    # Relation and False otherwise.
+    #
+    def relational(self) -> bool: return False
+
+    # This predicate returns True if this Expr is a (scalar or relation)
+    # variable and False otherwise.
+    #
+    def variable(self) -> bool: return False
+
+
+class Wildcard(Expr):
+    def __init__(self): pass
+
+    def display(self): return "_"
+
+    def grounded_using(self, groundings): return True
+
+    def refersto(self, varname: str): return False
+
+    def rename(self, renaming): return self
+
+    def revar(self, vmap): return self
+
+    def substitute(self, bindings): return self
+
+    def entityid(self): return hash(Wildcard)
+
+
+# Declare this variable for use in Datalog-style rules
+#
+_ = Wildcard()

relationalai/early_access/dsl/core/exprs/relational.py

@@ -0,0 +1,18 @@
+from relationalai.early_access.dsl.core.exprs import Expr, contextStack
+from relationalai.early_access.dsl.core.exprs.scalar import box_number
+
+
+# Relational non-scalar Exprs
+
+class RelationVariable(Expr):
+
+    # RelationVariables may be "invoked" to declare Atoms
+    #
+    def __call__(self, *args):
+        return contextStack.root_context().build_atom(self, [box_number(a) for a in args])
+
+    def arity(self): pass
+
+    def typeof(self): pass
+
+    def variable(self): return True