kele 0.0.1a1__cp314-cp314-win_amd64.whl

kele/control/status.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+from enum import Enum, auto
+
+from typing import TYPE_CHECKING, Literal
+import logging
+
+if TYPE_CHECKING:
+    from kele.syntax import FACT_TYPE, Question
+    from kele.equality import Equivalence
+    from collections.abc import Sequence, Mapping
+    from kele.syntax import Variable, Rule, CompoundTerm, Constant, _QuestionRule
+    from kele.syntax import SankuManagementSystem
+
+logger = logging.getLogger(__name__)
+
+
+class InferenceStatus(Enum):
+    """推理过程的终止状态类型"""
+
+    SUCCESS = auto()  # 成功推理出答案
+    MAX_STEPS_REACHED = auto()  # 达到最大执行轮次限制
+    MAX_ITERATIONS_REACHED = auto()  # 达到最大迭代次数限制（从main循环）
+    FIXPOINT_REACHED = auto()  # 达到不动点
+    CONFLICT_DETECTED = auto()  # 推理中发现矛盾
+    EXTERNALLY_INTERRUPTED = auto()  # 被外部中断（如人为终止）
+    NO_MORE_RULES = auto()  # 没有更多实例化规则可以推理
+    CONTINUE = auto()  # 当前轮未结束，继续执行
+
+    def log_message(self) -> str:
+        """每个状态对应的日志输出信息"""
+        return {
+            InferenceStatus.SUCCESS: "Successfully inferred the answer.",
+            InferenceStatus.MAX_STEPS_REACHED: "Max execution steps reached, terminating.",
+            InferenceStatus.MAX_ITERATIONS_REACHED: "Max inference iterations reached, terminating.",
+            InferenceStatus.FIXPOINT_REACHED: "Fixpoint reached, terminating.",
+            InferenceStatus.CONFLICT_DETECTED: "Conflict detected during execution.",
+            InferenceStatus.EXTERNALLY_INTERRUPTED: "Execution was externally interrupted.",
+            InferenceStatus.NO_MORE_RULES: "No more grounded rules available for execution.",
+            InferenceStatus.CONTINUE: "Execution continues to next round."
+        }[self]
+
+    def is_terminal_for_executor(self) -> bool:
+        """判断执行器是否应该终止"""
+        return self != InferenceStatus.CONTINUE
+
+    def is_terminal_for_main_loop(self) -> bool:
+        """判断主循环是否应该终止"""
+        return self in {
+            InferenceStatus.SUCCESS,
+            InferenceStatus.MAX_STEPS_REACHED,
+            InferenceStatus.MAX_ITERATIONS_REACHED,
+            InferenceStatus.FIXPOINT_REACHED,
+            InferenceStatus.EXTERNALLY_INTERRUPTED
+        }
+
+
+class QuerySolutionManager:
+    """查询解管理器：负责打印、收集和管理查询解"""
+
+    def __init__(self, interactive_query_mode: Literal["interactive", "first", "all"] = "first",
+                 *, store_solutions: bool = False) -> None:
+        self.collected_solutions: list[Mapping[Variable, Constant | CompoundTerm]] = []
+        self.interactive_query_mode = interactive_query_mode
+        self.store_solutions = store_solutions
+        self._solution_count: int = 0
+
+    def reset(self) -> None:
+        """清空已收集的解和计数"""
+        self.collected_solutions.clear()
+        self._solution_count = 0
+
+    def print_and_collect(
+        self,
+        question: Question,
+        solutions: list[Mapping[Variable, Constant | CompoundTerm]],
+        question_rule: _QuestionRule
+    ) -> bool:
+        """
+        打印并收集解
+        :return: 是否应该终止推理
+        """
+        question_str = ", ".join(str(q) for q in question.question)
+
+        for combination in solutions:
+            self._solution_count += 1
+
+            if combination:
+                binding_str = self._display_binding(combination)
+                logger.info("Query solution: %s variable bindings: %s", question_str, binding_str)
+                if self.store_solutions:
+                    self.collected_solutions.append(combination)
+            else:
+                logger.info("Query solution: %s", question_str)
+                if self.store_solutions:
+                    self.collected_solutions.append(combination)
+                if not question_rule.free_variables:
+                    return True
+
+            # 根据模式决定是否终止
+            if self._should_terminate(self.interactive_query_mode):
+                return True
+
+        return False  # 继续推理
+
+    @staticmethod
+    def _display_binding(combination: Mapping[Variable, Constant | CompoundTerm]) -> str:
+        """ 将内部变量名还原为查询中的原始变量名"""
+        entries: list[str] = []
+        for var, term in combination.items():
+            entries.append(f"{var.display_name}={term}")
+        return ", ".join(entries)
+
+    @staticmethod
+    def _should_terminate(mode: Literal["interactive", "first", "all"]) -> bool:
+        """根据交互模式决定是否应该终止推理"""
+        if mode == "first":
+            logger.info("Configured to output only the first query solution; stopping inference.")
+            return True
+
+        if mode == "all":
+            return False
+
+        user_input = input("发现解，输入 ';' 并回车继续本次推理；输入其他任意键并回车将终止本次推理: ").strip()  # TODO: input不太适合后续扩展
+        if user_input != ';':
+            logger.info("用户选择终止推理。")
+            return True
+        return False
+
+    def get_all_solutions(self) -> list[Mapping[Variable, Constant | CompoundTerm]]:
+        """返回所有已收集的解映射（如果 store_solutions=False，返回空列表）"""
+        return self.collected_solutions
+
+    def get_solution_count(self) -> int:
+        """返回找到的解数量"""
+        return self._solution_count
+
+
+class StatusChecker:
+    """通用状态检查逻辑"""
+
+    def __init__(self, equivalence: Equivalence, sk_system_handler: SankuManagementSystem):
+        self.equivalence = equivalence
+        self.sk_system_handler = sk_system_handler
+
+    def check_conflict(self, new_facts: list[FACT_TYPE]) -> bool:
+        """检查是否发生了矛盾。!!! 注意这里传入的是new_facts"""
+        return self._has_conflict_occurred(new_facts)
+
+    @staticmethod
+    def _has_conflict_occurred(new_facts: list[FACT_TYPE]) -> bool:
+        """检查是否发生了矛盾"""
+        # TODO: 实现矛盾检测逻辑
+        return False
+
+
+class MainLoopManager:
+    """主循环管理器"""
+
+    def __init__(self, status_checker: StatusChecker, max_iterations: int = 300):
+        self.status_checker = status_checker
+        self.max_iterations = max_iterations
+        self._current_iteration = 0
+
+        self.normal_rule_activated: dict[Rule, bool] = {}  # 如果某条rule上一轮有新事实生成，则True；反之False
+        self._true_count = -1
+
+    def check_status(self,
+                     current_facts: list[FACT_TYPE],
+                     question: Question) -> InferenceStatus:
+        """检查主循环状态"""
+        # 先检查迭代次数
+        if self._current_iteration >= self.max_iterations:
+            return InferenceStatus.MAX_ITERATIONS_REACHED
+
+        if self._true_count == 0:
+            return InferenceStatus.FIXPOINT_REACHED
+
+        if self._current_iteration == 0 and question.question and all(q in current_facts for q in question.question):
+            # FIXME: 这里的判断可能需要分的更细致
+            return InferenceStatus.SUCCESS
+
+        return InferenceStatus.CONTINUE
+
+    def next_iteration(self) -> None:
+        """进入下一轮迭代"""
+        self._current_iteration += 1
+
+    def reset(self) -> None:
+        """重置计数"""
+        self._current_iteration = 0
+
+    def initial_manager(self, normal_rules: Sequence[Rule] | None = None, *, resume: bool = False) -> None:
+        """
+        修改current rules, 为当前一个question的推理做准备
+        :raise ValueError: 如果待推理问题不变，仅中止引擎并重新推理时，认为不需要修改rules（其他各处也应调整）
+        """  # noqa: DOC501
+        if normal_rules is None:
+            if resume:
+                self.normal_rule_activated = dict.fromkeys(self.normal_rule_activated, True)  # 继续推理当前时，使用之前存储好的rule
+                # 但是清空之前的_activated记录（因为可能有新事实变化）
+            else:
+                raise ValueError("normal_rules is None")
+        else:
+            self.normal_rule_activated = dict.fromkeys(normal_rules, True)  # 如果某条rule上一轮有新事实生成，则True；反之False
+        self._true_count = len(self.normal_rule_activated)
+
+    @property
+    def iteration(self) -> int:
+        """获取当前迭代次数"""
+        return self._current_iteration
+
+    def update_normal_rule_activation(self, new_facts: list[FACT_TYPE], used_rule: Rule) -> None:
+        """每条规则完成推理后，使用本函数更新main_manager，用于判断是否所有的规则同时达到了不动点"""
+        activated = bool(new_facts)
+
+        old_value = self.normal_rule_activated.get(used_rule)
+        self.normal_rule_activated[used_rule] = activated
+
+        if old_value and not activated:
+            self._true_count -= 1
+        elif not old_value and activated:
+            self._true_count += 1
+
+    def is_at_fixpoint(self) -> bool:
+        """是否所有 normal rule 都已不再产生新事实（不动点，仅看 normal rules）"""
+        return self._true_count == 0
+
+
+class ExecutorManager:
+    """执行器管理器"""
+
+    def __init__(self, status_checker: StatusChecker, solution_manager: QuerySolutionManager,
+                  max_steps: int = 1000):
+        self.status_checker = status_checker
+        self.max_steps = max_steps
+        self._current_step = 1
+        self.solution_manager = solution_manager
+
+    def check_status(self, new_facts: list[FACT_TYPE], question: Question,
+                     solutions: list[Mapping[Variable, Constant | CompoundTerm]],
+                     question_rule: _QuestionRule | None) -> InferenceStatus:
+        """检查执行器状态"""
+        if self.max_steps != -1 and self._current_step >= self.max_steps:
+            return InferenceStatus.MAX_STEPS_REACHED  # 有解是success，且需要解
+
+        # 检查是否有矛盾
+        if self.status_checker.check_conflict(new_facts):  # TODO: 冲突时同步清理 solutions
+            return InferenceStatus.CONFLICT_DETECTED
+
+        if question_rule is not None and solutions:
+            terminate_sign = self.solution_manager.print_and_collect(question, solutions, question_rule)
+            if terminate_sign:
+                return InferenceStatus.SUCCESS
+
+        return InferenceStatus.CONTINUE
+
+    def next_step(self) -> None:
+        """执行下一步"""
+        self._current_step += 1
+
+    def reset_for_new_inference(self) -> None:
+        """为新的推理过程重置步数计数（仅在开始全新推理时调用）"""
+        self._current_step = 1
+
+    @property
+    def step_num(self) -> int:
+        """获取当前步数"""
+        return self._current_step
+
+
+def create_main_loop_manager(equivalence: Equivalence,
+                             sk_system_handler: SankuManagementSystem,
+                             max_iterations: int = 300) -> MainLoopManager:
+    """创建主循环管理器"""
+    status_checker = StatusChecker(equivalence, sk_system_handler)
+    return MainLoopManager(status_checker, max_iterations)
+
+
+def create_executor_manager(equivalence: Equivalence,
+                            sk_system_handler: SankuManagementSystem,
+                            solution_manager: QuerySolutionManager,
+                            max_steps: int = 1000) -> ExecutorManager:
+    """创建执行器管理器"""
+    status_checker = StatusChecker(equivalence, sk_system_handler)
+    return ExecutorManager(status_checker, solution_manager, max_steps)

