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

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

@@ -0,0 +1,412 @@
+from abc import abstractmethod
+
+from relationalai.early_access.dsl.core.builders import ExprBuilder
+from relationalai.early_access.dsl.core.exprs import Expr, contextStack
+
+# Arithmetic expressions are those Numbers, ScalarVariables, and larger
+# expressions that combine these with arithmetic operators
+#
+class ScalarExpr(Expr):
+
+    # ScalarExpr building operators and methods
+
+    def __add__(self, other):
+        return contextStack.root_context().build_plus(self, other)
+
+    def __radd__(self, other):
+        return contextStack.root_context().build_plus(self, other)
+
+    def __mod__(self, other):
+        return contextStack.root_context().build_modulus(self, other)
+
+    def __rmod__(self, other):
+        return contextStack.root_context().build_modulus(self, other)
+
+    def __mul__(self, other):
+        return contextStack.root_context().build_times(self, other)
+
+    def __rmul__(self, other):
+        return contextStack.root_context().build_times(self, other)
+
+    def __neg__(self):
+        return contextStack.root_context().build_negate(self)
+
+    def __sub__(self, other):
+        return contextStack.root_context().build_minus(self, other)
+
+    def __rsub__(self, other):
+        return contextStack.root_context().build_minus(self, other)
+
+    def __truediv__(self, other):
+        return contextStack.root_context().build_divide(self, other)
+
+    def __rtruediv__(self, other):
+        return contextStack.root_context().build_divide(self, other)
+
+    # Constraint-building operators and methods
+
+    def __ge__(self, other):
+        contextStack.root_context().build_comparison(self, ">=", other)
+
+    def __gt__(self, other):
+        contextStack.root_context().build_comparison(self, ">", other)
+
+    def __le__(self, other):
+        contextStack.root_context().build_comparison(self, "<=", other)
+
+    def __lt__(self, other):
+        contextStack.root_context().build_comparison(self, "<", other)
+
+    def __ne__(self, other): # type: ignore
+        contextStack.root_context().build_comparison(self, "!=", other)
+
+    def is_in(self, other):
+        return contextStack.root_context().build_element_of(self, other)
+
+    def not_in(self, other):
+        return contextStack.root_context().build_not_element_of(self, other)
+
+    @abstractmethod
+    def map_builder(self, builder):
+        raise NotImplementedError(f"Not implemented for \"{type(self)}\".")
+
+
+class ScalarVariable(ScalarExpr):
+
+    def physical_typeof(self):
+        raise Exception(f"Cannot retrieve phsyical type of variable {self.display()}")
+
+    def grounded(self):
+        return False
+
+    def grounded_using(self, groundings):
+        return self.display() in groundings
+
+    def refersto(self, varname: str) -> bool:
+        return self.display() == varname
+
+    def scalar_refs(self):
+        return {self.display(): self}
+
+    def rename(self, renaming):
+        vname = self.display()
+        if vname in renaming:
+            return renaming[vname]
+        else:
+            return self
+
+    def substitute(self, bindings):
+        return self.rename(bindings)
+
+    def typeof(self):
+        pass
+
+    def variable(self):
+        return True
+
+class Literal(ScalarExpr):
+    def __init__(self, v): self.val = v
+
+    def display(self): return str(self.val)
+
+    def entityid(self): return hash(self.val)
+
+    def grounded(self): return True
+
+    def grounded_using(self, groundings): return True
+
+    def rename(self, renaming): return self
+
+    def revar(self, vmap): return self
+
+    def refersto(self, varname): return False
+
+    def simplify(self): return self
+
+    def substitute(self, bindings): return self
+
+    def __hash__(self):
+        return hash(self.val)
+
+    def map_builder(self, builder):
+        return self
+
+class Number(Literal):
+    pass
+
+class String(Literal):
+
+    def display(self): return f"\"{self.val}\""
+
+
+class Negate(ScalarExpr):
+    def __init__(self, x):
+        self._part = x
+
+    def display(self):
+        p = self._part
+        return f"- {p.display()}"
+
+    def entityid(self):
+        return hash((Negate, self._part.entityid()))
+
+    # Attempts to evaluate this expression statically, returning a single Number if
+    # possible, otherwise returns self.
+    #
+    def evaluate(self):
+        if self.grounded():
+            exec(f"self.x = {self.display()}")
+            return Number(self.x) # type: ignore
+        else:
+            return self
+
+    def grounded(self):
+        return self._part.grounded()
+
+    def grounded_using(self, groundings):
+        return self._part.grounded_using(groundings)
+
+    def scalar_refs(self):
+        return self._part.scalar_refs()
+
+    def refersto(self, varname):
+        return self._part.refersto(varname)
+
+    def rename(self, renaming):
+        return Negate(self._part.rename(renaming))
+
+    def revar(self, vmap):
+        return Negate(self._part.revar(vmap))
+
+    def simplify(self):
+        ev = self.evaluate()
+        if ev.entityid() != self.entityid():
+            return ev
+        else:
+            return Negate(self._part.simplify())
+
+    def substitute(self, bindings):
+        return Negate(self._part.substitute(bindings))
+
+
+class BinaryScalarExpr(ScalarExpr):
+
+    def __init__(self, op):
+        self._op = op
+
+    def display(self):
+        return f"{self._left.display()} {self._op} {self._right.display()}"
+
+    # Attempts to evaluate this expression statically, returning a single Number if
+    # possible, otherwise returns self.
+    #
+    def evaluate(self):
+        if self.grounded():
+            exec(f"self.x = {self.display()}")
+            return Number(self.x) # type: ignore
+        else:
+            return self
+
+    def grounded(self):
+        return self._left.grounded() and self._right.grounded()
+
+    def grounded_using(self, groundings):
+        return self._left.grounded_using(groundings) and self._right.grounded_using(groundings)
+
+    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):
+        return self._left.refersto(varname) or self._right.refersto(varname)
+
+    def set_args(self, x, z):
+        self._left = box_number(x)
+        self._right = box_number(z)
+
+    def op(self):
+        return self._op
+
+
+class Plus(BinaryScalarExpr):
+
+    def __init__(self, x, z):
+        super().__init__("+")
+        self.set_args(x, z)
+
+    def rename(self, renaming):
+        return Plus(self._left.rename(renaming),
+                    self._right.rename(renaming))
+
+    def revar(self, vmap):
+        return Plus(self._left.revar(vmap),
+                    self._right.revar(vmap))
+
+    def simplify(self):
+        ev = self.evaluate()
+        if ev.entityid() != self.entityid():
+            return ev
+        else:
+            return Plus(self._left.simplify(), self._right.simplify())
+
+    def substitute(self, bindings):
+        return Plus(self._left.substitute(bindings), self._right.substitute(bindings))
+
+    def entityid(self):
+        return hash((Plus,
+                     self._left.entityid(),
+                     self._right.entityid()))
+
+    def map_builder(self, builder):
+        return Plus(self._left.map_builder(builder), self._right.map_builder(builder))
+
+
+class Minus(BinaryScalarExpr):
+
+    def __init__(self, x, z):
+        super().__init__("-")
+        self.set_args(x, z)
+
+    def rename(self, renaming):
+        return Minus(self._left.rename(renaming),
+                     self._right.rename(renaming))
+
+    def revar(self, vmap):
+        return Minus(self._left.revar(vmap),
+                     self._right.revar(vmap))
+
+    def simplify(self):
+        ev = self.evaluate()
+        if ev.entityid() != self.entityid():
+            return ev
+        else:
+            return Minus(self._left.simplify(), self._right.simplify())
+
+    def substitute(self, bindings):
+        return Minus(self._left.substitute(bindings), self._right.substitute(bindings))
+
+    def entityid(self):
+        return hash((Minus,
+                     self._left.entityid(),
+                     self._right.entityid()))
+
+    def map_builder(self, builder):
+        return Minus(self._left.map_builder(builder), self._right.map_builder(builder))
+
+
+class Modulus(BinaryScalarExpr):
+    def __init__(self, x, z):
+        super().__init__("%")
+        self.set_args(x, z)
+
+    def rename(self, renaming):
+        return Modulus(self._left.rename(renaming),
+                       self._right.rename(renaming))
+
+    def revar(self, vmap):
+        return Modulus(self._left.revar(vmap),
+                       self._right.revar(vmap))
+
+    def simplify(self):
+        ev = self.evaluate()
+        if ev.entityid() != self.entityid():
+            return ev
+        else:
+            return Modulus(self._left.simplify(), self._right.simplify())
+
+    def substitute(self, bindings):
+        return Modulus(self._left.substitute(bindings), self._right.substitute(bindings))
+
+    def entityid(self):
+        return hash((Modulus,
+                     self._left.entityid(),
+                     self._right.entityid()))
+
+
+class Times(BinaryScalarExpr):
+
+    def __init__(self, x, z):
+        super().__init__("*")
+        self.set_args(x, z)
+
+    def rename(self, renaming):
+        return Times(self._left.rename(renaming),
+                     self._right.rename(renaming))
+
+    def revar(self, vmap):
+        return Times(self._left.revar(vmap),
+                     self._right.revar(vmap))
+
+    def simplify(self):
+        ev = self.evaluate()
+        if ev.entityid() != self.entityid():
+            return ev
+        else:
+            return Times(self._left.simplify(), self._right.simplify())
+
+    def substitute(self, bindings):
+        return Times(self._left.substitute(bindings), self._right.substitute(bindings))
+
+    def entityid(self):
+        return hash((Times,
+                     self._left.entityid(),
+                     self._right.entityid()))
+
+
+class Divide(BinaryScalarExpr):
+
+    def __init__(self, x, z):
+        super().__init__("/")
+        self.set_args(x, z)
+
+    def entityid(self):
+        return hash((Divide,
+                     self._left.entityid(),
+                     self._right.entityid()))
+
+    def rename(self, renaming):
+        return Divide(self._left.rename(renaming),
+                      self._right.rename(renaming))
+
+    def revar(self, vmap):
+        return Divide(self._left.revar(vmap),
+                      self._right.revar(vmap))
+
+    def simplify(self):
+        ev = self.evaluate()
+        if ev.entityid() != self.entityid():
+            return ev
+        else:
+            return Divide(self._left.simplify(), self._right.simplify())
+
+    def substitute(self, bindings):
+        return Divide(self._left.substitute(bindings), self._right.substitute(bindings))
+
+
+class ScalarExprBuilder(ExprBuilder):
+
+    def build_divide(self, left, right): return Divide(left, box_number(right))
+
+    def build_plus(self, left, right): return Plus(left, box_number(right))
+
+    def build_minus(self, left, right): return Minus(left, box_number(right))
+
+    def build_modulus(self, left, right): return Modulus(left, box_number(right))
+
+    def build_negate(self, expr): return Negate(expr)
+
+    def build_times(self, left, right): return Times(left, box_number(right))
+
+
+def box_number(x):
+    if isinstance(x, (int, float)):
+        return Number(x)
+    else:
+        if isinstance(x, str):
+            return String(x)
+        else:
+            return x

