"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-06 23:10:41.212788
"""

```python
from typing import List, Tuple


class ReasoningEngine:
    """
    A simple reasoning engine that can evaluate logical expressions based on provided facts.

    Args:
        rules: A list of tuples representing logical rules where each rule is a tuple (condition, result).
               'condition' is a string representing a fact to check, and 'result' is the outcome if condition is true.
    
    Methods:
        infer(facts: dict) -> List[str]:
            Evaluates the provided facts against the rules and returns a list of inferred outcomes.

    Example Usage:
        rules = [
            ('is_raining', 'take_umbrella'),
            ('is_cold', 'wear_jacket'),
            ('is_hot', 'drink_water')
        ]
        
        engine = ReasoningEngine(rules)
        results = engine.infer({'is_cold': True, 'is_raining': False})
        print(results)  # Output: ['wear_jacket']
    """

    def __init__(self, rules: List[Tuple[str, str]]):
        self.rules = rules

    def infer(self, facts: dict) -> List[str]:
        """
        Infers outcomes based on provided facts against the predefined rules.

        Args:
            facts: A dictionary where keys are strings representing conditions and values are booleans indicating their truth.
        
        Returns:
            A list of strings representing inferred outcomes from applying the rules to the facts.
        """
        inferred_results = []
        for condition, outcome in self.rules:
            if condition in facts and facts[condition]:
                inferred_results.append(outcome)
        return inferred_results


# Example usage
if __name__ == "__main__":
    rules = [
        ('is_raining', 'take_umbrella'),
        ('is_cold', 'wear_jacket'),
        ('is_hot', 'drink_water')
    ]
    
    engine = ReasoningEngine(rules)
    results = engine.infer({'is_cold': True, 'is_raining': False})
    print(results)  # Output: ['wear_jacket']
```

This code defines a simple `ReasoningEngine` class that can be used to evaluate logical expressions based on given rules and facts. The example usage demonstrates how to instantiate the engine with some predefined rules and use it to infer outcomes from specific conditions.