problog 2.2.5__py3-none-any.whl

problog/__init__.py

@@ -0,0 +1,114 @@
+"""
+Part of the ProbLog distribution.
+
+Copyright 2015 KU Leuven, DTAI Research Group
+
+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.
+"""
+import os
+import sys
+import typing
+
+sys.setrecursionlimit(10000)
+
+# Set the PATH and PYTHON_PATH variables
+from .setup import set_environment, gather_info
+
+set_environment()
+
+system_info = gather_info()
+
+
+def root_path(*args):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", *args))
+
+
+library_paths = [root_path("problog", "library")]
+
+
+# Load all submodules. This has two reasons:
+#   - initializes all transformations (@transform)
+#   - makes it possible to just import 'problog' and then use
+#       something like problog.program.PrologFile
+from . import cnf_formula
+from . import core
+from . import engine
+from . import evaluator
+from . import formula
+from . import logic
+from . import ddnnf_formula
+from . import parser
+from . import program
+from . import sdd_formula
+from . import sdd_formula_explicit
+from . import util
+from . import bdd_formula
+from . import forward
+from . import cycles
+from . import kbest
+from . import tasks
+from . import debug
+
+_evaluatables: typing.Dict[str, typing.Type[evaluator.Evaluatable]] = {
+    "sdd": sdd_formula.SDD,
+    "sddx": sdd_formula_explicit.SDDExplicit,
+    "bdd": bdd_formula.BDD,
+    "nnf": ddnnf_formula.DDNNF,
+    "ddnnf": ddnnf_formula.DDNNF,
+    "kbest": kbest.KBestFormula,
+    "fsdd": forward.ForwardSDD,
+    "fbdd": forward.ForwardBDD,
+}
+
+_semirings: typing.Dict[str, typing.Type[evaluator.Semiring]] = {
+    "prob": evaluator.SemiringProbability,
+    "logprob": evaluator.SemiringLogProbability,
+    "symbolic": evaluator.SemiringSymbolic,
+}
+
+
+def get_semirings() -> typing.Collection[str]:
+    """Get the set of registered semirings."""
+    return _semirings.keys()
+
+
+def register_semiring(name: str, cls: typing.Type[evaluator.Semiring]):
+    """Register a semiring in the semiring registry."""
+    assert (
+        name not in _semirings
+    ), "A semi-ring with the same name is already registered."
+    _semirings[name] = cls
+
+
+def get_semiring(name: typing.Optional[str] = None) -> typing.Type[evaluator.Semiring]:
+    """Lookup a semiring."""
+    if name is None:
+        return _semirings["prob"]
+    return _semirings.get(name, None)
+
+
+def get_evaluatables() -> typing.Collection[str]:
+    return _evaluatables.keys()
+
+
+def get_evaluatable(
+    name: typing.Optional[str] = None,
+    semiring: typing.Optional[evaluator.Semiring] = None,
+) -> typing.Type[evaluator.Evaluatable]:
+    if name is None:
+        if semiring is None or semiring.is_dsp():
+            return evaluator.EvaluatableDSP
+        else:
+            return formula.LogicNNF
+    else:
+        return _evaluatables[name]

problog/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .tasks import main
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

problog/bdd_formula.py

