Digital Drosophila Archive
372 lines
25 KiB
Python
372 lines
25 KiB
Python
"""Pure CPU comparison of live-boundary and saved/restored diagnostics.
|
|
|
|
Array APIs require caller-authenticated records and immutable original graph /
|
|
delta arrays. They do NOT authenticate registrations, process receipts or disk
|
|
seals. load_record reads existing bytes without writing; its scope tags are not
|
|
authority. No GPU, learning, membrane replay or physiological inference.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
from types import ModuleType
|
|
|
|
import numpy as np
|
|
|
|
|
|
PINS = {
|
|
'engineering_compare.py': '5a2403f11bc08d65a9d242ac2cf9686b850e0c3680d65659f785e9b6b50c0238',
|
|
'engineering_queue_audit.py': '6ddaec52f2a0b5d0c528d51230d372fe2344160aef5eccea6a95b6c5e61a574e',
|
|
}
|
|
AUTHORITY_FIELDS = {'schema', 'boundary_id', 'registration_sha256', 'transition', 'diagnostic_mode', 'input_policy',
|
|
'case', 'parent', 'global_tick_offset', 'overlay_before', 'overlay_after',
|
|
'expected_effective_weight_before_sha256', 'expected_effective_weight_after_sha256', 'update',
|
|
'cpu_validation', 'source_files', 'frozen_inputs'}
|
|
|
|
|
|
def _digest(path):
|
|
h = hashlib.sha256()
|
|
with Path(path).open('rb') as stream:
|
|
for block in iter(lambda: stream.read(8 << 20), b''):
|
|
h.update(block)
|
|
return h.hexdigest()
|
|
|
|
|
|
def _load(filename, expected):
|
|
path = Path(__file__).resolve().parent.parent / 'olfactory-conditioning-lab-v1' / filename
|
|
raw = path.read_bytes()
|
|
if hashlib.sha256(raw).hexdigest() != expected:
|
|
raise ValueError('Frozen pure helper source differs: ' + filename)
|
|
module = ModuleType('conditioning_boundary_' + filename[:-3])
|
|
module.__file__ = str(path)
|
|
exec(compile(raw, str(path), 'exec'), module.__dict__)
|
|
return module
|
|
|
|
|
|
C = _load('engineering_compare.py', PINS['engineering_compare.py'])
|
|
require, bit_equal = C.require, C.bit_equal
|
|
|
|
|
|
def _raw(a):
|
|
h = hashlib.sha256()
|
|
for start in range(0, len(a), 1 << 18):
|
|
h.update(np.ascontiguousarray(a[start:start+(1 << 18)], dtype=a.dtype.newbyteorder('<')).tobytes())
|
|
return h.hexdigest()
|
|
|
|
|
|
def load_record(directory, *, kind):
|
|
"""Read actual inherited schemas; never disguise oracle as fixed-weight.
|
|
|
|
No external SHA pin is accepted or inferred here. The caller independently
|
|
verifies the complete oracle/new/old checkpoint seal before this reader.
|
|
"""
|
|
require(kind in ('oracle', 'updated', 'parent'), 'Explicit record kind required')
|
|
record = C.load_run(directory)
|
|
try:
|
|
summary = record['summary']
|
|
if kind == 'oracle':
|
|
require(summary.get('diagnostic_live_boundary') is True and summary.get('within_trial_weight_updates') is True and
|
|
summary.get('production_backend') is False and summary.get('restored_from_checkpoint') is False,
|
|
'Not a declared live-boundary diagnostic')
|
|
record['boundary_snapshot'] = C._npz(Path(directory)/'boundary-snapshot.npz',
|
|
('v','g','ref','counts','spike_ring','apl_state','apl_pending'))
|
|
record['boundary_report'] = C._json(Path(directory)/'boundary-comparison.json')
|
|
record['oracle_provenance'] = C._json(Path(directory)/'oracle-provenance.json')
|
|
else:
|
|
require(summary.get('within_trial_weight_updates') is False, 'Checkpoint segment updated during run')
|
|
if kind == 'updated':
|
|
require(summary.get('updated_boundary_schema') == 'conditioning-updated-boundary-v1' and
|
|
summary.get('checkpoint_continuation_used') is True, 'Not an updated checkpoint segment')
|
|
record['manifest_sha256'] = _digest(Path(directory)/'checkpoint-manifest.json')
|
|
record['read_scope'] = kind
|
|
return record
|
|
except BaseException:
|
|
C.close_run(record)
|
|
raise
|
|
|
|
|
|
def close_record(record):
|
|
C.close_run(record)
|
|
|
|
|
|
def _checks():
|
|
checks = {}
|
|
def check(name, okay):
|
|
checks[name] = bool(okay)
|
|
return checks, check
|
|
|
|
|
|
def _complete(record):
|
|
C.validate_run(record)
|
|
s=record.get('summary',{})
|
|
require(s.get('complete') is True and s.get('pass_all') is True and s.get('all_finite') is True and
|
|
type(s.get('steps')) is int and s['steps']==record['steps']==s.get('completed_ticks') and
|
|
type(s.get('nodes')) is int and s['nodes']==len(record['state']['v']) and
|
|
s.get('precision')=='float64' and s.get('apl_precision')=='float32' and s.get('apl_delay_steps')==18,
|
|
'Record summary is incomplete or has wrong numerical scope')
|
|
|
|
|
|
def _canonical(value):
|
|
return json.dumps(value,sort_keys=True,separators=(',',':'),ensure_ascii=False,allow_nan=False).encode('utf-8')
|
|
|
|
|
|
def _paired_authorities(pair, oracle_sha, child_sha, child_mode):
|
|
"""Bind actual raw JSON bytes and compare canonical content, not self hashes.
|
|
|
|
File SHA and canonical SHA are intentionally distinct. Only diagnostic_mode
|
|
and boundary_id may differ; every other byte of canonical JSON must agree.
|
|
"""
|
|
require(type(pair) in (tuple,list) and len(pair)==2 and all(type(raw)is bytes for raw in pair),
|
|
'paired_authorities must be the two original raw JSON byte strings')
|
|
def unique(items):
|
|
result={}
|
|
for key,value in items:
|
|
require(key not in result,'Duplicate authority JSON key: '+key);result[key]=value
|
|
return result
|
|
values=[json.loads(raw.decode('utf-8'),object_pairs_hook=unique,
|
|
parse_constant=lambda value:(_ for _ in ()).throw(ValueError('Nonfinite authority JSON'))) for raw in pair]
|
|
for value in values:
|
|
require(type(value)is dict and set(value)==AUTHORITY_FIELDS and value.get('schema')=='conditioning-updated-boundary-v1',
|
|
'Paired authority must use the exact boundary schema')
|
|
require(type(value['boundary_id'])is str and bool(value['boundary_id']) and value['boundary_id'].strip()==value['boundary_id'],
|
|
'Invalid paired boundary ID')
|
|
hashes=[hashlib.sha256(raw).hexdigest() for raw in pair]
|
|
allowed={'diagnostic_mode','boundary_id'}
|
|
normalized=[{k:v for k,v in value.items() if k not in allowed} for value in values]
|
|
differences=[key for key in sorted(AUTHORITY_FIELDS-allowed) if _canonical(values[0][key])!=_canonical(values[1][key])]
|
|
checks=dict(actual_raw_file_SHA_bound=hashes==[oracle_sha,child_sha],
|
|
explicit_modes=values[0]['diagnostic_mode']=='reference' and values[1]['diagnostic_mode']==child_mode,
|
|
only_two_allowed_fields_differ=_canonical(normalized[0])==_canonical(normalized[1]))
|
|
return dict(pass_all=all(checks.values()),checks=checks,raw_sha256=hashes,
|
|
canonical_sha256=[hashlib.sha256(_canonical(value)).hexdigest() for value in values],
|
|
common_content_canonical_sha256=[hashlib.sha256(_canonical(value)).hexdigest() for value in normalized],
|
|
allowed_differences=sorted(allowed),disallowed_different_fields=differences,
|
|
actual_disk_or_registration_authority_verified_here=False)
|
|
|
|
|
|
def compare_boundary(oracle, continuation, *, parent, expected_before_sha256, expected_after_sha256, paired_authorities=None):
|
|
"""Compare full oracle prefix/suffix against an authenticated parent/child.
|
|
|
|
Both reference and light children are supported. A light child's absent
|
|
intermediate traces/hashes are explicitly unobserved, never called exact.
|
|
No nonvacuity gate is invented here; changed-edge coverage is separate.
|
|
"""
|
|
for record in (oracle, continuation, parent): _complete(record)
|
|
require(C._sha(expected_before_sha256) and C._sha(expected_after_sha256), 'External expected weight identities required')
|
|
require(C._sha(parent.get('manifest_sha256')), 'Caller-authenticated parent manifest identity required')
|
|
require(parent['global_tick_offset'] == oracle['global_tick_offset'] == 0, 'Need original fresh parent/live oracle')
|
|
cut, steps = parent['steps'], continuation['steps']
|
|
require(continuation['global_tick_offset'] == cut and oracle['steps'] == cut+steps, 'Wrong boundary/duration')
|
|
n = len(parent['state']['v'])
|
|
require(len(oracle['state']['v']) == len(continuation['state']['v']) == n, 'Population differs')
|
|
require(oracle.get('traces') and oracle.get('state_hashes') is not None and oracle.get('queues') is not None,
|
|
'Live oracle must retain full reference diagnostics')
|
|
os, cs, ps = oracle['summary'], continuation['summary'], parent['summary']
|
|
require(cs.get('diagnostic_mode') in ('reference','light'), 'Child recording mode is undeclared')
|
|
reference = cs['diagnostic_mode'] == 'reference'
|
|
if reference:
|
|
require(continuation.get('traces') and continuation.get('state_hashes') is not None and continuation.get('queues') is not None,
|
|
'Reference child diagnostics missing')
|
|
else:
|
|
require(not continuation.get('traces') and continuation.get('state_hashes') is None and continuation.get('queues') is None,
|
|
'Light scope must not manufacture intermediate histories')
|
|
if ps.get('diagnostic_mode')=='reference':
|
|
require(parent.get('traces') and parent.get('state_hashes') is not None and parent.get('queues') is not None,
|
|
'Reference parent diagnostics missing')
|
|
checks, check = _checks()
|
|
check('oracle.explicit_live_scope', os.get('diagnostic_mode') == 'reference' and
|
|
os.get('diagnostic_live_boundary') is True and os.get('within_trial_weight_updates') is True and
|
|
os.get('explicit_weight_switches') == 1 and type(os.get('explicit_weight_switches')) is int and
|
|
os.get('boundary_tick') == cut and os.get('restored_from_checkpoint') is False and os.get('production_backend') is False)
|
|
check('child.explicit_updated_scope', cs.get('within_trial_weight_updates') is False and
|
|
cs.get('checkpoint_continuation_used') is True and cs.get('updated_boundary_schema') == 'conditioning-updated-boundary-v1' and
|
|
cs.get('parent_checkpoint_manifest_sha256') == parent['manifest_sha256'] and
|
|
cs.get('global_next_tick') == cut+steps and cs.get('boundary_transition') == 'epoch_update')
|
|
check('weights.before', ps.get('effective_weights_raw_sha256') == os.get('initial_effective_weights_raw_sha256') == expected_before_sha256)
|
|
check('weights.after', cs.get('effective_weights_raw_sha256') == os.get('effective_weights_raw_sha256') == expected_after_sha256)
|
|
ot, on = oracle['state']['step'], oracle['state']['neuron_idx']
|
|
split = int(np.searchsorted(ot,cut))
|
|
check('prefix.events.tick',bit_equal(ot[:split],parent['state']['step']))
|
|
check('prefix.events.neuron_idx',bit_equal(on[:split],parent['state']['neuron_idx']))
|
|
check('prefix.counts',np.array_equal(np.bincount(on[:split],minlength=n),parent['state']['counts']))
|
|
check('suffix.events.absolute_tick',np.array_equal(continuation['state']['step'].astype(np.int64)+cut,ot[split:].astype(np.int64)))
|
|
check('suffix.events.neuron_idx',bit_equal(continuation['state']['neuron_idx'],on[split:]))
|
|
check('suffix.segment_counts',np.array_equal(continuation['state']['counts'],np.bincount(on[split:],minlength=n)))
|
|
check('prefix_plus_suffix.total_counts',np.array_equal(parent['state']['counts'].astype(np.int64)+continuation['state']['counts'],oracle['state']['counts']))
|
|
for name in ('v','g','ref'):check('final.'+name,bit_equal(continuation['state'][name],oracle['state'][name]))
|
|
check('final.phase_normalized_spike_ring',bit_equal(C.normalized_ring(continuation['terminal']),C.normalized_ring(oracle['terminal'])))
|
|
for name in ('apl_pending','apl_state'):check('final.'+name,bit_equal(continuation['terminal'][name],oracle['terminal'][name]))
|
|
snapshot = oracle.get('boundary_snapshot')
|
|
require(type(snapshot) is dict and set(snapshot) == {'v','g','ref','counts','spike_ring','apl_state','apl_pending'}, 'Missing live boundary snapshot')
|
|
for name in ('v','g','ref','counts'):check('boundary.live_parent.'+name,bit_equal(snapshot[name],parent['state'][name]))
|
|
for name in ('spike_ring','apl_state','apl_pending'):check('boundary.live_parent.'+name,bit_equal(snapshot[name],parent['terminal'][name]))
|
|
report, provenance = oracle.get('boundary_report'), oracle.get('oracle_provenance')
|
|
require(type(report) is dict and type(provenance) is dict, 'Missing explicit oracle provenance/report')
|
|
paired=None
|
|
authority_matches=(C._sha(cs.get('boundary_authority_sha256')) and
|
|
provenance.get('authority_sha256')==cs['boundary_authority_sha256'])
|
|
if paired_authorities is not None:
|
|
paired=_paired_authorities(paired_authorities,provenance.get('authority_sha256'),
|
|
cs.get('boundary_authority_sha256'),cs['diagnostic_mode'])
|
|
authority_matches=paired['pass_all']
|
|
check('oracle.boundary_metadata',report.get('complete') is True and report.get('boundary_tick') == cut and
|
|
report.get('parent_checkpoint_manifest_sha256') == parent['manifest_sha256'] and report.get('restore_called') is False and
|
|
report.get('initial_state_replaced') is False and report.get('queues_replaced') is False and report.get('existing_weights_replaced_once') is True and
|
|
report.get('before_effective_sha256') == expected_before_sha256 and report.get('after_effective_sha256') == expected_after_sha256)
|
|
check('oracle.authority_matches_child',provenance.get('schema') == 'conditioning-live-boundary-oracle-v1' and
|
|
provenance.get('complete') is True and provenance.get('restore_called') is False and
|
|
provenance.get('prefix_sparse_events_exact') is True and provenance.get('learning_pass_claimed') is False and
|
|
authority_matches)
|
|
for label,record,start,stop in (('prefix',parent,0,cut),('suffix',continuation,cut,cut+steps)):
|
|
req=oracle['requests'];lo,hi=np.searchsorted(req[:,0],(start,stop))
|
|
actual=record['requests'].copy();actual[:,0]+=start
|
|
check(label+'.requests_all_five_fields',bit_equal(actual,req[lo:hi]))
|
|
if record.get('traces'):
|
|
for name in C.TRACE_FILES:check(label+'.trace.'+name,bit_equal(record['traces'][name],oracle['traces'][name][start:stop]))
|
|
if record.get('state_hashes') is not None:
|
|
check(label+'.state_hashes',all(all(row[key]==oracle['state_hashes'][start+t][key] for key in C.HASH_FIELDS)
|
|
for t,row in enumerate(record['state_hashes'])))
|
|
if record.get('queues') is not None:
|
|
check(label+'.queue_order_acceptance',all(all(row[key]==oracle['queues'][start+t][key] for key in C.QUEUE_FIELDS)
|
|
for t,row in enumerate(record['queues'])))
|
|
consume=min(steps,18)
|
|
if reference:check('boundary.applied_parent_APL',bit_equal(continuation['traces']['applied'][:consume],parent['terminal']['apl_pending'][:consume]))
|
|
if steps<18:check('boundary.unconsumed_parent_APL',bit_equal(continuation['terminal']['apl_pending'][:18-steps],parent['terminal']['apl_pending'][steps:]))
|
|
if steps<19:check('boundary.unwritten_parent_spike_slots',bit_equal(continuation['terminal']['spike_ring'][steps:],C.normalized_ring(parent['terminal'])[steps:]))
|
|
exact=all(checks.values())
|
|
return dict(schema='conditioning-live-vs-restored-comparison-v1',pass_all=exact,numerical_exact=exact,
|
|
status='EXACT-RECORDED-BOUNDARY-SCOPE-NOT-LEARNING' if exact else 'FAIL-BOUNDARY-NUMERICAL',checks=checks,
|
|
failed_checks=[k for k,v in checks.items() if not v],boundary_tick=cut,suffix_steps=steps,neurons=n,
|
|
child_mode=cs['diagnostic_mode'],suffix_reference_diagnostics_compared=reference,
|
|
paired_authority_audit=paired,
|
|
light_intermediate_states_observed=False,light_per_tick_identity_claimed=False,
|
|
queue_joint_hash_compared=False,queue_joint_hash_exclusion='Local tick headers differ; independent audit checks each actual header',
|
|
changed_candidate_pending_arrival_coverage_verified=False,external_file_authority_verified_here=False,
|
|
independent_membrane_replay_performed=False,learning_pass_claimed=False,candidate_generated=False)
|
|
|
|
|
|
def _effective_hash(base, apl, rows, values):
|
|
h=hashlib.sha256()
|
|
for start in range(0,len(base),1<<18):
|
|
stop=min(start+(1<<18),len(base));a=np.array(base[start:stop],copy=True)
|
|
a[apl[start:stop]]=np.float64(0)
|
|
lo,hi=np.searchsorted(rows,(start,stop));a[rows[lo:hi]-start]=values[lo:hi]
|
|
h.update(np.ascontiguousarray(a,dtype='<f8').tobytes())
|
|
return h.hexdigest()
|
|
|
|
|
|
def _candidates(ptr,src,dst,edge_id,base,apl,ids,before,after,Q):
|
|
n,e=Q._graph(ptr,dst,edge_id,base)
|
|
require(isinstance(src,np.ndarray) and src.dtype==np.int32 and src.shape==(e,), 'Invalid actual CSR source array')
|
|
require(isinstance(apl,np.ndarray) and apl.dtype==np.bool_ and apl.shape==(e,), 'Invalid fast APL mask')
|
|
for start in range(0,e,1<<18):
|
|
stop=min(start+(1<<18),e)
|
|
expected=np.searchsorted(ptr[1:],np.arange(start,stop,dtype=np.int64),side='right')
|
|
require(np.array_equal(src[start:stop],expected),'Source array disagrees with original CSR ordering')
|
|
require(isinstance(ids,np.ndarray) and ids.dtype==np.int64 and ids.ndim==1 and len(ids)>0 and
|
|
np.all(ids>=0) and np.all(ids[1:]>ids[:-1]),'Candidate IDs must preserve canonical sorted unique order')
|
|
for name,a in (('before',before),('after',after)):
|
|
require(isinstance(a,np.ndarray) and a.dtype==np.float32 and a.shape==ids.shape and
|
|
np.isfinite(a).all() and np.all(a<=0),'Invalid f32 mV delta '+name)
|
|
require(np.all(after<=before),'This diagnostic admits only existing depression, not potentiation')
|
|
rows=np.searchsorted(edge_id,ids)
|
|
require(np.all(rows<e) and np.array_equal(edge_id[rows],ids),'Candidate missing from actual graph')
|
|
require(not np.any(apl[rows]) and np.all(base[rows]>0),'Candidate overlaps APL or has nonpositive original weight')
|
|
values=[]
|
|
for delta in (before,after):
|
|
a=base[rows].copy();nz=delta!=np.float32(0)
|
|
a[nz]=np.add(a[nz],np.multiply(delta[nz].astype(np.float64),np.float64(.001)))
|
|
require(np.isfinite(a).all() and np.all(a>0),'Effective candidate weight changed sign/nonfinite')
|
|
values.append(a)
|
|
return n,e,rows,values[0],values[1]
|
|
|
|
|
|
def audit_changed_pending(parent,child,*,ptr,src,dst,edge_id,base_weights,apl_mask,
|
|
candidate_edge_id,delta_before,delta_after,input_pins):
|
|
"""Conditional ref/request/CSR audit plus a changed-edge crossing witness.
|
|
|
|
Post-threshold ref=22 precedes arrivals; requests use prior ref<=1. Every
|
|
real edge remains in source/CSR order, including rejected/zero weights.
|
|
Witnesses require an actual numeric effective-weight change and accepted
|
|
arrival emitted before cut and arriving within the child. This is not a
|
|
unique-cause claim and does not independently predict membrane spikes.
|
|
"""
|
|
require(type(input_pins)is dict and input_pins and all(type(k)is str and C._sha(v) for k,v in input_pins.items()),'Caller input anchors required')
|
|
Q=_load('engineering_queue_audit.py',PINS['engineering_queue_audit.py'])
|
|
for record in (parent,child):_complete(record)
|
|
n,e,rows,before,after=_candidates(ptr,src,dst,edge_id,base_weights,apl_mask,candidate_edge_id,delta_before,delta_after,Q)
|
|
require(parent['global_tick_offset']==0 and child['global_tick_offset']==parent['steps'],'Fresh parent / exact child boundary required')
|
|
require(len(parent['state']['v'])==len(child['state']['v'])==n,'Record/graph population mismatch')
|
|
require(all(type(record['summary'].get('edges')) is int and record['summary']['edges']==e for record in (parent,child)),
|
|
'Record/graph edge count differs')
|
|
cut,total=parent['steps'],parent['steps']+child['steps']
|
|
require(total<=np.iinfo(np.int32).max,'Diagnostic clock exceeds exact int32 event range')
|
|
before_sha=_effective_hash(base_weights,apl_mask,rows,before);after_sha=_effective_hash(base_weights,apl_mask,rows,after)
|
|
require(parent['summary'].get('effective_weights_raw_sha256')==before_sha and
|
|
child['summary'].get('effective_weights_raw_sha256')==after_sha,'Delta/base arithmetic mismatches actual runtime effective SHA')
|
|
changed=(before.view(np.uint64)!=after.view(np.uint64)) & (before!=after)
|
|
changed_rows=rows[changed];changed_ids=candidate_edge_id[changed]
|
|
effective=base_weights.copy();effective[apl_mask]=np.float64(0);effective[rows]=after
|
|
tick=np.concatenate((parent['state']['step'],child['state']['step']+np.int32(cut)))
|
|
node=np.concatenate((parent['state']['neuron_idx'],child['state']['neuron_idx']))
|
|
request=np.concatenate((parent['requests'],child['requests']+np.array([cut,0,0,0,0],np.int64)))
|
|
ref=np.zeros(n,np.int32);differences=[];difference_count=0
|
|
def check(ok,field,t):
|
|
nonlocal difference_count
|
|
if not ok:
|
|
difference_count+=1
|
|
if len(differences)<60:differences.append(dict(field=field,global_tick=t))
|
|
coverage=dict(changed_candidate_crossing_arrivals=0,accepted_changed_candidate_crossing_arrivals=0,
|
|
rejected_changed_candidate_crossing_arrivals=0,first_witness=None)
|
|
full=all(record.get('queues') is not None and record.get('state_hashes') is not None for record in (parent,child))
|
|
for t in range(total):
|
|
record,local=(parent,t) if t<cut else (child,t-cut)
|
|
rlo,rhi=np.searchsorted(request[:,0],(t,t+1));requested=request[rlo:rhi,1]
|
|
accepted=ref[requested]<=1
|
|
expected=request[rlo:rhi].copy();expected[:,2]=1;expected[:,3]=accepted;expected[:,4]=~accepted
|
|
check(bit_equal(request[rlo:rhi],expected),'request.acceptance',t)
|
|
np.maximum(ref-np.int32(1),np.int32(0),out=ref)
|
|
lo,hi=np.searchsorted(tick,(t,t+1));fired=node[lo:hi]
|
|
check(np.all(ref[fired]==0),'spike_during_refractory',t)
|
|
check(np.isin(requested[accepted],fired,assume_unique=True).all(),'accepted_request_without_spike',t)
|
|
ref[fired]=22
|
|
lo,hi=np.searchsorted(tick,(t-18,t-17));sources=node[lo:hi] if t>=18 else node[:0]
|
|
qrows,_,_=Q._queue(t,local,sources,ref,ptr,dst,edge_id,effective,[])
|
|
expected_queue=qrows[0] if t<cut else qrows[1]
|
|
if record.get('queues') is not None:
|
|
check(record['queues'][local]==expected_queue,'source_ordered_queue_all_fields',t)
|
|
if record.get('state_hashes') is not None:
|
|
check(record['state_hashes'][local]['ref_sha256']==_raw(ref),'ref_hash',t)
|
|
if local==record['steps']-1:check(bit_equal(record['state']['ref'],ref),'final_ref',t)
|
|
if t-18<cut<=t and t<total:
|
|
for source in sources:
|
|
lo,hi=np.searchsorted(changed_rows,(ptr[source],ptr[source+1]))
|
|
for at in range(int(lo),int(hi)):
|
|
row=int(changed_rows[at]);target=int(dst[row]);accepted_edge=ref[target]==0
|
|
coverage['changed_candidate_crossing_arrivals']+=1
|
|
coverage['accepted_changed_candidate_crossing_arrivals' if accepted_edge else 'rejected_changed_candidate_crossing_arrivals']+=1
|
|
if accepted_edge and coverage['first_witness'] is None:
|
|
original=int(np.searchsorted(rows,row))
|
|
coverage['first_witness']=dict(global_edge_id=int(changed_ids[at]),csr_row=row,
|
|
source_neuron_idx=int(source),target_neuron_idx=target,source_spike_global_tick=t-18,
|
|
arrival_global_tick=t,arrival_child_local_tick=t-cut,post_threshold_target_ref=0,accepted=True,
|
|
before_weight_SI_volt=float(before[original]),after_weight_SI_volt=float(after[original]),
|
|
before_weight_f64_le_hex=np.asarray(before[original],dtype='<f8').tobytes().hex(),
|
|
after_weight_f64_le_hex=np.asarray(after[original],dtype='<f8').tobytes().hex(),
|
|
delta_before_f32_mv_hex=np.asarray(delta_before[original],dtype='<f4').tobytes().hex(),
|
|
delta_after_f32_mv_hex=np.asarray(delta_after[original],dtype='<f4').tobytes().hex(),
|
|
unique_cause_or_necessity_claim=False)
|
|
exact=difference_count==0;witness=coverage['first_witness'] is not None;passed=exact and full and witness
|
|
return dict(schema='conditioning-changed-pending-edge-audit-v1',pass_all=passed,
|
|
status='FAIL-QUEUE-REF-REQUEST' if not exact else ('PASS-CHANGED-PENDING-EDGE-SCOPE' if passed else 'INCOMPLETE-CHANGED-EDGE-COVERAGE'),
|
|
conditional_ref_request_queue_exact=exact,reference_queue_and_ref_coverage_complete=full,
|
|
accepted_changed_edge_witness_verified=passed,difference_count=difference_count,differences=differences,
|
|
differences_truncated=difference_count>len(differences),coverage=coverage,neurons=n,edges=e,boundary_tick=cut,
|
|
changed_delta_bit_count=int(np.count_nonzero(delta_before.view(np.uint32)!=delta_after.view(np.uint32))),
|
|
changed_effective_numeric_count=int(changed.sum()),before_effective_sha256=before_sha,after_effective_sha256=after_sha,
|
|
supplied_input_pins=dict(input_pins),array_raw_sha256={key:_raw(a) for key,a in dict(ptr=ptr,src=src,dst=dst,edge_id=edge_id,
|
|
base_weights=base_weights,apl_mask=apl_mask,candidate_edge_id=candidate_edge_id,delta_before=delta_before,delta_after=delta_after).items()},
|
|
delay_steps=18,refractory_steps=22,actual_membrane_dynamics_independently_replayed=False,
|
|
observed_spikes_condition_the_audit=True,external_file_authority_verified_here=False,learning_pass_claimed=False)
|