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

v0/relationalai/early_access/dsl/core/logic/aggregation.py

@@ -0,0 +1,98 @@
+from v0.relationalai.early_access.dsl.core.exprs import contextStack
+from v0.relationalai.early_access.dsl.core.exprs.scalar import ScalarExpr
+from v0.relationalai.early_access.dsl.core.logic import LogicFragment
+
+
+class Aggregation(LogicFragment, ScalarExpr):
+
+    # Each Schema object is a ContextManager
+    def __enter__(self):
+        contextStack.push(self)  # open a new context for this Schema
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        contextStack.pop()
+
+    def __init__(self, method):
+        LogicFragment.__init__(self)
+        self._method = method
+        self._aggregates = None
+        self._schema = self
+
+    def aggregates(self, var):
+        self._aggregates = var
+
+    def display(self):
+        vars = [v.display() for v in self._scalars.values()]
+
+        args = ", ".join(vars)
+        body = self.rel_formula()
+        return f"{self._method}[" + args + ":" + body + "]"
+
+    def grounded(self): return False
+
+    def rename(self, renaming) -> 'Aggregation':
+        new_vars = {}
+        for d in self._scalars:
+            dv = self._scalars[d]
+            if d in renaming:
+                new_vars[d] = dv.rename(renaming[d])
+            else:
+                new_vars[d] = dv
+
+        renamed_agg = Aggregation(self._method)
+        renamed_agg._aggregates = self._aggregates
+        renamed_agg._scalars = new_vars
+
+        renamed_agg._existentials = self._existentials
+        renamed_agg._atoms = self._atoms
+        renamed_agg._sconstraints = self._sconstraints
+
+        return renamed_agg
+
+    def pprint(self): return self.display()
+
+    @staticmethod
+    def max(var):
+        return Aggregation._agg(var, "max")
+
+    @staticmethod
+    def min(var):
+        return Aggregation._agg(var, "min")
+
+    @staticmethod
+    def argmax(var):
+        return Aggregation._agg(var, "argmax")
+
+    @staticmethod
+    def argmin(var):
+        return Aggregation._agg(var, "argmin")
+
+    @staticmethod
+    def sum(var):
+        return Aggregation._agg(var, "sum")
+
+    @staticmethod
+    def count(var):
+        return Aggregation._agg(var, "count")
+
+    @staticmethod
+    def _agg(var, method):
+        agg = Aggregation(method)
+        var == agg
+        return agg
+
+    def map_builder(self, builder):
+        new_agg = Aggregation(self._method)
+        new_agg._aggregates = self._aggregates
+        new_agg._scalars = self._scalars
+        for a in self._sconstraints.values():
+            ap = a.map_builder(builder)
+            new_agg._sconstraints[ap.entityid()] = ap
+        for a in self._atoms.values():
+            new_atom = a.map_builder(builder)
+            new_agg._atoms[new_atom.entityid()] = new_atom
+        for ex in self._existentials.values():
+            new_ex = ex.map_builder(builder)
+            new_agg._existentials[new_ex.entityid()] = new_ex
+        return new_agg

v0/relationalai/early_access/dsl/core/logic/exists.py

