LTL-Scene-Graph-Price-Validator

The problem

It is difficult to ensure that a series of multi-step transactions follow specific business rules and stay consistent over time. Current systems often struggle to verify that every step in a sequence remains valid and logically sound.

What it does

It checks a sequence of transaction records against a set of predefined rules to ensure they follow the correct flow. It looks at each step of a process to make sure the data remains valid and consistent throughout.

Why it matters

It provides a consistent way to verify that complex sequences of actions follow the correct rules from start to finish.

Validation

It was run in the sandbox and it failed. run output shows an error/traceback — the artifact does NOT run clean.

$ python3 LTL-Scene-Graph-Price-Validator.py
Traceback (most recent call last):
  File "/work/LTL-Scene-Graph-Price-Validator.py", line 81, in <module>
    valid, error = validate_sequence(transactions, ltl_constraints)
                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/work/LTL-Scene-Graph-Price-Validator.py", line 60, in validate_sequence
    if not any(evaluate_condition(tx, cond) for tx in transactions):
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/work/LTL-Scene-Graph-Price-Validator.py", line 60, in <genexpr>
    if not any(evaluate_condition(tx, cond) for tx in transactions):
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/work/LTL-Scene-Graph-Price-Validator.py", line 35, in evaluate_condition
    return eval(re.sub(pattern, lambda m: f'tx["{m.group(0)}"]', condition), {'tx': tx})
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "<string>", line 1, in <module>
NameError: name 'tatus' is not defined

No screenshot — there is nothing working to show. This is recorded as an unfinished sketch so the attempt stays visible instead of being quietly dropped.

The code

All of it — 82 lines, one file, standard library only.

# LTL-Scene-Graph-Price-Validator.py
import json
import re
from typing import List, Dict, Any

def validate_transaction(tx: Dict, schema: Dict) -> (bool, str):
    """ Schema validation for individual transactions """
    for field in schema['required_fields']:
        if field not in tx:
            return False, f'Missing required field: {field}'
    for field, typ in schema['types'].items():
        if field in tx and not isinstance(tx[field], typ):
            return False, f'Field {field} is of incorrect type. Expected {typ}, got {type(tx[field])}'
    return True, ''

def parse_ltl_constraint(constraint: str) -> (str, str):
    """ Parse LTL constraint syntax """
    if constraint.startswith('Eventually, '):
        return 'eventually', constraint[13:]
    elif constraint.startswith('Always, '):
        return 'always', constraint[8:]
    elif constraint.startswith('Next, '):
        return 'next', constraint[7:]
    else:
        raise ValueError(f'Unsupported LTL constraint: {constraint}')

def evaluate_condition(tx: Dict, condition: str) -> bool:
    """ Evaluate condition on transaction using regex substitution """
    pattern = r'\b(status|amount|id)\b'
    return eval(re.sub(pattern, lambda m: f'tx["{m.group(0)}"]', condition), {'tx': tx})

def validate_sequence(transactions: List[Dict], ltl_constraints: List[str]) -> (bool, str):
    """ Main validation function combining schema and LTL checks """
    schema = {
        'required_fields': ['id', 'amount', 'status'],
        'types': {
            'id': str,
            'amount': (int, float),
            'status': str
        }
    }

    # Schema validation
    for tx in transactions:
        valid, error = validate_transaction(tx, schema)
        if not valid:
            return False, error

    # LTL constraint checking
    for constraint in ltl_constraints:
        op, cond = parse_ltl_constraint(constraint)
        if op == 'eventually':
            if not any(evaluate_condition(tx, cond) for tx in transactions):
                return False, f'Eventually constraint not met: {constraint}'
        elif op == 'always':
            if not all(evaluate_condition(tx, cond) for tx in transactions):
                return False, f'Always constraint not met: {constraint}'
        elif op == 'next':
            for i in range(len(transactions) - 1):
                next_tx = transactions[i + 1]
                if not evaluate_condition(next_tx, cond):
                    return False, f'Next constraint not met between tx {i} and {i+1}: {constraint}'

    return True, ''

if __name__ == '__main__':
    # Example usage with state-path validation
    transactions = [
        {'id': '1', 'amount': 100.0, 'status': 'pending'},
        {'id': '2', 'amount': 200.0, 'status': 'approved'},
        {'id': '3', 'amount': -50.0, 'status': 'failed'}
    ]
    ltl_constraints = [
        'Eventually, status == "approved"',
        'Always, amount > 0',
        'Next, status != "failed"'
    ]
    valid, error = validate_sequence(transactions, ltl_constraints)
    if valid:
        print('Validation passed: All constraints satisfied.')
    else:
        print(f'Validation failed: {error}')