qishizhe/digital-drosophila
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Seal AO interface failure and verified isolated postprocessing diagnosis

Browse Source
This commit is contained in:
Digital Drosophila Archive
2026-09-30 17:57:02 +08:00
parent 4ff241bdc9
commit 8e9f8f4d56
126 changed files with 92124 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
registry/phase4ao-conditioning-interface/source-snapshot/conditioning_preflight_compare.py
+247
View File
@@ -0,0 +1,247 @@
"""Pure CPU comparisons for a separately authorized, finite input/update test.
No files, checkpoint seals, source pins, parent trees or GPU are read here.
The coordinator must first verify subprocess receipts, externally pinned
checkpoint manifests, registered source/input files and learned-parent chains.
It must independently recompute update receipts with conditioning_update's
verify_receipt. These functions bind supplied arrays and declared metadata;
they cannot replace those external checks or prove functional learning.
The frozen engineering comparator is reused unchanged. Reference diagnostics
must be complete. Light has events, final state and queues, not per-tick V/g
or APL histories; missing light observations are never fabricated as exact.
"""
from __future__ import annotations
import hashlib
import json
import re
import numpy as np
import engineering_compare as C
N, E, N_KC, CANDIDATE_COUNT = 166700, 25582938, 4064, 14232
COMPARATOR_SHA256 = "5a2403f11bc08d65a9d242ac2cf9686b850e0c3680d65659f785e9b6b50c0238"
PHASE4J_SHA256 = "abb4574da85f00bd9ef61024c65993ef81d42651ff8d8d63c15dd69c6222471e"
ELIGIBILITY_BRIDGE_SHA256 = "174fb8d14619189e74b095e77a6db18b14c93046dc431c0b55710a5aa2dd2e61"
MASK_SHA256 = "8b0fb6eb2e6c31da4d17dc20d890aa3f367e514f05642de5bad6b42a1611c05b"
AM_OVERLAY_SHA256 = "7f891d0ba79b393c96e75fd2dee2eddc51e57d8213eaac2779703bc2c18712b4"
MANIFEST_FIELDS = frozenset(("schema", "overlay_name", "overlay_sha256", "mask_path", "mask_sha256",
"base_candidate_path", "base_candidate_sha256", "aj_model_dir", "am_overlay_path", "am_overlay_sha256",
"parent_snapshot_sha256", "eligibility_v2_source_sha256"))
def _require(condition, message):
if not condition:
raise ValueError(message)
def _canonical(value):
return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False)
def _sha(value):
return hashlib.sha256(_canonical(value).encode("utf-8")).hexdigest()
def _valid_sha(value):
return type(value) is str and re.fullmatch("[0-9a-f]{64}", value) is not None
def _evidence(value):
return dict(dtype=value.dtype.str, shape=list(value.shape), nbytes=int(value.nbytes),
raw_c_order_sha256=hashlib.sha256(value.tobytes(order="C")).hexdigest())
def _integer(mapping, key, expected):
return type(mapping.get(key)) is int and mapping[key] == expected
def _request_input(value, steps):
_require(isinstance(value, np.ndarray) and value.dtype == np.int32 and value.ndim == 2 and value.shape[1] == 2,
"Expected input requests must be exact int32 [M,2] (local tick, global neuron)")
_require(np.all((value[:, 0] >= 0) & (value[:, 0] < steps)) and
np.all((value[:, 1] >= 0) & (value[:, 1] < N)), "Expected input request is out of range")
keys = value[:, 0].astype(np.int64) * N + value[:, 1]
_require(len(keys) < 2 or np.all(keys[1:] > keys[:-1]), "Expected requests must already be sorted unique")
def compare_epoch_pair(reference_record, light_record, *, expected_requests, expected_steps,
expected_effective_weight_sha256):
"""Compare fresh reference/light records, not paths or self-asserted seals.
Inputs are dictionaries returned by frozen engineering_compare.load_run.
The coordinator supplies the original registered request array and the
independently expected effective-weight raw SHA, not a value copied from
the summary being checked. Corrupt array schemas raise ValueError. Valid
but different records return numerical_exact/pass_all=False. pass_all is
ONLY the supplied-record identity check, not a learning or activity gate.
"""
_require(type(expected_steps) is int and 0 < expected_steps <= np.iinfo(np.int32).max,
"Explicit expected epoch steps required")
_require(_valid_sha(expected_effective_weight_sha256), "Expected effective-weight raw SHA is required")
_request_input(expected_requests, expected_steps)
_require(type(reference_record) is dict and type(light_record) is dict,
"Supply already authenticated loaded records, not paths")
C.validate_run(reference_record)
C.validate_run(light_record)
inherited = C.compare_fresh(light_record, reference_record)
checks = dict(inherited["checks"])
for label, record, mode in (("reference", reference_record, "reference"), ("light", light_record, "light")):
summary = record.get("summary")
_require(type(summary) is dict, "Missing runtime summary")
checks[label + ".full_population"] = len(record["state"]["v"]) == N and _integer(summary, "nodes", N) and _integer(summary, "edges", E)
checks[label + ".expected_clock"] = (record["steps"] == expected_steps and record["global_tick_offset"] == 0 and
_integer(summary, "steps", expected_steps) and _integer(summary, "completed_ticks", expected_steps) and
_integer(summary, "explicit_steps_executed", expected_steps))
checks[label + ".fresh_fixed_weight_scope"] = (summary.get("checkpoint_continuation_used") is False and
summary.get("within_trial_weight_updates") is False and summary.get("hidden_early_stop") is False and
summary.get("entire_neural_trial_executed") is True and summary.get("record_history") is False and
summary.get("parent_checkpoint_manifest_sha256") is None)
checks[label + ".mode_precision_delay"] = (summary.get("diagnostic_mode") == mode and
summary.get("precision") == "float64" and summary.get("apl_precision") == "float32" and
_integer(summary, "apl_delay_steps", 18) and summary.get("state_units") == "SI volts")
checks[label + ".complete_reported_finite"] = (summary.get("complete") is True and summary.get("pass_all") is True and
summary.get("all_finite") is True and _integer(summary, "first_failure_tick", -1))
checks[label + ".effective_weight_authority"] = summary.get("effective_weights_raw_sha256") == expected_effective_weight_sha256
checks[label + ".input_request_array"] = np.array_equal(record["requests"][:, :2], expected_requests.astype(np.int64))
checks[label + ".request_and_spike_accounting"] = (summary.get("counts_match_sparse_events") is True and
_integer(summary, "total_spikes", len(record["state"]["step"])) and
_integer(summary, "requested", len(expected_requests)) and
_integer(summary, "accepted_requests", int(record["requests"][:, 3].sum(dtype=np.int64))) and
_integer(summary, "rejected_requests", int(record["requests"][:, 4].sum(dtype=np.int64))))
checks[label + ".recorded_full_APL_terminal"] = (record.get("terminal_origin") == "recorded_terminal_queues" and
record["terminal"]["apl_pending"].shape == (18, N_KC))
full = reference_record
full_summary = full["summary"]
checks["reference.full_diagnostics"] = (set(full["traces"]) == set(C.TRACE_FILES) and
full.get("state_hashes") is not None and full.get("queues") is not None and
all(full_summary.get(key) is True for key in
("full_APL_history_recorded", "full_tick_state_hashes_recorded", "full_queue_hashes_recorded", "full_sequence_bitwise_audit_performed")))
if full.get("queues") is not None:
checks["reference.queue_summary_accounting"] = (
_integer(full_summary, "arriving_edges", sum(row["count"] for row in full["queues"])) and
_integer(full_summary, "accepted_arriving_edges", sum(row["accepted_count"] for row in full["queues"])))
else:
checks["reference.queue_summary_accounting"] = False
light_summary = light_record["summary"]
checks["light.declared_recording_scope"] = (not light_record["traces"] and
light_record.get("state_hashes") is None and light_record.get("queues") is None and
all(light_summary.get(key) is False for key in
("full_APL_history_recorded", "full_tick_state_hashes_recorded", "full_queue_hashes_recorded", "full_sequence_bitwise_audit_performed")))
for label, summary in (("reference", full_summary), ("light", light_summary)):
inputs = summary.get("input_sha256")
checks[label + ".input_hash_schema"] = (type(inputs) is dict and
set(inputs) == {"base_weights.npy", "coefficients.json", "requests.npz", "spec.json"} and
all(_valid_sha(value) for value in inputs.values()))
for name in ("base_weights.npy", "coefficients.json"):
left = full_summary.get("input_sha256", {}).get(name)
right = light_summary.get("input_sha256", {}).get(name)
checks["pair.input." + name] = _valid_sha(left) and left == right
for name in ("arriving_edges", "accepted_arriving_edges"):
checks["pair.summary." + name] = (type(full_summary.get(name)) is int and
type(light_summary.get(name)) is int and full_summary[name] == light_summary[name])
checks = {key: bool(value) for key, value in checks.items()}
exact = all(checks.values())
return dict(schema="conditioning-preflight-epoch-comparison-v1", numerical_exact=exact, pass_all=exact,
status="EXACT-RECORDED-EPOCH-PAIR-NOT-LEARNING" if exact else "FAIL-EPOCH-COMPARISON",
checks=checks, failed_checks=[key for key, ok in checks.items() if not ok],
expected_steps=expected_steps, expected_requests=_evidence(expected_requests),
expected_effective_weight_raw_sha256=expected_effective_weight_sha256,
recorded_pair_availability=inherited["reference_comparisons_available"],
activity=inherited["activity"], nonvacuous_activity=inherited["nonvacuous_activity"],
activity_is_descriptive_not_a_new_gate=True,
full_reference_diagnostics_required=True, light_intermediate_states_observed=False,
light_per_tick_V_g_ref_identity_claimed=False, independent_finite_latch_replay_performed=False,
independent_CSR_queue_reconstruction_performed=False,
independent_wholebrain_CPU_oracle_performed=False,
expected_comparator_source_sha256=COMPARATOR_SHA256, source_pin_verified_here=False,
external_file_seals_process_and_input_authority_verified_here=False,
input_generator_or_parent_delta_chain_verified_here=False,
learning_pass_claimed=False, candidate_generated=False,
scope="Supplied fresh epoch records and original requests only; prerequisite external checkpoint/source/parent verification belongs to coordinator")
def _delta(value, name):
_require(isinstance(value, np.ndarray) and value.dtype == np.float32 and value.shape == (CANDIDATE_COUNT,) and
np.isfinite(value).all(), name + " must be the full finite float32 candidate delta vector")
def audit_delta_binding(delta_before, delta_after, installed_delta, *, update_receipt,
parent_snapshot_sha256, child_manifest):
"""Bind already computed/installed arrays to receipt and learned metadata.
parent_snapshot_sha256 means the actual PARENT OVERLAY NPZ file hash,
externally established by the coordinator, NOT a checkpoint manifest hash
and NOT a raw delta-array hash. installed_delta must come from the child
overlay subsequently checked by frozen runtime_light.load_overlay.
This function does not read those files, authenticate anatomical IDs,
recompute eligibility-v2, establish clipping bounds, or prove a causal
behavioral effect. Call conditioning_update.verify_receipt separately
against actual sealed epoch events and complete pinned mappings.
"""
for name, value in (("delta_before", delta_before), ("delta_after", delta_after), ("installed_delta", installed_delta)):
_delta(value, name)
_require(_valid_sha(parent_snapshot_sha256), "Externally established parent overlay FILE SHA is required")
_require(type(update_receipt) is dict and type(child_manifest) is dict, "Receipt and manifest must be dictionaries")
_require(type(update_receipt.get("input_arrays")) is dict and type(update_receipt.get("outputs")) is dict and
type(update_receipt.get("source_pins")) is dict and type(update_receipt.get("command")) is dict and
type(update_receipt.get("semantics")) is dict and type(update_receipt.get("counts")) is dict,
"Incomplete epoch update receipt schema")
before, after, installed = (_evidence(value) for value in (delta_before, delta_after, installed_delta))
command = update_receipt["command"]
counts = update_receipt["counts"]
checks = {
"receipt.self_hash": update_receipt.get("payload_sha256") == _sha({k: v for k, v in update_receipt.items() if k != "payload_sha256"}),
"receipt.schema": update_receipt.get("schema") == "phase4an-conditioning-update-draft-v1" and
update_receipt.get("status") == "DRAFT-COMPUTED-EPOCH-UPDATE-NOT-INSTALLED",
"receipt.original_source_pins": update_receipt["source_pins"] == {
"eligibility_bridge_sha256": ELIGIBILITY_BRIDGE_SHA256, "phase4j_sha256": PHASE4J_SHA256},
"receipt.delta_before": _canonical(update_receipt["input_arrays"].get("delta_before")) == _canonical(before),
"receipt.delta_after": _canonical(update_receipt["outputs"].get("delta_after")) == _canonical(after),
"computed_installed_delta_bitwise": C.bit_equal(delta_after, installed_delta),
"delta.nonpositive": bool(np.all(delta_before <= 0) and np.all(delta_after <= 0)),
"delta.no_potentiation": bool(np.all(delta_after <= delta_before)),
"receipt.candidate_count": _integer(counts, "candidates", CANDIDATE_COUNT),
"receipt.changed_bit_count": _integer(counts, "actual_bitwise_changed_edges", int(np.count_nonzero(delta_before.view(np.uint32) != delta_after.view(np.uint32)))),
"receipt.changed_value_count": _integer(counts, "actual_value_changed_edges", int(np.count_nonzero(delta_before != delta_after))),
"receipt.explicit_scheduled_D": type(command.get("D_scheduled")) is float and command["D_scheduled"] in (0.0, 1.0) and
type(command.get("frozen")) is bool,
"receipt.epoch_boundary_only": update_receipt["semantics"].get("application") == "epoch_boundary_after_all_recorded_ticks; affects subsequent epoch only" and
update_receipt["semantics"].get("delta_dtype") == "float32" and update_receipt["semantics"].get("delta_units") == "mV",
"receipt.not_a_DAN_measurement": update_receipt["semantics"].get("D_definition") == "artificial scheduled scalar" and
update_receipt["semantics"].get("actual_DAN_delivery_observed") is False and
update_receipt["semantics"].get("actual_DAN_delivery_used_to_gate") is False,
"manifest.exact_fields": set(child_manifest) == MANIFEST_FIELDS,
"manifest.learned_schema": child_manifest.get("schema") == "phase4an-overlay-v1" and child_manifest.get("overlay_name") == "learned",
"manifest.parent_overlay_file_sha": child_manifest.get("parent_snapshot_sha256") == parent_snapshot_sha256,
"manifest.frozen_rule_mask_helper": child_manifest.get("eligibility_v2_source_sha256") == PHASE4J_SHA256 and
child_manifest.get("mask_sha256") == MASK_SHA256 and child_manifest.get("am_overlay_sha256") == AM_OVERLAY_SHA256,
"manifest.declared_file_hashes": all(_valid_sha(child_manifest.get(key)) for key in ("overlay_sha256", "base_candidate_sha256")),
"manifest.declared_paths": all(type(child_manifest.get(key)) is str and bool(child_manifest[key])
for key in ("mask_path", "base_candidate_path", "aj_model_dir", "am_overlay_path")),
}
no_update = command.get("frozen") is True or command.get("D_scheduled") == 0.0
checks["zero_D_or_frozen_identity"] = not no_update or C.bit_equal(delta_before, delta_after)
for name in ("weights_installed", "base_modified", "brain_dynamics_executed", "scientific_learning_pass_claimed", "candidate_generated"):
checks["receipt.scope." + name] = update_receipt.get(name) is False
checks = {key: bool(value) for key, value in checks.items()}
exact = all(checks.values())
return dict(schema="conditioning-preflight-delta-binding-v1", pass_all=exact,
status="EXACT-DELTA-ARRAY-BINDING-NOT-LEARNING" if exact else "FAIL-DELTA-BINDING",
checks=checks, failed_checks=[key for key, ok in checks.items() if not ok],
delta_before=before, computed_delta_after=after, installed_delta=installed,
parent_overlay_file_sha256=parent_snapshot_sha256,
declared_child_overlay_file_sha256=child_manifest.get("overlay_sha256"),
update_receipt_payload_sha256=update_receipt.get("payload_sha256"),
actual_changed_edges=int(np.count_nonzero(delta_before != delta_after)),
actual_bitwise_changed_edges=int(np.count_nonzero(delta_before.view(np.uint32) != delta_after.view(np.uint32))),
delta_nonzero_or_change_is_not_learning_evidence=True,
eligibility_v2_independently_recomputed_here=False, full_mask_identity_verified_here=False,
candidate_order_or_compartment_mapping_verified_here=False, floor_bound_independently_verified_here=False,
file_bytes_and_parent_snapshot_authority_verified_here=False, installation_in_runtime_verified_here=False,
actual_DAN_delivery_verified_here=False, learning_pass_claimed=False, candidate_generated=False,
scope="Supplied float32 mV arrays and declared parent/update metadata only; coordinator must verify real files, v2 recomputation and next-epoch installation")