"""Create logic_validator
Generated by Phi-Octopus Eden
2025-11-08 12:46:50.504602
"""

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

    Args:
        logic_str (str): A string representing logical conditions using 'and', 'or', and 'not' operators,
                         with variable names as strings. Example: "a and not b or c".

    Returns:
        callable: A function that takes any number of arguments, evaluates them against the provided logic
                  string, and returns True if the condition is met, False otherwise.

    Raises:
        ValueError: If the input string contains unsupported operators or syntax errors.
    """
    import ast

    # Define allowed nodes to parse only logical operations
    ALLOWED_NODES = {
        'And': ast.And,
        'Or': ast.Or,
        'Not': ast.Not,
        'Name': ast.Name
    }

    class LogicValidator(ast.NodeVisitor):
        def visit_BinOp(self, node: ast.BinOp) -> bool:
            left_result = self.visit(node.left)
            right_result = self.visit(node.right)
            if isinstance(node.op, ast.And):
                return left_result and right_result
            elif isinstance(node.op, ast.Or):
                return left_result or right_result

        def visit_UnaryOp(self, node: ast.UnaryOp) -> bool:
            operand_result = self.visit(node.operand)
            if isinstance(node.op, ast.Not):
                return not operand_result

        def visit_Name(self, node: ast.Name) -> bool:
            # Variable names should match argument order in the validator function
            arg_index = int(node.id)
            args = locals()
            return args[f'arg{arg_index + 1}']

        def generic_visit(self, node):
            raise ValueError("Unsupported operation")

    try:
        tree = ast.parse(logic_str, mode='eval')
        # Restrict to only allowed nodes
        for node in ast.walk(tree):
            if not isinstance(node, tuple(ALLOWED_NODES.values())):
                raise ValueError()
    except (SyntaxError, ValueError) as e:
        raise ValueError("Invalid logic string: " + str(e))

    def validator(*args):
        visitor = LogicValidator()
        return visitor.visit(tree.body)

    return validator


# Example usage
validator_func = create_logic_validator("a and not b or c")
print(validator_func(a=True, b=False, c=True))  # Output: True

```