"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-06 07:49:25.239774
"""

```python
from typing import List, Dict


class KnowledgeBase:
    def __init__(self):
        self.knowledge = {}

    def add_fact(self, fact: str) -> None:
        """
        Adds a new fact to the knowledge base.

        :param fact: A string representing the new fact.
        """
        if isinstance(fact, str):
            self.knowledge[fact] = False

    def update_fact(self, fact: str, value: bool) -> None:
        """
        Updates the truth value of a fact in the knowledge base.

        :param fact: A string representing the fact to be updated.
        :param value: A boolean representing the new truth value of the fact.
        """
        if fact in self.knowledge:
            self.knowledge[fact] = value


class RuleBase:
    def __init__(self):
        self.rules = []

    def add_rule(self, rule: str) -> None:
        """
        Adds a new rule to the rule base.

        :param rule: A string representing the new rule.
        """
        if isinstance(rule, str):
            self.rules.append(rule)


class ReasoningEngine:
    """
    A simple reasoning engine that can evaluate rules based on facts in a knowledge base.
    """

    def __init__(self, knowledge_base: KnowledgeBase = None, rule_base: RuleBase = None):
        if knowledge_base is None:
            self.knowledge_base = KnowledgeBase()
        else:
            self.knowledge_base = knowledge_base
        if rule_base is None:
            self.rule_base = RuleBase()
        else:
            self.rule_base = rule_base

    def evaluate_rule(self, rule: str) -> bool:
        """
        Evaluates a given rule based on the current facts in the knowledge base.

        :param rule: A string representing the rule to be evaluated.
        :return: A boolean indicating whether the rule is true or false.
        """
        from re import findall
        variables = findall(r'\b\w+\b', rule)
        for variable in variables:
            fact_value = self.knowledge_base.knowledge.get(variable, False)
            if not fact_value:
                return False
        return True

    def update_knowledge(self) -> None:
        """
        Updates the knowledge base based on current rules.
        """
        for rule in self.rule_base.rules:
            if self.evaluate_rule(rule):
                variable = findall(r'\b\w+\b', rule)[0]
                self.knowledge_base.update_fact(variable, True)

    def add_knowledge_and_rules(self, facts: List[str], rules: List[str]) -> None:
        """
        Adds multiple facts and rules to the reasoning engine.

        :param facts: A list of strings representing new facts.
        :param rules: A list of strings representing new rules.
        """
        for fact in facts:
            self.knowledge_base.add_fact(fact)
        for rule in rules:
            self.rule_base.add_rule(rule)


# Example usage
if __name__ == "__main__":
    engine = ReasoningEngine()
    
    # Adding facts to the knowledge base
    engine.knowledge_base.add_fact('it_is_raining')
    engine.knowledge_base.add_fact('umbrella_is_at_home')
    
    # Adding rules to the rule base
    engine.rule_base.add_rule('if it_is_raining then take_umbrella')
    engine.rule_base.add_rule('if umbrella_is_at_home and not raining then go_without_umbrella')
    
    # Evaluating a rule based on current knowledge
    print(engine.evaluate_rule('if it_is_raining then take_umbrella'))  # Expected: True
    
    # Updating the knowledge base with new information based on rules
    engine.update_knowledge()
    print(engine.knowledge_base.knowledge)  # Should show that 'take_umbrella' is now true

    # Adding more facts and evaluating again
    engine.add_knowledge_and_rules(['raining_stopped'], ['if not raining then go_without_umbrella'])
    print(engine.evaluate_rule('if not raining then go_without_umbrella'))  # Expected: True
```