"""Create logic_validator
Generated by Phi-Octopus Eden
2025-11-07 06:01:00.938746
"""

```python
def create_logic_validator(logic: str) -> callable:
    """
    Creates a validator function based on provided logical expression.
    
    Args:
        logic (str): A string representation of a logical condition. 
                     Supported operators: ==, !=, <, >, and, or, not
    
    Returns:
        callable: A function that takes two arguments and returns True if the
                  logic holds, False otherwise.

    Example usage:
    >>> validator = create_logic_validator("x > 10 and y <= 20")
    >>> validator(15, 25)
    False
    >>> validator(15, 18)
    True
    """
    import ast

    class LogicNode(ast.NodeVisitor):
        def visit_Name(self, node: ast.Name) -> str:
            return node.id

        def visit_BinOp(self, node: ast.BinOp) -> bool:
            left = self.visit(node.left)
            right = self.visit(node.right)
            if isinstance(node.op, ast.GtE):
                return left >= right
            elif isinstance(node.op, ast.LtE):
                return left <= right
            elif isinstance(node.op, ast.Eq):
                return left == right
            elif isinstance(node.op, ast.NotEq):
                return left != right
            elif isinstance(node.op, ast.And):
                return self.visit(node.left) and self.visit(node.right)
            elif isinstance(node.op, ast.Or):
                return self.visit(node.left) or self.visit(node.right)
            raise ValueError("Unsupported operator")

        def visit_UnaryOp(self, node: ast.UnaryOp) -> bool:
            operand = self.visit(node.operand)
            if isinstance(node.op, ast.Not):
                return not operand
            raise ValueError("Unsupported operator")

    class LogicExpression(ast.Expression):
        def __init__(self, body: str) -> None:
            super().__init__()
            self.body = body

        @property
        def value(self) -> LogicNode:
            tree = compile(self.body, "<string>", "eval")
            node = LogicNode()
            node.visit(tree)
            return node

    def validator(*args):
        expression = LogicExpression(logic)
        for arg in args:
            if isinstance(arg, tuple):
                args += arg
            else:
                break
        return expression.value(*args)

    return validator


# Example usage
if __name__ == "__main__":
    logic_validator = create_logic_validator("x > 10 and y <= 20")
    print(logic_validator(15, 25))  # False
    print(logic_validator(15, 18))  # True
```