@@ -0,0 +1,176 @@
+"""
+problog.bdd_formula - Binary Decision Diagrams
+----------------------------------------------
+
+Provides access to Binary Decision Diagrams (BDDs).
+
+..
+    Part of the ProbLog distribution.
+
+    Copyright 2015 KU Leuven, DTAI Research Group
+
+    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.
+"""
+
+from .core import transform
+from .dd_formula import DD, build_dd, DDManager
+from .errors import InstallError
+from .formula import LogicDAG
+
+# noinspection PyBroadException
+# noinspection PyUnresolvedReferences
+try:
+    # noinspection PyPackageRequirements
+    import pyeda.boolalg.bdd as bdd
+
+    # noinspection PyPackageRequirements
+    import pyeda.boolalg.expr as bdd_expr
+except Exception:
+    bdd = None
+
+
+class BDD(DD):
+    """A propositional logic formula consisting of and, or, not and atoms represented as an BDD."""
+
+    def __init__(self, **kwdargs):
+        if bdd is None:
+            raise InstallError("The BDD library is not available.")
+
+        DD.__init__(self, auto_compact=False, **kwdargs)
+
+    def _create_manager(self):
+        return BDDManager()
+
+    def get_atom_from_inode(self, node):
+        """Get the original atom given an internal node.
+
+        :param node: internal node
+        :return: atom represented by the internal node
+        """
+        return self.var2atom[self.get_manager().get_variable(node)]
+
+    @classmethod
+    def is_available(cls):
+        """Checks whether the BDD library is available."""
+        return bdd is not None
+
+
+class BDDManager(DDManager):
+    """
+    Manager for BDDs.
+    It wraps around the pyeda BDD module
+    """
+
+    # noinspection PyUnusedLocal
+    def __init__(self, varcount=0, auto_gc=True):
+        """Create a new BDD manager.
+
+        :param varcount: number of initial variables
+        :type varcount: int
+        :param auto_gc: use automatic garbage collection and minimization
+        :type auto_gc: bool
+        """
+        DDManager.__init__(self)
+        self.varcount = 1
+        self.ZERO = bdd.expr2bdd(bdd_expr.expr("0"))
+        self.ONE = bdd.expr2bdd(bdd_expr.expr("1"))
+
+    def add_variable(self, label=0):
+        if label == 0 or label > self.varcount:
+            self.varcount += 1
+            return self.varcount
+        else:
+            return label
+
+    def get_variable(self, node):
+        """Get the variable represented by the given node.
+
+        :param node: internal node
+        :return: original node
+        """
+        # noinspection PyProtectedMember
+        return int(bdd._VARS[node.root].name[1:])
+
+    def literal(self, label):
+        return bdd.bddvar("v" + str(self.add_variable(label)))
+
+    def is_true(self, node):
+        return node.is_one()
+
+    def true(self):
+        return self.ONE
+
+    def is_false(self, node):
+        return node.is_zero()
+
+    def false(self):
+        return self.ZERO
+
+    def conjoin2(self, r, s):
+        return r & s
+
+    def disjoin2(self, r, s):
+        return r | s
+
+    def negate(self, node):
+        return ~node
+
+    def same(self, node1, node2):
+        # Assumes BDD library always reuses equivalent nodes.
+        return node1 is node2
+
+    def ref(self, *nodes):
+        pass
+
+    def deref(self, *nodes):
+        pass
+
+    def write_to_dot(self, node, filename):
+        with open(filename, "w") as f:
+            print(node.to_dot(), file=f)
+
+    def wmc(self, node, weights, semiring):
+        pall = semiring.zero()
+        for path in node.satisfy_all():
+            pw = semiring.one()
+            for var, val in path.items():
+                var = int(var.name[1:])
+                pos, neg = weights[var]
+                if val:
+                    p = pos
+                else:
+                    p = neg
+                pw = semiring.times(p, pw)
+            pall = semiring.plus(pw, pall)
+        return pall
+
+    def wmc_literal(self, node, weights, semiring, literal):
+        raise NotImplementedError("not supported")
+
+    def wmc_true(self, weights, semiring):
+        return semiring.one()
+
+    def __del__(self):
+        pass
+
+
+@transform(LogicDAG, BDD)
+def build_bdd(source, destination, **kwdargs):
+    """Build an SDD from another formula.
+
+    :param source: source formula
+    :param destination: destination formula
+    :param kwdargs: extra arguments
+    :return: destination
+    """
+    return build_dd(source, destination, **kwdargs)

problog/bdd_formula_alt.py

