"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-07 18:21:28.042773
"""

```python
from typing import List, Dict


class ReasoningEngine:
    """
    A simple reasoning engine that evaluates a set of rules against given facts to infer new conclusions.
    """

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

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

        :param rule: The rule in the format "if condition then conclusion"
        """
        self.rules.append(rule)

    def infer_conclusions(self, facts: List[str]) -> Dict[str, bool]:
        """
        Infers conclusions based on the given facts and existing rules.

        :param facts: A list of known facts.
        :return: A dictionary mapping each possible conclusion to a boolean indicating its validity.
        """
        conclusions = {conclusion: False for rule in self.rules for _, conclusion in
                       [self._parse_rule(rule)]}
        for fact in facts:
            if not self._validate_fact(fact):
                continue
            for rule in self.rules:
                condition, conclusion = self._parse_rule(rule)
                if all([fact == cond for cond in condition.split()]):
                    conclusions[conclusion] = True

        return {k: v for k, v in conclusions.items() if v}

    def _parse_rule(self, rule: str) -> (str, str):
        """
        Parses a given inference rule.

        :param rule: The rule to parse.
        :return: A tuple containing the condition and conclusion parts of the rule.
        """
        parts = rule.split("then")
        if len(parts) != 2:
            raise ValueError(f"Invalid rule format: {rule}")
        return " ".join(parts[0].split()[1:]), parts[1].strip()

    def _validate_fact(self, fact: str) -> bool:
        """
        Validates the format of a given fact.

        :param fact: The fact to validate.
        :return: True if valid, otherwise False.
        """
        return all([cond.isalpha() for cond in fact.split()])


# Example usage
if __name__ == "__main__":
    engine = ReasoningEngine()
    engine.add_rule("if A B then C")
    engine.add_rule("if D E then F")

    facts = ["A", "B", "D"]
    conclusions = engine.infer_conclusions(facts)

    print(conclusions)
```

This code provides a basic reasoning engine capable of inferring new conclusions based on provided facts and rules. The `ReasoningEngine` class adds, parses, and evaluates these rules to determine the validity of potential conclusions.