Digital Drosophila Archive
256 lines
16 KiB
Python
256 lines
16 KiB
Python
"""Post-seal descriptive extraction; not another scientific gate or model run.
|
|
|
|
The four original CAL summary dictionaries are copied, not recalculated.
|
|
Origin totals use only the earliest-cohort/pre-first-KC audit window from
|
|
the 60 sealed AG-r2 control trials. No AI population/window share is imported.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from collections import Counter
|
|
import hashlib
|
|
import importlib.util
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
|
|
|
|
ROOT = Path('/data/digital-drosophila')
|
|
MODEL_RELATIVE = Path('models/male-cns-lif/apl-timing-lab-v1')
|
|
EXPERIMENT_RELATIVE = Path('experiments/phase4aj-apl-timing')
|
|
REGISTRY_RELATIVE = Path('registry/phase4aj-apl-timing')
|
|
HELPER_RELATIVE = Path('models/male-cns-lif/pn-recruitment-audit-v1/publication.py')
|
|
HELPER_SHA256 = '7a79c499098b74163e7bb16adabcbc54e7069dafa204d0b99c7f4c03d79f8016'
|
|
LEGACY_CALIBRATION_SHA256 = 'edb9cb2d890471fd07afd88c959ef3540b0cd40af490fac3f26396b5e7f5bf9c'
|
|
MODES = ('physiological', 'matched_energy')
|
|
ARMS = ('delay0', 'delay18')
|
|
CAL_MODE_FIELDS = frozenset(('KC_active_fraction_mean', 'KC_active_fraction_min', 'KC_active_fraction_max',
|
|
'same_odor_jaccard_mean', 'different_odor_jaccard_mean', 'same_odor_euclidean_mean',
|
|
'different_odor_euclidean_mean', 'different_odor_cosine_mean', 'different_odor_correlation_mean',
|
|
'within_variance', 'between_distance_mean', 'pairwise_separation_pass_count', 'pair_count',
|
|
'expected_event_count_cv', 'actual_event_count_cv', 'within_distance_count', 'between_distance_count',
|
|
'pairwise_baseline', 'pairs', 'conditions', 'gate'))
|
|
WINDOW = 'cohort_pre_KC_and_pre_first'
|
|
GROUP_FIELDS = ('events', 'positive_events', 'negative_events', 'positive_weight_SI', 'negative_abs_weight_SI')
|
|
OUTGOING_FIELDS = ('cohort_ALLN_outgoing_events', 'outgoing_events_with_since_reset_design_antecedent',
|
|
'outgoing_events_without_since_reset_design_antecedent', 'compact_join_pair_count')
|
|
RELATIONS = frozenset(('no_non_design_spike', 'KC_unobserved', 'before', 'same_tick', 'after'))
|
|
MAX_BYTES = 4 * 1024 ** 2
|
|
|
|
|
|
def require(ok, message):
|
|
if not ok:
|
|
raise ValueError(message)
|
|
|
|
|
|
def load_helpers(path):
|
|
path = Path(path)
|
|
require(path.is_absolute() and path.is_file() and not path.is_symlink(), 'Invalid frozen verification helper')
|
|
source = path.read_bytes()
|
|
require(hashlib.sha256(source).hexdigest() == HELPER_SHA256, 'Frozen AI helper hash mismatch')
|
|
spec = importlib.util.spec_from_file_location('phase4aj_describe_frozen_ai_helpers', path)
|
|
require(spec is not None and spec.loader is not None, 'Cannot define frozen helper module')
|
|
module = importlib.util.module_from_spec(spec)
|
|
# Exact pinned bytes; no pyc read/write in the old sealed model directory.
|
|
exec(compile(source, str(path), 'exec'), module.__dict__)
|
|
return module
|
|
|
|
|
|
def _boolean_fields(value):
|
|
return {key: item for key, item in value.items() if type(item) is bool}
|
|
|
|
|
|
def _nonnegative_integer(value, field):
|
|
require(type(value) is int and value >= 0, 'Invalid nonnegative count: ' + field)
|
|
return value
|
|
|
|
|
|
def aggregate_origin(trials):
|
|
"""Sum stored audit totals, retaining source labels and the fixed window.
|
|
|
|
These are descriptive sums of already aggregated nominal weights. They
|
|
have no arithmetic-error-bound, membrane-effect, or causal interpretation.
|
|
"""
|
|
groups = {}
|
|
relations = Counter()
|
|
outgoing = {field: 0 for field in OUTGOING_FIELDS}
|
|
before_trials = before_neurons = censored = cohort_occurrences = 0
|
|
per_trial = []
|
|
for trial in trials:
|
|
source = trial['window_source_accounting'][WINDOW]
|
|
require(isinstance(source, dict), 'Origin source groups must be a dictionary')
|
|
for label, values in source.items():
|
|
require(isinstance(label, str) and set(values) == set(GROUP_FIELDS), 'Unexpected origin source-group schema')
|
|
target = groups.setdefault(label, {key: [] for key in GROUP_FIELDS})
|
|
for key in GROUP_FIELDS[:3]:
|
|
target[key].append(_nonnegative_integer(values[key], key))
|
|
require(values['positive_events'] + values['negative_events'] <= values['events'], 'Origin sign count exceeds events')
|
|
for key in GROUP_FIELDS[3:]:
|
|
require(type(values[key]) in (int, float) and math.isfinite(values[key]) and values[key] >= 0,
|
|
'Invalid nominal source weight: ' + key)
|
|
target[key].append(float(values[key]))
|
|
relation = trial['cohort_relation_to_first_KC']
|
|
require(relation in RELATIONS, 'Unknown earliest-cohort/first-KC relation')
|
|
require(type(trial['cohort_before_first_KC']) is bool and
|
|
trial['cohort_before_first_KC'] == (relation == 'before'), 'Inconsistent saved first-KC relation')
|
|
require(type(trial['pre_kc_window_censored']) is bool, 'Invalid saved censoring flag')
|
|
count = _nonnegative_integer(trial['cohort_neurons'], 'cohort_neurons')
|
|
relations[relation] += 1
|
|
cohort_occurrences += count
|
|
before_trials += int(trial['cohort_before_first_KC'])
|
|
before_neurons += count if trial['cohort_before_first_KC'] else 0
|
|
censored += int(trial['pre_kc_window_censored'])
|
|
for key in OUTGOING_FIELDS:
|
|
outgoing[key] += _nonnegative_integer(trial[key], key)
|
|
require(trial[OUTGOING_FIELDS[1]] + trial[OUTGOING_FIELDS[2]] == trial[OUTGOING_FIELDS[0]],
|
|
'Saved ALLN outgoing partition is inconsistent')
|
|
per_trial.append({key: trial[key] for key in ('case', 'mode', 'odor_id', 'seed', 'pass_all',
|
|
'first_any_KC_tick', 'earliest_tick', 'cohort_neurons', 'cohort_before_first_KC',
|
|
'cohort_relation_to_first_KC', 'pre_kc_window_censored', *OUTGOING_FIELDS)} |
|
|
{'source_groups': source, 'exact': trial['exact']})
|
|
totals = {label: {key: sum(parts[key]) if key in GROUP_FIELDS[:3] else math.fsum(parts[key])
|
|
for key in GROUP_FIELDS} for label, parts in sorted(groups.items())}
|
|
direct_pn = {key: sum(totals.get(label, {}).get(key, 0) for label in ('design_ALPN', 'non_design_ALPN'))
|
|
if key in GROUP_FIELDS[:3] else math.fsum(totals.get(label, {}).get(key, 0.0)
|
|
for label in ('design_ALPN', 'non_design_ALPN')) for key in GROUP_FIELDS}
|
|
return dict(trial_count=len(trials), source_window=WINDOW, source_groups=totals,
|
|
direct_ALPN_combined=direct_pn, direct_ALPN_labels=['design_ALPN', 'non_design_ALPN'],
|
|
first_before_KC_trial_count=before_trials, cohort_neuron_occurrences_before_first_KC=before_neurons,
|
|
cohort_neuron_occurrences_across_trials=cohort_occurrences,
|
|
first_KC_window_censored_trial_count=censored, cohort_relation_trial_counts=dict(sorted(relations.items())),
|
|
**outgoing, per_trial=per_trial,
|
|
absent_group_semantics='Producer emits only observed groups; an absent group contributes zero accepted events in this window',
|
|
nominal_weight_units='SI volts; accepted edge-weight increments, not membrane effect or causal contribution',
|
|
aggregation='Integer counts and math.fsum of saved per-trial nominal float totals; descriptive, no new roundoff-bound claim',
|
|
pair_count_semantics='Existing compact temporal join pairs; shared antecedents can recur for multiple outgoing edges, not unique causal chains')
|
|
|
|
|
|
def describe(root=ROOT, helper_path=None):
|
|
"""Write two exclusive post-publication files; never alter a seal/receipt."""
|
|
root = Path(root)
|
|
require(root.is_absolute() and root.is_dir() and not root.is_symlink(), 'Invalid project root')
|
|
root = root.resolve(strict=True)
|
|
model, experiment, registry = (root / item for item in (MODEL_RELATIVE, EXPERIMENT_RELATIVE, REGISTRY_RELATIVE))
|
|
output, checksum = registry / 'interpretation-metrics.json', registry / 'interpretation-metrics.sha256'
|
|
require(registry.is_dir() and not registry.is_symlink(), 'Publish the sealed evidence registry first')
|
|
require(not output.exists() and not output.is_symlink() and not checksum.exists() and not checksum.is_symlink(),
|
|
'Interpretation output already exists; no overwrite/resume')
|
|
for target in (model, experiment, registry):
|
|
path = root
|
|
for part in target.relative_to(root).parts:
|
|
path /= part
|
|
require(not path.is_symlink(), 'Symlink in descriptive source/output path')
|
|
helper_path = root / HELPER_RELATIVE if helper_path is None else Path(helper_path)
|
|
helper = load_helpers(helper_path)
|
|
verified = {'model': helper.verify_seal(model), 'experiment': helper.verify_seal(experiment)}
|
|
inventories = {name: {row['path']: row for row in verification['files']} for name, verification in verified.items()}
|
|
inputs = {}
|
|
|
|
def sealed_json(relative):
|
|
require(relative in inventories['experiment'], 'Required descriptive input absent from seal: ' + relative)
|
|
path = helper._regular_file(experiment, relative)
|
|
row = inventories['experiment'][relative]
|
|
inputs[relative] = row['sha256']
|
|
return helper._json_bytes(path.read_bytes())
|
|
|
|
status = sealed_json('audit/final-status.json')
|
|
calibration = sealed_json('calibration/summary.json')
|
|
origin = sealed_json('origin-audit/summary.json')
|
|
inventory = sealed_json('protocol/calibration-cases.json')
|
|
frozen = sealed_json('regression/frozen-five.json')
|
|
integrity = sealed_json('regression/old-integrity-after.json')
|
|
require(isinstance(status.get('status'), str) and status['status'].startswith(('PASS-', 'FAIL-', 'INCOMPLETE-')),
|
|
'Missing finalized status; publication is not a substitute for finalization')
|
|
require(status.get('candidate_generated') is False and status.get('learning_achieved') is False and
|
|
status.get('shared_APL_arithmetic_oracle_limitation') is True, 'Unexpected finalized scope')
|
|
require(calibration.get('legacy_calibration_sha256') == LEGACY_CALIBRATION_SHA256,
|
|
'CAL summary does not identify the sealed original metric implementation')
|
|
require(set(calibration['arms']) == set(ARMS), 'Both CAL arm summaries are required')
|
|
cal_modes = {}
|
|
arm_flags = {}
|
|
for arm in ARMS:
|
|
value = calibration['arms'][arm]
|
|
require(set(value['modes']) == set(MODES), 'Both original mode summaries are required: ' + arm)
|
|
# Preserve the complete existing dictionaries, including pairs, CV,
|
|
# conditions, gate and the original pairwise baseline description.
|
|
cal_modes[arm] = {mode: value['modes'][mode] for mode in MODES}
|
|
require(all(isinstance(value['modes'][mode], dict) and CAL_MODE_FIELDS.issubset(value['modes'][mode])
|
|
for mode in MODES), 'Incomplete saved original CAL mode summary')
|
|
arm_flags[arm] = _boolean_fields(value)
|
|
require(len(inventory) == 60 and len({row['name'] for row in inventory}) == 60, 'Require the fixed 60 CAL r0 cases')
|
|
names = {row['name']: row for row in inventory}
|
|
require(Counter(row['mode'] for row in inventory) == Counter({mode: 30 for mode in MODES}), 'Origin mode coverage changed')
|
|
require(len(origin['trials']) == 60 and {row['case'] for row in origin['trials']} == set(names),
|
|
'Origin trial inventory must match all 60 fixed control cases')
|
|
trials = []
|
|
for row in sorted(origin['trials'], key=lambda value: value['case']):
|
|
name = row['case']
|
|
require(helper._relative_name(name).name == name, 'Origin case must be a single relative name')
|
|
relative = 'origin-audit/' + name + '/summary.json'
|
|
trial = sealed_json(relative)
|
|
require(row['summary_sha256'] == inputs[relative], 'Origin receipt does not bind its sealed trial summary')
|
|
require(trial['case'] == name and trial['repeat'] == 0 and all(
|
|
trial[key] == names[name][key] for key in ('mode', 'odor_id', 'seed')), 'Origin case identity mismatch')
|
|
trials.append(trial)
|
|
receipt_path = helper._regular_file(registry, 'publication-receipt.json')
|
|
receipt_sha = helper._digest(receipt_path)
|
|
receipt = helper._json_bytes(receipt_path.read_bytes())
|
|
require(receipt.get('publication_complete') is True and receipt.get('declared_audit_status') == status['status'] and
|
|
all(receipt.get(name + '_manifest_sha256') == verified[name]['manifest_sha256']
|
|
for name in ('model', 'experiment')), 'Existing publication receipt belongs to different seals/status')
|
|
for row in receipt['files']:
|
|
path = helper._regular_file(registry, row['path'])
|
|
require(path.stat().st_size == row['bytes'] and helper._digest(path) == row['sha256'], 'Previously published evidence changed')
|
|
source_hashes = {'describe_phase4aj.py': helper._digest(Path(__file__)),
|
|
'frozen_AI_publication.py': HELPER_SHA256,
|
|
'sealed_AG_calibration.py': LEGACY_CALIBRATION_SHA256}
|
|
for name in ('al_origin_audit.py', 'calibration.py'):
|
|
require(name in inventories['model'], 'Registered metric-producing source absent from model seal: ' + name)
|
|
source_hashes['AJ_model/' + name] = inventories['model'][name]['sha256']
|
|
result = dict(kind='postseal-descriptive-interpretation-metrics', declared_final_status=status['status'],
|
|
final_status_boolean_flags=_boolean_fields(status), calibration_boolean_flags=_boolean_fields(calibration),
|
|
calibration_arm_boolean_flags=arm_flags, original_CAL_mode_summaries=cal_modes,
|
|
finalized_numerical_evidence={key: status[key] for key in ('gates', 'comparisons', 'repeats', 'controls', 'components')},
|
|
frozen_reference_report=frozen, frozen_integrity_report=integrity,
|
|
origin_audit_declared_status=origin['status'], origin_audit_boolean_flags=_boolean_fields(origin),
|
|
origin_scope='60 sealed AG-r2 control CAL r0 trials, 30 per mode; not a new delay18-origin audit',
|
|
origin_window=WINDOW, origin_all_modes=aggregate_origin(trials),
|
|
origin_by_mode={mode: aggregate_origin([trial for trial in trials if trial['mode'] == mode]) for mode in MODES},
|
|
source_sha256=source_hashes, sealed_input_sha256=inputs,
|
|
model_manifest_sha256=verified['model']['manifest_sha256'],
|
|
experiment_manifest_sha256=verified['experiment']['manifest_sha256'],
|
|
model_checksums_sha256=verified['model']['checksums_sha256'],
|
|
experiment_checksums_sha256=verified['experiment']['checksums_sha256'],
|
|
publication_receipt_sha256_unchanged=receipt_sha,
|
|
postseal_addition_outside_original_receipt=True, source_and_receipt_files_modified=False,
|
|
original_metric_dicts_copied_without_recalculation=True, new_scientific_gate=False,
|
|
scientific_pass_inferred_from_description=False, new_brain_simulation=False, GPU_used=False,
|
|
parameters_changed=False, unique_cause_proven=False, necessity_proven=False, learning_achieved=False,
|
|
inherited_AI_other_population_or_window_share=False,
|
|
limitations=['Nominal accepted weight sums are not voltage attribution, necessity, or unique causation.',
|
|
'Origin cohorts include all ties at the earliest non-design ALPN spike, with strict pre-first-target and pre-first-any-KC cutoffs.',
|
|
'Counts of timed ALLN outgoing edge events and antecedent pairs are distinct and need not denote unique paths.',
|
|
'Post-seal aggregation changes no original scientific gate or PASS/FAIL/INCOMPLETE status.',
|
|
'Origin data are sealed control trajectories; no treatment-specific origin conclusion is inferred.'])
|
|
after = {'model': helper.verify_seal(model), 'experiment': helper.verify_seal(experiment)}
|
|
require(after == verified and helper._digest(helper_path) == HELPER_SHA256, 'A sealed source changed during description')
|
|
require(helper._digest(receipt_path) == receipt_sha, 'Existing publication receipt changed during description')
|
|
data = (json.dumps(result, indent=2, ensure_ascii=False, allow_nan=False) + '\n').encode('utf-8')
|
|
require(len(data) <= MAX_BYTES, 'Descriptive output exceeds the 4 MiB small-evidence limit')
|
|
with output.open('xb') as stream:
|
|
stream.write(data)
|
|
output_sha = hashlib.sha256(data).hexdigest()
|
|
with checksum.open('xb') as stream:
|
|
stream.write((output_sha + ' interpretation-metrics.json\n').encode('ascii'))
|
|
require(helper._digest(output) == output_sha and helper._digest(receipt_path) == receipt_sha,
|
|
'Output or original receipt changed while writing')
|
|
return dict(description_complete=True, declared_final_status=status['status'], output=str(output),
|
|
sha256=output_sha, new_scientific_gate=False, learning_achieved=False)
|
|
|
|
|
|
def main():
|
|
print(json.dumps(describe(), ensure_ascii=False, allow_nan=False), flush=True)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|