relationalai/early_access/dsl/core/instances.py

@@ -0,0 +1,44 @@
+from relationalai.early_access.dsl.core.exprs import Expr
+
+
+class Instance(Expr):
+
+    def __init__(self, c, arglist):
+        self.concept = c
+        self.arglist = arglist
+
+    def entityid(self):
+        arghashes = []
+        for c in self.arglist:
+            if isinstance(c, Instance):
+                arghashes.append(c.entityid())
+            else:
+                arghashes.append(c)
+        return hash((self.concept.entityid(), *arghashes))
+
+    def display(self):
+        params = []
+        for i in range(len(self.arglist)):
+            arg = self.arglist[i]
+            if isinstance(arg, Instance):
+                params.append(arg.pprint())
+            else:
+                # Otherwise, arg must be a constraint of some UnconstrainedValueType
+                if isinstance(arg, str):
+                    params.append(f"\"{arg}\"")
+                else:
+                    params.append(arg)
+        return self.concept.ctor_name() + '[' + ",".join(params) + ']'
+
+    def pprint(self):
+        return self.display()
+
+
+class ValueTypeInstance(Instance):
+
+    def __init__(self, vtype, arglist):
+        if len(arglist) != len(vtype._params):
+            raise Exception(
+                f"Value type {vtype.name()} constructor maps tuples of length {len(vtype.constructor())} but was "
+                f"instantiated with {len(arglist)} arguments")
+        Instance.__init__(self, vtype, arglist)

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