kele/egg_equiv.pyi

@@ -0,0 +1,11 @@
+from kele.syntax import TERM_TYPE
+from kele.syntax import Constant, CompoundTerm
+
+class EggEquivalence:
+    def __init__(self, trace: bool) -> None: ...
+    def add_to_equiv(self, lhs: TERM_TYPE, rhs: TERM_TYPE) -> None: ...
+    def query_equivalence(self, term_l: TERM_TYPE, term_r: TERM_TYPE) -> bool: ...
+    def get_represent_elem(self, term: Constant | CompoundTerm) -> Constant | CompoundTerm[Constant | CompoundTerm]: ...
+    def get_equiv_elem(self, term: TERM_TYPE) -> list[TERM_TYPE]: ...
+    def rebuild_egraph(self) -> None: ...
+    def clear(self) -> None: ...

kele/equality/README.md

@@ -0,0 +1,8 @@
+## 实现功能：等价类的查询
+在文件夹equiv_class当中实现了等价类的查询功能：
+1. equiv_class.equivalence.Equivalence类，这个类中一共有两个对外的方法，分别为：
+    1. update_equiv_class：这个方法用于更新等价类，调用时请传入类型为：list[Assertion | Formula]的列表。此方法没有返回值
+
+    2. query_equivalence：这个方法用于查询一系列事实，调用时请传入Assertion或者list[Assertion]。此方法将返回一个列表，列表中为每个Assertion返回一个对应的list[bool]
+    
+2. 在test文件夹中添加了少量单例测试，在每次修改代码后使用pytest测试可以初步确定是否有误