@@ -0,0 +1,223 @@
+from v0.relationalai.early_access.dsl.core.constraints import Constraint
+from v0.relationalai.early_access.dsl.core.exprs import contextStack
+from v0.relationalai.early_access.dsl.core.logic import LogicFragment
+from v0.relationalai.early_access.dsl.core.logic.helper import one_point_reduce
+
+class ExistentialConstraint(Constraint, LogicFragment):
+
+    # Each Schema object is a ContextManager
+    def __enter__(self):
+        contextStack.push(self)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        contextStack.pop()
+
+    def __init__(self):
+        LogicFragment.__init__(self)
+
+    def grounds(self, v, groundings):
+
+        # First, we need to extend grounds to include variables introduce in this constraint
+        prop_vars = [d for d in self._scalars.values() if not d.relational()]
+
+        addl = {}
+        glen = -1
+
+        props = self.propositional_constraints()
+
+        while glen < len(addl):
+            glen = len(addl)
+
+            for c in props.values():
+                for pv in prop_vars:
+                    if c.grounds(pv, dict(groundings, **addl)):
+                        addl[pv.display()] = pv
+
+        gdgs = dict(groundings, **addl)
+
+        for c in props.values():
+            if c.grounds(v, gdgs):
+                return True
+
+        return False
+
+    def free_variables(self):
+        fvars = {}
+        bvars = self._scalars
+        for c in self.propositional_constraints().values():
+            cdict = c.scalar_refs()
+            for v in cdict:
+                if v not in bvars:
+                    fvars[v] = cdict[v]
+        return fvars
+
+    # Returns a new ExistentialConstraint that duplicates self after
+    # mapping every Relation referred to by an atom through relmap
+    #
+    def map(self, relmap):
+        x = ExistentialConstraint()
+        x._scalars = self._scalars
+        x._sconstraints = self._sconstraints
+        for a in self._atoms.values():
+            newatom = a.map(relmap)
+            x._atoms[newatom.entityid()] = newatom
+        for ex in self._existentials.values():
+            newex = ex.map(relmap)
+            x._existentials[newex.entityid()] = newex
+        return x
+
+    # Returns a new ExistentialConstraint that duplicates self after
+    # replacing each atom with the one constructed by the given builder
+    # function taking the relational component and arguments of the current atom.
+    #
+    def map_builder(self, builder):
+        x = ExistentialConstraint()
+        x._scalars = self._scalars      
+        x._sconstraints = {}
+        for a in self._sconstraints.values():
+            ap = a.map_builder(builder)
+            x._sconstraints[ap.entityid()] = ap
+
+        for a in self._atoms.values():
+            new_atom = a.map_builder(builder)
+            x._atoms[new_atom.entityid()] = new_atom
+        for ex in self._existentials.values():
+            new_ex = ex.map_builder(builder)
+            x._existentials[new_ex.entityid()] = new_ex
+        return x
+
+    @staticmethod
+    def build_existential() -> 'ExistentialConstraint':
+        return ExistentialConstraint()
+
+    @staticmethod
+    def assemble_existential(decls, comps, atoms) -> 'ExistentialConstraint':
+        x = ExistentialConstraint.build_existential()
+        x._scalars = decls
+        x._sconstraints = comps
+        x._atoms = atoms
+        return x
+
+    # Emit this schema to a textual output using the Z display style
+    #
+    def pprint(self):
+        vdecl = "; ".join([v for v in self._scalars])
+        head = f"exists(({vdecl}) |"
+
+        props = [f"    {c.pprint()}" for c in self.propositional_constraints().values()]
+        body = " true )" if len(props) == 0 else "\n" + "\n".join(props) + " )"
+
+        return head + body
+
+    def scalar_refs(self):
+        return self.free_variables()
+
+    def refersto(self, varname: str) -> bool:
+        return varname in self.free_variables()
+
+    def rel_formula(self):
+        propcs = self.propositional_constraints()
+
+        if len(self._scalars) + len(propcs) == 0:
+            return "true"
+
+        props = [f"    {c.rel_formula()}" for c in propcs.values()]
+
+        if len(self._scalars) > 0:
+            vdecl = ", ".join([v for v in self._scalars])
+            head = f"exists(({vdecl}) |"
+            if len(props) == 0:
+                return head + " true)"
+            else:
+                return head + "\n" + " and\n".join(props) + " )"
+        else:
+            if len(props) == 0:
+                return ""
+            else:
+                return "(" + " and\n".join(props) + " )"
+
+    def rename(self, renaming):
+
+        new_vars = {}
+        for d in self._scalars:
+            dv = self._scalars[d]
+            if d in renaming:
+                new_vars[d] = dv.rename(renaming[d])
+            else:
+                new_vars[d] = dv
+
+        new_comps = {}
+        for a in self._sconstraints.values():
+            ap = a.rename(renaming)
+            new_comps[ap.entityid()] = ap
+
+        new_atoms = {}
+        for a in self._atoms.values():
+            ap = a.rename(renaming)
+            new_atoms[ap.entityid()] = ap
+
+        return self.assemble_existential(new_vars, new_comps, new_atoms)
+
+    def simplify(self):
+        comps = {}
+        for p in self._sconstraints.values():
+            ps = p.simplify()
+            comps[ps.entityid()] = ps
+
+        atoms = {}
+        for p in self._atoms.values():
+            ps = p.simplify()
+            atoms[ps.entityid()] = ps
+
+        (decls, c, a) = one_point_reduce(self._scalars, comps, atoms)
+        return self.assemble_existential(decls, c, a)
+
+    def substitute(self, bindings):
+        decls = {}
+        for d in self._scalars.values():
+            dp = d.substitute(bindings)
+            decls[dp.display()] = dp
+
+        comps = {}
+        for p in self._sconstraints.values():
+            pp = p.substitute(bindings)
+            comps[pp.entityid()] = pp
+
+        atoms = {}
+        for p in self._atoms.values():
+            pp = p.substitute(bindings)
+            atoms[pp.entityid()] = pp
+
+        return self.assemble_existential(decls, comps, atoms)
+
+    def entityid(self):
+        return hash((hash(tuple(self._scalars)),
+                     hash(tuple(self._sconstraints)),
+                     hash(tuple(self._atoms))))
+
+# Given a LogicFragment of the form:
+#
+#     (bvars: sconsts & atoms)
+#
+# where:
+#
+#   - bvars is a set of ScalarVariable declarations,
+#   - sconsts is a dictionary of ScalarConstraints, and
+#   - atoms is a dictionary of AtomicConstraints
+#
+# Existentially quantify out all of the variables in bvars, returning either
+# a modified pair (sconsts', atoms') or an ExistentialConstraint that introduces
+# any remaining variables bvarsPrime under a quantifier.
+#
+# Note that constraints in sconsts and/or atoms could refer to ScalarVariables
+# that are not in bvars. In this case, those variables will occur free in the
+# fragment returned.
+#
+def existentially_quantify(bvars, sconsts, atoms):
+    (n, c, a) = one_point_reduce(bvars, sconsts, atoms)
+
+    if len(n) > 0:
+        return {}, {}, ExistentialConstraint.assemble_existential(n, c, a)
+    else:
+        return c, a, None

