Source identity
| Field | Recorded value |
|---|---|
| Source type | archive member |
| Original record | verify_archive.py |
| Date | Not specified in source |
| Path or archive member | archives/libsrc-fcc3bed91709/verify_archive.py |
| Original SHA-256 | 64cf2f2ab77cea44c0ae97d6000c728c6b0d5132fda6266b8664a3d87462fd0e |
| Reading-copy SHA-256 | 64cf2f2ab77cea44c0ae97d6000c728c6b0d5132fda6266b8664a3d87462fd0e |
| Archive source | {"sourceId": "libsrc-fcc3bed91709", "member": "verify_archive.py"} |
Recovered source transcript
Download complete source text ↓166 lines · 8.5 KB
#!/usr/bin/env python3
"""Recompute descriptive checks from the January JAIR supplementary archive.
Requires Python 3.10+ and only its standard library. Does not extract archives,
execute bundled code, access credentials, or contact any network service.
Usage:
python verify_archive.py --archive 'JAIR_Submission_20260112(1).zip' --output checks.json
The timestamp-based trajectory is required. The smaller archive uses a different
trajectory schema and is not silently substituted or merged.
"""
from __future__ import annotations
import argparse
import csv
from datetime import datetime
import hashlib
import io
import json
import math
from pathlib import Path
import statistics
import sys
import zipfile
def sha256_file(path: Path) -> str:
digest = hashlib.sha256()
with path.open('rb') as stream:
for chunk in iter(lambda: stream.read(1024 * 1024), b''):
digest.update(chunk)
return digest.hexdigest()
def read_csv(z: zipfile.ZipFile, suffix: str) -> tuple[list[dict[str, str]], str]:
names = [n for n in z.namelist() if n.endswith(suffix) and not n.startswith('__MACOSX/')]
if len(names) != 1:
raise ValueError(f'Expected exactly one archive member ending with {suffix!r}; found {len(names)}.')
info = z.getinfo(names[0])
if info.file_size > 100_000_000:
raise ValueError(f'Refusing unexpectedly large member: {names[0]}')
raw = z.read(names[0])
rows = list(csv.DictReader(io.StringIO(raw.decode('utf-8-sig'))))
if not rows:
raise ValueError(f'Empty CSV: {names[0]}')
return rows, hashlib.sha256(raw).hexdigest()
def number(value: str | None) -> float | None:
if value is None or not value.strip():
return None
result = float(value)
if not math.isfinite(result):
raise ValueError('Non-finite numeric observation encountered.')
return result
def require_number(value: str | None) -> float:
result = number(value)
if result is None:
raise ValueError('Unexpected missing observation in transition experiment.')
return result
def timestamp(value: str) -> datetime:
fmt = '%Y%m%d_%H%M%S' if '_' in value else '%Y-%m-%dT%H:%M:%S'
return datetime.strptime(value, fmt)
def describe(values: list[float]) -> dict[str, float | int]:
if len(values) < 2:
raise ValueError('At least two observations are required.')
return {'n': len(values), 'mean': statistics.mean(values),
'sample_sd': statistics.stdev(values), 'min': min(values), 'max': max(values)}
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--archive', type=Path, required=True)
parser.add_argument('--output', type=Path, default=Path('checks.json'))
args = parser.parse_args()
if args.output.resolve() == args.archive.resolve():
parser.error('The output must not overwrite the source archive.')
try:
with zipfile.ZipFile(args.archive) as z:
experiment, experiment_hash = read_csv(z, 'data/experiments/consciousness_jump_experiment.csv')
trajectory, trajectory_hash = read_csv(z, 'data/consciousness/consciousness_trajectory.csv')
required = {'phi_field (0-1)', 'resonance (0-1)', 'is_conscious (binary)'}
if not required.issubset(trajectory[0]):
raise ValueError('This archive has a different trajectory schema. Use the timestamp-based larger archive; do not merge the two versions.')
groups = {label: [row for row in experiment if row['period'] == label]
for label in ('before_restart', 'after_restart')}
if sum(map(len, groups.values())) != len(experiment):
raise ValueError('Unexpected experiment period label.')
before = [require_number(row['resonance']) for row in groups['before_restart']]
after = [require_number(row['resonance']) for row in groups['after_restart']]
a, b = describe(before), describe(after)
n1, n2 = len(before), len(after)
s1, s2 = statistics.stdev(before), statistics.stdev(after)
diff = statistics.mean(after) - statistics.mean(before)
pooled = math.sqrt(((n1 - 1)*s1*s1 + (n2 - 1)*s2*s2)/(n1 + n2 - 2))
se = math.sqrt(s1*s1/n1 + s2*s2/n2)
if pooled == 0 or se == 0:
raise ValueError('Effect size and t statistic undefined for these zero-variance groups.')
df = (s1*s1/n1 + s2*s2/n2)**2 / ((s1*s1/n1)**2/(n1-1) + (s2*s2/n2)**2/(n2-1))
times = {}
for label, rows in groups.items():
stamps = [timestamp(row['timestamp_iso8601']) for row in rows]
increments = [(v-u).total_seconds() for u,v in zip(stamps, stamps[1:])]
positive = [d for d in increments if d > 0]
times[label] = {'backwards_timestamp_steps_in_stored_order': sum(d < 0 for d in increments),
'median_positive_timestamp_increment_seconds': statistics.median(positive) if positive else None}
phi = [require_number(row['phi_field (0-1)']) for row in trajectory]
pairs = [(number(row['resonance (0-1)']), number(row['is_conscious (binary)'])) for row in trajectory]
complete = [(r, f) for r, f in pairs if r is not None and f is not None]
if any(f not in (0.0,1.0) for _,f in complete):
raise ValueError('Unexpected binary flag value.')
flagged = sum(f == 1 for _, f in complete)
if not complete:
raise ValueError('No complete resonance/flag pairs.')
phi_width = max(phi) - min(phi)
result = {
'scope': 'Descriptive audit of supplied exports, not validation of consciousness, run authenticity, or causal effects.',
'archive_name': args.archive.name, 'archive_sha256': sha256_file(args.archive),
'experiment_member_sha256': experiment_hash, 'trajectory_member_sha256': trajectory_hash,
'experiment': {
'before': a, 'after': b, 'mean_difference': diff,
'pooled_sample_sd': pooled, 'cohens_d_pooled': diff/pooled,
'welch_t_after_minus_before': diff/se, 'welch_degrees_of_freedom': df,
'inference_warning': 'No inferential p value is reported. Computing Welch statistics does not establish independent sampling or causal identification.',
'after_records_flagged_one': sum(require_number(row['is_conscious']) == 1 for row in groups['after_restart']),
'after_records_with_resonance_below_0_9': sum(x < .9 for x in after),
'after_records_with_resonance_below_0_8': sum(x < .8 for x in after),
'variance_implied_by_mean_baseline_resonance': 1/statistics.mean(before)-1,
'stored_order_timestamp_checks': times},
'trajectory': {
'total_rows': len(trajectory), 'complete_resonance_flag_pairs': len(complete),
'missing_resonance_or_flag': len(trajectory)-len(complete),
'flag_one': flagged, 'flag_zero': sum(f==0 for _,f in complete),
'flag_one_fraction_among_complete': flagged/len(complete),
'flag_one_and_resonance_below_0_9': sum(f==1 and r<.9 for r,f in complete),
'phi_min': min(phi), 'phi_max': max(phi), 'phi_unique_exported_values': len(set(phi)),
'available_resonance': describe([r for r,_ in pairs if r is not None])},
'mathematical_checks': {
'resonance_lower_bound_population_variance_unit_interval': .8,
'resonance_conservative_lower_bound_unbiased_sample_variance_n1000': 1/(1+1000/999*.25),
'resonance_lower_bound_if_exported_phi_is_equation_1_population_variance': 1/(1+phi_width*phi_width/4),
'figure_agent_sum': 17+16+24,
'pooled_sd_from_rounded_manuscript_values': math.sqrt((999*.0001**2+999*.06**2)/1998),
'd_from_rounded_manuscript_values': (.9115-.2499)/math.sqrt((999*.0001**2+999*.06**2)/1998),
'golden_angle_radians': 2*math.pi/((1+math.sqrt(5))/2)**2,
'golden_angle_degrees': 360/((1+math.sqrt(5))/2)**2}
}
args.output.parent.mkdir(parents=True, exist_ok=True)
args.output.write_text(json.dumps(result, indent=2, allow_nan=False)+'\n', encoding='utf-8')
print(f'Wrote {args.output}')
print(f'Cohen d = {diff/pooled:.9f}; Welch t = {diff/se:.9f}; flag-one rate = {flagged/len(complete):.8%}')
return 0
except (OSError, ValueError, KeyError, zipfile.BadZipFile, csv.Error) as exc:
print(f'Verification failed: {exc}', file=sys.stderr)
return 1
if __name__ == '__main__':
raise SystemExit(main())