"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-06 18:32:06.031873
"""

```python
from typing import List, Dict


class KnowledgeBase:
    def __init__(self):
        self.facts = []
    
    def add_fact(self, fact: str) -> None:
        """Add a new fact to the knowledge base."""
        self.facts.append(fact)
    
    def retrieve_facts(self, query: str) -> List[str]:
        """Retrieve facts that match the given query."""
        return [fact for fact in self.facts if query.lower() in fact.lower()]


class RuleBase:
    def __init__(self):
        self.rules = []
    
    def add_rule(self, rule: Dict[str, str]) -> None:
        """Add a new inference rule to the rule base."""
        self.rules.append(rule)
    
    def apply_rules(self, facts: List[str]) -> List[str]:
        """
        Apply rules to the given facts and generate new conclusions.
        
        Args:
            facts (List[str]): Facts available for reasoning.

        Returns:
            List[str]: New facts or conclusions derived from applying the rules.
        """
        new_facts = []
        for fact in facts:
            for rule in self.rules:
                if all(key in fact for key in rule.keys()):
                    conclusion = ""
                    for k, v in rule.items():
                        conclusion += str(fact.replace(k, v))
                    new_facts.append(conclusion)
        return list(set(new_facts))  # Remove duplicates


class ReasoningEngine:
    def __init__(self):
        self.knowledge_base = KnowledgeBase()
        self.rule_base = RuleBase()
    
    def add_fact(self, fact: str) -> None:
        """Add a new fact to the knowledge base."""
        self.knowledge_base.add_fact(fact)
    
    def add_rule(self, rule: Dict[str, str]) -> None:
        """Add a new inference rule to the rule base."""
        self.rule_base.add_rule(rule)
    
    def reason(self) -> List[str]:
        """
        Reason from available knowledge and rules.
        
        Returns:
            List[str]: New facts or conclusions derived by applying the rules.
        """
        return self.rule_base.apply_rules(self.knowledge_base.retrieve_facts(""))

# Example usage
engine = ReasoningEngine()
engine.add_fact("All men are mortal.")
engine.add_fact("Socrates is a man.")
engine.add_rule({"men": "mortal", "Socrates": "man"})
new_conclusions = engine.reason()
print(new_conclusions)  # Should print ["Socrates is mortal."]
```