@@ -0,0 +1,193 @@
+from relationalai.early_access.dsl.core import warn
+from relationalai.early_access.dsl.core.builders.logic import LogicBuilder
+from relationalai.early_access.dsl.core.cset import ConstraintSet
+from relationalai.early_access.dsl.core.exprs.scalar import ScalarVariable, ScalarExprBuilder
+
+class RelVariable(ScalarVariable):
+
+    def __init__(self, nm, tp):
+        self._name = nm
+        self._type = tp
+
+    def display(self): return self._name
+
+    def entityid(self):
+        return hash((self._name, self._type.entityid()))
+
+    def physical_typeof(self):
+        return self.typeof().physical_typeof()
+
+    def typeof(self): return self._type
+
+    def __hash__(self):
+        return hash((self._name, self._type))
+
+    def map_builder(self, builder):
+        return RelVariable(self._name, self._type)
+
+class LogicFragment(ConstraintSet, LogicBuilder, ScalarExprBuilder):
+
+    def __init__(self):
+        ConstraintSet.__init__(self)
+        self._scalars = {}
+        self._existentials = {}
+
+    def add_component(self, d):
+        vname = d.display()
+
+        if vname not in self._scalars:
+            self._scalars[vname] = d
+            return True
+        else:
+            d1 = d.typeof()
+            d2 = self._scalars[vname].typeof()
+            if not d2.subtype_of(d1):
+                if d1.subtype_of(d2):
+                    self._scalars[vname] = d
+                else:
+                    raise Exception(
+                        f"++ Error: Cannot declare two scalar variables named {vname} in the same schema context")
+
+        return False
+
+    def add_existential_constraint(self, c):
+        self._existentials[id(c)] = c
+        return c
+
+    def build_atom(self, rel, args):
+        atom = LogicBuilder.build_atom(self, rel, args)
+        self.add_atomic_constraint(atom)
+        return atom
+
+    def build_comparison(self, left, op, right):
+        c = LogicBuilder.build_comparison(self, left, op, right)
+        self.add_scalar_constraint(c)
+        return c
+
+    def build_scalar_variable(self, args, kwargs):
+        tp = args[0]
+        if len(args) < 2 or not isinstance(args[1], str):
+            raise Exception("This should not happen")
+
+        decl = RelVariable(args[1], tp)
+        self.add_component(decl)
+        return decl
+
+    def build_relation_variable(self, args, kwargs):
+        tp = args[0]
+
+        # [REKS] Very subtle. This is needed because when tp is a ConstrainedValueType,
+        #        this method will be called. Correct during type analysis, but incorrect
+        #        during declarations of Rel variables of said type
+        #
+        if tp.nominal():
+            return self.build_scalar_variable(args, kwargs)
+
+        # [REKS] Another subtlety. In Rel, we can name a Relation the same as an EntityType,
+        #        and we often do this for relations that maintain the finite population of
+        #        entites of that type. But then we can refer to these relations as Atoms in
+        #        rules, and they will be interpreted as requests to instantiate the EntityType
+        #        with a variable name -- which is not a name but a RelVariable meant to range
+        #        over the population of the relation.
+        #
+        varorname = args[1]
+        if isinstance(varorname, RelVariable):
+            # [VAMI] TODO: uncomment later
+            # warn(f"Corner case to follow up on when building_relation_varornameiable {varorname.display()}")
+            return self.build_atom(tp.population(), [varorname])
+        else:
+            decl = RelVariable(varorname, tp)
+
+            self.add_component(decl)
+            return decl
+
+
+    # Partially evaluate this Schema by substituting values for
+    # its schema variables, simplifying where possible.
+    #
+    def evaluate(self, bdgs):
+
+        # Project away from decls any variables that are declared in pdecls
+        #
+        def project_decls(decls, pdecls):
+            return {v: decls[v] for v in decls if v not in pdecls}
+
+        decls = project_decls(self._scalars, bdgs)
+
+        super = ConstraintSet.evaluate(self, bdgs)
+
+        if super is None:
+            return super
+        else:
+            s = LogicFragment()
+            s._scalars = decls
+            s._sconstraints = super._sconstraints
+            s._atoms = super._atoms
+            return s
+
+    def propositional_constraints(self):
+        par = ConstraintSet.propositional_constraints(self)
+        if len(self._existentials) == 0:
+            return par
+        else:
+            d = self._existentials
+            for x in d:
+                par[x] = d[x]
+        return par
+
+    def rel_formula(self):
+        subf = ConstraintSet.rel_formula(self)
+        if len(self._existentials) == 0:
+            if len(subf) == 0:
+                return '    true'
+            else:
+                return subf
+        else:
+            xcs = [c.rel_formula() for c in self._existentials.values()]
+            xf = "\n".join(xcs)
+            if subf == "":
+                return xf
+            return subf + "\n" + xf
+
+    # Given an optional set of constraints that defaults to all propositional
+    # constraints in this LogicFragment, returns a dictionary that represents
+    # that subset of this Fragment's scalar variables that is not grounded by
+    # those constraints.
+    #
+    # Grounding is decided the same way it is in datalog, namely if the
+    # variable is referenced positively in a finite relation or in an
+    # atom of an infinite relation in which every other variable in that
+    # atom is grounded.
+    #
+    def ungrounded_components(self, constraints=None):
+
+        if constraints is None:
+            constraints = self.propositional_constraints()
+        vars = [d for d in self._scalars.values()]
+
+        groundings = {}
+        glen = -1
+
+        while glen < len(groundings):
+            glen = len(groundings)
+
+            for c in constraints.values():
+                for v in vars:
+                    if c.grounds(v, groundings):
+                        groundings[v.display()] = v
+
+        return [v for v in vars if v.display() not in groundings]
+
+    def view(self, view_name):
+        c = self.ungrounded_components()
+
+        args = ", ".join([v.display() for v in self._scalars.values()])
+        body = self.rel_formula()
+        rule = f"def {view_name}({args}): " + "\n" + body
+
+        if len(c) > 0:
+            vstr = ", ".join([v.display() for v in c])
+            warn(f"Ungrounded variables ({vstr}) in schema prevent materialization (declaring view @inline)")
+            return "@inline\n" + rule
+        else:
+            return rule