"""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)