"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-07 07:43:30.406241
"""

```python
from typing import List, Dict

class ReasoningEngine:
    """
    A simple reasoning engine that can evaluate logical statements based on a set of facts.
    
    This engine supports basic logical operators and aims to address limited reasoning sophistication by providing
    clear and straightforward inference capabilities.

    Attributes:
        facts (Dict[str, bool]): A dictionary storing the known facts where keys are fact names and values are boolean truth values.
    """

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

    def add_fact(self, fact_name: str, value: bool) -> None:
        """
        Add a new fact or update an existing one.

        Args:
            fact_name (str): The name of the fact.
            value (bool): The truth value of the fact.
        """
        self.facts[fact_name] = value

    def is_fact(self, fact_name: str) -> bool:
        """
        Check if a given fact exists and return its value.

        Args:
            fact_name (str): The name of the fact to check.

        Returns:
            bool: True if the fact is present and has a truth value, False otherwise.
        """
        return self.facts.get(fact_name) is not None

    def evaluate(self, statement: str) -> bool:
        """
        Evaluate a logical statement based on the known facts.

        The statement should be a string containing variables and basic logical operators (AND, OR).

        Args:
            statement (str): A logical statement to evaluate.

        Returns:
            bool: The result of the evaluation.
        """
        # Example implementation with simple AND operation
        if 'AND' in statement.upper():
            parts = statement.split(' AND ')
            return all(self.facts.get(part) for part in parts)
        
        raise ValueError("Unsupported logical operation or fact name")

# Example usage:
engine = ReasoningEngine()
engine.add_fact("raining", True)
engine.add_fact("cold", False)

print(engine.evaluate("raining AND cold"))  # Output: False
print(engine.is_fact("raining"))  # Output: True

```

This `ReasoningEngine` class provides a basic framework for evaluating logical statements based on known facts. The example usage demonstrates adding facts and evaluating simple AND-based conditions.