The gap between a fresh screenshot and a safe tap notebook

Python starts when you choose Run.

The gap between a fresh screenshot and a safe tap

Re-observation narrows the stale-state window. Only an executor-enforced revision check closes it in this timing model.

Scripted temporal-grounding simulator; atomic revision checks are assumed tool contracts, not Android capabilities tested here.

"""The gap between a fresh screenshot and a safe tap
Deterministic, standard-library experiment. RESULTS contains the full data.
"""
from random import Random
rng = Random(36)
swaps = [rng.choice((25, 75, 125, 275, 525)) for _ in range(20)]

def observe(now, swap):
    revision = int(now >= swap)
    return {'target_slot': revision, 'revision': revision}

def evaluate(policy, delay):
    counts = dict(correct=0, wrong=0, canceled=0)
    for swap in swaps:
        observed_at = 0 if policy == 'stale' else delay
        observation = observe(observed_at, swap)
        current = observe(delay + 30, swap)
        if policy == 'guarded' and observation['revision'] != current['revision']:
            counts['canceled'] += 1
            continue
        slot = observation['target_slot']
        key = 'correct' if slot == current['target_slot'] else 'wrong'
        counts[key] += 1
    assert sum(counts.values()) == 20
    return counts

print('swap_times_ms', swaps)
for delay in (0, 100, 250, 500):
    for policy in ('stale', 'refreshed', 'guarded'):
        result = evaluate(policy, delay)
        print('delay_ms', delay, policy, result)
        if policy == 'guarded':
            assert result['wrong'] == 0

rows=[]
for delay in (0,100,250,500):
    for policy in ('stale','refreshed','guarded'):
        for index,swap in enumerate(swaps):
            observation=observe(0 if policy=='stale' else delay,swap); current=observe(delay+30,swap)
            outcome='canceled' if policy=='guarded' and observation['revision']!=current['revision'] else ('correct' if observation['target_slot']==current['target_slot'] else 'wrong')
            rows.append(dict(case=index,swap_ms=swap,delay_ms=delay,policy=policy,observed_ms=0 if policy=='stale' else delay,commit_ms=delay+30,outcome=outcome))
RESULTS=dict(swaps_ms=swaps,cases=rows,totals=[dict(delay_ms=d,policy=p,**evaluate(p,d)) for d in (0,100,250,500) for p in ('stale','refreshed','guarded')])
assert len(rows)==240
print('Matched schedule audit:',len(rows),'records')

swap_times_ms [125, 25, 25, 125, 25, 25, 525, 75, 75, 125, 275, 125, 525, 125, 525, 25, 525, 275, 275, 275]
delay_ms 0 stale {'correct': 15, 'wrong': 5, 'canceled': 0}
delay_ms 0 refreshed {'correct': 15, 'wrong': 5, 'canceled': 0}
delay_ms 0 guarded {'correct': 15, 'wrong': 0, 'canceled': 5}
delay_ms 100 stale {'correct': 8, 'wrong': 12, 'canceled': 0}
delay_ms 100 refreshed {'correct': 15, 'wrong': 5, 'canceled': 0}
delay_ms 100 guarded {'correct': 15, 'wrong': 0, 'canceled': 5}
delay_ms 250 stale {'correct': 4, 'wrong': 16, 'canceled': 0}
delay_ms 250 refreshed {'correct': 16, 'wrong': 4, 'canceled': 0}
delay_ms 250 guarded {'correct': 16, 'wrong': 0, 'canceled': 4}
delay_ms 500 stale {'correct': 0, 'wrong': 20, 'canceled': 0}
delay_ms 500 refreshed {'correct': 16, 'wrong': 4, 'canceled': 0}
delay_ms 500 guarded {'correct': 16, 'wrong': 0, 'canceled': 4}
Matched schedule audit: 240 records

Python runs locally in this page. Saved results and figures are visible before execution.

Download full experiment notebook