"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-06 02:22:12.041692
"""

```python
from typing import List, Dict


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

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

        :param fact: A string representing a fact.
        """
        if fact not in self.knowledge:
            self.knowledge[fact] = []

    def get_facts(self) -> List[str]:
        """
        Returns all facts present in the knowledge base.

        :return: A list of strings, each representing a fact.
        """
        return list(self.knowledge.keys())

    def add_rule(self, rule: str, premises: List[str]) -> None:
        """
        Adds a rule to the knowledge base with its premises.

        :param rule: The conclusion of the rule as a string.
        :param premises: A list of strings representing the premises of the rule.
        """
        for premise in premises:
            if premise not in self.knowledge:
                self.knowledge[premise] = []
            self.knowledge[premise].append(rule)

    def infer(self, fact: str) -> List[str]:
        """
        Infers new facts based on existing rules and knowledge.

        :param fact: A string representing a fact to be used as input for inference.
        :return: A list of strings representing inferred conclusions.
        """
        if fact not in self.knowledge:
            return []

        inferred_facts = set()
        queue = [fact]

        while queue:
            current_fact = queue.pop(0)
            if current_fact in self.knowledge and self.knowledge[current_fact]:
                for rule in self.knowledge[current_fact]:
                    inferred_facts.add(rule)
                    queue.append(rule)

        return list(inferred_facts)


def reasoning_engine(kb: KnowledgeBase) -> List[str]:
    """
    A simple reasoning engine that infers new facts from a given knowledge base.

    :param kb: An instance of the KnowledgeBase class.
    :return: A list of strings representing inferred conclusions.
    """
    initial_facts = kb.get_facts()
    if not initial_facts:
        return []

    # Example usage
    print("Initial Facts:")
    for fact in initial_facts:
        print(f"- {fact}")

    inference_results = kb.infer(initial_facts[0])
    print("\nInferred Conclusions:")
    for conclusion in inference_results:
        print(f"- {conclusion}")
    
    return inference_results


# Example usage
if __name__ == "__main__":
    knowledge_base = KnowledgeBase()
    knowledge_base.add_fact("All humans are mortal.")
    knowledge_base.add_fact("Socrates is a human.")
    knowledge_base.add_rule("Socrates is mortal.", ["All humans are mortal.", "Socrates is a human."])
    
    inferred_conclusions = reasoning_engine(knowledge_base)
    print("\nInferred Conclusions from Engine:")
    for conclusion in inferred_conclusions:
        print(f"- {conclusion}")
```

This code defines a simple `KnowledgeBase` class to manage facts and rules, along with an inference mechanism. The `reasoning_engine` function uses this knowledge base to perform basic reasoning tasks.