kele/equality/__init__.py

@@ -0,0 +1,4 @@
+"""用于快速判断两个term是否等价的模块"""
+from .equivalence import Equivalence
+
+__all__ = ["Equivalence"]

kele/equality/_egg_equiv/src/lib.rs

@@ -0,0 +1,267 @@
+use std::{collections::HashSet};
+
+use egg::{define_language, EGraph, Id, Symbol};
+use pyo3::{exceptions::*, prelude::*};
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+
+define_language! {
+    pub enum EngineElem {
+        Operator(Symbol),
+        Constant(Symbol),
+        "CompoundTerm" = CompoundTerm(Box<[Id]>),
+        // 要求CompoundTerm的第一个元素是Operator
+    }
+}
+
+
+// 用于储存python object，其中实现了hash和eq，调用的是python的hash和eq
+struct PyObjKey {
+    obj: Py<PyAny>, // 储存的时候使用Py<PyAny>的绑定版本，调用的时候需要unbind
+    py_hash: isize, // 缓存 Python hash
+}
+
+impl PyObjKey {
+    fn new(py: Python<'_>, obj: Py<PyAny>) -> PyResult<Self> {
+        let bound = obj.into_bound(py);
+        let h = bound.hash()?; // 调用 Python __hash__
+        Ok(Self {
+            obj: bound.unbind(), // 拿到可存储的 Py<PyAny>
+            py_hash: h,
+        })
+    }
+}
+
+impl Clone for PyObjKey {
+    fn clone(&self) -> Self {
+        Python::attach(|py| Self {
+            obj: self.obj.clone_ref(py),
+            py_hash: self.py_hash,
+        })
+    }
+}
+
+impl PartialEq for PyObjKey {
+    fn eq(&self, other: &Self) -> bool {
+        Python::attach(|py| {
+            let lhs = self.obj.bind(py);
+            let rhs = other.obj.bind(py);
+            match lhs.eq(&rhs) { // 调用 Python __eq__
+                Ok(b) => b,
+                Err(_) => false,
+            }
+        })
+    }
+}
+impl Eq for PyObjKey {}
+
+impl Hash for PyObjKey {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.py_hash.hash(state); // 使用缓存的 Python hash
+    }
+}
+
+
+#[pyclass]
+pub struct EggEquivalence {
+    egraph: EGraph<EngineElem, ()>,
+
+    /// 1. 每个 e-node (EngineElem) 出现过的所有 SyntaxType 写法
+    node_terms: HashMap<EngineElem, HashSet<PyObjKey>>,
+
+    /// 2. 每个 e-node 的“代表元”：第一次见到它时绑定的 SyntaxType
+    node_rep: HashMap<EngineElem, Py<PyAny>>,
+
+    trace: bool,
+}
+
+impl EggEquivalence {
+    pub fn new(trace: bool) -> Self {
+        let base: EGraph<EngineElem, ()> = EGraph::default();
+
+        // 按照 trace 决定是否启用 explanations
+        let egraph = if trace {
+            base.with_explanations_enabled()
+        } else {
+            base
+        };
+
+        Self {
+            egraph,
+            node_terms: HashMap::new(),
+            node_rep: HashMap::new(),
+            trace: trace,
+        }
+    }
+    /// 把某个 SyntaxType 的写法记到对应的 EngineElem 底下
+    /// 如果engineElem已经存在，那么就加入到对应的hashmap，否则创建新的hashmap并注册engineElem
+    fn record_term(&mut self, elem: &EngineElem, term: Bound<'_, PyAny>) {
+        // 所有写法都收集起来，给 get_equiv_elem 用
+        Python::attach(|py| {
+            self.node_terms
+                .entry(elem.clone())
+                .or_insert_with(HashSet::new)
+                .insert(PyObjKey::new(py, term.clone().unbind()).unwrap());
+        });
+
+        // 代表元：第一次见到这个 EngineElem 时绑定，不再修改。
+        // 之所以有这个问题是因为不同syntaxtype可能对应同一个engineelem，因此需要这样记录
+        self.node_rep
+            .entry(elem.clone())
+            .or_insert_with(|| term.unbind());
+    }
+    fn add_term_to_egraph(&mut self, py: Python<'_>, obj: Bound<'_, PyAny>) -> PyResult<Id> {
+        // 将一个用dict形式表示的term添加到egraph中，并获取它的Id。如果它已经存在，那么直接获取Id
+        let type_name = obj.get_type().name()?;
+
+        if type_name == "Constant"{
+            let symbol_obj = obj.getattr("symbol")?;
+            let value = symbol_obj.str()?.to_str()?.to_owned();
+            let belong_obj = obj.getattr("belong_concepts")?;
+            let belong_concepts = belong_obj.str()?.to_str()?.to_owned();
+            let constant_name = value + "::" + &belong_concepts;  //  TODO: 一些地方有内存优化的余地
+            let engine_elem = EngineElem::Constant(Symbol::from(constant_name.clone()));
+            if let Some(id) = self.egraph.lookup(engine_elem.clone()) {
+                self.record_term(&engine_elem, obj);
+                return Ok(id);
+            }
+            else{
+                self.record_term(&engine_elem, obj);
+                let id = self.egraph.add(engine_elem);
+                return Ok(id)
+            }
+        }
+        if type_name == "Operator"{
+            let name_obj = obj.getattr("name")?;
+            let value = name_obj.str()?.to_str()?.to_owned();
+            let operator_name = value.clone();
+            let engine_elem = EngineElem::Operator(Symbol::from(operator_name.clone()));
+            if let Some(id) = self.egraph.lookup(engine_elem.clone()) {
+                self.record_term(&engine_elem, obj);
+                return Ok(id);
+            }
+            else{
+                self.record_term(&engine_elem, obj);
+                let id = self.egraph.add(engine_elem);
+                return Ok(id)
+            }
+        }
+        if type_name == "CompoundTerm" || type_name == "FlatCompoundTerm"{
+            let operator_obj = obj.getattr("operator").unwrap();
+            let arguments_obj = obj.getattr("arguments").unwrap();
+            let operator_id = self.add_term_to_egraph(py, operator_obj)?;
+            let arguments_len = arguments_obj.len().unwrap();
+            let mut children_ids: Vec<Id> = Vec::new();
+            children_ids.push(operator_id); // CompoundTerm的第一个元素是Operator
+            for argument in 0..arguments_len{
+                let arg_obj = arguments_obj.get_item(argument).unwrap();
+                let arg_id = self.add_term_to_egraph(py, arg_obj)?;
+                children_ids.push(arg_id);
+            }
+            let engine_elem = EngineElem::CompoundTerm(children_ids.into_boxed_slice());
+            if let Some(id) = self.egraph.lookup(engine_elem.clone()) {
+                self.record_term(&engine_elem, obj);
+                return Ok(id);
+            }
+            else{
+                self.record_term(&engine_elem, obj);
+                let id = self.egraph.add(engine_elem);
+                return Ok(id)
+            }
+        }
+        return Err(PyErr::new::<PyTypeError, _>(format!("Unsupported type: {}", type_name)));
+    }
+    fn reset(&mut self) {
+        // 重新创建一个空的 egraph，并判断是否启用explanations
+        let base: EGraph<EngineElem, ()> = EGraph::default();
+
+        // 按照 trace 决定是否启用 explanations
+        self.egraph = if self.trace {
+            base.with_explanations_enabled()
+        } else {
+            base
+        };
+
+        // 清空辅助映射
+        self.node_terms.clear();
+        self.node_rep.clear();
+    }
+}
+
+
+#[pymethods]
+impl EggEquivalence {
+    #[new]
+    fn py_new(trace: bool) -> Self {
+        EggEquivalence::new(trace)
+    }
+    pub fn add_to_equiv(&mut self, py: Python<'_>, lhs: Bound<'_, PyAny>, rhs: Bound<'_, PyAny>){
+        // 将lhs==rhs这个事实添加到egraph中
+        let lhs_id = self.add_term_to_egraph(py, lhs).unwrap();
+        let rhs_id = self.add_term_to_egraph(py, rhs).unwrap();
+
+        // 如果启用了 trace，则使用带标签的 union 以便后续生成解释
+        if self.trace {
+            self.egraph.union_trusted(lhs_id, rhs_id, "input");
+        } else {
+            self.egraph.union(lhs_id, rhs_id);
+        }
+    }
+    pub fn query_equivalence(&mut self, py: Python<'_>, term_l: Bound<'_, PyAny>, term_r: Bound<'_, PyAny>) -> bool {
+        // 查询term_l是否等于term_r
+        let lhs_id = self.add_term_to_egraph(py, term_l).unwrap();
+        let rhs_id = self.add_term_to_egraph(py, term_r).unwrap();
+
+        self.rebuild_egraph(); // 可能发生了add，需要重建
+
+        return self.egraph.find(lhs_id) == self.egraph.find(rhs_id);
+    }
+    pub fn get_represent_id(&mut self, py: Python<'_>, term: Py<PyAny>) -> String {
+        // 获取等价类的Id
+        let term_id = self.add_term_to_egraph(py, term.bind(py).clone()).unwrap(); // 将term加入图中从而获得Id
+        self.rebuild_egraph(); // 可能发生了add，需要重建
+        let class_id = self.egraph.find(term_id);  // 获取e-class的ID
+
+        // 返回 e-class ID 的 index
+        class_id.to_string()  // 返回 e-class ID 作为 usize
+    }
+    pub fn get_represent_elem(&mut self, py: Python<'_>, term: Py<PyAny>) -> Py<PyAny> {
+        // 获取等价类的代表元的ID，注意这是一个元素的Id
+        let term_id = self.add_term_to_egraph(py, term.bind(py).clone()).unwrap(); // 将term加入图中从而获得Id
+        self.rebuild_egraph(); // 可能发生了add，需要重建
+        let class_id = self.egraph.find(term_id);
+        let result_elem = self.egraph.id_to_node(class_id);
+        self.node_rep.get(result_elem).unwrap().clone_ref(py)
+    }
+    pub fn get_equiv_elem(&mut self, py: Python<'_>, term: Py<PyAny>) -> Vec<Py<PyAny>> {   
+        // 获得与一个元素等价的所有元素，返回的是元素的ID列表
+        let term_id = self.add_term_to_egraph(py, term.bind(py).clone()).unwrap(); // 将term加入图中从而获得Id
+        self.rebuild_egraph(); // 可能发生了add，需要重建
+        let class_id = self.egraph.find(term_id); // 获得标准Id
+        let eclass = &self.egraph[class_id];  // 获得对应的eclass
+        let mut elem_list: Vec<Py<PyAny>> = Vec::new();
+        for node in &eclass.nodes {
+            if let Some(set) = self.node_terms.get(node) {
+                for term_key in set {
+                    elem_list.push(term_key.obj.clone_ref(py));
+                }
+            }
+        }
+        elem_list
+    }    
+    pub fn rebuild_egraph(&mut self) {
+        // 重建egraph，这个操作通常在进行查询之前调用，维护graph的同余闭包
+        if !self.egraph.clean {
+            self.egraph.rebuild();
+        }
+    }
+    pub fn clear(&mut self) {
+        self.reset();
+    }
+}
+
+#[pymodule]
+fn egg_equiv(_py: Python, m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_class::<EggEquivalence>()?;
+    Ok(())
+}

