"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-07 18:47:02.334184
"""

```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 fact.
        """
        if fact not in self.knowledge:
            self.knowledge[fact] = {'supports': [], 'supported_by': []}

    def add_support(self, supporting_fact: str, supported_fact: str) -> None:
        """
        Adds a support relationship between two facts.

        :param supporting_fact: The fact that supports another.
        :param supported_fact: The fact being supported by the other.
        """
        if supporting_fact in self.knowledge and supported_fact in self.knowledge:
            if supported_fact not in self.knowledge[supporting_fact]['supports']:
                self.knowledge[supporting_fact]['supports'].append(supported_fact)
            if supporting_fact not in self.knowledge[supported_fact]['supported_by']:
                self.knowledge[supported_fact]['supported_by'].append(supporting_fact)


def reasoning_engine(kb: KnowledgeBase) -> Dict[str, List[str]]:
    """
    Constructs a reasoning engine that infers new facts from the existing knowledge base.

    :param kb: A KnowledgeBase instance containing facts and their support relationships.
    :return: A dictionary of inferred facts where keys are supported facts and values are lists of supporting facts.
    """
    inferred_facts = {}

    for fact in kb.knowledge:
        if len(kb.knowledge[fact]['supports']) == 0 and fact not in inferred_facts.values():
            supports = set()
            stack = [fact]
            while stack:
                current_fact = stack.pop()
                if current_fact not in inferred_facts.keys() and current_fact not in supports:
                    inferred_facts[current_fact] = []
                    for supporting_fact in kb.knowledge[current_fact]['supports']:
                        inferred_facts[current_fact].append(supporting_fact)
                        if supporting_fact not in supports:
                            stack.append(supporting_fact)
                    supports.add(current_fact)
            if len(inferred_facts[fact]) > 0:
                print(f"Infer: {fact} -> {[s for s in inferred_facts[fact] if s != fact]}")

    return inferred_facts


# Example usage
kb = KnowledgeBase()
kb.add_fact("all_crows_are_birds")
kb.add_fact("some_birds_can_fly")
kb.add_support("all_crows_are_birds", "some_birds_can_fly")

inferred = reasoning_engine(kb)
print(inferred)
```

This example demonstrates a simple knowledge base and a basic reasoning engine that infers new facts based on existing ones.