kele 0.0.1a1__cp313-cp313-win32.whl

kele/syntax/_cnf_converter.py

@@ -0,0 +1,161 @@
+"""最合理的方案是调用有名的包，不过我没看什么合适的，就先作罢，手搓一个。这个也不是关键瓶颈"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+# FIXME: 另外请注意这里只是一个简单的CNF，无法获得最小的CNF（每个clause的元素尽可能少）。而且现在的单测检查规则也不够智能，不是用永真式验证的
+# 而是严格要求一致
+
+from .connectives import AND, EQUAL, IMPLIES, NOT, OR
+from .base_classes import Assertion, FACT_TYPE, Formula
+
+
+def _eliminate_implications(f: FACT_TYPE) -> FACT_TYPE:
+    """
+    1. 先递归处理左右子公式
+    2. 如果当前节点是EQUAL，就把 A ↔ B 转换为 (A → B) ∧ (B → A)
+    3. 如果当前节点是 IMPLIES，就把 A → B 转换为 (¬A) ∨ B
+    """
+    if isinstance(f, Assertion):
+        return f
+
+    # 递归下放
+    left = _eliminate_implications(f.formula_left)
+    right = None
+    if f.formula_right is not None:
+        right = _eliminate_implications(f.formula_right)
+
+    if f.connective == EQUAL:
+        if TYPE_CHECKING:
+            right = cast('FACT_TYPE', right)  # 当connective为EQUAL的时候formula_right一定不为None
+
+        # 构造两个单向蕴含
+        impl1 = Formula(left, IMPLIES, right)
+        impl2 = Formula(right, IMPLIES, left)
+        # 递归消除里面的蕴含
+        return Formula(
+            _eliminate_implications(impl1),
+            AND,
+            _eliminate_implications(impl2)
+        )
+
+    # 处理蕴含
+    if f.connective == IMPLIES:
+        # A → B  ⇒  (¬A) ∨ B
+        neg_left = Formula(left, NOT, None)
+        return Formula(neg_left, OR, right)
+
+    return Formula(left, f.connective, right)
+
+
+def _move_negations_inward(f: FACT_TYPE) -> FACT_TYPE:
+    """
+    使用德摩根律，把所有 ¬ 向内推进到原子断言层面。
+    """
+    if isinstance(f, Assertion):
+        return f
+
+    if f.connective != NOT:
+        left = _move_negations_inward(f.formula_left)
+        right = None
+        if f.formula_right is not None:
+            right = _move_negations_inward(f.formula_right)
+        return Formula(left, f.connective, right)
+
+    # 对应f.connective为 'NOT'
+    inner = f.formula_left
+    # 如果 ¬ 后面又是一个 Formula，就应用德摩根
+    if isinstance(inner, Formula):
+        if inner.connective == AND:
+            # ¬(A ∧ B) => (¬A) ∨ (¬B)
+            left = _move_negations_inward(Formula(inner.formula_left, NOT, None))
+            right = _move_negations_inward(Formula(inner.formula_right, NOT, None)) if inner.formula_right is not None else None
+            return Formula(left, OR, right)
+        if inner.connective == OR:
+            # ¬(A ∨ B) => (¬A) ∧ (¬B)
+            left = _move_negations_inward(Formula(inner.formula_left, NOT, None))
+            right = _move_negations_inward(Formula(inner.formula_right, NOT, None)) if inner.formula_right is not None else None
+            return Formula(left, AND, right)
+        if inner.connective == NOT:
+            # ¬¬A => A
+            return _move_negations_inward(inner.formula_left)
+
+    # 如果formula_left是Assertion，不需要处理
+    return f
+
+
+def _distribute_or_over_and(f: FACT_TYPE) -> FACT_TYPE:
+    """
+    应用分配律，把 ∨ 分布到 ∧ 上，生成 CNF 形式。
+    只处理当前节点是 OR 的情况，其它先递归。
+    """
+    if isinstance(f, Assertion):
+        return f
+
+    # 先递归下放
+    left = _distribute_or_over_and(f.formula_left)
+    right = None
+    if f.formula_right is not None:
+        right = _distribute_or_over_and(f.formula_right) if isinstance(f.formula_right, FACT_TYPE) else f.formula_right
+
+    # 只关心 OR 节点
+    if f.connective == OR:
+        # 如果左子公式是 AND，(A ∧ B) ∨ C => (A ∨ C) ∧ (B ∨ C)
+        if isinstance(left, Formula) and left.connective == AND:
+            formula_left = left.formula_left
+            formula_right = left.formula_right
+
+            if TYPE_CHECKING:  # 当connective为AND的时候formula_right一定不为None
+                # HACK: 理想情况下这个通过Formula内部保障，不过这个AND可能还是难以被mypy理解，可能也是工厂模式提供5个子类
+                formula_right = cast('FACT_TYPE', formula_right)
+
+            a = _distribute_or_over_and(Formula(formula_left, OR, right))
+            b = _distribute_or_over_and(Formula(formula_right, OR, right))
+            return Formula(a, AND, b)
+        # 如果右子公式是 AND，A ∨ (B ∧ C) => (A ∨ B) ∧ (A ∨ C)
+        if isinstance(right, Formula) and right.connective == AND:
+            a = _distribute_or_over_and(Formula(left, OR, right.formula_left))
+            b = _distribute_or_over_and(Formula(left, OR, right.formula_right))
+            return Formula(a, AND, b)
+
+    # 其它情况不变
+    return Formula(left, f.connective, right)
+
+
+def to_cnf(formula: FACT_TYPE) -> FACT_TYPE:
+    """
+    将任意公式转换为合取范式（CNF）。
+    步骤：
+      1. 消除蕴含
+      2. 消除部分否定
+      3. 分配率替换OR为AND
+    """
+    step1 = _eliminate_implications(formula)
+    step2 = _move_negations_inward(step1)
+    return _distribute_or_over_and(step2)  # 暂且认为不动点算法是非必要的，因为德摩根律不引入蕴含、分配率也不引入否定和蕴含。
+
+
+def _split_and(f: FACT_TYPE) -> list[FACT_TYPE]:
+    """
+    如果当前公式是 AND 连接符，则递归拆分左右子公式，否则返回当前公式本身。
+    """
+    # 如果公式是一个原子断言，直接返回
+    if isinstance(f, Assertion):
+        return [f]
+
+    # 如果当前公式的连接符是 AND，递归拆分左右子公式
+    if f.connective == AND:
+        left_facts = _split_and(f.formula_left)
+        right_facts = _split_and(f.formula_right) if f.formula_right is not None else []
+        return left_facts + right_facts
+
+    # 如果当前公式的连接符不是 AND，直接返回当前公式
+    return [f]
+
+
+def to_cnf_clauses(formula: FACT_TYPE) -> list[FACT_TYPE]:
+    """
+    先将公式转为 CNF，然后分拆为多个子句
+    """
+    cnf_formula = to_cnf(formula)
+    return _split_and(cnf_formula)

kele/syntax/_sat_solver.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+from bidict import bidict
+
+from kele.syntax import Assertion, Formula, FACT_TYPE, Rule, Concept, Constant
+from pysat.formula import CNF
+from pysat.solvers import Solver
+
+atom_to_var: bidict[Assertion, int] = bidict()
+cnf = CNF()
+
+
+def _get_var_for_assertion(assertion: Assertion) -> int:
+    if assertion not in atom_to_var:
+        vid = len(atom_to_var) + 1
+        atom_to_var[assertion] = vid
+        return vid  # hack: 理想情况下应该写atom_to_var[assertion]，但此时assertion的hash太慢了
+    return atom_to_var[assertion]
+
+
+def to_pysat_cnf(facts: list[FACT_TYPE]) -> list[list[int]]:
+    """
+    输入已经是处理过cnf的了，只需要同等转换
+    :raise ValueError: 如果输入的facts不符合CNF格式
+    """  # noqa: DOC501
+    pysat_program = []
+    for clause in facts:
+        if isinstance(clause, Assertion):
+            pysat_clause = [_get_var_for_assertion(clause)]
+        elif clause.connective == 'OR':
+            if TYPE_CHECKING:
+                clause.formula_right = cast('FACT_TYPE', clause.formula_right)
+
+            lf = to_pysat_cnf([clause.formula_left])[0]
+            rt = to_pysat_cnf([clause.formula_right])[0]
+
+            pysat_clause = lf + rt
+        elif clause.connective == 'NOT':
+            if TYPE_CHECKING:  # 因为已经转了CNF格式，CNF格式内的NOT只可能出现在Assertion上
+                clause.formula_left = cast('Assertion', clause.formula_left)
+
+            if isinstance(clause.formula_left, Assertion):
+                pysat_clause = [-_get_var_for_assertion(clause.formula_left)]
+            else:  # HACK: 这里确实没必要检查，只是功能初期稳妥一下
+                raise TypeError("CNF error.")
+        else:
+            raise ValueError("CNF conversion error.")  # HACK: 这里确实没必要检查，只是功能初期稳妥一下
+
+        pysat_program.append(pysat_clause)
+
+    return pysat_program
+
+
+def rule_to_cnf(rule: Rule) -> list[list[int]]:
+    body = to_pysat_cnf(rule.body_units)
+    head = to_pysat_cnf(rule.head_units)
+    return head + body  # 只取head为True的情况
+
+
+# -----------------
+# 枚举所有模型并统计 Assertion 的可能取值
+
+def get_models_for_rule(rule: Rule) -> dict[Assertion, list[bool]]:
+    """
+    对于一个Rule，从bool逻辑的角度找到所有可能的model，对应models变量；
+    并具体分析assignment，以判断其中各个assertion是否可能取True或False，对应possible_values。
+    HACK: 以后的优化余地是用信息更全面的models控制求解路径，而不是possible_values
+    """
+    cnf.extend(rule_to_cnf(rule))
+
+    models = []
+    possible_values = {atom: [False, False] for atom in atom_to_var}  # (bool, bool)分别表示某assertion是否在某个model中为True或False
+    # 若在第一位为True，则表示存在一个model，那个model里此assertion为True；若第二位为True，表明存在一个model，此assertion为False。
+
+    with Solver(name="glucose4", bootstrap_with=cnf) as solver:
+        while solver.solve():
+            model = solver.get_model()
+            assignment = {}
+            for atom, vid in atom_to_var.items():
+                val = (vid in model)  # PySAT: 正整数 = True, 负整数 = False
+                assignment[atom] = val
+
+                possible_values[atom][0 if val else 1] = True
+
+            models.append(assignment)
+            # 阻断该model，因为SAT求解器会一个个返回。
+            solver.add_clause([-lit for lit in model])
+
+    return possible_values
+
+
+if __name__ == '__main__':
+    Points = Concept("Points")  # 点
+    A = Constant("A", Points)
+    B = Constant("B", Points)
+    C = Constant("C", Points)
+    D = Constant("D", Points)
+    E = Constant("E", Points)
+
+    a = Assertion(A, B)
+    b = Assertion(C, D)
+    c = Assertion(E, C)
+    d = Assertion(E, D)
+
+    rule = Rule(head=b, body=[a, Formula(c, 'IMPLIES', d)])
+
+    cnf = CNF()
+    cnf.extend(rule_to_cnf(rule))  # a → b
+
+    possible_values = get_models_for_rule(rule)
+
+    print("\n每个 Assertion 的可能取值：")  # noqa: T201
+    for atom, vals in possible_values.items():
+        print(f"{atom}: {vals}")  # noqa: T201  # 示例就print了，也不值得进测试