Digital Drosophila Archive
414 lines
27 KiB
Python
414 lines
27 KiB
Python
"""Read-only CPU comparisons for the UNREGISTERED AN engineering gate.
|
|
|
|
load_run(path, allow_legacy_am=False) reads actual AJ/AM/AN artifact schemas.
|
|
Call close_run(record) after using explicitly loaded memory-mapped traces.
|
|
compare_fresh(left, right, legacy_am=None) and compare_segments(monolithic,
|
|
segments) accept loaded dictionaries or paths and return JSON-safe reports.
|
|
No report is written, no GPU is imported, no training/biological PASS is claimed.
|
|
The caller owns external source/input/root SHA pins and case selection. These
|
|
comparisons do not replace seal verification or prove unseen inputs unchanged.
|
|
|
|
AM did not save its raw spike ring: its fresh terminal ring is explicitly
|
|
reconstructed from sparse events, never described as independently recorded.
|
|
Reference queue joint hashes include LOCAL tick headers; cross-segment checks
|
|
compare the separate ordered-edge/accepted-mask hashes and counts instead.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import csv
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import re
|
|
|
|
import numpy as np
|
|
|
|
|
|
STATE_KEYS = ('step', 'neuron_idx', 'counts', 'v', 'g', 'ref')
|
|
REQUEST_FIELDS = ('tick', 'neuron_idx', 'attempted', 'accepted', 'rejected')
|
|
TRACE_FILES = {'drive': 'apl-drive.float32.npy', 'state': 'apl-state.float32.npy',
|
|
'generated': 'apl-inhibition.float32.npy', 'applied': 'apl-applied.float32.npy'}
|
|
HASH_FIELDS = ('v_sha256', 'g_sha256', 'ref_sha256')
|
|
QUEUE_FIELDS = ('count', 'accepted_count', 'ordered_edge_sha256', 'accepted_mask_sha256')
|
|
|
|
|
|
def require(ok, message):
|
|
if not ok:
|
|
raise ValueError(message)
|
|
|
|
|
|
def bit_equal(a, b):
|
|
return (isinstance(a, np.ndarray) and isinstance(b, np.ndarray) and a.dtype == b.dtype and a.shape == b.shape and
|
|
np.array_equal(np.ascontiguousarray(a).view(np.uint8), np.ascontiguousarray(b).view(np.uint8)))
|
|
|
|
|
|
def _sha(value):
|
|
return isinstance(value, str) and re.fullmatch('[0-9a-f]{64}', value) is not None
|
|
|
|
|
|
def _json(path):
|
|
def pairs(values):
|
|
result = {}
|
|
for key, value in values:
|
|
require(key not in result, 'Duplicate JSON key: ' + key)
|
|
result[key] = value
|
|
return result
|
|
return json.loads(Path(path).read_text(encoding='utf-8'), object_pairs_hook=pairs,
|
|
parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Nonfinite JSON: ' + value)))
|
|
|
|
|
|
def _jsonl(path):
|
|
with Path(path).open(encoding='utf-8') as stream:
|
|
return [json.loads(line) for line in stream if line.strip()]
|
|
|
|
|
|
def _npz(path, keys):
|
|
with np.load(path, allow_pickle=False) as archive:
|
|
require(len(archive.files) == len(keys) and set(archive.files) == set(keys), 'Unexpected array keys: ' + str(path))
|
|
return {key: archive[key].copy() for key in keys}
|
|
|
|
|
|
def reconstructed_fresh_ring(state, steps, neurons):
|
|
ring = np.zeros((19, neurons), np.uint8)
|
|
for tick in range(max(0, steps - 19), steps):
|
|
first, last = np.searchsorted(state['step'], (tick, tick + 1))
|
|
ring[tick % 19, state['neuron_idx'][first:last]] = 1
|
|
return ring
|
|
|
|
|
|
def normalized_ring(terminal):
|
|
ring, phase = terminal['spike_ring'], int(terminal['next_tick'])
|
|
return ring[(np.arange(19) + phase % 19) % 19]
|
|
|
|
|
|
def _requests(path):
|
|
with Path(path).open(encoding='utf-8', newline='') as stream:
|
|
reader = csv.DictReader(stream)
|
|
require(tuple(reader.fieldnames or ()) == REQUEST_FIELDS, 'requests.csv must use the exact five AJ fields in order')
|
|
rows = []
|
|
for row in reader:
|
|
require(set(row) == set(REQUEST_FIELDS), 'Extra/missing request CSV field')
|
|
rows.append([int(row[key]) for key in REQUEST_FIELDS])
|
|
return np.asarray(rows, dtype=np.int64).reshape(-1, 5)
|
|
|
|
|
|
def load_run(directory, *, allow_legacy_am=False):
|
|
directory = Path(directory).resolve(strict=True)
|
|
require(directory.is_dir(), 'Output is not a directory')
|
|
require(not any('error' in p.name.lower() or 'failure' in p.name.lower() for p in directory.iterdir()),
|
|
'Run contains error/failure evidence')
|
|
summary = _json(directory / 'summary.json')
|
|
require(summary.get('complete') is True and summary.get('pass_all') is True and summary.get('all_finite') is True and
|
|
summary.get('steps') == summary.get('completed_ticks'), 'Run is incomplete or failed')
|
|
state = _npz(directory / 'state.npz', STATE_KEYS)
|
|
steps, neurons = summary['steps'], len(state['v'])
|
|
require(summary.get('nodes') == neurons and summary.get('precision') == 'float64' and
|
|
summary.get('apl_precision') == 'float32' and summary.get('apl_delay_steps') == 18, 'Unexpected AN/AM numerical schema')
|
|
timing = _json(directory / 'apl-timing-audit.json')
|
|
pending = np.load(directory / 'apl-pending-tail.float32.npy', mmap_mode='r', allow_pickle=False)
|
|
terminal_path = directory / 'terminal-queues.npz'
|
|
if terminal_path.is_file():
|
|
terminal = _npz(terminal_path, ('spike_ring', 'apl_state', 'apl_pending', 'next_tick'))
|
|
origin = 'recorded_terminal_queues'
|
|
else:
|
|
require(allow_legacy_am and (directory / 'adapter-provenance.json').is_file(), 'Recorded terminal queues are missing')
|
|
bits = timing.get('final_apl_state_u32_bits')
|
|
require(isinstance(bits, list) and len(bits) == 2 and all(type(v) is int and 0 <= v < 2**32 for v in bits),
|
|
'AM has no exact terminal APL bits')
|
|
terminal = {'spike_ring': reconstructed_fresh_ring(state, steps, neurons),
|
|
'apl_state': np.asarray(bits, dtype=np.uint32).view(np.float32), 'apl_pending': np.asarray(pending),
|
|
'next_tick': np.asarray(steps, np.int64)}
|
|
origin = 'AM_spike_ring_derived_from_fresh_events_APL_bits_from_timing'
|
|
require(bit_equal(terminal['apl_pending'], pending), 'Terminal/pending file mismatch')
|
|
require(timing.get('final_apl_state_u32_bits') == terminal['apl_state'].view(np.uint32).tolist(), 'Terminal APL bit metadata mismatch')
|
|
continued = summary.get('checkpoint_continuation_used', False)
|
|
require(type(continued) is bool, 'Invalid continuation scope flag')
|
|
offset = summary.get('global_tick_offset', 0)
|
|
require(not continued or (type(offset) is int and offset > 0 and summary.get('global_next_tick') == offset + steps),
|
|
'Continued output lacks an explicit global clock')
|
|
require(continued or offset == 0, 'Fresh output has a nonzero global offset')
|
|
traces = {name: np.load(directory / file, mmap_mode='r', allow_pickle=False)
|
|
for name, file in TRACE_FILES.items() if (directory / file).is_file()}
|
|
reference = summary.get('diagnostic_mode') == 'reference' or origin.startswith('AM_')
|
|
if reference or summary.get('full_APL_history_recorded') is True:
|
|
require(len(traces) == 4, 'Declared reference APL history is incomplete')
|
|
hashes = _jsonl(directory / 'tick-state-hashes.jsonl') if (directory / 'tick-state-hashes.jsonl').is_file() else None
|
|
queues = _jsonl(directory / 'queue.jsonl') if (directory / 'queue.jsonl').is_file() else None
|
|
if reference or summary.get('full_tick_state_hashes_recorded') is True:
|
|
require(hashes is not None, 'Declared state hashes are missing')
|
|
if reference or summary.get('full_queue_hashes_recorded') is True:
|
|
require(queues is not None, 'Declared queue hashes are missing')
|
|
result = {'source': str(directory), 'state': state, 'terminal': terminal, 'requests': _requests(directory / 'requests.csv'),
|
|
'steps': steps, 'global_tick_offset': offset, 'summary': summary, 'traces': traces,
|
|
'state_hashes': hashes, 'queues': queues, 'terminal_origin': origin}
|
|
validate_run(result)
|
|
return result
|
|
|
|
|
|
def close_run(run):
|
|
"""Release read-only mappings opened by load_run; no files are modified."""
|
|
arrays = [*run.get('traces', {}).values(), *run.get('terminal', {}).values()]
|
|
closed = set()
|
|
for array in arrays:
|
|
current = array
|
|
while current is not None:
|
|
mapping = getattr(current, '_mmap', None)
|
|
if mapping is not None and id(mapping) not in closed:
|
|
mapping.close(); closed.add(id(mapping))
|
|
current = getattr(current, 'base', None)
|
|
|
|
|
|
def validate_run(run):
|
|
"""Array-level contract, also usable by synthetic tests without files."""
|
|
require(isinstance(run, dict), 'Run must be a dictionary')
|
|
steps, offset = run['steps'], run['global_tick_offset']
|
|
require(type(steps) is int and steps > 0 and type(offset) is int and offset >= 0, 'Invalid segment clock')
|
|
state, terminal = run['state'], run['terminal']
|
|
require(set(state) == set(STATE_KEYS), 'Expected exactly the six state keys')
|
|
n = len(state['v'])
|
|
require(n > 0, 'Empty neuron population')
|
|
for name, dtype in (('v', np.float64), ('g', np.float64), ('ref', np.int32), ('counts', np.int32)):
|
|
value = state[name]
|
|
require(value.dtype == dtype and value.shape == (n,) and np.isfinite(value).all(), 'Invalid state ' + name)
|
|
require(np.all((state['ref'] >= 0) & (state['ref'] <= 22)) and np.all(state['counts'] >= 0), 'Invalid ref/count values')
|
|
tick, node = state['step'], state['neuron_idx']
|
|
require(tick.dtype == node.dtype == np.int32 and tick.ndim == node.ndim == 1 and tick.shape == node.shape and
|
|
np.all((tick >= 0) & (tick < steps)) and np.all((node >= 0) & (node < n)), 'Invalid events')
|
|
keys = tick.astype(np.int64) * n + node
|
|
require(len(keys) < 2 or np.all(keys[1:] > keys[:-1]), 'Events must be sorted unique')
|
|
require(np.array_equal(np.bincount(node, minlength=n), state['counts']), 'Counts disagree with segment events')
|
|
request = run['requests']
|
|
require(isinstance(request, np.ndarray) and request.dtype == np.int64 and request.ndim == 2 and request.shape[1] == 5,
|
|
'Requests must be int64 rows in the five AJ fields')
|
|
require(np.all((request[:, 0] >= 0) & (request[:, 0] < steps)) and np.all((request[:, 1] >= 0) & (request[:, 1] < n)) and
|
|
np.all(request[:, 2] == 1) and np.all((request[:, 3] == 0) | (request[:, 3] == 1)) and
|
|
np.all(request[:, 4] == 1 - request[:, 3]), 'Invalid request values')
|
|
request_keys = request[:, 0] * n + request[:, 1]
|
|
require(len(request_keys) < 2 or np.all(request_keys[1:] > request_keys[:-1]), 'Requests must be sorted unique')
|
|
require(set(terminal) == {'spike_ring', 'apl_state', 'apl_pending', 'next_tick'}, 'Invalid terminal keys')
|
|
ring = terminal['spike_ring']
|
|
require(ring.dtype == np.uint8 and ring.shape == (19, n) and np.all(ring <= 1), 'Invalid spike ring')
|
|
phase = terminal['next_tick']
|
|
require(isinstance(phase, np.ndarray) and phase.dtype == np.int64 and phase.shape == () and int(phase) == steps,
|
|
'Terminal phase must be local segment length')
|
|
pending, apl_state = terminal['apl_pending'], terminal['apl_state']
|
|
require(pending.dtype == np.float32 and pending.ndim == 2 and pending.shape[0] == 18 and pending.shape[1] > 0 and
|
|
apl_state.dtype == np.float32 and apl_state.shape == (2,) and np.isfinite(pending).all() and np.isfinite(apl_state).all(),
|
|
'Invalid APL terminal state')
|
|
for t in range(max(0, steps - 19), steps):
|
|
expected = np.zeros(n, np.uint8)
|
|
first, last = np.searchsorted(tick, (t, t + 1)); expected[node[first:last]] = 1
|
|
require(bit_equal(ring[t % 19], expected), 'Written ring slot differs from sparse events')
|
|
if offset == 0 and steps < 19:
|
|
require(not np.any(ring[steps:]), 'Fresh uninitialized ring slots are not zero')
|
|
traces = run.get('traces', {})
|
|
require(not traces or set(traces) == set(TRACE_FILES), 'Partial APL trace set')
|
|
for key, trace in traces.items():
|
|
width = 2 if key in ('drive', 'state') else pending.shape[1]
|
|
require(trace.dtype == np.float32 and trace.shape == (steps, width) and np.isfinite(trace).all(), 'Invalid APL history: ' + key)
|
|
if traces:
|
|
require(bit_equal(traces['state'][-1], apl_state), 'Final APL history/state mismatch')
|
|
kept = min(steps, 18)
|
|
require(bit_equal(pending[-kept:], traces['generated'][-kept:]), 'Terminal APL queue does not retain generated suffix')
|
|
if steps > 18:
|
|
require(bit_equal(traces['applied'][18:], traces['generated'][:-18]), 'Within-segment APL delay differs from 18')
|
|
if offset == 0:
|
|
require(np.all(traces['applied'][:min(18, steps)].view(np.uint32) == 0), 'Fresh APL application padding is not positive zero')
|
|
hashes, queues = run.get('state_hashes'), run.get('queues')
|
|
if hashes is not None:
|
|
require(len(hashes) == steps, 'State hash coverage incomplete')
|
|
for t, row in enumerate(hashes):
|
|
require(set(row) == {'tick', *HASH_FIELDS} and type(row['tick']) is int and row['tick'] == t and
|
|
all(_sha(row[key]) for key in HASH_FIELDS), 'Invalid state hash row')
|
|
for name in ('v', 'g', 'ref'):
|
|
raw = np.ascontiguousarray(state[name], dtype=state[name].dtype.newbyteorder('<')).tobytes()
|
|
require(hashes[-1][name + '_sha256'] == hashlib.sha256(raw).hexdigest(), 'Last state hash differs from terminal ' + name)
|
|
if queues is not None:
|
|
require(len(queues) == steps, 'Queue coverage incomplete')
|
|
for t, row in enumerate(queues):
|
|
require(set(row) == {'tick', *QUEUE_FIELDS, 'joint_sha256'} and type(row['tick']) is int and row['tick'] == t and
|
|
type(row['count']) is int and type(row['accepted_count']) is int and 0 <= row['accepted_count'] <= row['count'] and
|
|
all(_sha(row[key]) for key in ('ordered_edge_sha256', 'accepted_mask_sha256', 'joint_sha256')), 'Invalid queue row')
|
|
return run
|
|
|
|
|
|
def _run(value, legacy=False):
|
|
return load_run(value, allow_legacy_am=legacy) if isinstance(value, (str, Path)) else validate_run(value)
|
|
|
|
|
|
def _activity(run):
|
|
terminal = run['terminal']
|
|
result = {'spikes': len(run['state']['step']), 'requested': len(run['requests']),
|
|
'accepted_requests': int(run['requests'][:, 3].sum(dtype=np.int64)),
|
|
'terminal_apl_state_nonzero_values': int(np.count_nonzero(terminal['apl_state'])),
|
|
'terminal_pending_nonzero_values': int(np.count_nonzero(terminal['apl_pending']))}
|
|
traces = run.get('traces', {})
|
|
result['generated_h_nonzero_values'] = int(np.count_nonzero(traces['generated'])) if traces else None
|
|
result['applied_h_nonzero_values'] = int(np.count_nonzero(traces['applied'])) if traces else None
|
|
result['apl_nonzero_observed'] = bool(result['terminal_apl_state_nonzero_values'] or result['terminal_pending_nonzero_values'] or
|
|
(result['generated_h_nonzero_values'] or 0) or (result['applied_h_nonzero_values'] or 0))
|
|
return result
|
|
|
|
|
|
def _pair_checks(left, right, prefix='pair'):
|
|
checks = {prefix + '.steps': left['steps'] == right['steps'], prefix + '.offset': left['global_tick_offset'] == right['global_tick_offset']}
|
|
for name in STATE_KEYS:
|
|
checks[prefix + '.state.' + name] = bit_equal(left['state'][name], right['state'][name])
|
|
checks[prefix + '.requests_five_fields'] = bit_equal(left['requests'], right['requests'])
|
|
for name in ('spike_ring', 'apl_state', 'apl_pending', 'next_tick'):
|
|
checks[prefix + '.terminal.' + name] = bit_equal(left['terminal'][name], right['terminal'][name])
|
|
for field in ('effective_weights_raw_sha256',):
|
|
a, b = left.get('summary', {}).get(field), right.get('summary', {}).get(field)
|
|
if a is not None or b is not None:
|
|
checks[prefix + '.' + field] = _sha(a) and a == b
|
|
availability = {'APL_traces': bool(left.get('traces')) and bool(right.get('traces')),
|
|
'state_hashes': left.get('state_hashes') is not None and right.get('state_hashes') is not None,
|
|
'queue_hashes': left.get('queues') is not None and right.get('queues') is not None}
|
|
if availability['APL_traces']:
|
|
for name in TRACE_FILES:
|
|
checks[prefix + '.trace.' + name] = bit_equal(left['traces'][name], right['traces'][name])
|
|
if availability['state_hashes']:
|
|
checks[prefix + '.state_hashes'] = left['state_hashes'] == right['state_hashes']
|
|
if availability['queue_hashes']:
|
|
checks[prefix + '.queues'] = left['queues'] == right['queues']
|
|
return checks, availability
|
|
|
|
|
|
def compare_fresh(left, right, legacy_am=None):
|
|
left, right = _run(left), _run(right)
|
|
require(left['global_tick_offset'] == right['global_tick_offset'] == 0, 'Fresh comparison requires fresh runs')
|
|
checks, available = _pair_checks(left, right)
|
|
origins = [left.get('terminal_origin', 'caller_arrays'), right.get('terminal_origin', 'caller_arrays')]
|
|
if legacy_am is not None:
|
|
legacy = _run(legacy_am, legacy=True)
|
|
require(legacy['global_tick_offset'] == 0, 'AM control must be fresh')
|
|
extra, legacy_available = _pair_checks(left, legacy, 'AM')
|
|
checks.update(extra); available['AM'] = legacy_available
|
|
# The left run may be light. Do not thereby skip the independent full
|
|
# diagnostic comparison between the right reference and sealed AM.
|
|
extra, reference_available = _pair_checks(right, legacy, 'reference_vs_AM')
|
|
checks.update(extra); available['reference_vs_AM'] = reference_available
|
|
origins.append(legacy.get('terminal_origin', 'caller_arrays'))
|
|
activity = _activity(left)
|
|
exact = bool(all(checks.values()))
|
|
nonvacuous = activity['spikes'] > 0 and activity['apl_nonzero_observed']
|
|
return {'schema': 'phase4an-fresh-engineering-comparison-v1', 'numerical_exact': exact,
|
|
'nonvacuous_activity': nonvacuous, 'pass_all': exact and nonvacuous,
|
|
'status': 'FAIL-NUMERICAL' if not exact else ('PASS-FRESH-SCOPE' if nonvacuous else 'INCOMPLETE-COVERAGE'),
|
|
'checks': checks, 'failed_checks': [key for key, value in checks.items() if not value], 'activity': activity,
|
|
'reference_comparisons_available': available, 'terminal_origins': origins,
|
|
'cross_segment_validation_performed': False, 'temporal_validation_complete': False,
|
|
'scope': 'Fresh event/state/request/terminal identity only; no continuation, learning, physiology or performance PASS',
|
|
'independent_CSR_queue_reconstruction_performed': False,
|
|
'accepted_nonzero_weight_edge_witness_verified': False,
|
|
'external_seals_and_input_authority_verified_here': False}
|
|
|
|
|
|
def compare_segments(monolithic, segments):
|
|
mono = _run(monolithic)
|
|
parts = [_run(value) for value in segments]
|
|
require(len(parts) >= 2, 'Need a monolithic run and at least two segments')
|
|
origin = mono['global_tick_offset']
|
|
if origin:
|
|
parent = mono.get('summary', {}).get('parent_checkpoint_manifest_sha256')
|
|
require(_sha(parent) and parts[0].get('summary', {}).get('parent_checkpoint_manifest_sha256') == parent,
|
|
'Nonzero-origin comparisons must bind the same starting parent checkpoint')
|
|
cursor = origin
|
|
for part in parts:
|
|
require(part['global_tick_offset'] == cursor, 'Segment clock gap/overlap/order error')
|
|
require(len(part['state']['v']) == len(mono['state']['v']), 'Segment population changed')
|
|
cursor += part['steps']
|
|
require(cursor == origin + mono['steps'], 'Segments do not cover the monolithic duration')
|
|
checks = {}
|
|
step = np.concatenate([part['state']['step'].astype(np.int64) + part['global_tick_offset'] for part in parts])
|
|
neuron = np.concatenate([part['state']['neuron_idx'] for part in parts])
|
|
checks['concatenated_global_events'] = np.array_equal(step, mono['state']['step'].astype(np.int64) + origin) and bit_equal(neuron, mono['state']['neuron_idx'])
|
|
counts = np.zeros_like(mono['state']['counts'], dtype=np.int64)
|
|
for part in parts:
|
|
counts += part['state']['counts'].astype(np.int64)
|
|
checks['sum_segment_counts'] = np.array_equal(counts, mono['state']['counts'].astype(np.int64))
|
|
requests = []
|
|
for part in parts:
|
|
rows = part['requests'].copy(); rows[:, 0] += part['global_tick_offset']; requests.append(rows)
|
|
mono_requests = mono['requests'].copy(); mono_requests[:, 0] += origin
|
|
checks['concatenated_requests_five_fields'] = bit_equal(np.concatenate(requests), mono_requests)
|
|
last = parts[-1]
|
|
for name in ('v', 'g', 'ref'):
|
|
checks['terminal.' + name] = bit_equal(last['state'][name], mono['state'][name])
|
|
checks['terminal.normalized_spike_ring'] = bit_equal(normalized_ring(last['terminal']), normalized_ring(mono['terminal']))
|
|
for name in ('apl_state', 'apl_pending'):
|
|
checks['terminal.' + name] = bit_equal(last['terminal'][name], mono['terminal'][name])
|
|
expected_weight = mono.get('summary', {}).get('effective_weights_raw_sha256')
|
|
if expected_weight is not None:
|
|
checks['unchanged_effective_weights'] = _sha(expected_weight) and all(part.get('summary', {}).get('effective_weights_raw_sha256') == expected_weight for part in parts)
|
|
trace_available = bool(mono.get('traces')) and all(part.get('traces') for part in parts)
|
|
hash_available = mono.get('state_hashes') is not None and all(part.get('state_hashes') is not None for part in parts)
|
|
queue_available = mono.get('queues') is not None and all(part.get('queues') is not None for part in parts)
|
|
if trace_available:
|
|
for name in TRACE_FILES:
|
|
checks['concatenated_APL.' + name] = all(bit_equal(part['traces'][name], mono['traces'][name][part['global_tick_offset'] - origin:part['global_tick_offset'] - origin + part['steps']]) for part in parts)
|
|
if hash_available:
|
|
checks['concatenated_per_tick_state_hashes'] = all(all(row[name] == mono['state_hashes'][part['global_tick_offset'] - origin + tick][name] for name in HASH_FIELDS)
|
|
for part in parts for tick, row in enumerate(part['state_hashes']))
|
|
if queue_available:
|
|
checks['concatenated_queue_order_and_acceptance'] = all(all(row[name] == mono['queues'][part['global_tick_offset'] - origin + tick][name] for name in QUEUE_FIELDS)
|
|
for part in parts for tick, row in enumerate(part['queues']))
|
|
boundary_rows = []
|
|
events = mono['state']['step'].astype(np.int64) + origin
|
|
for before, part in zip(parts, parts[1:]):
|
|
cut, stop = part['global_tick_offset'], part['global_tick_offset'] + part['steps']
|
|
emitted_before = (events < cut) & (events + 18 >= cut)
|
|
arriving_this_segment = emitted_before & (events + 18 < stop)
|
|
pending = before['terminal']['apl_pending']
|
|
consume = min(part['steps'], 18)
|
|
spike_carry = normalized_ring(before['terminal'])
|
|
# Future local arrival tick j consumes normalized slot j+1. This also
|
|
# covers spikes inherited from before a nonzero monolithic origin,
|
|
# which are legitimately absent from that run's local event log.
|
|
pending_spikes = int(spike_carry[1:].sum(dtype=np.int64))
|
|
arriving_spikes = int(spike_carry[1:consume + 1].sum(dtype=np.int64))
|
|
if cut - origin >= 18:
|
|
checks['boundary.' + str(cut) + '.ring_pending_event_count'] = pending_spikes == int(emitted_before.sum())
|
|
# Slots not overwritten by this short segment must remain bit-identical.
|
|
if part['steps'] < 19:
|
|
checks['boundary.' + str(cut) + '.unwritten_spike_slots'] = bit_equal(part['terminal']['spike_ring'][part['steps']:], spike_carry[part['steps']:])
|
|
if part['steps'] < 18:
|
|
checks['boundary.' + str(cut) + '.unconsumed_APL'] = bit_equal(part['terminal']['apl_pending'][:18 - part['steps']], pending[part['steps']:])
|
|
if part.get('traces'):
|
|
checks['boundary.' + str(cut) + '.applied_parent_APL'] = bit_equal(part['traces']['applied'][:consume], pending[:consume])
|
|
queue_rows = (part['queues'][:consume] if part.get('queues') is not None else
|
|
mono['queues'][cut - origin:cut - origin + consume] if mono.get('queues') is not None else None)
|
|
boundary_rows.append({'global_tick': cut, 'next_segment_steps': part['steps'],
|
|
'pending_source_spike_events': pending_spikes, 'source_spikes_arriving_in_next_segment': arriving_spikes,
|
|
'visible_local_log_source_spikes_arriving_in_next_segment': int(arriving_this_segment.sum()),
|
|
'pending_source_spike_origin': 'recorded normalized ring slots; includes pre-origin carry',
|
|
'observed_carried_arriving_edges': sum(row['count'] for row in queue_rows) if queue_rows is not None else None,
|
|
'observed_carried_accepted_edges': sum(row['accepted_count'] for row in queue_rows) if queue_rows is not None else None,
|
|
'carried_APL_nonzero_pending_values': int(np.count_nonzero(pending)),
|
|
'carried_APL_nonzero_values_applied_in_next_segment': int(np.count_nonzero(pending[:consume])),
|
|
'carried_APL_nonzero_rows_applied_in_next_segment': int(np.count_nonzero(np.any(pending[:consume] != 0, axis=1)))})
|
|
source_arrivals = sum(row['source_spikes_arriving_in_next_segment'] for row in boundary_rows)
|
|
edge_counts = [row['observed_carried_arriving_edges'] for row in boundary_rows]
|
|
observed_edges = sum(value for value in edge_counts if value is not None) if any(value is not None for value in edge_counts) else None
|
|
applied_values = sum(row['carried_APL_nonzero_values_applied_in_next_segment'] for row in boundary_rows)
|
|
activity = _activity(mono)
|
|
coverage = {'boundaries': boundary_rows, 'source_spikes_crossing_boundaries_and_due_in_receiver': source_arrivals,
|
|
'observed_carried_arriving_edges': observed_edges, 'carried_APL_nonzero_applied_values': applied_values,
|
|
'boundary_pending_event_counts_may_overlap_across_short_segments': True,
|
|
'actual_edge_arrival_coverage_known': observed_edges is not None}
|
|
nonvacuous = bool(activity['spikes'] > 0 and activity['apl_nonzero_observed'] and source_arrivals > 0 and
|
|
observed_edges is not None and observed_edges > 0 and applied_values > 0)
|
|
exact = bool(all(checks.values()))
|
|
return {'schema': 'phase4an-segment-engineering-comparison-v1', 'numerical_exact': exact,
|
|
'nonvacuous_temporal_coverage': nonvacuous, 'temporal_validation_complete': exact and nonvacuous,
|
|
'pass_all': exact and nonvacuous,
|
|
'status': 'FAIL-NUMERICAL' if not exact else ('PASS-SEGMENT-SCOPE' if nonvacuous else 'INCOMPLETE-COVERAGE'),
|
|
'checks': checks, 'failed_checks': [key for key, value in checks.items() if not value],
|
|
'activity': activity, 'coverage': coverage, 'segments': len(parts), 'steps': mono['steps'], 'global_tick_offset': origin,
|
|
'reference_comparisons_available': {'APL_traces': trace_available, 'state_hashes': hash_available, 'queue_hashes': queue_available},
|
|
'queue_joint_hash_compared': False, 'queue_joint_hash_exclusion_reason': 'local tick header differs; ordered-edge/mask hashes and counts compared when available',
|
|
'scope': 'Explicit finite engineering trajectory/terminal/carry checks only; no learning, physiology, or performance PASS',
|
|
'independent_CSR_queue_reconstruction_performed': False,
|
|
'accepted_nonzero_weight_edge_witness_verified': False,
|
|
'external_seals_and_input_authority_verified_here': False}
|