@@ -0,0 +1,253 @@
+"""
+problog.bdd_formula - Binary Decision Diagrams
+----------------------------------------------
+
+Provides access to Binary Decision Diagrams (BDDs).
+
+..
+    Part of the ProbLog distribution.
+
+    Copyright 2015 KU Leuven, DTAI Research Group
+
+    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.
+"""
+
+from .core import transform
+from .dd_formula import DD, build_dd, DDManager
+from .errors import InstallError
+from .formula import LogicDAG
+
+# noinspection PyBroadException
+# noinspection PyUnresolvedReferences
+try:
+    # noinspection PyPackageRequirements
+    pass
+except Exception:
+    bdd = None
+
+import dd.autoref as bdd
+
+
+class BDD(DD):
+    """A propositional logic formula consisting of and, or, not and atoms represented as an BDD."""
+
+    def __init__(self, **kwdargs):
+        if bdd is None:
+            raise InstallError("The BDD library is not available.")
+
+        DD.__init__(self, auto_compact=False, **kwdargs)
+
+    def _create_manager(self):
+        return BDDManager()
+
+    def get_atom_from_inode(self, node):
+        """Get the original atom given an internal node.
+
+        :param node: internal node
+        :return: atom represented by the internal node
+        """
+        return self.var2atom[self.get_manager().get_variable(node)]
+
+    @classmethod
+    def is_available(cls):
+        """Checks whether the BDD library is available."""
+        return bdd is not None
+
+
+class BDDManager(DDManager):
+    """
+    Manager for BDDs.
+    It wraps around the pyeda BDD module
+    """
+
+    # noinspection PyUnusedLocal
+    def __init__(self, varcount=0, auto_gc=True):
+        """Create a new BDD manager.
+
+        :param varcount: number of initial variables
+        :type varcount: int
+        :param auto_gc: use automatic garbage collection and minimization
+        :type auto_gc: bool
+        """
+        DDManager.__init__(self)
+        self.varcount = 1
+        self.base = bdd.BDD()
+        self.ZERO = self.base.false
+        self.ONE = self.base.true
+
+    def add_variable(self, label=0):
+        if label == 0 or label > self.varcount:
+            self.varcount += 1
+            res = self.varcount
+        else:
+            res = label
+        self.base.declare("v" + str(res))
+        return res
+
+    def get_variable(self, node):
+        """Get the variable represented by the given node.
+
+        :param node: internal node
+        :return: original node
+        """
+        # noinspection PyProtectedMember
+        return self.base.var(node)
+
+    def literal(self, label):
+        return self.base.var("v" + str(self.add_variable(label)))
+
+    def is_true(self, node):
+        return node.is_one()
+
+    def true(self):
+        return self.ONE
+
+    def is_false(self, node):
+        return node.is_zero()
+
+    def false(self):
+        return self.ZERO
+
+    def conjoin2(self, r, s):
+        return r & s
+
+    def disjoin2(self, r, s):
+        return r | s
+
+    def negate(self, node):
+        return ~node
+
+    def same(self, node1, node2):
+        # Assumes BDD library always reuses equivalent nodes.
+        return node1 is node2
+
+    def ref(self, *nodes):
+        pass
+
+    def deref(self, *nodes):
+        pass
+
+    def write_to_dot(self, node, filename):
+        with open(filename, "w") as f:
+            print(node.to_dot(), file=f)
+
+    def _parse_expr(self, expr):
+        # EXPR := VAR | "TRUE" | "FALSE" | ITE
+        # ITE := "ite" "(" VAR "," EXPR "," EXPR ")"
+        # VAR := expression
+        lexpr = len(expr)
+        if expr.startswith("TRUE"):
+            res = "TRUE"
+            pos = 4
+        elif expr.startswith("FALSE"):
+            res = "FALSE"
+            pos = 5
+        elif expr.startswith("ite("):
+            pos = 4
+            var, rst = expr[pos:].split(", ", 1)
+            ift, pos1 = self._parse_expr(rst)
+            iff, pos2 = self._parse_expr(rst[pos1:])
+            res = (var, ift, iff)
+            pos += pos1 + pos2 + len(var)
+        elif expr.startswith("(~ "):
+            pos = 3
+            sub, pos1 = self._parse_expr(expr[pos:])
+            pos = pos + pos1 + 1
+            res = ("~", sub)
+        else:
+            pos = 0
+            while pos < lexpr and expr[pos] not in " ,)":
+                pos += 1
+            res = expr[:pos]
+        while pos < lexpr and expr[pos] in " ,)":
+            pos += 1
+
+        return res, pos
+
+    def _enum_paths(self, expr, weights, semiring, negated=False):
+        if expr == "TRUE":
+            if not negated:
+                yield semiring.one()
+        elif expr == "FALSE":
+            if negated:
+                yield semiring.one()
+        elif type(expr) == str:
+            v = int(expr[1:])
+            wp, wn = weights[abs(v)]
+            if v > 0:
+                pass
+            else:
+                wp, wn = wn, wp
+            if negated:
+                yield wn
+            else:
+                yield wp
+        elif len(expr) == 3:
+            v = int(expr[0][1:])
+            wp, wn = weights[abs(v)]
+            if v > 0:
+                pass
+            else:
+                wp, wn = wn, wp
+
+            for p in self._enum_paths(expr[1], weights, semiring, negated=negated):
+                if negated:
+                    yield semiring.plus(wn, p)
+                else:
+                    yield semiring.times(wp, p)
+            for p in self._enum_paths(expr[2], weights, semiring, negated=negated):
+                if negated:
+                    yield semiring.plus(wp, p)
+                else:
+                    yield semiring.times(wn, p)
+        else:
+            if negated:
+                pall = semiring.one()
+            else:
+                pall = semiring.zero()
+            for p in self._enum_paths(expr[1], weights, semiring, negated=not negated):
+                if negated:
+                    pall = semiring.times(pall, p)
+                else:
+                    pall = semiring.plus(pall, p)
+            yield pall
+
+    def wmc(self, node, weights, semiring):
+        pall = semiring.zero()
+
+        expr, _ = self._parse_expr(node.to_expr())
+
+        for prob in self._enum_paths(expr, weights, semiring):
+            pall = semiring.plus(prob, pall)
+        return pall
+
+    def wmc_literal(self, node, weights, semiring, literal):
+        raise NotImplementedError("not supported")
+
+    def wmc_true(self, weights, semiring):
+        return semiring.one()
+
+    def __del__(self):
+        pass
+
+
+@transform(LogicDAG, BDD)
+def build_bdd(source, destination, **kwdargs):
+    """Build an SDD from another formula.
+
+    :param source: source formula
+    :param destination: destination formula
+    :param kwdargs: extra arguments
+    :return: destination
+    """
+    return build_dd(source, destination, **kwdargs)

problog/bin/darwin/cnf2dDNNF_wine

@@ -0,0 +1,12 @@
+#! /bin/bash
+
+# To start using:
+# - Install wine
+#       For example using HomeBrew:
+#           brew install wine
+#       ProbLog expects `wine` to be available on the PATH.
+# - Download c2d_windows.exe and rename it to cnf2dDNNF.exe
+#       see http://reasoning.cs.ucla.edu/c2d/
+# - Rename this file to 'cnf2dDNNF' to activate
+
+wine ${BASH_SOURCE[0]}.exe $*