kele/equality/_equiv_elem.py

@@ -0,0 +1,67 @@
+from kele.syntax.base_classes import Constant, CompoundTerm, Concept, Operator, TERM_TYPE, Variable
+from functools import singledispatch
+
+
+class EquivElem:
+    """等价类中的一个元素"""
+
+    def __init__(self, content: TERM_TYPE) -> None:
+        self.content = content
+        self._hash = get_hash(self.content)  # 缓存hash值，避免重复计算
+
+    def __hash__(self) -> int:
+        return self._hash
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, EquivElem):
+            return self.content == other.content
+        return False
+
+
+@singledispatch
+def get_hash(content: Constant | CompoundTerm | Concept | Operator | Variable) -> int:
+    """
+    使用singledispatchmethod是为了在后续添加新的类型的时候，能更加便捷地修改
+    """
+    return hash(content)
+
+
+@get_hash.register(Constant)
+def _(content: Constant) -> int:
+    """
+    取得hash值的时候，要考虑到Constant的value, name三个属性
+    value的类型是string，因此直接返回hash值，无需递归
+    """
+    return hash((content.symbol, content.belong_concepts))
+
+
+@get_hash.register(CompoundTerm)
+def _(content: CompoundTerm) -> int:
+    """
+    CompoundTerm的hash值应当考虑到Term的operator和所有的variable
+    """
+    return hash((content.operator, content.arguments))
+
+
+@get_hash.register(Concept)
+def _(content: Concept) -> int:
+    """
+    Concept的hash值应当考虑到Concept的name，name的类型为string，应当直接返回hash值
+    """
+    return hash(content.name)
+
+
+@get_hash.register(Operator)
+def _(content: Operator) -> int:
+    """
+    Operator的hash值暂时只需要考虑name，类型为string。我们暂时不允许name相同但Operator不同的情况
+    """
+    return hash(content.name)
+
+
+@get_hash.register(Variable)
+def _(content: Variable) -> int:
+    """
+    Operator的hash值暂时只需要考虑name，类型为string。我们暂时不允许name相同但Operator不同的情况
+    """
+    return hash(content.symbol)