v0/relationalai/early_access/dsl/core/logic/helper.py

@@ -0,0 +1,163 @@
+from v0.relationalai.early_access.dsl.core.constraints.scalar import fold_constants, propagate_definitions
+
+
+# Counts the number of constraints of props in which variable x occurs.
+#
+def occurrences(x: str, props):
+    count = 0
+    for c in props.values():
+        if c.refersto(x):
+            count += 1
+    return count
+
+
+# Given a LogicFragment of the form:
+#
+#     (bvars: sconsts & atoms)
+#
+# where:
+#
+#   - bvars is a set of (Scalar) bound variable declarations,
+#   - sconsts is a dictionary of ScalarConstraints, and
+#   - atoms is a dictionary of AtomicConstraints
+#
+# Note that constraints in sconsts and/or atoms could refer to *free variables*,
+# i.e., ScalarVariables that are not in bvars. We use type constraints on free
+# variables when reasoning to help check domain constraints on bound variables.
+#
+# This function folds constraints and applies the one-point rule where possible to
+# generate a hopefully simpler but equivalent fragment (bvars' : sconsts' & atoms')
+# where:
+#
+#    - |bvars'| <= |bvars|
+#    - |sconsts'| <= |sconsts|
+#
+# Recall the formal definition of the one-point rule:
+#
+#       exists(x in D : P and (x=t) )
+#      =============================== [one-point]
+#             t in D and P[t/x]
+#
+# To apply it, we take advantage of the fact that constant folding will often do
+# most of the substitution work (i.e., P[t/x]) for ScalarConstraints of the form:
+#
+#     x == t
+#
+# which means we can apply the rule by merely removing such constraints (and in
+# some cases also the variable ScalarVariable x) provided that we can stacially
+# check that t is in D, where D is the (value-) type of ScalarVariable x. This
+# check is called the "domain check" on t. Note that we cannot always statically
+# discharge the domain check.
+#
+def one_point_reduce(bvars, sconsts, atoms):
+
+    if len(sconsts) == 0:
+        return bvars, sconsts, atoms
+
+    # Start by folding constants
+    #
+    (sc_folded, atoms_folded) = fold_constants(sconsts, atoms)
+
+    # Next infer the set of free variables (those referenced in some constraint but
+    # that are not in bvars) so that we can commute and then and propagate definitions.
+    #
+    freevars = free_variable_refs(bvars, sc_folded, atoms_folded)
+
+    # Now that we know the free variables, go instantiate their type constraints so
+    # that we can leverage them to do more precise domain checking below.
+    #
+    free_var_constraints = {}
+    for v in freevars.values():
+        free_var_constraints = free_var_constraints | instantiate_type_constraints_for(v, v._scalartype)
+
+    sc_commuted = commute_definitions(freevars, sc_folded)
+
+    # Next, propagate definitions
+    #
+    (sc_propagated, atoms_propagated) = propagate_definitions(sc_commuted, atoms_folded)
+
+    # Post: Any ScalarVariable `x` in bvars that forms the lhs of some definition constraint
+    #       (of the form "x == t") can now be considered for elimination via the one-point
+    #       rule.
+    #
+    # We choose to eliminate the constraint (and the variable 'x') if 'x' occurs only in that
+    # constraint and if we can prove the domain check on `x` is satisfied
+    #
+
+    # Here are the variables from definition constraints that occur only in that definition
+    # constraint.
+    #
+    defns = {c.left.display(): c for c in sc_propagated.values() if c.definition()}
+    occurs_once = [x for x in bvars
+                   if x in defns and occurrences(x, sc_propagated) == 1 and occurrences(x, atoms_propagated) == 0]
+
+    # Any bound that occurs once and satisfies the domain constraint can be removed.
+    #
+    vars_to_remove = [x for x in occurs_once]
+
+    # Compute the set of new declarations to place under an existential quantifier.
+    # These should include any bvars that we have *not* selected for removal by
+    # virtue of applying the one-point rule.
+    #
+    existential_vars = {v: bvars[v] for v in bvars if v not in vars_to_remove}
+
+    # These constraints trigger an application of the one-point rule and so can
+    # be removed.
+    #
+    triggers = [defns[x] for x in vars_to_remove]
+
+    # These are the constraints that remain after removing those that were
+    # selected for removal using the one-point rule
+    #
+    sconsts_prime = {c.entityid(): c for c in sc_propagated.values() if c not in triggers}
+
+    return existential_vars, sconsts_prime, atoms_propagated
+
+
+def free_variable_refs(bvars, sconsts, atoms):
+    fvars = {}
+    for c in sconsts.values():
+        refs = c.scalar_refs()
+        for r in refs:
+            if r not in bvars:
+                fvars[r] = refs[r]
+
+    for a in atoms.values():
+        refs = a.scalar_refs()
+        for r in refs:
+            if r not in bvars:
+                fvars[r] = refs[r]
+
+    return fvars
+
+# We commute any commutative definitions that involve a free variable
+# to try to ensure the bound variable is in the lhs of the constratint
+#
+def commute_definitions(fvars, constraints):
+    commuted_constraints = {}
+    for c in constraints:
+        const = constraints[c]
+        if const.commutative_definition() and const.left.display() in fvars:
+
+            newc = const.commute()
+            commuted_constraints[newc.entityid()] = newc
+        else:
+            commuted_constraints[c] = const
+
+    return commuted_constraints
+
+
+# Given a ScalarVariable var and a ConstrainedValueType tp,
+# returns the set of type constraints on tp where the type
+# variable is replaced by var -- essentially "instantiating"
+# those constraints on var.
+#
+def instantiate_type_constraints_for(var, tp):
+    constraints = {}
+    if tp.constraint_unary():
+        tvar = tp.value()
+        typecs = tp.denotes()
+        for c in typecs.values():
+            xc = c.substitute({tvar.display(): var})
+            constraints[xc.entityid()] = xc
+    return constraints

v0/relationalai/early_access/dsl/core/namespaces.py

@@ -0,0 +1,32 @@
+from v0.relationalai.early_access.dsl.core.exprs import contextStack
+
+
+class Namespace:
+    top: 'Namespace'
+    std: 'Namespace'
+
+    def __enter__(self):
+        contextStack.push(self)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        contextStack.pop()
+        pass
+
+    def __init__(self, nm, par=None):
+        self._name = nm
+        self._parent = par
+
+    def name(self):
+        return self._name
+
+    def qualified_name(self):
+        if self._parent is None or self._parent == Namespace.top:
+            return self.name()
+        else:
+            # TODO: [VAMI] We changed `::` to `__` to spead up E2E testing. We should change it back to `::` before release.
+            return f"{self._parent.name()}__{self.name()}"
+
+
+Namespace.top = Namespace("")
+Namespace.std = Namespace("std", Namespace.top)