"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-07 13:57:33.191253
"""

```python
from typing import Dict, List

class ReasoningEngine:
    """
    A simple reasoning engine designed to solve limited reasoning sophistication problems.
    This implementation focuses on a basic rule-based system for decision-making.
    """

    def __init__(self):
        self.rules = {}

    def add_rule(self, condition: str, action: str) -> None:
        """
        Adds a new rule to the reasoning engine.

        :param condition: A string representing the conditions under which an action should be taken
        :param action: A string describing what action should be performed if the condition is met
        """
        self.rules[condition] = action

    def evaluate(self, facts: Dict[str, bool]) -> List[str]:
        """
        Evaluates a set of facts against the rules and returns a list of actions to be taken.

        :param facts: A dictionary of fact names (strings) and their boolean values
        :return: A list of strings representing the actions that should be performed based on the given facts
        """
        actions_to_perform = []
        for condition, action in self.rules.items():
            # Evaluate each rule's condition against the provided facts
            if all(fact_name in facts and fact_value == eval(condition.replace('fact_', ''), {'fact_': facts})
                   for fact_name, fact_value in facts.items()):
                actions_to_perform.append(action)
        return actions_to_perform

# Example Usage:
reasoning_engine = ReasoningEngine()
reasoning_engine.add_rule("fact_a or not fact_b", "act_1")
reasoning_engine.add_rule("(not fact_c and fact_d) -> act_2", "act_2")

facts = {"fact_a": True, "fact_b": False, "fact_c": False, "fact_d": True}
actions = reasoning_engine.evaluate(facts)
print(actions)  # Expected output: ['act_1', 'act_2']
```

This code defines a simple `ReasoningEngine` class with methods to add rules and evaluate them against a set of facts. It demonstrates how such an engine can be used in a basic decision-making scenario.