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

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

@@ -1,98 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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)