kele/equality/_utils.py

@@ -0,0 +1,36 @@
+from kele.syntax.base_classes import Assertion
+from ._equiv_elem import EquivElem
+import warnings
+from functools import singledispatch
+
+
+@singledispatch
+def fact_validator(item: Assertion | tuple[EquivElem, EquivElem]) -> bool:
+    """
+    用于验证fact的合法性，分别对Assertion和tuple两种更新方式验证是否包含非法元素
+    有其他的验证条件，也应当在这个函数实现
+
+    :param item: 一个fact，可能是Assertion或者tuple
+    :return: 如果fact合法，返回True；否则，返回False
+    """
+    warnings.warn(f"Should not update facts using {type(item)}.", stacklevel=5)
+    return False
+
+
+@fact_validator.register(Assertion)
+def _(item: Assertion) -> bool:
+    # 实际上这用来判断非法情形：断言中出现True/False这样的非法形式
+    # 这里将在后续解决：实际上Assertion左右放入False/True是非法的，True/False将以Constant/Concept的方式出现，需要单独的判断方法
+    return True
+
+
+@fact_validator.register(tuple)
+def _(item: tuple[EquivElem, EquivElem]) -> bool:
+    length_of_legal_assertion = 2
+    if not isinstance(item, tuple) or len(item) != length_of_legal_assertion:
+        warnings.warn(f"Invalid equivalence relation format: {item}; expected a 2-tuple.", stacklevel=2)
+        return False
+    # 后续还将有一个if
+    # 实际上这用来判断非法情形：断言中出现True/False这样的非法形式
+    # 这里将在后续解决：实际上Assertion左右放入False/True是非法的，True/False将以Constant/Concept的方式出现，需要单独的判断方法
+    return True