"""Create reasoning_engine
Generated by Phi-Octopus Eden
2025-11-06 09:26:30.639497
"""

```python
from typing import List


class ReasoningEngine:
    """
    A simple reasoning engine that solves a specific problem by applying basic logical operations.
    The engine is designed to determine if a given list of integers can be partitioned into two subsets such that the sum of elements in both subsets is equal.

    Args:
        numbers: A list of integers

    Returns:
        True if there exists a subset whose sum equals the total sum of the input list divided by 2, otherwise False
    """

    def __init__(self):
        pass

    def can_partition_equal_subset(self, numbers: List[int]) -> bool:
        """
        Determine if the given list of integers can be partitioned into two subsets with equal sum.

        Args:
            numbers: A list of integers

        Returns:
            True if such a partition exists, otherwise False
        """
        total_sum = sum(numbers)
        # If total sum is odd, it's impossible to divide it into two equal parts
        if total_sum % 2 != 0:
            return False
        target_sum = total_sum // 2

        # Initialize DP table
        dp = [False] * (target_sum + 1)
        dp[0] = True  # Base case: zero sum is always possible with empty subset

        for num in numbers:
            # Update the DP table bottom-up
            for i in range(target_sum, num - 1, -1):
                if not dp[i]:
                    continue
                dp[i] |= dp[i - num]

        return dp[target_sum]


# Example usage
if __name__ == "__main__":
    engine = ReasoningEngine()
    numbers = [1, 5, 11, 5]
    print(f"Can partition {numbers} into two subsets with equal sum: {engine.can_partition_equal_subset(numbers)}")

    numbers = [1, 2, 3, 5]
    print(f"Can partition {numbers} into two subsets with equal sum: {engine.can_partition_equal_subset(numbers)}")
```

This code implements a simple reasoning engine that can determine if a given list of integers can be partitioned into two subsets such that the sum of elements in both subsets is equal. It uses dynamic programming to solve this problem efficiently.