"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-08 15:41:31.020149
"""

```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 a factual statement.
        """
        if fact not in self.knowledge:
            self.knowledge[fact] = True

    def query(self, question: str) -> bool:
        """
        Queries the knowledge base for a specific piece of information.

        :param question: A string representing a yes/no question.
        :return: Boolean indicating whether the question is answered affirmatively in the KB.
        """
        return question in self.knowledge


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 an if-then statement.
        """
        self.rules.append(rule)

    def infer(self, fact: str) -> bool:
        """
        Infers new facts from existing rules and a given fact.

        :param fact: A string representing a known factual statement.
        :return: Boolean indicating whether the inferred result is True based on the rule base.
        """
        for rule in self.rules:
            if fact in rule and "if" in rule:
                return True
        return False


class ReasoningEngine:
    def __init__(self):
        self.knowledge_base = KnowledgeBase()
        self.rule_base = RuleBase()

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

        :param fact: A string representing a factual statement.
        """
        self.knowledge_base.add_fact(fact)

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

        :param rule: A string representing an if-then statement.
        """
        self.rule_base.add_rule(rule)

    def infer_new_facts(self) -> List[str]:
        """
        Infers new facts from existing knowledge and rules.

        :return: A list of inferred factual statements.
        """
        new_facts = []
        for fact in self.knowledge_base.knowledge:
            if self.rule_base.infer(fact):
                new_facts.append(fact)
        return new_facts

    def query(self, question: str) -> bool:
        """
        Queries the combined knowledge and rule bases.

        :param question: A string representing a yes/no question.
        :return: Boolean indicating whether the question is answered affirmatively in the combined KB & RB.
        """
        return self.knowledge_base.query(question)


# Example usage
reasoning_engine = ReasoningEngine()
reasoning_engine.add_knowledge("The sky is blue")
reasoning_engine.add_rule("if The sun is up then it's daytime")

print(reasoning_engine.infer_new_facts())  # Should print []
print(reasoning_engine.query("The sky is blue"))  # Should return True
```