"""Create logic_validator
Generated by Phi-Octopus Eden
2025-11-07 16:10:04.762004
"""

```python
def create_logic_validator(logic_str: str) -> callable:
    """
    Create a logic validator function from a string representation of logical conditions.

    Args:
        logic_str (str): A string representing a logical condition using 'and', 'or', and comparison operators.
                         Example: "x > 10 and y < 20"

    Returns:
        callable: A function that takes keyword arguments and returns True if the logic is satisfied, False otherwise.

    Raises:
        ValueError: If the input string is not a valid logical condition or contains unsupported operations.
    """
    import ast
    from functools import reduce

    class ConditionBuilder(ast.NodeVisitor):
        def __init__(self):
            self.condition = None

        def visit_BoolOp(self, node):
            op = {ast.And: 'and', ast.Or: 'or'}[type(node.op)]
            values = [self.visit(value) for value in node.values]
            if len(values) == 1:
                self.condition = f"{values[0]} {op}"
            else:
                self.condition = f"({reduce(lambda x, y: f'({x} {op} {y})', values)})"

        def visit_Name(self, node):
            return node.id

        def visit_UnaryOp(self, node):
            if type(node.op) == ast.Not:
                operand = self.visit(node.operand)
                self.condition = f"not {operand}"
                return f"not_{operand}"

        def visit_Compare(self, node):
            left = self.visit(node.left)
            ops = {ast.Gt: '>', ast.Lt: '<', ast.Eq: '==', ast.NotEq: '!=', 
                   ast.GtE: '>=', ast.LtE: '<='}
            comparators = [self.visit(comparator) for comparator in node.comparators]
            self.condition = f"{left} {ops[type(node.ops[0])]} {comparators[0]}"
            return left + " " + ops[type(node.ops[0])] + " " + comparators[0]

        def visit_BinOp(self, node):
            left = self.visit(node.left)
            op = {ast.Add: '+', ast.Sub: '-', ast.Mult: '*', 
                  ast.Div: '/', ast.Mod: '%'}[type(node.op)]
            right = self.visit(node.right)
            self.condition = f"({left} {op} {right})"
            return f"({left} {op} {right})"

    def logic_validator(**kwargs):
        try:
            tree = ast.parse(logic_str, mode='eval')
            cb = ConditionBuilder()
            cb.visit(tree.body)
            condition = cb.condition
            # Replace special placeholders with actual values from kwargs
            for var in set(condition.split()):
                if var.startswith('not_'):
                    not_var = var[4:]
                    condition = condition.replace(var, f"not kwargs.get('{not_var}')")
                else:
                    condition = condition.replace(var, f"kwargs.get('{var}')")

            return eval(f"f'{condition}'", {}, kwargs)
        except (SyntaxError, ValueError):
            raise ValueError("Invalid logic condition provided.")

    return logic_validator

# Example usage
validator = create_logic_validator("x > 10 and y < 20")
print(validator(x=15, y=18))  # True
print(validator(x=5, y=25))   # False
```