biological-computer
The biological-computer worked example.
Run it from sema/:
sema check examples/biological-computerSEMA_STRICT=1 sema run examples/biological-computersema assure examples/biological-computer --grade silverSource
Section titled “Source”src/main.sema
Section titled “src/main.sema”"""Sema-owned biological workflow with evidence-gated foreign kernels and non-authoritative projections."""from std.crypto import file_sha256
from biological_computer.openmm import openmm_adapter, openmm_backendfrom biological_computer.coarse import coarse_backendfrom biological_computer.ensemble import ensemble_backendfrom biological_computer.reference import molecular_referencefrom biological_computer.rare_event import rare_event_backendfrom biological_computer.mace import mace_backendfrom biological_computer.mace_off import mace_off_backendfrom biological_computer.insulin import insulin_backendfrom biological_computer.insulin_structure import insulin_structure_backendfrom biological_computer.insulin_pmf import insulin_pmf_backendfrom biological_computer.qmmm import qmmm_backendfrom biological_computer.qmmm_multicode import run_profile as run_qmmm_multicodefrom biological_computer.mesoscopic import mesoscopic_backendfrom biological_computer.readdy_calibration import readdy_calibration_backendfrom biological_computer.physicell import physicell_backendfrom biological_computer.dynamics import ControlIntent, Phase8AdmissionEvidence, admit_association_model, preview_unadmitted_multiscale_dynamicsfrom biological_computer.live import serve_livefrom biological_computer.volume import run_volume_profilefrom biological_computer.portable import portable_backendfrom biological_computer.rerun import rerun_projectionfrom biological_computer.viewer import prepare_viewerfrom biological_computer.phase10 import Phase10QualificationResult, qualify_phase10
assure silver
args BiologicalComputerCli: live: bool = flag("--live") prepare_viewer_only: bool = flag("--prepare-viewer") qualify_phase10_only: bool = flag("--qualify-phase10") port: int = option("--port", default=8790)
def phase10_summary(result: Phase10QualificationResult): return ( "phase=10 state=confined_local_preview_untrusted profile=" + result.profile_id + " scales=" + str(result.scale_count) + " minimum_fps=" + str(result.minimum_average_fps) + " input_hz=" + str(result.interaction_hz) + " canonical_update_hz=" + str(result.canonical_update_hz) + " pick_p95_ms=" + str(result.pick_p95_ms) + " gpu_allocated_bytes=" + str(result.gpu_allocated_bytes) + " scene_sha256=" + result.scene_sha256 + " bundle_sha256=" + result.bundle_sha256 + " external_reference_sha256=" + result.external_reference_sha256 + " pixel_equality_observed=" + str(result.pixel_equality_observed) + " capture_provenance=" + result.capture_provenance_status + " admission=false" + " visual_regression_replay=" + str(result.visual_regression_replay_pass) + " scientific_admission=" + str(result.scientific_validated) )
def main() !{ffi.call, fs.read, fs.write, net.listen}: if BiologicalComputerCli.qualify_phase10_only: print(phase10_summary(qualify_phase10())) return if BiologicalComputerCli.prepare_viewer_only: viewer_scene = prepare_viewer() print("viewer_scene=" + viewer_scene.path + " sha256=" + viewer_scene.file_sha256) return if BiologicalComputerCli.live: serve_live(BiologicalComputerCli.port) return ensure file_sha256("src/live.sema") == "2a447254090468057239653441109e02940e94e084f73b494a003c452e2f25e0" ensure file_sha256("viewer/public/data/scene.json") == "644bf09172c4d4ea4c221287af2f7f74350bd5ec29efd918dcbaa185fa345c1f" probe = openmm_adapter.backend_probe() if probe.available: result = openmm_backend.run_openmm_cpu() coarse_result = coarse_backend.analyze_coarse_state( "coarse.toml", result.frames_path, "runs/cpu/" + result.benchmark_id + "-coarse.json", result.frames_sha256, ) ensure coarse_result.source_frames_sha256 == result.frames_sha256 ensure coarse_result.source_model_sha256 == result.system_sha256 ensure coarse_result.source_parameter_sha256 == result.config_sha256 ensemble_result = ensemble_backend.run_ensemble( "ensemble.toml", "coarse.toml", "runs/ensemble/" + result.benchmark_id + "-ensemble.json", ) ensure ensemble_result.benchmark_config_sha256 == result.config_sha256 ensure ensemble_result.coarse_config_sha256 == coarse_result.config_sha256 ensure ensemble_result.source_model_sha256 == result.system_sha256 reference_result = molecular_reference.run_reference( "reference.toml", "runs/reference/ala2-mdshare.json", ) ensure reference_result.target_config_sha256 == result.config_sha256 ensure reference_result.reproduced ensure reference_result.ensemble_converged ensure reference_result.condition_matched == false ensure reference_result.evidence_class == "published_related_reference" rare_event_result = rare_event_backend.run_metadynamics( "rare_event.toml", "runs/rare-event/symmetric-double-well.json", ) ensure rare_event_result.converged mace_result = mace_backend.run_profile( "mace.toml", "runs/mace/direct.json", "runs/mace/mace_mp_0a_small_si_v1.json", ) ensure mace_result.direct_parity_pass ensure mace_result.technical_pass ensure mace_result.uncertainty_available == false ensure mace_result.molecular_validated == false mace_off_result = mace_off_backend.run_profile( "mace_off.toml", "runs/mace-off/direct.json", "runs/mace-off/mace_off23_spice_holdout.json", ) ensure mace_off_result.direct_parity_pass ensure mace_off_result.accuracy_pass ensure mace_off_result.uncertainty_pass ensure mace_off_result.ood_pass ensure mace_off_result.ablation_pass ensure mace_off_result.molecular_validated insulin_result = insulin_backend.run_profile( "insulin.toml", "runs/insulin/direct.json", "runs/insulin/human_itc.json", ) ensure insulin_result.direct_parity_pass ensure insulin_result.condition_pass ensure insulin_result.thermodynamic_pass ensure insulin_result.validated insulin_structure_result = insulin_structure_backend.run_profile( "insulin_structure.toml", "runs/insulin/structure-direct.json", "runs/insulin/structure-sema.json", ) ensure insulin_structure_result.direct_parity_pass ensure insulin_structure_result.structural_pass ensure insulin_structure_result.technical_pass ensure insulin_structure_result.association_validated == false insulin_pmf_result = insulin_pmf_backend.run_profile( "insulin_pmf.toml", "runs/insulin-pmf/direct.json", "runs/insulin-pmf/sema.json", ) ensure insulin_pmf_result.direct_parity_pass ensure insulin_pmf_result.technical_pass ensure insulin_pmf_result.standard_state_delta_g_available == false ensure len(insulin_pmf_result.standard_state_delta_g_kj_mol) == 0 ensure insulin_pmf_result.scientific_validated == false ensure insulin_pmf_result.failure_type == "InsulinPmfNonConverged" qmmm_result = qmmm_backend.run_profile( "qmmm.toml", "runs/qmmm/direct.json", "runs/qmmm/fixed_partition.json", ) ensure qmmm_result.direct_parity_pass ensure qmmm_result.technical_pass ensure qmmm_result.multicode_validated == false qmmm_multicode_result = run_qmmm_multicode( "qmmm_multicode.toml", "runs/qmmm/phase7-direct.json", "runs/qmmm/phase7-sema.json", ) ensure qmmm_multicode_result.direct_parity_pass ensure qmmm_multicode_result.primary_converged ensure qmmm_multicode_result.primary_technical_pass ensure qmmm_multicode_result.insulin_partition_validated ensure qmmm_multicode_result.secondary_status == "unavailable" ensure qmmm_multicode_result.secondary_executed == false ensure qmmm_multicode_result.multicode_energy_parity_pass == false ensure qmmm_multicode_result.multicode_force_parity_pass == false ensure qmmm_multicode_result.multicode_charge_parity_pass == false ensure qmmm_multicode_result.multicode_reaction_coordinate_parity_pass == false ensure qmmm_multicode_result.multicode_technical_pass == false ensure qmmm_multicode_result.multicode_residuals_available == false ensure qmmm_multicode_result.maximum_energy_residual_hartree == -1.0 ensure qmmm_multicode_result.maximum_force_residual_hartree_per_angstrom == -1.0 ensure qmmm_multicode_result.maximum_atomic_charge_residual_e == -1.0 ensure qmmm_multicode_result.phase7_validated == false ensure qmmm_multicode_result.scientific_validated == false mesoscopic_result = mesoscopic_backend.run_profile( "mesoscopic.toml", "runs/mesoscopic/phase8-direct.json", "runs/mesoscopic/phase8-sema.json", ) ensure mesoscopic_result.direct_parity_pass ensure mesoscopic_result.transfer_pass ensure mesoscopic_result.readdy_executed ensure mesoscopic_result.readdy_status == "failed" ensure mesoscopic_result.readdy_spatial_evidence ensure mesoscopic_result.readdy_target_rate_evidence == false ensure mesoscopic_result.readdy_concentration_evidence == false ensure mesoscopic_result.readdy_uncertainty_evidence ensure mesoscopic_result.readdy_validated == false ensure mesoscopic_result.physicell_status == "unavailable" ensure mesoscopic_result.physicell_executed == false ensure mesoscopic_result.physicell_validated == false ensure mesoscopic_result.phase8_technical_pass == false ensure mesoscopic_result.scientific_validated == false readdy_calibration_result = readdy_calibration_backend.run_profile( "readdy_calibration.toml", "runs/readdy-calibration/direct.json", "runs/readdy-calibration/sema.json", ) readdy_direct_file_sha256 = file_sha256("runs/readdy-calibration/direct.json") readdy_sema_file_sha256 = file_sha256("runs/readdy-calibration/sema.json") ensure readdy_direct_file_sha256 == readdy_sema_file_sha256 ensure readdy_calibration_result.config_sha256 == file_sha256("readdy_calibration.toml") ensure readdy_calibration_result.profile_id == "insulin_dimer_readdy_2_0_14_preregistered_v1" ensure readdy_calibration_result.calibration_lock["heldout_inspected_before_lock"] == false ensure readdy_calibration_result.heldout_design["disjoint_from_training"] == true ensure readdy_calibration_result.heldout_design["parameters_locked_before_execution"] == false ensure readdy_calibration_result.heldout_evidence_admission["chronology_proven"] == false ensure readdy_calibration_result.heldout_evidence_admission["metrics_classification"] == "exploratory_unadmitted" ensure readdy_calibration_result.calibration_evidence_status == "chronology_unproven" ensure readdy_calibration_result.gates["rate_pass"] ensure readdy_calibration_result.gates["kd_pass"] ensure readdy_calibration_result.gates["uncertainty_ci_pass"] ensure readdy_calibration_result.gates["concentration_pass"] ensure readdy_calibration_result.gates["event_count_pass"] ensure readdy_calibration_result.gates["spatial_pass"] == false ensure readdy_calibration_result.gates["convergence_pass"] == false ensure readdy_calibration_result.statistics["maximum_spatial_axis_ks"] > 0.15 ensure readdy_calibration_result.statistics["total_effective_samples"] < 100.0 ensure readdy_calibration_result.qualification_pass == false ensure readdy_calibration_result.failure_type == "ReaddyCalibrationChronologyUnproven" ensure len(readdy_calibration_result.blockers) == 3 ensure readdy_calibration_result.blockers[0] == "heldout_chronology_unproven" ensure readdy_calibration_result.blockers[1] == "convergence_pass" ensure readdy_calibration_result.blockers[2] == "spatial_pass" ensure readdy_calibration_result.phase8_scientific_validation == false ensure readdy_calibration_result.scientific_validated == false physicell_result = physicell_backend.run_profile( "physicell.toml", "sema", "runs/physicell/direct.json", "runs/physicell/sema.json", ) ensure physicell_result.release_version == "1.14.2" ensure physicell_result.config_sha256 == file_sha256("physicell.toml") ensure physicell_result.phase8_result_sha256 == mesoscopic_result.result_sha256 ensure physicell_result.phase8_artifact_sha256 == file_sha256("runs/mesoscopic/phase8-sema.json") ensure physicell_result.profile_id == "physicell_1_14_2_arm64_phase8_field_coupling_v1" ensure physicell_result.release_asset_bytes == 2371922 ensure physicell_result.binary_bytes == 7656072 ensure physicell_result.host_architecture == "arm64" ensure len(physicell_result.arm64_dependencies) == 1 ensure physicell_result.arm64_dependencies[0] == "/usr/lib/libSystem.B.dylib" ensure physicell_result.fetch_manifest_schema == "sema.physicell-fetch/v1" ensure physicell_result.fetch_manifest_sha256 == file_sha256(physicell_result.fetch_manifest_path) ensure physicell_result.fetch_manifest_path == ".physicell-cache/manifest.json" ensure physicell_result.fetch_remote_verified ensure physicell_result.tag_commit == "dbd3499250141b27600e91e501c54c46f68f2763" ensure physicell_result.tag_ref_sha == physicell_result.tag_commit ensure physicell_result.tag_commit_verified ensure physicell_result.fetch_manifest_pass ensure physicell_result.executable_pass ensure physicell_result.platform_pass ensure physicell_result.config_xml_field_coupling_pass ensure physicell_result.field_output_pass ensure physicell_result.concentration_transfer_pass ensure physicell_result.spatial_transfer_pass ensure physicell_result.mass_transfer_pass ensure physicell_result.uncertainty_bound_transfer_pass ensure physicell_result.cell_secretion_uptake_coupling_pass ensure physicell_result.failure_contract_pass ensure physicell_result.missing_failure_typed ensure physicell_result.corrupt_failure_typed ensure physicell_result.wrong_arch_failure_typed ensure physicell_result.timeout_failure_typed ensure physicell_result.oversized_output_failure_typed ensure physicell_result.manifest_missing_failure_typed ensure physicell_result.manifest_unverified_failure_typed ensure physicell_result.manifest_tampered_failure_typed ensure physicell_result.corrupt_asset_failure_typed ensure physicell_result.corrupt_binary_failure_typed ensure physicell_result.timeout_descendants_reaped ensure physicell_result.oversized_output_descendants_reaped ensure physicell_result.technical_qualified ensure physicell_result.direct_parity_pass ensure physicell_result.direct_residual == 0.0 ensure physicell_result.direct_artifact_sha256 == file_sha256("runs/physicell/direct.json") ensure physicell_result.result_sha256 == physicell_result.direct_result_sha256 ensure physicell_result.target_rate_evidence == false ensure physicell_result.insulin_reaction_supported == false ensure physicell_result.scientific_uncertainty_evidence == false ensure physicell_result.scientific_validated == false phase8_admission_evidence = Phase8AdmissionEvidence( phase8_technical_pass=mesoscopic_result.phase8_technical_pass, readdy_chronology_proven=readdy_calibration_result.heldout_evidence_admission["chronology_proven"], readdy_qualification_pass=readdy_calibration_result.qualification_pass, readdy_convergence_pass=readdy_calibration_result.gates["convergence_pass"], readdy_spatial_pass=readdy_calibration_result.gates["spatial_pass"], readdy_admission_pass=readdy_calibration_result.phase8_scientific_validation, physicell_custom_insulin_pass=physicell_result.insulin_reaction_supported, physicell_target_rate_pass=physicell_result.target_rate_evidence, physicell_uncertainty_pass=physicell_result.scientific_uncertainty_evidence, physicell_scientific_pass=physicell_result.scientific_validated, ) dynamics_adaptation = admit_association_model( mesoscopic_result.profile_id, mesoscopic_result.association_rate_per_micromolar_s, mesoscopic_result.dissociation_rate_per_s, mesoscopic_result.source_kd_sem_micromolar / mesoscopic_result.source_kd_micromolar, mesoscopic_result.kd_relative_residual, mesoscopic_result.result_sha256, mesoscopic_result.simulated_time_s, phase8_admission_evidence, ) ensure dynamics_adaptation.admission_status == "exploratory_unadmitted" ensure dynamics_adaptation.candidate_model_id == mesoscopic_result.profile_id ensure dynamics_adaptation.selected_model_id == dynamics_adaptation.active_model_id ensure dynamics_adaptation.activated == false ensure dynamics_adaptation.admitted == false ensure dynamics_adaptation.exploratory ensure dynamics_adaptation.evidence_reliability == 0.0 ensure dynamics_adaptation.parameter_apply_authorized == false dynamics_result = preview_unadmitted_multiscale_dynamics( mesoscopic_result.profile_id, mesoscopic_result.observed_monomer_micromolar, mesoscopic_result.observed_dimer_micromolar, mesoscopic_result.association_rate_per_micromolar_s, mesoscopic_result.dissociation_rate_per_s, ControlIntent( id="inspect-bounded-tissue-response-preview-v1", natural_language="Inspect a bounded tissue-response preview without applying unadmitted Phase8 parameters", target_tissue_response=0.08, maximum_cellular_gain=1.0, effort_penalty=0.0001, horizon_s=mesoscopic_result.simulated_time_s, evidence_ids=[mesoscopic_result.result_sha256, mesoscopic_result.direct_oracle_result_sha256], ), dynamics_adaptation, ) ensure dynamics_result.admission_status == "exploratory_unadmitted" ensure dynamics_result.admitted == false ensure dynamics_result.exploratory ensure dynamics_result.parameter_apply_authorized == false ensure dynamics_result.technical_pass == false ensure dynamics_result.scientific_validated == false volume_result = run_volume_profile( "volume.toml", "runs/volumes/cellular-tissue.json", ) ensure volume_result.source_result_sha256 == mesoscopic_result.result_sha256 ensure volume_result.deterministic_pass ensure volume_result.source_binding_pass ensure volume_result.phase10_technical_pass ensure volume_result.scientific_validated == false portable_result = portable_backend.run_profile( "portable.toml", "runs/portable/direct-phase9.json", "runs/portable/sema-phase9.json", ) ensure portable_result.source_result_sha256 == mesoscopic_result.result_sha256 ensure portable_result.source_artifact_sha256 == file_sha256("runs/mesoscopic/phase8-sema.json") ensure portable_result.direct_oracle_artifact_sha256 == file_sha256("runs/portable/direct-phase9.json") ensure portable_result.direct_oracle_path == "runs/portable/direct-phase9.json" ensure portable_result.direct_parity_pass ensure portable_result.bulk_abi_pass ensure portable_result.scientific_parity_pass ensure portable_result.single_node_portability_pass ensure portable_result.worker_loss_failure_validated ensure portable_result.same_node_distributed_process_pass ensure portable_result.distributed_validated == false ensure portable_result.checkpoint_pass ensure portable_result.device_loss_failure_validated ensure portable_result.device_loss_injection_observed ensure portable_result.device_loss_recovery_pass ensure portable_result.local_technical_pass ensure portable_result.portable_core_validated == false ensure portable_result.phase9_admitted == false ensure portable_result.phase9_validated == false ensure portable_result.cross_node_distributed_validated == false ensure portable_result.physical_device_loss_validated == false ensure portable_result.sema_bridge_zero_copy_validated == false ensure portable_result.evidence_class == "local_technical_evidence" ensure portable_result.scientific_validated == false ensure portable_result.source_result_sha256 == "3164645981cd04fae5811856b166156769b39b35a85bf441748a468a24fa19f7" recording = rerun_projection.record_run( result.frames_path, coarse_result.result_path, ensemble_result.result_path, rare_event_result.result_path, mace_result.result_path, ".sema/cache/inputs/" + result.input_sha256 + ".pdb", "runs/cpu/" + result.benchmark_id + ".rrd", result.result_sha256, ) ensure recording.source_frames_sha256 == result.frames_sha256 ensure recording.source_result_sha256 == result.result_sha256 ensure recording.coarse_result_sha256 == coarse_result.result_sha256 ensure recording.ensemble_result_sha256 == ensemble_result.result_sha256 ensure recording.ensemble_sampling_converged == ensemble_result.converged ensure recording.rare_event_result_sha256 == rare_event_result.result_sha256 ensure recording.rare_event_technical_converged == rare_event_result.converged ensure recording.mace_result_sha256 == mace_result.result_sha256 ensure recording.mace_technical_pass == mace_result.technical_pass ensure recording.mace_uncertainty_available == mace_result.uncertainty_available ensure recording.mace_molecular_validated == mace_result.molecular_validated ensure recording.model_sha256 == result.system_sha256 ensure recording.parameter_sha256 == result.config_sha256 viewer_scene = prepare_viewer() ensure viewer_scene.source_result_sha256 == result.result_sha256 ensure viewer_scene.source_frames_sha256 == result.frames_sha256 phase10_result = qualify_phase10() ensure phase10_result.scene_sha256 == viewer_scene.file_sha256 ensure phase10_result.evidence_sha256 == "82b00f0bf08250a6e40e7d1b437ee4e4a8527607b61765782ff1668323989110" ensure phase10_result.scene_sha256 == "644bf09172c4d4ea4c221287af2f7f74350bd5ec29efd918dcbaa185fa345c1f" ensure phase10_result.bundle_sha256 == "7336af8d81101b20705005f9eff8cb957552f57945542527d781c76b2e243b92" ensure phase10_result.scientific_result_sha256 == result.result_sha256 ensure phase10_result.pixel_equality_observed ensure phase10_result.capture_provenance_status == "technical_untrusted" ensure phase10_result.visual_regression_replay_pass == false ensure phase10_result.scientific_validated == false print("backend=" + probe.engine + " version=" + probe.version) print("benchmark=" + result.benchmark_id + " platform=" + result.platform) print("frames=" + str(result.frames) + " result_sha256=" + result.result_sha256) print("recording_sha256=" + recording.sha256) print("viewer_scene=" + viewer_scene.path + " sha256=" + viewer_scene.file_sha256) print("equation_terms=" + str(recording.equation_terms)) print( "coarse_samples=" + str(coarse_result.samples) + " transitions=" + str(coarse_result.transitions) + " effective_samples=" + str(coarse_result.effective_samples) + " converged=" + str(coarse_result.sampling_converged) ) print( "exploratory_ensemble_replicas=" + str(ensemble_result.replicas) + " transitions=" + str(ensemble_result.transitions) + " effective_samples=" + str(ensemble_result.effective_samples) + " rhat=" + str(ensemble_result.rhat_max) + " converged=" + str(ensemble_result.converged) ) print( "reference=" + reference_result.reference_id + " replicas=" + str(reference_result.replicas) + " slow_ps=" + str(reference_result.slow_timescale_ps) + " fast_ps=" + str(reference_result.fast_timescale_ps) + " effective_samples=" + str(reference_result.effective_samples) + " reproduced=" + str(reference_result.reproduced) + " ensemble_transitions=" + str(reference_result.ensemble_transitions) + " ensemble_rhat=" + str(reference_result.ensemble_rhat) + " ensemble_converged=" + str(reference_result.ensemble_converged) + " condition_matched=" + str(reference_result.condition_matched) ) print( "rare_event=" + rare_event_result.benchmark_id + " replicas=" + str(rare_event_result.replicas) + " min_transitions=" + str(rare_event_result.min_transitions) + " left_population=" + str(rare_event_result.left_population_mean) + " delta_f_kj_mol=" + str(rare_event_result.free_energy_difference_mean_kj_mol) + " converged=" + str(rare_event_result.converged) ) print( "mace_profile=" + mace_result.profile_id + " checkpoint_sha256=" + mace_result.checkpoint_sha256 + " direct_parity=" + str(mace_result.direct_parity_pass) + " technical_pass=" + str(mace_result.technical_pass) + " molecular_admission=" + str(mace_result.molecular_validated) ) print( "mace_off_profile=" + mace_off_result.profile_id + " energy_rmse_mev_atom=" + str(mace_off_result.heldout_energy_rmse_mev_per_atom) + " force_rmse_mev_a=" + str(mace_off_result.heldout_force_rmse_mev_per_angstrom) + " coverage=" + str(mace_off_result.conformal_coverage) + " ood_blocked=" + str(mace_off_result.ood_blocked) + " holdout_evidence_pass=" + str(mace_off_result.molecular_validated) ) print( "phase=5 state=technical_evidence_unadmitted reference_ensemble_converged=" + str(reference_result.ensemble_converged) + " exact_condition=" + str(reference_result.condition_matched) + " reference_profile=" + reference_result.reference_id + " learned_profile=" + mace_off_result.profile_id ) print( "phase=6 state=technical_evidence_unadmitted reference_model_evidence=published_related thermodynamic_profile=" + insulin_result.profile_id + " atomistic_profile=" + insulin_structure_result.profile_id + " atoms=" + str(insulin_structure_result.atoms) + " binding_free_energy_kj_mol=" + str(insulin_result.modeled_binding_free_energy_kj_mol) + " experiments=" + str(insulin_result.independent_experiments) + " association_admission=" + str(insulin_structure_result.association_validated) ) print( "insulin_pmf_profile=" + insulin_pmf_result.profile_id + " evidence_sha256=" + insulin_pmf_result.evidence_sha256 + " failure_type=" + insulin_pmf_result.failure_type + " technical_pass=" + str(insulin_pmf_result.technical_pass) + " standard_state_delta_g_available=" + str(insulin_pmf_result.standard_state_delta_g_available) + " scientific_admission=" + str(insulin_pmf_result.scientific_validated) ) print( "phase=7 state=technical_evidence_unadmitted zundel_technical=" + str(qmmm_result.technical_pass) + " insulin_partition_evidence=" + str(qmmm_multicode_result.insulin_partition_validated) + " primary_backend=" + qmmm_multicode_result.primary_backend + " primary_technical=" + str(qmmm_multicode_result.primary_technical_pass) + " secondary_backend=" + qmmm_multicode_result.secondary_backend + " secondary_status=" + qmmm_multicode_result.secondary_status + " multicode_technical=" + str(qmmm_multicode_result.multicode_technical_pass) + " scientific_admission=" + str(qmmm_multicode_result.scientific_validated) ) print( "phase=8 state=exploratory_unadmitted transfer_pass=" + str(mesoscopic_result.transfer_pass) + " readdy_status=" + mesoscopic_result.readdy_status + " readdy_spatial_evidence=" + str(mesoscopic_result.readdy_spatial_evidence) + " readdy_admission=" + str(mesoscopic_result.readdy_validated) + " active_mesoscopic_physicell_status=" + mesoscopic_result.physicell_status + " scientific_admission=" + str(mesoscopic_result.scientific_validated) + " result_sha256=" + mesoscopic_result.result_sha256 + " artifact_sha256=" + file_sha256("runs/mesoscopic/phase8-sema.json") ) print( "readdy_calibration_profile=" + readdy_calibration_result.profile_id + " config_sha256=" + readdy_calibration_result.config_sha256 + " evidence_sha256=" + readdy_calibration_result.evidence_sha256 + " direct_sema_byte_sha256=" + readdy_direct_file_sha256 + " result_sha256=" + readdy_calibration_result.result_sha256 + " qualification_pass=" + str(readdy_calibration_result.qualification_pass) + " calibration_evidence_status=" + readdy_calibration_result.calibration_evidence_status + " parameters_locked_before_execution=" + str(readdy_calibration_result.heldout_design["parameters_locked_before_execution"]) + " metrics_classification=" + readdy_calibration_result.heldout_evidence_admission["metrics_classification"] + " blockers=heldout_chronology_unproven,convergence_pass,spatial_pass" + " spatial_ks=" + str(readdy_calibration_result.statistics["maximum_spatial_axis_ks"]) + " ess=" + str(readdy_calibration_result.statistics["total_effective_samples"]) ) print( "physicell_profile=" + physicell_result.profile_id + " source=official_prebuilt" + " release_asset_sha256=" + physicell_result.release_asset_sha256 + " binary_sha256=" + physicell_result.binary_sha256 + " fetch_manifest_sha256=" + physicell_result.fetch_manifest_sha256 + " fetch_evidence_sha256=" + physicell_result.fetch_evidence_sha256 + " fetch_remote_verified=" + str(physicell_result.fetch_remote_verified) + " tag_commit=" + physicell_result.tag_commit + " tag_commit_verified=" + str(physicell_result.tag_commit_verified) + " timeout_descendants_reaped=" + str(physicell_result.timeout_descendants_reaped) + " oversized_output_descendants_reaped=" + str(physicell_result.oversized_output_descendants_reaped) + " fetch_manifest_pass=" + str(physicell_result.fetch_manifest_pass) + " canonical_result_sha256=" + physicell_result.result_sha256 + " direct_parity=" + str(physicell_result.direct_parity_pass) + " technical_evidence_pass=" + str(physicell_result.technical_qualified) + " target_rate_evidence=" + str(physicell_result.target_rate_evidence) + " insulin_reaction_supported=" + str(physicell_result.insulin_reaction_supported) + " manifest_missing_typed=" + str(physicell_result.manifest_missing_failure_typed) + " manifest_unverified_typed=" + str(physicell_result.manifest_unverified_failure_typed) + " manifest_tampered_typed=" + str(physicell_result.manifest_tampered_failure_typed) + " corrupt_asset_typed=" + str(physicell_result.corrupt_asset_failure_typed) + " corrupt_binary_typed=" + str(physicell_result.corrupt_binary_failure_typed) + " scientific_admission=" + str(physicell_result.scientific_validated) + " blocker=custom_insulin_2M_to_D_reaction_and_uncertainty" ) print( "dynamics_contract=" + dynamics_result.contract_id + " adaptation=" + dynamics_result.adaptation.selected_model_id + " admission_status=" + dynamics_result.admission_status + " activated=" + str(dynamics_result.adaptation.activated) + " admitted=" + str(dynamics_result.admitted) + " exploratory=" + str(dynamics_result.exploratory) + " evidence_reliability=" + str(dynamics_result.adaptation.evidence_reliability) + " parameter_apply_authorized=" + str(dynamics_result.parameter_apply_authorized) + " optimizer_scope=" + dynamics_result.optimizer_scope + " cellular_gain=" + str(dynamics_result.cellular_gain) + " tissue_response=" + str(dynamics_result.final_state[3]) + " mass_residual=" + str(dynamics_result.molecular_mass_relative_residual) + " technical_evidence_pass=" + str(dynamics_result.technical_pass) + " scientific_admission=" + str(dynamics_result.scientific_validated) ) print( "phase=9 state=local_technical_evidence_unadmitted profile=" + portable_result.profile_id + " bulk_abi=" + str(portable_result.bulk_abi_pass) + " single_node=" + str(portable_result.single_node_portability_pass) + " local_technical_pass=" + str(portable_result.local_technical_pass) + " same_node_distributed_process=" + str(portable_result.same_node_distributed_process_pass) + " distributed_admission=" + str(portable_result.distributed_validated) + " cross_node=" + str(portable_result.cross_node_distributed_validated) + " device_loss_injected=" + str(portable_result.device_loss_injection_observed) + " physical_device_loss=" + str(portable_result.physical_device_loss_validated) + " sema_bridge_zero_copy=" + str(portable_result.sema_bridge_zero_copy_validated) + " phase9_admission=" + str(portable_result.phase9_admitted) + " external_gate_admission=" + str(portable_result.phase9_validated) + " evidence_class=" + portable_result.evidence_class + " scientific_admission=" + str(portable_result.scientific_validated) + " phase8_result_sha256=" + portable_result.source_result_sha256 + " phase8_artifact_sha256=" + portable_result.source_artifact_sha256 + " direct_oracle_path=" + portable_result.direct_oracle_path + " result_sha256=" + portable_result.result_sha256 + " artifact_sha256=" + file_sha256("runs/portable/sema-phase9.json") ) print(phase10_summary(phase10_result)) else: print("phase=2 state=blocked reason=" + probe.detail)src/agent.sema
Section titled “src/agent.sema”"""Proposal-only agent contract for bounded biological programming."""
from std.crypto import sha256_jsonfrom biological_computer.programming import compile_biological_command
assure silver
pub def propose_agent_program(payload: dict[str, any]) -> dict[str, any] !{}: required = ["agent_id", "request_id", "objective", "commands", "max_compute_units", "evidence_ids"] if not all(payload.has(field) for field in required): return {"ok": false, "error": "AgentProposalInvalid", "detail": "agent proposal is missing a required field"} if len(payload["agent_id"]) == 0 or len(payload["agent_id"]) > 128: return {"ok": false, "error": "AgentProposalInvalid", "detail": "agent_id must contain 1..128 characters"} if len(payload["request_id"]) == 0 or len(payload["request_id"]) > 128: return {"ok": false, "error": "AgentProposalInvalid", "detail": "request_id must contain 1..128 characters"} if len(payload["objective"]) == 0 or len(payload["objective"]) > 512: return {"ok": false, "error": "AgentProposalInvalid", "detail": "objective must contain 1..512 characters"} commands = payload["commands"] if len(commands) == 0 or len(commands) > 4: return {"ok": false, "error": "AgentProposalInvalid", "detail": "commands must contain 1..4 bounded programs"} if payload["max_compute_units"] <= 0 or payload["max_compute_units"] > 32: return {"ok": false, "error": "AgentProposalInvalid", "detail": "max_compute_units must be within 1..32"} if len(payload["evidence_ids"]) == 0 or len(payload["evidence_ids"]) > 16: return {"ok": false, "error": "AgentProposalInvalid", "detail": "evidence_ids must contain 1..16 digests"} if not all(len(evidence_id) == 64 for evidence_id in payload["evidence_ids"]): return {"ok": false, "error": "AgentProposalInvalid", "detail": "every evidence id must be a 64-character digest"} mut operations: list[dict[str, any]] = [] for command in commands: compiled = compile_biological_command(command) if not compiled["ok"]: return {"ok": false, "error": compiled["error"], "detail": compiled["detail"]} for operation in compiled["operations"]: operations.append(operation) if len(operations) == 0 or len(operations) > 8 or len(operations) > payload["max_compute_units"]: return {"ok": false, "error": "AgentProposalInvalid", "detail": "compiled operations exceed the declared compute or instruction bound"} if len(operations) > 1 and any(operation["kind"] == "reset_program" for operation in operations): return {"ok": false, "error": "AgentProposalInvalid", "detail": "reset_program must be proposed alone"} proposal = { "agent_id": payload["agent_id"], "request_id": payload["request_id"], "objective": payload["objective"], "commands": commands, "operations": operations, "evidence_ids": payload["evidence_ids"], } return { "ok": true, "schema": "sema.biological-agent-proposal/v1", "backend": "Sema", "proposal_id": sha256_json(proposal), "status": "proposed", "operations": operations, "compute_units": len(operations), "evidence_ids": payload["evidence_ids"], "requires_explicit_commit": true, "safety_class": "simulation_only", "scientific_validated": false, }
pub def agent_capabilities() -> dict[str, any] !{}: return { "schema": "sema.biological-agent-capabilities/v1", "mode": "proposal_only", "max_commands": 4, "max_operations": 8, "max_compute_units": 32, "commit_endpoint": "/api/sema/program", "proposal_endpoint": "/api/sema/agent/propose", "training_contract": "versioned_state_and_evidence_bound", }
test "agent proposals are bounded evidence-bound and never self-commit": evidence_id = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" proposal = propose_agent_program({ "agent_id": "training-agent-01", "request_id": "episode-0001", "objective": "Adjust bounded simulator signals", "commands": ["set glucose to 8", "inhibit cytokine release"], "max_compute_units": 4, "evidence_ids": [evidence_id], }) ensure proposal["ok"] ensure proposal["compute_units"] == 2 ensure proposal["requires_explicit_commit"] ensure proposal["scientific_validated"] == false rejected = propose_agent_program({ "agent_id": "training-agent-01", "request_id": "episode-0002", "objective": "Attempt an invalid mixed reset", "commands": ["reset", "stiffen bonds"], "max_compute_units": 4, "evidence_ids": [evidence_id], }) ensure not rejected["ok"] ensure rejected["error"] == "AgentProposalInvalid"src/api.sema
Section titled “src/api.sema”"""Canonical HTTP contract emitted with every biological-computer scene."""
assure silver
pub def biological_api_contract() -> dict[str, any] !{}: return { "schema": "sema.biological-api/v1", "backend": "Sema", "base_path": "/api/sema", "state_ownership": "sema", "scientific_validated": false, "endpoints": [ {"method": "GET", "path": "/status", "response_schema": "sema.biological-live-status/v1", "mutates": false, "max_request_bytes": 0}, {"method": "GET", "path": "/capabilities", "response_schema": "sema.biological-programming-capabilities/v1", "mutates": false, "max_request_bytes": 0}, {"method": "POST", "path": "/step", "response_schema": "sema.multiscale-dynamics-step/v1", "mutates": true, "max_request_bytes": 4096}, {"method": "POST", "path": "/intervene", "response_schema": "sema.biological-live-status/v1", "mutates": true, "max_request_bytes": 4096}, {"method": "POST", "path": "/molecule", "response_schema": "sema.molecular-session/v1", "mutates": true, "max_request_bytes": 4096}, {"method": "POST", "path": "/molecule/step", "response_schema": "sema.molecular-session/v1", "mutates": true, "max_request_bytes": 4096}, {"method": "POST", "path": "/program", "response_schema": "sema.biological-program-result/v1", "mutates": true, "max_request_bytes": 8192}, {"method": "POST", "path": "/design", "response_schema": "sema.molecular-design-result/v1", "mutates": true, "max_request_bytes": 8192}, {"method": "POST", "path": "/dock", "response_schema": "sema.molecular-binding-result/v1", "mutates": true, "max_request_bytes": 4096}, {"method": "POST", "path": "/introduce", "response_schema": "sema.biological-live-status/v1", "mutates": true, "max_request_bytes": 4096}, {"method": "POST", "path": "/agent/propose", "response_schema": "sema.biological-agent-proposal/v1", "mutates": false, "max_request_bytes": 8192}, {"method": "POST", "path": "/cortex/propose", "response_schema": "sema.biological-llm-proposal/v1", "mutates": false, "max_request_bytes": 8192}, ], "conflict_status": 409, "validation_status": 422, "not_found_status": 404, "over_cap_status": 413, "max_request_bytes": 8192, }src/assurance.sema
Section titled “src/assurance.sema”"""Behavioral assurance gates for the multiscale biological-computer contracts."""
from biological_computer.discovery import CandidateClaim, CandidateEvidence, CandidateHypothesis, CandidateKind, CandidateStatus, DiscoveryBatch, SearchBoundary, admit_candidate, may_report_claim, validate_discovery_batchfrom biological_computer.domain import Atom, Bond, EvidenceKind, EvidenceRecord, InteractionTerm, MolecularTopology, PeriodicBox, PhaseEvidence, PhaseState, Vector3, interaction_ownership_valid, phase_validated, topology_validfrom biological_computer.models import ApplicabilityDecision, EquationTermDescriptor, HybridPrediction, LearnedModelManifest, LearnedRole, PredictionStatus, PredictionUncertainty, TermImplementation, assess_hybrid_prediction, prediction_admissiblefrom biological_computer.profiles import AcceleratorKind, KernelDemand, NativeAccelerationProfile, NativeKernelKind, ParameterizationEdge, PlatformBenchmark, QmMmPartition, benchmark_comparable, parameterization_valid, qmmm_partition_valid, select_native_accelerationfrom biological_computer.resolution import ApproximationContract, EdgeKind, ResolutionEdge, TransitionState, commit_transition, prepare_transition, validate_transitionfrom biological_computer.statistics import BasinPopulations, PmfCorrections, basin_populations, compare_populations, corrected_pmf, diagnose_ensemblefrom biological_computer.visualization import ComplexityScenario, EntityFocusPath, EquationStateSample, EquationTermSample, EquationUpdateKind, FieldOfViewBudget, FidelityClass, GeometryOrigin, SemanticScaleSource, SemanticZoomDecision, ViewportQuery, VisualObservationEnvelope, VisualPrimitiveBinding, VisualRepresentation, VisualScale, decide_multiscale_compute, decide_semantic_zoom, focus_path_valid, validate_visual_observation
assure silver
def digest(): return "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
def evidence(id: str, accepted: bool): return EvidenceRecord( id=id, kind=EvidenceKind.computational, source="bounded assurance fixture", summary="condition-matched deterministic evidence", artifact_sha256=digest(), observed_at_s=1.0, accepted=accepted, )
def alanine_topology(): atoms = [ Atom(id="atom:N", index=0, element="N", residue="ALA", mass_da=14.0, charge_e=-0.3, position_nm=Vector3(x=0.0, y=0.0, z=0.0)), Atom(id="atom:CA", index=1, element="C", residue="ALA", mass_da=12.0, charge_e=0.1, position_nm=Vector3(x=0.1, y=0.0, z=0.0)), Atom(id="atom:C", index=2, element="C", residue="ALA", mass_da=12.0, charge_e=0.2, position_nm=Vector3(x=0.2, y=0.0, z=0.0)), ] bonds = [Bond(left_index=0, right_index=1, order=1), Bond(left_index=1, right_index=2, order=1)] return MolecularTopology( id="ala-fragment", atoms=atoms, bonds=bonds, box=PeriodicBox(x_nm=1.0, y_nm=1.0, z_nm=1.0), source_sha256=digest(), )
def approximation(valid: bool, maximum_error: f64): return ApproximationContract( id="ala2-aa-to-phi-psi-v1", source_model_id="ala2-aa-v1", target_model_id="ala2-phi-psi-v1", transform="periodic phi/psi restriction", preserved_observables=["phi", "psi", "basin_population"], marginalized_degrees=["solvent", "bond_vibration"], calibration_domain="aqueous alanine dipeptide at 300 K", maximum_error=maximum_error, refine_threshold=0.1, evidence_ids=["held-out-aa-ensemble"], valid=valid, )
def coarse_edge(contract: ApproximationContract): return ResolutionEdge( id="edge:ala2-aa-to-phi-psi-v1", kind=EdgeKind.coarsen, source_node_id="ala2-aa-v1", target_node_id="ala2-phi-psi-v1", approximation=contract, restriction="extract periodic phi and psi", prolongation="sample conditional atomistic microstate ensemble", checkpoint_only=true, )
def learned_manifest(output_unit: str): return LearnedModelManifest( id="ala2-hybrid-residual-v1", family="periodic residual potential", version="1.0.0", role=LearnedRole.energy, architecture_sha256=digest(), weights_sha256=digest(), training_data_sha256=digest(), validation_data_sha256=digest(), license_id="MIT", preprocessing="wrapped phi/psi radians", input_units=["rad", "rad"], output_unit=output_unit, chemical_domain="aqueous alanine dipeptide", thermodynamic_domain="300 K NVT", symmetry_contract="2pi periodic in both coordinates", calibration_method="held-out conformal interval", uncertainty_method="deep ensemble", ood_method="training-support distance", backend_profile_id="cpu-f64-v1", evidence_ids=["held-out-model-report"], validated=true, )
def hybrid_term(): return EquationTermDescriptor( id="term:ala2-free-energy", owner_model_id="ala2-phi-psi-v1", implementation=TermImplementation.hybrid, role=LearnedRole.energy, input_units=["rad", "rad"], output_unit="kJ/mol", symbolic_expression="fourier(phi, psi)", learned_model_id="ala2-hybrid-residual-v1", combination_rule="symbolic_plus_gated_residual", authoritative_outputs=["free_energy"], )
def calibrated_uncertainty(): return PredictionUncertainty( aleatoric=0.02, epistemic=0.03, lower=-0.1, upper=0.1, coverage=0.95, calibrated=true, )
def assess( manifest: LearnedModelManifest, applicability: ApplicabilityDecision, gate: f64, uncertainty: PredictionUncertainty,): return assess_hybrid_prediction( hybrid_term(), manifest, 2.0, -0.25, gate, uncertainty, applicability, 0.01, 0.02, 0.2, 0.1, ["prediction-observation-1"], )
def search_boundary(): return SearchBoundary( id="search:interaction-v1", description="bounded interaction proposals for alanine fixtures", allowed_kinds=[CandidateKind.interaction], max_candidates=4, max_rounds=2, max_compute_units=100, prior_art_sources=["Crossref", "PDB"], safety_policy_id="research-only-v1", )
def interaction_candidate(compute_units: int): return CandidateHypothesis( id="candidate:interaction-1", parent_ids=[], kind=CandidateKind.interaction, representation_digest=digest(), rationale="rank a bounded model-proposed interaction", provenance_ids=["model-run-1"], prior_art_scope_id="search:interaction-v1", model_id="ala2-hybrid-residual-v1", model_version=1, equation_graph_id="ala2-phi-psi-v1", equation_version=1, uncertainty=0.05, requested_compute_units=compute_units, status=CandidateStatus.proposed, rejection_reasons=[], )
test "canonical topology and interaction ownership reject inconsistent state": topology = alanine_topology() ensure topology_valid(topology) invalid_topology = MolecularTopology( id=topology.id, atoms=topology.atoms, bonds=[Bond(left_index=0, right_index=4, order=1)], box=topology.box, source_sha256=topology.source_sha256, ) ensure not topology_valid(invalid_topology) term = InteractionTerm(id="bond:0-1", family="bond", owner_model_id="ff-v1", active=true, target_observable="energy", evidence_ids=["ff-source"]) duplicate = InteractionTerm(id="bond:0-1", family="bond", owner_model_id="other-v1", active=true, target_observable="energy", evidence_ids=["other-source"]) ensure not interaction_ownership_valid([term, duplicate])
test "phase validation needs positive and negative evidence": complete = PhaseEvidence(phase=1, state=PhaseState.validated, profile_id="domain-v1", positive_evidence=["valid-topology"], negative_evidence=["invalid-topology-rejected"], blockers=[]) incomplete = PhaseEvidence(phase=1, state=PhaseState.validated, profile_id="domain-v1", positive_evidence=["valid-topology"], negative_evidence=[], blockers=[]) ensure phase_validated(complete) ensure not phase_validated(incomplete)
test "resolution transition is prepare validate commit and preserves active state on failure": prepared = prepare_transition(0, coarse_edge(approximation(true, 0.05)), 7, 1.0) ensure prepared.state == TransitionState.prepared ensure prepared.from_state_version == 7 ensure prepared.to_state_version == 8 rejected = validate_transition(prepared, [evidence("rejected", false)], 0.2, 0.1) ensure rejected.state == TransitionState.blocked ensure rejected.to_state_version == rejected.from_state_version validated = validate_transition(prepared, [evidence("accepted", true)], 0.05, 0.1) committed = commit_transition(validated) ensure committed.state == TransitionState.committed ensure committed.to_state_version == 8 blocked = prepare_transition(1, coarse_edge(approximation(false, 0.05)), 8, 2.0) ensure blocked.state == TransitionState.blocked ensure commit_transition(blocked).to_state_version == 8
test "hybrid prediction is admitted only inside manifest units calibration and domain": accepted = assess(learned_manifest("kJ/mol"), ApplicabilityDecision.applicable, 0.5, calibrated_uncertainty()) ensure prediction_admissible(accepted) ensure accepted.combined_value == 1.875 wrong_units = assess(learned_manifest("eV"), ApplicabilityDecision.applicable, 0.5, calibrated_uncertainty()) ensure wrong_units.status == PredictionStatus.blocked ensure not prediction_admissible(wrong_units) ood = assess(learned_manifest("kJ/mol"), ApplicabilityDecision.out_of_domain, 0.5, calibrated_uncertainty()) ensure ood.status == PredictionStatus.blocked invalid_gate = assess(learned_manifest("kJ/mol"), ApplicabilityDecision.applicable, 1.5, calibrated_uncertainty()) ensure invalid_gate.status == PredictionStatus.blocked ensure not prediction_admissible(invalid_gate)
test "uncalibrated learned uncertainty fails closed": uncalibrated = PredictionUncertainty( aleatoric=0.01, epistemic=0.01, lower=-0.1, upper=0.1, coverage=0.95, calibrated=false, ) prediction = assess(learned_manifest("kJ/mol"), ApplicabilityDecision.applicable, 0.5, uncalibrated) ensure prediction.status == PredictionStatus.blocked
test "ensemble and coarse observables remain statistical": fine = basin_populations([-1.0, -2.0, -1.5, -2.8], [-0.5, 2.0, 1.5, -2.8]) coarse = BasinPopulations(alpha=0.25, beta=0.5, other=0.25, samples=400) comparison = compare_populations(fine, coarse, 0.26) ensure comparison.passed diagnostics = diagnose_ensemble([1.0, 1.2, 0.8, 1.1, 0.9, 1.0], 3, 3.0) ensure diagnostics.replicas == 3 pmf = corrected_pmf(-7.0, PmfCorrections(restraint_kj_mol=0.5, jacobian_kj_mol=0.2, finite_box_kj_mol=0.1, standard_state_kj_mol=1.0), 0.05, 200.0, 4, true) ensure pmf.corrected_delta_g_kj_mol == -5.2 ensure pmf.validated
test "bounded discovery rejects excess compute and keeps predictions provisional": boundary = search_boundary() candidate = interaction_candidate(40) batch = DiscoveryBatch(boundary_id=boundary.id, round_index=1, candidate_ids=[candidate.id], requested_compute_units=40) ensure validate_discovery_batch(batch, [candidate], boundary) admitted = admit_candidate(candidate, boundary, true, true, true, true, true) ensure admitted.status == CandidateStatus.admitted excessive = admit_candidate(interaction_candidate(101), boundary, true, true, true, true, true) ensure excessive.status == CandidateStatus.rejected proposed_evidence = CandidateEvidence(candidate_id=candidate.id, observation_ids=[], oracle_evidence_ids=[], prior_art_evidence_ids=[], objective_names=["affinity"], objective_values=[0.5], uncertainty=0.1, information_gain=0.2, claim=CandidateClaim.predicted_interaction, status=CandidateStatus.ranked) ensure not may_report_claim(proposed_evidence) ranked_evidence = CandidateEvidence(candidate_id=candidate.id, observation_ids=["prediction-observation-1"], oracle_evidence_ids=[], prior_art_evidence_ids=[], objective_names=["affinity"], objective_values=[0.5], uncertainty=0.1, information_gain=0.2, claim=CandidateClaim.predicted_interaction, status=CandidateStatus.ranked) ensure may_report_claim(ranked_evidence)
test "canonical visual geometry is synchronized with its equation state": term = EquationTermSample(term_id="bond-energy", symbol="E_bond", value=1.2, unit_symbol="kJ/mol", owner_model_id="ff-v1") equation = EquationStateSample(entity_id="atom:CA", model_id="ff-v1", model_version=1, equation_id="bonded-v1", equation_version=1, parameter_version=1, update_kind=EquationUpdateKind.state_step, terms=[term], residuals=[], active_constraints=["bond-length"], transition_id="step:1", cause="backend state step") binding = VisualPrimitiveBinding(primitive_id="sphere:CA", entity_id="atom:CA", observation_id="observation:1", source_state_version=1, scale=VisualScale.atomic, fidelity=FidelityClass.canonical, origin=GeometryOrigin.simulated, source_algorithm="OpenMM position", source_parameters=[]) frame = VisualObservationEnvelope(schema="sema.biological-visual-observation/v1", scenario_id="ala2", run_id="run:1", observation_id="observation:1", physical_time_s=0.001, scheduler_tick=1, state_version=1, resolution_version=1, model_version=1, equation_version=1, parameter_version=1, source_frame_age_ms=10.0, bindings=[binding], equation_states=[equation], dropped_frames=0, interpolation_ratio=0.0) ensure validate_visual_observation(frame) stale = VisualPrimitiveBinding(primitive_id="sphere:CA", entity_id="atom:CA", observation_id="observation:1", source_state_version=2, scale=VisualScale.atomic, fidelity=FidelityClass.canonical, origin=GeometryOrigin.simulated, source_algorithm="stale position", source_parameters=[]) stale_frame = VisualObservationEnvelope(schema=frame.schema, scenario_id=frame.scenario_id, run_id=frame.run_id, observation_id=frame.observation_id, physical_time_s=frame.physical_time_s, scheduler_tick=frame.scheduler_tick, state_version=frame.state_version, resolution_version=frame.resolution_version, model_version=frame.model_version, equation_version=frame.equation_version, parameter_version=frame.parameter_version, source_frame_age_ms=frame.source_frame_age_ms, bindings=[stale], equation_states=[equation], dropped_frames=0, interpolation_ratio=0.0) ensure not validate_visual_observation(stale_frame)
test "semantic zoom renders only evidence-bound scale sources": query = ViewportQuery(query_id="viewport:1", requested_scale=VisualScale.atomic, field_of_view_m=0.0000000005, observation_id="observation:1", state_version=1, resolution_version=1) atomic = SemanticScaleSource(source_id="ala2-atoms", scale=VisualScale.atomic, minimum_length_m=0.0000000001, maximum_length_m=0.000000001, available=true, fidelity=FidelityClass.canonical, origin=GeometryOrigin.simulated, observation_id="observation:1", representation_ids=[VisualRepresentation.particles, VisualRepresentation.topology_bonds], source_algorithm="OpenMM recorded positions and topology",) decision = decide_semantic_zoom(query, [atomic]) ensure decision.renderable ensure decision.fidelity == FidelityClass.canonical ensure decision.source_observation_id == query.observation_id unavailable = SemanticScaleSource(source_id="cell-volume", scale=VisualScale.cellular, minimum_length_m=0.000001, maximum_length_m=0.0001, available=false, fidelity=FidelityClass.unknown, origin=GeometryOrigin.unknown, observation_id="", representation_ids=[], source_algorithm="registered scalar or segmented volume required") cellular_query = ViewportQuery(query_id="viewport:2", requested_scale=VisualScale.cellular, field_of_view_m=0.00005, observation_id="observation:1", state_version=1, resolution_version=1) blocked = decide_semantic_zoom(cellular_query, [atomic, unavailable]) ensure not blocked.renderable ensure blocked.fidelity == FidelityClass.unknown outside_atomic_range = ViewportQuery(query_id="viewport:3", requested_scale=VisualScale.atomic, field_of_view_m=0.00000001, observation_id="observation:1", state_version=1, resolution_version=1) range_blocked = decide_semantic_zoom(outside_atomic_range, [atomic]) ensure not range_blocked.renderable
test "field of view bounds multiscale GPU work and preserves focus": focus = EntityFocusPath(path_id="focus:1", entity_ids=["TISSUE:PANCREAS", "ISLET:01", "CELL:BETA:0001", "PROTEIN:INSULIN"], selected_depth=2) ensure focus_path_valid(focus) scenario = ComplexityScenario(id="healthy-fed", glucose_millimolar=8.0, oxygen_fraction=0.96, cytokine_fraction=0.05, insulin_demand_fraction=0.55, illustrative=true) ensure scenario.illustrative bounded = decide_multiscale_compute(FieldOfViewBudget(field_of_view_m=0.00000005, candidate_instances=30000, required_upload_bytes=65536, desired_update_hz=60, max_visible_instances=16384, max_upload_bytes=262144, max_update_hz=60)) ensure bounded.scale == VisualScale.molecular ensure bounded.admissible ensure bounded.visible_instances == 16384 blocked = decide_multiscale_compute(FieldOfViewBudget(field_of_view_m=0.0005, candidate_instances=2000, required_upload_bytes=300000, desired_update_hz=30, max_visible_instances=16384, max_upload_bytes=262144, max_update_hz=60)) ensure blocked.scale == VisualScale.tissue ensure not blocked.admissible
test "native acceleration selects measured evidence rather than backend labels": demand = KernelDemand(operation="surface-projection", precision="f32", tolerance_profile="visual-proxy-v1", minimum_throughput_per_s=30.0, maximum_p95_ms=8.0, maximum_observable_error=0.1, maximum_resident_memory_bytes=100000000) cpu = NativeAccelerationProfile(profile_id="fixture-cpu", kernel_id="surface-v1", native_kind=NativeKernelKind.sema_aot, accelerator=AcceleratorKind.cpu, device_name="fixture CPU", precision="f32", tolerance_profile="visual-proxy-v1", available=true, qualified=true, zero_copy=true, unified_memory=true, supported_operations=["surface-projection"], measured_throughput_per_s=60.0, measured_p95_ms=2.5, observable_error=0.01, resident_memory_bytes=1000000, host_device_transfer_bytes=0, artifact_sha256=digest(), model_sha256=digest(), oracle_evidence_ids=["fixture-oracle"], benchmark_evidence_ids=["fixture-benchmark"]) cuda = NativeAccelerationProfile(profile_id="fixture-cuda", kernel_id="surface-v1", native_kind=NativeKernelKind.cpp_abi, accelerator=AcceleratorKind.cuda, device_name="fixture CUDA", precision="f32", tolerance_profile="visual-proxy-v1", available=true, qualified=true, zero_copy=false, unified_memory=false, supported_operations=["surface-projection"], measured_throughput_per_s=90.0, measured_p95_ms=1.5, observable_error=0.01, resident_memory_bytes=2000000, host_device_transfer_bytes=4000000, artifact_sha256=digest(), model_sha256=digest(), oracle_evidence_ids=["fixture-oracle"], benchmark_evidence_ids=["fixture-benchmark"]) mlx = NativeAccelerationProfile(profile_id="fixture-mlx", kernel_id="surface-v1", native_kind=NativeKernelKind.cpp_abi, accelerator=AcceleratorKind.mlx, device_name="fixture unified GPU", precision="f32", tolerance_profile="visual-proxy-v1", available=true, qualified=true, zero_copy=true, unified_memory=true, supported_operations=["surface-projection"], measured_throughput_per_s=80.0, measured_p95_ms=0.9, observable_error=0.01, resident_memory_bytes=1500000, host_device_transfer_bytes=0, artifact_sha256=digest(), model_sha256=digest(), oracle_evidence_ids=["fixture-oracle"], benchmark_evidence_ids=["fixture-benchmark"]) declared_only = NativeAccelerationProfile(profile_id="fixture-unqualified", kernel_id="surface-v1", native_kind=NativeKernelKind.cpp_abi, accelerator=AcceleratorKind.cuda, device_name="fixture unavailable evidence", precision="f32", tolerance_profile="visual-proxy-v1", available=true, qualified=false, zero_copy=true, unified_memory=false, supported_operations=["surface-projection"], measured_throughput_per_s=1000.0, measured_p95_ms=0.1, observable_error=0.0, resident_memory_bytes=1000, host_device_transfer_bytes=0, artifact_sha256=digest(), model_sha256=digest(), oracle_evidence_ids=[], benchmark_evidence_ids=[]) selected = select_native_acceleration(demand, [cpu, cuda, mlx, declared_only]) ensure selected.selected ensure selected.profile_id == "fixture-mlx" ensure selected.zero_copy
test "advanced phase profiles fail closed without complete evidence": partition = QmMmPartition(id="qmmm:1", qm_atom_indices=[0], mm_atom_indices=[1, 2], boundary_atom_indices=[1], total_charge_e=0, spin_multiplicity=1, embedding="electrostatic", backend_profile_id="qmmm-backend-v1") ensure qmmm_partition_valid(partition, 3) invalid_partition = QmMmPartition(id="qmmm:bad", qm_atom_indices=[0, 1], mm_atom_indices=[1, 2], boundary_atom_indices=[1], total_charge_e=0, spin_multiplicity=1, embedding="electrostatic", backend_profile_id="qmmm-backend-v1") ensure not qmmm_partition_valid(invalid_partition, 3) parameters = ParameterizationEdge(id="edge:qmmm-to-mm", source_model_id="qmmm-v1", target_model_id="ff-v2", parameter_names=["charge"], values=[-0.2], uncertainties=[0.01], units=["e"], evidence_ids=["fit-report"]) ensure parameterization_valid(parameters) reference = PlatformBenchmark(profile_id="cpu-ref", hardware="Apple Silicon", operating_system="Darwin", backend="OpenMM", precision="mixed", model_digest=digest(), tolerance_profile="ala2-v1", simulated_ns_per_day=1.0, p50_step_ms=1.0, p95_step_ms=2.0, resident_memory_bytes=1000, transfer_bytes=0, observable_error=0.01, evidence_ids=["benchmark-ref"]) candidate = PlatformBenchmark(profile_id="cpu-candidate", hardware="Apple Silicon", operating_system="Darwin", backend="OpenMM", precision="mixed", model_digest=digest(), tolerance_profile="ala2-v1", simulated_ns_per_day=1.1, p50_step_ms=0.9, p95_step_ms=1.8, resident_memory_bytes=1000, transfer_bytes=0, observable_error=0.01, evidence_ids=["benchmark-candidate"]) ensure benchmark_comparable(reference, candidate)src/binding.sema
Section titled “src/binding.sema”"""Bounded, deterministic ligand/target docking and designed-species physiology coupling.
Every number produced here is an empirical rank, never a measurement. The scoring function andits calibration constants are published on each result so a reader can see exactly how a scorebecomes a free energy, and every payload carries `scientific_validated: false`."""
import mathfrom biological_computer.physiology import initial_physiology_parameters, physiology_parameter_bounds
assure silver
BINDING_SCHEMA = "sema.molecular-binding-result/v1"SPECIES_SCHEMA = "sema.designed-species-state/v1"SCORING_FUNCTION = "lj12-6 + dd-dielectric coulomb + gaussian hydrophobic contact"CALIBRATION_NAME = "linear_score_to_free_energy_v1"CALIBRATION_SLOPE = 0.35CALIBRATION_INTERCEPT = -4.0CALIBRATION_NOTE = "empirical rank-to-energy map: delta_g = 0.35 * score - 4.0 kJ/mol, chosen so bounded fragment scores land in a plausible micromolar window. It is not regressed against measured affinities and must never be read as one."GAS_CONSTANT_KJ_PER_MOL_K = 0.0083145BODY_TEMPERATURE_K = 310.15INTERACTION_CUTOFF_ANGSTROM = 8.0CLOSE_CONTACT_ANGSTROM = 0.8CLASH_DISTANCE_ANGSTROM = 2.2CLASH_STIFFNESS_KJ_PER_MOL_ANGSTROM2 = 400.0LJ_PAIR_CEILING_KJ_PER_MOL = 200.0COULOMB_CONSTANT_KJ_ANGSTROM_PER_MOL = 1389.35DIELECTRIC_SLOPE = 4.0HYDROPHOBIC_DEPTH_KJ_PER_MOL = 0.35HYDROPHOBIC_CENTER_ANGSTROM = 4.0HYDROPHOBIC_WIDTH_ANGSTROM = 1.2CONTACT_DISTANCE_ANGSTROM = 4.5BURIAL_DISTANCE_ANGSTROM = 5.0MAX_CONTACTS = 64MAX_TARGET_ATOMS = 4096MAX_LIGAND_ATOMS = 512MAX_SPECIES = 16MIN_POSE_BUDGET = 64DEFAULT_POSE_BUDGET = 512MAX_POSE_BUDGET = 4096ANGLE_LADDER_STEPS = 6TRANSLATION_HALF_EXTENT_ANGSTROM = 2.0POSE_TRANSLATION_LIMIT_ANGSTROM = 3.6GRID_CELL_ANGSTROM = 4.0POCKET_PROBE_LIMIT = 512POCKET_COARSE_SPACING_ANGSTROM = 3.0POCKET_FINE_STEPS = 2POCKET_MIN_CLEARANCE_ANGSTROM = 2.6POCKET_MAX_CLEARANCE_ANGSTROM = 8.0POCKET_CLUSTER_FRACTION = 0.9REFINEMENT_MAX_STEPS = 24REFINEMENT_TRANSLATION_STEP_ANGSTROM = 0.8REFINEMENT_ROTATION_STEP_RADIAN = 0.14REFINEMENT_TOLERANCE_ANGSTROM = 0.1MIN_CONCENTRATION_MICROMOLAR = 0.000001MAX_CONCENTRATION_MICROMOLAR = 1000000.0MIN_KD_MICROMOLAR = 0.000001MAX_KD_MICROMOLAR = 1000000.0IMMUNE_SHIELDING_CEILING = 1.0EXOGENOUS_INSULIN_CEILING = 5000.0
def lj_parameters(atomic_number: int): """OPLS-AA style [sigma in Angstrom, epsilon in kJ/mol]; unmapped elements fall back to carbon.""" if atomic_number == 1: return [2.42, 0.0657] if atomic_number == 6: return [3.40, 0.3598] if atomic_number == 7: return [3.25, 0.7113] if atomic_number == 8: return [2.96, 0.8786] if atomic_number == 9: return [3.12, 0.2552] if atomic_number == 11: return [2.35, 0.5443] if atomic_number == 12: return [1.64, 3.6610] if atomic_number == 15: return [3.74, 0.8368] if atomic_number == 16: return [3.55, 1.0460] if atomic_number == 17: return [3.47, 1.1087] if atomic_number == 20: return [2.41, 2.1502] if atomic_number == 26: return [2.19, 0.0134] if atomic_number == 30: return [1.96, 0.0523] return [3.40, 0.3598]
def partial_charge(atomic_number: int, degree: int, polar_neighbours: int): """Bounded element-plus-bond-context charge in elementary charge units; no QM, no force-field fit.""" if atomic_number == 1: return 0.30 if polar_neighbours > 0 else 0.06 if atomic_number == 6: return min(0.40, 0.14 * polar_neighbours) if atomic_number == 7: return -0.45 if atomic_number == 8: return -0.50 if degree <= 1 else -0.40 if atomic_number == 15: return 0.60 if atomic_number == 16: return -0.20 if atomic_number == 9 or atomic_number == 17: return -0.20 if atomic_number == 11: return 1.00 if atomic_number == 12 or atomic_number == 20 or atomic_number == 26 or atomic_number == 30: return 2.00 return 0.0
def partial_charges(atomic_numbers: list[int], bond_pairs: list[int]): mut degree = [0 for atomic_number in atomic_numbers] mut polar = [0 for atomic_number in atomic_numbers] for bond_index in range(len(bond_pairs) // 2): left = bond_pairs[bond_index * 2] right = bond_pairs[bond_index * 2 + 1] degree[left] = degree[left] + 1 degree[right] = degree[right] + 1 if atomic_numbers[right] == 7 or atomic_numbers[right] == 8: polar[left] = polar[left] + 1 if atomic_numbers[left] == 7 or atomic_numbers[left] == 8: polar[right] = polar[right] + 1 return [partial_charge(atomic_numbers[index], degree[index], polar[index]) for index in range(len(atomic_numbers))]
def bounding_box(x: list[f64], y: list[f64], z: list[f64]): mut minimum = [x[0], y[0], z[0]] mut maximum = [x[0], y[0], z[0]] for index in range(len(x)): minimum = [min(minimum[0], x[index]), min(minimum[1], y[index]), min(minimum[2], z[index])] maximum = [max(maximum[0], x[index]), max(maximum[1], y[index]), max(maximum[2], z[index])] return [minimum, maximum]
def neighbour_grid(x: list[f64], y: list[f64], z: list[f64], cell_size: f64, minimum: list[f64], maximum: list[f64]): """Uniform bucket grid in compressed-row form: `starts[cell]..starts[cell + 1]` indexes `entries`.""" counts = [max(1, math.floor((maximum[axis] - minimum[axis]) / cell_size) + 1) for axis in range(3)] cell_count = counts[0] * counts[1] * counts[2] mut cell_of = [0 for index in range(len(x))] mut starts = [0 for cell in range(cell_count + 1)] for index in range(len(x)): cell_x = min(counts[0] - 1, max(0, math.floor((x[index] - minimum[0]) / cell_size))) cell_y = min(counts[1] - 1, max(0, math.floor((y[index] - minimum[1]) / cell_size))) cell_z = min(counts[2] - 1, max(0, math.floor((z[index] - minimum[2]) / cell_size))) cell = (cell_x * counts[1] + cell_y) * counts[2] + cell_z cell_of[index] = cell starts[cell + 1] = starts[cell + 1] + 1 for cell in range(cell_count): starts[cell + 1] = starts[cell + 1] + starts[cell] mut cursor = [starts[cell] for cell in range(cell_count)] mut entries = [0 for index in range(len(x))] for index in range(len(x)): cell = cell_of[index] entries[cursor[cell]] = index cursor[cell] = cursor[cell] + 1 return {"origin": minimum, "counts": counts, "cell_size": cell_size, "starts": starts, "entries": entries}
def probe_metrics(grid: dict[str, any], x: list[f64], y: list[f64], z: list[f64], point: list[f64]): """One grid walk yielding [atoms within 8 A, atoms within 3 A, distance to the closest atom].""" origin = grid["origin"] counts = grid["counts"] cell_size = grid["cell_size"] starts = grid["starts"] entries = grid["entries"] far_squared = INTERACTION_CUTOFF_ANGSTROM * INTERACTION_CUTOFF_ANGSTROM near_squared = 9.0 low_x = max(0, math.floor((point[0] - INTERACTION_CUTOFF_ANGSTROM - origin[0]) / cell_size)) high_x = min(counts[0] - 1, math.floor((point[0] + INTERACTION_CUTOFF_ANGSTROM - origin[0]) / cell_size)) low_y = max(0, math.floor((point[1] - INTERACTION_CUTOFF_ANGSTROM - origin[1]) / cell_size)) high_y = min(counts[1] - 1, math.floor((point[1] + INTERACTION_CUTOFF_ANGSTROM - origin[1]) / cell_size)) low_z = max(0, math.floor((point[2] - INTERACTION_CUTOFF_ANGSTROM - origin[2]) / cell_size)) high_z = min(counts[2] - 1, math.floor((point[2] + INTERACTION_CUTOFF_ANGSTROM - origin[2]) / cell_size)) mut far = 0 mut near = 0 mut closest = far_squared for cell_x in range(low_x, high_x + 1): for cell_y in range(low_y, high_y + 1): row = (cell_x * counts[1] + cell_y) * counts[2] for cell_z in range(low_z, high_z + 1): cell = row + cell_z for slot in range(starts[cell], starts[cell + 1]): index = entries[slot] dx = point[0] - x[index] dy = point[1] - y[index] dz = point[2] - z[index] separation = dx * dx + dy * dy + dz * dz if separation >= far_squared: continue far = far + 1 if separation < near_squared: near = near + 1 if separation < closest: closest = separation return [far - near, math.sqrt(closest)]
def pocket_site(grid: dict[str, any], x: list[f64], y: list[f64], z: list[f64]) -> dict[str, any]: """Highest-buriedness placeable grid point, refined on a local sub-lattice and averaged over its cluster.
A probe is placeable when its closest target atom sits in [POCKET_MIN_CLEARANCE_ANGSTROM, POCKET_MAX_CLEARANCE_ANGSTROM]: close enough to be a surface cavity rather than bulk solvent, open enough for a ligand heavy atom to occupy. Without that filter the verbatim argmax lands in the protein core (measured on 6S34: clearance 0.67 Angstrom), where every pose clashes. """ box = bounding_box(x, y, z) minimum = box[0] maximum = box[1] mut spacing = POCKET_COARSE_SPACING_ANGSTROM mut steps = [1, 1, 1] for attempt in range(8): steps = [max(1, math.floor((maximum[axis] - minimum[axis] + 2.0 * POCKET_MIN_CLEARANCE_ANGSTROM) / spacing) + 1) for axis in range(3)] if steps[0] * steps[1] * steps[2] <= POCKET_PROBE_LIMIT: break spacing = spacing * 1.25 origin = [minimum[axis] - POCKET_MIN_CLEARANCE_ANGSTROM for axis in range(3)] mut center = [(minimum[axis] + maximum[axis]) * 0.5 for axis in range(3)] mut best = -1.0 mut probes = 0 for step_x in range(steps[0]): for step_y in range(steps[1]): for step_z in range(steps[2]): point = [origin[0] + step_x * spacing, origin[1] + step_y * spacing, origin[2] + step_z * spacing] metrics = probe_metrics(grid, x, y, z, point) probes = probes + 1 if metrics[1] < POCKET_MIN_CLEARANCE_ANGSTROM or metrics[1] >= POCKET_MAX_CLEARANCE_ANGSTROM: continue if metrics[0] > best: best = metrics[0] center = point fine_spacing = spacing / (2.0 * POCKET_FINE_STEPS) mut cluster = [0.0, 0.0, 0.0] mut cluster_size = 0 for step_x in range(-POCKET_FINE_STEPS, POCKET_FINE_STEPS + 1): for step_y in range(-POCKET_FINE_STEPS, POCKET_FINE_STEPS + 1): for step_z in range(-POCKET_FINE_STEPS, POCKET_FINE_STEPS + 1): point = [center[0] + step_x * fine_spacing, center[1] + step_y * fine_spacing, center[2] + step_z * fine_spacing] metrics = probe_metrics(grid, x, y, z, point) probes = probes + 1 if metrics[1] < POCKET_MIN_CLEARANCE_ANGSTROM or metrics[1] >= POCKET_MAX_CLEARANCE_ANGSTROM: continue if metrics[0] > best: best = metrics[0] if metrics[0] >= POCKET_CLUSTER_FRACTION * best: cluster = [cluster[axis] + point[axis] for axis in range(3)] cluster_size = cluster_size + 1 if cluster_size > 0: center = [cluster[axis] / cluster_size for axis in range(3)] return {"center": center, "buriedness": best, "probes": probes, "spacing": spacing}
def quaternion_from_axis_angle(axis: list[f64], angle: f64): half = math.sin(angle * 0.5) return [math.cos(angle * 0.5), axis[0] * half, axis[1] * half, axis[2] * half]
def quaternion_multiply(left: list[f64], right: list[f64]): return [ left[0] * right[0] - left[1] * right[1] - left[2] * right[2] - left[3] * right[3], left[0] * right[1] + left[1] * right[0] + left[2] * right[3] - left[3] * right[2], left[0] * right[2] - left[1] * right[3] + left[2] * right[0] + left[3] * right[1], left[0] * right[3] + left[1] * right[2] - left[2] * right[1] + left[3] * right[0], ]
def rotation_from_quaternion(q: list[f64]): """Row-major 3x3 rotation matrix from a unit quaternion [w, x, y, z].""" w = q[0] x = q[1] y = q[2] z = q[3] return [ 1.0 - 2.0 * (y * y + z * z), 2.0 * (x * y - z * w), 2.0 * (x * z + y * w), 2.0 * (x * y + z * w), 1.0 - 2.0 * (x * x + z * z), 2.0 * (y * z - x * w), 2.0 * (x * z - y * w), 2.0 * (y * z + x * w), 1.0 - 2.0 * (x * x + y * y), ]
def golden_spiral_axis(index: int, count: int): """Deterministic quasi-uniform unit axis; the spiral increment is the golden angle pi (3 - sqrt 5).""" height = 1.0 - 2.0 * (index + 0.5) / count radius = math.sqrt(max(0.0, 1.0 - height * height)) azimuth = math.pi * (3.0 - math.sqrt(5.0)) * index return [radius * math.cos(azimuth), radius * math.sin(azimuth), height]
def translation_lattice(half_extent: f64): """Nine deterministic offsets: the pocket point plus the eight corners of a cube around it.""" mut lattice = [[0.0, 0.0, 0.0]] for corner in range(8): lattice.append([ half_extent if corner % 2 == 0 else -half_extent, half_extent if (corner // 2) % 2 == 0 else -half_extent, half_extent if (corner // 4) % 2 == 0 else -half_extent, ]) return lattice
def posed_coordinates(probe: dict[str, any], rotation: list[f64], center: list[f64], translation: list[f64]): local_x = probe["x"] local_y = probe["y"] local_z = probe["z"] shift_x = center[0] + translation[0] shift_y = center[1] + translation[1] shift_z = center[2] + translation[2] mut pose_x = [0.0 for value in local_x] mut pose_y = [0.0 for value in local_y] mut pose_z = [0.0 for value in local_z] for index in range(len(local_x)): px = local_x[index] py = local_y[index] pz = local_z[index] pose_x[index] = rotation[0] * px + rotation[1] * py + rotation[2] * pz + shift_x pose_y[index] = rotation[3] * px + rotation[4] * py + rotation[5] * pz + shift_y pose_z[index] = rotation[6] * px + rotation[7] * py + rotation[8] * pz + shift_z return [pose_x, pose_y, pose_z]
def score_pose(field: dict[str, any], probe: dict[str, any], pose: list[list[f64]]): """Interaction terms [lennard_jones, coulomb, hydrophobic, clash] in kJ/mol for one rigid pose.
Cost is O(n_ligand * k) where k is the number of shell atoms in the grid cells overlapping an 8 Angstrom sphere. The grid holds the pocket shell only, so k tracks local packing density and never the target atom count: a 3948-atom target costs the same as a 796-atom one. """ pose_x = pose[0] pose_y = pose[1] pose_z = pose[2] probe_sigma = probe["sigma"] probe_root_epsilon = probe["root_epsilon"] probe_coulomb = probe["coulomb"] probe_carbon = probe["carbon"] shell_x = field["x"] shell_y = field["y"] shell_z = field["z"] shell_sigma = field["sigma"] shell_root_epsilon = field["root_epsilon"] shell_charge = field["charge"] shell_carbon = field["carbon"] grid = field["grid"] origin = grid["origin"] counts = grid["counts"] cell_size = grid["cell_size"] starts = grid["starts"] entries = grid["entries"] last_x = counts[0] - 1 last_y = counts[1] - 1 last_z = counts[2] - 1 stride_y = counts[2] stride_x = counts[1] * counts[2] cutoff_squared = INTERACTION_CUTOFF_ANGSTROM * INTERACTION_CUTOFF_ANGSTROM mut lennard_jones = 0.0 mut coulomb = 0.0 mut hydrophobic = 0.0 mut clash = 0.0 for index in range(len(pose_x)): px = pose_x[index] py = pose_y[index] pz = pose_z[index] sigma_i = probe_sigma[index] root_epsilon_i = probe_root_epsilon[index] coulomb_i = probe_coulomb[index] carbon_i = probe_carbon[index] low_x = max(0, math.floor((px - INTERACTION_CUTOFF_ANGSTROM - origin[0]) / cell_size)) high_x = min(last_x, math.floor((px + INTERACTION_CUTOFF_ANGSTROM - origin[0]) / cell_size)) low_y = max(0, math.floor((py - INTERACTION_CUTOFF_ANGSTROM - origin[1]) / cell_size)) high_y = min(last_y, math.floor((py + INTERACTION_CUTOFF_ANGSTROM - origin[1]) / cell_size)) low_z = max(0, math.floor((pz - INTERACTION_CUTOFF_ANGSTROM - origin[2]) / cell_size)) high_z = min(last_z, math.floor((pz + INTERACTION_CUTOFF_ANGSTROM - origin[2]) / cell_size)) for cell_x in range(low_x, high_x + 1): for cell_y in range(low_y, high_y + 1): row = cell_x * stride_x + cell_y * stride_y for cell_z in range(low_z, high_z + 1): cell = row + cell_z for slot in range(starts[cell], starts[cell + 1]): target_index = entries[slot] dx = px - shell_x[target_index] dy = py - shell_y[target_index] dz = pz - shell_z[target_index] separation = dx * dx + dy * dy + dz * dz if separation >= cutoff_squared: continue distance = math.sqrt(separation) guarded = max(distance, CLOSE_CONTACT_ANGSTROM) ratio = (sigma_i + shell_sigma[target_index]) * 0.5 / guarded ratio_six = ratio * ratio * ratio ratio_six = ratio_six * ratio_six lennard_jones = lennard_jones + min(LJ_PAIR_CEILING_KJ_PER_MOL, 4.0 * root_epsilon_i * shell_root_epsilon[target_index] * ratio_six * (ratio_six - 1.0)) coulomb = coulomb + coulomb_i * shell_charge[target_index] / (guarded * guarded) if carbon_i and shell_carbon[target_index]: spread = (distance - HYDROPHOBIC_CENTER_ANGSTROM) / HYDROPHOBIC_WIDTH_ANGSTROM hydrophobic = hydrophobic - HYDROPHOBIC_DEPTH_KJ_PER_MOL * math.exp(-spread * spread) if distance < CLASH_DISTANCE_ANGSTROM: gap = CLASH_DISTANCE_ANGSTROM - distance clash = clash + CLASH_STIFFNESS_KJ_PER_MOL_ANGSTROM2 * gap * gap return [lennard_jones, coulomb, hydrophobic, clash]
def pose_energy(field: dict[str, any], probe: dict[str, any], pose: list[list[f64]]): terms = score_pose(field, probe, pose) return terms[0] + terms[1] + terms[2] + terms[3]
def refined_state(field: dict[str, any], probe: dict[str, any], center: list[f64], base: list[f64], start: list[f64]): """Bounded local coordinate descent over three translations and three body-frame rotations.""" mut state = [value for value in start] mut best = pose_energy(field, probe, posed_coordinates(probe, rotation_from_quaternion(descent_quaternion(base, state)), center, state)) mut translation_step = REFINEMENT_TRANSLATION_STEP_ANGSTROM mut rotation_step = REFINEMENT_ROTATION_STEP_RADIAN mut steps = 0 mut converged = false while steps < REFINEMENT_MAX_STEPS: steps = steps + 1 mut improved = false for axis in range(6): for direction in range(2): delta = translation_step if axis < 3 else rotation_step mut candidate = [value for value in state] candidate[axis] = candidate[axis] + (delta if direction == 0 else -delta) if candidate[0] * candidate[0] + candidate[1] * candidate[1] + candidate[2] * candidate[2] > POSE_TRANSLATION_LIMIT_ANGSTROM * POSE_TRANSLATION_LIMIT_ANGSTROM: continue trial = pose_energy(field, probe, posed_coordinates(probe, rotation_from_quaternion(descent_quaternion(base, candidate)), center, candidate)) if trial < best - 0.000001: best = trial state = candidate improved = true if not improved: translation_step = translation_step * 0.5 rotation_step = rotation_step * 0.5 if translation_step < REFINEMENT_TOLERANCE_ANGSTROM: converged = true break return {"state": state, "score": best, "steps": steps, "converged": converged}
def descent_quaternion(base: list[f64], state: list[f64]): """Enumerated orientation composed with the descent's body-frame x, y, then z rotations.""" rotated = quaternion_multiply(quaternion_from_axis_angle([1.0, 0.0, 0.0], state[3]), base) rotated = quaternion_multiply(quaternion_from_axis_angle([0.0, 1.0, 0.0], state[4]), rotated) return quaternion_multiply(quaternion_from_axis_angle([0.0, 0.0, 1.0], state[5]), rotated)
def structure_positions(structure: dict[str, any]): return structure["positions"]
def structure_bonds(structure: dict[str, any]): return structure["bonds"] if structure.has("bonds") else structure["bond_pairs"]
pub def docking_rejection(target: dict[str, any], ligand: dict[str, any], budget: int) -> str !{}: """Empty string when the pair is dockable, otherwise the reason a caller should report as 422.""" if not target.has("positions") or not target.has("atomic_numbers"): return "target is not a loaded molecular session" if not ligand.has("positions") or not ligand.has("atomic_numbers"): return "ligand structure carries no positions or atomic numbers" if not ligand.has("bonds") and not ligand.has("bond_pairs"): return "ligand structure carries no bond list" target_atoms = len(target["atomic_numbers"]) ligand_atoms = len(ligand["atomic_numbers"]) if target_atoms < 1 or target_atoms > MAX_TARGET_ATOMS: return "target must carry 1.." + str(MAX_TARGET_ATOMS) + " atoms" if ligand_atoms < 1 or ligand_atoms > MAX_LIGAND_ATOMS: return "ligand must carry 1.." + str(MAX_LIGAND_ATOMS) + " atoms" if len(target["positions"]) != target_atoms * 3: return "target positions must hold three Angstrom coordinates per atom" if len(structure_positions(ligand)) != ligand_atoms * 3: return "ligand positions must hold three Angstrom coordinates per atom" ligand_bonds = structure_bonds(ligand) if len(ligand_bonds) % 2 != 0: return "ligand bond list must hold index pairs" for atom_index in ligand_bonds: if atom_index < 0 or atom_index >= ligand_atoms: return "ligand bond list references an atom outside the structure" if budget != 0 and (budget < MIN_POSE_BUDGET or budget > MAX_POSE_BUDGET): return "pose budget must be 0 for the default or " + str(MIN_POSE_BUDGET) + ".." + str(MAX_POSE_BUDGET) return ""
def clamped_budget(budget: int): if budget <= 0: return DEFAULT_POSE_BUDGET return min(MAX_POSE_BUDGET, max(MIN_POSE_BUDGET, budget))
def target_field(target: dict[str, any], center: list[f64], pose_reach: f64): """Pocket shell: every target atom a posed ligand atom could reach, with its grid and Verlet lists.""" positions = target["positions"] atomic_numbers = target["atomic_numbers"] charges = partial_charges(atomic_numbers, target["bond_pairs"]) mut x: list[f64] = [] mut y: list[f64] = [] mut z: list[f64] = [] mut sigma: list[f64] = [] mut root_epsilon: list[f64] = [] mut charge: list[f64] = [] mut carbon: list[bool] = [] mut source: list[int] = [] reach_squared = (INTERACTION_CUTOFF_ANGSTROM + pose_reach) * (INTERACTION_CUTOFF_ANGSTROM + pose_reach) for atom_index in range(len(atomic_numbers)): offset = atom_index * 3 dx = positions[offset] - center[0] dy = positions[offset + 1] - center[1] dz = positions[offset + 2] - center[2] if dx * dx + dy * dy + dz * dz > reach_squared: continue parameters = lj_parameters(atomic_numbers[atom_index]) x.append(positions[offset]) y.append(positions[offset + 1]) z.append(positions[offset + 2]) sigma.append(parameters[0]) root_epsilon.append(math.sqrt(parameters[1])) charge.append(charges[atom_index]) carbon.append(atomic_numbers[atom_index] == 6) source.append(atom_index) box = bounding_box(x, y, z) minimum = [min(box[0][axis], center[axis] - pose_reach) for axis in range(3)] maximum = [max(box[1][axis], center[axis] + pose_reach) for axis in range(3)] grid = neighbour_grid(x, y, z, GRID_CELL_ANGSTROM, minimum, maximum) return { "x": x, "y": y, "z": z, "sigma": sigma, "root_epsilon": root_epsilon, "charge": charge, "carbon": carbon, "source": source, "grid": grid, }
def ligand_probe(ligand: dict[str, any]) -> dict[str, any]: """Ligand recentred on its centroid; the internal geometry is never re-optimised (rigid ligand).""" positions = structure_positions(ligand) atomic_numbers = ligand["atomic_numbers"] charges = partial_charges(atomic_numbers, structure_bonds(ligand)) count = len(atomic_numbers) mut centroid = [0.0, 0.0, 0.0] for atom_index in range(count): offset = atom_index * 3 centroid = [centroid[0] + positions[offset], centroid[1] + positions[offset + 1], centroid[2] + positions[offset + 2]] centroid = [centroid[axis] / count for axis in range(3)] mut x = [0.0 for atom_index in range(count)] mut y = [0.0 for atom_index in range(count)] mut z = [0.0 for atom_index in range(count)] mut sigma = [0.0 for atom_index in range(count)] mut root_epsilon = [0.0 for atom_index in range(count)] mut coulomb = [0.0 for atom_index in range(count)] mut carbon = [false for atom_index in range(count)] mut radius = 0.0 for atom_index in range(count): offset = atom_index * 3 x[atom_index] = positions[offset] - centroid[0] y[atom_index] = positions[offset + 1] - centroid[1] z[atom_index] = positions[offset + 2] - centroid[2] radius = max(radius, math.sqrt(x[atom_index] * x[atom_index] + y[atom_index] * y[atom_index] + z[atom_index] * z[atom_index])) parameters = lj_parameters(atomic_numbers[atom_index]) sigma[atom_index] = parameters[0] root_epsilon[atom_index] = math.sqrt(parameters[1]) coulomb[atom_index] = COULOMB_CONSTANT_KJ_ANGSTROM_PER_MOL * charges[atom_index] / DIELECTRIC_SLOPE carbon[atom_index] = atomic_numbers[atom_index] == 6 return {"x": x, "y": y, "z": z, "sigma": sigma, "root_epsilon": root_epsilon, "coulomb": coulomb, "carbon": carbon, "radius": radius, "centroid": centroid}
def pose_contacts(field: dict[str, any], pose: list[list[f64]]): """The MAX_CONTACTS shortest ligand/target contacts under CONTACT_DISTANCE_ANGSTROM, nearest first.""" pose_x = pose[0] pose_y = pose[1] pose_z = pose[2] shell_x = field["x"] shell_y = field["y"] shell_z = field["z"] source = field["source"] limit_squared = CONTACT_DISTANCE_ANGSTROM * CONTACT_DISTANCE_ANGSTROM mut distances: list[f64] = [] mut probe_indices: list[int] = [] mut target_indices: list[int] = [] for index in range(len(pose_x)): for shell_index in range(len(shell_x)): dx = pose_x[index] - shell_x[shell_index] dy = pose_y[index] - shell_y[shell_index] dz = pose_z[index] - shell_z[shell_index] separation = dx * dx + dy * dy + dz * dz if separation >= limit_squared: continue distance = math.sqrt(separation) filled = len(distances) if filled == MAX_CONTACTS and distance >= distances[filled - 1]: continue if filled < MAX_CONTACTS: distances.append(distance) probe_indices.append(index) target_indices.append(source[shell_index]) else: distances[filled - 1] = distance probe_indices[filled - 1] = index target_indices[filled - 1] = source[shell_index] mut slot = len(distances) - 1 while slot > 0 and distances[slot] < distances[slot - 1]: held_distance = distances[slot - 1] held_probe = probe_indices[slot - 1] held_target = target_indices[slot - 1] distances[slot - 1] = distances[slot] probe_indices[slot - 1] = probe_indices[slot] target_indices[slot - 1] = target_indices[slot] distances[slot] = held_distance probe_indices[slot] = held_probe target_indices[slot] = held_target slot = slot - 1 return [[probe_indices[slot], target_indices[slot], distances[slot]] for slot in range(len(distances))]
def buried_ligand_fraction(field: dict[str, any], pose: list[list[f64]]): pose_x = pose[0] pose_y = pose[1] pose_z = pose[2] shell_x = field["x"] shell_y = field["y"] shell_z = field["z"] limit_squared = BURIAL_DISTANCE_ANGSTROM * BURIAL_DISTANCE_ANGSTROM mut buried = 0 for index in range(len(pose_x)): for shell_index in range(len(shell_x)): dx = pose_x[index] - shell_x[shell_index] dy = pose_y[index] - shell_y[shell_index] dz = pose_z[index] - shell_z[shell_index] if dx * dx + dy * dy + dz * dz < limit_squared: buried = buried + 1 break return buried / len(pose_x)
pub def free_energy_kj_mol(score: f64) -> f64 !{}: return CALIBRATION_SLOPE * score + CALIBRATION_INTERCEPT
pub def dissociation_constant_micromolar(delta_g_kj_mol: f64) -> f64 !{}: """Kd = exp(dG / RT) * 1e6 uM at 310.15 K, clamped to the published reporting window.""" exponent = max(-40.0, min(40.0, delta_g_kj_mol / (GAS_CONSTANT_KJ_PER_MOL_K * BODY_TEMPERATURE_K))) return max(MIN_KD_MICROMOLAR, min(MAX_KD_MICROMOLAR, math.exp(exponent) * 1000000.0))
pub def dock_ligand(target: dict[str, any], ligand: dict[str, any], budget: int) -> dict[str, any] !{}: sem "Rank a rigid ligand pose against a target pocket with a published empirical scoring function" require docking_rejection(target, ligand, budget) == "" ensure result["schema"] == BINDING_SCHEMA ensure result["kd_micromolar"] >= MIN_KD_MICROMOLAR and result["kd_micromolar"] <= MAX_KD_MICROMOLAR poses = clamped_budget(budget) positions = target["positions"] atom_count = len(target["atomic_numbers"]) target_x = [positions[atom_index * 3] for atom_index in range(atom_count)] target_y = [positions[atom_index * 3 + 1] for atom_index in range(atom_count)] target_z = [positions[atom_index * 3 + 2] for atom_index in range(atom_count)] target_box = bounding_box(target_x, target_y, target_z) site = pocket_site(neighbour_grid(target_x, target_y, target_z, GRID_CELL_ANGSTROM, target_box[0], target_box[1]), target_x, target_y, target_z) center = site["center"] probe = ligand_probe(ligand) field = target_field(target, center, POSE_TRANSLATION_LIMIT_ANGSTROM + probe["radius"]) lattice = translation_lattice(TRANSLATION_HALF_EXTENT_ANGSTROM) angle_steps = ANGLE_LADDER_STEPS axis_count = max(1, (poses + len(lattice) * angle_steps - 1) // (len(lattice) * angle_steps)) mut best_score = math.inf mut best_quaternion = [1.0, 0.0, 0.0, 0.0] mut best_translation = [0.0, 0.0, 0.0] for pose_index in range(poses): translation = lattice[pose_index % len(lattice)] orientation = pose_index // len(lattice) quaternion = quaternion_from_axis_angle(golden_spiral_axis(orientation // angle_steps, axis_count), 2.0 * math.pi * (orientation % angle_steps) / angle_steps) score = pose_energy(field, probe, posed_coordinates(probe, rotation_from_quaternion(quaternion), center, translation)) if score < best_score: best_score = score best_quaternion = quaternion best_translation = translation refinement = refined_state(field, probe, center, best_quaternion, [best_translation[0], best_translation[1], best_translation[2], 0.0, 0.0, 0.0]) state = refinement["state"] quaternion = descent_quaternion(best_quaternion, state) translation = [state[0], state[1], state[2]] pose = posed_coordinates(probe, rotation_from_quaternion(quaternion), center, translation) terms = score_pose(field, probe, pose) score = terms[0] + terms[1] + terms[2] + terms[3] delta_g = free_energy_kj_mol(score) mut flat: list[f64] = [] for index in range(len(pose[0])): flat.append(pose[0][index]) flat.append(pose[1][index]) flat.append(pose[2][index]) return { "schema": BINDING_SCHEMA, "backend": "Sema", "evidence_class": "derived_illustrative", "scientific_validated": false, "target_key": target["key"], "target_source_sha256": target["source_sha256"], "ligand_name": ligand["key"], "ligand_source_sha256": ligand["source_sha256"], "scoring_function": SCORING_FUNCTION, "calibration": { "name": CALIBRATION_NAME, "slope": CALIBRATION_SLOPE, "intercept": CALIBRATION_INTERCEPT, "note": CALIBRATION_NOTE, }, "pocket_center_angstrom": center, "pocket_buriedness": site["buriedness"], "pocket_probes": site["probes"], "pose_translation_angstrom": translation, "pose_quaternion": quaternion, "score": score, "lennard_jones": terms[0], "coulomb": terms[1], "hydrophobic": terms[2], "clash_penalty": terms[3], "delta_g_kj_mol": delta_g, "kd_micromolar": dissociation_constant_micromolar(delta_g), "contacts": pose_contacts(field, pose), "buried_fraction": buried_ligand_fraction(field, pose), "poses_evaluated": poses, "refinement_steps": refinement["steps"], "converged": refinement["converged"], "shell_atoms": len(field["x"]), "ligand_rigid": true, "notes": [ "rigid ligand: internal strain is not re-optimised during docking", "score is an empirical rank, not a measured or computed binding free energy", "pocket is the highest-buriedness placeable grid point, refined on a local sub-lattice", ], "ligand_positions_angstrom": flat, }
pub def occupancy_fraction(kd_micromolar: f64, concentration_micromolar: f64) -> f64 !{}: sem "Mass-action receptor occupancy c / (Kd + c) for a single independent site" ensure result >= 0.0 and result <= 1.0 kd = max(MIN_KD_MICROMOLAR, kd_micromolar) concentration = max(0.0, concentration_micromolar) return concentration / (kd + concentration)
pub def binding_mechanisms() -> list[str] !{}: return ["secretion_agonist", "secretion_antagonist", "cytokine_inhibitor", "immune_shield", "insulin_analog", "inert"]
def bounded_multiplier(name: str, multiplier: f64): """Cap a multiplier so the published baseline parameter stays inside its physiology bound.""" baseline = initial_physiology_parameters()[name] bound = physiology_parameter_bounds()[name] return max(bound[0] / baseline, min(bound[1] / baseline, multiplier))
pub def species_effect(mechanism: str, occupancy: f64) -> dict[str, f64] !{}: """Physiology couplings keyed by effect kind.
`parameter:<name>` multiplies that physiology parameter, `signal_max:<name>` raises the signal to at least the value, `signal_add:<name>` adds to it. Occupancy is clamped to [0, 1] and every value here is already bounded against the published baseline, so applying it to the source parameters can never leave `physiology_parameter_bounds()`; `apply_species_effects` clamps again against whatever the live parameters happen to be. """ fraction = max(0.0, min(1.0, occupancy)) if mechanism == "secretion_agonist": return {"parameter:insulin_secretion_micro_u_ml_day_mg": bounded_multiplier("insulin_secretion_micro_u_ml_day_mg", 1.0 + 1.4 * fraction)} if mechanism == "secretion_antagonist": return {"parameter:insulin_secretion_micro_u_ml_day_mg": bounded_multiplier("insulin_secretion_micro_u_ml_day_mg", 1.0 - 0.7 * fraction)} if mechanism == "cytokine_inhibitor": return {"parameter:cytokine_release_per_day": bounded_multiplier("cytokine_release_per_day", 1.0 - 0.8 * fraction)} if mechanism == "immune_shield": return {"signal_max:immune_shielding": min(IMMUNE_SHIELDING_CEILING, 0.95 * fraction)} if mechanism == "insulin_analog": return {"signal_add:exogenous_insulin_micro_u_ml_day": min(EXOGENOUS_INSULIN_CEILING, 900.0 * fraction)} return {}
def signal_ceiling(name: str): """Upper bounds mirror the signal table in programming.sema; species may never exceed them.""" if name == "immune_shielding": return IMMUNE_SHIELDING_CEILING if name == "exogenous_insulin_micro_u_ml_day": return EXOGENOUS_INSULIN_CEILING return 0.0
pub def apply_species_effects(parameters: dict[str, f64], signals: dict[str, f64], registry: dict[str, any]) -> dict[str, any] !{}: sem "Combine every registered species onto a copy of the physiology parameters and signals" ensure result["species_applied"] >= 0 bounds = physiology_parameter_bounds() mut next_parameters = {name: value for name, value in parameters.items()} mut next_signals = {name: value for name, value in signals.items()} mut applied = 0 for name in sorted(registry.keys()): effect = registry[name]["effect"] applied = applied + 1 for key in sorted(effect.keys()): value = effect[key] if key.startswith("parameter:"): parameter = key.slice(10, len(key)) if next_parameters.has(parameter) and bounds.has(parameter): next_parameters[parameter] = max(bounds[parameter][0], min(bounds[parameter][1], next_parameters[parameter] * value)) elif key.startswith("signal_max:"): signal = key.slice(11, len(key)) if next_signals.has(signal): next_signals[signal] = max(0.0, min(signal_ceiling(signal), max(next_signals[signal], value))) elif key.startswith("signal_add:"): signal = key.slice(11, len(key)) if next_signals.has(signal): next_signals[signal] = max(0.0, min(signal_ceiling(signal), next_signals[signal] + value)) return {"parameters": next_parameters, "signals": next_signals, "species_applied": applied}
pub def initial_species_registry() -> dict[str, any] !{}: return {}
pub def species_registration_error(registry: dict[str, any], spec: dict[str, any], docking: dict[str, any], concentration_micromolar: f64, mechanism: str) -> dict[str, str] !{}: """`{"error": "", "detail": ""}` when the species may be introduced, otherwise the typed refusal.""" if not spec.has("name") or not spec.has("label") or not spec.has("class"): return {"error": "SpeciesRejected", "detail": "design spec must carry name, label, and class"} chosen = mechanism if len(mechanism) > 0 else spec["mechanism"] if not binding_mechanisms().contains(chosen): return {"error": "SpeciesRejected", "detail": "mechanism must be one of " + str(binding_mechanisms())} if concentration_micromolar <= 0.0 or concentration_micromolar > MAX_CONCENTRATION_MICROMOLAR: return {"error": "SpeciesRejected", "detail": "concentration must be within (0, 1e6] micromolar"} if len(docking) > 0 and docking["schema"] != BINDING_SCHEMA: return {"error": "SpeciesRejected", "detail": "docking record must be a " + BINDING_SCHEMA} if not registry.has(spec["name"]) and len(registry) >= MAX_SPECIES: return {"error": "SpeciesRegistryFull", "detail": "at most " + str(MAX_SPECIES) + " designed species may coexist"} return {"error": "", "detail": ""}
pub def register_species(registry: dict[str, any], spec: dict[str, any], structure: dict[str, any], docking: dict[str, any], concentration_micromolar: f64, mechanism: str, introduced_at_days: f64) -> dict[str, any] !{}: sem "Introduce or replace one designed species in a bounded registry, leaving the input untouched" require species_registration_error(registry, spec, docking, concentration_micromolar, mechanism)["error"] == "" ensure len(result) <= MAX_SPECIES docked = len(docking) > 0 chosen = mechanism if len(mechanism) > 0 else spec["mechanism"] kd = docking["kd_micromolar"] if docked else MAX_KD_MICROMOLAR occupancy = occupancy_fraction(kd, concentration_micromolar) mut next_registry = {name: record for name, record in registry.items()} next_registry[spec["name"]] = { "schema": SPECIES_SCHEMA, "name": spec["name"], "label": spec["label"], "class": spec["class"], "mechanism": chosen, "target_key": docking["target_key"] if docked else spec["target_key"], "concentration_micromolar": concentration_micromolar, "kd_micromolar": kd, "occupancy_fraction": occupancy, "structure_sha256": structure["asset_sha256"], "atoms": len(structure["atomic_numbers"]), "bonds": len(structure_bonds(structure)) // 2, "introduced_at_days": introduced_at_days, "docked": docked, "effect": species_effect(chosen, occupancy), "scientific_validated": false, } return next_registry
pub def species_public_state(registry: dict[str, any]) -> list[dict[str, any]] !{}: sem "Every designed species as a sema.designed-species-state/v1 record, ordered by name" ensure len(result) <= MAX_SPECIES return [registry[name] for name in sorted(registry.keys())]
pub def binding_capabilities() -> dict[str, any] !{}: return { "schema": "sema.molecular-binding-capabilities/v1", "backend": "Sema", "evidence_class": "derived_illustrative", "scientific_validated": false, "pose_budget": [MIN_POSE_BUDGET, MAX_POSE_BUDGET], "default_pose_budget": DEFAULT_POSE_BUDGET, "max_target_atoms": MAX_TARGET_ATOMS, "max_ligand_atoms": MAX_LIGAND_ATOMS, "max_species": MAX_SPECIES, "max_contacts": MAX_CONTACTS, "scoring_function": SCORING_FUNCTION, "search": "golden-spiral rotation axes x a " + str(ANGLE_LADDER_STEPS) + "-step angle ladder x a 9-point translation lattice, then bounded local coordinate descent", "pocket_rule": "highest buriedness (atoms within 8 A minus atoms within 3 A) over placeable probes whose closest target atom lies in [2.6, 8.0] A, refined on a local sub-lattice and averaged over its cluster", "rigid_ligand": true, "calibration": { "name": CALIBRATION_NAME, "slope": CALIBRATION_SLOPE, "intercept": CALIBRATION_INTERCEPT, "note": CALIBRATION_NOTE, }, "constants": { "interaction_cutoff_angstrom": INTERACTION_CUTOFF_ANGSTROM, "clash_distance_angstrom": CLASH_DISTANCE_ANGSTROM, "clash_stiffness_kj_per_mol_angstrom2": CLASH_STIFFNESS_KJ_PER_MOL_ANGSTROM2, "lj_pair_ceiling_kj_per_mol": LJ_PAIR_CEILING_KJ_PER_MOL, "coulomb_constant_kj_angstrom_per_mol": COULOMB_CONSTANT_KJ_ANGSTROM_PER_MOL, "dielectric_model": "distance dependent, epsilon(r) = 4r", "hydrophobic_depth_kj_per_mol": HYDROPHOBIC_DEPTH_KJ_PER_MOL, "hydrophobic_center_angstrom": HYDROPHOBIC_CENTER_ANGSTROM, "hydrophobic_width_angstrom": HYDROPHOBIC_WIDTH_ANGSTROM, "gas_constant_kj_per_mol_k": GAS_CONSTANT_KJ_PER_MOL_K, "temperature_k": BODY_TEMPERATURE_K, "kd_window_micromolar": [MIN_KD_MICROMOLAR, MAX_KD_MICROMOLAR], }, "mechanisms": { "secretion_agonist": "insulin_secretion_micro_u_ml_day_mg x (1 + 1.4 occupancy)", "secretion_antagonist": "insulin_secretion_micro_u_ml_day_mg x (1 - 0.7 occupancy)", "cytokine_inhibitor": "cytokine_release_per_day x (1 - 0.8 occupancy)", "immune_shield": "immune_shielding raised to at least 0.95 occupancy", "insulin_analog": "exogenous_insulin_micro_u_ml_day increased by 900 occupancy", "inert": "no physiology coupling", }, "occupancy_model": "mass action, occupancy = c / (Kd + c)", "parameter_bounds": physiology_parameter_bounds(), }src/coarse.sema
Section titled “src/coarse.sema”"""Periodic phi/psi coarse-state mapping with explicit sampling diagnostics."""
assure silver
pub struct CoarseStateResult: schema: str analysis_id: str config_sha256: str source_frames_sha256: str source_model_sha256: str source_parameter_sha256: str result_sha256: str result_path: str samples: int basin_ids: list[str] counts: list[int] transition_counts: list[int] transitions: int observed_basins: int lag_frames: int pseudocount: f64 free_energy_kj_mol: list[f64] effective_samples: f64 mapping_validated: bool sampling_converged: bool evidence_class: str invariant schema == "sema.coarse-state-result/v1" invariant len(analysis_id) > 0 invariant len(config_sha256) == 64 invariant len(source_frames_sha256) == 64 invariant len(source_model_sha256) == 64 invariant len(source_parameter_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant samples > 1 and samples <= 101 invariant len(basin_ids) >= 2 and len(basin_ids) <= 16 invariant len(counts) == len(basin_ids) invariant len(transition_counts) == len(basin_ids) * len(basin_ids) invariant transitions >= 0 and transitions < samples invariant observed_basins > 0 and observed_basins <= len(basin_ids) invariant lag_frames > 0 and lag_frames < samples invariant pseudocount > 0.0 invariant len(free_energy_kj_mol) == len(basin_ids) invariant effective_samples >= 0.0 and effective_samples <= f64(samples) invariant mapping_validated invariant evidence_class == "exploratory"
pub bridge python.inline coarse_backend from "foreign/python/coarse_backend.py": deps "python>=3.12,<3.13" expose: def analyze_coarse_state( config_path: str, frames_path: str, output_path: str, expected_frames_sha256: str, ) -> CoarseStateResult !{ffi.call}: sem "Map canonical atomistic phi/psi frames onto preregistered periodic coarse basins"src/cortex.sema
Section titled “src/cortex.sema”"""Governed proposal-only Cortex bridge with native Sema contract revalidation."""
from biological_computer.programming import programming_capabilities
assure silver
bridge python.inline cortex_sdk_backend from "foreign/python/cortex_sdk_backend.py": deps "python>=3.12,<3.13" expose: def propose_cortex_backend(payload: any) -> dict[str, any] !{ffi.call}: sem "Request one bounded proposal from a warm Cortex session without mutating live state"
def cortex_units(): return { "glucose": "mmol/L", "oxygen": "kPa", "cytokine": "fraction", "morphology": "relative", "amplitude": "relative", "attraction": "relative", "molecular_temperature": "relative", "bond_stiffness": "relative", "meal_intensity": "relative", "exercise_intensity": "relative", "exogenous_insulin_micro_u_ml_day": "microU/mL/day", "immune_shielding": "fraction", "graft_target_mg": "mg", "physiology_seconds_per_real_second": "model-s/real-s", "glucose_inflow_mg_dl_day": "mg/dL/day", "insulin_sensitivity_ml_micro_u_day": "mL/microU/day", "glucose_effectiveness_per_day": "1/day", "insulin_secretion_micro_u_ml_day_mg": "microU/mL/day/mg", "insulin_clearance_per_day": "1/day", "secretion_half_saturation_mg2_dl2": "mg2/dL2", "beta_death_per_day": "1/day", "beta_growth_dl_mg_day": "dL/mg/day", "beta_glucotoxicity_dl2_mg2_day": "dL2/mg2/day", "immune_activation_per_day": "1/day", "immune_clearance_per_day": "1/day", "immune_kill_per_day": "1/day", "cytokine_release_per_day": "1/day", "cytokine_clearance_per_day": "1/day", "regulatory_recovery_per_day": "1/day", "graft_engraftment_per_day": "1/day", "graft_rejection_per_day": "1/day", }
def cortex_operation_error(operation: any) !{}: if not (operation is dict): return "Cortex operation must be an object" if not all(operation.has(field) for field in ["kind", "name", "value", "unit"]): return "Cortex operation is missing a required field" if not (operation["kind"] is str) or not (operation["name"] is str) or not (operation["unit"] is str): return "Cortex operation kind, name, and unit must be strings" kind = operation["kind"] name = operation["name"] capabilities = programming_capabilities() mut bounds: any = None if kind == "set_signal" and capabilities["signals"].has(name): bounds = capabilities["signals"][name] elif kind == "set_parameter" and capabilities["parameters"].has(name): bounds = capabilities["parameters"][name] else: return "Cortex operation kind or name is unsupported" units = cortex_units() if not units.has(name) or operation["unit"] != units[name]: return "Cortex operation unit does not match its Sema contract" if operation["value"] < bounds[0] or operation["value"] > bounds[1]: return "Cortex operation value is outside its Sema bounds" return ""
def cortex_proposal_error(proposal: any) !{}: if not (proposal is dict): return "Cortex proposal must be an object" required = ["schema", "provider", "harness", "model", "summary", "rationale", "assumptions", "warnings", "operations", "requires_explicit_apply", "scientific_validated"] if not all(proposal.has(field) for field in required): return "Cortex proposal is missing a required field" if not (proposal["summary"] is str) or not (proposal["rationale"] is str): return "Cortex proposal summary and rationale must be strings" if not (proposal["assumptions"] is list) or not (proposal["warnings"] is list) or not (proposal["operations"] is list): return "Cortex proposal list fields are malformed" if proposal["schema"] != "sema.biological-llm-proposal/v1" or proposal["provider"] != "Cortex": return "Cortex proposal schema or provider identity is invalid" if proposal["harness"] != "omp" or proposal["model"] != "openai-codex/gpt-5.6-sol": return "Cortex proposal harness or model identity is invalid" if proposal["requires_explicit_apply"] != true or proposal["scientific_validated"] != false: return "Cortex proposal safety identity is invalid" if len(proposal["summary"]) == 0 or len(proposal["summary"]) > 240 or len(proposal["rationale"]) == 0 or len(proposal["rationale"]) > 900: return "Cortex proposal summary or rationale is outside its text bound" if len(proposal["assumptions"]) > 4 or len(proposal["warnings"]) > 4: return "Cortex proposal assumptions or warnings exceed their list bound" if any(not (entry is str) or len(entry) == 0 or len(entry) > 180 for entry in proposal["assumptions"]): return "Cortex proposal assumption text is invalid" if any(not (entry is str) or len(entry) == 0 or len(entry) > 180 for entry in proposal["warnings"]): return "Cortex proposal warning text is invalid" operations = proposal["operations"] if len(operations) < 1 or len(operations) > 6: return "Cortex proposal must contain 1..6 operations" for operation in operations: operation_error = cortex_operation_error(operation) if len(operation_error) > 0: return operation_error return ""
pub def propose_cortex(payload: any) -> dict[str, any] !{ffi.call}: if not (payload is dict): return {"ok": false, "error": "CortexProposalInvalid", "detail": "Cortex proposal request must be an object"} required = ["prompt", "scenario_id", "program", "physiology"] if not all(payload.has(field) for field in required): return {"ok": false, "error": "CortexProposalInvalid", "detail": "Cortex proposal request is missing a required field"} if not (payload["prompt"] is str) or not (payload["scenario_id"] is str): return {"ok": false, "error": "CortexProposalInvalid", "detail": "prompt and scenario_id must be strings"} if not (payload["program"] is dict) or not (payload["physiology"] is dict): return {"ok": false, "error": "CortexProposalInvalid", "detail": "program and physiology must be objects"} if len(payload["prompt"]) == 0 or len(payload["prompt"]) > 1200: return {"ok": false, "error": "CortexProposalInvalid", "detail": "prompt must contain 1..1200 characters"} if len(payload["scenario_id"]) == 0 or len(payload["scenario_id"]) > 80: return {"ok": false, "error": "CortexProposalInvalid", "detail": "scenario_id must contain 1..80 characters"} if not payload["program"].has("schema") or payload["program"]["schema"] != "sema.biological-program-state/v2": return {"ok": false, "error": "CortexProposalInvalid", "detail": "program must use sema.biological-program-state/v2"} if not payload["physiology"].has("schema") or payload["physiology"]["schema"] != "sema.metabolic-immune-observation/v1": return {"ok": false, "error": "CortexProposalInvalid", "detail": "physiology must use sema.metabolic-immune-observation/v1"} result = cortex_sdk_backend.propose_cortex_backend(payload) if not result.has("ok") or result["ok"] != true: if result.has("error") and result.has("detail"): return {"ok": false, "error": result["error"], "detail": result["detail"]} return {"ok": false, "error": "CortexProposalUnavailable", "detail": "Cortex proposal adapter failed closed"} if not result.has("proposal"): return {"ok": false, "error": "CortexProposalInvalid", "detail": "Cortex proposal adapter returned no proposal"} proposal_error = cortex_proposal_error(result["proposal"]) if len(proposal_error) > 0: return {"ok": false, "error": "CortexProposalInvalid", "detail": proposal_error} return {"ok": true, "proposal": result["proposal"]}
pub def cortex_capabilities() -> dict[str, any] !{}: return { "schema": "sema.biological-cortex-capabilities/v1", "provider": "Cortex", "harness": "omp", "model": "openai-codex/gpt-5.6-sol", "proposal_endpoint": "/api/sema/cortex/propose", "request_schema": "prompt + scenario_id + sema.biological-program-state/v2 + sema.metabolic-immune-observation/v1", "response_schema": "sema.biological-llm-proposal/v1", "operation_kinds": ["set_signal", "set_parameter"], "max_operations": 6, "requires_explicit_apply": true, "scientific_validated": false, }src/design.sema
Section titled “src/design.sema”"""Bounded de-novo molecular design: natural-language specs turned into computed geometry.
Everything here is exploratory engineering, never a measurement. Structures are built frompublished internal coordinates by natural-extension-reference-frame placement and a boundedsteepest-descent relaxation, so every coordinate is computed rather than copied from a table ofpositions. Designed structures therefore carry `fidelity: "engineered_unvalidated"`,`biological_match: "designed_de_novo"` and `scientific_validated: false` downstream: no claim ismade that any of these molecules exists, folds, or binds."""
import mathfrom std.crypto import sha256_json
assure silver
SPEC_SCHEMA = "sema.molecular-design-spec/v1"MAX_COMMAND_CHARS = 320MAX_DESIGNS = 16MAX_DESIGN_ATOMS = 512MAX_DESIGN_BONDS = 1024MAX_RESIDUES = 24MAX_FRAGMENTS = 6RESIDUE_ALPHABET = "ACDEFGHIKLMNPQRSTVWY"SIDECHAIN_MODEL = "backbone_plus_truncated_sidechain"SIDECHAIN_HEAVY_ATOM_LIMIT = 4
BOND_N_CA_ANGSTROM = 1.458BOND_CA_C_ANGSTROM = 1.525BOND_C_N_ANGSTROM = 1.329BOND_C_O_ANGSTROM = 1.231BOND_CA_CB_ANGSTROM = 1.530BOND_C_OXT_ANGSTROM = 1.249ANGLE_N_CA_C_DEGREE = 111.2ANGLE_CA_C_N_DEGREE = 116.2ANGLE_C_N_CA_DEGREE = 121.7ANGLE_CA_C_O_DEGREE = 120.8ANGLE_C_CA_CB_DEGREE = 110.5ANGLE_CA_C_OXT_DEGREE = 118.0DIHEDRAL_N_C_CA_CB_DEGREE = 122.6OMEGA_DEGREE = 180.0EXTENDED_PHI_DEGREE = -135.0EXTENDED_PSI_DEGREE = 135.0HELIX_PHI_DEGREE = -57.0HELIX_PSI_DEGREE = -47.0
FRAGMENT_LINK_ANGSTROM = 1.50SEED_DIHEDRAL_POINT = [0.0, 1.0, 0.0]SEED_AXIS_POINT = [-1.5, 0.0, 0.0]GROWTH_LATERAL = 0.55GROWTH_VERTICAL = 0.35
BOND_STIFFNESS_KJ_PER_MOL_ANGSTROM2 = 4000.0ANGLE_STIFFNESS_KJ_PER_MOL_ANGSTROM2 = 1200.0CLASH_CORE_ANGSTROM = 2.70CLASH_FLOOR_ANGSTROM = 2.60CORE_EPSILON_KJ_PER_MOL = 8.0CORE_EPSILON_ESCALATED_KJ_PER_MOL = 48.0MIN_SEPARATION_ANGSTROM = 0.5NEIGHBOUR_SKIN_ANGSTROM = 2.0NEIGHBOUR_REBUILD_STEPS = 24PEPTIDE_RELAXATION_STEPS = 200MOLECULE_RELAXATION_STEPS = 320INITIAL_STEP = 0.0005STEP_GROWTH = 1.3STEP_SHRINK = 0.4MAX_DISPLACEMENT_ANGSTROM = 0.05FORCE_TOLERANCE_KJ_PER_MOL_ANGSTROM = 1.0UNIT_SCALE = 0.1
def design_target_keys(): return [ "insulin", "glucagon", "somatostatin", "pancreatic_polypeptide", "amylase", "adiponectin", "interleukin_1_beta", "von_willebrand_a1", "b_dna", "hemoglobin", ]
def design_mechanisms(): return [ "secretion_agonist", "secretion_antagonist", "cytokine_inhibitor", "immune_shield", "insulin_analog", "inert", ]
def design_fragment_names(): return [ "benzene", "cyclohexane", "phenol", "carboxyl", "amine", "amide", "sulfonyl", "sulfonylurea", "hydroxyl", "methyl", "ethyl", "guanidine", "imidazole", "glucosyl", ]
def listed(values: list[str], value: str): return any(candidate == value for candidate in values)
def element_name(atomic_number: int): if atomic_number == 6: return "Carbon" if atomic_number == 7: return "Nitrogen" if atomic_number == 8: return "Oxygen" if atomic_number == 16: return "Sulfur" return "Unmapped element"
def atomic_radius(atomic_number: int, radius_kind: str): if atomic_number == 6: return 1.70 if radius_kind == "vdw" else 0.76 if atomic_number == 7: return 1.55 if radius_kind == "vdw" else 0.71 if atomic_number == 8: return 1.52 if radius_kind == "vdw" else 0.66 if atomic_number == 16: return 1.80 if radius_kind == "vdw" else 1.05 return 1.80 if radius_kind == "vdw" else 0.80
def unit_vector(vector: list[f64]): length = max(0.000001, math.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2])) return [vector[0] / length, vector[1] / length, vector[2] / length]
def cross(left: list[f64], right: list[f64]): return [ left[1] * right[2] - left[2] * right[1], left[2] * right[0] - left[0] * right[2], left[0] * right[1] - left[1] * right[0], ]
def difference(from_point: list[f64], to_point: list[f64]): return [to_point[0] - from_point[0], to_point[1] - from_point[1], to_point[2] - from_point[2]]
def point_at(positions: list[f64], atom_index: int): offset = atom_index * 3 return [positions[offset], positions[offset + 1], positions[offset + 2]]
def place_atom(first: list[f64], second: list[f64], third: list[f64], bond_angstrom: f64, angle_degree: f64, dihedral_degree: f64): sem "Natural extension reference frame: place one atom bonded to `third` from a bond length, the valence angle second-third-new, and the IUPAC torsion first-second-third-new" require bond_angstrom > 0.0 theta = angle_degree * math.pi / 180.0 phi = dihedral_degree * math.pi / 180.0 axis = unit_vector(difference(second, third)) normal = unit_vector(cross(difference(first, second), axis)) side = cross(normal, axis) along = -bond_angstrom * math.cos(theta) lateral = bond_angstrom * math.sin(theta) * math.cos(phi) outward = bond_angstrom * math.sin(theta) * math.sin(phi) return [third[a] + along * axis[a] + lateral * side[a] + outward * normal[a] for a in range(3)]
def rotation_between(source: list[f64], target: list[f64]): """Rodrigues rotation matrix (row-major, flat 9) carrying unit `source` onto unit `target`.""" u = unit_vector(source) v = unit_vector(target) axis = cross(u, v) sine = math.sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]) cosine = u[0] * v[0] + u[1] * v[1] + u[2] * v[2] if sine < 0.000001 and cosine >= 0.0: return [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0] if sine < 0.000001: p = unit_vector(cross(u, [0.0, 1.0, 0.0] if abs(u[0]) > 0.9 else [1.0, 0.0, 0.0])) return [ 2.0 * p[0] * p[0] - 1.0, 2.0 * p[0] * p[1], 2.0 * p[0] * p[2], 2.0 * p[1] * p[0], 2.0 * p[1] * p[1] - 1.0, 2.0 * p[1] * p[2], 2.0 * p[2] * p[0], 2.0 * p[2] * p[1], 2.0 * p[2] * p[2] - 1.0, ] k = [axis[0] / sine, axis[1] / sine, axis[2] / sine] rest = 1.0 - cosine return [ cosine + rest * k[0] * k[0], rest * k[0] * k[1] - sine * k[2], rest * k[0] * k[2] + sine * k[1], rest * k[1] * k[0] + sine * k[2], cosine + rest * k[1] * k[1], rest * k[1] * k[2] - sine * k[0], rest * k[2] * k[0] - sine * k[1], rest * k[2] * k[1] + sine * k[0], cosine + rest * k[2] * k[2], ]
def rotated(matrix: list[f64], vector: list[f64]): return [ matrix[0] * vector[0] + matrix[1] * vector[1] + matrix[2] * vector[2], matrix[3] * vector[0] + matrix[4] * vector[1] + matrix[5] * vector[2], matrix[6] * vector[0] + matrix[7] * vector[1] + matrix[8] * vector[2], ]
def residue_three_letter(code: str): names = { "A": "ALA", "C": "CYS", "D": "ASP", "E": "GLU", "F": "PHE", "G": "GLY", "H": "HIS", "I": "ILE", "K": "LYS", "L": "LEU", "M": "MET", "N": "ASN", "P": "PRO", "Q": "GLN", "R": "ARG", "S": "SER", "T": "THR", "V": "VAL", "W": "TRP", "Y": "TYR", } return names[code]
def residue_charge(code: str): """Side-chain formal charge at pH 7.4; the free N- and C-termini cancel and are omitted.""" if code == "D" or code == "E": return -1.0 if code == "K" or code == "R": return 1.0 return 0.0
def residue_sidechains(): """Truncated side chains beyond C-beta as internal coordinates.
Every row is `[atom name, atomic number, torsion reference, angle reference, bonded parent, bond length in angstrom, valence angle in degrees, torsion in degrees]`; references -3, -2 and -1 are backbone N, CA and CB and a non-negative reference is an earlier row of the same residue. At most four heavy atoms are emitted per side chain, so anything past the delta shell is truncated - the structure declares this through `sidechain_model`. """ return { "G": [], "A": [], "S": [["OG", 8, -3, -2, -1, 1.417, 110.8, -60.0]], "C": [["SG", 16, -3, -2, -1, 1.808, 114.0, -60.0]], "T": [["OG1", 8, -3, -2, -1, 1.433, 109.6, -60.0], ["CG2", 6, -3, -2, -1, 1.521, 110.5, 60.0]], "V": [["CG1", 6, -3, -2, -1, 1.521, 110.5, -60.0], ["CG2", 6, -3, -2, -1, 1.521, 110.5, 60.0]], "P": [["CG", 6, -3, -2, -1, 1.492, 106.1, 16.5], ["CD", 6, -2, -1, 0, 1.503, 104.5, -8.0]], "L": [["CG", 6, -3, -2, -1, 1.530, 116.3, -60.0], ["CD1", 6, -2, -1, 0, 1.521, 110.7, 175.0], ["CD2", 6, -2, -1, 0, 1.521, 110.7, -60.0]], "I": [["CG1", 6, -3, -2, -1, 1.530, 110.4, -60.0], ["CG2", 6, -3, -2, -1, 1.521, 110.5, 60.0], ["CD1", 6, -2, -1, 0, 1.521, 113.8, 170.0]], "M": [["CG", 6, -3, -2, -1, 1.520, 114.1, -60.0], ["SD", 16, -2, -1, 0, 1.803, 112.7, 180.0], ["CE", 6, -1, 0, 1, 1.791, 100.9, 75.0]], "F": [["CG", 6, -3, -2, -1, 1.502, 113.8, -60.0], ["CD1", 6, -2, -1, 0, 1.384, 120.8, 90.0], ["CD2", 6, -2, -1, 0, 1.384, 120.8, -90.0], ["CE1", 6, -1, 0, 1, 1.382, 120.8, 180.0]], "Y": [["CG", 6, -3, -2, -1, 1.512, 113.8, -60.0], ["CD1", 6, -2, -1, 0, 1.389, 120.8, 90.0], ["CD2", 6, -2, -1, 0, 1.389, 120.8, -90.0], ["CE1", 6, -1, 0, 1, 1.382, 121.1, 180.0]], "W": [["CG", 6, -3, -2, -1, 1.498, 113.6, -60.0], ["CD1", 6, -2, -1, 0, 1.365, 127.0, 90.0], ["CD2", 6, -2, -1, 0, 1.433, 126.6, -90.0], ["NE1", 7, -1, 0, 1, 1.375, 110.2, 180.0]], "H": [["CG", 6, -3, -2, -1, 1.497, 113.8, -60.0], ["ND1", 7, -2, -1, 0, 1.378, 122.7, 90.0], ["CD2", 6, -2, -1, 0, 1.354, 131.0, -90.0], ["CE1", 6, -1, 0, 1, 1.321, 109.3, 180.0]], "N": [["CG", 6, -3, -2, -1, 1.516, 112.6, -60.0], ["OD1", 8, -2, -1, 0, 1.231, 120.8, -30.0], ["ND2", 7, -2, -1, 0, 1.328, 116.4, 150.0]], "D": [["CG", 6, -3, -2, -1, 1.516, 112.6, -60.0], ["OD1", 8, -2, -1, 0, 1.249, 118.4, -30.0], ["OD2", 8, -2, -1, 0, 1.249, 118.4, 150.0]], "Q": [["CG", 6, -3, -2, -1, 1.520, 114.1, -60.0], ["CD", 6, -2, -1, 0, 1.516, 112.6, 180.0], ["OE1", 8, -1, 0, 1, 1.231, 120.8, -30.0], ["NE2", 7, -1, 0, 1, 1.328, 116.4, 150.0]], "E": [["CG", 6, -3, -2, -1, 1.520, 114.1, -60.0], ["CD", 6, -2, -1, 0, 1.516, 112.6, 180.0], ["OE1", 8, -1, 0, 1, 1.249, 118.4, -30.0], ["OE2", 8, -1, 0, 1, 1.249, 118.4, 150.0]], "K": [["CG", 6, -3, -2, -1, 1.520, 114.1, -60.0], ["CD", 6, -2, -1, 0, 1.520, 111.3, 180.0], ["CE", 6, -1, 0, 1, 1.520, 111.3, 180.0], ["NZ", 7, 0, 1, 2, 1.489, 111.9, 180.0]], "R": [["CG", 6, -3, -2, -1, 1.520, 114.1, -60.0], ["CD", 6, -2, -1, 0, 1.520, 111.3, 180.0], ["NE", 7, -1, 0, 1, 1.461, 111.8, 180.0], ["CZ", 6, 0, 1, 2, 1.329, 124.2, 180.0]], }
def fragment_template(name: str) -> dict[str, any]: """Literature internal coordinates for one attachable fragment.
Rings are generated from their bond length and ring size; every other atom is an `[name, atomic number, torsion reference, angle reference, bonded parent, bond, angle, torsion]` row placed by the same reference-frame routine as the peptide backbone. References -2 and -1 are the two virtual seed points that define the incoming bond direction, a non-negative reference indexes an atom already placed in this fragment, and a zero bond length means the atom is the fragment head sitting at the local origin. `head` bonds to the previous fragment and `tail` carries the growing chain onward. """ if name == "benzene": return {"tag": "BEN", "charge_e": 0.0, "ring": 6, "ring_bond": 1.390, "ring_pucker": 0.0, "ring_elements": [6, 6, 6, 6, 6, 6], "extras": [], "extra_bonds": [], "head": 0, "tail": 3} if name == "cyclohexane": return {"tag": "CHX", "charge_e": 0.0, "ring": 6, "ring_bond": 1.530, "ring_pucker": 0.25, "ring_elements": [6, 6, 6, 6, 6, 6], "extras": [], "extra_bonds": [], "head": 0, "tail": 3} if name == "phenol": return {"tag": "PHO", "charge_e": 0.0, "ring": 6, "ring_bond": 1.390, "ring_pucker": 0.0, "ring_elements": [6, 6, 6, 6, 6, 6], "extras": [["O1", 8, 0, 1, 2, 1.362, 120.0, 180.0]], "extra_bonds": [[2, 6]], "head": 0, "tail": 3} if name == "imidazole": return {"tag": "IMD", "charge_e": 0.0, "ring": 5, "ring_bond": 1.360, "ring_pucker": 0.0, "ring_elements": [7, 6, 7, 6, 6], "extras": [], "extra_bonds": [], "head": 0, "tail": 3} if name == "glucosyl": return {"tag": "GLC", "charge_e": 0.0, "ring": 6, "ring_bond": 1.492, "ring_pucker": 0.25, "ring_elements": [6, 6, 6, 6, 6, 8], "extras": [["O2", 8, 5, 0, 1, 1.430, 109.5, 180.0], ["O3", 8, 0, 1, 2, 1.430, 109.5, 180.0], ["C6", 6, 2, 3, 4, 1.520, 111.0, 180.0], ["O6", 8, 3, 4, 8, 1.430, 111.0, 180.0]], "extra_bonds": [[1, 6], [2, 7], [4, 8], [8, 9]], "head": 0, "tail": 3} if name == "methyl": return {"tag": "MET", "charge_e": 0.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["C1", 6, 0, 0, 0, 0.0, 0.0, 0.0]], "extra_bonds": [], "head": 0, "tail": 0} if name == "hydroxyl": return {"tag": "OHX", "charge_e": 0.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["O1", 8, 0, 0, 0, 0.0, 0.0, 0.0]], "extra_bonds": [], "head": 0, "tail": 0} if name == "amine": return {"tag": "NH2", "charge_e": 1.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["N1", 7, 0, 0, 0, 0.0, 0.0, 0.0]], "extra_bonds": [], "head": 0, "tail": 0} if name == "ethyl": return {"tag": "ETY", "charge_e": 0.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["C1", 6, 0, 0, 0, 0.0, 0.0, 0.0], ["C2", 6, -2, -1, 0, 1.530, 111.0, 180.0]], "extra_bonds": [[0, 1]], "head": 0, "tail": 1} if name == "carboxyl": return {"tag": "COO", "charge_e": -1.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["C1", 6, 0, 0, 0, 0.0, 0.0, 0.0], ["O1", 8, -2, -1, 0, 1.230, 120.0, 0.0], ["O2", 8, -2, -1, 0, 1.312, 117.0, 180.0]], "extra_bonds": [[0, 1], [0, 2]], "head": 0, "tail": 2} if name == "amide": return {"tag": "AMD", "charge_e": 0.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["C1", 6, 0, 0, 0, 0.0, 0.0, 0.0], ["O1", 8, -2, -1, 0, 1.230, 120.5, 0.0], ["N1", 7, -2, -1, 0, 1.335, 116.5, 180.0]], "extra_bonds": [[0, 1], [0, 2]], "head": 0, "tail": 2} if name == "sulfonyl": return {"tag": "SO2", "charge_e": 0.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["S1", 16, 0, 0, 0, 0.0, 0.0, 0.0], ["O1", 8, -2, -1, 0, 1.440, 108.0, 60.0], ["O2", 8, -2, -1, 0, 1.440, 108.0, -60.0]], "extra_bonds": [[0, 1], [0, 2]], "head": 0, "tail": 0} if name == "sulfonylurea": return {"tag": "SUR", "charge_e": 0.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["S1", 16, 0, 0, 0, 0.0, 0.0, 0.0], ["O1", 8, -2, -1, 0, 1.440, 108.0, 60.0], ["O2", 8, -2, -1, 0, 1.440, 108.0, -60.0], ["N1", 7, -2, -1, 0, 1.633, 106.0, 180.0], ["C1", 6, -1, 0, 3, 1.380, 122.0, 180.0], ["O3", 8, 0, 3, 4, 1.226, 121.5, 0.0], ["N2", 7, 0, 3, 4, 1.340, 115.0, 180.0]], "extra_bonds": [[0, 1], [0, 2], [0, 3], [3, 4], [4, 5], [4, 6]], "head": 0, "tail": 6} return {"tag": "GUA", "charge_e": 1.0, "ring": 0, "ring_bond": 0.0, "ring_pucker": 0.0, "ring_elements": [], "extras": [["N1", 7, 0, 0, 0, 0.0, 0.0, 0.0], ["C1", 6, -2, -1, 0, 1.329, 124.0, 180.0], ["N2", 7, -1, 0, 1, 1.329, 120.0, 0.0], ["N3", 7, -1, 0, 1, 1.329, 120.0, 180.0]], "extra_bonds": [[0, 1], [1, 2], [1, 3]], "head": 0, "tail": 3}
def build_fragment(name: str): """Instantiate one fragment in a local frame with its head at the origin and its head-to-tail axis on +x, so the chain builder can drop it onto a growth direction with one rotation.""" template = fragment_template(name) ring_size = template["ring"] pucker = template["ring_pucker"] mut points: list[list[f64]] = [] mut atomic_numbers: list[int] = [] mut atom_names: list[str] = [] mut bonds: list[int] = [] if ring_size > 0: # A regular ring: the in-plane radius follows from the bond length once the alternating # chair displacement is removed, so the emitted bonds are exactly `ring_bond` long. radius = math.sqrt(max(0.000001, template["ring_bond"] * template["ring_bond"] - 4.0 * pucker * pucker)) / (2.0 * math.sin(math.pi / ring_size)) for vertex in range(ring_size): angle = math.pi - 2.0 * math.pi * vertex / ring_size element = template["ring_elements"][vertex] points.append([radius * math.cos(angle), radius * math.sin(angle), pucker if vertex % 2 == 0 else -pucker]) atomic_numbers.append(element) atom_names.append(("C" if element == 6 else ("N" if element == 7 else "O")) + str(vertex + 1)) bonds.append(vertex) bonds.append((vertex + 1) % ring_size) for row in template["extras"]: if row[5] == 0.0: points.append([0.0, 0.0, 0.0]) else: first = SEED_DIHEDRAL_POINT if row[2] == -2 else (SEED_AXIS_POINT if row[2] == -1 else points[row[2]]) second = SEED_DIHEDRAL_POINT if row[3] == -2 else (SEED_AXIS_POINT if row[3] == -1 else points[row[3]]) third = SEED_DIHEDRAL_POINT if row[4] == -2 else (SEED_AXIS_POINT if row[4] == -1 else points[row[4]]) points.append(place_atom(first, second, third, row[5], row[6], row[7])) atomic_numbers.append(row[1]) atom_names.append(row[0]) for pair in template["extra_bonds"]: bonds.append(pair[0]) bonds.append(pair[1]) head = points[template["head"]] mut local = [[point[a] - head[a] for a in range(3)] for point in points] if template["tail"] != template["head"]: alignment = rotation_between(local[template["tail"]], [1.0, 0.0, 0.0]) local = [rotated(alignment, point) for point in local] return { "points": local, "atomic_numbers": atomic_numbers, "atom_names": atom_names, "bonds": bonds, "head": template["head"], "tail": template["tail"], "tag": template["tag"], }
def new_build(): return { "positions": [], "atomic_numbers": [], "labels": [], "mobile": [], "bonds": [], "fragment_of": [], "trace": [], }
def add_atom(built: dict[str, any], position: list[f64], atomic_number: int, label: str, mobile: bool, group: int) !{}: for axis in range(3): built["positions"].append(position[axis]) built["atomic_numbers"].append(atomic_number) built["labels"].append(label) built["mobile"].append(mobile) built["fragment_of"].append(group) return len(built["atomic_numbers"]) - 1
def add_bond(built: dict[str, any], left: int, right: int) !{}: built["bonds"].append(left) built["bonds"].append(right)
def build_peptide(spec: dict[str, any]) !{}: """Grow the backbone and truncated side chains residue by residue from standard internal coordinates; only the side-chain atoms are later relaxed so the backbone torsions stay exact.""" sequence = spec["sequence"] helix = spec["conformation"] == "helix" phi = HELIX_PHI_DEGREE if helix else EXTENDED_PHI_DEGREE psi = HELIX_PSI_DEGREE if helix else EXTENDED_PSI_DEGREE table = residue_sidechains() mut built = new_build() mut previous = [-1, -1, -1] for residue_index in range(len(sequence)): code = sequence.slice(residue_index, residue_index + 1) prefix = "A:" + str(residue_index + 1) + ":" + residue_three_letter(code) + ":" if previous[0] < 0: nitrogen = [0.0, 0.0, 0.0] alpha = [BOND_N_CA_ANGSTROM, 0.0, 0.0] carbon = place_atom(SEED_DIHEDRAL_POINT, nitrogen, alpha, BOND_CA_C_ANGSTROM, ANGLE_N_CA_C_DEGREE, phi) else: nitrogen = place_atom(point_at(built["positions"], previous[0]), point_at(built["positions"], previous[1]), point_at(built["positions"], previous[2]), BOND_C_N_ANGSTROM, ANGLE_CA_C_N_DEGREE, psi) alpha = place_atom(point_at(built["positions"], previous[1]), point_at(built["positions"], previous[2]), nitrogen, BOND_N_CA_ANGSTROM, ANGLE_C_N_CA_DEGREE, OMEGA_DEGREE) carbon = place_atom(point_at(built["positions"], previous[2]), nitrogen, alpha, BOND_CA_C_ANGSTROM, ANGLE_N_CA_C_DEGREE, phi) oxygen = place_atom(nitrogen, alpha, carbon, BOND_C_O_ANGSTROM, ANGLE_CA_C_O_DEGREE, psi + 180.0) nitrogen_index = add_atom(built, nitrogen, 7, prefix + "N", false, residue_index) alpha_index = add_atom(built, alpha, 6, prefix + "CA", false, residue_index) carbon_index = add_atom(built, carbon, 6, prefix + "C", false, residue_index) oxygen_index = add_atom(built, oxygen, 8, prefix + "O", false, residue_index) add_bond(built, nitrogen_index, alpha_index) add_bond(built, alpha_index, carbon_index) add_bond(built, carbon_index, oxygen_index) if previous[0] >= 0: add_bond(built, previous[2], nitrogen_index) for axis in range(3): built["trace"].append(alpha[axis]) previous = [nitrogen_index, alpha_index, carbon_index] if code == "G": continue beta = place_atom(nitrogen, carbon, alpha, BOND_CA_CB_ANGSTROM, ANGLE_C_CA_CB_DEGREE, DIHEDRAL_N_C_CA_CB_DEGREE) mut slots = [nitrogen_index, alpha_index, add_atom(built, beta, 6, prefix + "CB", true, residue_index)] add_bond(built, alpha_index, slots[2]) for row in table[code]: placed = place_atom(point_at(built["positions"], slots[row[2] + 3]), point_at(built["positions"], slots[row[3] + 3]), point_at(built["positions"], slots[row[4] + 3]), row[5], row[6], row[7]) index = add_atom(built, placed, row[1], prefix + row[0], true, residue_index) add_bond(built, slots[row[4] + 3], index) slots.append(index) if code == "P": # Proline's pyrrolidine ring closes back onto the backbone nitrogen through CD. add_bond(built, slots[4], nitrogen_index) last = len(sequence) - 1 terminal = place_atom(point_at(built["positions"], previous[0]), point_at(built["positions"], previous[1]), point_at(built["positions"], previous[2]), BOND_C_OXT_ANGSTROM, ANGLE_CA_C_OXT_DEGREE, psi) add_bond(built, previous[2], add_atom(built, terminal, 8, "A:" + str(last + 1) + ":" + residue_three_letter(sequence.slice(last, last + 1)) + ":OXT", false, last)) built["max_steps"] = PEPTIDE_RELAXATION_STEPS return built
def build_molecule(spec: dict[str, any]) !{}: """Attach fragment templates head to tail along a zig-zagging growth axis so the initial guess is an extended chain rather than a stack; the relaxation then resolves the linkage geometry.""" mut built = new_build() mut cursor = [0.0, 0.0, 0.0] mut previous_tail = -1 for fragment_index in range(len(spec["fragments"])): fragment = build_fragment(spec["fragments"][fragment_index]) direction = unit_vector([ 1.0, GROWTH_LATERAL if fragment_index % 2 == 0 else -GROWTH_LATERAL, GROWTH_VERTICAL if (fragment_index // 2) % 2 == 0 else -GROWTH_VERTICAL, ]) placement = rotation_between([1.0, 0.0, 0.0], direction) base = len(built["atomic_numbers"]) prefix = "L:" + str(fragment_index + 1) + ":" + fragment["tag"] + ":" for atom in range(len(fragment["atomic_numbers"])): turned = rotated(placement, fragment["points"][atom]) add_atom(built, [turned[a] + cursor[a] for a in range(3)], fragment["atomic_numbers"][atom], prefix + fragment["atom_names"][atom], true, fragment_index) for entry in range(len(fragment["bonds"]) // 2): add_bond(built, base + fragment["bonds"][entry * 2], base + fragment["bonds"][entry * 2 + 1]) if previous_tail >= 0: add_bond(built, previous_tail, base + fragment["head"]) previous_tail = base + fragment["tail"] advance = fragment["points"][fragment["tail"]][0] + FRAGMENT_LINK_ANGSTROM cursor = [cursor[a] + direction[a] * advance for a in range(3)] built["max_steps"] = MOLECULE_RELAXATION_STEPS return built
def restraint_field(built: dict[str, any]): """Harmonic 1-2 bonds at their as-built length plus 1-3 Urey-Bradley terms.
Inside a fragment or a residue the 1-3 rest length is the template distance, so the published fragment geometry is preserved exactly. Across a head-to-tail link there is no template angle, so the rest length comes from the law of cosines on the two bond lengths and the ideal valence angle for the central atom's coordination number. """ positions = built["positions"] count = len(built["atomic_numbers"]) bonds = built["bonds"] mut excluded = [false for slot in range(count * count)] mut left: list[int] = [] mut right: list[int] = [] mut length: list[f64] = [] mut stiffness: list[f64] = [] mut neighbours = [[] for atom in range(count)] mut neighbour_length = [[] for atom in range(count)] for entry in range(len(bonds) // 2): a = bonds[entry * 2] b = bonds[entry * 2 + 1] separation = math.sqrt(sum((positions[b * 3 + axis] - positions[a * 3 + axis]) ** 2 for axis in range(3))) left.append(a) right.append(b) length.append(separation) stiffness.append(BOND_STIFFNESS_KJ_PER_MOL_ANGSTROM2) excluded[a * count + b] = true excluded[b * count + a] = true neighbours[a].append(b) neighbours[b].append(a) neighbour_length[a].append(separation) neighbour_length[b].append(separation) for centre in range(count): ideal = math.cos(109.5 * math.pi / 180.0) if len(neighbours[centre]) >= 4 else math.cos(120.0 * math.pi / 180.0) for first in range(len(neighbours[centre])): for second in range(first + 1, len(neighbours[centre])): a = neighbours[centre][first] b = neighbours[centre][second] if excluded[a * count + b]: continue same_group = built["fragment_of"][a] == built["fragment_of"][centre] and built["fragment_of"][b] == built["fragment_of"][centre] first_bond = neighbour_length[centre][first] second_bond = neighbour_length[centre][second] template = math.sqrt(sum((positions[b * 3 + axis] - positions[a * 3 + axis]) ** 2 for axis in range(3))) left.append(a) right.append(b) length.append(template if same_group else math.sqrt(first_bond * first_bond + second_bond * second_bond - 2.0 * first_bond * second_bond * ideal)) stiffness.append(ANGLE_STIFFNESS_KJ_PER_MOL_ANGSTROM2) excluded[a * count + b] = true excluded[b * count + a] = true return { "count": count, "mobile": built["mobile"], "excluded": excluded, "restraint_left": left, "restraint_right": right, "restraint_length": length, "restraint_stiffness": stiffness, "neighbour_left": [], "neighbour_right": [], }
def rebuild_neighbours(field: dict[str, any], positions: list[f64]): """Verlet candidate list: only pairs inside the repulsive core plus a skin can ever clash, and a pair of frozen atoms contributes a constant energy so it never changes the line search.""" count = field["count"] limit = (CLASH_CORE_ANGSTROM + NEIGHBOUR_SKIN_ANGSTROM) ** 2 mut left: list[int] = [] mut right: list[int] = [] for a in range(count): for b in range(a + 1, count): if field["excluded"][a * count + b] or (not field["mobile"][a] and not field["mobile"][b]): continue if sum((positions[b * 3 + axis] - positions[a * 3 + axis]) ** 2 for axis in range(3)) < limit: left.append(a) right.append(b) field["neighbour_left"] = left field["neighbour_right"] = right
def relaxation_energy(field: dict[str, any], positions: list[f64], forces: list[f64]): """Harmonic restraints plus a purely repulsive r^-12 core truncated and shifted to zero at `CLASH_CORE_ANGSTROM`. Fills `forces` with -dE/dx and returns the energy in kJ/mol.""" for slot in range(len(forces)): forces[slot] = 0.0 mut energy = 0.0 for entry in range(len(field["restraint_length"])): a = field["restraint_left"][entry] * 3 b = field["restraint_right"][entry] * 3 dx = positions[b] - positions[a] dy = positions[b + 1] - positions[a + 1] dz = positions[b + 2] - positions[a + 2] separation = max(MIN_SEPARATION_ANGSTROM, math.sqrt(dx * dx + dy * dy + dz * dz)) stretch = separation - field["restraint_length"][entry] gradient = 2.0 * field["restraint_stiffness"][entry] * stretch / separation energy = energy + field["restraint_stiffness"][entry] * stretch * stretch forces[a] = forces[a] + gradient * dx forces[a + 1] = forces[a + 1] + gradient * dy forces[a + 2] = forces[a + 2] + gradient * dz forces[b] = forces[b] - gradient * dx forces[b + 1] = forces[b + 1] - gradient * dy forces[b + 2] = forces[b + 2] - gradient * dz for pair in range(len(field["neighbour_left"])): a = field["neighbour_left"][pair] * 3 b = field["neighbour_right"][pair] * 3 dx = positions[b] - positions[a] dy = positions[b + 1] - positions[a + 1] dz = positions[b + 2] - positions[a + 2] separation = max(MIN_SEPARATION_ANGSTROM, math.sqrt(dx * dx + dy * dy + dz * dz)) if separation >= CLASH_CORE_ANGSTROM: continue cube = (CLASH_CORE_ANGSTROM / separation) ** 3 power = cube * cube * cube * cube gradient = 12.0 * field["epsilon"] * power / (separation * separation) energy = energy + field["epsilon"] * (power - 1.0) forces[a] = forces[a] - gradient * dx forces[a + 1] = forces[a + 1] - gradient * dy forces[a + 2] = forces[a + 2] - gradient * dz forces[b] = forces[b] + gradient * dx forces[b + 1] = forces[b + 1] + gradient * dy forces[b + 2] = forces[b + 2] + gradient * dz for atom in range(field["count"]): if not field["mobile"][atom]: for axis in range(3): forces[atom * 3 + axis] = 0.0 return energy
def minimise(field: dict[str, any], positions: list[f64], max_steps: int, epsilon: f64): """Bounded steepest descent with a backtracking step: accept a trial move only when it lowers the energy, otherwise shrink the step. Deterministic and capped at `max_steps` evaluations.""" field["epsilon"] = epsilon mut current = [coordinate for coordinate in positions] mut trial = [coordinate for coordinate in positions] mut forces = [0.0 for coordinate in positions] mut trial_forces = [0.0 for coordinate in positions] rebuild_neighbours(field, current) mut energy = relaxation_energy(field, current, forces) mut step = INITIAL_STEP mut used = 0 mut max_force = 0.0 for iteration in range(max_steps): if iteration > 0 and iteration % NEIGHBOUR_REBUILD_STEPS == 0: rebuild_neighbours(field, current) energy = relaxation_energy(field, current, forces) max_force = 0.0 for atom in range(field["count"]): offset = atom * 3 max_force = max(max_force, math.sqrt(forces[offset] ** 2 + forces[offset + 1] ** 2 + forces[offset + 2] ** 2)) used = iteration + 1 if max_force < FORCE_TOLERANCE_KJ_PER_MOL_ANGSTROM: break scale = min(step, MAX_DISPLACEMENT_ANGSTROM / max_force) for slot in range(len(current)): trial[slot] = current[slot] + scale * forces[slot] candidate = relaxation_energy(field, trial, trial_forces) if candidate < energy: for slot in range(len(current)): current[slot] = trial[slot] forces[slot] = trial_forces[slot] energy = candidate step = step * STEP_GROWTH else: step = step * STEP_SHRINK return {"positions": current, "steps": used, "max_force": max_force}
def minimum_free_separation(field: dict[str, any], positions: list[f64]): """Closest approach over heavy-atom pairs that are more than two bonds apart; 1-2 and 1-3 pairs are covalent geometry (a ring's meta carbons sit at 2.4 angstrom by construction) and excluded.""" count = field["count"] mut closest = 1000.0 for a in range(count): for b in range(a + 1, count): if field["excluded"][a * count + b]: continue closest = min(closest, math.sqrt(sum((positions[b * 3 + axis] - positions[a * 3 + axis]) ** 2 for axis in range(3)))) return closest
def relax_build(built: dict[str, any]): field = restraint_field(built) relaxed = minimise(field, built["positions"], built["max_steps"], CORE_EPSILON_KJ_PER_MOL) if minimum_free_separation(field, relaxed["positions"]) >= CLASH_FLOOR_ANGSTROM: return relaxed escalated = minimise(field, relaxed["positions"], built["max_steps"], CORE_EPSILON_ESCALATED_KJ_PER_MOL) return {"positions": escalated["positions"], "steps": relaxed["steps"] + escalated["steps"], "max_force": escalated["max_force"]}
def design_compile_error(detail: str): return {"ok": false, "error": "DesignCompileError", "detail": detail}
def spec_core(name: str, label: str, design_class: str, conformation: str, sequence: str, fragments: list[str], target_key: str, mechanism: str, charge_e: f64): return { "schema": SPEC_SCHEMA, "name": name, "label": label, "class": design_class, "conformation": conformation, "sequence": sequence, "fragments": fragments, "target_key": target_key, "mechanism": mechanism, "charge_e": charge_e, }
def sealed_spec(core: dict[str, any]) !{}: mut sealed = {key: value for key, value in core.items()} sealed["spec_sha256"] = sha256_json(core) return sealed
def targeting_suffix(target_key: str): return "" if len(target_key) == 0 else " targeting " + target_key
def peptide_spec(form: str, raw_sequence: str, name: str, target_key: str) !{}: if len(target_key) > 0 and not listed(design_target_keys(), target_key): return design_compile_error("targeting key is not a bounded molecular library key") sequence = raw_sequence.upper() conformation = "helix" if form == "helix" else "extended" charge = sum(residue_charge(sequence.slice(index, index + 1)) for index in range(len(sequence))) label = name + " - designed " + conformation + " peptide " + sequence + ", backbone N/CA/C/O plus CB with side chains truncated to at most " + str(SIDECHAIN_HEAVY_ATOM_LIMIT) + " heavy atoms beyond CB" + targeting_suffix(target_key) return {"ok": true, "kind": "design", "name": name, "spec": sealed_spec(spec_core(name, label, "peptide", conformation, sequence, [], target_key, "inert", charge))}
def molecule_spec(raw_fragments: str, name: str, target_key: str) !{}: if len(target_key) > 0 and not listed(design_target_keys(), target_key): return design_compile_error("targeting key is not a bounded molecular library key") fragments = raw_fragments.split("+") if len(fragments) > MAX_FRAGMENTS: return design_compile_error("a designed molecule may chain at most " + str(MAX_FRAGMENTS) + " fragments") known = design_fragment_names() for fragment in fragments: if not listed(known, fragment): return design_compile_error("unknown fragment '" + fragment + "'; the library is " + ", ".join(known)) charge = sum(fragment_template(fragment)["charge_e"] for fragment in fragments) label = name + " - designed small molecule " + "+".join(fragments) + ", fragment templates linked head to tail and relaxed" + targeting_suffix(target_key) return {"ok": true, "kind": "design", "name": name, "spec": sealed_spec(spec_core(name, label, "small_molecule", "extended", "", fragments, target_key, "inert", charge))}
pub def compile_design_command(command: str) -> dict[str, any] !{}: sem "Compile one bounded natural-language molecular design instruction into a sealed design spec" if len(command) == 0 or len(command) > MAX_COMMAND_CHARS: return design_compile_error("command must contain 1..320 characters") text = command.lower().strip() match text: # Match "design peptide <one-letter sequence> as <handle>" with no targeting clause. case re"^design peptide (?P<sequence>[acdefghiklmnpqrstvwy]{1,24}) as (?P<name>[a-z][a-z0-9-]{0,23})$": return peptide_spec("peptide", sequence, name, "") # Match the same extended-peptide command followed by a "targeting <library key>" clause. case re"^design peptide (?P<sequence>[acdefghiklmnpqrstvwy]{1,24}) as (?P<name>[a-z][a-z0-9-]{0,23}) targeting (?P<target>[a-z0-9_]{1,32})$": return peptide_spec("peptide", sequence, name, target) # Match "design helix <one-letter sequence> as <handle>" with no targeting clause. case re"^design helix (?P<sequence>[acdefghiklmnpqrstvwy]{1,24}) as (?P<name>[a-z][a-z0-9-]{0,23})$": return peptide_spec("helix", sequence, name, "") # Match the same alpha-helix command followed by a "targeting <library key>" clause. case re"^design helix (?P<sequence>[acdefghiklmnpqrstvwy]{1,24}) as (?P<name>[a-z][a-z0-9-]{0,23}) targeting (?P<target>[a-z0-9_]{1,32})$": return peptide_spec("helix", sequence, name, target) # Match "design molecule <fragment>[+<fragment>]... as <handle>" with no targeting clause. case re"^design molecule (?P<fragments>[a-z]+(\+[a-z]+)*) as (?P<name>[a-z][a-z0-9-]{0,23})$": return molecule_spec(fragments, name, "") # Match the same molecule command followed by a "targeting <library key>" clause. case re"^design molecule (?P<fragments>[a-z]+(\+[a-z]+)*) as (?P<name>[a-z][a-z0-9-]{0,23}) targeting (?P<target>[a-z0-9_]{1,32})$": return molecule_spec(fragments, name, target) # Match "set mechanism of <handle> to <mechanism>" for an already designed species. case re"^set mechanism of (?P<name>[a-z][a-z0-9-]{0,23}) to (?P<mechanism>[a-z_]{1,32})$": if not listed(design_mechanisms(), mechanism): return design_compile_error("unknown mechanism '" + mechanism + "'; supported mechanisms are " + ", ".join(design_mechanisms())) return {"ok": true, "kind": "set_mechanism", "name": name, "mechanism": mechanism} case _: return design_compile_error("command does not match the bounded molecular design grammar")
def design_name_valid(name: str): match name: # Match a design handle: one lowercase letter then up to 23 letters, digits or hyphens. case re"^[a-z][a-z0-9-]{0,23}$": return true case _: return false
pub def design_spec_valid(spec: dict[str, any]) -> bool !{}: sem "Accept only a sealed design spec whose fields are inside every declared bound and whose digest still matches" fields = ["schema", "name", "label", "class", "conformation", "sequence", "fragments", "target_key", "mechanism", "charge_e", "spec_sha256"] if not all(spec.has(field) for field in fields): return false if spec["schema"] != SPEC_SCHEMA or not design_name_valid(spec["name"]) or len(spec["label"]) == 0: return false if not listed(["extended", "helix"], spec["conformation"]) or not listed(design_mechanisms(), spec["mechanism"]): return false if len(spec["target_key"]) > 0 and not listed(design_target_keys(), spec["target_key"]): return false if spec["class"] == "peptide": sequence = spec["sequence"] if len(sequence) == 0 or len(sequence) > MAX_RESIDUES or len(spec["fragments"]) > 0: return false if not all(RESIDUE_ALPHABET.contains(sequence.slice(index, index + 1)) for index in range(len(sequence))): return false elif spec["class"] == "small_molecule": fragments = spec["fragments"] if len(fragments) == 0 or len(fragments) > MAX_FRAGMENTS or len(spec["sequence"]) > 0: return false if not all(listed(design_fragment_names(), fragment) for fragment in fragments): return false else: return false return spec["spec_sha256"] == sha256_json(spec_core(spec["name"], spec["label"], spec["class"], spec["conformation"], spec["sequence"], spec["fragments"], spec["target_key"], spec["mechanism"], spec["charge_e"]))
pub def design_capabilities() -> dict[str, any] !{}: return { "max_designs": MAX_DESIGNS, "max_atoms": MAX_DESIGN_ATOMS, "max_bonds": MAX_DESIGN_BONDS, "classes": ["peptide", "small_molecule"], "mechanisms": design_mechanisms(), "fragments": design_fragment_names(), "residues": RESIDUE_ALPHABET, "examples": [ "design peptide ACDEFG as probe-1 targeting insulin", "design helix eaalkkleaalkk as shield-1 targeting interleukin_1_beta", "design molecule benzene+sulfonylurea as sulfa-1", "design molecule phenol+carboxyl+glucosyl as sugar-acid-1 targeting amylase", "set mechanism of sulfa-1 to secretion_agonist", ], "commands": [ "design peptide <sequence 1..24 of ACDEFGHIKLMNPQRSTVWY> as <name>", "design peptide <sequence> as <name> targeting <target-key>", "design helix <sequence> as <name>[ targeting <target-key>]", "design molecule <fragment>[+<fragment>]... (1..6 fragments) as <name>[ targeting <target-key>]", "set mechanism of <name> to <mechanism>", ], }
pub def build_designed_structure(spec: dict[str, any]) -> dict[str, any] !{}: sem "Build computed engineered geometry for a sealed design spec in the shape the molecular viewer already renders" require design_spec_valid(spec) built = build_peptide(spec) if spec["class"] == "peptide" else build_molecule(spec) count = len(built["atomic_numbers"]) ensure count > 0 and count <= MAX_DESIGN_ATOMS ensure len(built["bonds"]) // 2 <= MAX_DESIGN_BONDS relaxed = relax_build(built) coordinates = relaxed["positions"] mut centre = [0.0, 0.0, 0.0] for atom in range(count): for axis in range(3): centre[axis] = centre[axis] + coordinates[atom * 3 + axis] / count positions = [coordinates[slot] - centre[slot % 3] for slot in range(len(coordinates))] mut minimum = [positions[0], positions[1], positions[2]] mut maximum = [positions[0], positions[1], positions[2]] mut radius_angstrom = 0.0 for atom in range(count): offset = atom * 3 # The framing radius is the van der Waals envelope, so a one-atom design is still non-zero. radius_angstrom = max(radius_angstrom, math.sqrt(positions[offset] ** 2 + positions[offset + 1] ** 2 + positions[offset + 2] ** 2) + atomic_radius(built["atomic_numbers"][atom], "vdw")) for axis in range(3): minimum[axis] = min(minimum[axis], positions[offset + axis]) maximum[axis] = max(maximum[axis], positions[offset + axis]) ensure radius_angstrom > 0.0 traces = [] if spec["class"] == "small_molecule" else [{ "chain_id": "A", "polymer_type": "protein", "secondary": "helix" if spec["conformation"] == "helix" else "coil", "positions": [built["trace"][slot] - centre[slot % 3] for slot in range(len(built["trace"]))], }] structure = { "key": spec["name"], "label": spec["label"], "pdb_id": "", "source_sha256": spec["spec_sha256"], "topology_sha256": sha256_json({"source_sha256": spec["spec_sha256"], "bonds": built["bonds"]}), "fidelity": "engineered_unvalidated", "biological_match": "designed_de_novo", "source_page": "sema://design/" + spec["name"], "atomic_numbers": built["atomic_numbers"], "element_names": [element_name(atomic_number) for atomic_number in built["atomic_numbers"]], "positions": positions, "labels": built["labels"], "bonds": built["bonds"], "traces": traces, "covalent_radii_angstrom": [atomic_radius(atomic_number, "covalent") for atomic_number in built["atomic_numbers"]], "vdw_radii_angstrom": [atomic_radius(atomic_number, "vdw") for atomic_number in built["atomic_numbers"]], "radius_angstrom": radius_angstrom, "unit_scale": UNIT_SCALE, "radius_nm": radius_angstrom * UNIT_SCALE, "extent_nm": [(maximum[axis] - minimum[axis]) * UNIT_SCALE for axis in range(3)], "center_offset_angstrom": [0.0, 0.0, 0.0], "base_bond_count": len(built["bonds"]) // 2, "bond_capacity": len(built["bonds"]) // 2 + 16, "structural_edits": 0, "coordinate_edits": 0, "sidechain_model": SIDECHAIN_MODEL if spec["class"] == "peptide" else "fragment_template_chain", "relaxation_steps": relaxed["steps"], "max_force_kj_mol_angstrom": relaxed["max_force"], } mut sealed = {key: value for key, value in structure.items()} sealed["asset_sha256"] = sha256_json(structure) return sealed
test "the design grammar seals specs, rejects everything outside its bounds, and builds computed geometry": peptide = compile_design_command("design peptide ACDEFG as probe-1 targeting insulin") ensure peptide["ok"] and peptide["kind"] == "design" and peptide["name"] == "probe-1" spec = peptide["spec"] ensure spec["class"] == "peptide" and spec["conformation"] == "extended" and spec["sequence"] == "ACDEFG" ensure spec["target_key"] == "insulin" and spec["mechanism"] == "inert" and spec["charge_e"] == -2.0 ensure len(spec["spec_sha256"]) == 64 and design_spec_valid(spec) structure = build_designed_structure(spec) atoms = len(structure["atomic_numbers"]) ensure atoms >= 40 and atoms <= 512 ensure len(structure["positions"]) == atoms * 3 and len(structure["labels"]) == atoms ensure len(structure["element_names"]) == atoms and len(structure["covalent_radii_angstrom"]) == atoms ensure len(structure["vdw_radii_angstrom"]) == atoms and len(structure["bonds"]) % 2 == 0 ensure structure["radius_angstrom"] > 0.0 and len(structure["extent_nm"]) == 3 ensure len(structure["source_sha256"]) == 64 and len(structure["asset_sha256"]) == 64 ensure structure["fidelity"] == "engineered_unvalidated" and structure["biological_match"] == "designed_de_novo" ensure structure["sidechain_model"] == "backbone_plus_truncated_sidechain" ensure len(structure["traces"]) == 1 and len(structure["traces"][0]["positions"]) == 18 ensure build_designed_structure(spec)["asset_sha256"] == structure["asset_sha256"] other = compile_design_command("design peptide ACDEFH as probe-1 targeting insulin")["spec"] ensure build_designed_structure(other)["asset_sha256"] != structure["asset_sha256"] molecule = compile_design_command("design molecule benzene+sulfonylurea as sulfa-1") ensure molecule["ok"] and molecule["spec"]["class"] == "small_molecule" ensure molecule["spec"]["fragments"] == ["benzene", "sulfonylurea"] built = build_designed_structure(molecule["spec"]) ensure len(built["atomic_numbers"]) == 13 and built["traces"] == [] ensure built["relaxation_steps"] > 0 and built["max_force_kj_mol_angstrom"] >= 0.0 mechanism = compile_design_command("set mechanism of sulfa-1 to secretion_agonist") ensure mechanism["ok"] and mechanism["kind"] == "set_mechanism" and mechanism["mechanism"] == "secretion_agonist" ensure not compile_design_command("set mechanism of sulfa-1 to teleport")["ok"] ensure not compile_design_command("design peptide ACBX as bad-1")["ok"] ensure not compile_design_command("design molecule unobtainium as bad-2")["ok"] ensure not compile_design_command("design molecule benzene+benzene+benzene+benzene+benzene+benzene+benzene as bad-3")["ok"] ensure not compile_design_command("design peptide ACDEFG as probe-1 targeting unicorn")["ok"] ensure compile_design_command("")["error"] == "DesignCompileError" ensure not design_spec_valid({"schema": SPEC_SCHEMA, "name": "x"})src/discovery.sema
Section titled “src/discovery.sema”"""Bounded computational-discovery lineage, gates, and honest result classes."""
assure silver
pub enum CandidateKind: molecule | bond | interaction | circuit | equation_change | experiment
pub enum CandidateStatus: proposed | rejected | admitted | simulated | ranked | blocked
pub enum CandidateClaim: unseen_in_bounded_search | predicted_interaction | simulated_association | experimentally_supported | clinical
pub struct SearchBoundary: id: str description: str allowed_kinds: list[CandidateKind] max_candidates: int max_rounds: int max_compute_units: int prior_art_sources: list[str] safety_policy_id: str invariant len(id) > 0 invariant len(description) > 0 invariant max_candidates > 0 invariant max_rounds > 0 invariant max_compute_units > 0 invariant len(prior_art_sources) > 0 invariant len(safety_policy_id) > 0
pub struct DiscoveryBatch: boundary_id: str round_index: int candidate_ids: list[str] requested_compute_units: int invariant len(boundary_id) > 0 invariant round_index > 0 invariant len(candidate_ids) > 0 invariant requested_compute_units > 0
pub struct CandidateHypothesis: id: str parent_ids: list[str] kind: CandidateKind representation_digest: str rationale: str provenance_ids: list[str] prior_art_scope_id: str model_id: str model_version: int equation_graph_id: str equation_version: int uncertainty: f64 requested_compute_units: int status: CandidateStatus rejection_reasons: list[str] invariant len(id) > 0 invariant len(representation_digest) == 64 invariant len(rationale) > 0 invariant len(provenance_ids) > 0 invariant len(prior_art_scope_id) > 0 invariant len(model_id) > 0 invariant model_version > 0 invariant len(equation_graph_id) > 0 invariant equation_version > 0 invariant uncertainty >= 0.0 invariant requested_compute_units > 0
pub struct CandidateEvidence: candidate_id: str observation_ids: list[str] oracle_evidence_ids: list[str] prior_art_evidence_ids: list[str] objective_names: list[str] objective_values: list[f64] uncertainty: f64 information_gain: f64 claim: CandidateClaim status: CandidateStatus invariant len(candidate_id) > 0 invariant len(objective_names) == len(objective_values) invariant uncertainty >= 0.0 invariant information_gain >= 0.0
def within_boundary(candidate: CandidateHypothesis, boundary: SearchBoundary): if candidate.requested_compute_units > boundary.max_compute_units: return false if candidate.prior_art_scope_id != boundary.id: return false return candidate.kind in boundary.allowed_kinds
pub def validate_discovery_batch( batch: DiscoveryBatch, candidates: list[CandidateHypothesis], boundary: SearchBoundary,) -> bool !{}: if batch.boundary_id != boundary.id: return false if batch.round_index > boundary.max_rounds: return false if len(candidates) == 0 or len(candidates) > boundary.max_candidates: return false if len(batch.candidate_ids) != len(candidates): return false mut compute_units = 0 mut seen_ids: list[str] = [] for candidate in candidates: if not within_boundary(candidate, boundary): return false if candidate.id not in batch.candidate_ids or candidate.id in seen_ids: return false seen_ids.append(candidate.id) compute_units = compute_units + candidate.requested_compute_units if compute_units > boundary.max_compute_units: return false return compute_units == batch.requested_compute_units
def reject_candidate(candidate: CandidateHypothesis, reason: str): require len(reason) > 0 mut reasons = candidate.rejection_reasons reasons.append(reason) return CandidateHypothesis( id=candidate.id, parent_ids=candidate.parent_ids, kind=candidate.kind, representation_digest=candidate.representation_digest, rationale=candidate.rationale, provenance_ids=candidate.provenance_ids, prior_art_scope_id=candidate.prior_art_scope_id, model_id=candidate.model_id, model_version=candidate.model_version, equation_graph_id=candidate.equation_graph_id, equation_version=candidate.equation_version, uncertainty=candidate.uncertainty, requested_compute_units=candidate.requested_compute_units, status=CandidateStatus.rejected, rejection_reasons=reasons, )
pub def admit_candidate( candidate: CandidateHypothesis, boundary: SearchBoundary, chemistry_valid: bool, topology_valid: bool, applicability_valid: bool, evidence_valid: bool, safety_valid: bool,) -> CandidateHypothesis !{}: if not within_boundary(candidate, boundary): return reject_candidate(candidate, "outside declared search or resource boundary") if not chemistry_valid: return reject_candidate(candidate, "chemistry validation failed") if not topology_valid: return reject_candidate(candidate, "topology validation failed") if not applicability_valid: return reject_candidate(candidate, "model applicability validation failed") if not evidence_valid: return reject_candidate(candidate, "evidence preflight failed") if not safety_valid: return reject_candidate(candidate, "safety policy denied candidate") return CandidateHypothesis( id=candidate.id, parent_ids=candidate.parent_ids, kind=candidate.kind, representation_digest=candidate.representation_digest, rationale=candidate.rationale, provenance_ids=candidate.provenance_ids, prior_art_scope_id=candidate.prior_art_scope_id, model_id=candidate.model_id, model_version=candidate.model_version, equation_graph_id=candidate.equation_graph_id, equation_version=candidate.equation_version, uncertainty=candidate.uncertainty, requested_compute_units=candidate.requested_compute_units, status=CandidateStatus.admitted, rejection_reasons=[], )
pub def may_report_claim(evidence: CandidateEvidence) -> bool !{}: if evidence.claim == CandidateClaim.clinical: return false if evidence.claim == CandidateClaim.unseen_in_bounded_search: return len(evidence.prior_art_evidence_ids) > 0 and evidence.status == CandidateStatus.ranked if evidence.claim == CandidateClaim.experimentally_supported: return len(evidence.oracle_evidence_ids) > 0 if evidence.claim == CandidateClaim.simulated_association: return len(evidence.observation_ids) > 0 and len(evidence.oracle_evidence_ids) > 0 if evidence.claim == CandidateClaim.predicted_interaction: return len(evidence.observation_ids) > 0 and evidence.status == CandidateStatus.ranked return evidence.status == CandidateStatus.rankedsrc/domain.sema
Section titled “src/domain.sema”"""Typed physical identities, topology, backend profiles, observations, and phase evidence."""
assure silver
pub enum PhaseState: not_started | implemented_unvalidated | validated | blocked
enum EntityKind: particle | atom | residue | molecule | ensemble | coarse_state | field | membrane | organelle | cell | tissue
pub enum ModelScale: quantum | atomistic | coarse | mesoscopic | network | cellular | tissue
enum ResultClass: validated | calibrated | exploratory | unknown | invalid | failed
enum ReplayClass: exact | deterministic_tolerance | statistical | unavailable
pub enum EvidenceKind: computational | structural | ensemble | experimental | performance | negative
enum InteractionMethod: classical_fixed_topology | reactive_force_field | learned_potential | quantum | qmmm | particle_reaction_diffusion
enum PropertyValueKind: scalar | vector | tensor | per_atom | categorical | distribution
enum ReactionState: proposed | parameterized | computed | validated | blocked
pub struct Vector3: x: f64 y: f64 z: f64
pub struct Atom: id: str index: int element: str residue: str mass_da: f64 charge_e: f64 position_nm: Vector3 invariant len(id) > 0 invariant index >= 0 invariant len(element) > 0 invariant len(residue) > 0 invariant mass_da > 0.0
pub struct Bond: left_index: int right_index: int order: int invariant left_index >= 0 invariant right_index >= 0 invariant order >= 1 and order <= 3
pub struct PeriodicBox: x_nm: f64 y_nm: f64 z_nm: f64 invariant x_nm > 0.0 invariant y_nm > 0.0 invariant z_nm > 0.0
pub struct MolecularTopology: id: str atoms: list[Atom] bonds: list[Bond] box: PeriodicBox source_sha256: str invariant len(id) > 0 invariant len(atoms) > 0 and len(atoms) <= 10000 invariant len(bonds) <= 30000 invariant len(source_sha256) == 64
struct BackendProfile: id: str engine: str version: str platform: str precision: str properties: list[str] artifact_sha256: str replay: ReplayClass invariant len(id) > 0 invariant len(engine) > 0 invariant len(version) > 0 invariant len(platform) > 0 invariant len(precision) > 0 invariant len(properties) <= 64 invariant len(artifact_sha256) == 64
pub struct EvidenceRecord: id: str kind: EvidenceKind source: str summary: str artifact_sha256: str observed_at_s: f64 accepted: bool invariant len(id) > 0 invariant len(source) > 0 invariant len(summary) > 0 invariant len(artifact_sha256) == 64 invariant observed_at_s >= 0.0
pub struct InteractionTerm: id: str family: str owner_model_id: str active: bool target_observable: str evidence_ids: list[str] invariant len(id) > 0 invariant len(family) > 0 invariant len(owner_model_id) > 0 invariant len(target_observable) > 0 invariant len(evidence_ids) <= 128
struct MolecularProperty: id: str entity_id: str property_name: str scope_id: str value_kind: PropertyValueKind values: list[f64] labels: list[str] shape: list[int] unit_symbol: str uncertainty: f64 conditions: list[str] method_profile_id: str evidence_ids: list[str] valid: bool invariant len(id) > 0 invariant len(entity_id) > 0 invariant len(property_name) > 0 invariant len(scope_id) > 0 invariant len(values) > 0 or len(labels) > 0 invariant len(values) <= 1000000 invariant len(labels) <= 1000000 invariant len(shape) <= 8 invariant len(unit_symbol) > 0 invariant uncertainty >= 0.0 invariant len(conditions) <= 128 invariant len(method_profile_id) > 0 invariant len(evidence_ids) <= 128
struct InteractionProfile: id: str method: InteractionMethod engine: str version: str parameter_sha256: str scope_id: str supported_elements: list[str] properties: list[str] minimum_atoms: int maximum_atoms: int conditions: list[str] supports_topology_change: bool qualified: bool uncertainty_policy: str evidence_ids: list[str] invariant len(id) > 0 invariant len(engine) > 0 invariant len(version) > 0 invariant len(parameter_sha256) == 64 invariant len(scope_id) > 0 invariant len(supported_elements) > 0 and len(supported_elements) <= 118 invariant len(properties) > 0 and len(properties) <= 128 invariant minimum_atoms > 0 and maximum_atoms >= minimum_atoms invariant maximum_atoms <= 1000000 invariant len(conditions) > 0 and len(conditions) <= 128 invariant len(uncertainty_policy) > 0 invariant len(evidence_ids) <= 128
struct ReactionProposal: id: str reactant_topology_sha256: str product_topology_sha256: str elements: list[str] atom_map: list[int] total_charge: int spin_multiplicity: int profile_id: str scope_id: str conditions: list[str] evidence_ids: list[str] invariant len(id) > 0 invariant len(reactant_topology_sha256) == 64 invariant len(product_topology_sha256) == 64 invariant len(elements) > 0 and len(elements) <= 256 invariant len(atom_map) == len(elements) invariant spin_multiplicity > 0 invariant len(profile_id) > 0 invariant len(scope_id) > 0 invariant len(conditions) > 0 and len(conditions) <= 128 invariant len(evidence_ids) <= 128
struct ReactionDecision: proposal_id: str state: ReactionState admissible: bool profile_id: str reason: str invariant len(proposal_id) > 0 invariant len(profile_id) > 0 invariant len(reason) > 0
struct ObservationFrame: schema: str run_id: str state_version: int step: int physical_time_ps: f64 potential_energy_kj_mol: f64 kinetic_energy_kj_mol: f64 max_force_kj_mol_nm: f64 phi_rad: f64 psi_rad: f64 backend_profile_id: str evidence_ids: list[str] invariant schema == "sema.molecular-observation/v1" invariant len(run_id) > 0 invariant state_version >= 0 invariant step >= 0 invariant physical_time_ps >= 0.0 invariant max_force_kj_mol_nm >= 0.0 invariant len(backend_profile_id) > 0 invariant len(evidence_ids) <= 128
pub struct PhaseEvidence: phase: int state: PhaseState profile_id: str positive_evidence: list[str] negative_evidence: list[str] blockers: list[str] invariant phase >= 0 and phase <= 10 invariant len(profile_id) > 0 invariant len(positive_evidence) <= 128 invariant len(negative_evidence) <= 128 invariant len(blockers) <= 128
def distinct_atom_ids(atoms: list[Atom]): mut expected_index = 0 mut seen_ids: list[str] = [] for atom in atoms: if atom.index != expected_index or atom.id in seen_ids: return false seen_ids.append(atom.id) expected_index = expected_index + 1 return true
def bonds_reference_atoms(topology: MolecularTopology): for bond in topology.bonds: if bond.left_index >= len(topology.atoms) or bond.right_index >= len(topology.atoms): return false if bond.left_index == bond.right_index: return false return true
pub def topology_valid(topology: MolecularTopology) -> bool !{}: return distinct_atom_ids(topology.atoms) and bonds_reference_atoms(topology)
pub def interaction_ownership_valid(terms: list[InteractionTerm]) -> bool !{}: mut left = 0 for term in terms: mut right = 0 for other in terms: if left != right and term.active and other.active and term.id == other.id: return false right = right + 1 left = left + 1 return true
def profile_supports_elements(profile: InteractionProfile, elements: list[str]): for element in elements: if element not in profile.supported_elements: return false return true
def reaction_atom_map_valid(proposal: ReactionProposal): mut seen: list[int] = [] for atom_index in proposal.atom_map: if atom_index < 0 or atom_index >= len(proposal.atom_map) or atom_index in seen: return false seen.append(atom_index) return true
def molecular_property_admissible(property: MolecularProperty, profile: InteractionProfile): return property.valid and property.method_profile_id == profile.id and property.scope_id == profile.scope_id and property.conditions == profile.conditions and property.property_name in profile.properties and len(property.evidence_ids) > 0
def admit_reaction(proposal: ReactionProposal, profile: InteractionProfile): if proposal.profile_id != profile.id: return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="proposal and interaction profile identities differ") if proposal.scope_id != profile.scope_id or proposal.conditions != profile.conditions: return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="proposal scope or conditions differ from the interaction profile") if len(proposal.elements) < profile.minimum_atoms or len(proposal.elements) > profile.maximum_atoms: return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="proposal atom count lies outside the interaction profile") if not profile.supports_topology_change: return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="selected interaction profile cannot change topology") if not profile.qualified: return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="selected interaction profile is not qualified") if not profile_supports_elements(profile, proposal.elements): return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="proposal contains elements outside the interaction profile") if not reaction_atom_map_valid(proposal): return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="proposal atom mapping is not bijective") if len(proposal.evidence_ids) == 0 or len(profile.evidence_ids) == 0: return ReactionDecision(proposal_id=proposal.id, state=ReactionState.blocked, admissible=false, profile_id=profile.id, reason="reaction proposal or interaction profile lacks evidence") return ReactionDecision(proposal_id=proposal.id, state=ReactionState.parameterized, admissible=true, profile_id=profile.id, reason="proposal lies inside the qualified interaction profile")
pub def phase_validated(phase: PhaseEvidence) -> bool !{}: return phase.state == PhaseState.validated and len(phase.positive_evidence) > 0 and len(phase.negative_evidence) > 0 and len(phase.blockers) == 0
def blocked_phase(phase: int, profile_id: str, reason: str): require len(reason) > 0 return PhaseEvidence(phase=phase, state=PhaseState.blocked, profile_id=profile_id, positive_evidence=[], negative_evidence=[], blockers=[reason])src/dynamics.sema
Section titled “src/dynamics.sema”"""Sema-owned multiscale dynamics, model admission, control, and solver evidence."""
from std.adaptive_dynamics import ActivationDecision, ModelDescriptor, ModelLifecycle, SelectionPolicy, activate_validated, validate_candidatefrom std.epistemic import Assumption, Evidence, ValidityRegion
assure silver
pub struct ControlIntent: id: str natural_language: str target_tissue_response: f64 maximum_cellular_gain: f64 effort_penalty: f64 horizon_s: f64 evidence_ids: list[str] invariant len(id) > 0 invariant len(natural_language) > 0 invariant target_tissue_response >= 0.0 and target_tissue_response <= 1.0 invariant maximum_cellular_gain > 0.0 and maximum_cellular_gain <= 1.0 invariant effort_penalty > 0.0 invariant horizon_s > 0.0 and horizon_s <= 1000.0 invariant len(evidence_ids) > 0 and len(evidence_ids) <= 128
pub struct Phase8AdmissionEvidence: phase8_technical_pass: bool readdy_chronology_proven: bool readdy_qualification_pass: bool readdy_convergence_pass: bool readdy_spatial_pass: bool readdy_admission_pass: bool physicell_custom_insulin_pass: bool physicell_target_rate_pass: bool physicell_uncertainty_pass: bool physicell_scientific_pass: bool
pub def phase8_admission_evidence_complete(evidence: Phase8AdmissionEvidence) -> bool !{}: sem "Require every technical and scientific Phase8 gate before association-model admission" return evidence.phase8_technical_pass and evidence.readdy_chronology_proven and evidence.readdy_qualification_pass and evidence.readdy_convergence_pass and evidence.readdy_spatial_pass and evidence.readdy_admission_pass and evidence.physicell_custom_insulin_pass and evidence.physicell_target_rate_pass and evidence.physicell_uncertainty_pass and evidence.physicell_scientific_pass
pub struct AdaptationSummary: active_model_id: str candidate_model_id: str selected_model_id: str activated: bool admission_status: str admitted: bool exploratory: bool evidence_reliability: f64 parameter_apply_authorized: bool reason: str evidence_ids: list[str] invariant len(active_model_id) > 0 invariant len(candidate_model_id) > 0 invariant len(selected_model_id) > 0 invariant len(reason) > 0 invariant len(evidence_ids) > 0 and len(evidence_ids) <= 128 invariant admission_status == "admitted" or admission_status == "exploratory_unadmitted" invariant admitted == activated and exploratory != admitted invariant evidence_reliability == (1.0 if admitted else 0.0) invariant parameter_apply_authorized == admitted
pub struct DynamicsResult: schema: str contract_id: str semantics: str formal_equations: list[str] state_names: list[str] state_units: list[str] final_state: list[f64] cellular_gain: f64 target_tissue_response: f64 tissue_target_error: f64 initial_molecular_mass_micromolar: f64 final_molecular_mass_micromolar: f64 molecular_mass_relative_residual: f64 integration_error_bound: f64 integration_steps_accepted: int integration_steps_rejected: int integration_method: str optimizer_status: str optimizer_scope: str optimizer_objective: f64 optimizer_iterations: int adaptation: AdaptationSummary evidence_ids: list[str] admission_status: str admitted: bool exploratory: bool parameter_apply_authorized: bool technical_pass: bool scientific_validated: bool invariant schema == "sema.multiscale-dynamics-result/v1" invariant len(contract_id) > 0 invariant len(semantics) > 0 invariant len(formal_equations) == 4 invariant len(state_names) == 4 and len(state_units) == 4 and len(final_state) == 4 invariant cellular_gain >= 0.0 and cellular_gain <= 1.0 invariant tissue_target_error >= 0.0 invariant initial_molecular_mass_micromolar > 0.0 invariant final_molecular_mass_micromolar > 0.0 invariant molecular_mass_relative_residual >= 0.0 invariant integration_error_bound >= 0.0 invariant integration_steps_accepted > 0 and integration_steps_rejected >= 0 invariant len(integration_method) > 0 invariant len(optimizer_status) > 0 and len(optimizer_scope) > 0 invariant optimizer_iterations >= 0 invariant len(evidence_ids) > 0 and len(evidence_ids) <= 128 invariant admission_status == adaptation.admission_status invariant admitted == adaptation.admitted and exploratory == adaptation.exploratory invariant parameter_apply_authorized == adaptation.parameter_apply_authorized invariant admitted or technical_pass == false invariant scientific_validated == false
pub struct PopulationState: schema: str total_cells: int viable_cells: int dead_cells: int mutated_cells: int adapted_cells: int injected_micromolar: f64 applied_force_pn: f64 stress_fraction: f64 injected_molecule: str mutation_label: str last_intervention: str affected_index: int affected_kind: str event_count: int scientific_validated: bool invariant schema == "sema.biological-population-state/v2" invariant total_cells > 0 and viable_cells >= 0 and viable_cells + dead_cells == total_cells invariant mutated_cells >= 0 and mutated_cells <= viable_cells invariant adapted_cells >= 0 and adapted_cells <= viable_cells invariant injected_micromolar >= 0.0 and injected_micromolar <= 1000.0 invariant abs(applied_force_pn) <= 80.0 invariant stress_fraction >= 0.0 and stress_fraction <= 1.0 invariant len(injected_molecule) > 0 and len(mutation_label) > 0 and len(last_intervention) > 0 invariant affected_index >= -1 and affected_index < 16384 invariant affected_kind == "none" or affected_kind == "population" or affected_kind == "tissue-cell" or affected_kind == "vessel" or affected_kind == "granule" or affected_kind == "mitochondrion" or affected_kind == "receptor" or affected_kind == "protein" or affected_kind == "protein-atom" or affected_kind == "source-atom" or affected_kind == "membrane" or affected_kind == "nucleus" or affected_kind == "cytoskeleton" or affected_kind == "endoplasmic-reticulum" or affected_kind == "lipid-droplet" or affected_kind == "vessel-wall" or affected_kind == "vessel-lumen" or affected_kind == "erythrocyte" invariant event_count >= 0 invariant scientific_validated == false
pub struct DynamicsStep: schema: str sequence: int state_version: int equation_id: str equation_version: int model_id: str semantics: str state: list[f64] target_tissue_response: f64 cellular_gain: f64 molecular_integrity: f64 dt_s: f64 molecular_mass_relative_residual: f64 integration_error_bound: f64 integration_steps_accepted: int integration_steps_rejected: int optimizer_status: str optimizer_scope: str evidence_ids: list[str] physiology: dict[str, any] population: PopulationState admission_status: str admitted: bool exploratory: bool parameter_apply_authorized: bool technical_pass: bool scientific_validated: bool invariant schema == "sema.multiscale-dynamics-step/v1" invariant sequence >= 0 and state_version >= 1 invariant equation_id == "insulin-association-cell-tissue-control" invariant equation_version == 1 invariant len(model_id) > 0 and len(semantics) > 0 invariant len(state) == 4 invariant target_tissue_response >= 0.0 and target_tissue_response <= 1.0 invariant cellular_gain >= 0.0 and cellular_gain <= 1.0 invariant molecular_integrity >= 0.0 and molecular_integrity <= 1.0 invariant dt_s >= 0.01 and dt_s <= 0.25 invariant molecular_mass_relative_residual >= 0.0 invariant integration_error_bound >= 0.0 invariant integration_steps_accepted > 0 and integration_steps_rejected >= 0 invariant optimizer_status == "Optimal" and optimizer_scope == "global-convex" invariant len(evidence_ids) > 0 and len(evidence_ids) <= 128 invariant physiology["schema"] == "sema.metabolic-immune-observation/v1" and physiology["technical_pass"] invariant admission_status == "admitted" or admission_status == "exploratory_unadmitted" invariant admitted == (admission_status == "admitted") and exploratory != admitted invariant parameter_apply_authorized == admitted invariant admitted or technical_pass == false invariant scientific_validated == false
pub def initial_population_state(total_cells: int) -> PopulationState !{}: require total_cells > 0 and total_cells <= 16384 return PopulationState(schema="sema.biological-population-state/v2", total_cells=total_cells, viable_cells=total_cells, dead_cells=0, mutated_cells=0, adapted_cells=0, injected_micromolar=0.0, applied_force_pn=0.0, stress_fraction=0.0, injected_molecule="none", mutation_label="none", last_intervention="baseline", affected_index=-1, affected_kind="none", event_count=0, scientific_validated=false)
pub def apply_biological_intervention(state: PopulationState, kind: str, target_index: int, target_kind: str, magnitude: f64, amount: f64, molecule: str, mutation: str, seed_cells: int) -> PopulationState !{}: sem "Apply a bounded force, molecule injection, mutation seed, or ablation to Sema-owned population state" require kind == "force" or kind == "inject" or kind == "mutate" or kind == "ablate" require target_index >= -1 and target_index < 16384 require target_kind == "population" or target_kind == "tissue-cell" or target_kind == "vessel" or target_kind == "granule" or target_kind == "mitochondrion" or target_kind == "receptor" or target_kind == "protein" or target_kind == "protein-atom" or target_kind == "source-atom" or target_kind == "membrane" or target_kind == "nucleus" or target_kind == "cytoskeleton" or target_kind == "endoplasmic-reticulum" or target_kind == "lipid-droplet" or target_kind == "vessel-wall" or target_kind == "vessel-lumen" or target_kind == "erythrocyte" require magnitude >= -80.0 and magnitude <= 80.0 require amount >= 0.0 and amount <= 100.0 require seed_cells >= 0 and seed_cells <= 32 viable = state.viable_cells dead = state.dead_cells mutated = state.mutated_cells adapted = state.adapted_cells injected = state.injected_micromolar force = state.applied_force_pn stress = state.stress_fraction injected_molecule = state.injected_molecule mutation_label = state.mutation_label if kind == "force": ensure target_index >= 0 and abs(magnitude) > 0.0 ensure target_kind != "population" force = magnitude stress = min(1.0, stress + abs(magnitude) / 800.0) if abs(magnitude) >= 20.0: adapted = min(viable, adapted + 1) elif kind == "inject": ensure molecule == "insulin" or molecule == "glucose" or molecule == "cytokine" or molecule == "oxygen" ensure amount > 0.0 injected = min(1000.0, injected + amount) injected_molecule = molecule if molecule == "cytokine": stress = min(1.0, stress + amount / 200.0) elif molecule == "oxygen": stress = max(0.0, stress - amount / 300.0) elif kind == "mutate": ensure len(mutation) > 0 and seed_cells > 0 ensure target_kind == "population" or target_kind == "tissue-cell" mutated = min(viable, mutated + seed_cells) mutation_label = mutation stress = min(1.0, stress + f64(seed_cells) / f64(state.total_cells)) else: ensure target_index >= 0 and viable > 0 ensure target_kind == "tissue-cell" dead = min(state.total_cells, dead + 1) viable = state.total_cells - dead mutated = min(mutated, viable) adapted = min(adapted, viable) stress = min(1.0, stress + 0.04) return PopulationState(schema=state.schema, total_cells=state.total_cells, viable_cells=viable, dead_cells=dead, mutated_cells=mutated, adapted_cells=adapted, injected_micromolar=injected, applied_force_pn=force, stress_fraction=stress, injected_molecule=injected_molecule, mutation_label=mutation_label, last_intervention=kind, affected_index=target_index, affected_kind=target_kind, event_count=state.event_count + 1, scientific_validated=false)
def advance_population_dynamics(state: PopulationState, dt_s: f64, cellular_signal: f64, tissue_response: f64, beta_function_fraction: f64, immune_effector_fraction: f64): sem "Advance bounded mutation propagation, stress, adaptation, molecule clearance, and physiology-coupled cell viability" require dt_s >= 0.01 and dt_s <= 0.25 require cellular_signal >= 0.0 and cellular_signal <= 1.0 and tissue_response >= 0.0 and tissue_response <= 1.0 require beta_function_fraction >= 0.0 and beta_function_fraction <= 1.5 require immune_effector_fraction >= 0.0 and immune_effector_fraction <= 1.0 events = state.event_count + 1 immune_stress = immune_effector_fraction * 0.35 stress = max(0.0, min(1.0, state.stress_fraction + dt_s * immune_stress - dt_s * (0.01 + tissue_response * 0.02))) injected = max(0.0, state.injected_micromolar * (1.0 - dt_s * 0.025)) force = state.applied_force_pn if force > 0.0: force = max(0.0, force - dt_s * 2.0) elif force < 0.0: force = min(0.0, force + dt_s * 2.0) viable = state.viable_cells dead = state.dead_cells mutated = state.mutated_cells adapted = state.adapted_cells if mutated > 0 and mutated < viable and stress > 0.03 and events % 20 == 0: mutated = mutated + 1 if stress > 0.05 and adapted < viable and events % 25 == 0: adapted = adapted + 1 target_beta_deaths = int(f64(state.total_cells) * 0.24 * (1.0 - min(1.0, beta_function_fraction))) if (dead < target_beta_deaths or immune_effector_fraction > 0.6) and viable > 0 and events % 10 == 0: dead = dead + 1 viable = state.total_cells - dead mutated = min(mutated, viable) adapted = min(adapted, viable) return PopulationState(schema=state.schema, total_cells=state.total_cells, viable_cells=viable, dead_cells=dead, mutated_cells=mutated, adapted_cells=adapted, injected_micromolar=injected, applied_force_pn=force, stress_fraction=stress, injected_molecule=state.injected_molecule, mutation_label=state.mutation_label, last_intervention="advance", affected_index=state.affected_index, affected_kind=state.affected_kind, event_count=events, scientific_validated=false)
pub def dynamics_equations() -> list[str] !{}: return ["d[M]/dt = -2 k_on [M]^2 + 2 k_off [D]", "d[D]/dt = k_on [M]^2 - k_off [D]", "d[C]/dt = u I [D]/([M]+2[D]) - k_C C", "d[T]/dt = g_T C - k_T T"]
equation insulin_signal_rhs(t, state, association_rate, dissociation_rate, cellular_gain, molecular_integrity, cellular_decay, tissue_gain, tissue_decay) -> any: association_flux := association_rate * state[0]^2 dissociation_flux := dissociation_rate * state[1] molecular_mass := state[0] + 2.0 * state[1] dimer_fraction := state[1] / molecular_mass return [ 0.0 - 2.0 * association_flux + 2.0 * dissociation_flux, association_flux - dissociation_flux, cellular_gain * molecular_integrity * dimer_fraction - cellular_decay * state[2], tissue_gain * state[2] - tissue_decay * state[3], ]
equation optimize_cellular_gain(dimer_fraction, target, maximum_gain, effort_penalty, cellular_decay, tissue_gain, tissue_decay) -> any: response_gain := tissue_gain * dimer_fraction / (cellular_decay * tissue_decay) quadratic := 2.0 * (response_gain^2 + effort_penalty) linear := 0.0 - 2.0 * response_gain * target return quadratic_program([[quadratic]], [linear], [[1.0], [-1.0]], [maximum_gain, 0.0])
equation integrate_insulin_signal(monomer, dimer, horizon, association_rate, dissociation_rate, cellular_gain, cellular_decay, tissue_gain, tissue_decay) -> any: return ode(insulin_signal_rhs, 0.0, [monomer, dimer, 0.0, 0.0], horizon, 0.000000001, 0.000000000001, 100000, [association_rate, dissociation_rate, cellular_gain, 1.0, cellular_decay, tissue_gain, tissue_decay], "rk45")
equation integrate_insulin_live_state(state, horizon, association_rate, dissociation_rate, cellular_gain, molecular_integrity, cellular_decay, tissue_gain, tissue_decay) -> any: return ode(insulin_signal_rhs, 0.0, state, horizon, 0.000000001, 0.000000000001, 10000, [association_rate, dissociation_rate, cellular_gain, molecular_integrity, cellular_decay, tissue_gain, tissue_decay], "rk45")
def exploratory_unadmitted_association_preview(profile_id: str, evidence_id: str): sem "Expose an unadmitted association candidate for inspection without activating assumptions, evidence reliability, parameters, or decision authority" require len(profile_id) > 0 and len(evidence_id) == 64 return AdaptationSummary( active_model_id="preregistered-insulin-association-v0", candidate_model_id=profile_id, selected_model_id="preregistered-insulin-association-v0", activated=false, admission_status="exploratory_unadmitted", admitted=false, exploratory=true, evidence_reliability=0.0, parameter_apply_authorized=false, reason="Phase8 admission gates failed; candidate remains proposed for exploratory inspection only", evidence_ids=[evidence_id], )
pub def admit_association_model(profile_id: str, association_rate: f64, dissociation_rate: f64, reference_error: f64, candidate_error: f64, evidence_id: str, observed_at: f64, admission_evidence: Phase8AdmissionEvidence) -> AdaptationSummary !{}: sem "Activate a reaction model only after the complete typed Phase8 evidence predicate plus held-out error, dwell-time, and hysteresis gates" require len(profile_id) > 0 and association_rate > 0.0 and dissociation_rate > 0.0 require reference_error > 0.0 and candidate_error >= 0.0 and observed_at >= 1.0 require len(evidence_id) == 64 if not phase8_admission_evidence_complete(admission_evidence): return exploratory_unadmitted_association_preview(profile_id, evidence_id) validity = ValidityRegion(label=profile_id, in_scope=true, distance_to_boundary=0.0, checked_at=observed_at) assumption = Assumption(id="well-mixed-insulin-association", statement="The admitted Phase8 profile defines a bounded well-mixed association model", active=true, checked_at=observed_at, evidence_ids=[evidence_id]) active = ModelDescriptor(id="preregistered-insulin-association-v0", family="mass-action-association", version=1, lifecycle=ModelLifecycle.active, parameter_names=["association_rate", "dissociation_rate"], parameters=[association_rate, dissociation_rate], structure_signature="M + M <-> D", assumptions=[assumption], validity=validity, fit_error=reference_error, validation_error=reference_error, created_at=0.0, activated_step=0) candidate = ModelDescriptor(id=profile_id, family="mass-action-association", version=2, lifecycle=ModelLifecycle.proposed, parameter_names=["association_rate", "dissociation_rate"], parameters=[association_rate, dissociation_rate], structure_signature="M + M <-> D", assumptions=[assumption], validity=validity, fit_error=candidate_error, validation_error=candidate_error, created_at=observed_at, activated_step=0) evidence = Evidence(id=evidence_id, source=profile_id, observed_at=observed_at, reliability=1.0, summary="Admitted Phase8 direct parity, mass conservation, interchange, ReaDDy, and PhysiCell validation", provenance=[evidence_id]) policy = SelectionPolicy(min_validation_improvement=0.1, max_validation_error=0.000001, max_invariant_violations=0, min_dwell_steps=1, hysteresis_margin=0.000001, required_horizon_steps=1) validation = validate_candidate(active, candidate, candidate_error, candidate_error, 0, [evidence], observed_at, policy) decision = activate_validated(active, validation.model, 1, 1, [evidence], policy) match decision: case ActivationDecision.activated(previous, current, transition): return AdaptationSummary(active_model_id=previous.id, candidate_model_id=candidate.id, selected_model_id=current.id, activated=true, admission_status="admitted", admitted=true, exploratory=false, evidence_reliability=1.0, parameter_apply_authorized=true, reason=transition.reason, evidence_ids=[evidence_id]) case ActivationDecision.blocked(reason, transition): return AdaptationSummary(active_model_id=active.id, candidate_model_id=candidate.id, selected_model_id=active.id, activated=false, admission_status="exploratory_unadmitted", admitted=false, exploratory=true, evidence_reliability=0.0, parameter_apply_authorized=false, reason=reason, evidence_ids=[evidence_id])
def run_multiscale_dynamics(profile_id: str, monomer_micromolar: f64, dimer_micromolar: f64, association_rate: f64, dissociation_rate: f64, intent: ControlIntent, adaptation: AdaptationSummary) !{}: sem "Compile a typed natural-language control intent into a globally solved gain, then integrate the admitted cross-scale equations" require len(profile_id) > 0 and monomer_micromolar > 0.0 and dimer_micromolar > 0.0 require association_rate > 0.0 and dissociation_rate > 0.0 require adaptation.activated and adaptation.selected_model_id == profile_id initial_mass = monomer_micromolar + 2.0 * dimer_micromolar dimer_fraction = dimer_micromolar / initial_mass cellular_decay = 1.0 tissue_gain = 0.2 tissue_decay = 0.5 optimized = optimize_cellular_gain(dimer_fraction, intent.target_tissue_response, intent.maximum_cellular_gain, intent.effort_penalty, cellular_decay, tissue_gain, tissue_decay) ensure optimized.status == "Optimal" and optimized.scope == "global-convex" cellular_gain = optimized.solution[0] solved = integrate_insulin_signal(monomer_micromolar, dimer_micromolar, intent.horizon_s, association_rate, dissociation_rate, cellular_gain, cellular_decay, tissue_gain, tissue_decay) approximation = solved[0] final_state = [approximation.value[0], approximation.value[1], approximation.value[2], approximation.value[3]] final_mass = final_state[0] + 2.0 * final_state[1] mass_residual = abs(final_mass - initial_mass) / initial_mass target_error = abs(final_state[3] - intent.target_tissue_response) technical_pass = approximation.converged and optimized.status == "Optimal" and optimized.scope == "global-convex" and mass_residual <= 0.00000001 and approximation.residual <= 1.0 and target_error <= 0.005 and final_state[0] > 0.0 and final_state[1] > 0.0 and final_state[2] >= 0.0 and final_state[2] <= 1.0 and final_state[3] >= 0.0 and final_state[3] <= 1.0 return DynamicsResult(schema="sema.multiscale-dynamics-result/v1", contract_id="insulin-association-cell-tissue-control-v1", semantics=intent.natural_language, formal_equations=["d[M]/dt = -2 k_on [M]^2 + 2 k_off [D]", "d[D]/dt = k_on [M]^2 - k_off [D]", "d[C]/dt = u [D]/([M]+2[D]) - k_C C", "d[T]/dt = g_T C - k_T T"], state_names=["insulin_monomer", "insulin_dimer", "cellular_signal", "tissue_response"], state_units=["micromolar", "micromolar", "fraction", "fraction"], final_state=final_state, cellular_gain=cellular_gain, target_tissue_response=intent.target_tissue_response, tissue_target_error=target_error, initial_molecular_mass_micromolar=initial_mass, final_molecular_mass_micromolar=final_mass, molecular_mass_relative_residual=mass_residual, integration_error_bound=approximation.residual, integration_steps_accepted=solved[1], integration_steps_rejected=solved[2], integration_method=approximation.method, optimizer_status=optimized.status, optimizer_scope=optimized.scope, optimizer_objective=optimized.objective, optimizer_iterations=optimized.iterations, adaptation=adaptation, evidence_ids=intent.evidence_ids, admission_status=adaptation.admission_status, admitted=adaptation.admitted, exploratory=adaptation.exploratory, parameter_apply_authorized=adaptation.parameter_apply_authorized, technical_pass=technical_pass, scientific_validated=false)
pub def preview_unadmitted_multiscale_dynamics(profile_id: str, monomer_micromolar: f64, dimer_micromolar: f64, association_rate: f64, dissociation_rate: f64, intent: ControlIntent, adaptation: AdaptationSummary) -> DynamicsResult !{}: sem "Compute an explicitly unadmitted, non-authoritative exploratory preview without applying candidate parameters to an active model" require len(profile_id) > 0 and monomer_micromolar > 0.0 and dimer_micromolar > 0.0 require association_rate > 0.0 and dissociation_rate > 0.0 require adaptation.candidate_model_id == profile_id and adaptation.exploratory and not adaptation.admitted and not adaptation.activated and not adaptation.parameter_apply_authorized initial_mass = monomer_micromolar + 2.0 * dimer_micromolar dimer_fraction = dimer_micromolar / initial_mass cellular_decay = 1.0 tissue_gain = 0.2 tissue_decay = 0.5 optimized = optimize_cellular_gain(dimer_fraction, intent.target_tissue_response, intent.maximum_cellular_gain, intent.effort_penalty, cellular_decay, tissue_gain, tissue_decay) ensure optimized.status == "Optimal" and optimized.scope == "global-convex" cellular_gain = optimized.solution[0] solved = integrate_insulin_signal(monomer_micromolar, dimer_micromolar, intent.horizon_s, association_rate, dissociation_rate, cellular_gain, cellular_decay, tissue_gain, tissue_decay) approximation = solved[0] final_state = [approximation.value[0], approximation.value[1], approximation.value[2], approximation.value[3]] final_mass = final_state[0] + 2.0 * final_state[1] mass_residual = abs(final_mass - initial_mass) / initial_mass target_error = abs(final_state[3] - intent.target_tissue_response) return DynamicsResult(schema="sema.multiscale-dynamics-result/v1", contract_id="insulin-association-cell-tissue-control-v1", semantics="exploratory_unadmitted preview: " + intent.natural_language, formal_equations=["d[M]/dt = -2 k_on [M]^2 + 2 k_off [D]", "d[D]/dt = k_on [M]^2 - k_off [D]", "d[C]/dt = u [D]/([M]+2[D]) - k_C C", "d[T]/dt = g_T C - k_T T"], state_names=["insulin_monomer", "insulin_dimer", "cellular_signal", "tissue_response"], state_units=["micromolar", "micromolar", "fraction", "fraction"], final_state=final_state, cellular_gain=cellular_gain, target_tissue_response=intent.target_tissue_response, tissue_target_error=target_error, initial_molecular_mass_micromolar=initial_mass, final_molecular_mass_micromolar=final_mass, molecular_mass_relative_residual=mass_residual, integration_error_bound=approximation.residual, integration_steps_accepted=solved[1], integration_steps_rejected=solved[2], integration_method=approximation.method, optimizer_status=optimized.status, optimizer_scope=optimized.scope, optimizer_objective=optimized.objective, optimizer_iterations=optimized.iterations, adaptation=adaptation, evidence_ids=intent.evidence_ids, admission_status="exploratory_unadmitted", admitted=false, exploratory=true, parameter_apply_authorized=false, technical_pass=false, scientific_validated=false)
def compute_multiscale_dynamics_step(sequence: int, state_version: int, model_id: str, adaptation: AdaptationSummary, state: list[f64], population: PopulationState, physiology: dict[str, any], dt_s: f64, target_tissue_response: f64, maximum_cellular_gain: f64, effort_penalty: f64, molecular_integrity: f64, association_rate: f64, dissociation_rate: f64, evidence_ids: list[str], admitted_execution: bool) !{}: require sequence >= 0 and state_version >= 0 require len(model_id) > 0 and len(state) == 4 require state[0] > 0.0 and state[1] > 0.0 and state[2] >= 0.0 and state[2] <= 1.0 and state[3] >= 0.0 and state[3] <= 1.0 require physiology["schema"] == "sema.metabolic-immune-observation/v1" and physiology["technical_pass"] require dt_s >= 0.01 and dt_s <= 0.25 require target_tissue_response >= 0.0 and target_tissue_response <= 1.0 require maximum_cellular_gain > 0.0 and maximum_cellular_gain <= 1.0 and effort_penalty > 0.0 require molecular_integrity >= 0.0 and molecular_integrity <= 1.0 require association_rate > 0.0 and dissociation_rate > 0.0 require len(evidence_ids) > 0 and len(evidence_ids) <= 128 if admitted_execution: ensure adaptation.admitted and adaptation.activated and adaptation.parameter_apply_authorized and adaptation.selected_model_id == model_id else: ensure adaptation.exploratory and not adaptation.admitted and not adaptation.activated and not adaptation.parameter_apply_authorized and adaptation.candidate_model_id == model_id population_next = advance_population_dynamics(population, dt_s, state[2], state[3], physiology["beta_function_fraction"], physiology["immune_effector_fraction"]) effective_integrity = max(0.0, molecular_integrity - population_next.stress_fraction * 0.08) effective_target = target_tissue_response initial_mass = state[0] + 2.0 * state[1] dimer_fraction = state[1] / initial_mass cellular_decay = 1.0 tissue_gain = 0.2 tissue_decay = 0.5 optimized = optimize_cellular_gain(dimer_fraction * effective_integrity, effective_target, maximum_cellular_gain, effort_penalty, cellular_decay, tissue_gain, tissue_decay) ensure optimized.status == "Optimal" and optimized.scope == "global-convex" cellular_gain = optimized.solution[0] solved = integrate_insulin_live_state(state, dt_s, association_rate, dissociation_rate, cellular_gain, effective_integrity, cellular_decay, tissue_gain, tissue_decay) approximation = solved[0] next_state = [approximation.value[0], approximation.value[1], approximation.value[2], approximation.value[3]] final_mass = next_state[0] + 2.0 * next_state[1] mass_residual = abs(final_mass - initial_mass) / initial_mass numerical_pass = approximation.converged and mass_residual <= 0.00000001 and approximation.residual <= 1.0 and next_state[0] > 0.0 and next_state[1] > 0.0 and next_state[2] >= 0.0 and next_state[2] <= 1.0 and next_state[3] >= 0.0 and next_state[3] <= 1.0 admission_status = "admitted" if admitted_execution else "exploratory_unadmitted" semantics = "Sema RK45 molecular signaling coupled to glucose-insulin-beta and immune-graft physiology" if admitted_execution else "exploratory_unadmitted Sema RK45 preview without parameter-apply or decision authority" return DynamicsStep( schema="sema.multiscale-dynamics-step/v1", sequence=sequence, state_version=state_version + 1, equation_id="insulin-association-cell-tissue-control", equation_version=1, model_id=model_id, semantics=semantics, state=next_state, target_tissue_response=effective_target, cellular_gain=cellular_gain, molecular_integrity=effective_integrity, dt_s=dt_s, molecular_mass_relative_residual=mass_residual, integration_error_bound=max(approximation.residual, physiology["integration_error_bound"]), integration_steps_accepted=solved[1] + physiology["integration_steps_accepted"], integration_steps_rejected=solved[2] + physiology["integration_steps_rejected"], optimizer_status=optimized.status, optimizer_scope=optimized.scope, evidence_ids=evidence_ids, physiology=physiology, population=population_next, admission_status=admission_status, admitted=admitted_execution, exploratory=not admitted_execution, parameter_apply_authorized=admitted_execution, technical_pass=admitted_execution and numerical_pass, scientific_validated=false, )
pub def step_multiscale_dynamics(sequence: int, state_version: int, model_id: str, adaptation: AdaptationSummary, state: list[f64], population: PopulationState, physiology: dict[str, any], dt_s: f64, target_tissue_response: f64, maximum_cellular_gain: f64, effort_penalty: f64, molecular_integrity: f64, association_rate: f64, dissociation_rate: f64, evidence_ids: list[str]) -> DynamicsStep !{}: sem "Advance one viewer frame only through an explicitly admitted Phase8 association model" require adaptation.admitted and adaptation.activated and adaptation.parameter_apply_authorized return compute_multiscale_dynamics_step(sequence, state_version, model_id, adaptation, state, population, physiology, dt_s, target_tissue_response, maximum_cellular_gain, effort_penalty, molecular_integrity, association_rate, dissociation_rate, evidence_ids, true)
pub def preview_unadmitted_multiscale_dynamics_step(sequence: int, state_version: int, model_id: str, adaptation: AdaptationSummary, state: list[f64], population: PopulationState, physiology: dict[str, any], dt_s: f64, target_tissue_response: f64, maximum_cellular_gain: f64, effort_penalty: f64, molecular_integrity: f64, association_rate: f64, dissociation_rate: f64, evidence_ids: list[str]) -> DynamicsStep !{}: sem "Advance an isolated exploratory preview without applying candidate parameters to admitted state" require adaptation.exploratory and not adaptation.admitted and not adaptation.activated and not adaptation.parameter_apply_authorized return compute_multiscale_dynamics_step(sequence, state_version, model_id, adaptation, state, population, physiology, dt_s, target_tissue_response, maximum_cellular_gain, effort_penalty, molecular_integrity, association_rate, dissociation_rate, evidence_ids, false)src/ensemble.sema
Section titled “src/ensemble.sema”"""Independent stochastic replica evidence with explicit uncertainty and replay class."""
assure silver
pub struct EnsembleResult: schema: str ensemble_id: str config_sha256: str coarse_config_sha256: str benchmark_config_sha256: str source_model_sha256: str result_sha256: str result_path: str platform: str replay_class: str evidence_class: str replicas: int samples_per_replica: int seeds: list[int] initial_state_sha256: list[str] distinct_initial_states: int basin_ids: list[str] occupancy_mean: list[f64] occupancy_sem: list[f64] transition_counts: list[int] transitions: int observed_basins: int free_energy_mean_kj_mol: list[f64] free_energy_sem_kj_mol: list[f64] effective_samples: f64 rhat_defined: bool rhat_max: f64 converged: bool invariant schema == "sema.ensemble-result/v1" invariant len(ensemble_id) > 0 invariant len(config_sha256) == 64 invariant len(coarse_config_sha256) == 64 invariant len(benchmark_config_sha256) == 64 invariant len(source_model_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant platform == "CPU" invariant replay_class == "statistical" invariant evidence_class == "independently_simulated" invariant replicas >= 2 and replicas <= 8 invariant samples_per_replica > 1 and samples_per_replica <= 1000 invariant len(seeds) == replicas invariant len(initial_state_sha256) == replicas invariant distinct_initial_states >= 2 and distinct_initial_states <= replicas invariant len(basin_ids) >= 2 and len(basin_ids) <= 16 invariant len(occupancy_mean) == len(basin_ids) invariant len(occupancy_sem) == len(basin_ids) invariant len(transition_counts) == len(basin_ids) * len(basin_ids) invariant transitions >= 0 and transitions < replicas * samples_per_replica invariant observed_basins > 0 and observed_basins <= len(basin_ids) invariant len(free_energy_mean_kj_mol) == len(basin_ids) invariant len(free_energy_sem_kj_mol) == len(basin_ids) invariant effective_samples >= 0.0 and effective_samples <= f64(replicas * samples_per_replica) invariant rhat_max >= 0.0
pub bridge python.inline ensemble_backend from "foreign/python/ensemble_backend.py": deps "python>=3.12,<3.13" # The pinned four-replica workload measured 153.98 s standalone on the # qualified CPU profile; 300 s is a finite ~1.95x wall-time ceiling. timeout_ms "300000" expose: def run_ensemble( config_path: str, coarse_config_path: str, output_path: str, ) -> EnsembleResult !{ffi.call}: sem "Run seeded independent Langevin replicas and report PMF uncertainty and convergence"src/insulin_pmf.sema
Section titled “src/insulin_pmf.sema”"""Bounded explicit-solvent insulin-dimer association PMF evidence with strict validation gates."""
assure silver
pub struct InsulinPmfResult: schema: str profile_id: str config_sha256: str source_sha256: str system_sha256: str sample_sha256: list[str] evidence_sha256: str result_sha256: str result_path: str pdb_id: str backend: str backend_version: str platform: str force_field: str water_model: str temperature_k: f64 atoms: int protein_atoms: int windows: int replicas_per_window: int samples_per_replica: int total_dynamics_steps: int window_centers_nm: list[f64] force_constants_kj_mol_nm2: list[f64] initial_centroid_distance_nm: f64 minimized_energy_kj_mol: f64 minimum_adjacent_overlap: f64 adjacent_overlap: list[f64] overlap_matrix: list[f64] rhat_by_window: list[f64] rhat_max: f64 integrated_autocorrelation_by_replica: list[f64] maximum_integrated_autocorrelation: f64 ess_by_replica: list[f64] total_ess: f64 mbar_free_energies_reduced: list[f64] mbar_iterations: int mbar_residual: f64 estimator_converged: bool overlap_pass: bool rhat_pass: bool autocorrelation_pass: bool ess_pass: bool sampling_converged: bool sampling_uncertainty_available: bool parameter_uncertainty_available: bool model_form_uncertainty_available: bool restraint_correction_available: bool finite_size_correction_available: bool standard_state_correction_available: bool experimental_uncertainty_available: bool sampling_uncertainty_kj_mol: list[f64] parameter_uncertainty_kj_mol: list[f64] model_form_uncertainty_kj_mol: list[f64] restraint_correction_kj_mol: list[f64] finite_size_correction_kj_mol: list[f64] standard_state_correction_kj_mol: list[f64] experimental_uncertainty_kj_mol: list[f64] standard_state_delta_g_available: bool standard_state_delta_g_kj_mol: list[f64] independent_reference_pass: bool scientific_validated: bool technical_pass: bool failure_type: str blockers: list[str] resumed_replicas: int runtime_seconds: f64 direct_oracle_result_sha256: str direct_oracle_path: str direct_parity_pass: bool invariant schema == "sema.insulin-association-pmf-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(source_sha256) == 64 invariant len(system_sha256) == 64 invariant len(evidence_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant pdb_id == "6S34" invariant backend == "OpenMM" invariant backend_version == "8.5" invariant platform == "CPU" invariant force_field == "amber19-all.xml" invariant water_model == "amber19/tip3pfb.xml" invariant temperature_k == 298.15 invariant atoms > protein_atoms and protein_atoms > 0 invariant windows == len(window_centers_nm) invariant windows == len(force_constants_kj_mol_nm2) invariant len(sample_sha256) == windows * replicas_per_window invariant len(adjacent_overlap) == windows - 1 invariant len(overlap_matrix) == windows * windows invariant len(rhat_by_window) == windows invariant len(integrated_autocorrelation_by_replica) == windows * replicas_per_window invariant len(ess_by_replica) == windows * replicas_per_window invariant len(mbar_free_energies_reduced) == windows invariant replicas_per_window >= 2 invariant samples_per_replica > 0 invariant total_dynamics_steps > 0 invariant minimum_adjacent_overlap >= 0.0 invariant total_ess >= 0.0 invariant mbar_iterations > 0 invariant mbar_residual >= 0.0 invariant runtime_seconds >= 0.0 invariant not scientific_validated or independent_reference_pass invariant not standard_state_delta_g_available or scientific_validated invariant standard_state_delta_g_available or len(standard_state_delta_g_kj_mol) == 0 invariant scientific_validated or len(failure_type) > 0 invariant len(direct_oracle_result_sha256) == 64 invariant len(direct_oracle_path) > 0
pub bridge python.inline insulin_pmf_backend from "foreign/python/insulin_pmf_backend.py": deps "python>=3.12,<3.13", "numpy==2.4.1", "openmm==8.5.0" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> InsulinPmfResult !{ffi.call}: sem "Run or resume pinned explicit-solvent insulin umbrella windows and admit no association free energy unless every gate passes"src/insulin_structure.sema
Section titled “src/insulin_structure.sema”"""Pinned zinc-free human-insulin dimer construction and explicit-solvent technical evidence."""
assure silver
pub struct InsulinAtomisticResult: schema: str profile_id: str config_sha256: str source_sha256: str result_sha256: str result_path: str pdb_id: str assembly: int license: str doi: str backend: str backend_version: str platform: str force_field: str water_model: str temperature_k: f64 ph: f64 ionic_strength_molar: f64 monomers: int protein_residues: int protein_atoms: int atoms: int solvent_atoms: int disulfide_bonds: int interface_contact_angstrom: f64 initial_energy_kj_mol: f64 final_energy_kj_mol: f64 max_force_kj_mol_nm: f64 steps: int system_sha256: str final_positions_sha256: str structural_pass: bool technical_pass: bool association_validated: bool evidence_class: str direct_oracle_result_sha256: str direct_oracle_path: str direct_parity_pass: bool invariant schema == "sema.insulin-atomistic-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(source_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant pdb_id == "6S34" invariant assembly == 1 invariant license == "CC0-1.0" invariant backend == "OpenMM" invariant platform == "CPU" invariant temperature_k == 298.15 invariant ph == 2.5 invariant ionic_strength_molar == 0.1 invariant monomers == 2 invariant protein_residues == 102 invariant protein_atoms > 0 invariant atoms > protein_atoms invariant solvent_atoms == atoms - protein_atoms invariant disulfide_bonds >= 6 invariant interface_contact_angstrom >= 0.0 invariant max_force_kj_mol_nm >= 0.0 invariant steps > 0 and steps <= 1000 invariant len(system_sha256) == 64 invariant len(final_positions_sha256) == 64 invariant evidence_class == "validated_atomistic_technical" or evidence_class == "failed_atomistic_technical" invariant len(direct_oracle_result_sha256) == 64 invariant len(direct_oracle_path) > 0
pub bridge python.inline insulin_structure_backend from "foreign/python/insulin_structure_backend.py": deps "python>=3.12,<3.13", "numpy==2.4.1", "openmm==8.5.0" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> InsulinAtomisticResult !{ffi.call}: sem "Construct a pinned zinc-free human-insulin dimer in explicit solvent and verify direct OpenMM parity"src/insulin.sema
Section titled “src/insulin.sema”"""Human insulin solution-thermodynamics model with pinned experimental evidence."""
assure silver
pub struct InsulinThermodynamicsResult: schema: str profile_id: str config_sha256: str artifact_sha256: str pmid: str doi: str subject: str assay: str temperature_k: f64 buffer: str ph: f64 zinc_added: bool ligand_added: bool independent_experiments: int kd_micromolar: f64 kd_sem_micromolar: f64 reported_dissociation_free_energy_kj_mol: f64 reported_dissociation_free_energy_sem_kj_mol: f64 modeled_dissociation_free_energy_kj_mol: f64 modeled_dissociation_free_energy_sem_kj_mol: f64 modeled_binding_free_energy_kj_mol: f64 free_energy_residual_kj_mol: f64 uncertainty_residual_kj_mol: f64 combined_z_score: f64 condition_pass: bool thermodynamic_pass: bool validated: bool evidence_class: str new_atomistic_simulation: bool result_sha256: str direct_oracle_result_sha256: str direct_oracle_path: str direct_parity_pass: bool result_path: str invariant schema == "sema.insulin-thermodynamics-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(artifact_sha256) == 64 invariant len(pmid) > 0 invariant len(doi) > 0 invariant len(subject) > 0 invariant len(assay) > 0 invariant temperature_k > 0.0 invariant len(buffer) > 0 invariant ph > 0.0 and ph <= 14.0 invariant independent_experiments > 1 invariant kd_micromolar > 0.0 invariant kd_sem_micromolar >= 0.0 invariant reported_dissociation_free_energy_kj_mol > 0.0 invariant reported_dissociation_free_energy_sem_kj_mol >= 0.0 invariant modeled_dissociation_free_energy_kj_mol > 0.0 invariant modeled_dissociation_free_energy_sem_kj_mol >= 0.0 invariant modeled_binding_free_energy_kj_mol < 0.0 invariant free_energy_residual_kj_mol >= 0.0 invariant uncertainty_residual_kj_mol >= 0.0 invariant combined_z_score >= 0.0 invariant len(result_sha256) == 64 invariant len(direct_oracle_result_sha256) == 64 invariant len(direct_oracle_path) > 0 invariant len(result_path) > 0 invariant evidence_class == "validated_human_solution_thermodynamics" or evidence_class == "failed_human_solution_thermodynamics"
pub bridge python.inline insulin_backend from "foreign/python/insulin_backend.py": deps "python>=3.12,<3.13" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> InsulinThermodynamicsResult !{ffi.call}: sem "Validate human insulin monomer-dimer thermodynamics against a pinned eight-experiment ITC reference"src/live.sema
Section titled “src/live.sema”"""Persistent Sema HTTP service for evidence-bound live viewer dynamics."""
import httpfrom std.crypto import file_sha256from std.json import decode as decode_json, encode as encode_json, read as read_jsonfrom biological_computer.agent import agent_capabilities, propose_agent_programfrom biological_computer.binding import binding_capabilities, dock_ligand, docking_rejection, initial_species_registry, occupancy_fraction, register_species, species_effect, species_public_state, species_registration_errorfrom biological_computer.cortex import cortex_capabilities, propose_cortexfrom biological_computer.design import build_designed_structure, compile_design_command, design_capabilities, design_spec_validfrom biological_computer.dynamics import AdaptationSummary, Phase8AdmissionEvidence, admit_association_model, apply_biological_intervention, dynamics_equations, initial_population_state, phase8_admission_evidence_complete, preview_unadmitted_multiscale_dynamics_step, step_multiscale_dynamicsfrom biological_computer.molecular import apply_molecular_program, load_molecular_session, molecular_public_state, molecular_session_integrity, step_molecular_session, structure_key_supportedfrom biological_computer.physiology import initial_physiology_state, physiology_parameter_bounds, physiology_public_state, step_physiology_statefrom biological_computer.programming import apply_biological_program, compile_biological_command, initial_program_state, programming_capabilities, signal_bounds
assure silver
struct LiveProfile: model_id: str association_rate: f64 dissociation_rate: f64 initial_state: list[f64] evidence_ids: list[str] scene_sha256: str population_cells: int admission_evidence: Phase8AdmissionEvidence adaptation: AdaptationSummary invariant len(model_id) > 0 invariant association_rate > 0.0 and dissociation_rate > 0.0 invariant len(initial_state) == 4 invariant initial_state[0] > 0.0 and initial_state[1] > 0.0 invariant len(evidence_ids) == 2 invariant all(len(evidence_id) == 64 for evidence_id in evidence_ids) invariant len(scene_sha256) == 64 invariant population_cells > 0 and population_cells <= 16384 invariant adaptation.candidate_model_id == model_id invariant adaptation.admitted == false or phase8_admission_evidence_complete(admission_evidence)
def load_live_profile() !{fs.read}: ensure file_sha256("runs/mesoscopic/phase8-sema.json") == "9a38dc0a0057fcd667fa88e85d88d99a2d65755eefdf0813aa1337933ec419cc" source = read_json("runs/mesoscopic/phase8-sema.json") ensure source["result_sha256"] == "3164645981cd04fae5811856b166156769b39b35a85bf441748a468a24fa19f7" ensure source["schema"] == "sema.mesoscopic-result/v1" ensure source["direct_parity_pass"] and source["transfer_pass"] ensure file_sha256("runs/readdy-calibration/sema.json") == "9000bb00e06c6b00daf03b075f834a46b7cfcaff7be4b61d4e393f3258758679" readdy = read_json("runs/readdy-calibration/sema.json") ensure readdy["schema"] == "sema.readdy-calibration-result/v1" ensure readdy["result_sha256"] == "70ab940f6eecb9aaeb309a068ab20055a58e7df85f686be6fb7669c15cd4995a" ensure file_sha256("runs/physicell/sema.json") == "27a819ceca949921ce75afe89632255a88c107b207ab224e28ea0498aa5b2c82" physicell = read_json("runs/physicell/sema.json") ensure physicell["schema"] == "sema.physicell-result/v1" ensure physicell["result_sha256"] == "04c0f4cd8885e0dd88535a2e01e5b06d7609bd4cfdfa58f36ff28407fe463b97" ensure physicell["phase8_result_sha256"] == source["result_sha256"] ensure physicell["phase8_artifact_sha256"] == file_sha256("runs/mesoscopic/phase8-sema.json") admission_evidence = Phase8AdmissionEvidence( phase8_technical_pass=source["phase8_technical_pass"], readdy_chronology_proven=readdy["heldout_evidence_admission"]["chronology_proven"], readdy_qualification_pass=readdy["qualification_pass"], readdy_convergence_pass=readdy["gates"]["convergence_pass"], readdy_spatial_pass=readdy["gates"]["spatial_pass"], readdy_admission_pass=readdy["phase8_scientific_validation"], physicell_custom_insulin_pass=physicell["insulin_reaction_supported"], physicell_target_rate_pass=physicell["target_rate_evidence"], physicell_uncertainty_pass=physicell["scientific_uncertainty_evidence"], physicell_scientific_pass=physicell["scientific_validated"], ) adaptation = admit_association_model( source["profile_id"], source["association_rate_per_micromolar_s"], source["dissociation_rate_per_s"], source["source_kd_sem_micromolar"] / source["source_kd_micromolar"], source["kd_relative_residual"], source["result_sha256"], source["simulated_time_s"], admission_evidence, ) scene = read_json("viewer/public/data/scene.json") ensure scene["schema"] == "sema.multiscale-viewer/v4" return LiveProfile( model_id=source["profile_id"], association_rate=source["association_rate_per_micromolar_s"], dissociation_rate=source["dissociation_rate_per_s"], initial_state=[source["observed_monomer_micromolar"], source["observed_dimer_micromolar"], 0.0, 0.0], evidence_ids=[source["result_sha256"], source["direct_oracle_result_sha256"]], scene_sha256=file_sha256("viewer/public/data/scene.json"), population_cells=scene["scene_model"]["tissue"]["cell_count"], admission_evidence=admission_evidence, adaptation=adaptation, )
def response(status: int, body: any) !{}: return { "status": status, "content_type": "application/json", "headers": {"Cache-Control": "no-store"}, "body": encode_json(body), }
def error_response(status: int, code: str, detail: str) !{}: return response(status, {"schema": "sema.biological-live-error/v1", "error": code, "detail": detail})
def active_species_registry(profile: LiveProfile, session: dict[str, any]): return session["preview_species"] if profile.adaptation.exploratory else session["species"]
def species_adjusted_program(program: dict[str, any], registry: dict[str, any]) !{}: sem "Fold every introduced designed species into a bounded copy of the physiology parameters and signals" introduced = species_public_state(registry) if len(introduced) == 0: return {"parameters": program["parameters"], "signals": program["signals"]} parameter_bounds = physiology_parameter_bounds() bounds = signal_bounds() mut parameters = {name: value for name, value in program["parameters"].items()} mut signals = {name: value for name, value in program["signals"].items()} for species in introduced: effect = species_effect(species["mechanism"], occupancy_fraction(species["kd_micromolar"], species["concentration_micromolar"])) for key in effect.keys(): if key.startswith("parameter:"): name = key.slice(10, len(key)) limits = parameter_bounds[name] parameters[name] = max(limits[0], min(limits[1], parameters[name] * effect[key])) elif key.startswith("signal_max:"): name = key.slice(11, len(key)) limits = bounds[name] signals[name] = max(limits[0], min(limits[1], max(signals[name], effect[key]))) elif key.startswith("signal_add:"): name = key.slice(11, len(key)) limits = bounds[name] signals[name] = max(limits[0], min(limits[1], signals[name] + effect[key])) return {"parameters": parameters, "signals": signals}
def status_response(profile: LiveProfile, session: dict[str, any]) !{}: mut molecular: any = None if session["molecular"] != None: molecular = molecular_public_state(session["molecular"]) molecular["generation"] = session["molecular_generation"] mut visible_state = session["state"] mut visible_sequence = session["sequence"] mut visible_state_version = session["state_version"] mut visible_generation = session["active_generation"] mut visible_population = session["population"] mut visible_physiology = session["physiology"] mut visible_species = session["species"] if profile.adaptation.exploratory: visible_state = session["preview_state"] visible_sequence = session["preview_sequence"] visible_state_version = session["preview_state_version"] visible_generation = session["preview_generation"] visible_population = session["preview_population"] visible_physiology = session["preview_physiology"] visible_species = session["preview_species"] effective = species_adjusted_program(session["program"], visible_species) return response(200, { "schema": "sema.biological-live-status/v1", "backend": "Sema", "model_id": profile.model_id, "equation_id": "insulin-association-cell-tissue-control", "equation_version": 1, "equations": dynamics_equations(), "state_names": ["insulin_monomer", "insulin_dimer", "cellular_signal", "tissue_response"], "state_units": ["micromolar", "micromolar", "fraction", "fraction"], "initial_state": profile.initial_state, "state": visible_state, "sequence": visible_sequence, "state_version": visible_state_version, "generation": visible_generation, "state_admission_status": profile.adaptation.admission_status, "active_state": session["state"], "active_state_version": session["state_version"], "active_generation": session["active_generation"], "preview_generation": session["preview_generation"], "molecular_generation": session["molecular_generation"], "phase8_technical_pass": profile.admission_evidence.phase8_technical_pass, "readdy_validated": profile.admission_evidence.readdy_chronology_proven and profile.admission_evidence.readdy_qualification_pass and profile.admission_evidence.readdy_convergence_pass and profile.admission_evidence.readdy_spatial_pass and profile.admission_evidence.readdy_admission_pass, "physicell_validated": profile.admission_evidence.physicell_custom_insulin_pass and profile.admission_evidence.physicell_target_rate_pass and profile.admission_evidence.physicell_uncertainty_pass and profile.admission_evidence.physicell_scientific_pass, "phase8_admission_evidence_complete": phase8_admission_evidence_complete(profile.admission_evidence), "admitted": profile.adaptation.admitted, "activated": profile.adaptation.activated, "exploratory": profile.adaptation.exploratory, "evidence_reliability": profile.adaptation.evidence_reliability, "parameter_apply_authorized": profile.adaptation.parameter_apply_authorized, "decision_authority": false, "technical_pass": profile.adaptation.admitted, "update_hz": 10, "scene_sha256": profile.scene_sha256, "evidence_ids": profile.evidence_ids, "population": visible_population, "program": session["program"], "physiology": physiology_public_state(visible_physiology, effective["signals"], effective["parameters"]), "programming_capabilities": programming_capabilities(), "molecular": molecular, "species": species_public_state(visible_species), "design_generation": session["design_generation"], "scientific_validated": false, })
def step_input_error(payload: any) !{}: if not (payload is dict): return "step request must be an object" required = ["generation", "molecular_generation", "sequence", "state_version", "dt_s", "target_tissue_response"] if not all(payload.has(field) for field in required): return "step request is missing a required field" if not (payload["generation"] is int) or not (payload["molecular_generation"] is int) or not (payload["sequence"] is int) or not (payload["state_version"] is int): return "generation, molecular_generation, sequence, and state_version must be integers" if payload["generation"] < 0 or payload["molecular_generation"] < 0 or payload["sequence"] < 0 or payload["state_version"] < 0: return "generation, molecular_generation, sequence, and state_version must be nonnegative" if not (payload["dt_s"] is float) or payload["dt_s"] != payload["dt_s"] or payload["dt_s"] < 0.01 or payload["dt_s"] > 0.25: return "dt_s must be a finite number in [0.01, 0.25]" if not (payload["target_tissue_response"] is int or payload["target_tissue_response"] is float) or payload["target_tissue_response"] != payload["target_tissue_response"] or payload["target_tissue_response"] < 0.0 or payload["target_tissue_response"] > 1.0: return "target_tissue_response must be a finite number in [0, 1]" return ""
def canonical_step_request_identity(payload: dict[str, any], profile: LiveProfile, session: dict[str, any], admission_branch: str, step_state: any, step_population: any, step_physiology: any, step_species: any) !{}: molecular_integrity = 1.0 if session["molecular"] is None else molecular_session_integrity(session["molecular"]) return encode_json({ "schema": "sema.biological-live-step-request-identity/v1", "generation": payload["generation"], "molecular_generation": payload["molecular_generation"], "sequence": payload["sequence"], "state_version": payload["state_version"], "dt_s": payload["dt_s"], "target_tissue_response": payload["target_tissue_response"], "admission_branch": admission_branch, "admission_status": profile.adaptation.admission_status, "admitted": profile.adaptation.admitted, "activated": profile.adaptation.activated, "exploratory": profile.adaptation.exploratory, "parameter_apply_authorized": profile.adaptation.parameter_apply_authorized, "model_id": profile.model_id, "association_rate": profile.association_rate, "dissociation_rate": profile.dissociation_rate, "evidence_ids": profile.evidence_ids, "molecular_revision": session["molecular_revision"], "molecular_integrity": molecular_integrity, "program": session["program"], "step_state": step_state, "step_population": step_population, "step_physiology": step_physiology, "step_species": species_public_state(step_species), })
def live_step_response_body(step: any, generation: int, molecular_generation: int) !{}: body = decode_json(encode_json(step)) body["generation"] = generation body["molecular_generation"] = molecular_generation return body
def exploratory_step_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}: require profile.adaptation.exploratory and not profile.adaptation.admitted and not profile.adaptation.activated and not profile.adaptation.parameter_apply_authorized if payload["generation"] != session["preview_generation"]: return error_response(409, "LiveGenerationConflict", "generation does not match isolated exploratory_unadmitted preview state") if payload["molecular_generation"] != session["molecular_generation"]: return error_response(409, "MolecularGenerationConflict", "molecular generation does not match the state coupled to this live step") mut step_state = session["preview_state"] mut step_population = session["preview_population"] mut step_physiology = session["preview_physiology"] mut step_species = session["preview_species"] mut retrying_retained_request = false retry_context = session["preview_retry_context"] retry_identifiers_match = retry_context != None and payload["generation"] == retry_context["generation"] and payload["sequence"] == retry_context["sequence"] and payload["state_version"] == retry_context["state_version"] completed_identifiers_match = payload["generation"] == session["preview_generation"] and payload["sequence"] == session["preview_sequence"] and payload["state_version"] + 1 == session["preview_state_version"] if retry_identifiers_match: step_state = retry_context["state"] step_population = retry_context["population"] step_physiology = retry_context["physiology"] step_species = retry_context["species"] request_identity = canonical_step_request_identity(payload, profile, session, "exploratory_unadmitted", step_state, step_population, step_physiology, step_species) if request_identity != retry_context["request_identity"]: return error_response(409, "LiveRequestConflict", "step identifiers are already bound to a different exploratory request identity") if session["preview_last_step"] != None and completed_identifiers_match: return response(200, session["preview_last_step"]) retrying_retained_request = true elif completed_identifiers_match: return error_response(409, "LiveRequestConflict", "completed exploratory step identifiers have no matching retained request identity") if not retrying_retained_request and (payload["sequence"] != session["preview_sequence"] + 1 or payload["state_version"] != session["preview_state_version"]): return error_response(409, "LiveStateConflict", "sequence or state version does not match isolated exploratory_unadmitted preview state") request_identity = canonical_step_request_identity(payload, profile, session, "exploratory_unadmitted", step_state, step_population, step_physiology, step_species) effective = species_adjusted_program(session["program"], step_species) physiology_state = step_physiology_state(step_physiology, payload["dt_s"], effective["signals"], effective["parameters"]) if not physiology_state["technical_pass"]: return error_response(422, "PhysiologyPreviewRejected", "exploratory physiology preview solver evidence did not pass") physiology = physiology_public_state(physiology_state, effective["signals"], effective["parameters"]) physiology_target = min(1.0, payload["target_tissue_response"] * min(1.0, physiology["beta_function_fraction"]) * (1.0 - physiology["cytokine_fraction"] * 0.4)) integrity = 1.0 if session["molecular"] is None else molecular_session_integrity(session["molecular"]) step = preview_unadmitted_multiscale_dynamics_step( payload["sequence"], payload["state_version"], profile.model_id, profile.adaptation, step_state, step_population, physiology, payload["dt_s"], physiology_target, 1.0, 0.0001, integrity, profile.association_rate, profile.dissociation_rate, profile.evidence_ids, ) ensure step.admission_status == "exploratory_unadmitted" and step.exploratory ensure not step.admitted and not step.parameter_apply_authorized and not step.technical_pass and not step.scientific_validated session["preview_retry_context"] = { "generation": payload["generation"], "sequence": payload["sequence"], "state_version": payload["state_version"], "request_identity": request_identity, "state": step_state, "population": step_population, "physiology": step_physiology, "species": step_species, } session["preview_state"] = step.state session["preview_physiology"] = physiology_state session["preview_population"] = step.population session["preview_sequence"] = step.sequence session["preview_state_version"] = step.state_version step_body = live_step_response_body(step, session["preview_generation"], session["molecular_generation"]) session["preview_last_step"] = step_body return response(200, step_body)
def step_response(payload: any, profile: LiveProfile, session: dict[str, any]) !{}: input_error = step_input_error(payload) if len(input_error) > 0: return error_response(422, "LiveInputInvalid", input_error) if profile.adaptation.exploratory: return exploratory_step_response(payload, profile, session) if not phase8_admission_evidence_complete(profile.admission_evidence) or not profile.adaptation.admitted or not profile.adaptation.activated or not profile.adaptation.parameter_apply_authorized: return error_response(409, "Phase8ModelUnadmitted", "Phase8 association rates cannot advance admitted live state") if payload["generation"] != session["active_generation"]: return error_response(409, "LiveGenerationConflict", "generation does not match Sema-owned admitted state") if payload["molecular_generation"] != session["molecular_generation"]: return error_response(409, "MolecularGenerationConflict", "molecular generation does not match the state coupled to this live step") mut step_state = session["state"] mut step_population = session["population"] mut step_physiology = session["physiology"] mut step_species = session["species"] mut retrying_retained_request = false retry_context = session["retry_context"] retry_identifiers_match = retry_context != None and payload["generation"] == retry_context["generation"] and payload["sequence"] == retry_context["sequence"] and payload["state_version"] == retry_context["state_version"] completed_identifiers_match = payload["generation"] == session["active_generation"] and payload["sequence"] == session["sequence"] and payload["state_version"] + 1 == session["state_version"] if retry_identifiers_match: step_state = retry_context["state"] step_population = retry_context["population"] step_physiology = retry_context["physiology"] step_species = retry_context["species"] request_identity = canonical_step_request_identity(payload, profile, session, "admitted_active", step_state, step_population, step_physiology, step_species) if request_identity != retry_context["request_identity"]: return error_response(409, "LiveRequestConflict", "step identifiers are already bound to a different admitted request identity") if session["last_step"] != None and completed_identifiers_match: return response(200, session["last_step"]) retrying_retained_request = true elif completed_identifiers_match: return error_response(409, "LiveRequestConflict", "completed admitted step identifiers have no matching retained request identity") if not retrying_retained_request and (payload["sequence"] != session["sequence"] + 1 or payload["state_version"] != session["state_version"]): return error_response(409, "LiveStateConflict", "sequence or state version does not match Sema-owned state") request_identity = canonical_step_request_identity(payload, profile, session, "admitted_active", step_state, step_population, step_physiology, step_species) effective = species_adjusted_program(session["program"], step_species) physiology_state = step_physiology_state(step_physiology, payload["dt_s"], effective["signals"], effective["parameters"]) if not physiology_state["technical_pass"]: return error_response(422, "PhysiologyStepRejected", "Sema metabolic-immune solver evidence did not pass") physiology = physiology_public_state(physiology_state, effective["signals"], effective["parameters"]) physiology_target = min(1.0, payload["target_tissue_response"] * min(1.0, physiology["beta_function_fraction"]) * (1.0 - physiology["cytokine_fraction"] * 0.4)) integrity = 1.0 if session["molecular"] is None else molecular_session_integrity(session["molecular"]) step = step_multiscale_dynamics( payload["sequence"], payload["state_version"], profile.model_id, profile.adaptation, step_state, step_population, physiology, payload["dt_s"], physiology_target, 1.0, 0.0001, integrity, profile.association_rate, profile.dissociation_rate, profile.evidence_ids, ) if not step.technical_pass: return error_response(422, "LiveStepRejected", "Sema numerical or invariant evidence did not pass") session["retry_context"] = { "generation": payload["generation"], "sequence": payload["sequence"], "state_version": payload["state_version"], "request_identity": request_identity, "state": step_state, "population": step_population, "physiology": step_physiology, "species": step_species, } session["state"] = step.state session["physiology"] = physiology_state session["population"] = step.population session["sequence"] = step.sequence session["state_version"] = step.state_version step_body = live_step_response_body(step, session["active_generation"], session["molecular_generation"]) session["last_step"] = step_body return response(200, step_body)
def has_intervention_fields(payload: dict[str, any]): return all(payload.has(field) for field in ["generation", "state_version", "kind", "target_index", "target_kind", "magnitude", "amount", "molecule", "mutation", "seed_cells"])
def intervention_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}: if not has_intervention_fields(payload): return error_response(422, "LiveInterventionInvalid", "intervention request is missing a required field") if profile.adaptation.exploratory and payload["generation"] != session["preview_generation"]: return error_response(409, "LiveGenerationConflict", "generation does not match isolated exploratory_unadmitted preview state") if not profile.adaptation.exploratory and payload["generation"] != session["active_generation"]: return error_response(409, "LiveGenerationConflict", "generation does not match Sema-owned admitted state") if profile.adaptation.exploratory and payload["state_version"] != session["preview_state_version"]: return error_response(409, "LiveStateConflict", "state version does not match isolated exploratory_unadmitted preview state") if not profile.adaptation.exploratory and payload["state_version"] != session["state_version"]: return error_response(409, "LiveStateConflict", "state version does not match Sema-owned admitted state") if not (payload["kind"] == "force" or payload["kind"] == "inject" or payload["kind"] == "mutate" or payload["kind"] == "ablate"): return error_response(422, "LiveInterventionInvalid", "unsupported intervention kind") if payload["target_index"] < -1 or payload["target_index"] >= 16384: return error_response(422, "LiveInterventionInvalid", "target index is outside the bounded biological scene") if not (payload["target_kind"] == "population" or payload["target_kind"] == "tissue-cell" or payload["target_kind"] == "vessel" or payload["target_kind"] == "granule" or payload["target_kind"] == "mitochondrion" or payload["target_kind"] == "receptor" or payload["target_kind"] == "protein" or payload["target_kind"] == "protein-atom" or payload["target_kind"] == "source-atom" or payload["target_kind"] == "membrane" or payload["target_kind"] == "nucleus" or payload["target_kind"] == "cytoskeleton" or payload["target_kind"] == "endoplasmic-reticulum" or payload["target_kind"] == "lipid-droplet" or payload["target_kind"] == "vessel-wall" or payload["target_kind"] == "vessel-lumen" or payload["target_kind"] == "erythrocyte"): return error_response(422, "LiveInterventionInvalid", "unsupported intervention target kind") if payload["magnitude"] < -80.0 or payload["magnitude"] > 80.0 or payload["amount"] < 0.0 or payload["amount"] > 100.0: return error_response(422, "LiveInterventionInvalid", "force or amount is outside its declared bounds") if payload["kind"] == "force" and (payload["target_index"] < 0 or payload["magnitude"] == 0.0): return error_response(422, "LiveInterventionInvalid", "force requires a selected target and nonzero signed magnitude") if payload["kind"] == "ablate" and payload["target_index"] < 0: return error_response(422, "LiveInterventionInvalid", "ablation requires a selected target") if payload["kind"] == "ablate" and payload["target_kind"] != "tissue-cell": return error_response(422, "LiveInterventionInvalid", "ablation requires a tissue-cell target") if payload["kind"] == "mutate" and not (payload["target_kind"] == "population" or payload["target_kind"] == "tissue-cell"): return error_response(422, "LiveInterventionInvalid", "mutation requires a population or tissue-cell target") if payload["seed_cells"] < 0 or payload["seed_cells"] > 32: return error_response(422, "LiveInterventionInvalid", "mutation seed count is outside its declared bound") if profile.adaptation.exploratory: preview_population = apply_biological_intervention(session["preview_population"], payload["kind"], payload["target_index"], payload["target_kind"], payload["magnitude"], payload["amount"], payload["molecule"], payload["mutation"], payload["seed_cells"]) session["preview_population"] = preview_population session["preview_state_version"] = session["preview_state_version"] + 1 session["preview_last_step"] = None session["preview_retry_context"] = None return status_response(profile, session) population = apply_biological_intervention(session["population"], payload["kind"], payload["target_index"], payload["target_kind"], payload["magnitude"], payload["amount"], payload["molecule"], payload["mutation"], payload["seed_cells"]) session["population"] = population session["state_version"] = session["state_version"] + 1 session["last_step"] = None session["retry_context"] = None return status_response(profile, session)
def store_species(profile: LiveProfile, session: dict[str, any], registry: dict[str, any]): if profile.adaptation.exploratory: session["preview_species"] = registry session["preview_state_version"] = session["preview_state_version"] + 1 session["preview_last_step"] = None session["preview_retry_context"] = None else: session["species"] = registry session["state_version"] = session["state_version"] + 1 session["last_step"] = None session["retry_context"] = None
def docking_identity(target: dict[str, any], ligand: dict[str, any], budget: int) !{}: return encode_json({ "schema": "sema.molecular-binding-request-identity/v1", "ligand_source_sha256": ligand["source_sha256"], "target_source_sha256": target["source_sha256"], "budget": budget, })
def dock_design(session: dict[str, any], name: str, budget: int) !{fs.read}: mut designs = session["designs"] design = designs[name] target_key = design["spec"]["target_key"] if len(target_key) == 0: return {"error": "DockingRejected", "detail": "the design carries no targeting clause, so there is no target to dock against", "design": design} if not structure_key_supported(target_key): return {"error": "MolecularStructureUnavailable", "detail": "the design target is not in the digest-bound molecular library", "design": design} target = load_molecular_session(target_key) identity = docking_identity(target, design["structure"], budget) if design["docking_identity"] == identity: return {"error": "", "detail": "", "design": design} rejection = docking_rejection(target, design["structure"], budget) if len(rejection) > 0: return {"error": "DockingRejected", "detail": rejection, "design": design} design["docking"] = dock_ligand(target, design["structure"], budget) design["docking_identity"] = identity designs[name] = design session["designs"] = designs return {"error": "", "detail": "", "design": design}
def design_result_body(design: dict[str, any], species: any, summary: list[str]): return { "schema": "sema.molecular-design-result/v1", "backend": "Sema", "spec": design["spec"], "structure": design["structure"], "species": species, "summary": summary, "scientific_validated": false, }
def registration_error_response(registration: dict[str, str]) !{}: status = 413 if registration["error"] == "SpeciesRegistryFull" else 422 return error_response(status, registration["error"], registration["detail"])
def set_design_mechanism(compiled: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}: sem "Re-declare what an existing design does biologically, committing the registry only once the species re-registers" name = compiled["name"] mut designs = session["designs"] if not designs.has(name): return error_response(404, "DesignUnknown", "no design with that name exists in this Sema session") mechanism = compiled["mechanism"] design = designs[name] registry = active_species_registry(profile, session) mut species: any = None if registry.has(name): introduced = registry[name] registration = species_registration_error(registry, design["spec"], design["docking"], introduced["concentration_micromolar"], mechanism) if len(registration["error"]) > 0: return registration_error_response(registration) next_registry = register_species(registry, design["spec"], design["structure"], design["docking"], introduced["concentration_micromolar"], mechanism, introduced["introduced_at_days"]) species = next_registry[name] store_species(profile, session, next_registry) design["mechanism"] = mechanism designs[name] = design session["designs"] = designs session["design_generation"] = session["design_generation"] + 1 return response(200, design_result_body(design, species, ["design=" + name, "mechanism=" + mechanism]))
def apply_design_command(compiled: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}: if compiled["kind"] == "set_mechanism": return set_design_mechanism(compiled, profile, session) name = compiled["name"] spec = compiled["spec"] if not design_spec_valid(spec): return error_response(422, "DesignRejected", "the compiled design specification is outside its declared bounds") if active_species_registry(profile, session).has(name): return error_response(409, "SpeciesStateConflict", "a designed species with that name is already introduced into the live tissue") mut designs = session["designs"] if not designs.has(name) and len(designs) >= design_capabilities()["max_designs"]: return error_response(413, "DesignRegistryFull", "this Sema session already holds the maximum number of bounded designs") structure = build_designed_structure(spec) design = {"spec": spec, "structure": structure, "mechanism": spec["mechanism"], "docking": None, "docking_identity": ""} designs[name] = design session["designs"] = designs session["design_generation"] = session["design_generation"] + 1 return response(200, design_result_body(design, None, [ "design=" + name, "class=" + spec["class"], "conformation=" + spec["conformation"], "target=" + spec["target_key"], "mechanism=" + spec["mechanism"], "atoms=" + str(len(structure["atomic_numbers"])), "bonds=" + str(len(structure["bonds"]) // 2), "fidelity=" + structure["fidelity"], "biological_match=" + structure["biological_match"], ]))
def design_mutation_identity(payload: dict[str, any]) !{}: return encode_json({ "schema": "sema.biological-design-request-identity/v1", "program_state_version": payload["program_state_version"], "command": payload["command"], })
def design_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}: if not payload.has("program_state_version") or not payload.has("command"): return error_response(422, "DesignCompileError", "program_state_version and command are required") if payload["program_state_version"] != session["program"]["state_version"]: return error_response(409, "DesignStateConflict", "program state version does not match Sema-owned program state") request_identity = design_mutation_identity(payload) if session["design_last_identity"] == request_identity and session["design_last_generation"] == session["design_generation"]: return session["design_last_response"] compiled = compile_design_command(payload["command"]) if not compiled["ok"]: return error_response(422, compiled["error"], compiled["detail"]) applied = apply_design_command(compiled, profile, session) if applied["status"] == 200: session["design_last_identity"] = request_identity session["design_last_response"] = applied session["design_last_generation"] = session["design_generation"] return applied
def dock_response(payload: dict[str, any], session: dict[str, any]) !{fs.read}: if not payload.has("generation") or not payload.has("name"): return error_response(422, "DockingRejected", "generation and name are required") if payload["generation"] != session["design_generation"]: return error_response(409, "DesignStateConflict", "generation does not match the Sema-owned design registry") if not session["designs"].has(payload["name"]): return error_response(404, "DesignUnknown", "no design with that name exists in this Sema session") budget = payload["budget"] if payload.has("budget") else 512 if budget < 64 or budget > 4096: return error_response(422, "DockingRejected", "budget must be a pose count in [64, 4096]") docked = dock_design(session, payload["name"], budget) if len(docked["error"]) > 0: return error_response(404 if docked["error"] == "MolecularStructureUnavailable" else 422, docked["error"], docked["detail"]) return response(200, docked["design"]["docking"])
def introduce_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{fs.read}: if not all(payload.has(field) for field in ["state_version", "generation", "name", "concentration_micromolar"]): return error_response(422, "SpeciesRejected", "state_version, generation, name, and concentration_micromolar are required") if payload["generation"] != session["design_generation"]: return error_response(409, "DesignStateConflict", "generation does not match the Sema-owned design registry") visible_state_version = session["preview_state_version"] if profile.adaptation.exploratory else session["state_version"] if payload["state_version"] != visible_state_version: return error_response(409, "SpeciesStateConflict", "state version does not match the Sema-owned live state") name = payload["name"] if not session["designs"].has(name): return error_response(404, "DesignUnknown", "no design with that name exists in this Sema session") docked = dock_design(session, name, 512) if len(docked["error"]) > 0: return error_response(404 if docked["error"] == "MolecularStructureUnavailable" else 422, docked["error"], docked["detail"]) design = docked["design"] mechanism = payload["mechanism"] if payload.has("mechanism") else design["mechanism"] concentration = payload["concentration_micromolar"] registry = active_species_registry(profile, session) registration = species_registration_error(registry, design["spec"], design["docking"], concentration, mechanism) if len(registration["error"]) > 0: return registration_error_response(registration) physiology = session["preview_physiology"] if profile.adaptation.exploratory else session["physiology"] store_species(profile, session, register_species(registry, design["spec"], design["structure"], design["docking"], concentration, mechanism, physiology["model_time_days"])) return status_response(profile, session)
def invalidate_molecular_step_caches(session: dict[str, any]): session["molecular_revision"] = session["molecular_revision"] + 1 session["last_step"] = None session["preview_last_step"] = None session["molecular_last_step_identity"] = None session["molecular_last_step_response"] = None session["molecular_last_mutation_identity"] = None session["molecular_last_mutation_response"] = None session["molecular_last_mutation_generation"] = None session["molecular_last_mutation_program_state_version"] = None
def advance_molecular_generation(session: dict[str, any]): session["molecular_generation"] = session["molecular_generation"] + 1 invalidate_molecular_step_caches(session)
def molecular_mutation_identity(kind: str, payload: dict[str, any]) !{}: return encode_json({ "schema": "sema.biological-molecular-mutation-request-identity/v1", "kind": kind, "payload": payload, })
def retained_molecular_mutation(identity: str, session: dict[str, any]): return session["molecular_last_mutation_identity"] == identity and session["molecular_last_mutation_response"] != None and session["molecular_last_mutation_generation"] == session["molecular_generation"] and session["molecular_last_mutation_program_state_version"] == session["program"]["state_version"]
def retain_molecular_mutation(identity: str, body: dict[str, any], session: dict[str, any]): session["molecular_last_mutation_identity"] = identity session["molecular_last_mutation_response"] = body session["molecular_last_mutation_generation"] = session["molecular_generation"] session["molecular_last_mutation_program_state_version"] = session["program"]["state_version"]
def molecule_response(payload: dict[str, any], session: dict[str, any]) !{fs.read}: if not payload.has("generation") or not payload.has("key"): return error_response(422, "MolecularInputInvalid", "generation and key are required") request_identity = molecular_mutation_identity("load", payload) if retained_molecular_mutation(request_identity, session): return response(200, session["molecular_last_mutation_response"]) if payload["generation"] != session["molecular_generation"]: return error_response(409, "MolecularGenerationConflict", "generation does not match Sema-owned molecular state") if not structure_key_supported(payload["key"]): return error_response(404, "MolecularStructureUnavailable", "the requested digest-bound molecular structure is unavailable") molecular = load_molecular_session(payload["key"]) molecular["thermal_scale"] = session["program"]["signals"]["molecular_temperature"] molecular["bond_stiffness"] = session["program"]["signals"]["bond_stiffness"] session["molecular"] = molecular advance_molecular_generation(session) body = molecular_public_state(molecular) body["generation"] = session["molecular_generation"] retain_molecular_mutation(request_identity, body, session) return response(200, body)
def molecule_step_response(payload: dict[str, any], session: dict[str, any]) !{}: if not all(payload.has(field) for field in ["generation", "key", "sequence", "state_version", "dt_s"]): return error_response(422, "MolecularStepInvalid", "generation, key, sequence, state_version, and dt_s are required") request_identity = molecular_mutation_identity("step", payload) if retained_molecular_mutation(request_identity, session): return response(200, session["molecular_last_mutation_response"]) if session["molecular"] == None: return error_response(409, "MolecularStateUnavailable", "load a molecular structure before stepping it") molecular = session["molecular"] if payload["generation"] != session["molecular_generation"]: return error_response(409, "MolecularGenerationConflict", "generation does not match Sema-owned molecular state") if payload["key"] != molecular["key"]: return error_response(409, "MolecularStateConflict", "molecular source does not match Sema-owned state") if payload["dt_s"] <= 0.0 or payload["dt_s"] > 0.1: return error_response(422, "MolecularStepInvalid", "dt_s must be in (0, 0.1]") if payload["sequence"] == molecular["sequence"] and payload["state_version"] == molecular["state_version"]: if session["molecular_last_step_identity"] == request_identity and session["molecular_last_step_response"] != None: return response(200, session["molecular_last_step_response"]) return error_response(409, "MolecularRequestConflict", "molecular step identifiers are already bound to a different request identity") if payload["sequence"] != molecular["sequence"] + 1 or payload["state_version"] != molecular["state_version"]: return error_response(409, "MolecularStateConflict", "molecular sequence or state version does not match") session["molecular"] = step_molecular_session(molecular, payload["dt_s"]) advance_molecular_generation(session) molecular_response_body = molecular_public_state(session["molecular"]) molecular_response_body["generation"] = session["molecular_generation"] session["molecular_last_step_identity"] = request_identity session["molecular_last_step_response"] = molecular_response_body retain_molecular_mutation(request_identity, molecular_response_body, session) return response(200, molecular_response_body)
def direct_molecular_operations(operations: list[dict[str, any]]): for operation in operations: if operation["kind"] == "translate_atom" or operation["kind"] == "add_bond" or operation["kind"] == "remove_bond": return true return false
def program_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{fs.read}: if payload.has("command"): compiled = compile_biological_command(payload["command"]) if not compiled["ok"]: return error_response(422, compiled["error"], compiled["detail"]) payload["operations"] = compiled["operations"] request_identity = molecular_mutation_identity("program", payload) if retained_molecular_mutation(request_identity, session): return response(200, session["molecular_last_mutation_response"]) program_result = apply_biological_program(session["program"], payload) if not program_result["ok"]: status = 409 if program_result["error"] == "ProgramStateConflict" else 422 return error_response(status, program_result["error"], program_result["detail"]) molecular_operations = program_result["molecular_operations"] mut molecular: any = None if len(molecular_operations) > 0 and session["molecular"] is not None: if not payload.has("molecular_generation"): return error_response(422, "MolecularProgramInvalid", "molecular_generation is required for a molecular edit") if payload["molecular_generation"] != session["molecular_generation"]: return error_response(409, "MolecularGenerationConflict", "generation does not match Sema-owned molecular state") mut reset_molecular: any = None if program_result["reset_molecular"] and session["molecular"] is not None: reset_molecular = load_molecular_session(session["molecular"]["key"]) if program_result["reset_molecular"]: if profile.adaptation.exploratory: session["preview_generation"] = session["preview_generation"] + 1 session["preview_sequence"] = 0 session["preview_state_version"] = 0 session["preview_state"] = profile.initial_state session["preview_population"] = initial_population_state(profile.population_cells) session["preview_physiology"] = initial_physiology_state() session["preview_last_step"] = None session["preview_retry_context"] = None else: session["active_generation"] = session["active_generation"] + 1 session["sequence"] = 0 session["state_version"] = 0 session["state"] = profile.initial_state session["population"] = initial_population_state(profile.population_cells) session["physiology"] = initial_physiology_state() session["last_step"] = None session["retry_context"] = None if reset_molecular is not None: session["molecular"] = reset_molecular advance_molecular_generation(session) if session["molecular"] is not None: molecular = molecular_public_state(session["molecular"]) molecular["generation"] = session["molecular_generation"] if len(molecular_operations) > 0: if session["molecular"] == None: if direct_molecular_operations(molecular_operations): return error_response(409, "MolecularStateUnavailable", "load a molecular structure before applying topology or coordinate edits") else: if not payload.has("molecular_state_version"): return error_response(422, "MolecularProgramInvalid", "molecular_state_version is required for a molecular edit") molecular_result = apply_molecular_program(session["molecular"], { "state_version": payload["molecular_state_version"], "operations": molecular_operations, }) if not molecular_result["ok"]: status = 409 if molecular_result["error"] == "MolecularStateConflict" else 422 return error_response(status, molecular_result["error"], molecular_result["detail"]) session["molecular"] = molecular_result["session"] advance_molecular_generation(session) molecular = molecular_public_state(session["molecular"]) molecular["generation"] = session["molecular_generation"] for design_operation in program_result["design_operations"]: design_result = apply_design_command(design_operation, profile, session) if design_result["status"] != 200: return design_result session["program"] = program_result["state"] session["last_step"] = None session["preview_last_step"] = None body = { "schema": "sema.biological-program-result/v1", "backend": "Sema", "active_generation": session["active_generation"], "preview_generation": session["preview_generation"], "molecular_generation": session["molecular_generation"], "program": session["program"], "molecular": molecular, "summary": program_result["summary"], } if program_result["reset_molecular"] or (len(molecular_operations) > 0 and session["molecular"] is not None): retain_molecular_mutation(request_identity, body, session) return response(200, body)
def capabilities_response() !{}: capabilities = programming_capabilities() capabilities["agent"] = agent_capabilities() capabilities["binding"] = binding_capabilities() capabilities["cortex"] = cortex_capabilities() capabilities["design"] = design_capabilities() return response(200, capabilities)
def live_response(request: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{ffi.call, fs.read}: if request["method"] == "GET" and request["path"] == "/api/sema/status": return status_response(profile, session) if request["method"] == "GET" and request["path"] == "/api/sema/capabilities": return capabilities_response() if request["method"] == "POST" and request["path"] == "/api/sema/step": if len(request["body"]) == 0 or len(request["body"]) > 4096: return error_response(413, "LiveInputInvalid", "step payload must contain at most 4096 bytes") expect payload = decode_json(request["body"]): return step_response(payload, profile, session) except JsonError as error: return error_response(422, "LiveInputInvalid", "step request must contain finite valid JSON") if request["method"] == "POST" and request["path"] == "/api/sema/intervene": if len(request["body"]) == 0 or len(request["body"]) > 4096: return error_response(413, "LiveInterventionInvalid", "intervention payload must contain at most 4096 bytes") return intervention_response(decode_json(request["body"]), profile, session) if request["method"] == "POST" and request["path"] == "/api/sema/molecule": if len(request["body"]) == 0 or len(request["body"]) > 4096: return error_response(413, "MolecularInputInvalid", "molecular payload must contain at most 4096 bytes") return molecule_response(decode_json(request["body"]), session) if request["method"] == "POST" and request["path"] == "/api/sema/molecule/step": if len(request["body"]) == 0 or len(request["body"]) > 4096: return error_response(413, "MolecularStepInvalid", "molecular step payload must contain at most 4096 bytes") return molecule_step_response(decode_json(request["body"]), session) if request["method"] == "POST" and request["path"] == "/api/sema/program": if len(request["body"]) == 0 or len(request["body"]) > 8192: return error_response(413, "ProgramInvalid", "program payload must contain at most 8192 bytes") return program_response(decode_json(request["body"]), profile, session) if request["method"] == "POST" and request["path"] == "/api/sema/design": if len(request["body"]) == 0 or len(request["body"]) > 8192: return error_response(413, "DesignCompileError", "design payload must contain at most 8192 bytes") return design_response(decode_json(request["body"]), profile, session) if request["method"] == "POST" and request["path"] == "/api/sema/dock": if len(request["body"]) == 0 or len(request["body"]) > 4096: return error_response(413, "DockingRejected", "docking payload must contain at most 4096 bytes") return dock_response(decode_json(request["body"]), session) if request["method"] == "POST" and request["path"] == "/api/sema/introduce": if len(request["body"]) == 0 or len(request["body"]) > 4096: return error_response(413, "SpeciesRejected", "introduction payload must contain at most 4096 bytes") return introduce_response(decode_json(request["body"]), profile, session) if request["method"] == "POST" and request["path"] == "/api/sema/agent/propose": if len(request["body"]) == 0 or len(request["body"]) > 8192: return error_response(413, "AgentProposalInvalid", "agent proposal must contain at most 8192 bytes") proposal = propose_agent_program(decode_json(request["body"])) if not proposal["ok"]: return error_response(422, proposal["error"], proposal["detail"]) return response(200, proposal) if request["method"] == "POST" and request["path"] == "/api/sema/cortex/propose": if len(request["body"]) == 0 or len(request["body"]) > 8192: return error_response(413, "CortexProposalInvalid", "Cortex proposal must contain at most 8192 bytes") active_state_version_before = session["state_version"] active_sequence_before = session["sequence"] preview_state_version_before = session["preview_state_version"] preview_sequence_before = session["preview_sequence"] cortex = propose_cortex(decode_json(request["body"])) if not cortex["ok"]: if cortex["error"] == "CortexProposalUnavailable": return error_response(503, cortex["error"], cortex["detail"]) return error_response(422, cortex["error"], cortex["detail"]) ensure session["state_version"] == active_state_version_before and session["sequence"] == active_sequence_before ensure session["preview_state_version"] == preview_state_version_before and session["preview_sequence"] == preview_sequence_before return response(200, cortex["proposal"]) return error_response(404, "NotFound", "unknown Sema live endpoint")
pub def serve_live(port: int) -> None !{ffi.call, fs.read, net.listen}: sem "Serve the viewer's live equation steps from the same evidence-bound Sema model" require port >= 1024 and port <= 65535 profile = load_live_profile() session = {"sequence": 0, "state_version": 0, "active_generation": 0, "state": profile.initial_state, "last_step": None, "retry_context": None, "population": initial_population_state(profile.population_cells), "preview_sequence": 0, "preview_state_version": 0, "preview_generation": 0, "preview_state": profile.initial_state, "preview_last_step": None, "preview_retry_context": None, "preview_population": initial_population_state(profile.population_cells), "preview_physiology": initial_physiology_state(), "program": initial_program_state(), "physiology": initial_physiology_state(), "molecular": None, "molecular_generation": 0, "molecular_revision": 0, "molecular_last_step_identity": None, "molecular_last_step_response": None, "molecular_last_mutation_identity": None, "molecular_last_mutation_response": None, "molecular_last_mutation_generation": None, "molecular_last_mutation_program_state_version": None, "designs": {}, "design_generation": 0, "species": initial_species_registry(), "preview_species": initial_species_registry(), "design_last_identity": None, "design_last_response": None, "design_last_generation": None} print("sema_live=http://127.0.0.1:" + str(port) + " model=" + profile.model_id + " admission_status=" + profile.adaptation.admission_status + " activated=" + str(profile.adaptation.activated) + " technical_pass=" + str(profile.adaptation.admitted) + " scientific_validated=false scene_sha256=" + profile.scene_sha256) http.serve(port, request => live_response(request, profile, session))src/mace_off.sema
Section titled “src/mace_off.sema”"""MACE-OFF23 molecular holdout, calibrated uncertainty, OOD, and ablation evidence."""
assure silver
pub struct MaceOffResult: schema: str profile_id: str config_sha256: str dataset_sha256: str model_sha256: list[str] provenance_sha256: str checkpoint_license: str dataset_license: str level_of_theory: str calibration_configurations: int heldout_configurations: int unique_molecules: int heldout_energy_rmse_mev_per_atom: f64 heldout_force_rmse_mev_per_angstrom: f64 symbolic_only_force_rmse_mev_per_angstrom: f64 hybrid_force_rmse_mev_per_angstrom: f64 conformal_scale: f64 conformal_coverage: f64 ood_minimum_distance_angstrom: f64 ood_uncertainty_ratio: f64 in_domain_force_disagreement_mev_per_angstrom: f64 ood_force_disagreement_mev_per_angstrom: f64 ood_blocked: bool translation_energy_residual_ev: f64 translation_force_residual_ev_per_angstrom: f64 accuracy_pass: bool uncertainty_pass: bool symmetry_pass: bool ood_pass: bool ablation_pass: bool molecular_validated: bool evidence_class: str direct_oracle_result_sha256: str direct_energy_residual: f64 direct_force_residual: f64 direct_parity_pass: bool result_sha256: str result_path: str invariant schema == "sema.mace-off-profile-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(dataset_sha256) == 64 invariant len(model_sha256) == 3 invariant all(len(digest) == 64 for digest in model_sha256) invariant len(provenance_sha256) == 64 invariant checkpoint_license == "Academic Software License" invariant dataset_license == "MIT" invariant calibration_configurations == 12 invariant heldout_configurations == 12 invariant unique_molecules == calibration_configurations + heldout_configurations invariant heldout_energy_rmse_mev_per_atom >= 0.0 invariant heldout_force_rmse_mev_per_angstrom >= 0.0 invariant symbolic_only_force_rmse_mev_per_angstrom >= 0.0 invariant hybrid_force_rmse_mev_per_angstrom >= 0.0 invariant conformal_scale >= 0.0 invariant conformal_coverage >= 0.0 and conformal_coverage <= 1.0 invariant ood_minimum_distance_angstrom > 0.0 invariant ood_uncertainty_ratio >= 0.0 invariant in_domain_force_disagreement_mev_per_angstrom >= 0.0 invariant ood_force_disagreement_mev_per_angstrom >= 0.0 invariant translation_energy_residual_ev >= 0.0 invariant translation_force_residual_ev_per_angstrom >= 0.0 invariant len(direct_oracle_result_sha256) == 64 invariant direct_energy_residual >= 0.0 invariant direct_force_residual >= 0.0 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant evidence_class == "validated_molecular_holdout" or evidence_class == "failed_molecular_holdout"
pub bridge python.inline mace_off_backend from "foreign/python/mace_off_backend.py": deps "python>=3.12,<3.13" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> MaceOffResult !{ffi.call}: sem "Validate three pinned molecular models on disjoint quantum holdouts with calibrated OOD evidence"src/mace.sema
Section titled “src/mace.sema”"""Pinned MACE-MP technical adapter with independent direct parity."""
assure silver
pub struct MaceProfileResult: schema: str profile_id: str platform: str device: str default_dtype: str mace_torch_version: str torch_version: str checkpoint_url: str checkpoint_sha256: str checkpoint_bytes: int checkpoint_license: str training_domain: str provenance_sha256: str config_sha256: str system_sha256: str result_sha256: str result_path: str direct_oracle_file_sha256: str direct_oracle_result_sha256: str atoms: int base_energy_ev: f64 displaced_energy_ev: f64 ablation_energy_delta_ev: f64 max_force_ev_per_angstrom: f64 finite_difference_force_residual_ev_per_angstrom: f64 translation_energy_residual_ev: f64 translation_force_residual_ev_per_angstrom: f64 direct_energy_residual_ev: f64 direct_force_residual_ev_per_angstrom: f64 finite_difference_pass: bool translation_pass: bool ablation_pass: bool direct_parity_pass: bool technical_pass: bool reference_kind: str replay_class: str domain_status: str uncertainty_available: bool molecular_validated: bool evidence_class: str invariant schema == "sema.mace-profile-result/v1" invariant profile_id == "mace_mp_0a_small_si_v1" invariant platform == "CPU" and device == "cpu" invariant default_dtype == "float64" invariant mace_torch_version == "0.3.16" invariant checkpoint_sha256 == "2ddb079cee0e131eaaf6912ba581b394551ead283e95c99cfe78c605d10b5736" invariant checkpoint_bytes > 0 and checkpoint_bytes <= 67108864 invariant checkpoint_license == "MIT" invariant len(provenance_sha256) == 64 invariant len(config_sha256) == 64 invariant len(system_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant len(direct_oracle_file_sha256) == 64 invariant len(direct_oracle_result_sha256) == 64 invariant atoms == 8 invariant max_force_ev_per_angstrom >= 0.0 invariant finite_difference_force_residual_ev_per_angstrom >= 0.0 invariant translation_energy_residual_ev >= 0.0 invariant translation_force_residual_ev_per_angstrom >= 0.0 invariant direct_energy_residual_ev >= 0.0 invariant direct_force_residual_ev_per_angstrom >= 0.0 invariant reference_kind == "internal_consistency_only" invariant replay_class == "exact" invariant domain_status == "composition_supported_geometry_unqualified" invariant uncertainty_available == false invariant molecular_validated == false invariant evidence_class == "validated_technical" or evidence_class == "exploratory"
pub bridge python.inline mace_backend from "foreign/python/mace_backend.py": deps "python>=3.12,<3.13" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> MaceProfileResult !{ffi.call}: sem "Validate a pinned MACE checkpoint against an independent direct invocation and internal physical residuals"src/mesoscopic.sema
Section titled “src/mesoscopic.sema”"""Uncertainty-preserving molecular-to-reaction-diffusion parameter transfer."""
assure silver
pub struct MesoscopicResult: schema: str profile_id: str config_sha256: str source_result_sha256: str source_artifact_sha256: str source_kd_micromolar: f64 source_kd_sem_micromolar: f64 association_rate_per_micromolar_s: f64 dissociation_rate_per_s: f64 voxels: int steps: int dt_s: f64 simulated_time_s: f64 initial_mass_micromolar: f64 final_mass_micromolar: f64 mass_relative_residual: f64 expected_monomer_micromolar: f64 expected_dimer_micromolar: f64 observed_monomer_micromolar: f64 observed_dimer_micromolar: f64 observed_kd_micromolar: f64 kd_relative_residual: f64 spatial_cv: f64 dimer_uncertainty_min_micromolar: f64 dimer_uncertainty_max_micromolar: f64 rate_roundtrip_relative_residual: f64 sbml_sha256: str bngl_sha256: str uncertainty_pass: bool interchange_pass: bool transfer_pass: bool reverse_discrepancy_signaled: bool adapter_backend_sha256: str readdy_status: str readdy_unavailable_reason: str readdy_version: str readdy_source_commit: str readdy_wheel_filename: str readdy_wheel_sha256: str readdy_module_sha256: str readdy_platform: str readdy_executed: bool readdy_target_rate_evidence: bool readdy_concentration_evidence: bool readdy_spatial_evidence: bool readdy_uncertainty_evidence: bool readdy_association_events: int readdy_dissociation_events: int readdy_lower_uncertainty_dissociation_events: int readdy_upper_uncertainty_dissociation_events: int readdy_final_monomer_particles: int readdy_final_dimer_particles: int readdy_mass_relative_residual: f64 readdy_mean_displacement_micrometers: f64 readdy_observation_sha256: str readdy_observation_json: str readdy_validated: bool physicell_status: str physicell_unavailable_reason: str physicell_version: str physicell_source_commit: str physicell_source_url: str physicell_executable: str physicell_executed: bool physicell_target_rate_evidence: bool physicell_concentration_evidence: bool physicell_spatial_evidence: bool physicell_uncertainty_evidence: bool physicell_validated: bool scientific_validated: bool evidence_class: str result_sha256: str direct_oracle_result_sha256: str direct_oracle_path: str direct_residual: f64 direct_parity_pass: bool phase8_technical_pass: bool sbml_path: str bngl_path: str result_path: str invariant schema == "sema.mesoscopic-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(source_result_sha256) == 64 invariant len(source_artifact_sha256) == 64 invariant source_kd_micromolar > 0.0 invariant source_kd_sem_micromolar >= 0.0 invariant association_rate_per_micromolar_s > 0.0 invariant dissociation_rate_per_s > 0.0 invariant voxels > 2 invariant steps > 0 invariant dt_s > 0.0 invariant simulated_time_s > 0.0 invariant initial_mass_micromolar > 0.0 invariant final_mass_micromolar > 0.0 invariant mass_relative_residual >= 0.0 invariant expected_monomer_micromolar >= 0.0 invariant expected_dimer_micromolar >= 0.0 invariant observed_monomer_micromolar >= 0.0 invariant observed_dimer_micromolar > 0.0 invariant observed_kd_micromolar > 0.0 invariant kd_relative_residual >= 0.0 invariant spatial_cv >= 0.0 invariant dimer_uncertainty_min_micromolar >= 0.0 invariant dimer_uncertainty_max_micromolar >= dimer_uncertainty_min_micromolar invariant rate_roundtrip_relative_residual >= 0.0 invariant len(sbml_sha256) == 64 invariant len(bngl_sha256) == 64 invariant len(adapter_backend_sha256) == 64 invariant readdy_status == "qualified" or readdy_status == "failed" or readdy_status == "unavailable" invariant readdy_status == "qualified" or len(readdy_unavailable_reason) > 0 invariant len(readdy_source_commit) == 40 invariant len(readdy_wheel_filename) > 0 invariant len(readdy_wheel_sha256) == 64 invariant len(readdy_observation_sha256) == 64 invariant len(readdy_observation_json) > 0 invariant readdy_association_events >= 0 invariant readdy_dissociation_events >= 0 invariant readdy_lower_uncertainty_dissociation_events >= 0 invariant readdy_upper_uncertainty_dissociation_events >= 0 invariant readdy_final_monomer_particles >= 0 invariant readdy_final_dimer_particles >= 0 invariant readdy_mass_relative_residual >= 0.0 invariant readdy_mean_displacement_micrometers >= 0.0 invariant not readdy_validated or readdy_executed invariant not readdy_validated or readdy_status == "qualified" invariant not readdy_validated or readdy_target_rate_evidence invariant not readdy_validated or readdy_concentration_evidence invariant not readdy_validated or readdy_spatial_evidence invariant not readdy_validated or readdy_uncertainty_evidence invariant physicell_status == "qualified" or physicell_status == "failed" or physicell_status == "unavailable" invariant physicell_status == "qualified" or len(physicell_unavailable_reason) > 0 invariant len(physicell_version) > 0 invariant len(physicell_source_commit) == 40 invariant len(physicell_source_url) > 0 invariant not physicell_validated or physicell_executed invariant not physicell_validated or physicell_target_rate_evidence invariant not physicell_validated or physicell_concentration_evidence invariant not physicell_validated or physicell_spatial_evidence invariant not physicell_validated or physicell_uncertainty_evidence invariant not phase8_technical_pass or transfer_pass invariant not phase8_technical_pass or direct_parity_pass invariant not phase8_technical_pass or readdy_validated invariant not scientific_validated or phase8_technical_pass invariant len(result_sha256) == 64 invariant len(direct_oracle_result_sha256) == 64 invariant len(direct_oracle_path) > 0 invariant direct_residual >= 0.0 invariant len(sbml_path) > 0 invariant len(bngl_path) > 0 invariant len(result_path) > 0 invariant evidence_class == "validated_reaction_diffusion_reference" or evidence_class == "failed_reaction_diffusion_reference"
pub bridge python.inline mesoscopic_backend from "foreign/python/mesoscopic_backend.py": deps "python>=3.12,<3.13", "numpy==2.4.1" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> MesoscopicResult !{ffi.call}: sem "Transfer molecular equilibrium evidence into bounded reaction-diffusion with SBML and BioNetGen round trips"src/models.sema
Section titled “src/models.sema”"""Typed symbolic, learned, and hybrid equation terms with fail-closed evidence gates."""
assure silver
pub enum TermImplementation: symbolic | learned | hybrid
pub enum LearnedRole: energy | force | rate | transition_probability | structure_proposal | closure | parameter
pub enum ApplicabilityDecision: applicable | out_of_domain | unknown
pub enum PredictionStatus: proposed | admissible | blocked
pub struct LearnedModelManifest: id: str family: str version: str role: LearnedRole architecture_sha256: str weights_sha256: str training_data_sha256: str validation_data_sha256: str license_id: str preprocessing: str input_units: list[str] output_unit: str chemical_domain: str thermodynamic_domain: str symmetry_contract: str calibration_method: str uncertainty_method: str ood_method: str backend_profile_id: str evidence_ids: list[str] validated: bool invariant len(id) > 0 invariant len(family) > 0 invariant len(version) > 0 invariant len(architecture_sha256) == 64 invariant len(weights_sha256) == 64 invariant len(training_data_sha256) == 64 invariant len(validation_data_sha256) == 64 invariant len(license_id) > 0 invariant len(preprocessing) > 0 invariant len(input_units) > 0 and len(input_units) <= 128 invariant len(output_unit) > 0 invariant len(chemical_domain) > 0 invariant len(thermodynamic_domain) > 0 invariant len(symmetry_contract) > 0 invariant len(calibration_method) > 0 invariant len(uncertainty_method) > 0 invariant len(ood_method) > 0 invariant len(backend_profile_id) > 0 invariant len(evidence_ids) <= 128
pub struct EquationTermDescriptor: id: str owner_model_id: str implementation: TermImplementation role: LearnedRole input_units: list[str] output_unit: str symbolic_expression: str learned_model_id: str combination_rule: str authoritative_outputs: list[str] invariant len(id) > 0 invariant len(owner_model_id) > 0 invariant len(input_units) > 0 and len(input_units) <= 128 invariant len(output_unit) > 0 invariant len(combination_rule) > 0 invariant len(authoritative_outputs) > 0 and len(authoritative_outputs) <= 16
pub struct PredictionUncertainty: aleatoric: f64 epistemic: f64 lower: f64 upper: f64 coverage: f64 calibrated: bool invariant aleatoric >= 0.0 invariant epistemic >= 0.0 invariant lower <= upper invariant coverage > 0.0 and coverage < 1.0
pub struct HybridPrediction: term_id: str manifest_id: str symbolic_value: f64 learned_value: f64 gate: f64 combined_value: f64 output_unit: str uncertainty: PredictionUncertainty applicability: ApplicabilityDecision ood_score: f64 symbolic_residual: f64 evidence_ids: list[str] status: PredictionStatus reason: str invariant len(term_id) > 0 invariant len(manifest_id) > 0 invariant len(output_unit) > 0 invariant ood_score >= 0.0 invariant symbolic_residual >= 0.0 invariant len(evidence_ids) <= 128 invariant len(reason) > 0
equation raw_additive_hybrid_value(symbolic_value: f64, learned_correction: f64, gate: f64) -> f64: return symbolic_value + gate * learned_correction
def additive_hybrid_value(symbolic_value: f64, learned_correction: f64, gate: f64) !{}: require gate >= 0.0 and gate <= 1.0 return raw_additive_hybrid_value(symbolic_value, learned_correction, gate)
def manifest_qualified(manifest: LearnedModelManifest): return manifest.validated and len(manifest.evidence_ids) > 0
def term_matches_manifest(term: EquationTermDescriptor, manifest: LearnedModelManifest): return ( term.learned_model_id == manifest.id and term.role == manifest.role and term.input_units == manifest.input_units and term.output_unit == manifest.output_unit )
def term_descriptor_valid(term: EquationTermDescriptor): if term.implementation == TermImplementation.symbolic: return len(term.symbolic_expression) > 0 and len(term.learned_model_id) == 0 if term.implementation == TermImplementation.learned: return len(term.learned_model_id) > 0 and term.combination_rule == "learned_only" return len(term.symbolic_expression) > 0 and len(term.learned_model_id) > 0
pub def assess_hybrid_prediction( term: EquationTermDescriptor, manifest: LearnedModelManifest, symbolic_value: f64, learned_value: f64, gate: f64, uncertainty: PredictionUncertainty, applicability: ApplicabilityDecision, ood_score: f64, symbolic_residual: f64, maximum_uncertainty: f64, maximum_residual: f64, evidence_ids: list[str],) -> HybridPrediction !{}: require maximum_uncertainty >= 0.0 require maximum_residual >= 0.0 mut combined = symbolic_value mut status = PredictionStatus.blocked mut reason = "gate is outside the closed unit interval" if gate >= 0.0 and gate <= 1.0: combined = raw_additive_hybrid_value(symbolic_value, learned_value, gate) status = PredictionStatus.admissible reason = "manifest, applicability, calibration, uncertainty, and residual gates passed" if status == PredictionStatus.admissible and (not term_descriptor_valid(term) or not manifest_qualified(manifest)): status = PredictionStatus.blocked reason = "term or learned model manifest is not qualified" elif status == PredictionStatus.admissible and not term_matches_manifest(term, manifest): status = PredictionStatus.blocked reason = "term and learned model dimensional or semantic contracts differ" elif status == PredictionStatus.admissible and applicability != ApplicabilityDecision.applicable: status = PredictionStatus.blocked reason = "input is out of domain or applicability is unknown" elif status == PredictionStatus.admissible and not uncertainty.calibrated: status = PredictionStatus.blocked reason = "uncertainty is not calibrated" elif status == PredictionStatus.admissible and uncertainty.aleatoric + uncertainty.epistemic > maximum_uncertainty: status = PredictionStatus.blocked reason = "uncertainty exceeds the declared threshold" elif status == PredictionStatus.admissible and symbolic_residual > maximum_residual: status = PredictionStatus.blocked reason = "symbolic residual exceeds the declared threshold" elif status == PredictionStatus.admissible and len(evidence_ids) == 0: status = PredictionStatus.blocked reason = "prediction has no evidence" return HybridPrediction( term_id=term.id, manifest_id=manifest.id, symbolic_value=symbolic_value, learned_value=learned_value, gate=gate, combined_value=combined, output_unit=term.output_unit, uncertainty=uncertainty, applicability=applicability, ood_score=ood_score, symbolic_residual=symbolic_residual, evidence_ids=evidence_ids, status=status, reason=reason, )
pub def prediction_admissible(prediction: HybridPrediction) -> bool !{}: return ( prediction.status == PredictionStatus.admissible and prediction.gate >= 0.0 and prediction.gate <= 1.0 and prediction.applicability == ApplicabilityDecision.applicable and prediction.uncertainty.calibrated and len(prediction.evidence_ids) > 0 )src/molecular.sema
Section titled “src/molecular.sema”"""Headless, bounded molecular state, topology, and dynamics owned by Sema."""
import mathfrom std.binary import decode_bytes, decode_f32_le, decode_u16_lefrom std.crypto import file_sha256, sha256_jsonfrom std.json import read as read_json
assure silver
def molecular_manifest() !{fs.read}: manifest = read_json("viewer/public/data/structures/manifest.json") ensure manifest["schema"] == "sema.molecular-structure-library/v1" ensure len(manifest["entries"]) > 0 and len(manifest["entries"]) <= 32 return manifest
pub def structure_key_supported(key: str) -> bool !{fs.read}: if len(key) == 0 or len(key) > 64: return false for entry in molecular_manifest()["entries"]: if entry["key"] == key: return true return false
def structure_entry(key: str) !{fs.read}: for entry in molecular_manifest()["entries"]: if entry["key"] == key: return entry ensure false return {}
def validate_record(record: dict[str, any], encoding: str, components: int, maximum_items: int): ensure record["encoding"] == encoding ensure record["components"] == components ensure record["items"] > 0 and record["items"] <= maximum_items ensure len(record["sha256"]) == 64 ensure len(record["base64"]) > 0 and len(record["base64"]) <= 8388608
def atomic_radius(atomic_number: int, radius_kind: str): if atomic_number == 1: return 1.20 if radius_kind == "vdw" else 0.31 if atomic_number == 6: return 1.70 if radius_kind == "vdw" else 0.76 if atomic_number == 7: return 1.55 if radius_kind == "vdw" else 0.71 if atomic_number == 8: return 1.52 if radius_kind == "vdw" else 0.66 if atomic_number == 15: return 1.80 if radius_kind == "vdw" else 1.07 if atomic_number == 16: return 1.80 if radius_kind == "vdw" else 1.05 return 1.80 if radius_kind == "vdw" else 0.80
def atomic_name(atomic_number: int): if atomic_number == 1: return "Hydrogen" if atomic_number == 6: return "Carbon" if atomic_number == 7: return "Nitrogen" if atomic_number == 8: return "Oxygen" if atomic_number == 9: return "Fluorine" if atomic_number == 11: return "Sodium" if atomic_number == 12: return "Magnesium" if atomic_number == 15: return "Phosphorus" if atomic_number == 16: return "Sulfur" if atomic_number == 17: return "Chlorine" if atomic_number == 20: return "Calcium" if atomic_number == 26: return "Iron" if atomic_number == 30: return "Zinc" return "Unmapped element"
def decoded_traces(source: list[dict[str, any]]) !{}: ensure len(source) > 0 and len(source) <= 64 mut traces: list[dict[str, any]] = [] for trace in source: record = trace["positions_angstrom"] validate_record(record, "base64-<f4", 3, 4096) traces.append({ "chain_id": trace["chain_id"], "polymer_type": trace["polymer_type"], "secondary": trace["secondary"], "positions": decode_f32_le(record["base64"], record["sha256"], record["items"] * 3), }) return traces
def active_bond_pairs(session: dict[str, any]): mut pairs: list[int] = [] for bond_index in range(len(session["active_bonds"])): if session["active_bonds"][bond_index]: pairs.append(session["bond_pairs"][bond_index * 2]) pairs.append(session["bond_pairs"][bond_index * 2 + 1]) return pairs
def topology_digest(session: dict[str, any]) !{}: return sha256_json({ "source_sha256": session["source_sha256"], "bonds": active_bond_pairs(session), })
pub def molecular_session_integrity(session: dict[str, any]) -> f64 !{}: mut broken_bonds = 0 mut added_bonds = 0 for bond_index in range(session["base_bond_count"]): if not session["active_bonds"][bond_index]: broken_bonds = broken_bonds + 1 for bond_index in range(session["base_bond_count"], len(session["active_bonds"])): if session["active_bonds"][bond_index]: added_bonds = added_bonds + 1 mut squared_displacement = 0.0 for coordinate_index in range(len(session["positions"])): displacement = session["positions"][coordinate_index] - session["base_positions"][coordinate_index] squared_displacement = squared_displacement + displacement * displacement rmsd_angstrom = math.sqrt(squared_displacement / len(session["atomic_numbers"])) topology_impact = min(1.0, (broken_bonds + added_bonds) / 16.0) displacement_impact = min(1.0, rmsd_angstrom / max(0.1, session["radius_angstrom"])) return max(0.0, 1.0 - topology_impact * 0.55 - displacement_impact * 0.25)
pub def molecular_public_state(session: dict[str, any]) -> dict[str, any] !{}: return { "schema": "sema.molecular-session/v1", "backend": "Sema", "state_version": session["state_version"], "sequence": session["sequence"], "time_s": session["time_s"], "scientific_validated": false, "integrity": molecular_session_integrity(session), "structure": { "key": session["key"], "label": session["label"], "pdb_id": session["pdb_id"], "source_sha256": session["source_sha256"], "asset_sha256": session["asset_sha256"], "topology_sha256": session["topology_sha256"], "fidelity": session["fidelity"], "biological_match": session["biological_match"], "source_page": session["source_page"], "atomic_numbers": session["atomic_numbers"], "element_names": session["element_names"], "positions": session["positions"], "labels": session["labels"], "bonds": active_bond_pairs(session), "traces": session["traces"], "covalent_radii_angstrom": session["covalent_radii_angstrom"], "vdw_radii_angstrom": session["vdw_radii_angstrom"], "radius_angstrom": session["radius_angstrom"], "unit_scale": session["unit_scale"], "radius_nm": session["radius_nm"], "extent_nm": session["extent_nm"], "center_offset_angstrom": session["center_offset_angstrom"], "base_bond_count": session["base_bond_count"], "bond_capacity": session["base_bond_count"] + 16, "structural_edits": session["structural_edits"], "coordinate_edits": session["coordinate_edits"], }, "parameters": { "thermal_scale": session["thermal_scale"], "bond_stiffness": session["bond_stiffness"], }, }
pub def load_molecular_session(key: str) -> dict[str, any] !{fs.read}: entry = structure_entry(key) asset_path = "viewer/public" + entry["path"] ensure file_sha256(asset_path) == entry["sha256"] source = read_json(asset_path) ensure source["schema"] == "sema.molecular-structure/v1" ensure source["key"] == entry["key"] and source["pdb_id"] == entry["pdb_id"] ensure source["source_sha256"] == entry["source"]["sha256"] atomic_record = source["atomic_numbers"] position_record = source["positions_angstrom"] bond_record = source["bonds"] validate_record(atomic_record, "base64-u1", 1, 4096) validate_record(position_record, "base64-<f4", 3, 4096) validate_record(bond_record, "base64-<u2", 2, 8192) atomic_numbers = decode_bytes(atomic_record["base64"], atomic_record["sha256"], atomic_record["items"]) positions = decode_f32_le(position_record["base64"], position_record["sha256"], position_record["items"] * 3) bonds = decode_u16_le(bond_record["base64"], bond_record["sha256"], bond_record["items"] * 2) ensure len(atomic_numbers) == entry["atoms"] and len(source["labels"]) == len(atomic_numbers) ensure len(positions) == len(atomic_numbers) * 3 and len(bonds) == entry["bonds"] * 2 mut radius_squared = 0.0 mut minimum = [positions[0], positions[1], positions[2]] mut maximum = [positions[0], positions[1], positions[2]] for atom_index in range(len(atomic_numbers)): offset = atom_index * 3 candidate = positions[offset] * positions[offset] + positions[offset + 1] * positions[offset + 1] + positions[offset + 2] * positions[offset + 2] radius_squared = max(radius_squared, candidate) for axis in range(3): minimum[axis] = min(minimum[axis], positions[offset + axis]) maximum[axis] = max(maximum[axis], positions[offset + axis]) radius_angstrom = math.sqrt(radius_squared) ensure radius_angstrom > 0.0 mut rest_lengths: list[f64] = [] for bond_index in range(len(bonds) // 2): left = bonds[bond_index * 2] right = bonds[bond_index * 2 + 1] ensure left >= 0 and left < len(atomic_numbers) and right >= 0 and right < len(atomic_numbers) and left != right left_offset = left * 3 right_offset = right * 3 dx = positions[right_offset] - positions[left_offset] dy = positions[right_offset + 1] - positions[left_offset + 1] dz = positions[right_offset + 2] - positions[left_offset + 2] rest_lengths.append(math.sqrt(dx * dx + dy * dy + dz * dz)) session = { "key": entry["key"], "label": entry["label"], "pdb_id": entry["pdb_id"], "source_sha256": source["source_sha256"], "asset_sha256": entry["sha256"], "fidelity": entry["fidelity"], "biological_match": entry["biological_match"], "source_page": entry["source_page"], "atomic_numbers": atomic_numbers, "positions": positions, "base_positions": [coordinate for coordinate in positions], "velocities": [0.0 for coordinate in positions], "labels": source["labels"], "bond_pairs": bonds, "active_bonds": [true for bond_index in range(len(bonds) // 2)], "rest_lengths": rest_lengths, "base_bond_count": len(bonds) // 2, "traces": decoded_traces(source["traces"]), "covalent_radii_angstrom": [atomic_radius(atomic_number, "covalent") for atomic_number in atomic_numbers], "vdw_radii_angstrom": [atomic_radius(atomic_number, "vdw") for atomic_number in atomic_numbers], "element_names": [atomic_name(atomic_number) for atomic_number in atomic_numbers], "radius_angstrom": radius_angstrom, "radius_nm": radius_angstrom * 0.1, "extent_nm": [(maximum[axis] - minimum[axis]) * 0.1 for axis in range(3)], "center_offset_angstrom": [0.0, 0.0, 0.0], "unit_scale": 0.1, "thermal_scale": 1.0, "bond_stiffness": 1.0, "structural_edits": 0, "coordinate_edits": 0, "state_version": 0, "sequence": 0, "time_s": 0.0, "topology_sha256": "", } session["topology_sha256"] = topology_digest(session) return session
def clone_molecular_session(session: dict[str, any]): return { "key": session["key"], "label": session["label"], "pdb_id": session["pdb_id"], "source_sha256": session["source_sha256"], "asset_sha256": session["asset_sha256"], "fidelity": session["fidelity"], "biological_match": session["biological_match"], "source_page": session["source_page"], "atomic_numbers": session["atomic_numbers"], "positions": [coordinate for coordinate in session["positions"]], "base_positions": session["base_positions"], "velocities": [velocity for velocity in session["velocities"]], "labels": session["labels"], "bond_pairs": [atom_index for atom_index in session["bond_pairs"]], "active_bonds": [active for active in session["active_bonds"]], "rest_lengths": [length for length in session["rest_lengths"]], "base_bond_count": session["base_bond_count"], "traces": session["traces"], "covalent_radii_angstrom": session["covalent_radii_angstrom"], "vdw_radii_angstrom": session["vdw_radii_angstrom"], "element_names": session["element_names"], "radius_angstrom": session["radius_angstrom"], "unit_scale": session["unit_scale"], "radius_nm": session["radius_nm"], "extent_nm": session["extent_nm"], "center_offset_angstrom": session["center_offset_angstrom"], "thermal_scale": session["thermal_scale"], "bond_stiffness": session["bond_stiffness"], "structural_edits": session["structural_edits"], "coordinate_edits": session["coordinate_edits"], "state_version": session["state_version"], "sequence": session["sequence"], "time_s": session["time_s"], "topology_sha256": session["topology_sha256"], }
def find_bond_index(session: dict[str, any], left: int, right: int): for index in range(len(session["active_bonds"])): first = session["bond_pairs"][index * 2] second = session["bond_pairs"][index * 2 + 1] if session["active_bonds"][index] and ((first == left and second == right) or (first == right and second == left)): return index return -1
def operation_valid(session: dict[str, any], operation: dict[str, any]): if not operation.has("kind"): return false kind = operation["kind"] if kind == "set_thermal_scale" or kind == "set_bond_stiffness": return operation.has("value") and operation["value"] >= 0.0 and operation["value"] <= 4.0 if kind == "translate_atom": if not all(operation.has(field) for field in ["atom_index", "delta_angstrom"]): return false atom_index = operation["atom_index"] delta = operation["delta_angstrom"] return atom_index >= 0 and atom_index < len(session["atomic_numbers"]) and len(delta) == 3 and max(abs(delta[0]), abs(delta[1]), abs(delta[2])) <= 10.0 if kind == "remove_bond" or kind == "add_bond": if not operation.has("left") or not operation.has("right"): return false left = operation["left"] right = operation["right"] if left < 0 or left >= len(session["atomic_numbers"]) or right < 0 or right >= len(session["atomic_numbers"]) or left == right: return false existing = find_bond_index(session, left, right) return existing >= 0 if kind == "remove_bond" else existing < 0 and session["structural_edits"] < 16 return false
def apply_operation(session: dict[str, any], operation: dict[str, any]) !{}: kind = operation["kind"] if kind == "set_thermal_scale": session["thermal_scale"] = operation["value"] return "thermal_scale=" + str(operation["value"]) if kind == "set_bond_stiffness": session["bond_stiffness"] = operation["value"] return "bond_stiffness=" + str(operation["value"]) if kind == "translate_atom": offset = operation["atom_index"] * 3 for axis in range(3): session["positions"][offset + axis] = session["positions"][offset + axis] + operation["delta_angstrom"][axis] session["coordinate_edits"] = session["coordinate_edits"] + 1 return "translated_atom=" + str(operation["atom_index"]) left = operation["left"] right = operation["right"] if kind == "remove_bond": session["active_bonds"][find_bond_index(session, left, right)] = false session["structural_edits"] = session["structural_edits"] + 1 return "removed_bond=" + str(left) + ":" + str(right) left_offset = left * 3 right_offset = right * 3 dx = session["positions"][right_offset] - session["positions"][left_offset] dy = session["positions"][right_offset + 1] - session["positions"][left_offset + 1] dz = session["positions"][right_offset + 2] - session["positions"][left_offset + 2] session["bond_pairs"].append(left) session["bond_pairs"].append(right) session["active_bonds"].append(true) session["rest_lengths"].append(math.sqrt(dx * dx + dy * dy + dz * dz)) session["structural_edits"] = session["structural_edits"] + 1 return "added_bond=" + str(left) + ":" + str(right)
pub def apply_molecular_program(session: dict[str, any], payload: dict[str, any]) -> dict[str, any] !{}: if not payload.has("state_version") or not payload.has("operations"): return {"ok": false, "error": "MolecularProgramInvalid", "detail": "state_version and operations are required"} if payload["state_version"] != session["state_version"]: return {"ok": false, "error": "MolecularStateConflict", "detail": "molecular state version does not match"} operations = payload["operations"] if len(operations) == 0 or len(operations) > 8: return {"ok": false, "error": "MolecularProgramInvalid", "detail": "operations must contain 1..8 bounded edits"} next_session = clone_molecular_session(session) mut summary: list[str] = [] for operation in operations: if not operation_valid(next_session, operation): return {"ok": false, "error": "MolecularProgramInvalid", "detail": "an operation is unsupported, out of bounds, or conflicts with topology"} summary.append(apply_operation(next_session, operation)) next_session["state_version"] = next_session["state_version"] + 1 next_session["topology_sha256"] = topology_digest(next_session) return {"ok": true, "session": next_session, "summary": summary}
pub def step_molecular_session(session: dict[str, any], dt_s: f64) -> dict[str, any] !{}: require dt_s > 0.0 and dt_s <= 0.1 atom_count = len(session["atomic_numbers"]) mut forces = [0.0 for coordinate in session["positions"]] next_time = session["time_s"] + dt_s thermal = 0.24 * session["thermal_scale"] for atom_index in range(atom_count): offset = atom_index * 3 phase = atom_index * 0.754877666 + next_time * (1.7 + (atom_index % 11) * 0.03) forces[offset] = (session["base_positions"][offset] - session["positions"][offset]) * 0.35 + math.sin(phase) * thermal forces[offset + 1] = (session["base_positions"][offset + 1] - session["positions"][offset + 1]) * 0.35 + math.cos(phase * 1.17) * thermal forces[offset + 2] = (session["base_positions"][offset + 2] - session["positions"][offset + 2]) * 0.35 + math.sin(phase * 0.73) * thermal for bond in range(len(session["active_bonds"])): if not session["active_bonds"][bond]: continue left = session["bond_pairs"][bond * 2] right = session["bond_pairs"][bond * 2 + 1] left_offset = left * 3 right_offset = right * 3 dx = session["positions"][right_offset] - session["positions"][left_offset] dy = session["positions"][right_offset + 1] - session["positions"][left_offset + 1] dz = session["positions"][right_offset + 2] - session["positions"][left_offset + 2] distance = math.sqrt(dx * dx + dy * dy + dz * dz) if distance > 0.000001: spring = (distance - session["rest_lengths"][bond]) * session["bond_stiffness"] * 1.8 / distance forces[left_offset] = forces[left_offset] + dx * spring forces[left_offset + 1] = forces[left_offset + 1] + dy * spring forces[left_offset + 2] = forces[left_offset + 2] + dz * spring forces[right_offset] = forces[right_offset] - dx * spring forces[right_offset + 1] = forces[right_offset + 1] - dy * spring forces[right_offset + 2] = forces[right_offset + 2] - dz * spring mut next_positions: list[f64] = [] mut next_velocities: list[f64] = [] for coordinate in range(len(session["positions"])): velocity = (session["velocities"][coordinate] + forces[coordinate] * dt_s) * 0.975 displacement = clamp(velocity * dt_s, -0.08, 0.08) next_velocities.append(velocity) next_positions.append(session["positions"][coordinate] + displacement) session["positions"] = next_positions session["velocities"] = next_velocities session["time_s"] = next_time session["sequence"] = session["sequence"] + 1 return sessionsrc/openmm.sema
Section titled “src/openmm.sema”"""Pinned OpenMM bridge contracts for the first scientific vertical."""
assure silver
pub struct BackendProbe: available: bool engine: str version: str platforms: list[str] detail: str invariant len(engine) > 0 invariant len(version) > 0 invariant len(detail) > 0
pub struct OpenMMRun: schema: str benchmark_id: str profile_id: str engine_version: str platform: str platform_properties: list[str] config_sha256: str input_sha256: str system_sha256: str atom_count: int bond_count: int steps: int frames: int initial_potential_energy_kj_mol: f64 initial_max_force_kj_mol_nm: f64 initial_force_sha256: str minimized_potential_energy_kj_mol: f64 minimized_max_force_kj_mol_nm: f64 minimized_force_sha256: str nve_initial_total_energy_kj_mol: f64 nve_final_total_energy_kj_mol: f64 nve_drift_kj_mol: f64 frames_sha256: str state_arrays_sha256: str frames_path: str initial_forces_path: str minimized_forces_path: str result_sha256: str invariant schema == "sema.openmm-benchmark/v1" invariant platform == "CPU" or platform == "Reference" invariant atom_count > 0 invariant bond_count > 0 invariant steps >= 0 invariant frames > 0 invariant len(config_sha256) == 64 invariant len(input_sha256) == 64 invariant len(system_sha256) == 64 invariant len(initial_force_sha256) == 64 invariant len(minimized_force_sha256) == 64 invariant len(frames_sha256) == 64 invariant len(state_arrays_sha256) == 64 invariant len(result_sha256) == 64
pub bridge python.inline openmm_adapter from "foreign/python/openmm_adapter.py": deps "python>=3.12,<3.13" expose: def backend_probe() -> BackendProbe !{ffi.call}: sem "Import pinned OpenMM and enumerate real runtime platforms" ensure len(result.detail) > 0 ensure result.engine == "OpenMM"
pub bridge python.inline openmm_backend from "foreign/python/scientific_backend.py": deps "python>=3.12,<3.13" expose: def run_openmm_cpu() -> OpenMMRun !{ffi.call}: sem "Run the fixed bounded benchmark on the qualified CPU platform" ensure result.platform == "CPU" ensure result.frames > 0 ensure len(result.result_sha256) == 64src/phase10.sema
Section titled “src/phase10.sema”"""Fail-closed qualification of measured Phase 10 renderer and interaction evidence."""
from std.crypto import file_sha256, sha256_jsonfrom std.json import decode as decode_jsonfrom std.toml import read as read_toml
assure silver
pub struct Phase10QualificationResult: schema: str profile_id: str config_sha256: str evidence_sha256: str scene_sha256: str bundle_sha256: str external_reference_sha256: str scientific_result_sha256: str screenshot_sha256: list[str] scale_count: int minimum_average_fps: f64 interaction_hz: int canonical_update_hz: int pick_p95_ms: f64 dropped_frames: int gpu_allocated_bytes: int gpu_resource_count: int context_loss_recovered: bool semantic_validation_pass: bool viewer_disabled_parity_pass: bool pixel_equality_observed: bool visual_regression_replay_pass: bool capture_provenance_status: str profile_validated: bool scientific_validated: bool invariant schema == "sema.phase10-qualification-result/v2" invariant profile_id == "apple_m3_max_chrome_webgl2_v1" invariant len(config_sha256) == 64 and len(evidence_sha256) == 64 invariant len(scene_sha256) == 64 and len(bundle_sha256) == 64 invariant len(external_reference_sha256) == 64 and len(scientific_result_sha256) == 64 invariant len(screenshot_sha256) == 4 and all(len(digest) == 64 for digest in screenshot_sha256) invariant scale_count == 4 and minimum_average_fps >= 30.0 invariant interaction_hz == 60 and canonical_update_hz == 10 invariant pick_p95_ms >= 0.0 and pick_p95_ms <= 16.67 invariant dropped_frames >= 0 and dropped_frames <= 16 invariant gpu_allocated_bytes > 0 and gpu_resource_count > 0 invariant context_loss_recovered and semantic_validation_pass and viewer_disabled_parity_pass invariant pixel_equality_observed invariant capture_provenance_status == "technical_untrusted" invariant visual_regression_replay_pass == false invariant profile_validated == false invariant scientific_validated == false
def covers_four_scales(records: list[any], key: str): mut atomic = 0 mut molecular = 0 mut cellular = 0 mut tissue = 0 for record in records: if record[key] == "atomic": atomic = atomic + 1 elif record[key] == "molecular": molecular = molecular + 1 elif record[key] == "cellular": cellular = cellular + 1 elif record[key] == "tissue": tissue = tissue + 1 else: return false return atomic >= 1 and molecular >= 1 and cellular >= 1 and tissue >= 1
pub def qualify_phase10(config_path: str = "phase10.toml") -> Phase10QualificationResult !{fs.read}: sem "Validate bounded renderer evidence without promoting modeled biology to scientific evidence" config = read_toml(config_path) ensure len(config) == 14 ensure config["schema"] == "sema.phase10-qualification-profile/v1" ensure config["profile_id"] == "apple_m3_max_chrome_webgl2_v1" ensure config["scales"] == ["atomic", "molecular", "cellular", "tissue"] ensure config["capture_provenance_trust"] == "technical_untrusted" ensure len(config["reference"]) == 6 and len(config["thresholds"]) == 29 ensure len(config["artifacts"]) == 2 and len(config["screenshots"]) == 4 ensure config["reference"]["role"] == "external_reference_only" ensure config["reference"]["geometry_input"] == false ensure path.is_relative_to(config["evidence_path"], "runs/phase10") ensure path.is_relative_to(config["visual_regression_replay_path"], "runs/phase10") ensure path.is_relative_to(config["reference_refresh_path"], "runs/phase10") ensure path.is_relative_to(config["scene_path"], "viewer/public/data") ensure path.is_relative_to(config["reference"]["local_preview_path"], "viewer/public/data")
payload = fs.read_text(config["evidence_path"])? ensure len(payload) > 0 and len(payload) <= config["thresholds"]["maximum_evidence_bytes"] evidence = decode_json(payload) ensure len(evidence) == 19 ensure evidence["schema"] == "sema.phase10-render-evidence/v4" canonical_evidence = {key: value for key, value in evidence.items() if key != "evidence_sha256"} ensure sha256_json(canonical_evidence) == evidence["evidence_sha256"] ensure evidence["profile_id"] == config["profile_id"] ensure evidence["capture_provenance_status"] == config["capture_provenance_trust"] ensure evidence["profile_validated"] == false ensure evidence["scientific_validated"] == false
scene_record = evidence["scene"] ensure len(scene_record) == 4 ensure scene_record["path"] == config["scene_path"] ensure file_sha256(scene_record["path"]) == scene_record["sha256"] ensure scene_record["sha256"] == config["artifacts"]["scene_sha256"] scene = decode_json(fs.read_text(scene_record["path"])? ) ensure scene["schema"] == "sema.multiscale-viewer/v4" canonical_scene = {key: value for key, value in scene.items() if key != "scene_sha256"} ensure sha256_json(canonical_scene) == scene["scene_sha256"] ensure scene_record["canonical_sha256"] == scene["scene_sha256"] ensure scene_record["scientific_result_sha256"] == scene["source"]["result_sha256"]
bundle = evidence["viewer_bundle"] ensure len(bundle) == 2 bundle_manifest = bundle["manifest"] ensure len(bundle_manifest) == 2 ensure bundle_manifest["schema"] == "sema.phase10-viewer-bundle-manifest/v1" bundle_entries = bundle_manifest["entries"] ensure len(bundle_entries) == 6 ensure all( len(entry) == 4 and path.is_relative_to(entry["path"], config["bundle_root"]) and entry["path"] == "viewer/dist" + entry["served_path"] and entry["served_path"].startswith("/") and len(entry["sha256"]) == 64 and entry["byte_length"] > 0 and file_sha256(entry["path"]) == entry["sha256"] and len([other for other in bundle_entries if other["path"] == entry["path"] and other["served_path"] == entry["served_path"]]) == 1 for entry in bundle_entries ) ensure len([entry for entry in bundle_entries if entry["path"] == "viewer/dist/index.html" and entry["served_path"] == "/index.html"]) == 1 ensure len([entry for entry in bundle_entries if entry["path"].endswith(".css") and entry["served_path"].startswith("/assets/")]) == 1 ensure len([entry for entry in bundle_entries if entry["path"].endswith(".js") and entry["served_path"].startswith("/assets/")]) == 1 ensure len([entry for entry in bundle_entries if entry["served_path"] == "/data/scene.json" and entry["sha256"] == scene_record["sha256"]]) == 1 ensure len([entry for entry in bundle_entries if entry["served_path"] == "/data/scene.json.sha256" and entry["sha256"] == file_sha256("viewer/public/data/scene.json.sha256")]) == 1 ensure len([entry for entry in bundle_entries if entry["served_path"] == "/data/idr0116-deboer-npod-preview.jpg" and entry["sha256"] == config["reference"]["preview_sha256"]]) == 1 ensure sha256_json(bundle_manifest) == bundle["sha256"] ensure bundle["sha256"] == config["artifacts"]["bundle_sha256"]
baseline_capture = evidence["capture"] ensure len(baseline_capture) == 17 ensure baseline_capture["schema"] == "sema.phase10-capture-provenance/v2" ensure baseline_capture["mode"] == "baseline" ensure baseline_capture["completed"] and baseline_capture["fresh_stack"] ensure baseline_capture["validator_sha256"] == file_sha256("viewer/validate-phase10.mjs") ensure baseline_capture["profile_sha256"] == file_sha256(config_path)
reference = evidence["external_reference"] ensure len(reference) == 5 ensure reference["role"] == config["reference"]["role"] ensure reference["geometry_input"] == false reference_metadata = {key: value for key, value in reference["metadata"].items() if key != "preview_sha256"} ensure reference_metadata == scene["measurement_sources"][0] ensure reference_metadata["id"] == config["reference"]["id"] ensure reference_metadata["fidelity"] == "measured" ensure reference["metadata"]["preview_sha256"] == config["reference"]["preview_sha256"] ensure reference["metadata_sha256"] == sha256_json(reference_metadata) ensure reference["metadata_sha256"] == config["reference"]["metadata_sha256"] local_preview = reference["local_preview"] ensure len(local_preview) == 7 ensure local_preview["path"] == config["reference"]["local_preview_path"] ensure local_preview["served_path"] == reference_metadata["local_preview_url"] ensure local_preview["served_path"].startswith("/data/") and not local_preview["served_path"].contains("..") ensure file_sha256(local_preview["path"]) == local_preview["sha256"] ensure local_preview["sha256"] == config["reference"]["preview_sha256"] ensure local_preview["byte_length"] > 1024 and local_preview["byte_length"] <= config["thresholds"]["maximum_evidence_bytes"] ensure ( local_preview["source"] == "pinned_local_after_remote_refresh" or local_preview["source"] == "pinned_local_offline" ) served_resource = local_preview["served_resource"] ensure len(served_resource) == 7 ensure served_resource["url"].startswith("http://127.0.0.1:") ensure served_resource["url"].endswith(local_preview["served_path"]) ensure len(served_resource["request_id"]) > 0 ensure served_resource["status"] == 200 and served_resource["mime_type"].startswith("image/") ensure served_resource["encoded_data_length"] > 0 ensure served_resource["sha256"] == local_preview["sha256"] ensure len(served_resource["decoded_images"]) == 2 ensure all( len(image) == 5 and image["complete"] and image["src"] == served_resource["url"] and image["natural_width"] > 0 and image["natural_height"] > 0 for image in served_resource["decoded_images"] ) mut retained_refresh_sha256 = "" if local_preview["source"] == "pinned_local_after_remote_refresh": ensure len(local_preview["refresh_evidence_sha256"]) == 64 refresh_payload = fs.read_text(config["reference_refresh_path"])? ensure len(refresh_payload) > 0 and len(refresh_payload) <= config["thresholds"]["maximum_evidence_bytes"] refresh = decode_json(refresh_payload) ensure len(refresh) == 11 and refresh["schema"] == "sema.phase10-reference-refresh/v1" canonical_refresh = {key: value for key, value in refresh.items() if key != "evidence_sha256"} ensure sha256_json(canonical_refresh) == refresh["evidence_sha256"] ensure refresh["source_url"] == reference_metadata["preview_url"] ensure refresh["local_path"] == config["reference"]["local_preview_path"] ensure refresh["preview_sha256"] == config["reference"]["preview_sha256"] ensure refresh["preview_sha256"] == file_sha256(refresh["local_path"]) ensure refresh["byte_length"] == local_preview["byte_length"] ensure refresh["content_type"].startswith("image/") ensure refresh["scientific_validated"] == false retained_refresh_sha256 = refresh["evidence_sha256"]
ensure ( baseline_capture["network_mode"] == "remote_refresh_verified_then_browser_offline" or baseline_capture["network_mode"] == "offline_pinned_local" ) baseline_network_policy = baseline_capture["network_policy"] ensure len(baseline_network_policy) == 10 ensure baseline_network_policy["enforcement"] == "cdp_auto_attach_fetch_fail_exact_origin_method_path_before_resume" ensure baseline_network_policy["forbidden_protocols"] == ["ws:", "wss:"] baseline_origins = baseline_network_policy["spawned_origins"] ensure len(baseline_origins) == 2 baseline_viewer_origin = baseline_origins["viewer"] baseline_live_origin = baseline_origins["live"] viewer_origin_parts = baseline_viewer_origin.split(":") live_origin_parts = baseline_live_origin.split(":") ensure len(viewer_origin_parts) == 3 and viewer_origin_parts[0] == "http" and viewer_origin_parts[1] == "//127.0.0.1" ensure len(live_origin_parts) == 3 and live_origin_parts[0] == "http" and live_origin_parts[1] == "//127.0.0.1" ensure int(viewer_origin_parts[2]) >= 4177 and int(viewer_origin_parts[2]) <= 4187 ensure int(live_origin_parts[2]) >= 8791 and int(live_origin_parts[2]) <= 8801 baseline_contracts = baseline_network_policy["allowed_request_contracts"] ensure len(baseline_contracts) == 14 ensure all( len(contract) == 4 and contract["origin"] == baseline_viewer_origin and contract["method"] in ["GET", "POST"] and contract["path"].startswith("/") and (contract["search"] == "" or contract["search"] == "?phase10-viewer=disabled") and len([other for other in baseline_contracts if other == contract]) == 1 for contract in baseline_contracts ) ensure len([contract for contract in baseline_contracts if contract["method"] == "GET" and contract["path"] == "/" and contract["search"] == ""]) == 1 ensure len([contract for contract in baseline_contracts if contract["method"] == "GET" and contract["path"] == "/" and contract["search"] == "?phase10-viewer=disabled"]) == 1 ensure all( ( entry["served_path"] == "/index.html" and len([contract for contract in baseline_contracts if contract["method"] == "GET" and contract["path"] == entry["served_path"] and contract["search"] == ""]) == 0 ) or ( entry["served_path"] != "/index.html" and len([contract for contract in baseline_contracts if contract["method"] == "GET" and contract["path"] == entry["served_path"] and contract["search"] == ""]) == 1 ) for entry in bundle_entries ) ensure len([contract for contract in baseline_contracts if contract["method"] == "GET" and contract["path"] == "/api/sema/status" and contract["search"] == ""]) == 1 ensure len([contract for contract in baseline_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/step" and contract["search"] == ""]) == 1 ensure len([contract for contract in baseline_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/intervene" and contract["search"] == ""]) == 1 ensure len([contract for contract in baseline_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/molecule" and contract["search"] == ""]) == 1 ensure len([contract for contract in baseline_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/molecule/step" and contract["search"] == ""]) == 1 ensure len([contract for contract in baseline_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/program" and contract["search"] == ""]) == 1 ensure len([contract for contract in baseline_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/cortex/propose" and contract["search"] == ""]) == 1 baseline_qualified_contracts = baseline_network_policy["qualified_control_contracts"] ensure len(baseline_qualified_contracts) == 2 ensure all(len(contract) == 4 and contract["origin"] == baseline_viewer_origin and contract["method"] == "POST" and contract["search"] == "" for contract in baseline_qualified_contracts) ensure len([contract for contract in baseline_qualified_contracts if contract["path"] == "/api/sema/program"]) == 1 ensure len([contract for contract in baseline_qualified_contracts if contract["path"] == "/api/sema/cortex/propose"]) == 1 ensure all(len([allowed for allowed in baseline_contracts if allowed == contract]) == 1 for contract in baseline_qualified_contracts) baseline_control_actions = baseline_network_policy["qualified_control_actions"] ensure len(baseline_control_actions) == 5 ensure all( len(action) == 14 and len(action["contract"]) == 4 and len([contract for contract in baseline_qualified_contracts if contract == action["contract"]]) == 1 and action["request_url"] == action["contract"]["origin"] + action["contract"]["path"] and action["request_method"] == "POST" and len(action["request_id"]) > 0 and action["request_body_byte_length"] > 0 and action["request_body_byte_length"] <= 8192 and len(action["request_body_sha256"]) == 64 and action["status"] >= 200 and action["status"] < 300 and len(action["response_mime_type"]) > 0 and action["response_encoded_data_length"] > 0 and action["completion_observed"] and len(action["session_id"]) > 0 and len(action["target_id"]) > 0 for action in baseline_control_actions ) ensure len([action for action in baseline_control_actions if action["action_id"] == "scenario_select" and action["control_id"] == "scenario-control" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure len([action for action in baseline_control_actions if action["action_id"] == "compile_apply" and action["control_id"] == "edit-apply" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure len([action for action in baseline_control_actions if action["action_id"] == "cortex_propose" and action["control_id"] == "edit-propose" and action["contract"]["path"] == "/api/sema/cortex/propose"]) == 1 ensure len([action for action in baseline_control_actions if action["action_id"] == "assistant_apply" and action["control_id"] == "assistant-apply" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure len([action for action in baseline_control_actions if action["action_id"] == "program_reset" and action["control_id"] == "edit-reset" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure all(len([action for action in baseline_control_actions if action["contract"] == contract]) >= 1 for contract in baseline_qualified_contracts) baseline_completed_contracts = baseline_network_policy["completed_request_contracts"] ensure baseline_network_policy["exact_contract_coverage_pass"] ensure len(baseline_completed_contracts) == len(baseline_contracts) ensure all( len(completed) == 15 and completed["origin"] == baseline_viewer_origin and completed["method"] in ["GET", "POST"] and completed["path"].startswith("/") and (completed["search"] == "" or completed["search"] == "?phase10-viewer=disabled") and completed["url"].startswith(completed["origin"] + completed["path"]) and len(completed["request_id"]) > 0 and completed["request_body_byte_length"] >= 0 and completed["request_body_byte_length"] <= 8192 and ( completed["method"] == "GET" or (completed["request_body_byte_length"] > 0 and len(completed["request_body_sha256"]) == 64) ) and completed["status"] >= 200 and completed["status"] < 300 and completed["encoded_data_length"] > 0 and len(completed["session_id"]) > 0 and len(completed["target_id"]) > 0 and completed["target_type"] == "page" and completed["completion_observed"] and len([contract for contract in baseline_contracts if contract["origin"] == completed["origin"] and contract["method"] == completed["method"] and contract["path"] == completed["path"] and contract["search"] == completed["search"]]) == 1 for completed in baseline_completed_contracts ) ensure all( len([completed for completed in baseline_completed_contracts if completed["origin"] == contract["origin"] and completed["method"] == contract["method"] and completed["path"] == contract["path"] and completed["search"] == contract["search"]]) == 1 for contract in baseline_contracts ) baseline_targets = baseline_network_policy["governed_targets"] ensure len(baseline_targets) >= 3 ensure all( len(target) == 6 and len(target["session_id"]) > 0 and len(target["target_id"]) > 0 and target["target_type"] in ["page", "iframe", "worker", "shared_worker", "service_worker"] and ( (target["target_type"] in ["worker", "shared_worker", "service_worker"] and target["policy_mechanism"] == "network_block_all_worker_before_resume") or (target["target_type"] in ["page", "iframe"] and target["policy_mechanism"] == "fetch_request_pause_exact_contract") ) and target["policy_installed"] and target["resumed"] for target in baseline_targets ) baseline_blocked_probes = baseline_network_policy["blocked_probes"] ensure len(baseline_blocked_probes) == 9 ensure all( len(probe) == 12 and probe["method"] == "GET" and probe["rejection_reason"] in ["outside_exact_contract", "websocket_forbidden"] and len(probe["request_id"]) > 0 and len(probe["session_id"]) > 0 and len(probe["target_id"]) > 0 and len(probe["policy_target_id"]) > 0 and probe["policy_target_type"] in ["page", "worker"] for probe in baseline_blocked_probes ) ensure any(probe["probe_id"] == "page_hostname" and probe["context"] == "page" and probe["url"] == "https://phase10-page-probe.invalid/page-hostname" for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "page_direct_ip" and probe["context"] == "page" and probe["url"] == "http://93.184.216.34/page-direct-ip" for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "page_rogue_loopback" and probe["context"] == "page" and probe["url"] == "http://127.0.0.1:65534/phase10-page-rogue" for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "page_localhost_alias" and probe["context"] == "page" and probe["url"].startswith("http://localhost:") and probe["url"].endswith("/") for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "page_websocket" and probe["context"] == "page" and probe["url"].startswith("ws://127.0.0.1:") and probe["url"].endswith("/phase10-websocket-rogue") and probe["rejection_reason"] == "websocket_forbidden" for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "blank_hostname" and probe["context"] == "_blank" and probe["url"] == "https://phase10-popup-probe.invalid/popup-target-blank" for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "blank_rogue_loopback" and probe["context"] == "_blank" and probe["url"] == baseline_viewer_origin + "/phase10-popup-rogue" for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "worker_direct_ip" and probe["context"] == "worker" and probe["url"] == "http://93.184.216.34/worker-direct-ip" for probe in baseline_blocked_probes) ensure any(probe["probe_id"] == "worker_rogue_loopback" and probe["context"] == "worker" and probe["url"] == baseline_live_origin + "/phase10-worker-rogue" for probe in baseline_blocked_probes) ensure len(baseline_capture["runtime"]) == 3 ensure baseline_capture["runtime"]["platform"] == "darwin" ensure baseline_capture["runtime"]["architecture"] == "arm64" ensure baseline_capture["runtime"]["node_version"].startswith("v") ensure len(baseline_capture["validator_run_id"]) == 36 ensure len(baseline_capture["session_id"]) == 36 ensure len(baseline_capture["capture_id"]) == 36 ensure len(baseline_capture["stack_id"]) == 36 ensure baseline_capture["validator_run_id"] != baseline_capture["session_id"] ensure baseline_capture["validator_run_id"] != baseline_capture["capture_id"] ensure baseline_capture["session_id"] != baseline_capture["capture_id"] ensure baseline_capture["stack_id"] != baseline_capture["capture_id"] ensure baseline_capture["completed_at"] > baseline_capture["started_at"] ensure baseline_capture["reference_preview"] == local_preview if baseline_capture["reference_preview"]["source"] == "pinned_local_after_remote_refresh": ensure baseline_capture["reference_preview"]["refresh_evidence_sha256"] == retained_refresh_sha256 baseline_groups = baseline_capture["process_groups"] ensure len(baseline_groups) >= 5 ensure all(len(group) == 3 and group["process_group_id"] > 0 for group in baseline_groups) ensure len([group for group in baseline_groups if group["role"] == "typecheck"]) == 1 ensure len([group for group in baseline_groups if group["role"] == "production-build"]) == 1 ensure len([group for group in baseline_groups if group["role"] == "sema"]) == 1 ensure len([group for group in baseline_groups if group["role"] == "vite"]) == 1 ensure len([group for group in baseline_groups if group["role"] == "chrome"]) == 1
modeled = evidence["modeled_layers"] ensure len(modeled) == 2 ensure any(layer["layer_id"] == "cellular" and layer["scientific_validated"] == false for layer in modeled) ensure any(layer["layer_id"] == "tissue" and layer["scientific_validated"] == false for layer in modeled) ensure all(len(layer) == 2 for layer in modeled)
thresholds = config["thresholds"] scales = evidence["scale_profiles"] ensure len(scales) == 4 and covers_four_scales(scales, "scale_id") mut minimum_fps = 1000000.0 mut dropped_frames = 0 mut maximum_gpu_bytes = 0 mut maximum_gpu_resources = 0 mut total_visible_instances = 0 for scale in scales: ensure len(scale) == 12 ensure scale["average_fps"] >= thresholds["minimum_scale_fps"] ensure scale["dropped_frames"] >= 0 and scale["dropped_frames"] <= thresholds["maximum_dropped_frames_per_scale"] ensure len(scale["frame_samples_ms"]) >= thresholds["minimum_scale_frame_samples"] ensure len(scale["frame_samples_ms"]) <= thresholds["maximum_scale_frame_samples"] ensure all(sample_ms > 0.0 for sample_ms in scale["frame_samples_ms"]) observed_fps = 1000.0 * f64(len(scale["frame_samples_ms"])) / sum(scale["frame_samples_ms"]) ensure observed_fps >= thresholds["minimum_scale_fps"] ensure abs(observed_fps - scale["average_fps"]) <= thresholds["maximum_reported_fps_residual"] ensure scale["gpu_allocated_bytes"] > 0 and scale["gpu_resource_count"] > 0 ensure scale["visible_instances"] > 0 and scale["visible_instances"] <= scale["max_visible_instances"] ensure len(scale["webgl_renderer"]) > 0 ensure scale["fov_value"] > 0.0 and scale["fov_value"] <= thresholds["maximum_fov_um"] ensure scale["fov_unit"] == "micrometer" ensure scale["deterministic_switch_pass"] total_visible_instances = total_visible_instances + scale["visible_instances"] minimum_fps = min(minimum_fps, observed_fps) dropped_frames = dropped_frames + scale["dropped_frames"] maximum_gpu_bytes = max(maximum_gpu_bytes, scale["gpu_allocated_bytes"]) maximum_gpu_resources = max(maximum_gpu_resources, scale["gpu_resource_count"])
interaction = evidence["interaction_profile"] ensure len(interaction) == 2 and interaction["hz"] == thresholds["interaction_hz"] ensure len(interaction["samples"]) >= thresholds["minimum_interaction_samples"] ensure len(interaction["samples"]) <= thresholds["maximum_interaction_samples"] ensure all(sample >= 0.0 for sample in interaction["samples"]) mut previous_interaction_ms = -1.0 for timestamp_ms in interaction["samples"]: ensure timestamp_ms > previous_interaction_ms previous_interaction_ms = timestamp_ms interaction_interval_ms = ( interaction["samples"][len(interaction["samples"]) - 1] - interaction["samples"][0] ) / f64(len(interaction["samples"]) - 1) ensure abs(interaction_interval_ms - 1000.0 / f64(interaction["hz"])) <= thresholds["maximum_interaction_interval_residual_ms"]
updates = evidence["canonical_updates"] ensure len(updates) == 2 and updates["hz"] == thresholds["canonical_update_hz"] ensure len(updates["samples"]) >= thresholds["minimum_canonical_updates"] ensure len(updates["samples"]) <= thresholds["maximum_canonical_updates"] mut previous_sequence = -1 mut previous_update_ms = -1.0 for update in updates["samples"]: ensure len(update) == 4 ensure update["sequence"] > previous_sequence and update["canonical"] == false ensure update["timestamp_ms"] > previous_update_ms ensure update["simulation_digest"] == scene_record["scientific_result_sha256"] previous_sequence = update["sequence"] previous_update_ms = update["timestamp_ms"] canonical_interval_ms = ( updates["samples"][len(updates["samples"]) - 1]["timestamp_ms"] - updates["samples"][0]["timestamp_ms"] ) / f64(len(updates["samples"]) - 1) ensure abs(canonical_interval_ms - 1000.0 / f64(updates["hz"])) <= thresholds["maximum_canonical_update_interval_residual_ms"]
pick = evidence["pick_latency"] ensure len(pick) == 2 ensure pick["p95_ms"] >= 0.0 and pick["p95_ms"] <= thresholds["maximum_pick_p95_ms"] ensure len(pick["samples_ms"]) >= thresholds["minimum_pick_samples"] ensure len(pick["samples_ms"]) <= thresholds["maximum_pick_samples"] ensure all(sample_ms >= 0.0 for sample_ms in pick["samples_ms"]) mut picks_within_reported_p95 = 0 for sample_ms in pick["samples_ms"]: if sample_ms <= pick["p95_ms"]: picks_within_reported_p95 = picks_within_reported_p95 + 1 ensure picks_within_reported_p95 * 100 >= len(pick["samples_ms"]) * 95
telemetry = evidence["gpu_telemetry"] ensure len(telemetry) == 2 renderer = telemetry["renderer"] ensure len(renderer) == 6 ensure len(renderer["version"]) > 0 and len(renderer["shading_language_version"]) > 0 ensure len(renderer["vendor"]) > 0 and len(renderer["renderer"]) > 0 ensure renderer["max_texture_size"] > 0 and renderer["max_renderbuffer_size"] > 0 ensure len(telemetry["samples"]) > 0 and len(telemetry["samples"]) <= thresholds["maximum_gpu_samples"] for sample in telemetry["samples"]: ensure len(sample) == 3 ensure sample["timestamp_ms"] >= 0.0 ensure sample["allocated_bytes"] > 0 and sample["resource_count"] > 0 maximum_gpu_bytes = max(maximum_gpu_bytes, sample["allocated_bytes"]) maximum_gpu_resources = max(maximum_gpu_resources, sample["resource_count"])
context_loss = evidence["context_loss"] ensure len(context_loss) == 6 and context_loss["classification"] == "expected_test" ensure context_loss["negative_observed"] and context_loss["recovered"] and context_loss["resources_reinitialized"] ensure context_loss["digest_before"] == scene_record["scientific_result_sha256"] ensure context_loss["digest_after"] == context_loss["digest_before"]
screenshots = evidence["screenshots"] ensure len(screenshots) == 4 and covers_four_scales(screenshots, "scale_id") screenshot_digests = [] for screenshot in screenshots: ensure len(screenshot) == 6 ensure path.is_relative_to(screenshot["path"], config["screenshot_root"]) ensure screenshot["path"].endswith(".png") ensure file_sha256(screenshot["path"]) == screenshot["sha256"] ensure screenshot["sha256"] == config["screenshots"][screenshot["scale_id"]] ensure screenshot["capture_id"] == baseline_capture["capture_id"] ensure len(screenshot["capture_nonce"]) == 36 ensure screenshot["captured_at"] >= baseline_capture["started_at"] ensure screenshot["captured_at"] <= baseline_capture["completed_at"] ensure len([other for other in screenshots if other["capture_nonce"] == screenshot["capture_nonce"]]) == 1 screenshot_digests.append(screenshot["sha256"])
replay_payload = fs.read_text(config["visual_regression_replay_path"])? ensure len(replay_payload) > 0 and len(replay_payload) <= thresholds["maximum_evidence_bytes"] regression = decode_json(replay_payload) ensure len(regression) == 12 ensure regression["schema"] == "sema.phase10-visual-regression-replay/v4" canonical_regression = {key: value for key, value in regression.items() if key != "evidence_sha256"} ensure sha256_json(canonical_regression) == regression["evidence_sha256"] ensure regression["profile_id"] == evidence["profile_id"] baseline_identity = regression["baseline_evidence"] ensure len(baseline_identity) == 6 ensure baseline_identity["path"] == config["evidence_path"] ensure baseline_identity["file_sha256"] == file_sha256(config["evidence_path"]) ensure baseline_identity["evidence_sha256"] == evidence["evidence_sha256"] ensure baseline_identity["capture_id"] == baseline_capture["capture_id"] ensure baseline_identity["validator_run_id"] == baseline_capture["validator_run_id"] ensure baseline_identity["session_id"] == baseline_capture["session_id"] replay_capture = regression["replay_capture"] ensure len(replay_capture) == 17 ensure replay_capture["schema"] == "sema.phase10-capture-provenance/v2" ensure replay_capture["mode"] == "replay" ensure replay_capture["completed"] and replay_capture["fresh_stack"] ensure replay_capture["validator_sha256"] == file_sha256("viewer/validate-phase10.mjs") ensure replay_capture["validator_sha256"] == baseline_capture["validator_sha256"] ensure replay_capture["profile_sha256"] == file_sha256(config_path) ensure replay_capture["profile_sha256"] == baseline_capture["profile_sha256"] ensure regression["scene_sha256"] == scene_record["sha256"] ensure regression["viewer_bundle"] == bundle ensure regression["viewer_bundle"]["sha256"] == sha256_json(regression["viewer_bundle"]["manifest"]) ensure regression["pixel_equality_observed"] ensure regression["capture_provenance_status"] == "technical_untrusted" ensure regression["visual_regression_replay_pass"] == false ensure regression["scientific_validated"] == false
ensure replay_capture["network_mode"] == "offline_pinned_local" replay_network_policy = replay_capture["network_policy"] ensure len(replay_network_policy) == 10 ensure replay_network_policy["enforcement"] == baseline_network_policy["enforcement"] ensure replay_network_policy["forbidden_protocols"] == baseline_network_policy["forbidden_protocols"] replay_origins = replay_network_policy["spawned_origins"] ensure len(replay_origins) == 2 replay_viewer_origin = replay_origins["viewer"] replay_live_origin = replay_origins["live"] replay_viewer_origin_parts = replay_viewer_origin.split(":") replay_live_origin_parts = replay_live_origin.split(":") ensure len(replay_viewer_origin_parts) == 3 and replay_viewer_origin_parts[0] == "http" and replay_viewer_origin_parts[1] == "//127.0.0.1" ensure len(replay_live_origin_parts) == 3 and replay_live_origin_parts[0] == "http" and replay_live_origin_parts[1] == "//127.0.0.1" ensure int(replay_viewer_origin_parts[2]) >= 4177 and int(replay_viewer_origin_parts[2]) <= 4187 ensure int(replay_live_origin_parts[2]) >= 8791 and int(replay_live_origin_parts[2]) <= 8801 replay_contracts = replay_network_policy["allowed_request_contracts"] ensure len(replay_contracts) == 14 ensure all( len(contract) == 4 and contract["origin"] == replay_viewer_origin and contract["method"] in ["GET", "POST"] and contract["path"].startswith("/") and (contract["search"] == "" or contract["search"] == "?phase10-viewer=disabled") and len([other for other in replay_contracts if other == contract]) == 1 for contract in replay_contracts ) ensure len([contract for contract in replay_contracts if contract["method"] == "GET" and contract["path"] == "/" and contract["search"] == ""]) == 1 ensure len([contract for contract in replay_contracts if contract["method"] == "GET" and contract["path"] == "/" and contract["search"] == "?phase10-viewer=disabled"]) == 1 ensure all( ( entry["served_path"] == "/index.html" and len([contract for contract in replay_contracts if contract["method"] == "GET" and contract["path"] == entry["served_path"] and contract["search"] == ""]) == 0 ) or ( entry["served_path"] != "/index.html" and len([contract for contract in replay_contracts if contract["method"] == "GET" and contract["path"] == entry["served_path"] and contract["search"] == ""]) == 1 ) for entry in bundle_entries ) ensure len([contract for contract in replay_contracts if contract["method"] == "GET" and contract["path"] == "/api/sema/status" and contract["search"] == ""]) == 1 ensure len([contract for contract in replay_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/step" and contract["search"] == ""]) == 1 ensure len([contract for contract in replay_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/intervene" and contract["search"] == ""]) == 1 ensure len([contract for contract in replay_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/molecule" and contract["search"] == ""]) == 1 ensure len([contract for contract in replay_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/molecule/step" and contract["search"] == ""]) == 1 ensure len([contract for contract in replay_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/program" and contract["search"] == ""]) == 1 ensure len([contract for contract in replay_contracts if contract["method"] == "POST" and contract["path"] == "/api/sema/cortex/propose" and contract["search"] == ""]) == 1 replay_qualified_contracts = replay_network_policy["qualified_control_contracts"] ensure len(replay_qualified_contracts) == 2 ensure all(len(contract) == 4 and contract["origin"] == replay_viewer_origin and contract["method"] == "POST" and contract["search"] == "" for contract in replay_qualified_contracts) ensure len([contract for contract in replay_qualified_contracts if contract["path"] == "/api/sema/program"]) == 1 ensure len([contract for contract in replay_qualified_contracts if contract["path"] == "/api/sema/cortex/propose"]) == 1 ensure all(len([allowed for allowed in replay_contracts if allowed == contract]) == 1 for contract in replay_qualified_contracts) replay_control_actions = replay_network_policy["qualified_control_actions"] ensure len(replay_control_actions) == 5 ensure all( len(action) == 14 and len(action["contract"]) == 4 and len([contract for contract in replay_qualified_contracts if contract == action["contract"]]) == 1 and action["request_url"] == action["contract"]["origin"] + action["contract"]["path"] and action["request_method"] == "POST" and len(action["request_id"]) > 0 and action["request_body_byte_length"] > 0 and action["request_body_byte_length"] <= 8192 and len(action["request_body_sha256"]) == 64 and action["status"] >= 200 and action["status"] < 300 and len(action["response_mime_type"]) > 0 and action["response_encoded_data_length"] > 0 and action["completion_observed"] and len(action["session_id"]) > 0 and len(action["target_id"]) > 0 for action in replay_control_actions ) ensure len([action for action in replay_control_actions if action["action_id"] == "scenario_select" and action["control_id"] == "scenario-control" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure len([action for action in replay_control_actions if action["action_id"] == "compile_apply" and action["control_id"] == "edit-apply" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure len([action for action in replay_control_actions if action["action_id"] == "cortex_propose" and action["control_id"] == "edit-propose" and action["contract"]["path"] == "/api/sema/cortex/propose"]) == 1 ensure len([action for action in replay_control_actions if action["action_id"] == "assistant_apply" and action["control_id"] == "assistant-apply" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure len([action for action in replay_control_actions if action["action_id"] == "program_reset" and action["control_id"] == "edit-reset" and action["contract"]["path"] == "/api/sema/program"]) == 1 ensure all(len([action for action in replay_control_actions if action["contract"] == contract]) >= 1 for contract in replay_qualified_contracts) replay_completed_contracts = replay_network_policy["completed_request_contracts"] ensure replay_network_policy["exact_contract_coverage_pass"] ensure len(replay_completed_contracts) == len(replay_contracts) ensure all( len(completed) == 15 and completed["origin"] == replay_viewer_origin and completed["method"] in ["GET", "POST"] and completed["path"].startswith("/") and (completed["search"] == "" or completed["search"] == "?phase10-viewer=disabled") and completed["url"].startswith(completed["origin"] + completed["path"]) and len(completed["request_id"]) > 0 and completed["request_body_byte_length"] >= 0 and completed["request_body_byte_length"] <= 8192 and ( completed["method"] == "GET" or (completed["request_body_byte_length"] > 0 and len(completed["request_body_sha256"]) == 64) ) and completed["status"] >= 200 and completed["status"] < 300 and completed["encoded_data_length"] > 0 and len(completed["session_id"]) > 0 and len(completed["target_id"]) > 0 and completed["target_type"] == "page" and completed["completion_observed"] and len([contract for contract in replay_contracts if contract["origin"] == completed["origin"] and contract["method"] == completed["method"] and contract["path"] == completed["path"] and contract["search"] == completed["search"]]) == 1 for completed in replay_completed_contracts ) ensure all( len([completed for completed in replay_completed_contracts if completed["origin"] == contract["origin"] and completed["method"] == contract["method"] and completed["path"] == contract["path"] and completed["search"] == contract["search"]]) == 1 for contract in replay_contracts ) replay_targets = replay_network_policy["governed_targets"] ensure len(replay_targets) >= 3 ensure all( len(target) == 6 and len(target["session_id"]) > 0 and len(target["target_id"]) > 0 and target["target_type"] in ["page", "iframe", "worker", "shared_worker", "service_worker"] and ( (target["target_type"] in ["worker", "shared_worker", "service_worker"] and target["policy_mechanism"] == "network_block_all_worker_before_resume") or (target["target_type"] in ["page", "iframe"] and target["policy_mechanism"] == "fetch_request_pause_exact_contract") ) and target["policy_installed"] and target["resumed"] for target in replay_targets ) replay_blocked_probes = replay_network_policy["blocked_probes"] ensure len(replay_blocked_probes) == 9 ensure all( len(probe) == 12 and probe["method"] == "GET" and probe["rejection_reason"] in ["outside_exact_contract", "websocket_forbidden"] and len(probe["request_id"]) > 0 and len(probe["session_id"]) > 0 and len(probe["target_id"]) > 0 and len(probe["policy_target_id"]) > 0 and probe["policy_target_type"] in ["page", "worker"] and len([baseline_probe for baseline_probe in baseline_blocked_probes if baseline_probe["probe_id"] == probe["probe_id"] and baseline_probe["context"] == probe["context"] and baseline_probe["target_type"] == probe["target_type"] and baseline_probe["policy_target_type"] == probe["policy_target_type"] and baseline_probe["rejection_reason"] == probe["rejection_reason"]]) == 1 for probe in replay_blocked_probes ) ensure any(probe["probe_id"] == "page_hostname" and probe["context"] == "page" and probe["target_type"] == "page" and probe["url"] == "https://phase10-page-probe.invalid/page-hostname" for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "page_direct_ip" and probe["context"] == "page" and probe["target_type"] == "page" and probe["url"] == "http://93.184.216.34/page-direct-ip" for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "blank_hostname" and probe["context"] == "_blank" and probe["target_type"] == "page" and probe["url"] == "https://phase10-popup-probe.invalid/popup-target-blank" for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "worker_direct_ip" and probe["context"] == "worker" and probe["target_type"] == "worker" and probe["url"] == "http://93.184.216.34/worker-direct-ip" for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "page_rogue_loopback" and probe["url"] == "http://127.0.0.1:65534/phase10-page-rogue" for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "page_localhost_alias" and probe["url"].startswith("http://localhost:") and probe["url"].endswith("/") for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "page_websocket" and probe["url"].startswith("ws://127.0.0.1:") and probe["url"].endswith("/phase10-websocket-rogue") and probe["rejection_reason"] == "websocket_forbidden" for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "blank_rogue_loopback" and probe["url"] == replay_viewer_origin + "/phase10-popup-rogue" for probe in replay_blocked_probes) ensure any(probe["probe_id"] == "worker_rogue_loopback" and probe["url"] == replay_live_origin + "/phase10-worker-rogue" for probe in replay_blocked_probes) ensure replay_capture["runtime"] == baseline_capture["runtime"] ensure replay_capture["started_at"] > baseline_capture["completed_at"] ensure replay_capture["completed_at"] > replay_capture["started_at"] ensure len(replay_capture["validator_run_id"]) == 36 ensure len(replay_capture["session_id"]) == 36 ensure len(replay_capture["capture_id"]) == 36 ensure len(replay_capture["stack_id"]) == 36 ensure replay_capture["validator_run_id"] != baseline_capture["validator_run_id"] ensure replay_capture["session_id"] != baseline_capture["session_id"] ensure replay_capture["capture_id"] != baseline_capture["capture_id"] ensure replay_capture["stack_id"] != baseline_capture["stack_id"] replay_preview = replay_capture["reference_preview"] ensure len(replay_preview) == 7 ensure replay_preview["path"] == local_preview["path"] ensure replay_preview["sha256"] == local_preview["sha256"] ensure replay_preview["source"] == "pinned_local_offline" ensure replay_preview["served_path"] == local_preview["served_path"] ensure file_sha256(replay_preview["path"]) == replay_preview["sha256"] replay_served_resource = replay_preview["served_resource"] ensure len(replay_served_resource) == 7 ensure replay_served_resource["url"].startswith("http://127.0.0.1:") ensure replay_served_resource["url"].endswith(replay_preview["served_path"]) ensure len(replay_served_resource["request_id"]) > 0 ensure replay_served_resource["status"] == 200 ensure replay_served_resource["mime_type"].startswith("image/") ensure replay_served_resource["encoded_data_length"] > 0 ensure replay_served_resource["sha256"] == replay_preview["sha256"] ensure len(replay_served_resource["decoded_images"]) == 2 ensure all( len(image) == 5 and image["complete"] and image["src"] == replay_served_resource["url"] and image["natural_width"] > 0 and image["natural_height"] > 0 for image in replay_served_resource["decoded_images"] ) ensure replay_served_resource["decoded_images"] == served_resource["decoded_images"] replay_groups = replay_capture["process_groups"] ensure len(replay_groups) >= 5 ensure all(len(group) == 3 and group["process_group_id"] > 0 for group in replay_groups) ensure len([group for group in replay_groups if group["role"] == "typecheck"]) == 1 ensure len([group for group in replay_groups if group["role"] == "production-build"]) == 1 ensure len([group for group in replay_groups if group["role"] == "sema"]) == 1 ensure len([group for group in replay_groups if group["role"] == "vite"]) == 1 ensure len([group for group in replay_groups if group["role"] == "chrome"]) == 1
captures = regression["captures"] ensure len(captures) == 4 and covers_four_scales(captures, "scale_id") for capture in captures: ensure len(capture) == 10 baseline = [screenshot for screenshot in screenshots if screenshot["scale_id"] == capture["scale_id"]] ensure len(baseline) == 1 ensure capture["baseline_path"] == baseline[0]["path"] ensure capture["baseline_sha256"] == baseline[0]["sha256"] ensure capture["baseline_capture_id"] == baseline[0]["capture_id"] ensure capture["baseline_capture_nonce"] == baseline[0]["capture_nonce"] ensure file_sha256(capture["baseline_path"]) == capture["baseline_sha256"] ensure path.is_relative_to(capture["replay_path"], "runs/phase10/visual-regression-replay") ensure capture["replay_path"].endswith(".png") ensure capture["replay_path"] != capture["baseline_path"] ensure file_sha256(capture["replay_path"]) == capture["replay_sha256"] ensure capture["replay_capture_id"] == replay_capture["capture_id"] ensure len(capture["replay_capture_nonce"]) == 36 ensure capture["replay_capture_nonce"] != capture["baseline_capture_nonce"] ensure len([other for other in captures if other["replay_capture_nonce"] == capture["replay_capture_nonce"]]) == 1 ensure capture["exact_match"] ensure capture["replay_sha256"] == capture["baseline_sha256"]
validator = evidence["validator"] ensure len(validator) == 5 local_url_policy = validator["local_preview_url_policy"] ensure len(local_url_policy) == 2 ensure local_url_policy["canonical_url"] == local_preview["served_path"] ensure len(local_url_policy["probes"]) == 4 ensure all(len(probe) == 3 and probe["rejected"] for probe in local_url_policy["probes"]) ensure any(probe["probe_id"] == "encoded_dot" and probe["value"] == "/data/%2e%2e/escape.jpg" for probe in local_url_policy["probes"]) ensure any(probe["probe_id"] == "foreign_origin" and probe["value"] == "https://phase10-origin-probe.invalid/data/reference.jpg" for probe in local_url_policy["probes"]) ensure any(probe["probe_id"] == "query" and probe["value"] == "/data/reference.jpg?variant=escape" for probe in local_url_policy["probes"]) ensure any(probe["probe_id"] == "fragment" and probe["value"] == "/data/reference.jpg#escape" for probe in local_url_policy["probes"]) roundtrips = validator["pick_roundtrips"] ensure len(roundtrips) >= 4 and len(roundtrips) <= thresholds["maximum_pick_roundtrips"] ensure len(roundtrips) == total_visible_instances ensure covers_four_scales(roundtrips, "layer_id") for roundtrip in roundtrips: ensure len(roundtrip) == 10 ensure roundtrip["visible"] and roundtrip["roundtrip_pass"] ensure len(roundtrip["primitive_id"]) > 0 and len(roundtrip["semantic_id"]) > 0 ensure len(roundtrip["canonical_entity_id"]) > 0 and roundtrip["canonical_entity_id"] != "unknown" ensure len(roundtrip["equation_id"]) > 0 and roundtrip["equation_id"] != "unknown" ensure len(roundtrip["evidence_id"]) == 64 ensure roundtrip["source_frame"] >= 0 ensure roundtrip["fidelity"] != "unknown" and len(roundtrip["fidelity"]) > 0
stability = validator["semantic_stability"] ensure len(stability) == thresholds["maximum_semantic_stability_records"] ensure covers_four_scales(stability, "scale_id") for record in stability: ensure len(record) == 8 visible_counts = [scale["visible_instances"] for scale in scales if scale["scale_id"] == record["scale_id"]] ensure len(visible_counts) == 1 and record["stable_count"] == visible_counts[0] semantic_ids = [roundtrip["semantic_id"] for roundtrip in roundtrips if roundtrip["layer_id"] == record["scale_id"]] ensure len(semantic_ids) == record["stable_count"] ensure sha256_json(semantic_ids) == record["semantic_ids_sha256"] ensure len(record["semantic_ids_sha256"]) == 64 ensure record["replay_semantic_ids_sha256"] == record["semantic_ids_sha256"] ensure record["interpolation_semantic_ids_sha256"] == record["semantic_ids_sha256"] ensure record["lod_semantic_ids_sha256"] == record["semantic_ids_sha256"] ensure record["simulation_digest_before"] == scene_record["scientific_result_sha256"] ensure record["simulation_digest_after"] == record["simulation_digest_before"]
unsupported = validator["unsupported_layers"] ensure len(unsupported) > 0 and len(unsupported) <= thresholds["maximum_unsupported_layers"] for layer in unsupported: ensure len(layer) == 4 ensure len(layer["layer_id"]) > 0 ensure layer["canonical_entity_id"] == "unknown" ensure layer["fidelity"] == "unknown" and layer["result"] == "unknown"
disabled = validator["viewer_disabled_parity"] ensure len(disabled) == 3 and disabled["parity_pass"] ensure disabled["viewer_enabled_digest"] == scene_record["scientific_result_sha256"] ensure disabled["viewer_disabled_digest"] == disabled["viewer_enabled_digest"]
return Phase10QualificationResult( schema="sema.phase10-qualification-result/v2", profile_id=evidence["profile_id"], config_sha256=file_sha256(config_path), evidence_sha256=file_sha256(config["evidence_path"]), scene_sha256=scene_record["sha256"], bundle_sha256=bundle["sha256"], external_reference_sha256=reference["metadata_sha256"], scientific_result_sha256=scene_record["scientific_result_sha256"], screenshot_sha256=screenshot_digests, scale_count=len(scales), minimum_average_fps=minimum_fps, interaction_hz=interaction["hz"], canonical_update_hz=updates["hz"], pick_p95_ms=pick["p95_ms"], dropped_frames=dropped_frames, gpu_allocated_bytes=maximum_gpu_bytes, gpu_resource_count=maximum_gpu_resources, context_loss_recovered=context_loss["recovered"], semantic_validation_pass=true, viewer_disabled_parity_pass=disabled["parity_pass"], pixel_equality_observed=regression["pixel_equality_observed"], capture_provenance_status=regression["capture_provenance_status"], visual_regression_replay_pass=false, profile_validated=false, scientific_validated=false, )src/physicell.sema
Section titled “src/physicell.sema”"""Pinned official PhysiCell 1.14.2 Apple-arm64 executable and stock XML field-coupling evidence."""
assure silver
pub struct PhysiCellFieldMetrics: mean_micromolar: f64 minimum_micromolar: f64 maximum_micromolar: f64 spatial_cv: f64 field_mass_micromolar_micrometer3: f64
pub struct PhysiCellSubstrateCellMetrics: uptake_rates_per_min: list[list[f64]] net_export_rates_micromolar_micrometer3_per_min: list[list[f64]] internalized_total_micromolar_micrometer3: list[f64]
pub struct PhysiCellSnapshot: voxels: int cells: int total_volume_micrometer3: f64 substrates: list[str] fields: dict[str, PhysiCellFieldMetrics] cell_substrates: PhysiCellSubstrateCellMetrics
pub struct PhysiCellScenario: name: str coupled: bool configured_monomer_micromolar: f64 configured_dimer_micromolar: f64 initial: PhysiCellSnapshot final: PhysiCellSnapshot
pub struct PhysiCellScenarioExecution: name: str wall_runtime_s: f64 captured_output_bytes: int output_files: int output_bytes: int initial_xml_sha256: str initial_mat_sha256: str initial_cell_mat_sha256: str final_xml_sha256: str final_mat_sha256: str final_cell_mat_sha256: str
pub struct PhysiCellExecution: scenario_executions: list[PhysiCellScenarioExecution] total_wall_runtime_s: f64 total_output_bytes: int total_output_files: int
pub struct PhysiCellResult: schema: str profile_id: str config_sha256: str config_path: str phase8_result_sha256: str phase8_artifact_sha256: str release_version: str release_asset_sha256: str release_asset_bytes: int release_asset_id: int tag_commit: str tag_ref_sha: str tag_commit_verified: bool license: str workflow_sha256: str fetch_manifest_schema: str fetch_manifest_path: str fetch_manifest_sha256: str fetch_evidence_sha256: str fetch_remote_verified: bool fetch_manifest_pass: bool binary_sha256: str binary_bytes: int binary_architectures: list[str] host_architecture: str arm64_dependencies: list[str] initial_concentration_residual_micromolar: f64 uniform_spatial_cv: f64 mass_relative_residual: f64 coupled_monomer_mean_delta_micromolar: f64 coupled_dimer_mean_delta_micromolar: f64 coupled_spatial_cv: f64 coupled_external_monomer_mass_delta_micromolar_micrometer3: f64 coupled_internalized_monomer_delta_micromolar_micrometer3: f64 coupled_external_dimer_mass_delta_micromolar_micrometer3: f64 coupled_internalized_dimer_delta_micromolar_micrometer3: f64 coupled_mass_transfer_relative_residual: f64 executable_pass: bool platform_pass: bool config_xml_field_coupling_pass: bool field_output_pass: bool concentration_transfer_pass: bool spatial_transfer_pass: bool mass_transfer_pass: bool uncertainty_bound_transfer_pass: bool cell_secretion_uptake_coupling_pass: bool failure_contract_pass: bool missing_failure_typed: bool corrupt_failure_typed: bool wrong_arch_failure_typed: bool timeout_failure_typed: bool oversized_output_failure_typed: bool manifest_missing_failure_typed: bool manifest_unverified_failure_typed: bool manifest_tampered_failure_typed: bool corrupt_asset_failure_typed: bool corrupt_binary_failure_typed: bool timeout_descendants_reaped: bool oversized_output_descendants_reaped: bool typed_failure_classes: list[str] target_rate_evidence: bool insulin_reaction_supported: bool scientific_uncertainty_evidence: bool scientific_validated: bool technical_qualified: bool evidence_class: str unsupported_semantics: list[str] integration_guidance: list[str] scenarios: list[PhysiCellScenario] execution: PhysiCellExecution result_sha256: str mode: str direct_parity_pass: bool direct_result_sha256: str direct_residual: f64 direct_artifact_sha256: str artifact_directory: str result_path: str invariant schema == "sema.physicell-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(phase8_result_sha256) == 64 and len(phase8_artifact_sha256) == 64 invariant release_version == "1.14.2" invariant release_asset_bytes == 2371922 and release_asset_id == 233689828 invariant len(release_asset_sha256) == 64 and len(workflow_sha256) == 64 invariant len(tag_commit) == 40 and license == "BSD-3-Clause" invariant len(tag_ref_sha) == 40 and tag_commit_verified invariant fetch_manifest_schema == "sema.physicell-fetch/v1" invariant len(fetch_manifest_path) > 0 invariant len(fetch_manifest_sha256) == 64 and len(fetch_evidence_sha256) == 64 invariant fetch_remote_verified and fetch_manifest_pass invariant binary_bytes == 7656072 and len(binary_sha256) == 64 invariant len(binary_architectures) == 2 invariant host_architecture == "arm64" invariant len(arm64_dependencies) == 1 invariant arm64_dependencies[0] == "/usr/lib/libSystem.B.dylib" invariant initial_concentration_residual_micromolar >= 0.0 invariant uniform_spatial_cv >= 0.0 and mass_relative_residual >= 0.0 invariant coupled_monomer_mean_delta_micromolar < 0.0 invariant coupled_dimer_mean_delta_micromolar > 0.0 and coupled_spatial_cv > 0.0 invariant coupled_external_monomer_mass_delta_micromolar_micrometer3 < 0.0 invariant coupled_internalized_monomer_delta_micromolar_micrometer3 > 0.0 invariant coupled_external_dimer_mass_delta_micromolar_micrometer3 > 0.0 invariant coupled_internalized_dimer_delta_micromolar_micrometer3 < 0.0 invariant coupled_mass_transfer_relative_residual >= 0.0 invariant executable_pass and platform_pass and config_xml_field_coupling_pass invariant field_output_pass and concentration_transfer_pass and spatial_transfer_pass invariant mass_transfer_pass and uncertainty_bound_transfer_pass invariant cell_secretion_uptake_coupling_pass and failure_contract_pass invariant missing_failure_typed and corrupt_failure_typed and wrong_arch_failure_typed invariant timeout_failure_typed and oversized_output_failure_typed invariant manifest_missing_failure_typed and manifest_unverified_failure_typed invariant manifest_tampered_failure_typed invariant corrupt_asset_failure_typed and corrupt_binary_failure_typed invariant timeout_descendants_reaped and oversized_output_descendants_reaped invariant len(typed_failure_classes) == 6 invariant not target_rate_evidence and not insulin_reaction_supported invariant not scientific_uncertainty_evidence and not scientific_validated invariant technical_qualified invariant evidence_class == "validated_stock_prebuilt_field_coupling" invariant len(unsupported_semantics) == 4 invariant len(integration_guidance) == 3 invariant len(scenarios) == 4 invariant len(execution.scenario_executions) == 4 invariant execution.total_wall_runtime_s > 0.0 invariant execution.total_output_bytes > 0 and execution.total_output_files > 0 invariant mode == "sema" and direct_parity_pass invariant len(direct_result_sha256) == 64 and len(direct_artifact_sha256) == 64 invariant direct_residual >= 0.0 invariant len(result_sha256) == 64 invariant len(artifact_directory) > 0 and len(result_path) > 0
pub bridge python.inline physicell_backend from "foreign/python/physicell_backend.py": deps "python>=3.12,<3.13" expose: def run_profile(config_path: str, mode: str, direct_path: str, output_path: str) -> PhysiCellResult !{ffi.call}: sem "Run the real pinned universal PhysiCell binary on arm64, parse MultiCellDS/BioFVM outputs, and preserve explicit stock-template semantic limits"src/physiology.sema
Section titled “src/physiology.sema”"""Evidence-bound glucose, insulin, beta-cell, immune, and graft physiology."""
assure silver
pub def initial_physiology_parameters() -> dict[str, f64] !{}: return { "glucose_inflow_mg_dl_day": 846.0, "insulin_sensitivity_ml_micro_u_day": 0.72, "glucose_effectiveness_per_day": 1.44, "insulin_secretion_micro_u_ml_day_mg": 43.2, "insulin_clearance_per_day": 432.0, "secretion_half_saturation_mg2_dl2": 2000.0, "beta_death_per_day": 0.06, "beta_growth_dl_mg_day": 0.00084, "beta_glucotoxicity_dl2_mg2_day": 0.0000024, "immune_activation_per_day": 2.4, "immune_clearance_per_day": 1.8, "immune_kill_per_day": 0.22, "cytokine_release_per_day": 1.6, "cytokine_clearance_per_day": 2.2, "regulatory_recovery_per_day": 0.8, "graft_engraftment_per_day": 1.2, "graft_rejection_per_day": 0.28, }
pub def physiology_parameter_bounds() -> dict[str, list[f64]] !{}: return { "glucose_inflow_mg_dl_day": [300.0, 1600.0], "insulin_sensitivity_ml_micro_u_day": [0.05, 2.0], "glucose_effectiveness_per_day": [0.1, 4.0], "insulin_secretion_micro_u_ml_day_mg": [5.0, 100.0], "insulin_clearance_per_day": [50.0, 1000.0], "secretion_half_saturation_mg2_dl2": [500.0, 10000.0], "beta_death_per_day": [0.0, 0.5], "beta_growth_dl_mg_day": [0.0, 0.005], "beta_glucotoxicity_dl2_mg2_day": [0.0, 0.0001], "immune_activation_per_day": [0.0, 10.0], "immune_clearance_per_day": [0.0, 10.0], "immune_kill_per_day": [0.0, 1.0], "cytokine_release_per_day": [0.0, 10.0], "cytokine_clearance_per_day": [0.0, 10.0], "regulatory_recovery_per_day": [0.0, 10.0], "graft_engraftment_per_day": [0.0, 10.0], "graft_rejection_per_day": [0.0, 1.0], }
pub def physiology_parameter_value_valid(name: str, value: f64) -> bool !{}: bounds = physiology_parameter_bounds() if not bounds.has(name): return false return value >= bounds[name][0] and value <= bounds[name][1]
pub def initial_physiology_state() -> dict[str, any] !{}: return { "schema": "sema.metabolic-immune-state/v1", "model_time_days": 0.0, "values": [98.0, 10.0, 120.0, 0.02, 0.01, 0.35, 0.0], "integration_steps_accepted": 0, "integration_steps_rejected": 0, "integration_error_bound": 0.0, "technical_pass": true, "scientific_validated": false, }
pub def physiology_equations() -> list[str] !{}: return [ "dG/dt = R0 + meal - exercise - (EG0 + SI I) G", "dI/dt = (beta + graft) sigma G^2 / (alpha + G^2) + dose - k I", "dbeta/dt = (r1 G - d0 - r2 G^2 - immune_kill E - hypoxia_loss) beta", "dC/dt = cytokine_release (challenge + E) (1-C) - cytokine_clearance C", "dE/dt = immune_activation C (1-E) - immune_clearance (0.15+R) E", "dR/dt = regulatory_recovery (0.35-R)", "dgraft/dt = engraftment (target-graft) - rejection E (1-shield) graft", ]
equation metabolic_immune_rhs(t, state, glucose_inflow, insulin_sensitivity, glucose_effectiveness, insulin_secretion, insulin_clearance, secretion_half_saturation, beta_death, beta_growth, beta_glucotoxicity, immune_activation, immune_clearance, immune_kill, cytokine_release, cytokine_clearance, regulatory_recovery, graft_engraftment, graft_rejection, glucose_target_millimolar, oxygen_kilopascal, cytokine_challenge, meal_intensity, exercise_intensity, exogenous_insulin, immune_shielding, graft_target_mg) -> any: glucose := state[0] insulin := state[1] beta_mass := state[2] cytokine := state[3] immune_effector := state[4] regulatory := state[5] graft_mass := state[6] glucose_target := glucose_target_millimolar * 18.018 hypoxia := max(0.0, min(1.0, (5.0 - oxygen_kilopascal) / 5.0)) effective_sensitivity := insulin_sensitivity * (1.0 + 0.8 * exercise_intensity) meal_appearance := 120.0 * meal_intensity + 2.4 * (glucose_target - glucose) exercise_disposal := 70.0 * exercise_intensity secretion := (beta_mass + graft_mass) * insulin_secretion * glucose^2 / (secretion_half_saturation + glucose^2) beta_growth_rate := beta_growth * glucose - beta_death - beta_glucotoxicity * glucose^2 immune_loss := immune_kill * immune_effector hypoxia_loss := 0.18 * hypoxia return [ glucose_inflow + meal_appearance - exercise_disposal - (glucose_effectiveness + effective_sensitivity * insulin) * glucose, secretion + exogenous_insulin - insulin_clearance * insulin, (beta_growth_rate - immune_loss - hypoxia_loss) * beta_mass, cytokine_release * (cytokine_challenge + immune_effector) * (1.0 - cytokine) - cytokine_clearance * cytokine, immune_activation * cytokine * (1.0 - immune_effector) - immune_clearance * (0.15 + regulatory) * immune_effector, regulatory_recovery * (0.35 - regulatory), graft_engraftment * (graft_target_mg - graft_mass) - (graft_rejection * immune_effector * (1.0 - immune_shielding) + hypoxia_loss) * graft_mass, ]
equation integrate_metabolic_immune_state(state, horizon_days, rates) -> any: return ode(metabolic_immune_rhs, 0.0, state, horizon_days, 0.00000001, 0.0000000001, 20000, rates, "rk45")
def physiology_rates(parameters: dict[str, f64], signals: dict[str, f64]): return [ parameters["glucose_inflow_mg_dl_day"], parameters["insulin_sensitivity_ml_micro_u_day"], parameters["glucose_effectiveness_per_day"], parameters["insulin_secretion_micro_u_ml_day_mg"], parameters["insulin_clearance_per_day"], parameters["secretion_half_saturation_mg2_dl2"], parameters["beta_death_per_day"], parameters["beta_growth_dl_mg_day"], parameters["beta_glucotoxicity_dl2_mg2_day"], parameters["immune_activation_per_day"], parameters["immune_clearance_per_day"], parameters["immune_kill_per_day"], parameters["cytokine_release_per_day"], parameters["cytokine_clearance_per_day"], parameters["regulatory_recovery_per_day"], parameters["graft_engraftment_per_day"], parameters["graft_rejection_per_day"], signals["glucose"], signals["oxygen"], signals["cytokine"], signals["meal_intensity"], signals["exercise_intensity"], signals["exogenous_insulin_micro_u_ml_day"], signals["immune_shielding"], signals["graft_target_mg"], ]
def bounded_physiology_values(values: list[f64]): return [ max(20.0, min(600.0, values[0])), max(0.0, min(1000.0, values[1])), max(0.01, min(1000.0, values[2])), max(0.0, min(1.0, values[3])), max(0.0, min(1.0, values[4])), max(0.0, min(1.0, values[5])), max(0.0, min(1000.0, values[6])), ]
pub def step_physiology_state(state: dict[str, any], dt_s: f64, signals: dict[str, f64], parameters: dict[str, f64]) -> dict[str, any] !{}: sem "Advance published glucose-insulin-beta equations and a bounded immune/graft extension on explicit model time" require state["schema"] == "sema.metabolic-immune-state/v1" require len(state["values"]) == 7 and dt_s >= 0.01 and dt_s <= 0.25 horizon_days = dt_s * signals["physiology_seconds_per_real_second"] / 86400.0 solved = integrate_metabolic_immune_state(state["values"], horizon_days, physiology_rates(parameters, signals)) approximation = solved[0] raw_values = approximation.value values = bounded_physiology_values(raw_values) technical_pass = approximation.converged and approximation.residual <= 1.0 and raw_values[0] >= 20.0 and raw_values[0] <= 600.0 and raw_values[1] >= 0.0 and raw_values[1] <= 1000.0 and raw_values[2] > 0.0 and raw_values[2] <= 1000.0 and raw_values[3] >= 0.0 and raw_values[3] <= 1.0 and raw_values[4] >= 0.0 and raw_values[4] <= 1.0 and raw_values[5] >= 0.0 and raw_values[5] <= 1.0 and raw_values[6] >= 0.0 and raw_values[6] <= 1000.0 return { "schema": state["schema"], "model_time_days": state["model_time_days"] + horizon_days, "values": values, "integration_steps_accepted": solved[1], "integration_steps_rejected": solved[2], "integration_error_bound": approximation.residual, "technical_pass": technical_pass, "scientific_validated": false, }
pub def physiology_public_state(state: dict[str, any], signals: dict[str, f64], parameters: dict[str, f64]) -> dict[str, any] !{}: values = state["values"] total_beta = values[2] + values[6] return { "schema": "sema.metabolic-immune-observation/v1", "model_id": "topp-2000-plus-bounded-immune-graft-v1", "model_time_days": state["model_time_days"], "state_names": ["glucose", "insulin", "native_beta_mass", "cytokine", "immune_effector", "regulatory_t_cell", "graft_beta_mass"], "state_units": ["mg/dL", "microU/mL", "mg", "fraction", "fraction", "fraction", "mg"], "state": values, "glucose_millimolar": values[0] / 18.018, "insulin_micro_u_ml": values[1], "native_beta_mass_mg": values[2], "graft_beta_mass_mg": values[6], "beta_function_fraction": max(0.0, min(1.5, total_beta / 120.0)), "cytokine_fraction": values[3], "immune_effector_fraction": values[4], "regulatory_fraction": values[5], "oxygen_kilopascal": signals["oxygen"], "meal_intensity": signals["meal_intensity"], "exercise_intensity": signals["exercise_intensity"], "immune_shielding": signals["immune_shielding"], "equations": physiology_equations(), "parameters": parameters, "integration_method": "adaptive RK45", "integration_steps_accepted": state["integration_steps_accepted"], "integration_steps_rejected": state["integration_steps_rejected"], "integration_error_bound": state["integration_error_bound"], "sources": ["Topp et al. 2000 PMID:11013117", "Oresic et al. 2012 DOI:10.1371/journal.pone.0051909"], "technical_pass": state["technical_pass"], "scientific_validated": false, }src/portable.sema
Section titled “src/portable.sema”"""Measured Phase 9 ABI, CPU/MPS, process-loss, and checkpoint evidence."""
assure silver
pub struct PortabilityResult: schema: str profile_id: str profile_identity_sha256: str config_sha256: str source_result_sha256: str source_artifact_sha256: str backend_identity_sha256: str backend_source_sha256: str sema_contract_source_sha256: str numpy_version: str torch_version: str python_version: str cpu_backend: str cpu_device: str gpu_backend: str gpu_device: str mps_available: bool mps_evidence_status: str precision: str batch: int voxels: int steps: int repeats: int concentration_residual_micromolar: f64 cpu_mass_relative_residual: f64 gpu_mass_relative_residual: f64 cpu_p95_latency_ms: f64 gpu_p95_latency_ms: f64 cpu_throughput_voxel_steps_per_s: f64 gpu_throughput_voxel_steps_per_s: f64 gpu_allocated_bytes: int gpu_host_transfer_bytes: int abi_scope: str bulk_elements: int bulk_payload_bytes: int bulk_calls: int bulk_p95_latency_ms: f64 bulk_checksum_residual: f64 bulk_pointer_equal: bool bulk_shares_memory: bool cpu_zero_copy: bool gpu_zero_copy: bool sema_bridge_zero_copy_validated: bool bulk_abi_pass: bool distributed_evidence_kind: str multiprocessing_start_method: str distributed_worker_count: int distributed_partition_batch: int distributed_total_steps: int worker_pids: list[int] survivor_worker_ids: list[int] survivor_worker_pids: list[int] survivor_worker_exitcodes: list[int] killed_worker_id: int killed_worker_pid: int killed_worker_exitcode: int killed_worker_signal: str recovery_worker_pid: int recovery_worker_exitcode: int recovery_resumed_step: int stable_checkpoint_step: int partial_checkpoint_step: int partial_checkpoint_bytes: int partial_checkpoint_intended_bytes: int rejected_checkpoint_count: int rejected_checkpoint_error_codes: list[str] checkpoint_manifest_sha256: str distributed_residual_micromolar: f64 corrupt_checkpoint_blocked: bool partial_checkpoint_blocked: bool worker_loss_failure_validated: bool same_node_distributed_process_pass: bool distributed_validated: bool cross_node_distributed_validated: bool checkpoint_pass: bool device_loss_evidence_kind: str device_loss_injection_attempted: bool device_loss_injection_observed: bool device_loss_recovery_pass: bool device_loss_recovery_residual_micromolar: f64 device_loss_failure_validated: bool physical_device_loss_observed: bool physical_device_loss_validated: bool scientific_parity_pass: bool cpu_profile_qualified: bool gpu_profile_qualified: bool single_node_portability_pass: bool local_technical_pass: bool portable_core_validated: bool direct_parity_pass: bool phase9_admitted: bool phase9_validated: bool scientific_validated: bool evidence_class: str direct_oracle_result_sha256: str direct_oracle_artifact_sha256: str direct_oracle_path: str direct_residual: f64 result_sha256: str result_path: str invariant schema == "sema.portability-result/v2" invariant len(profile_id) > 0 invariant len(profile_identity_sha256) == 64 invariant len(config_sha256) == 64 invariant len(source_result_sha256) == 64 invariant len(source_artifact_sha256) == 64 invariant len(backend_identity_sha256) == 64 invariant len(backend_source_sha256) == 64 invariant len(sema_contract_source_sha256) == 64 invariant len(numpy_version) > 0 and len(torch_version) > 0 and len(python_version) > 0 invariant cpu_backend == "NumPy" and cpu_device == "cpu" invariant gpu_backend == "PyTorch" and gpu_device == "mps" invariant mps_evidence_status == "real_measured" or mps_evidence_status == "unavailable" invariant precision == "float32" invariant batch > 0 and voxels > 2 and steps > 0 and repeats > 2 invariant concentration_residual_micromolar >= 0.0 invariant cpu_mass_relative_residual >= 0.0 and gpu_mass_relative_residual >= 0.0 invariant cpu_p95_latency_ms > 0.0 and gpu_p95_latency_ms >= 0.0 invariant cpu_throughput_voxel_steps_per_s > 0.0 and gpu_throughput_voxel_steps_per_s >= 0.0 invariant gpu_allocated_bytes >= 0 and gpu_host_transfer_bytes >= 0 invariant abi_scope == "python_buffer_protocol_adapter" invariant bulk_elements > 0 and bulk_payload_bytes > 0 and bulk_calls > 2 invariant bulk_p95_latency_ms > 0.0 and bulk_checksum_residual >= 0.0 invariant not sema_bridge_zero_copy_validated invariant distributed_evidence_kind == "local_multiprocess_partitioned" invariant multiprocessing_start_method == "spawn" or multiprocessing_start_method == "fork" invariant distributed_worker_count == 2 and len(worker_pids) == distributed_worker_count invariant len(survivor_worker_ids) == distributed_worker_count - 1 invariant len(survivor_worker_pids) == len(survivor_worker_ids) invariant len(survivor_worker_exitcodes) == len(survivor_worker_ids) invariant survivor_worker_exitcodes[0] == 0 invariant distributed_partition_batch >= distributed_worker_count invariant distributed_total_steps > partial_checkpoint_step invariant killed_worker_pid > 0 and recovery_worker_pid > 0 invariant killed_worker_pid != recovery_worker_pid invariant killed_worker_exitcode < 0 and recovery_worker_exitcode == 0 invariant killed_worker_signal == "SIGTERM" invariant recovery_resumed_step == stable_checkpoint_step invariant partial_checkpoint_step > stable_checkpoint_step invariant partial_checkpoint_bytes > 0 and partial_checkpoint_bytes < partial_checkpoint_intended_bytes invariant rejected_checkpoint_count == len(rejected_checkpoint_error_codes) invariant len(checkpoint_manifest_sha256) == 64 invariant distributed_residual_micromolar >= 0.0 invariant same_node_distributed_process_pass == (checkpoint_pass and worker_loss_failure_validated) invariant distributed_validated == (same_node_distributed_process_pass and cross_node_distributed_validated) invariant not cross_node_distributed_validated invariant device_loss_evidence_kind == "adapter_injected_mps_dispatch_loss" or device_loss_evidence_kind == "unavailable_mps_not_injected" invariant device_loss_recovery_residual_micromolar >= 0.0 invariant not physical_device_loss_observed and not physical_device_loss_validated invariant local_technical_pass == (single_node_portability_pass and cpu_zero_copy and same_node_distributed_process_pass and checkpoint_pass and worker_loss_failure_validated and device_loss_injection_observed and device_loss_recovery_pass) invariant phase9_admitted == (local_technical_pass and direct_parity_pass and cross_node_distributed_validated and physical_device_loss_validated and sema_bridge_zero_copy_validated) invariant phase9_validated == phase9_admitted and portable_core_validated == phase9_admitted invariant not scientific_validated invariant evidence_class == "local_technical_evidence" or evidence_class == "implemented_unvalidated" invariant len(direct_oracle_result_sha256) == 64 invariant len(direct_oracle_artifact_sha256) == 64 invariant len(direct_oracle_path) > 0 and direct_residual >= 0.0 invariant len(result_sha256) == 64 and len(result_path) > 0
pub bridge python.inline portable_backend from "foreign/python/portable_backend.py": deps "python>=3.12,<3.13", "numpy==2.4.1", "torch==2.13.0" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> PortabilityResult !{ffi.call}: sem "Measure digest-bound bulk ABI, equal-tolerance CPU/MPS, and bounded process/checkpoint recovery evidence"src/profiles.sema
Section titled “src/profiles.sema”"""Honest contracts for QM/MM, mesoscopic, cellular, and performance phases."""
from biological_computer.domain import PhaseEvidence, PhaseState
assure silver
pub struct QmMmPartition: id: str qm_atom_indices: list[int] mm_atom_indices: list[int] boundary_atom_indices: list[int] total_charge_e: int spin_multiplicity: int embedding: str backend_profile_id: str invariant len(id) > 0 invariant len(qm_atom_indices) > 0 and len(qm_atom_indices) <= 10000 invariant len(mm_atom_indices) > 0 and len(mm_atom_indices) <= 10000000 invariant len(boundary_atom_indices) <= 1024 invariant spin_multiplicity > 0 invariant len(embedding) > 0 invariant len(backend_profile_id) > 0
pub struct ParameterizationEdge: id: str source_model_id: str target_model_id: str parameter_names: list[str] values: list[f64] uncertainties: list[f64] units: list[str] evidence_ids: list[str] invariant len(id) > 0 invariant len(source_model_id) > 0 invariant len(target_model_id) > 0 invariant len(parameter_names) > 0 and len(parameter_names) <= 1024 invariant len(parameter_names) == len(values) invariant len(values) == len(uncertainties) invariant len(uncertainties) == len(units) invariant len(evidence_ids) <= 128
pub struct PlatformBenchmark: profile_id: str hardware: str operating_system: str backend: str precision: str model_digest: str tolerance_profile: str simulated_ns_per_day: f64 p50_step_ms: f64 p95_step_ms: f64 resident_memory_bytes: int transfer_bytes: int observable_error: f64 evidence_ids: list[str] invariant len(profile_id) > 0 invariant len(hardware) > 0 invariant len(operating_system) > 0 invariant len(backend) > 0 invariant len(precision) > 0 invariant len(model_digest) == 64 invariant len(tolerance_profile) > 0 invariant simulated_ns_per_day >= 0.0 invariant p50_step_ms >= 0.0 invariant p95_step_ms >= p50_step_ms invariant resident_memory_bytes >= 0 invariant transfer_bytes >= 0 invariant observable_error >= 0.0 invariant len(evidence_ids) <= 128
pub enum NativeKernelKind: sema_aot | rust_native | c_abi | cpp_abi | ecosystem_bridge
pub enum AcceleratorKind: cpu | apple_metal | apple_mps | mlx | cuda | hip | webgl2 | webgpu
pub struct KernelDemand: operation: str precision: str tolerance_profile: str minimum_throughput_per_s: f64 maximum_p95_ms: f64 maximum_observable_error: f64 maximum_resident_memory_bytes: int invariant len(operation) > 0 invariant len(precision) > 0 invariant len(tolerance_profile) > 0 invariant minimum_throughput_per_s >= 0.0 invariant maximum_p95_ms >= 0.0 invariant maximum_observable_error >= 0.0 invariant maximum_resident_memory_bytes >= 0
pub struct NativeAccelerationProfile: profile_id: str kernel_id: str native_kind: NativeKernelKind accelerator: AcceleratorKind device_name: str precision: str tolerance_profile: str available: bool qualified: bool zero_copy: bool unified_memory: bool supported_operations: list[str] measured_throughput_per_s: f64 measured_p95_ms: f64 observable_error: f64 resident_memory_bytes: int host_device_transfer_bytes: int artifact_sha256: str model_sha256: str oracle_evidence_ids: list[str] benchmark_evidence_ids: list[str] invariant len(profile_id) > 0 invariant len(kernel_id) > 0 invariant len(device_name) > 0 invariant len(precision) > 0 invariant len(tolerance_profile) > 0 invariant len(supported_operations) > 0 and len(supported_operations) <= 64 invariant measured_throughput_per_s >= 0.0 invariant measured_p95_ms >= 0.0 invariant observable_error >= 0.0 invariant resident_memory_bytes >= 0 invariant host_device_transfer_bytes >= 0 invariant len(artifact_sha256) == 64 invariant len(model_sha256) == 64 invariant len(oracle_evidence_ids) <= 128 invariant len(benchmark_evidence_ids) <= 128
pub struct AccelerationDecision: selected: bool profile_id: str native_kind: NativeKernelKind accelerator: AcceleratorKind zero_copy: bool reason: str invariant len(reason) > 0
def operation_supported(operation: str, supported_operations: list[str]): for supported in supported_operations: if supported == operation: return true return false
def acceleration_priority(accelerator: AcceleratorKind): if accelerator == AcceleratorKind.cuda: return 100 if accelerator == AcceleratorKind.mlx: return 95 if accelerator == AcceleratorKind.apple_mps: return 90 if accelerator == AcceleratorKind.apple_metal: return 85 if accelerator == AcceleratorKind.hip: return 80 if accelerator == AcceleratorKind.webgpu: return 75 if accelerator == AcceleratorKind.webgl2: return 70 return 50
def acceleration_profile_eligible(profile: NativeAccelerationProfile, demand: KernelDemand): if not profile.available or not profile.qualified: return false if len(profile.oracle_evidence_ids) == 0 or len(profile.benchmark_evidence_ids) == 0: return false if profile.precision != demand.precision or profile.tolerance_profile != demand.tolerance_profile: return false if not operation_supported(demand.operation, profile.supported_operations): return false if profile.measured_throughput_per_s < demand.minimum_throughput_per_s: return false if profile.measured_p95_ms > demand.maximum_p95_ms: return false if profile.observable_error > demand.maximum_observable_error: return false return profile.resident_memory_bytes <= demand.maximum_resident_memory_bytes
pub def select_native_acceleration(demand: KernelDemand, profiles: list[NativeAccelerationProfile]) -> AccelerationDecision !{}: mut best_p95_ms = 0.0 mut best_throughput_per_s = 0.0 mut best_transfer_bytes = 0 mut best_priority = -1 mut decision = AccelerationDecision(selected=false, profile_id="", native_kind=NativeKernelKind.sema_aot, accelerator=AcceleratorKind.cpu, zero_copy=false, reason="no measured and oracle-qualified native profile satisfies the kernel demand") for profile in profiles: if not acceleration_profile_eligible(profile, demand): continue priority = acceleration_priority(profile.accelerator) mut better = not decision.selected if decision.selected and profile.measured_p95_ms < best_p95_ms: better = true if decision.selected and profile.measured_p95_ms == best_p95_ms and profile.measured_throughput_per_s > best_throughput_per_s: better = true if decision.selected and profile.measured_p95_ms == best_p95_ms and profile.measured_throughput_per_s == best_throughput_per_s and profile.host_device_transfer_bytes < best_transfer_bytes: better = true if decision.selected and profile.measured_p95_ms == best_p95_ms and profile.measured_throughput_per_s == best_throughput_per_s and profile.host_device_transfer_bytes == best_transfer_bytes and profile.zero_copy and not decision.zero_copy: better = true if decision.selected and profile.measured_p95_ms == best_p95_ms and profile.measured_throughput_per_s == best_throughput_per_s and profile.host_device_transfer_bytes == best_transfer_bytes and profile.zero_copy == decision.zero_copy and priority > best_priority: better = true if better: best_p95_ms = profile.measured_p95_ms best_throughput_per_s = profile.measured_throughput_per_s best_transfer_bytes = profile.host_device_transfer_bytes best_priority = priority decision = AccelerationDecision(selected=true, profile_id=profile.profile_id, native_kind=profile.native_kind, accelerator=profile.accelerator, zero_copy=profile.zero_copy, reason="selected by measured p95 latency, throughput, transfer cost, zero-copy, then accelerator tie-break") return decision
def indices_unique(values: list[int]): mut left = 0 for value in values: mut right = 0 for other in values: if left != right and value == other: return false right = right + 1 left = left + 1 return true
def lists_disjoint(left_values: list[int], right_values: list[int]): for left in left_values: for right in right_values: if left == right: return false return true
pub def qmmm_partition_valid(partition: QmMmPartition, atom_count: int) -> bool !{}: require atom_count > 0 if not indices_unique(partition.qm_atom_indices) or not indices_unique(partition.mm_atom_indices): return false if not lists_disjoint(partition.qm_atom_indices, partition.mm_atom_indices): return false for index in partition.qm_atom_indices: if index < 0 or index >= atom_count: return false for index in partition.mm_atom_indices: if index < 0 or index >= atom_count: return false return len(partition.qm_atom_indices) + len(partition.mm_atom_indices) == atom_count
pub def parameterization_valid(edge: ParameterizationEdge) -> bool !{}: if len(edge.evidence_ids) == 0: return false for uncertainty in edge.uncertainties: if uncertainty < 0.0: return false for unit in edge.units: if len(unit) == 0: return false return true
pub def benchmark_comparable(reference: PlatformBenchmark, candidate: PlatformBenchmark) -> bool !{}: return reference.model_digest == candidate.model_digest and reference.tolerance_profile == candidate.tolerance_profile and reference.backend == candidate.backend
def unavailable_phase(phase: int, profile_id: str, backend: str): require len(backend) > 0 return PhaseEvidence(phase=phase, state=PhaseState.blocked, profile_id=profile_id, positive_evidence=[], negative_evidence=[], blockers=[backend + " backend has not been qualified"])src/programming.sema
Section titled “src/programming.sema”"""Typed, transactional biological programming plans for viewers and agents."""
from biological_computer.design import compile_design_command, design_capabilities, design_spec_validfrom biological_computer.physiology import initial_physiology_parameters, physiology_parameter_bounds, physiology_parameter_value_valid
assure silver
def initial_signal_values(): return { "glucose": 5.5, "oxygen": 8.0, "cytokine": 0.0, "morphology": 1.0, "amplitude": 1.0, "attraction": 0.0, "molecular_temperature": 1.0, "bond_stiffness": 1.0, "meal_intensity": 0.0, "exercise_intensity": 0.0, "exogenous_insulin_micro_u_ml_day": 0.0, "immune_shielding": 0.0, "graft_target_mg": 0.0, "physiology_seconds_per_real_second": 300.0, }
pub def initial_program_state() -> dict[str, any] !{}: return { "schema": "sema.biological-program-state/v2", "state_version": 0, "signals": initial_signal_values(), "parameters": initial_physiology_parameters(), "last_summary": [], }
def normalized_signal(name: str): if name == "thermal" or name == "thermal motion" or name == "temperature": return "molecular_temperature" if name == "bond stiffness" or name == "bonds": return "bond_stiffness" return name
pub def signal_bounds() -> dict[str, list[f64]] !{}: return { "glucose": [2.5, 25.0], "oxygen": [1.0, 30.0], "cytokine": [0.0, 2.0], "morphology": [0.2, 3.0], "amplitude": [0.2, 3.0], "attraction": [0.0, 2.0], "molecular_temperature": [0.0, 4.0], "bond_stiffness": [0.0, 4.0], "meal_intensity": [0.0, 4.0], "exercise_intensity": [0.0, 2.0], "exogenous_insulin_micro_u_ml_day": [0.0, 5000.0], "immune_shielding": [0.0, 1.0], "graft_target_mg": [0.0, 500.0], "physiology_seconds_per_real_second": [1.0, 86400.0], }
def signal_value_valid(name: str, value: f64): bounds = signal_bounds() if not bounds.has(name): return false return value >= bounds[name][0] and value <= bounds[name][1]
def signal_operation(name: str, value: f64): return {"kind": "set_signal", "name": normalized_signal(name), "value": value}
def design_command_result(text: str): compiled = compile_design_command(text) if not compiled["ok"]: return compiled return {"ok": true, "operations": [{"kind": "design_species", "design": compiled}]}
def design_command_valid(design: any) !{}: if not (design is dict) or not all(design.has(field) for field in ["ok", "kind", "name"]): return false if not design["ok"]: return false if design["kind"] == "design": return design.has("spec") and design_spec_valid(design["spec"]) return design["kind"] == "set_mechanism" and design.has("mechanism")
pub def compile_biological_command(command: str) -> dict[str, any] !{}: if len(command) == 0 or len(command) > 320: return {"ok": false, "error": "ProgramCompileError", "detail": "command must contain 1..320 characters"} plain_command = command.lower().strip() mut text = plain_command if text == "reset" or text == "reset simulation" or text == "restore baseline": return {"ok": true, "operations": [{"kind": "reset_program"}]} if text == "inhibit cytokine release": return {"ok": true, "operations": [{"kind": "set_parameter", "name": "cytokine_release_per_day", "value": 0.8}]} if text == "stiffen bonds": return {"ok": true, "operations": [signal_operation("bond_stiffness", 1.5)]} if text == "increase thermal motion": return {"ok": true, "operations": [signal_operation("molecular_temperature", 1.5)]} if text == "make cell wider": return {"ok": true, "operations": [signal_operation("morphology", 1.25)]} if text == "increase receptor attraction": return {"ok": true, "operations": [signal_operation("attraction", 1.3)]} if text == "simulate meal": return {"ok": true, "operations": [signal_operation("meal_intensity", 1.0), signal_operation("glucose", 8.0)]} if text == "simulate exercise": return {"ok": true, "operations": [signal_operation("exercise_intensity", 1.0), signal_operation("glucose", 5.5)]} if text == "simulate autoimmune attack": return {"ok": true, "operations": [signal_operation("cytokine", 1.2)]} if text == "transplant beta cells": return {"ok": true, "operations": [signal_operation("graft_target_mg", 120.0)]} if text == "shield transplanted cells": return {"ok": true, "operations": [signal_operation("immune_shielding", 0.9)]} if text == "dose insulin": return {"ok": true, "operations": [signal_operation("exogenous_insulin_micro_u_ml_day", 600.0)]} if text.startswith("set "): text = text.slice(4, text.len()) if text.startswith("increase "): text = text.slice(9, text.len()) if text.startswith("decrease "): text = text.slice(9, text.len()) # No rule of the bounded grammar below begins with these two prefixes, so routing them here is # observationally the same as falling through the match, and keeps the delegation out of a case arm. if plain_command.startswith("design ") or plain_command.startswith("set mechanism of "): return design_command_result(plain_command) match text: # Match the two-signal glucose/oxygen phrase shown in the programming console. case re"^glucose to (?P<glucose>-?[0-9]+(\.[0-9]+)?) and oxygen to (?P<oxygen>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("glucose", float(glucose)), signal_operation("oxygen", float(oxygen))]} # Match a glucose setting followed by one finite signed decimal. case re"^glucose to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("glucose", float(value))]} # Match an oxygen setting followed by one finite signed decimal. case re"^oxygen to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("oxygen", float(value))]} # Match a cytokine setting followed by one finite signed decimal. case re"^cytokine to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("cytokine", float(value))]} # Match a morphology setting followed by one finite signed decimal. case re"^morphology to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("morphology", float(value))]} # Match an amplitude setting followed by one finite signed decimal. case re"^amplitude to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("amplitude", float(value))]} # Match an attraction setting followed by one finite signed decimal. case re"^attraction to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("attraction", float(value))]} # Match a thermal-motion setting followed by one finite signed decimal. case re"^thermal motion to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("molecular_temperature", float(value))]} # Match a temperature setting followed by one finite signed decimal. case re"^temperature to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("molecular_temperature", float(value))]} # Match a bond-stiffness setting followed by one finite signed decimal. case re"^bond stiffness to (?P<value>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [signal_operation("bond_stiffness", float(value))]} # Match a topology removal command with two bounded integer atom indexes. case re"^remove bond (?P<left:int>[0-9]+) (?P<right:int>[0-9]+)$": return {"ok": true, "operations": [{"kind": "remove_bond", "left": left, "right": right}]} # Match a topology addition command with two bounded integer atom indexes. case re"^add bond (?P<left:int>[0-9]+) (?P<right:int>[0-9]+)$": return {"ok": true, "operations": [{"kind": "add_bond", "left": left, "right": right}]} # Match a move command and parse its three signed decimal offsets. case re"^move atom (?P<atom_index:int>[0-9]+) by (?P<dx>-?[0-9]+(\.[0-9]+)?) (?P<dy>-?[0-9]+(\.[0-9]+)?) (?P<dz>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [{"kind": "translate_atom", "atom_index": atom_index, "delta_angstrom": [float(dx), float(dy), float(dz)]}]} # Match a translate command and parse its three signed decimal offsets. case re"^translate atom (?P<atom_index:int>[0-9]+) by (?P<dx>-?[0-9]+(\.[0-9]+)?) (?P<dy>-?[0-9]+(\.[0-9]+)?) (?P<dz>-?[0-9]+(\.[0-9]+)?)$": return {"ok": true, "operations": [{"kind": "translate_atom", "atom_index": atom_index, "delta_angstrom": [float(dx), float(dy), float(dz)]}]} case _: return {"ok": false, "error": "ProgramCompileError", "detail": "command does not match the bounded biological programming grammar"}
def program_operation_valid(operation: dict[str, any]) !{}: if not operation.has("kind"): return false if operation["kind"] == "reset_program": return true if operation["kind"] == "set_signal": if not operation.has("name") or not operation.has("value"): return false name = normalized_signal(operation["name"]) return signal_value_valid(name, operation["value"]) if operation["kind"] == "set_parameter": if not operation.has("name") or not operation.has("value"): return false return physiology_parameter_value_valid(operation["name"], operation["value"]) if operation["kind"] == "remove_bond" or operation["kind"] == "add_bond": return operation.has("left") and operation.has("right") if operation["kind"] == "design_species": return operation.has("design") and design_command_valid(operation["design"]) if operation["kind"] == "translate_atom": return operation.has("atom_index") and operation.has("delta_angstrom") return false
pub def apply_biological_program(state: dict[str, any], payload: dict[str, any]) -> dict[str, any] !{}: if not payload.has("program_state_version") or not payload.has("operations"): return {"ok": false, "error": "ProgramInvalid", "detail": "program_state_version and operations are required"} if payload["program_state_version"] != state["state_version"]: return {"ok": false, "error": "ProgramStateConflict", "detail": "program state version does not match"} operations = payload["operations"] if len(operations) == 0 or len(operations) > 16: return {"ok": false, "error": "ProgramInvalid", "detail": "operations must contain 1..16 bounded instructions"} if len(operations) > 1 and any(operation.has("kind") and operation["kind"] == "reset_program" for operation in operations): return {"ok": false, "error": "ProgramInvalid", "detail": "reset_program must be the only instruction"} mut next_signals = {name: value for name, value in state["signals"].items()} mut next_parameters = {name: value for name, value in state["parameters"].items()} mut molecular_operations: list[dict[str, any]] = [] mut design_operations: list[dict[str, any]] = [] mut summary: list[str] = [] for operation in operations: if not program_operation_valid(operation): return {"ok": false, "error": "ProgramInvalid", "detail": "an instruction is unsupported or malformed"} if operation["kind"] == "reset_program": next_signals = initial_signal_values() next_parameters = initial_physiology_parameters() summary.append("source_baseline_restored") continue if operation["kind"] == "set_signal": name = normalized_signal(operation["name"]) value = operation["value"] if not signal_value_valid(name, value): return {"ok": false, "error": "ProgramInvalid", "detail": "a signal setting is outside its declared biological bound"} next_signals[name] = value summary.append(name + "=" + str(value)) if name == "molecular_temperature": molecular_operations.append({"kind": "set_thermal_scale", "value": value}) if name == "bond_stiffness": molecular_operations.append({"kind": "set_bond_stiffness", "value": value}) elif operation["kind"] == "set_parameter": name = operation["name"] value = operation["value"] if not physiology_parameter_value_valid(name, value): return {"ok": false, "error": "ProgramInvalid", "detail": "an equation parameter is outside its declared bound"} next_parameters[name] = value summary.append(name + "=" + str(value)) elif operation["kind"] == "design_species": design_operations.append(operation["design"]) summary.append("design_species=" + operation["design"]["name"]) else: molecular_operations.append(operation) summary.append(operation["kind"]) next_state = { "schema": state["schema"], "state_version": state["state_version"] + 1, "signals": next_signals, "parameters": next_parameters, "last_summary": summary, } return {"ok": true, "state": next_state, "molecular_operations": molecular_operations, "design_operations": design_operations, "summary": summary, "reset_molecular": operations[0]["kind"] == "reset_program"}
pub def programming_capabilities() -> dict[str, any] !{}: return { "schema": "sema.biological-programming-capabilities/v1", "backend": "Sema", "max_operations": 16, "max_command_chars": 320, "operations": ["set_signal", "set_parameter", "translate_atom", "add_bond", "remove_bond", "reset_program", "design_species"], "signals": signal_bounds(), "parameters": physiology_parameter_bounds(), "examples": [ "increase glucose to 8 and oxygen to 12", "inhibit cytokine release", "stiffen bonds", "translate atom 12 by 0.5 0 0", "remove bond 12 13", "design peptide ACDEFG as probe-1 targeting insulin", "design helix EALKAEALKA as shield-1 targeting interleukin_1_beta", "design molecule sulfonylurea+benzene as agonist-1 targeting insulin", "set mechanism of probe-1 to secretion_agonist", ], "design_commands": design_capabilities()["commands"], }
test "program reset restores the Sema baseline and rejects mixed instructions": state = initial_program_state() changed = apply_biological_program(state, { "program_state_version": 0, "operations": [signal_operation("glucose", 8.0)], }) ensure changed["ok"] reset = apply_biological_program(changed["state"], { "program_state_version": 1, "operations": [{"kind": "reset_program"}], }) ensure reset["ok"] ensure reset["reset_molecular"] ensure reset["state"]["signals"]["glucose"] == 5.5 ensure reset["state"]["signals"]["bond_stiffness"] == 1.0 mixed = apply_biological_program(reset["state"], { "program_state_version": 2, "operations": [{"kind": "reset_program"}, signal_operation("cytokine", 0.5)], }) ensure not mixed["ok"]src/qmmm_multicode.sema
Section titled “src/qmmm_multicode.sema”"""Pinned 6S34 insulin fixed-partition QM/MM evidence with honest second-code gating."""
assure silver
struct QmmmMulticodeResult: schema: str profile_id: str config_sha256: str backend_source_path: str backend_source_sha256: str sema_contract_source_path: str sema_contract_source_sha256: str oracle_source_path: str oracle_source_sha256: str structure_path: str structure_sha256: str pdb_id: str partition_id: str partition_identity_sha256: str qm_atom_ids: list[str] boundary_identities: Any link_atom_ids: list[str] embedding_site_identities: Any embedding_model: str embedding_total_charge_e: f64 qm_charge_e: int spin_multiplicity: int source_reaction_coordinate_angstrom: f64 reaction_coordinates_angstrom: list[f64] primary_backend: str primary_version: str primary_method: str primary_basis: str primary_status: str primary_executed: bool primary_energies_hartree: list[f64] primary_forces_hartree_per_angstrom: list[f64] primary_mulliken_charges_e: Any primary_scf_iterations: list[int] primary_converged: bool primary_charge_sum_residual_e: f64 secondary_backend: str secondary_requested_version: str secondary_observed_version: str secondary_status: str secondary_failure_code: str secondary_unavailable_reason: str secondary_executed: bool secondary_energies_hartree: list[f64] secondary_forces_hartree_per_angstrom: list[f64] secondary_atomic_charges_e: Any secondary_converged: bool partition_identity_pass: bool primary_technical_pass: bool multicode_energy_parity_pass: bool multicode_force_parity_pass: bool multicode_charge_parity_pass: bool multicode_reaction_coordinate_parity_pass: bool multicode_technical_pass: bool insulin_partition_validated: bool phase7_validated: bool multicode_residuals_available: bool maximum_energy_residual_hartree: f64 maximum_force_residual_hartree_per_angstrom: f64 maximum_atomic_charge_residual_e: f64 scientific_validated: bool evidence_class: str platform: str result_sha256: str direct_oracle_result_sha256: str direct_oracle_path: str direct_residual: f64 direct_parity_pass: bool result_path: str invariant schema == "sema.qmmm-multicode-result/v2" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(backend_source_sha256) == 64 invariant len(sema_contract_source_sha256) == 64 invariant len(oracle_source_sha256) == 64 invariant len(structure_sha256) == 64 invariant pdb_id == "6S34" invariant len(partition_identity_sha256) == 64 invariant len(qm_atom_ids) == 2 invariant len(boundary_identities) == 2 invariant len(link_atom_ids) == 2 invariant len(embedding_site_identities) > 0 invariant qm_charge_e == 0 invariant spin_multiplicity == 1 invariant source_reaction_coordinate_angstrom > 0.0 invariant len(reaction_coordinates_angstrom) > 0 and len(reaction_coordinates_angstrom) <= 5 invariant primary_backend == "PySCF" invariant primary_version == "2.11.0" invariant primary_status == "real_measured" or primary_status == "execution_failed" invariant len(primary_energies_hartree) == len(reaction_coordinates_angstrom) invariant len(primary_forces_hartree_per_angstrom) == len(reaction_coordinates_angstrom) invariant len(primary_mulliken_charges_e) == len(reaction_coordinates_angstrom) invariant primary_charge_sum_residual_e >= 0.0 invariant secondary_backend == "Psi4" invariant secondary_status == "real_measured" or secondary_status == "unavailable" or secondary_status == "version_mismatch" or secondary_status == "execution_failed" invariant not multicode_technical_pass or (secondary_executed and secondary_converged) invariant not multicode_technical_pass or (multicode_energy_parity_pass and multicode_force_parity_pass and multicode_charge_parity_pass and multicode_reaction_coordinate_parity_pass) invariant multicode_residuals_available == multicode_reaction_coordinate_parity_pass invariant multicode_residuals_available or maximum_energy_residual_hartree == -1.0 invariant multicode_residuals_available or maximum_force_residual_hartree_per_angstrom == -1.0 invariant multicode_residuals_available or maximum_atomic_charge_residual_e == -1.0 invariant not multicode_residuals_available or maximum_energy_residual_hartree >= 0.0 invariant not multicode_residuals_available or maximum_force_residual_hartree_per_angstrom >= 0.0 invariant not multicode_residuals_available or maximum_atomic_charge_residual_e >= 0.0 invariant phase7_validated == (multicode_technical_pass and direct_parity_pass) invariant not scientific_validated invariant len(result_sha256) == 64 invariant len(direct_oracle_result_sha256) == 64 invariant len(direct_oracle_path) > 0 invariant direct_residual >= 0.0 invariant len(result_path) > 0
bridge python.inline qmmm_multicode_backend from "foreign/python/qmmm_multicode_backend.py": deps "python>=3.12,<3.13", "numpy==2.4.1", "pyscf==2.11.0" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> QmmmMulticodeResult !{ffi.call}: sem "Run pinned 6S34 insulin fixed-partition QM/MM and require a real independent second code before the Phase 7 multicode gate can pass"
pub def run_profile( config_path: str, oracle_path: str, output_path: str,) -> QmmmMulticodeResult !{ffi.call, fs.read, fs.write}: return qmmm_multicode_backend.run_profile(config_path, oracle_path, output_path)src/qmmm.sema
Section titled “src/qmmm.sema”"""Fixed-partition electrostatic-embedding QM/MM technical evidence."""
assure silver
pub struct QmmmResult: schema: str profile_id: str config_sha256: str backend: str backend_version: str method: str basis: str embedding: str qm_atoms: int mm_point_charges: int charge_e: int spin_2s: int link_atoms: int boundary_treatment: str reaction_coordinate: str coordinate_angstrom: list[f64] energies_hartree: list[f64] forces_hartree_per_bohr: list[f64] reaction_span_kj_mol: f64 energy_symmetry_residual_hartree: f64 force_antisymmetry_residual_hartree_per_bohr: f64 center_force_hartree_per_bohr: f64 gradient_residual_hartree_per_bohr: f64 symmetry_pass: bool gradient_pass: bool technical_pass: bool evidence_class: str adaptive_partition: bool multicode_validated: bool result_sha256: str direct_oracle_result_sha256: str direct_oracle_path: str direct_energy_residual_hartree: f64 direct_force_residual_hartree_per_bohr: f64 direct_gradient_residual_hartree_per_bohr: f64 direct_parity_pass: bool result_path: str invariant schema == "sema.qmmm-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(backend) > 0 and len(backend_version) > 0 invariant len(method) > 0 and len(basis) > 0 invariant len(embedding) > 0 invariant qm_atoms > 0 invariant mm_point_charges > 0 invariant spin_2s >= 0 invariant link_atoms >= 0 invariant len(boundary_treatment) > 0 invariant len(reaction_coordinate) > 0 invariant len(coordinate_angstrom) > 2 invariant len(coordinate_angstrom) == len(energies_hartree) invariant len(coordinate_angstrom) == len(forces_hartree_per_bohr) invariant reaction_span_kj_mol >= 0.0 invariant energy_symmetry_residual_hartree >= 0.0 invariant force_antisymmetry_residual_hartree_per_bohr >= 0.0 invariant center_force_hartree_per_bohr >= 0.0 invariant gradient_residual_hartree_per_bohr >= 0.0 invariant len(result_sha256) == 64 invariant len(direct_oracle_result_sha256) == 64 invariant len(direct_oracle_path) > 0 invariant direct_energy_residual_hartree >= 0.0 invariant direct_force_residual_hartree_per_bohr >= 0.0 invariant direct_gradient_residual_hartree_per_bohr >= 0.0 invariant len(result_path) > 0 invariant evidence_class == "validated_fixed_partition_technical" or evidence_class == "failed_fixed_partition_technical"
pub bridge python.inline qmmm_backend from "foreign/python/qmmm_backend.py": deps "python>=3.12,<3.13" expose: def run_profile(config_path: str, oracle_path: str, output_path: str) -> QmmmResult !{ffi.call}: sem "Run a fixed quantum partition with electrostatic embedding and direct energy-force parity"src/rare_event.sema
Section titled “src/rare_event.sema”"""Bounded well-tempered metadynamics with an exact symmetry reference."""
assure silver
pub struct RareEventResult: schema: str benchmark_id: str method: str method_reference_doi: str engine: str engine_version: str platform: str config_sha256: str system_sha256: str result_sha256: str result_path: str replay_class: str reference_replay_class: str evidence_class: str replicas: int grid_min_nm: f64 grid_max_nm: f64 grid_width: int free_energy_mean_kj_mol: list[f64] free_energy_sem_kj_mol: list[f64] left_population_mean: f64 left_population_sem: f64 free_energy_difference_mean_kj_mol: f64 free_energy_difference_sem_kj_mol: f64 min_transitions: int reference_left_population: f64 reference_free_energy_difference_kj_mol: f64 converged: bool invariant schema == "sema.rare-event-result/v1" invariant len(benchmark_id) > 0 invariant engine == "OpenMM" invariant len(engine_version) > 0 invariant platform == "CPU" invariant len(config_sha256) == 64 invariant len(system_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant replay_class == "statistical" invariant reference_replay_class == "exact" invariant evidence_class == "validated_technical" or evidence_class == "exploratory" invariant replicas >= 2 and replicas <= 8 invariant grid_min_nm < grid_max_nm invariant grid_width > 2 and grid_width <= 1024 invariant len(free_energy_mean_kj_mol) == grid_width invariant len(free_energy_sem_kj_mol) == grid_width invariant left_population_mean >= 0.0 and left_population_mean <= 1.0 invariant left_population_sem >= 0.0 invariant min_transitions >= 0 invariant reference_left_population == 0.5 invariant reference_free_energy_difference_kj_mol == 0.0
pub bridge python.inline rare_event_backend from "foreign/python/rare_event_backend.py": deps "python>=3.12,<3.13" expose: def run_metadynamics(config_path: str, output_path: str) -> RareEventResult !{ffi.call}: sem "Validate well-tempered metadynamics against an exact symmetric population reference"src/readdy_calibration.sema
Section titled “src/readdy_calibration.sema”"""Preregistered ReaDDy calibration qualification with held-out, fail-closed evidence."""
assure silver
pub struct ReaddyCalibrationResult: schema: str profile_id: str config_sha256: str execution_config_sha256: str evidence_sha256: str evidence_rebound_without_execution: bool result_sha256: str source_digests: dict[str, str] package_manifest: dict[str, any] unit_mapping: dict[str, any] target: dict[str, f64] training_design: dict[str, any] calibration_lock: dict[str, any] heldout_design: dict[str, any] heldout_evidence_admission: dict[str, any] heldout_rates: dict[str, any] condition_summaries: list[dict[str, any]] statistics: dict[str, any] gates: dict[str, bool] qualification_pass: bool calibration_evidence_status: str failure_type: str blockers: list[str] phase8_scientific_validation: bool scientific_validated: bool scientific_validation_scope: str training_evidence_manifest: list[dict[str, str]] heldout_evidence_manifest: list[dict[str, str]] runtime_seconds: f64 invariant schema == "sema.readdy-calibration-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(execution_config_sha256) == 64 invariant len(evidence_sha256) == 64 invariant len(result_sha256) == 64 invariant len(source_digests["phase8_profile_sha256"]) == 64 invariant len(source_digests["molecular_result_sha256"]) == 64 invariant calibration_lock["heldout_inspected_before_lock"] == false invariant heldout_design["disjoint_from_training"] == true invariant heldout_design["parameters_locked_before_execution"] == heldout_evidence_admission["chronology_proven"] invariant not qualification_pass or heldout_evidence_admission["chronology_proven"] invariant calibration_evidence_status == "qualified" or calibration_evidence_status == "failed" or calibration_evidence_status == "chronology_unproven" invariant heldout_evidence_admission["chronology_proven"] or calibration_evidence_status == "chronology_unproven" invariant heldout_evidence_admission["chronology_proven"] or failure_type == "ReaddyCalibrationChronologyUnproven" invariant phase8_scientific_validation == false invariant scientific_validated == false invariant qualification_pass or len(failure_type) > 0 invariant qualification_pass or len(blockers) > 0 invariant runtime_seconds >= 0.0
pub bridge python.inline readdy_calibration_backend from "foreign/python/readdy_calibration_backend.py": deps "python>=3.12,<3.13", "numpy==2.4.1", "readdy==2.0.14" expose: def run_profile(config_path: str, direct_path: str, output_path: str) -> ReaddyCalibrationResult !{ffi.call}: sem "Verify digest-bound direct evidence and emit byte-identical Sema qualification output without refitting or rerunning held-out conditions"src/reference.sema
Section titled “src/reference.sema”"""Pinned condition-matched public molecular reference and published-timescale reproduction."""
assure silver
pub struct MolecularReferenceResult: schema: str reference_id: str config_sha256: str artifact_sha256: str target_config_sha256: str result_sha256: str result_path: str license: str primary_reference: str engine: str force_field: str water_model: str integrator: str temperature_k: f64 observable: str replicas: int samples_per_replica: int clusters: int primary_lag_frames: int slow_timescale_ps: f64 fast_timescale_ps: f64 slow_timescale_sem_ps: f64 fast_timescale_sem_ps: f64 right_population_mean: f64 right_population_sem: f64 right_population_by_replica: list[f64] ensemble_transitions: int ensemble_rhat: f64 ensemble_converged: bool effective_samples: f64 lag_relative_spread_max: f64 kmeans_iterations: int kmeans_final_shift: f64 reproduced: bool condition_matched: bool evidence_class: str invariant schema == "sema.molecular-reference-result/v1" invariant len(reference_id) > 0 invariant len(config_sha256) == 64 invariant len(artifact_sha256) == 64 invariant len(target_config_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant license == "CC-BY-4.0" invariant engine == "ACEMD" invariant force_field == "AMBER ff-99SB-ILDN" invariant water_model == "TIP3P" invariant integrator == "Langevin" invariant temperature_k == 300.0 invariant replicas == 3 invariant samples_per_replica == 250000 invariant clusters == 40 invariant primary_lag_frames == 100 invariant slow_timescale_ps > 0.0 invariant fast_timescale_ps > 0.0 invariant slow_timescale_sem_ps >= 0.0 invariant fast_timescale_sem_ps >= 0.0 invariant right_population_mean >= 0.0 and right_population_mean <= 1.0 invariant right_population_sem >= 0.0 invariant len(right_population_by_replica) == replicas invariant ensemble_transitions >= 0 invariant ensemble_rhat >= 0.0 invariant effective_samples >= 0.0 invariant lag_relative_spread_max >= 0.0 invariant kmeans_iterations > 0 and kmeans_iterations <= 50 invariant kmeans_final_shift >= 0.0 invariant evidence_class == "condition_matched_public_reference" or evidence_class == "published_related_reference" or evidence_class == "failed_reference_reproduction"
pub bridge python.inline molecular_reference from "foreign/python/reference_backend.py": deps "python>=3.12,<3.13" expose: def run_reference(config_path: str, output_path: str) -> MolecularReferenceResult !{ffi.call}: sem "Reproduce published alanine relaxation timescales from a hash-pinned public ensemble"src/rerun.sema
Section titled “src/rerun.sema”"""Non-authoritative Rerun recording projection for canonical molecular frames."""
assure silver
pub struct RerunRecording: schema: str path: str frames: int bytes: int sha256: str source_frames_sha256: str source_result_sha256: str coarse_result_sha256: str ensemble_result_sha256: str ensemble_sampling_converged: bool rare_event_result_sha256: str rare_event_technical_converged: bool mace_result_sha256: str mace_technical_pass: bool mace_uncertainty_available: bool mace_molecular_validated: bool model_sha256: str parameter_sha256: str equation_terms: int invariant schema == "sema.rerun-recording/v1" invariant len(path) > 0 invariant frames > 0 and frames <= 101 invariant bytes > 0 and bytes <= 16777216 invariant len(sha256) == 64 invariant len(source_frames_sha256) == 64 invariant len(source_result_sha256) == 64 invariant len(coarse_result_sha256) == 64 invariant len(ensemble_result_sha256) == 64 invariant len(rare_event_result_sha256) == 64 invariant len(mace_result_sha256) == 64 invariant mace_technical_pass == true invariant mace_uncertainty_available == false invariant mace_molecular_validated == false invariant len(model_sha256) == 64 invariant len(parameter_sha256) == 64 invariant equation_terms > 0 and equation_terms <= 32
pub bridge python.inline rerun_projection from "foreign/python/rerun_projection.py": deps "python>=3.12,<3.13" expose: def record_run( frames_path: str, coarse_path: str, ensemble_path: str, rare_event_path: str, mace_path: str, input_path: str, output_path: str, source_result_sha256: str, ) -> RerunRecording !{ffi.call}: sem "Project canonical backend frames into a labeled non-authoritative Rerun recording"src/resolution.sema
Section titled “src/resolution.sema”"""Approximation, negligibility, resolution-graph, and transactional transition contracts."""
from biological_computer.domain import EvidenceRecord, ModelScale
assure silver
pub enum EdgeKind: compose | couple | refine | coarsen | restrict | prolong | observe | parameterize
pub enum TransitionState: requested | prepared | validated | committed | blocked
pub struct ApproximationContract: id: str source_model_id: str target_model_id: str transform: str preserved_observables: list[str] marginalized_degrees: list[str] calibration_domain: str maximum_error: f64 refine_threshold: f64 evidence_ids: list[str] valid: bool invariant len(id) > 0 invariant len(source_model_id) > 0 invariant len(target_model_id) > 0 invariant len(transform) > 0 invariant len(preserved_observables) > 0 and len(preserved_observables) <= 64 invariant len(marginalized_degrees) > 0 and len(marginalized_degrees) <= 128 invariant len(calibration_domain) > 0 invariant maximum_error >= 0.0 invariant refine_threshold >= 0.0 invariant len(evidence_ids) <= 128
struct NegligibilityCertificate: id: str interaction_family: str target_observable: str comparison_scale: str upper_bound_ratio: f64 error_floor_ratio: f64 activation_condition: str evidence_ids: list[str] valid: bool invariant len(id) > 0 invariant len(interaction_family) > 0 invariant len(target_observable) > 0 invariant len(comparison_scale) > 0 invariant upper_bound_ratio >= 0.0 invariant error_floor_ratio >= 0.0 invariant len(activation_condition) > 0 invariant len(evidence_ids) <= 128
struct ResolutionNode: id: str scale: ModelScale model_version: str resolved_degrees: list[str] target_observables: list[str] active: bool invariant len(id) > 0 invariant len(model_version) > 0 invariant len(resolved_degrees) > 0 and len(resolved_degrees) <= 256 invariant len(target_observables) > 0 and len(target_observables) <= 64
pub struct ResolutionEdge: id: str kind: EdgeKind source_node_id: str target_node_id: str approximation: ApproximationContract restriction: str prolongation: str checkpoint_only: bool invariant len(id) > 0 invariant len(source_node_id) > 0 invariant len(target_node_id) > 0 invariant source_node_id != target_node_id invariant len(restriction) > 0 invariant len(prolongation) > 0
pub struct TransitionRecord: sequence: int edge_id: str from_state_version: int to_state_version: int state: TransitionState reason: str evidence_ids: list[str] lost_information: list[str] occurred_at_s: f64 invariant sequence >= 0 invariant len(edge_id) > 0 invariant from_state_version >= 0 invariant to_state_version >= from_state_version invariant len(reason) > 0 invariant len(evidence_ids) <= 128 invariant len(lost_information) <= 128 invariant occurred_at_s >= 0.0
def approximation_valid(contract: ApproximationContract): return contract.valid and len(contract.evidence_ids) > 0 and contract.maximum_error <= contract.refine_threshold
def negligibility_valid(certificate: NegligibilityCertificate): return certificate.valid and len(certificate.evidence_ids) > 0 and certificate.upper_bound_ratio <= certificate.error_floor_ratio
def edge_valid(edge: ResolutionEdge): if edge.kind == EdgeKind.coarsen or edge.kind == EdgeKind.restrict: return approximation_valid(edge.approximation) and len(edge.approximation.marginalized_degrees) > 0 if edge.kind == EdgeKind.refine or edge.kind == EdgeKind.prolong: return approximation_valid(edge.approximation) and len(edge.prolongation) > 0 return approximation_valid(edge.approximation)
pub def prepare_transition(sequence: int, edge: ResolutionEdge, state_version: int, occurred_at_s: f64) -> TransitionRecord !{}: require sequence >= 0 and state_version >= 0 if not edge_valid(edge): return TransitionRecord(sequence=sequence, edge_id=edge.id, from_state_version=state_version, to_state_version=state_version, state=TransitionState.blocked, reason="edge lacks valid approximation evidence", evidence_ids=edge.approximation.evidence_ids, lost_information=edge.approximation.marginalized_degrees, occurred_at_s=occurred_at_s) return TransitionRecord(sequence=sequence, edge_id=edge.id, from_state_version=state_version, to_state_version=state_version + 1, state=TransitionState.prepared, reason="candidate state prepared without mutating active state", evidence_ids=edge.approximation.evidence_ids, lost_information=edge.approximation.marginalized_degrees, occurred_at_s=occurred_at_s)
pub def validate_transition(record: TransitionRecord, evidence: list[EvidenceRecord], observable_error: f64, threshold: f64) -> TransitionRecord !{}: require observable_error >= 0.0 and threshold >= 0.0 if record.state != TransitionState.prepared: return record mut accepted_ids = [] for item in evidence: if item.accepted: accepted_ids.append(item.id) if len(accepted_ids) == 0 or observable_error > threshold: return TransitionRecord(sequence=record.sequence, edge_id=record.edge_id, from_state_version=record.from_state_version, to_state_version=record.from_state_version, state=TransitionState.blocked, reason="held-out observable validation failed", evidence_ids=accepted_ids, lost_information=record.lost_information, occurred_at_s=record.occurred_at_s) return TransitionRecord(sequence=record.sequence, edge_id=record.edge_id, from_state_version=record.from_state_version, to_state_version=record.to_state_version, state=TransitionState.validated, reason="held-out observable validation passed", evidence_ids=accepted_ids, lost_information=record.lost_information, occurred_at_s=record.occurred_at_s)
pub def commit_transition(record: TransitionRecord) -> TransitionRecord !{}: if record.state != TransitionState.validated: return TransitionRecord(sequence=record.sequence, edge_id=record.edge_id, from_state_version=record.from_state_version, to_state_version=record.from_state_version, state=TransitionState.blocked, reason="only validated transitions may commit", evidence_ids=record.evidence_ids, lost_information=record.lost_information, occurred_at_s=record.occurred_at_s) return TransitionRecord(sequence=record.sequence, edge_id=record.edge_id, from_state_version=record.from_state_version, to_state_version=record.to_state_version, state=TransitionState.committed, reason="validated candidate committed atomically", evidence_ids=record.evidence_ids, lost_information=record.lost_information, occurred_at_s=record.occurred_at_s)src/statistics.sema
Section titled “src/statistics.sema”"""Bounded ensemble diagnostics, coarse-state comparison, and PMF correction algebra."""
import math
assure silver
pub struct BasinPopulations: alpha: f64 beta: f64 other: f64 samples: int invariant alpha >= 0.0 and alpha <= 1.0 invariant beta >= 0.0 and beta <= 1.0 invariant other >= 0.0 and other <= 1.0 invariant samples > 0
pub struct EnsembleDiagnostics: samples: int replicas: int mean: f64 variance: f64 lag1_autocorrelation: f64 effective_sample_size: f64 converged: bool invariant samples > 1 and samples <= 1000000 invariant replicas > 0 and replicas <= 1024 invariant variance >= 0.0 invariant lag1_autocorrelation >= -1.0 and lag1_autocorrelation <= 1.0 invariant effective_sample_size >= 0.0 and effective_sample_size <= f64(samples)
pub struct DistributionComparison: total_variation: f64 threshold: f64 passed: bool invariant total_variation >= 0.0 and total_variation <= 1.0 invariant threshold >= 0.0 and threshold <= 1.0
pub struct PmfCorrections: restraint_kj_mol: f64 jacobian_kj_mol: f64 finite_box_kj_mol: f64 standard_state_kj_mol: f64
pub struct PmfResult: raw_delta_g_kj_mol: f64 corrected_delta_g_kj_mol: f64 corrections: PmfCorrections window_overlap_min: f64 effective_sample_size: f64 replicas: int converged: bool validated: bool invariant window_overlap_min >= 0.0 and window_overlap_min <= 1.0 invariant effective_sample_size >= 0.0 invariant replicas > 0 and replicas <= 1024
pub def basin_populations(phi_values: list[f64], psi_values: list[f64]) -> BasinPopulations !{}: require len(phi_values) == len(psi_values) require len(phi_values) > 0 and len(phi_values) <= 1000000 mut alpha_count = 0 mut beta_count = 0 mut index = 0 for phi in phi_values: psi = psi_values[index] if phi >= -2.1 and phi <= -0.5 and psi >= -1.4 and psi <= 0.8: alpha_count = alpha_count + 1 elif phi >= -3.2 and phi <= -1.2 and (psi >= 1.0 or psi <= -2.4): beta_count = beta_count + 1 index = index + 1 count = f64(len(phi_values)) alpha = f64(alpha_count) / count beta = f64(beta_count) / count return BasinPopulations(alpha=alpha, beta=beta, other=1.0 - alpha - beta, samples=len(phi_values))
pub def compare_populations(fine: BasinPopulations, coarse: BasinPopulations, threshold: f64) -> DistributionComparison !{}: require threshold >= 0.0 and threshold <= 1.0 variation = 0.5 * (abs(fine.alpha - coarse.alpha) + abs(fine.beta - coarse.beta) + abs(fine.other - coarse.other)) return DistributionComparison(total_variation=variation, threshold=threshold, passed=variation <= threshold)
def sample_mean(values: list[f64]): require len(values) > 0 and len(values) <= 1000000 return sum(values) / f64(len(values))
def sample_variance(values: list[f64], average: f64): require len(values) > 1 and len(values) <= 1000000 mut total = 0.0 for value in values: delta = value - average total = total + delta * delta return total / f64(len(values) - 1)
def lag1_autocorrelation(values: list[f64], average: f64, variance: f64): require len(values) > 1 and len(values) <= 1000000 if variance == 0.0: return 0.0 mut covariance = 0.0 mut index = 1 for value in values: if index < len(values): covariance = covariance + (value - average) * (values[index] - average) index = index + 1 raw = covariance / (f64(len(values) - 1) * variance) return max(-1.0, min(1.0, raw))
def effective_sample_size(samples: int, autocorrelation: f64): require samples > 1 require autocorrelation >= -1.0 and autocorrelation <= 1.0 if autocorrelation <= 0.0: return f64(samples) return max(1.0, min(f64(samples), f64(samples) * (1.0 - autocorrelation) / (1.0 + autocorrelation)))
pub def diagnose_ensemble(values: list[f64], replicas: int, minimum_effective_samples: f64) -> EnsembleDiagnostics !{}: require replicas > 0 and replicas <= 1024 require minimum_effective_samples > 0.0 average = sample_mean(values) variance = sample_variance(values, average) autocorrelation = lag1_autocorrelation(values, average, variance) effective = effective_sample_size(len(values), autocorrelation) return EnsembleDiagnostics(samples=len(values), replicas=replicas, mean=average, variance=variance, lag1_autocorrelation=autocorrelation, effective_sample_size=effective, converged=replicas >= 2 and effective >= minimum_effective_samples)
def probability_free_energy(probability: f64, temperature_k: f64): require probability > 0.0 and probability <= 1.0 require temperature_k > 0.0 return -0.00831446261815324 * temperature_k * math.log(probability)
pub def corrected_pmf(raw_delta_g_kj_mol: f64, corrections: PmfCorrections, window_overlap_min: f64, effective_samples: f64, replicas: int, converged: bool) -> PmfResult !{}: require window_overlap_min >= 0.0 and window_overlap_min <= 1.0 require effective_samples >= 0.0 corrected = raw_delta_g_kj_mol + corrections.restraint_kj_mol + corrections.jacobian_kj_mol + corrections.finite_box_kj_mol + corrections.standard_state_kj_mol validated = converged and replicas >= 2 and effective_samples >= 100.0 and window_overlap_min >= 0.03 return PmfResult(raw_delta_g_kj_mol=raw_delta_g_kj_mol, corrected_delta_g_kj_mol=corrected, corrections=corrections, window_overlap_min=window_overlap_min, effective_sample_size=effective_samples, replicas=replicas, converged=converged, validated=validated)src/viewer.sema
Section titled “src/viewer.sema”"""Native scene verification, composition binding, and bounded viewer export."""
from std.crypto import file_sha256, sha256_json, sha256_textfrom std.json import decode as decode_json, encode as encode_json, read as read_jsonfrom biological_computer.api import biological_api_contract
assure silver
pub struct ViewerSceneArtifact: schema: str path: str bytes: int scene_sha256: str file_sha256: str source_result_sha256: str source_frames_sha256: str atoms: int bonds: int frames: int volume_result_sha256: str volume_frames: int cellular_voxels: int tissue_voxels: int scene_instances: int protein_atoms: int scenarios: int invariant schema == "sema.multiscale-viewer/v4" invariant len(path) > 0 invariant bytes > 0 and bytes <= 4194304 invariant len(scene_sha256) == 64 and len(file_sha256) == 64 invariant len(source_result_sha256) == 64 and len(source_frames_sha256) == 64 invariant atoms > 0 and atoms <= 256 and bonds > 0 and bonds <= 512 invariant frames > 0 and frames <= 101 invariant len(volume_result_sha256) == 64 invariant volume_frames > 1 and volume_frames <= 64 invariant cellular_voxels > 0 and cellular_voxels <= 131072 invariant tissue_voxels > 0 and tissue_voxels <= 131072 invariant scene_instances > 0 and scene_instances <= 16384 invariant protein_atoms > 0 and protein_atoms <= 4096 invariant scenarios > 0 and scenarios <= 16
def ala2_topology_bonds(): return [ [4, 1], [4, 5], [1, 0], [1, 2], [1, 3], [4, 6], [14, 8], [14, 15], [8, 10], [8, 9], [8, 6], [10, 11], [10, 12], [10, 13], [7, 6], [14, 16], [18, 19], [18, 20], [18, 21], [18, 16], [17, 16], ]
def parse_pinned_topology(pdb_text: str) !{}: sem "Parse the source-bound alanine PDB metadata in native Sema and attach its curated OpenMM topology" require len(pdb_text) > 0 and len(pdb_text) <= 1048576 atoms = [] for line in pdb_text.split("\n"): if not line.startswith("ATOM") or len(line) < 78: continue residue_name = line.substring(17, 3).strip() if residue_name == "HOH" or residue_name == "WAT": continue name = line.substring(12, 4).strip() element = line.substring(76, 2).strip() if len(element) == 0: element = name.substring(0, 1) atoms.append({ "source_index": int(line.substring(6, 5).strip()) - 1, "element": element, "residue_name": residue_name, "residue_id": line.substring(22, 4).strip(), "name": name, }) bonds = ala2_topology_bonds() ensure len(atoms) == 22 and len(bonds) == 21 ensure all(bond[0] < len(atoms) and bond[1] < len(atoms) for bond in bonds) return {"atoms": atoms, "bonds": bonds}
def atom_style(element: str): if element == "H": return {"color": "#edf3f6", "radius_angstrom": 1.2} if element == "C": return {"color": "#424c56", "radius_angstrom": 1.7} if element == "N": return {"color": "#396ec6", "radius_angstrom": 1.55} if element == "O": return {"color": "#e7554f", "radius_angstrom": 1.52} if element == "S": return {"color": "#e4b84e", "radius_angstrom": 1.8} return {"color": "#9a7fb4", "radius_angstrom": 1.6}
def decorate_topology(raw: dict[str, any]): ensure len(raw["atoms"]) > 0 and len(raw["atoms"]) <= 256 and len(raw["bonds"]) > 0 atoms = [] mut index = 0 for atom in raw["atoms"]: style = atom_style(atom["element"]) atoms.append({ "index": index, "source_index": atom["source_index"], "element": atom["element"], "label": atom["residue_name"] + ":" + atom["residue_id"] + ":" + atom["name"], "color": style["color"], "radius_angstrom": style["radius_angstrom"], }) index = index + 1 return {"atoms": atoms, "bonds": raw["bonds"]}
def load_frames(source: dict[str, any]) !{fs.read}: frames_path = "runs/cpu/" + path.basename(source["frames_path"]) ensure path.is_relative_to(frames_path, "runs/cpu") ensure file_sha256(frames_path) == source["frames_sha256"] payload = fs.read_text(frames_path)? frames = [decode_json(line) for line in payload.split("\n") if len(line) > 0] ensure len(frames) == source["frames"] and len(frames) > 0 and len(frames) <= 101 return frames
def measurement_sources(): return [{ "id": "idr0116-deboer-npod", "title": "Large-scale electron microscopy database for human type 1 diabetes", "sample": "Homo sapiens pancreatic islet tissue", "modality": "scanning-transmission electron microscopy", "fidelity": "measured", "data_doi": "10.17867/10000168", "publication_doi": "10.1038/s41467-020-16287-5", "license": "CC-BY-4.0", "image_id": 13457674, "image_name": "6229-2015-246.ome.tiff", "pixel_size_nm": 2.52784054231644, "dimensions_px": [47284, 47229], "preview_url": "https://cdn.ncbi.nlm.nih.gov/pmc/blobs/8148/7235089/e8391cb31b2a/41467_2020_16287_Fig1_HTML.jpg", "local_preview_url": "/data/idr0116-deboer-npod-preview.jpg", "deep_zoom_url": "https://idr.openmicroscopy.org/webclient/?show=image-13457674", "attribution": "de Boer et al., Nature Communications 11, 2475 (2020), IDR0116", "warning": "Static measured external reference; it does not depict or supply geometry for the simulated live state", "role": "external_reference_only", "geometry_input": false, }]
def composition_profiles(): return { "beta": {"name": "β cell", "hormone": "insulin / IAPP", "markers": ["INS", "IAPP", "PCSK1", "SLC30A8"], "granule": "dense crystalline core; sulfur-rich insulin", "elements": ["N", "S"], "structures": ["RCSB 6S34"], "evidence": "10.1038/s41467-020-16287-5"}, "alpha": {"name": "α cell", "hormone": "glucagon", "markers": ["GCG", "TTR", "LOXL4", "IRX2"], "granule": "dense round core; phosphorus-enriched", "elements": ["N", "P"], "structures": ["RCSB 1GCN"], "evidence": "10.1038/s41467-020-16287-5"}, "delta": {"name": "δ cell", "hormone": "somatostatin", "markers": ["SST", "HHEX", "RBP4", "GHSR"], "granule": "homogeneous low-density endocrine granule", "elements": ["N"], "structures": [], "evidence": "10.1038/s41467-020-16287-5"}, "pp": {"name": "PP / γ cell", "hormone": "pancreatic polypeptide", "markers": ["PPY", "PNLIPRP1", "CARTPT"], "granule": "small electron-dense endocrine granule", "elements": ["N"], "structures": [], "evidence": "10.1038/s41467-020-16287-5"}, "acinar": {"name": "Acinar cell", "hormone": "digestive enzyme cargo", "markers": ["PRSS1", "AMY2A", "CPA1", "REG1A"], "granule": "large apical zymogen granules", "elements": ["N"], "structures": [], "evidence": "10.1038/s41467-020-16287-5"}, "adipocyte": {"name": "Adipocyte", "hormone": "adipokine / lipid cargo", "markers": ["PLIN1", "ADIPOQ", "FABP4", "LPL"], "granule": "dominant neutral-lipid droplet; peripheral nucleus", "elements": ["C", "O"], "structures": [], "evidence": "model descriptor"}, "immune": {"name": "Innate immune cell", "hormone": "granule and cytokine cargo", "markers": ["PTPRC", "S100A8", "S100A9", "FCGR3B"], "granule": "heterogeneous lysosomal / secretory granules", "elements": ["N", "S"], "structures": [], "evidence": "10.1038/s41467-020-16287-5"}, "vessel": {"name": "Microvascular segment", "hormone": "blood plasma and endothelial membrane", "markers": ["PECAM1", "VWF", "KDR", "CD34"], "granule": "Weibel-Palade bodies in endothelial wall", "elements": ["N", "P", "S"], "structures": [], "evidence": "10.2337/db09-1177"}, }
pub def prepare_viewer() -> ViewerSceneArtifact !{ffi.call, fs.read, fs.write}: sem "Verify scientific artifacts in native Sema and publish a composition-bound scene" result = read_json("runs/cpu/cpu-result.json") ensure result["schema"] == "sema.openmm-benchmark/v1" result_digest = result["result_sha256"] result_identity = {key: value for key, value in result.items() if key != "result_sha256" and key != "frames_path" and key != "initial_forces_path" and key != "minimized_forces_path"} ensure sha256_json(result_identity) == result_digest frames = load_frames(result) raw_topology = parse_pinned_topology(fs.read_text(".sema/cache/inputs/" + result["input_sha256"] + ".pdb")?) topology = decorate_topology(raw_topology) ensure all(len(frame["peptide_positions_nm"]) == len(topology["atoms"]) for frame in frames) volume_path = "runs/volumes/cellular-tissue.json" expected_volume_file_sha256 = "675c5208e7a100e78924995fb38a3f56510f551f6e4c59ac3402382445f0f14b" expected_volume_result_sha256 = "3a141fa21788f76ea589105ec65052e17b5185685283ee62e47a450dde0b0bf5" volume_file_digest = file_sha256(volume_path) ensure volume_file_digest == expected_volume_file_sha256 volume_result = read_json(volume_path) ensure volume_result["schema"] == "sema.biological-volume-result/v1" and volume_result["phase10_technical_pass"] ensure volume_result["source_binding_pass"] and volume_result["result_sha256"] == expected_volume_result_sha256 volume_identity = {key: value for key, value in volume_result.items() if key != "result_sha256"} recomputed_volume_result_sha256 = sha256_json(volume_identity) ensure recomputed_volume_result_sha256 == volume_result["result_sha256"] ensure volume_result["source_result_sha256"] == volume_result["volumes"]["source"]["result_sha256"] volume_sidecar_digest = fs.read_text(volume_path + ".sha256")?.split(" ")[0] ensure volume_sidecar_digest == volume_file_digest volumes = volume_result["volumes"] ensure volumes["schema"] == "sema.biological-volume-frames/v2" ensure volumes["cellular"]["schema"] == "sema.segment-volume/v1" and volumes["tissue"]["schema"] == "sema.segment-volume/v1" scene_model = volumes["scene_model"] ensure scene_model["schema"] == "sema.biological-scene-model/v1" ensure scene_model["tissue"]["cell_count"] <= scene_model["budgets"]["max_visible_instances"] cellular_contexts = scene_model["cellular"]["contexts"] ensure len(cellular_contexts) == 8 and len(scene_model["detail_bindings"]) == 112 context_ids = [context["id"] for context in cellular_contexts] ensure all(context_id in context_ids for context_id in ["beta", "alpha", "delta", "pp", "acinar", "adipocyte", "immune", "vessel"]) for context in cellular_contexts: ensure context["kind"] == "cell" or context["kind"] == "vessel" ensure context["radius_um"] > 0.0 and context["nucleus_radius_um"] > 0.0 ensure len(context["shape"]) == 3 and len(context["nucleus_offset_um"]) == 3 ensure context["counts"]["granule"] > 0 and context["counts"]["mitochondrion"] > 0 ensure context["counts"]["receptor"] > 0 and context["counts"]["protein"] > 0 ensure context["molecular_fidelity"] == "derived" or context["molecular_fidelity"] == "illustrative" physical_objects = scene_model["physical_objects"] ensure physical_objects["schema"] == "sema.cellular-physical-object-profiles/v1" ensure physical_objects["fidelity"] == "derived_unvalidated" and not physical_objects["scientific_validated"] ensure len(physical_objects["profiles"]) == 12 ensure all(profile["radius_nm"] > 0.0 and profile["molecular_entities"] > 0 for profile in physical_objects["profiles"]) visual_frames = [] for frame in frames: visual_frames.append({ "step": frame["step"], "physical_time_ps": frame["physical_time_ps"], "positions_angstrom": [[coordinate * 10.0 for coordinate in position] for position in frame["peptide_positions_nm"]], "forces_kj_mol_nm": frame["peptide_forces_kj_mol_nm"], "potential_energy_kj_mol": frame["potential_energy_kj_mol"], "kinetic_energy_kj_mol": frame["kinetic_energy_kj_mol"], "max_force_kj_mol_nm": frame["max_force_kj_mol_nm"], "phi_rad": frame["phi_rad"], "psi_rad": frame["psi_rad"], "energy_terms_kj_mol": frame["energy_terms_kj_mol"], }) volume_frames = {key: value for key, value in volumes.items() if key != "scene_model"} scene = { "schema": "sema.multiscale-viewer/v4", "scenario_id": result["benchmark_id"], "source": { "mode": "canonical_recording_replay", "live_compute": false, "geometry_origin": "reconstructed_molecular_reference_plus_simulated_cellular_tissue", "result_sha256": result_digest, "frames_sha256": result["frames_sha256"], "model_sha256": result["system_sha256"], "parameter_sha256": result["config_sha256"], "equation_version": 2, "parameter_version": 2, "volume_result_sha256": volume_result["result_sha256"], "volume_file_sha256": file_sha256("runs/volumes/cellular-tissue.json"), "volume_payload_sha256": volume_result["volume_payload_sha256"], "volume_profile_id": volume_result["profile_id"], "rendered_cellular_tissue_geometry_origin": "simulated", "rendered_cellular_tissue_geometry_fidelity": "derived_unvalidated", "external_reference_role": "external_reference_only", "external_reference_geometry_input": false, }, "topology": topology, "frames": visual_frames, "volumes": volume_frames, "scene_model": scene_model, "measurement_sources": measurement_sources(), "api_contract": biological_api_contract(), "composition_profiles": composition_profiles(), "lod": [ {"id": "atomic", "scale_label": "0.1–10 nm", "available": true, "fidelity": "canonical", "origin": "reconstructed", "representation": "element-colored atoms plus strain-coded covalent cylinders", "warning": "RCSB 6S34 neighborhood; edited motion is a bounded mechanical model"}, {"id": "molecular", "scale_label": "1 nm–1 µm", "available": true, "fidelity": "canonical", "origin": "reconstructed", "representation": "ball-and-stick insulin topology with distinct atom and bond channels", "warning": "RCSB 6S34 assembly geometry; live motion is not molecular dynamics"}, {"id": "cellular", "scale_label": "1–100 µm", "available": true, "fidelity": "derived_unvalidated", "origin": "simulated", "representation": "composition-constrained simulated cell and organelle geometry", "warning": "Rendered geometry is simulated, derived, and unvalidated; measured IDR0116 imagery is external reference only and is not a geometry input"}, {"id": "tissue", "scale_label": "0.1–1 mm", "available": true, "fidelity": "derived_unvalidated", "origin": "simulated", "representation": "simulated endocrine, exocrine, immune, matrix, and vascular tissue geometry", "warning": "Rendered geometry is simulated, derived, and unvalidated; measured IDR0116 imagery is external reference only and is not a geometry input"}, ], } scene["scene_sha256"] = sha256_json(scene) payload = encode_json(scene) ensure len(payload) <= 4194304 output_path = "viewer/public/data/scene.json" fs.write_text(output_path, payload)? file_digest = sha256_text(payload) fs.write_text(output_path + ".sha256", file_digest + " scene.json\n")? return ViewerSceneArtifact( schema=scene["schema"], path=output_path, bytes=len(payload), scene_sha256=scene["scene_sha256"], file_sha256=file_digest, source_result_sha256=result_digest, source_frames_sha256=result["frames_sha256"], atoms=len(topology["atoms"]), bonds=len(topology["bonds"]), frames=len(frames), volume_result_sha256=volume_result["result_sha256"], volume_frames=volume_result["frames"], cellular_voxels=volume_result["cellular_voxels"], tissue_voxels=volume_result["tissue_voxels"], scene_instances=scene_model["tissue"]["cell_count"], protein_atoms=scene_model["molecular"]["positions_angstrom"]["items"], scenarios=len(scene_model["scenarios"]), )src/visualization.sema
Section titled “src/visualization.sema”"""Non-authoritative multiscale visual bindings and live equation-frame contracts."""
assure silver
pub enum FidelityClass: canonical | derived | interpolated | illustrative | unknown
pub enum VisualScale: field_quantum | atomic | molecular | cellular | tissue
pub enum GeometryOrigin: measured | simulated | reconstructed | illustrative | unknown
pub enum EquationUpdateKind: state_step | parameter_transition | structural_transition
pub struct EntityFocusPath: path_id: str entity_ids: list[str] selected_depth: int invariant len(path_id) > 0 invariant len(entity_ids) > 0 and len(entity_ids) <= 8 invariant selected_depth >= 0 and selected_depth < len(entity_ids)
pub struct ComplexityScenario: id: str glucose_millimolar: f64 oxygen_fraction: f64 cytokine_fraction: f64 insulin_demand_fraction: f64 illustrative: bool invariant len(id) > 0 invariant glucose_millimolar >= 0.0 and glucose_millimolar <= 40.0 invariant oxygen_fraction >= 0.0 and oxygen_fraction <= 1.0 invariant cytokine_fraction >= 0.0 and cytokine_fraction <= 1.0 invariant insulin_demand_fraction >= 0.0 and insulin_demand_fraction <= 1.0 invariant illustrative
enum BiologicalEditKind: signal | morphology | motility | thermal | bond_strength | bond_form | bond_break | reset
enum BiologicalEditTarget: all | beta_cell | alpha_cell | delta_cell | acinar_cell | adipocyte | immune_cell | vessel | granule | mitochondrion | receptor | protein
struct BiologicalEditOperation: kind: BiologicalEditKind target: BiologicalEditTarget scalar: f64 atom_index_a: int atom_index_b: int compiled_equation: str invariant scalar >= 0.0 and scalar <= 4.0 invariant atom_index_a >= -1 and atom_index_b >= -1 invariant len(compiled_equation) > 0 and len(compiled_equation) <= 160
struct BiologicalEditPlan: schema: str request_id: str natural_language: str compiler_id: str source_state_version: int operations: list[BiologicalEditOperation] invariant schema == "sema.biological-edit-plan/v1" invariant len(request_id) > 0 invariant len(natural_language) > 0 and len(natural_language) <= 320 invariant len(compiler_id) > 0 invariant source_state_version > 0 invariant len(operations) > 0 and len(operations) <= 8
struct BiologicalEditBudget: max_operations: int max_structural_edits: int atom_count: int max_visible_instances: int candidate_visible_instances: int invariant max_operations > 0 and max_operations <= 8 invariant max_structural_edits >= 0 and max_structural_edits <= 16 invariant atom_count > 0 invariant max_visible_instances > 0 invariant candidate_visible_instances >= 0
struct BiologicalEditDecision: request_id: str admissible: bool live_computed: bool scientific_fidelity: FidelityClass accepted_operations: int reason: str invariant len(request_id) > 0 invariant accepted_operations >= 0 and accepted_operations <= 8 invariant len(reason) > 0
def biological_edit_operation_valid(operation: BiologicalEditOperation, atom_count: int): require atom_count > 0 if operation.kind == BiologicalEditKind.bond_form or operation.kind == BiologicalEditKind.bond_break: return operation.atom_index_a >= 0 and operation.atom_index_a < atom_count and operation.atom_index_b >= 0 and operation.atom_index_b < atom_count and operation.atom_index_a != operation.atom_index_b if operation.kind == BiologicalEditKind.reset: return operation.scalar == 0.0 return operation.scalar > 0.0
def admit_biological_edit(plan: BiologicalEditPlan, budget: BiologicalEditBudget): if len(plan.operations) > budget.max_operations: return BiologicalEditDecision(request_id=plan.request_id, admissible=false, live_computed=false, scientific_fidelity=FidelityClass.illustrative, accepted_operations=0, reason="compiled edit exceeds the operation budget") if budget.candidate_visible_instances > budget.max_visible_instances: return BiologicalEditDecision(request_id=plan.request_id, admissible=false, live_computed=false, scientific_fidelity=FidelityClass.illustrative, accepted_operations=0, reason="edited population exceeds the visible-instance budget") mut structural_edits = 0 for operation in plan.operations: if not biological_edit_operation_valid(operation, budget.atom_count): return BiologicalEditDecision(request_id=plan.request_id, admissible=false, live_computed=false, scientific_fidelity=FidelityClass.illustrative, accepted_operations=0, reason="compiled edit contains an invalid bounded operation") if operation.kind == BiologicalEditKind.bond_form or operation.kind == BiologicalEditKind.bond_break: structural_edits = structural_edits + 1 if structural_edits > budget.max_structural_edits: return BiologicalEditDecision(request_id=plan.request_id, admissible=false, live_computed=false, scientific_fidelity=FidelityClass.illustrative, accepted_operations=0, reason="compiled edit exceeds the structural-change budget") return BiologicalEditDecision(request_id=plan.request_id, admissible=true, live_computed=true, scientific_fidelity=FidelityClass.illustrative, accepted_operations=len(plan.operations), reason="bounded edit admitted to the live computed visual simulation")
pub struct FieldOfViewBudget: field_of_view_m: f64 candidate_instances: int required_upload_bytes: int desired_update_hz: int max_visible_instances: int max_upload_bytes: int max_update_hz: int invariant field_of_view_m >= 0.000000001 and field_of_view_m <= 0.001 invariant candidate_instances >= 0 invariant required_upload_bytes >= 0 invariant desired_update_hz > 0 invariant max_visible_instances > 0 invariant max_upload_bytes > 0 invariant max_update_hz > 0
pub struct MultiscaleComputeDecision: scale: VisualScale field_of_view_m: f64 visible_instances: int update_hz: int admissible: bool reason: str invariant field_of_view_m >= 0.000000001 and field_of_view_m <= 0.001 invariant visible_instances >= 0 invariant update_hz > 0 invariant len(reason) > 0
def visual_scale_for_field(field_of_view_m: f64): require field_of_view_m >= 0.000000001 and field_of_view_m <= 0.001 if field_of_view_m <= 0.00000001: return VisualScale.atomic if field_of_view_m <= 0.000001: return VisualScale.molecular if field_of_view_m <= 0.0001: return VisualScale.cellular return VisualScale.tissue
pub def decide_multiscale_compute(budget: FieldOfViewBudget) -> MultiscaleComputeDecision !{}: scale = visual_scale_for_field(budget.field_of_view_m) visible_instances = min(budget.candidate_instances, budget.max_visible_instances) update_hz = min(budget.desired_update_hz, budget.max_update_hz) if budget.required_upload_bytes > budget.max_upload_bytes: return MultiscaleComputeDecision(scale=scale, field_of_view_m=budget.field_of_view_m, visible_instances=0, update_hz=update_hz, admissible=false, reason="GPU upload budget exceeded") if budget.candidate_instances > budget.max_visible_instances: return MultiscaleComputeDecision(scale=scale, field_of_view_m=budget.field_of_view_m, visible_instances=visible_instances, update_hz=update_hz, admissible=true, reason="field-of-view population bounded by instance budget") return MultiscaleComputeDecision(scale=scale, field_of_view_m=budget.field_of_view_m, visible_instances=visible_instances, update_hz=update_hz, admissible=true, reason="field-of-view population admitted")
pub def focus_path_valid(path: EntityFocusPath) -> bool !{}: for entity_id in path.entity_ids: if len(entity_id) == 0: return false return true
pub struct EquationTermSample: term_id: str symbol: str value: f64 unit_symbol: str owner_model_id: str invariant len(term_id) > 0 invariant len(symbol) > 0 invariant len(unit_symbol) > 0 invariant len(owner_model_id) > 0
pub struct EquationStateSample: entity_id: str model_id: str model_version: int equation_id: str equation_version: int parameter_version: int update_kind: EquationUpdateKind terms: list[EquationTermSample] residuals: list[EquationTermSample] active_constraints: list[str] transition_id: str cause: str invariant len(entity_id) > 0 invariant len(model_id) > 0 invariant model_version > 0 invariant len(equation_id) > 0 invariant equation_version > 0 invariant parameter_version > 0 invariant len(cause) > 0
pub struct VisualPrimitiveBinding: primitive_id: str entity_id: str observation_id: str source_state_version: int scale: VisualScale fidelity: FidelityClass origin: GeometryOrigin source_algorithm: str source_parameters: list[str] invariant len(primitive_id) > 0 invariant len(entity_id) > 0 invariant len(observation_id) > 0 invariant source_state_version > 0 invariant len(source_algorithm) > 0
pub struct VisualObservationEnvelope: schema: str scenario_id: str run_id: str observation_id: str physical_time_s: f64 scheduler_tick: int state_version: int resolution_version: int model_version: int equation_version: int parameter_version: int source_frame_age_ms: f64 bindings: list[VisualPrimitiveBinding] equation_states: list[EquationStateSample] dropped_frames: int interpolation_ratio: f64 invariant schema == "sema.biological-visual-observation/v1" invariant len(scenario_id) > 0 invariant len(run_id) > 0 invariant len(observation_id) > 0 invariant physical_time_s >= 0.0 invariant scheduler_tick >= 0 invariant state_version > 0 invariant resolution_version > 0 invariant model_version > 0 invariant equation_version > 0 invariant parameter_version > 0 invariant source_frame_age_ms >= 0.0 invariant dropped_frames >= 0 invariant interpolation_ratio >= 0.0 and interpolation_ratio <= 1.0
def distinct_binding_ids(bindings: list[VisualPrimitiveBinding]): mut seen: list[str] = [] for binding in bindings: for primitive_id in seen: if primitive_id == binding.primitive_id: return false seen.append(binding.primitive_id) return true
def equations_cover_canonical_bindings( bindings: list[VisualPrimitiveBinding], equations: list[EquationStateSample],): for binding in bindings: if binding.fidelity == FidelityClass.canonical: mut found = false for equation in equations: if equation.entity_id == binding.entity_id: found = true if not found: return false return true
pub def validate_visual_observation(frame: VisualObservationEnvelope) -> bool !{}: if not distinct_binding_ids(frame.bindings): return false for binding in frame.bindings: if binding.source_state_version != frame.state_version: return false if binding.fidelity == FidelityClass.illustrative and binding.origin != GeometryOrigin.illustrative: return false if binding.fidelity == FidelityClass.unknown and binding.origin != GeometryOrigin.unknown: return false for equation in frame.equation_states: if equation.model_version != frame.model_version: return false if equation.equation_version != frame.equation_version: return false if equation.parameter_version != frame.parameter_version: return false return equations_cover_canonical_bindings(frame.bindings, frame.equation_states)
def unknown_binding( primitive_id: str, entity_id: str, observation_id: str, state_version: int, scale: VisualScale, reason: str,): require len(reason) > 0 return VisualPrimitiveBinding( primitive_id=primitive_id, entity_id=entity_id, observation_id=observation_id, source_state_version=state_version, scale=scale, fidelity=FidelityClass.unknown, origin=GeometryOrigin.unknown, source_algorithm=reason, source_parameters=[], )
pub enum VisualRepresentation: particles | topology_bonds | occupancy_envelope | scalar_volume | segmented_volume | instanced_cells | instanced_organelles | instanced_vessels | instanced_proteins
pub struct SemanticScaleSource: source_id: str scale: VisualScale minimum_length_m: f64 maximum_length_m: f64 available: bool fidelity: FidelityClass origin: GeometryOrigin observation_id: str representation_ids: list[VisualRepresentation] source_algorithm: str invariant len(source_id) > 0 invariant minimum_length_m > 0.0 invariant maximum_length_m >= minimum_length_m invariant len(representation_ids) <= 8 invariant len(source_algorithm) > 0
struct ScaleDetailBinding: id: str parent_scale: VisualScale parent_selector: str child_scale: VisualScale child_model_id: str default_child_kind: str default_child_index: int binding: str fidelity: FidelityClass evidence_ids: list[str] invariant len(id) > 0 invariant len(parent_selector) > 0 invariant len(default_child_kind) > 0 invariant len(binding) > 0 invariant len(child_model_id) > 0 invariant default_child_index >= 0 invariant len(evidence_ids) > 0 and len(evidence_ids) <= 128
struct MultiscaleCouplingEdge: id: str source_scale: VisualScale target_scale: VisualScale source_observable: str target_observable: str coupling_expression: str unit_symbol: str maximum_error: f64 evidence_ids: list[str] validated: bool invariant len(id) > 0 invariant len(source_observable) > 0 invariant len(target_observable) > 0 invariant len(coupling_expression) > 0 invariant len(unit_symbol) > 0 invariant maximum_error >= 0.0 invariant len(evidence_ids) <= 128
def detail_refinement_admissible(binding: ScaleDetailBinding, parent_entity_id: str): return binding.parent_selector == parent_entity_id and binding.parent_scale != binding.child_scale and len(binding.evidence_ids) > 0
def coupling_claim_admissible(edge: MultiscaleCouplingEdge): return edge.validated and len(edge.evidence_ids) > 0
pub struct ViewportQuery: query_id: str requested_scale: VisualScale field_of_view_m: f64 observation_id: str state_version: int resolution_version: int invariant len(query_id) > 0 invariant field_of_view_m > 0.0 invariant len(observation_id) > 0 invariant state_version >= 0 invariant resolution_version >= 0
pub struct SemanticZoomDecision: query_id: str requested_scale: VisualScale rendered_scale: VisualScale renderable: bool fidelity: FidelityClass origin: GeometryOrigin source_id: str source_observation_id: str representation_ids: list[VisualRepresentation] reason: str invariant len(query_id) > 0 invariant len(representation_ids) <= 8 invariant len(reason) > 0
pub def decide_semantic_zoom(query: ViewportQuery, sources: list[SemanticScaleSource]) -> SemanticZoomDecision !{}: for source in sources: if source.scale != query.requested_scale: continue if not source.available: return SemanticZoomDecision(query_id=query.query_id, requested_scale=query.requested_scale, rendered_scale=query.requested_scale, renderable=false, fidelity=FidelityClass.unknown, origin=GeometryOrigin.unknown, source_id=source.source_id, source_observation_id="", representation_ids=[], reason="requested scale has no admissible geometry source") if query.field_of_view_m < source.minimum_length_m or query.field_of_view_m > source.maximum_length_m: return SemanticZoomDecision(query_id=query.query_id, requested_scale=query.requested_scale, rendered_scale=query.requested_scale, renderable=false, fidelity=FidelityClass.unknown, origin=GeometryOrigin.unknown, source_id=source.source_id, source_observation_id=source.observation_id, representation_ids=[], reason="viewport field of view is outside the source scale interval") if source.observation_id != query.observation_id: return SemanticZoomDecision(query_id=query.query_id, requested_scale=query.requested_scale, rendered_scale=query.requested_scale, renderable=false, fidelity=FidelityClass.unknown, origin=GeometryOrigin.unknown, source_id=source.source_id, source_observation_id=source.observation_id, representation_ids=[], reason="scale source is stale for the current observation") if source.fidelity == FidelityClass.unknown or source.origin == GeometryOrigin.unknown or len(source.representation_ids) == 0: return SemanticZoomDecision(query_id=query.query_id, requested_scale=query.requested_scale, rendered_scale=query.requested_scale, renderable=false, fidelity=FidelityClass.unknown, origin=GeometryOrigin.unknown, source_id=source.source_id, source_observation_id=source.observation_id, representation_ids=[], reason="scale source lacks explicit fidelity, origin, or representation") return SemanticZoomDecision(query_id=query.query_id, requested_scale=query.requested_scale, rendered_scale=source.scale, renderable=true, fidelity=source.fidelity, origin=source.origin, source_id=source.source_id, source_observation_id=source.observation_id, representation_ids=source.representation_ids, reason="requested semantic scale is evidence-bound") return SemanticZoomDecision(query_id=query.query_id, requested_scale=query.requested_scale, rendered_scale=query.requested_scale, renderable=false, fidelity=FidelityClass.unknown, origin=GeometryOrigin.unknown, source_id="", source_observation_id="", representation_ids=[], reason="requested scale is absent from the resolution graph")src/volume.sema
Section titled “src/volume.sema”"""Versioned cellular and tissue segment-volume frames for bounded live replay."""
from std.crypto import file_sha256
assure silver
pub struct BiologicalVolumeResult: schema: str profile_id: str config_sha256: str source_result_sha256: str result_sha256: str result_path: str frames: int frame_interval_s: f64 cellular_voxels: int tissue_voxels: int cellular_segments: int tissue_segments: int scene_instances: int insulin_atoms: int scenario_count: int volume_payload_bytes: int deterministic_pass: bool source_binding_pass: bool phase10_technical_pass: bool scientific_validated: bool evidence_class: str invariant schema == "sema.biological-volume-result/v1" invariant len(profile_id) > 0 invariant len(config_sha256) == 64 invariant len(source_result_sha256) == 64 invariant len(result_sha256) == 64 invariant len(result_path) > 0 invariant frames > 1 and frames <= 64 invariant frame_interval_s > 0.0 invariant cellular_voxels > 0 and cellular_voxels <= 131072 invariant tissue_voxels > 0 and tissue_voxels <= 131072 invariant cellular_segments > 0 and cellular_segments <= 32 invariant tissue_segments > 0 and tissue_segments <= 16 invariant scene_instances > 0 and scene_instances <= 16384 invariant insulin_atoms > 0 and insulin_atoms <= 4096 invariant scenario_count > 0 and scenario_count <= 16 invariant volume_payload_bytes > 0 and volume_payload_bytes <= 4194304 invariant evidence_class == "bounded_simulated_volume" or evidence_class == "failed_simulated_volume"
bridge python.inline volume_backend from "foreign/python/volume_backend.py": deps "python>=3.12,<3.13" "numpy>=2.4.1" "openmm>=8.5.0,<8.6.0" expose: def run_profile(config_path: str, output_path: str) -> BiologicalVolumeResult !{ffi.call}: sem "Generate source-bound segmented cellular and tissue volume frames for deterministic replay" ensure result.deterministic_pass ensure result.source_binding_pass ensure result.phase10_technical_pass ensure result.scientific_validated == false
pub def run_volume_profile(config_path: str, output_path: str) -> BiologicalVolumeResult !{ffi.call, fs.read, fs.write}: sem "Run the numerical volume kernel, then bind its artifact with a native Sema digest" ensure path.is_relative_to(output_path, "runs/volumes") generated = volume_backend.run_profile(config_path, output_path) digest = file_sha256(output_path) fs.write_text(output_path + ".sha256", digest + " " + path.basename(output_path) + "\n")? return generatedReflected API
Section titled “Reflected API”Proposal-only agent contract for bounded biological programming.
def propose_agent_program
Section titled “def propose_agent_program”def propose_agent_program(payload: dict[str, any]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
Returns dict[str, any]
Effects !{}
def agent_capabilities
Section titled “def agent_capabilities”def agent_capabilities() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
Canonical HTTP contract emitted with every biological-computer scene.
def biological_api_contract
Section titled “def biological_api_contract”def biological_api_contract() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
assurance
Section titled “assurance”Behavioral assurance gates for the multiscale biological-computer contracts.
def digest
Section titled “def digest”def digest()def evidence
Section titled “def evidence”def evidence(id: str, accepted: bool)Parameters
| name | type |
|---|---|
id |
str |
accepted |
bool |
def alanine_topology
Section titled “def alanine_topology”def alanine_topology()def approximation
Section titled “def approximation”def approximation(valid: bool, maximum_error: f64)Parameters
| name | type |
|---|---|
valid |
bool |
maximum_error |
f64 |
def coarse_edge
Section titled “def coarse_edge”def coarse_edge(contract: ApproximationContract)Parameters
| name | type |
|---|---|
contract |
ApproximationContract |
def learned_manifest
Section titled “def learned_manifest”def learned_manifest(output_unit: str)Parameters
| name | type |
|---|---|
output_unit |
str |
def hybrid_term
Section titled “def hybrid_term”def hybrid_term()def calibrated_uncertainty
Section titled “def calibrated_uncertainty”def calibrated_uncertainty()def assess
Section titled “def assess”def assess(manifest: LearnedModelManifest, applicability: ApplicabilityDecision, gate: f64, uncertainty: PredictionUncertainty)Parameters
| name | type |
|---|---|
manifest |
LearnedModelManifest |
applicability |
ApplicabilityDecision |
gate |
f64 |
uncertainty |
PredictionUncertainty |
def search_boundary
Section titled “def search_boundary”def search_boundary()def interaction_candidate
Section titled “def interaction_candidate”def interaction_candidate(compute_units: int)Parameters
| name | type |
|---|---|
compute_units |
int |
binding
Section titled “binding”Bounded, deterministic ligand/target docking and designed-species physiology coupling.
Every number produced here is an empirical rank, never a measurement. The scoring function and
its calibration constants are published on each result so a reader can see exactly how a score
becomes a free energy, and every payload carries scientific_validated: false.
def lj_parameters
Section titled “def lj_parameters”def lj_parameters(atomic_number: int)Parameters
| name | type |
|---|---|
atomic_number |
int |
OPLS-AA style [sigma in Angstrom, epsilon in kJ/mol]; unmapped elements fall back to carbon.
def partial_charge
Section titled “def partial_charge”def partial_charge(atomic_number: int, degree: int, polar_neighbours: int)Parameters
| name | type |
|---|---|
atomic_number |
int |
degree |
int |
polar_neighbours |
int |
Bounded element-plus-bond-context charge in elementary charge units; no QM, no force-field fit.
def partial_charges
Section titled “def partial_charges”def partial_charges(atomic_numbers: list[int], bond_pairs: list[int])Parameters
| name | type |
|---|---|
atomic_numbers |
list[int] |
bond_pairs |
list[int] |
def bounding_box
Section titled “def bounding_box”def bounding_box(x: list[f64], y: list[f64], z: list[f64])Parameters
| name | type |
|---|---|
x |
list[f64] |
y |
list[f64] |
z |
list[f64] |
def neighbour_grid
Section titled “def neighbour_grid”def neighbour_grid(x: list[f64], y: list[f64], z: list[f64], cell_size: f64, minimum: list[f64], maximum: list[f64])Parameters
| name | type |
|---|---|
x |
list[f64] |
y |
list[f64] |
z |
list[f64] |
cell_size |
f64 |
minimum |
list[f64] |
maximum |
list[f64] |
Uniform bucket grid in compressed-row form: starts[cell]..starts[cell + 1] indexes entries.
def probe_metrics
Section titled “def probe_metrics”def probe_metrics(grid: dict[str, any], x: list[f64], y: list[f64], z: list[f64], point: list[f64])Parameters
| name | type |
|---|---|
grid |
dict[str, any] |
x |
list[f64] |
y |
list[f64] |
z |
list[f64] |
point |
list[f64] |
One grid walk yielding [atoms within 8 A, atoms within 3 A, distance to the closest atom].
def pocket_site
Section titled “def pocket_site”def pocket_site(grid: dict[str, any], x: list[f64], y: list[f64], z: list[f64]) -> dict[str, any]Parameters
| name | type |
|---|---|
grid |
dict[str, any] |
x |
list[f64] |
y |
list[f64] |
z |
list[f64] |
Returns dict[str, any]
Highest-buriedness placeable grid point, refined on a local sub-lattice and averaged over its cluster.
A probe is placeable when its closest target atom sits in [POCKET_MIN_CLEARANCE_ANGSTROM, POCKET_MAX_CLEARANCE_ANGSTROM]: close enough to be a surface cavity rather than bulk solvent, open enough for a ligand heavy atom to occupy. Without that filter the verbatim argmax lands in the protein core (measured on 6S34: clearance 0.67 Angstrom), where every pose clashes.
def quaternion_from_axis_angle
Section titled “def quaternion_from_axis_angle”def quaternion_from_axis_angle(axis: list[f64], angle: f64)Parameters
| name | type |
|---|---|
axis |
list[f64] |
angle |
f64 |
def quaternion_multiply
Section titled “def quaternion_multiply”def quaternion_multiply(left: list[f64], right: list[f64])Parameters
| name | type |
|---|---|
left |
list[f64] |
right |
list[f64] |
def rotation_from_quaternion
Section titled “def rotation_from_quaternion”def rotation_from_quaternion(q: list[f64])Parameters
| name | type |
|---|---|
q |
list[f64] |
Row-major 3x3 rotation matrix from a unit quaternion [w, x, y, z].
def golden_spiral_axis
Section titled “def golden_spiral_axis”def golden_spiral_axis(index: int, count: int)Parameters
| name | type |
|---|---|
index |
int |
count |
int |
Deterministic quasi-uniform unit axis; the spiral increment is the golden angle pi (3 - sqrt 5).
def translation_lattice
Section titled “def translation_lattice”def translation_lattice(half_extent: f64)Parameters
| name | type |
|---|---|
half_extent |
f64 |
Nine deterministic offsets: the pocket point plus the eight corners of a cube around it.
def posed_coordinates
Section titled “def posed_coordinates”def posed_coordinates(probe: dict[str, any], rotation: list[f64], center: list[f64], translation: list[f64])Parameters
| name | type |
|---|---|
probe |
dict[str, any] |
rotation |
list[f64] |
center |
list[f64] |
translation |
list[f64] |
def score_pose
Section titled “def score_pose”def score_pose(field: dict[str, any], probe: dict[str, any], pose: list[list[f64]])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
probe |
dict[str, any] |
pose |
list[list[f64]] |
Interaction terms [lennard_jones, coulomb, hydrophobic, clash] in kJ/mol for one rigid pose.
Cost is O(n_ligand * k) where k is the number of shell atoms in the grid cells overlapping an 8 Angstrom sphere. The grid holds the pocket shell only, so k tracks local packing density and never the target atom count: a 3948-atom target costs the same as a 796-atom one.
def pose_energy
Section titled “def pose_energy”def pose_energy(field: dict[str, any], probe: dict[str, any], pose: list[list[f64]])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
probe |
dict[str, any] |
pose |
list[list[f64]] |
def refined_state
Section titled “def refined_state”def refined_state(field: dict[str, any], probe: dict[str, any], center: list[f64], base: list[f64], start: list[f64])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
probe |
dict[str, any] |
center |
list[f64] |
base |
list[f64] |
start |
list[f64] |
Bounded local coordinate descent over three translations and three body-frame rotations.
def descent_quaternion
Section titled “def descent_quaternion”def descent_quaternion(base: list[f64], state: list[f64])Parameters
| name | type |
|---|---|
base |
list[f64] |
state |
list[f64] |
Enumerated orientation composed with the descent’s body-frame x, y, then z rotations.
def structure_positions
Section titled “def structure_positions”def structure_positions(structure: dict[str, any])Parameters
| name | type |
|---|---|
structure |
dict[str, any] |
def structure_bonds
Section titled “def structure_bonds”def structure_bonds(structure: dict[str, any])Parameters
| name | type |
|---|---|
structure |
dict[str, any] |
def docking_rejection
Section titled “def docking_rejection”def docking_rejection(target: dict[str, any], ligand: dict[str, any], budget: int) -> str !{}Parameters
| name | type |
|---|---|
target |
dict[str, any] |
ligand |
dict[str, any] |
budget |
int |
Returns str
Effects !{}
Empty string when the pair is dockable, otherwise the reason a caller should report as 422.
def clamped_budget
Section titled “def clamped_budget”def clamped_budget(budget: int)Parameters
| name | type |
|---|---|
budget |
int |
def target_field
Section titled “def target_field”def target_field(target: dict[str, any], center: list[f64], pose_reach: f64)Parameters
| name | type |
|---|---|
target |
dict[str, any] |
center |
list[f64] |
pose_reach |
f64 |
Pocket shell: every target atom a posed ligand atom could reach, with its grid and Verlet lists.
def ligand_probe
Section titled “def ligand_probe”def ligand_probe(ligand: dict[str, any]) -> dict[str, any]Parameters
| name | type |
|---|---|
ligand |
dict[str, any] |
Returns dict[str, any]
Ligand recentred on its centroid; the internal geometry is never re-optimised (rigid ligand).
def pose_contacts
Section titled “def pose_contacts”def pose_contacts(field: dict[str, any], pose: list[list[f64]])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
pose |
list[list[f64]] |
The MAX_CONTACTS shortest ligand/target contacts under CONTACT_DISTANCE_ANGSTROM, nearest first.
def buried_ligand_fraction
Section titled “def buried_ligand_fraction”def buried_ligand_fraction(field: dict[str, any], pose: list[list[f64]])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
pose |
list[list[f64]] |
def free_energy_kj_mol
Section titled “def free_energy_kj_mol”def free_energy_kj_mol(score: f64) -> f64 !{}Parameters
| name | type |
|---|---|
score |
f64 |
Returns f64
Effects !{}
def dissociation_constant_micromolar
Section titled “def dissociation_constant_micromolar”def dissociation_constant_micromolar(delta_g_kj_mol: f64) -> f64 !{}Parameters
| name | type |
|---|---|
delta_g_kj_mol |
f64 |
Returns f64
Effects !{}
Kd = exp(dG / RT) * 1e6 uM at 310.15 K, clamped to the published reporting window.
def dock_ligand
Section titled “def dock_ligand”def dock_ligand(target: dict[str, any], ligand: dict[str, any], budget: int) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
target |
dict[str, any] |
ligand |
dict[str, any] |
budget |
int |
Returns dict[str, any]
Effects !{}
def occupancy_fraction
Section titled “def occupancy_fraction”def occupancy_fraction(kd_micromolar: f64, concentration_micromolar: f64) -> f64 !{}Parameters
| name | type |
|---|---|
kd_micromolar |
f64 |
concentration_micromolar |
f64 |
Returns f64
Effects !{}
def binding_mechanisms
Section titled “def binding_mechanisms”def binding_mechanisms() -> list[str] !{}Returns list[str]
Effects !{}
def bounded_multiplier
Section titled “def bounded_multiplier”def bounded_multiplier(name: str, multiplier: f64)Parameters
| name | type |
|---|---|
name |
str |
multiplier |
f64 |
Cap a multiplier so the published baseline parameter stays inside its physiology bound.
def species_effect
Section titled “def species_effect”def species_effect(mechanism: str, occupancy: f64) -> dict[str, f64] !{}Parameters
| name | type |
|---|---|
mechanism |
str |
occupancy |
f64 |
Returns dict[str, f64]
Effects !{}
Physiology couplings keyed by effect kind.
parameter:<name> multiplies that physiology parameter, signal_max:<name> raises the signal
to at least the value, signal_add:<name> adds to it. Occupancy is clamped to [0, 1] and every
value here is already bounded against the published baseline, so applying it to the source
parameters can never leave physiology_parameter_bounds(); apply_species_effects clamps again
against whatever the live parameters happen to be.
def signal_ceiling
Section titled “def signal_ceiling”def signal_ceiling(name: str)Parameters
| name | type |
|---|---|
name |
str |
Upper bounds mirror the signal table in programming.sema; species may never exceed them.
def apply_species_effects
Section titled “def apply_species_effects”def apply_species_effects(parameters: dict[str, f64], signals: dict[str, f64], registry: dict[str, any]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
parameters |
dict[str, f64] |
signals |
dict[str, f64] |
registry |
dict[str, any] |
Returns dict[str, any]
Effects !{}
def initial_species_registry
Section titled “def initial_species_registry”def initial_species_registry() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
def species_registration_error
Section titled “def species_registration_error”def species_registration_error(registry: dict[str, any], spec: dict[str, any], docking: dict[str, any], concentration_micromolar: f64, mechanism: str) -> dict[str, str] !{}Parameters
| name | type |
|---|---|
registry |
dict[str, any] |
spec |
dict[str, any] |
docking |
dict[str, any] |
concentration_micromolar |
f64 |
mechanism |
str |
Returns dict[str, str]
Effects !{}
{"error": "", "detail": ""} when the species may be introduced, otherwise the typed refusal.
def register_species
Section titled “def register_species”def register_species(registry: dict[str, any], spec: dict[str, any], structure: dict[str, any], docking: dict[str, any], concentration_micromolar: f64, mechanism: str, introduced_at_days: f64) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
registry |
dict[str, any] |
spec |
dict[str, any] |
structure |
dict[str, any] |
docking |
dict[str, any] |
concentration_micromolar |
f64 |
mechanism |
str |
introduced_at_days |
f64 |
Returns dict[str, any]
Effects !{}
def species_public_state
Section titled “def species_public_state”def species_public_state(registry: dict[str, any]) -> list[dict[str, any]] !{}Parameters
| name | type |
|---|---|
registry |
dict[str, any] |
Returns list[dict[str, any]]
Effects !{}
def binding_capabilities
Section titled “def binding_capabilities”def binding_capabilities() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
coarse
Section titled “coarse”Periodic phi/psi coarse-state mapping with explicit sampling diagnostics.
struct CoarseStateResult
Section titled “struct CoarseStateResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
analysis_id |
str |
|
config_sha256 |
str |
|
source_frames_sha256 |
str |
|
source_model_sha256 |
str |
|
source_parameter_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
samples |
int |
|
basin_ids |
list[str] |
|
counts |
list[int] |
|
transition_counts |
list[int] |
|
transitions |
int |
|
observed_basins |
int |
|
lag_frames |
int |
|
pseudocount |
f64 |
|
free_energy_kj_mol |
list[f64] |
|
effective_samples |
f64 |
|
mapping_validated |
bool |
|
sampling_converged |
bool |
|
evidence_class |
str |
bridge coarse_backend
Section titled “bridge coarse_backend”cortex
Section titled “cortex”Governed proposal-only Cortex bridge with native Sema contract revalidation.
bridge cortex_sdk_backend
Section titled “bridge cortex_sdk_backend”def cortex_units
Section titled “def cortex_units”def cortex_units()def cortex_operation_error
Section titled “def cortex_operation_error”def cortex_operation_error(operation: any) !{}Parameters
| name | type |
|---|---|
operation |
any |
Effects !{}
def cortex_proposal_error
Section titled “def cortex_proposal_error”def cortex_proposal_error(proposal: any) !{}Parameters
| name | type |
|---|---|
proposal |
any |
Effects !{}
def propose_cortex
Section titled “def propose_cortex”def propose_cortex(payload: any) -> dict[str, any] !{ffi.call}Parameters
| name | type |
|---|---|
payload |
any |
Returns dict[str, any]
Effects !{ffi.call}
def cortex_capabilities
Section titled “def cortex_capabilities”def cortex_capabilities() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
design
Section titled “design”Bounded de-novo molecular design: natural-language specs turned into computed geometry.
Everything here is exploratory engineering, never a measurement. Structures are built from
published internal coordinates by natural-extension-reference-frame placement and a bounded
steepest-descent relaxation, so every coordinate is computed rather than copied from a table of
positions. Designed structures therefore carry fidelity: "engineered_unvalidated",
biological_match: "designed_de_novo" and scientific_validated: false downstream: no claim is
made that any of these molecules exists, folds, or binds.
def design_target_keys
Section titled “def design_target_keys”def design_target_keys()def design_mechanisms
Section titled “def design_mechanisms”def design_mechanisms()def design_fragment_names
Section titled “def design_fragment_names”def design_fragment_names()def listed
Section titled “def listed”def listed(values: list[str], value: str)Parameters
| name | type |
|---|---|
values |
list[str] |
value |
str |
def element_name
Section titled “def element_name”def element_name(atomic_number: int)Parameters
| name | type |
|---|---|
atomic_number |
int |
def atomic_radius
Section titled “def atomic_radius”def atomic_radius(atomic_number: int, radius_kind: str)Parameters
| name | type |
|---|---|
atomic_number |
int |
radius_kind |
str |
def unit_vector
Section titled “def unit_vector”def unit_vector(vector: list[f64])Parameters
| name | type |
|---|---|
vector |
list[f64] |
def cross
Section titled “def cross”def cross(left: list[f64], right: list[f64])Parameters
| name | type |
|---|---|
left |
list[f64] |
right |
list[f64] |
def difference
Section titled “def difference”def difference(from_point: list[f64], to_point: list[f64])Parameters
| name | type |
|---|---|
from_point |
list[f64] |
to_point |
list[f64] |
def point_at
Section titled “def point_at”def point_at(positions: list[f64], atom_index: int)Parameters
| name | type |
|---|---|
positions |
list[f64] |
atom_index |
int |
def place_atom
Section titled “def place_atom”def place_atom(first: list[f64], second: list[f64], third: list[f64], bond_angstrom: f64, angle_degree: f64, dihedral_degree: f64)Parameters
| name | type |
|---|---|
first |
list[f64] |
second |
list[f64] |
third |
list[f64] |
bond_angstrom |
f64 |
angle_degree |
f64 |
dihedral_degree |
f64 |
def rotation_between
Section titled “def rotation_between”def rotation_between(source: list[f64], target: list[f64])Parameters
| name | type |
|---|---|
source |
list[f64] |
target |
list[f64] |
Rodrigues rotation matrix (row-major, flat 9) carrying unit source onto unit target.
def rotated
Section titled “def rotated”def rotated(matrix: list[f64], vector: list[f64])Parameters
| name | type |
|---|---|
matrix |
list[f64] |
vector |
list[f64] |
def residue_three_letter
Section titled “def residue_three_letter”def residue_three_letter(code: str)Parameters
| name | type |
|---|---|
code |
str |
def residue_charge
Section titled “def residue_charge”def residue_charge(code: str)Parameters
| name | type |
|---|---|
code |
str |
Side-chain formal charge at pH 7.4; the free N- and C-termini cancel and are omitted.
def residue_sidechains
Section titled “def residue_sidechains”def residue_sidechains()Truncated side chains beyond C-beta as internal coordinates.
Every row is [atom name, atomic number, torsion reference, angle reference, bonded parent, bond length in angstrom, valence angle in degrees, torsion in degrees]; references -3, -2 and
-1 are backbone N, CA and CB and a non-negative reference is an earlier row of the same
residue. At most four heavy atoms are emitted per side chain, so anything past the delta shell
is truncated - the structure declares this through sidechain_model.
def fragment_template
Section titled “def fragment_template”def fragment_template(name: str) -> dict[str, any]Parameters
| name | type |
|---|---|
name |
str |
Returns dict[str, any]
Literature internal coordinates for one attachable fragment.
Rings are generated from their bond length and ring size; every other atom is an
[name, atomic number, torsion reference, angle reference, bonded parent, bond, angle, torsion] row placed by the same reference-frame routine as the peptide backbone. References
-2 and -1 are the two virtual seed points that define the incoming bond direction, a
non-negative reference indexes an atom already placed in this fragment, and a zero bond length
means the atom is the fragment head sitting at the local origin. head bonds to the previous
fragment and tail carries the growing chain onward.
def build_fragment
Section titled “def build_fragment”def build_fragment(name: str)Parameters
| name | type |
|---|---|
name |
str |
Instantiate one fragment in a local frame with its head at the origin and its head-to-tail axis on +x, so the chain builder can drop it onto a growth direction with one rotation.
def new_build
Section titled “def new_build”def new_build()def add_atom
Section titled “def add_atom”def add_atom(built: dict[str, any], position: list[f64], atomic_number: int, label: str, mobile: bool, group: int) !{}Parameters
| name | type |
|---|---|
built |
dict[str, any] |
position |
list[f64] |
atomic_number |
int |
label |
str |
mobile |
bool |
group |
int |
Effects !{}
def add_bond
Section titled “def add_bond”def add_bond(built: dict[str, any], left: int, right: int) !{}Parameters
| name | type |
|---|---|
built |
dict[str, any] |
left |
int |
right |
int |
Effects !{}
def build_peptide
Section titled “def build_peptide”def build_peptide(spec: dict[str, any]) !{}Parameters
| name | type |
|---|---|
spec |
dict[str, any] |
Effects !{}
Grow the backbone and truncated side chains residue by residue from standard internal coordinates; only the side-chain atoms are later relaxed so the backbone torsions stay exact.
def build_molecule
Section titled “def build_molecule”def build_molecule(spec: dict[str, any]) !{}Parameters
| name | type |
|---|---|
spec |
dict[str, any] |
Effects !{}
Attach fragment templates head to tail along a zig-zagging growth axis so the initial guess is an extended chain rather than a stack; the relaxation then resolves the linkage geometry.
def restraint_field
Section titled “def restraint_field”def restraint_field(built: dict[str, any])Parameters
| name | type |
|---|---|
built |
dict[str, any] |
Harmonic 1-2 bonds at their as-built length plus 1-3 Urey-Bradley terms.
Inside a fragment or a residue the 1-3 rest length is the template distance, so the published fragment geometry is preserved exactly. Across a head-to-tail link there is no template angle, so the rest length comes from the law of cosines on the two bond lengths and the ideal valence angle for the central atom’s coordination number.
def rebuild_neighbours
Section titled “def rebuild_neighbours”def rebuild_neighbours(field: dict[str, any], positions: list[f64])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
positions |
list[f64] |
Verlet candidate list: only pairs inside the repulsive core plus a skin can ever clash, and a pair of frozen atoms contributes a constant energy so it never changes the line search.
def relaxation_energy
Section titled “def relaxation_energy”def relaxation_energy(field: dict[str, any], positions: list[f64], forces: list[f64])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
positions |
list[f64] |
forces |
list[f64] |
Harmonic restraints plus a purely repulsive r^-12 core truncated and shifted to zero at
CLASH_CORE_ANGSTROM. Fills forces with -dE/dx and returns the energy in kJ/mol.
def minimise
Section titled “def minimise”def minimise(field: dict[str, any], positions: list[f64], max_steps: int, epsilon: f64)Parameters
| name | type |
|---|---|
field |
dict[str, any] |
positions |
list[f64] |
max_steps |
int |
epsilon |
f64 |
Bounded steepest descent with a backtracking step: accept a trial move only when it lowers
the energy, otherwise shrink the step. Deterministic and capped at max_steps evaluations.
def minimum_free_separation
Section titled “def minimum_free_separation”def minimum_free_separation(field: dict[str, any], positions: list[f64])Parameters
| name | type |
|---|---|
field |
dict[str, any] |
positions |
list[f64] |
Closest approach over heavy-atom pairs that are more than two bonds apart; 1-2 and 1-3 pairs are covalent geometry (a ring’s meta carbons sit at 2.4 angstrom by construction) and excluded.
def relax_build
Section titled “def relax_build”def relax_build(built: dict[str, any])Parameters
| name | type |
|---|---|
built |
dict[str, any] |
def design_compile_error
Section titled “def design_compile_error”def design_compile_error(detail: str)Parameters
| name | type |
|---|---|
detail |
str |
def spec_core
Section titled “def spec_core”def spec_core(name: str, label: str, design_class: str, conformation: str, sequence: str, fragments: list[str], target_key: str, mechanism: str, charge_e: f64)Parameters
| name | type |
|---|---|
name |
str |
label |
str |
design_class |
str |
conformation |
str |
sequence |
str |
fragments |
list[str] |
target_key |
str |
mechanism |
str |
charge_e |
f64 |
def sealed_spec
Section titled “def sealed_spec”def sealed_spec(core: dict[str, any]) !{}Parameters
| name | type |
|---|---|
core |
dict[str, any] |
Effects !{}
def targeting_suffix
Section titled “def targeting_suffix”def targeting_suffix(target_key: str)Parameters
| name | type |
|---|---|
target_key |
str |
def peptide_spec
Section titled “def peptide_spec”def peptide_spec(form: str, raw_sequence: str, name: str, target_key: str) !{}Parameters
| name | type |
|---|---|
form |
str |
raw_sequence |
str |
name |
str |
target_key |
str |
Effects !{}
def molecule_spec
Section titled “def molecule_spec”def molecule_spec(raw_fragments: str, name: str, target_key: str) !{}Parameters
| name | type |
|---|---|
raw_fragments |
str |
name |
str |
target_key |
str |
Effects !{}
def compile_design_command
Section titled “def compile_design_command”def compile_design_command(command: str) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
command |
str |
Returns dict[str, any]
Effects !{}
def design_name_valid
Section titled “def design_name_valid”def design_name_valid(name: str)Parameters
| name | type |
|---|---|
name |
str |
def design_spec_valid
Section titled “def design_spec_valid”def design_spec_valid(spec: dict[str, any]) -> bool !{}Parameters
| name | type |
|---|---|
spec |
dict[str, any] |
Returns bool
Effects !{}
def design_capabilities
Section titled “def design_capabilities”def design_capabilities() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
def build_designed_structure
Section titled “def build_designed_structure”def build_designed_structure(spec: dict[str, any]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
spec |
dict[str, any] |
Returns dict[str, any]
Effects !{}
discovery
Section titled “discovery”Bounded computational-discovery lineage, gates, and honest result classes.
enum CandidateKind
Section titled “enum CandidateKind”Variants
moleculebondinteractioncircuitequation_changeexperiment
enum CandidateStatus
Section titled “enum CandidateStatus”Variants
proposedrejectedadmittedsimulatedrankedblocked
enum CandidateClaim
Section titled “enum CandidateClaim”Variants
unseen_in_bounded_searchpredicted_interactionsimulated_associationexperimentally_supportedclinical
struct SearchBoundary
Section titled “struct SearchBoundary”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
description |
str |
|
allowed_kinds |
list[CandidateKind] |
|
max_candidates |
int |
|
max_rounds |
int |
|
max_compute_units |
int |
|
prior_art_sources |
list[str] |
|
safety_policy_id |
str |
struct DiscoveryBatch
Section titled “struct DiscoveryBatch”Fields
| field | type | descriptor |
|---|---|---|
boundary_id |
str |
|
round_index |
int |
|
candidate_ids |
list[str] |
|
requested_compute_units |
int |
struct CandidateHypothesis
Section titled “struct CandidateHypothesis”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
parent_ids |
list[str] |
|
kind |
CandidateKind |
|
representation_digest |
str |
|
rationale |
str |
|
provenance_ids |
list[str] |
|
prior_art_scope_id |
str |
|
model_id |
str |
|
model_version |
int |
|
equation_graph_id |
str |
|
equation_version |
int |
|
uncertainty |
f64 |
|
requested_compute_units |
int |
|
status |
CandidateStatus |
|
rejection_reasons |
list[str] |
struct CandidateEvidence
Section titled “struct CandidateEvidence”Fields
| field | type | descriptor |
|---|---|---|
candidate_id |
str |
|
observation_ids |
list[str] |
|
oracle_evidence_ids |
list[str] |
|
prior_art_evidence_ids |
list[str] |
|
objective_names |
list[str] |
|
objective_values |
list[f64] |
|
uncertainty |
f64 |
|
information_gain |
f64 |
|
claim |
CandidateClaim |
|
status |
CandidateStatus |
def within_boundary
Section titled “def within_boundary”def within_boundary(candidate: CandidateHypothesis, boundary: SearchBoundary)Parameters
| name | type |
|---|---|
candidate |
CandidateHypothesis |
boundary |
SearchBoundary |
def validate_discovery_batch
Section titled “def validate_discovery_batch”def validate_discovery_batch(batch: DiscoveryBatch, candidates: list[CandidateHypothesis], boundary: SearchBoundary) -> bool !{}Parameters
| name | type |
|---|---|
batch |
DiscoveryBatch |
candidates |
list[CandidateHypothesis] |
boundary |
SearchBoundary |
Returns bool
Effects !{}
def reject_candidate
Section titled “def reject_candidate”def reject_candidate(candidate: CandidateHypothesis, reason: str)Parameters
| name | type |
|---|---|
candidate |
CandidateHypothesis |
reason |
str |
def admit_candidate
Section titled “def admit_candidate”def admit_candidate(candidate: CandidateHypothesis, boundary: SearchBoundary, chemistry_valid: bool, topology_valid: bool, applicability_valid: bool, evidence_valid: bool, safety_valid: bool) -> CandidateHypothesis !{}Parameters
| name | type |
|---|---|
candidate |
CandidateHypothesis |
boundary |
SearchBoundary |
chemistry_valid |
bool |
topology_valid |
bool |
applicability_valid |
bool |
evidence_valid |
bool |
safety_valid |
bool |
Returns CandidateHypothesis
Effects !{}
def may_report_claim
Section titled “def may_report_claim”def may_report_claim(evidence: CandidateEvidence) -> bool !{}Parameters
| name | type |
|---|---|
evidence |
CandidateEvidence |
Returns bool
Effects !{}
domain
Section titled “domain”Typed physical identities, topology, backend profiles, observations, and phase evidence.
enum PhaseState
Section titled “enum PhaseState”Variants
not_startedimplemented_unvalidatedvalidatedblocked
enum EntityKind
Section titled “enum EntityKind”Variants
particleatomresiduemoleculeensemblecoarse_statefieldmembraneorganellecelltissue
enum ModelScale
Section titled “enum ModelScale”Variants
quantumatomisticcoarsemesoscopicnetworkcellulartissue
enum ResultClass
Section titled “enum ResultClass”Variants
validatedcalibratedexploratoryunknowninvalidfailed
enum ReplayClass
Section titled “enum ReplayClass”Variants
exactdeterministic_tolerancestatisticalunavailable
enum EvidenceKind
Section titled “enum EvidenceKind”Variants
computationalstructuralensembleexperimentalperformancenegative
enum InteractionMethod
Section titled “enum InteractionMethod”Variants
classical_fixed_topologyreactive_force_fieldlearned_potentialquantumqmmmparticle_reaction_diffusion
enum PropertyValueKind
Section titled “enum PropertyValueKind”Variants
scalarvectortensorper_atomcategoricaldistribution
enum ReactionState
Section titled “enum ReactionState”Variants
proposedparameterizedcomputedvalidatedblocked
struct Vector3
Section titled “struct Vector3”Fields
| field | type | descriptor |
|---|---|---|
x |
f64 |
|
y |
f64 |
|
z |
f64 |
struct Atom
Section titled “struct Atom”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
index |
int |
|
element |
str |
|
residue |
str |
|
mass_da |
f64 |
|
charge_e |
f64 |
|
position_nm |
Vector3 |
struct Bond
Section titled “struct Bond”Fields
| field | type | descriptor |
|---|---|---|
left_index |
int |
|
right_index |
int |
|
order |
int |
struct PeriodicBox
Section titled “struct PeriodicBox”Fields
| field | type | descriptor |
|---|---|---|
x_nm |
f64 |
|
y_nm |
f64 |
|
z_nm |
f64 |
struct MolecularTopology
Section titled “struct MolecularTopology”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
atoms |
list[Atom] |
|
bonds |
list[Bond] |
|
box |
PeriodicBox |
|
source_sha256 |
str |
struct BackendProfile
Section titled “struct BackendProfile”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
engine |
str |
|
version |
str |
|
platform |
str |
|
precision |
str |
|
properties |
list[str] |
|
artifact_sha256 |
str |
|
replay |
ReplayClass |
struct EvidenceRecord
Section titled “struct EvidenceRecord”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
kind |
EvidenceKind |
|
source |
str |
|
summary |
str |
|
artifact_sha256 |
str |
|
observed_at_s |
f64 |
|
accepted |
bool |
struct InteractionTerm
Section titled “struct InteractionTerm”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
family |
str |
|
owner_model_id |
str |
|
active |
bool |
|
target_observable |
str |
|
evidence_ids |
list[str] |
struct MolecularProperty
Section titled “struct MolecularProperty”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
entity_id |
str |
|
property_name |
str |
|
scope_id |
str |
|
value_kind |
PropertyValueKind |
|
values |
list[f64] |
|
labels |
list[str] |
|
shape |
list[int] |
|
unit_symbol |
str |
|
uncertainty |
f64 |
|
conditions |
list[str] |
|
method_profile_id |
str |
|
evidence_ids |
list[str] |
|
valid |
bool |
struct InteractionProfile
Section titled “struct InteractionProfile”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
method |
InteractionMethod |
|
engine |
str |
|
version |
str |
|
parameter_sha256 |
str |
|
scope_id |
str |
|
supported_elements |
list[str] |
|
properties |
list[str] |
|
minimum_atoms |
int |
|
maximum_atoms |
int |
|
conditions |
list[str] |
|
supports_topology_change |
bool |
|
qualified |
bool |
|
uncertainty_policy |
str |
|
evidence_ids |
list[str] |
struct ReactionProposal
Section titled “struct ReactionProposal”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
reactant_topology_sha256 |
str |
|
product_topology_sha256 |
str |
|
elements |
list[str] |
|
atom_map |
list[int] |
|
total_charge |
int |
|
spin_multiplicity |
int |
|
profile_id |
str |
|
scope_id |
str |
|
conditions |
list[str] |
|
evidence_ids |
list[str] |
struct ReactionDecision
Section titled “struct ReactionDecision”Fields
| field | type | descriptor |
|---|---|---|
proposal_id |
str |
|
state |
ReactionState |
|
admissible |
bool |
|
profile_id |
str |
|
reason |
str |
struct ObservationFrame
Section titled “struct ObservationFrame”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
run_id |
str |
|
state_version |
int |
|
step |
int |
|
physical_time_ps |
f64 |
|
potential_energy_kj_mol |
f64 |
|
kinetic_energy_kj_mol |
f64 |
|
max_force_kj_mol_nm |
f64 |
|
phi_rad |
f64 |
|
psi_rad |
f64 |
|
backend_profile_id |
str |
|
evidence_ids |
list[str] |
struct PhaseEvidence
Section titled “struct PhaseEvidence”Fields
| field | type | descriptor |
|---|---|---|
phase |
int |
|
state |
PhaseState |
|
profile_id |
str |
|
positive_evidence |
list[str] |
|
negative_evidence |
list[str] |
|
blockers |
list[str] |
def distinct_atom_ids
Section titled “def distinct_atom_ids”def distinct_atom_ids(atoms: list[Atom])Parameters
| name | type |
|---|---|
atoms |
list[Atom] |
def bonds_reference_atoms
Section titled “def bonds_reference_atoms”def bonds_reference_atoms(topology: MolecularTopology)Parameters
| name | type |
|---|---|
topology |
MolecularTopology |
def topology_valid
Section titled “def topology_valid”def topology_valid(topology: MolecularTopology) -> bool !{}Parameters
| name | type |
|---|---|
topology |
MolecularTopology |
Returns bool
Effects !{}
def interaction_ownership_valid
Section titled “def interaction_ownership_valid”def interaction_ownership_valid(terms: list[InteractionTerm]) -> bool !{}Parameters
| name | type |
|---|---|
terms |
list[InteractionTerm] |
Returns bool
Effects !{}
def profile_supports_elements
Section titled “def profile_supports_elements”def profile_supports_elements(profile: InteractionProfile, elements: list[str])Parameters
| name | type |
|---|---|
profile |
InteractionProfile |
elements |
list[str] |
def reaction_atom_map_valid
Section titled “def reaction_atom_map_valid”def reaction_atom_map_valid(proposal: ReactionProposal)Parameters
| name | type |
|---|---|
proposal |
ReactionProposal |
def molecular_property_admissible
Section titled “def molecular_property_admissible”def molecular_property_admissible(property: MolecularProperty, profile: InteractionProfile)Parameters
| name | type |
|---|---|
property |
MolecularProperty |
profile |
InteractionProfile |
def admit_reaction
Section titled “def admit_reaction”def admit_reaction(proposal: ReactionProposal, profile: InteractionProfile)Parameters
| name | type |
|---|---|
proposal |
ReactionProposal |
profile |
InteractionProfile |
def phase_validated
Section titled “def phase_validated”def phase_validated(phase: PhaseEvidence) -> bool !{}Parameters
| name | type |
|---|---|
phase |
PhaseEvidence |
Returns bool
Effects !{}
def blocked_phase
Section titled “def blocked_phase”def blocked_phase(phase: int, profile_id: str, reason: str)Parameters
| name | type |
|---|---|
phase |
int |
profile_id |
str |
reason |
str |
dynamics
Section titled “dynamics”Sema-owned multiscale dynamics, model admission, control, and solver evidence.
struct ControlIntent
Section titled “struct ControlIntent”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
natural_language |
str |
|
target_tissue_response |
f64 |
|
maximum_cellular_gain |
f64 |
|
effort_penalty |
f64 |
|
horizon_s |
f64 |
|
evidence_ids |
list[str] |
struct Phase8AdmissionEvidence
Section titled “struct Phase8AdmissionEvidence”Fields
| field | type | descriptor |
|---|---|---|
phase8_technical_pass |
bool |
|
readdy_chronology_proven |
bool |
|
readdy_qualification_pass |
bool |
|
readdy_convergence_pass |
bool |
|
readdy_spatial_pass |
bool |
|
readdy_admission_pass |
bool |
|
physicell_custom_insulin_pass |
bool |
|
physicell_target_rate_pass |
bool |
|
physicell_uncertainty_pass |
bool |
|
physicell_scientific_pass |
bool |
def phase8_admission_evidence_complete
Section titled “def phase8_admission_evidence_complete”def phase8_admission_evidence_complete(evidence: Phase8AdmissionEvidence) -> bool !{}Parameters
| name | type |
|---|---|
evidence |
Phase8AdmissionEvidence |
Returns bool
Effects !{}
struct AdaptationSummary
Section titled “struct AdaptationSummary”Fields
| field | type | descriptor |
|---|---|---|
active_model_id |
str |
|
candidate_model_id |
str |
|
selected_model_id |
str |
|
activated |
bool |
|
admission_status |
str |
|
admitted |
bool |
|
exploratory |
bool |
|
evidence_reliability |
f64 |
|
parameter_apply_authorized |
bool |
|
reason |
str |
|
evidence_ids |
list[str] |
struct DynamicsResult
Section titled “struct DynamicsResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
contract_id |
str |
|
semantics |
str |
|
formal_equations |
list[str] |
|
state_names |
list[str] |
|
state_units |
list[str] |
|
final_state |
list[f64] |
|
cellular_gain |
f64 |
|
target_tissue_response |
f64 |
|
tissue_target_error |
f64 |
|
initial_molecular_mass_micromolar |
f64 |
|
final_molecular_mass_micromolar |
f64 |
|
molecular_mass_relative_residual |
f64 |
|
integration_error_bound |
f64 |
|
integration_steps_accepted |
int |
|
integration_steps_rejected |
int |
|
integration_method |
str |
|
optimizer_status |
str |
|
optimizer_scope |
str |
|
optimizer_objective |
f64 |
|
optimizer_iterations |
int |
|
adaptation |
AdaptationSummary |
|
evidence_ids |
list[str] |
|
admission_status |
str |
|
admitted |
bool |
|
exploratory |
bool |
|
parameter_apply_authorized |
bool |
|
technical_pass |
bool |
|
scientific_validated |
bool |
struct PopulationState
Section titled “struct PopulationState”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
total_cells |
int |
|
viable_cells |
int |
|
dead_cells |
int |
|
mutated_cells |
int |
|
adapted_cells |
int |
|
injected_micromolar |
f64 |
|
applied_force_pn |
f64 |
|
stress_fraction |
f64 |
|
injected_molecule |
str |
|
mutation_label |
str |
|
last_intervention |
str |
|
affected_index |
int |
|
affected_kind |
str |
|
event_count |
int |
|
scientific_validated |
bool |
struct DynamicsStep
Section titled “struct DynamicsStep”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
sequence |
int |
|
state_version |
int |
|
equation_id |
str |
|
equation_version |
int |
|
model_id |
str |
|
semantics |
str |
|
state |
list[f64] |
|
target_tissue_response |
f64 |
|
cellular_gain |
f64 |
|
molecular_integrity |
f64 |
|
dt_s |
f64 |
|
molecular_mass_relative_residual |
f64 |
|
integration_error_bound |
f64 |
|
integration_steps_accepted |
int |
|
integration_steps_rejected |
int |
|
optimizer_status |
str |
|
optimizer_scope |
str |
|
evidence_ids |
list[str] |
|
physiology |
dict[str, any] |
|
population |
PopulationState |
|
admission_status |
str |
|
admitted |
bool |
|
exploratory |
bool |
|
parameter_apply_authorized |
bool |
|
technical_pass |
bool |
|
scientific_validated |
bool |
def initial_population_state
Section titled “def initial_population_state”def initial_population_state(total_cells: int) -> PopulationState !{}Parameters
| name | type |
|---|---|
total_cells |
int |
Returns PopulationState
Effects !{}
def apply_biological_intervention
Section titled “def apply_biological_intervention”def apply_biological_intervention(state: PopulationState, kind: str, target_index: int, target_kind: str, magnitude: f64, amount: f64, molecule: str, mutation: str, seed_cells: int) -> PopulationState !{}Parameters
| name | type |
|---|---|
state |
PopulationState |
kind |
str |
target_index |
int |
target_kind |
str |
magnitude |
f64 |
amount |
f64 |
molecule |
str |
mutation |
str |
seed_cells |
int |
Returns PopulationState
Effects !{}
def advance_population_dynamics
Section titled “def advance_population_dynamics”def advance_population_dynamics(state: PopulationState, dt_s: f64, cellular_signal: f64, tissue_response: f64, beta_function_fraction: f64, immune_effector_fraction: f64)Parameters
| name | type |
|---|---|
state |
PopulationState |
dt_s |
f64 |
cellular_signal |
f64 |
tissue_response |
f64 |
beta_function_fraction |
f64 |
immune_effector_fraction |
f64 |
def dynamics_equations
Section titled “def dynamics_equations”def dynamics_equations() -> list[str] !{}Returns list[str]
Effects !{}
def exploratory_unadmitted_association_preview
Section titled “def exploratory_unadmitted_association_preview”def exploratory_unadmitted_association_preview(profile_id: str, evidence_id: str)Parameters
| name | type |
|---|---|
profile_id |
str |
evidence_id |
str |
def admit_association_model
Section titled “def admit_association_model”def admit_association_model(profile_id: str, association_rate: f64, dissociation_rate: f64, reference_error: f64, candidate_error: f64, evidence_id: str, observed_at: f64, admission_evidence: Phase8AdmissionEvidence) -> AdaptationSummary !{}Parameters
| name | type |
|---|---|
profile_id |
str |
association_rate |
f64 |
dissociation_rate |
f64 |
reference_error |
f64 |
candidate_error |
f64 |
evidence_id |
str |
observed_at |
f64 |
admission_evidence |
Phase8AdmissionEvidence |
Returns AdaptationSummary
Effects !{}
def run_multiscale_dynamics
Section titled “def run_multiscale_dynamics”def run_multiscale_dynamics(profile_id: str, monomer_micromolar: f64, dimer_micromolar: f64, association_rate: f64, dissociation_rate: f64, intent: ControlIntent, adaptation: AdaptationSummary) !{}Parameters
| name | type |
|---|---|
profile_id |
str |
monomer_micromolar |
f64 |
dimer_micromolar |
f64 |
association_rate |
f64 |
dissociation_rate |
f64 |
intent |
ControlIntent |
adaptation |
AdaptationSummary |
Effects !{}
def preview_unadmitted_multiscale_dynamics
Section titled “def preview_unadmitted_multiscale_dynamics”def preview_unadmitted_multiscale_dynamics(profile_id: str, monomer_micromolar: f64, dimer_micromolar: f64, association_rate: f64, dissociation_rate: f64, intent: ControlIntent, adaptation: AdaptationSummary) -> DynamicsResult !{}Parameters
| name | type |
|---|---|
profile_id |
str |
monomer_micromolar |
f64 |
dimer_micromolar |
f64 |
association_rate |
f64 |
dissociation_rate |
f64 |
intent |
ControlIntent |
adaptation |
AdaptationSummary |
Returns DynamicsResult
Effects !{}
def compute_multiscale_dynamics_step
Section titled “def compute_multiscale_dynamics_step”def compute_multiscale_dynamics_step(sequence: int, state_version: int, model_id: str, adaptation: AdaptationSummary, state: list[f64], population: PopulationState, physiology: dict[str, any], dt_s: f64, target_tissue_response: f64, maximum_cellular_gain: f64, effort_penalty: f64, molecular_integrity: f64, association_rate: f64, dissociation_rate: f64, evidence_ids: list[str], admitted_execution: bool) !{}Parameters
| name | type |
|---|---|
sequence |
int |
state_version |
int |
model_id |
str |
adaptation |
AdaptationSummary |
state |
list[f64] |
population |
PopulationState |
physiology |
dict[str, any] |
dt_s |
f64 |
target_tissue_response |
f64 |
maximum_cellular_gain |
f64 |
effort_penalty |
f64 |
molecular_integrity |
f64 |
association_rate |
f64 |
dissociation_rate |
f64 |
evidence_ids |
list[str] |
admitted_execution |
bool |
Effects !{}
def step_multiscale_dynamics
Section titled “def step_multiscale_dynamics”def step_multiscale_dynamics(sequence: int, state_version: int, model_id: str, adaptation: AdaptationSummary, state: list[f64], population: PopulationState, physiology: dict[str, any], dt_s: f64, target_tissue_response: f64, maximum_cellular_gain: f64, effort_penalty: f64, molecular_integrity: f64, association_rate: f64, dissociation_rate: f64, evidence_ids: list[str]) -> DynamicsStep !{}Parameters
| name | type |
|---|---|
sequence |
int |
state_version |
int |
model_id |
str |
adaptation |
AdaptationSummary |
state |
list[f64] |
population |
PopulationState |
physiology |
dict[str, any] |
dt_s |
f64 |
target_tissue_response |
f64 |
maximum_cellular_gain |
f64 |
effort_penalty |
f64 |
molecular_integrity |
f64 |
association_rate |
f64 |
dissociation_rate |
f64 |
evidence_ids |
list[str] |
Returns DynamicsStep
Effects !{}
def preview_unadmitted_multiscale_dynamics_step
Section titled “def preview_unadmitted_multiscale_dynamics_step”def preview_unadmitted_multiscale_dynamics_step(sequence: int, state_version: int, model_id: str, adaptation: AdaptationSummary, state: list[f64], population: PopulationState, physiology: dict[str, any], dt_s: f64, target_tissue_response: f64, maximum_cellular_gain: f64, effort_penalty: f64, molecular_integrity: f64, association_rate: f64, dissociation_rate: f64, evidence_ids: list[str]) -> DynamicsStep !{}Parameters
| name | type |
|---|---|
sequence |
int |
state_version |
int |
model_id |
str |
adaptation |
AdaptationSummary |
state |
list[f64] |
population |
PopulationState |
physiology |
dict[str, any] |
dt_s |
f64 |
target_tissue_response |
f64 |
maximum_cellular_gain |
f64 |
effort_penalty |
f64 |
molecular_integrity |
f64 |
association_rate |
f64 |
dissociation_rate |
f64 |
evidence_ids |
list[str] |
Returns DynamicsStep
Effects !{}
ensemble
Section titled “ensemble”Independent stochastic replica evidence with explicit uncertainty and replay class.
struct EnsembleResult
Section titled “struct EnsembleResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
ensemble_id |
str |
|
config_sha256 |
str |
|
coarse_config_sha256 |
str |
|
benchmark_config_sha256 |
str |
|
source_model_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
platform |
str |
|
replay_class |
str |
|
evidence_class |
str |
|
replicas |
int |
|
samples_per_replica |
int |
|
seeds |
list[int] |
|
initial_state_sha256 |
list[str] |
|
distinct_initial_states |
int |
|
basin_ids |
list[str] |
|
occupancy_mean |
list[f64] |
|
occupancy_sem |
list[f64] |
|
transition_counts |
list[int] |
|
transitions |
int |
|
observed_basins |
int |
|
free_energy_mean_kj_mol |
list[f64] |
|
free_energy_sem_kj_mol |
list[f64] |
|
effective_samples |
f64 |
|
rhat_defined |
bool |
|
rhat_max |
f64 |
|
converged |
bool |
bridge ensemble_backend
Section titled “bridge ensemble_backend”insulin
Section titled “insulin”Human insulin solution-thermodynamics model with pinned experimental evidence.
struct InsulinThermodynamicsResult
Section titled “struct InsulinThermodynamicsResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
artifact_sha256 |
str |
|
pmid |
str |
|
doi |
str |
|
subject |
str |
|
assay |
str |
|
temperature_k |
f64 |
|
buffer |
str |
|
ph |
f64 |
|
zinc_added |
bool |
|
ligand_added |
bool |
|
independent_experiments |
int |
|
kd_micromolar |
f64 |
|
kd_sem_micromolar |
f64 |
|
reported_dissociation_free_energy_kj_mol |
f64 |
|
reported_dissociation_free_energy_sem_kj_mol |
f64 |
|
modeled_dissociation_free_energy_kj_mol |
f64 |
|
modeled_dissociation_free_energy_sem_kj_mol |
f64 |
|
modeled_binding_free_energy_kj_mol |
f64 |
|
free_energy_residual_kj_mol |
f64 |
|
uncertainty_residual_kj_mol |
f64 |
|
combined_z_score |
f64 |
|
condition_pass |
bool |
|
thermodynamic_pass |
bool |
|
validated |
bool |
|
evidence_class |
str |
|
new_atomistic_simulation |
bool |
|
result_sha256 |
str |
|
direct_oracle_result_sha256 |
str |
|
direct_oracle_path |
str |
|
direct_parity_pass |
bool |
|
result_path |
str |
bridge insulin_backend
Section titled “bridge insulin_backend”insulin_pmf
Section titled “insulin_pmf”Bounded explicit-solvent insulin-dimer association PMF evidence with strict validation gates.
struct InsulinPmfResult
Section titled “struct InsulinPmfResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
source_sha256 |
str |
|
system_sha256 |
str |
|
sample_sha256 |
list[str] |
|
evidence_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
pdb_id |
str |
|
backend |
str |
|
backend_version |
str |
|
platform |
str |
|
force_field |
str |
|
water_model |
str |
|
temperature_k |
f64 |
|
atoms |
int |
|
protein_atoms |
int |
|
windows |
int |
|
replicas_per_window |
int |
|
samples_per_replica |
int |
|
total_dynamics_steps |
int |
|
window_centers_nm |
list[f64] |
|
force_constants_kj_mol_nm2 |
list[f64] |
|
initial_centroid_distance_nm |
f64 |
|
minimized_energy_kj_mol |
f64 |
|
minimum_adjacent_overlap |
f64 |
|
adjacent_overlap |
list[f64] |
|
overlap_matrix |
list[f64] |
|
rhat_by_window |
list[f64] |
|
rhat_max |
f64 |
|
integrated_autocorrelation_by_replica |
list[f64] |
|
maximum_integrated_autocorrelation |
f64 |
|
ess_by_replica |
list[f64] |
|
total_ess |
f64 |
|
mbar_free_energies_reduced |
list[f64] |
|
mbar_iterations |
int |
|
mbar_residual |
f64 |
|
estimator_converged |
bool |
|
overlap_pass |
bool |
|
rhat_pass |
bool |
|
autocorrelation_pass |
bool |
|
ess_pass |
bool |
|
sampling_converged |
bool |
|
sampling_uncertainty_available |
bool |
|
parameter_uncertainty_available |
bool |
|
model_form_uncertainty_available |
bool |
|
restraint_correction_available |
bool |
|
finite_size_correction_available |
bool |
|
standard_state_correction_available |
bool |
|
experimental_uncertainty_available |
bool |
|
sampling_uncertainty_kj_mol |
list[f64] |
|
parameter_uncertainty_kj_mol |
list[f64] |
|
model_form_uncertainty_kj_mol |
list[f64] |
|
restraint_correction_kj_mol |
list[f64] |
|
finite_size_correction_kj_mol |
list[f64] |
|
standard_state_correction_kj_mol |
list[f64] |
|
experimental_uncertainty_kj_mol |
list[f64] |
|
standard_state_delta_g_available |
bool |
|
standard_state_delta_g_kj_mol |
list[f64] |
|
independent_reference_pass |
bool |
|
scientific_validated |
bool |
|
technical_pass |
bool |
|
failure_type |
str |
|
blockers |
list[str] |
|
resumed_replicas |
int |
|
runtime_seconds |
f64 |
|
direct_oracle_result_sha256 |
str |
|
direct_oracle_path |
str |
|
direct_parity_pass |
bool |
bridge insulin_pmf_backend
Section titled “bridge insulin_pmf_backend”insulin_structure
Section titled “insulin_structure”Pinned zinc-free human-insulin dimer construction and explicit-solvent technical evidence.
struct InsulinAtomisticResult
Section titled “struct InsulinAtomisticResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
source_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
pdb_id |
str |
|
assembly |
int |
|
license |
str |
|
doi |
str |
|
backend |
str |
|
backend_version |
str |
|
platform |
str |
|
force_field |
str |
|
water_model |
str |
|
temperature_k |
f64 |
|
ph |
f64 |
|
ionic_strength_molar |
f64 |
|
monomers |
int |
|
protein_residues |
int |
|
protein_atoms |
int |
|
atoms |
int |
|
solvent_atoms |
int |
|
disulfide_bonds |
int |
|
interface_contact_angstrom |
f64 |
|
initial_energy_kj_mol |
f64 |
|
final_energy_kj_mol |
f64 |
|
max_force_kj_mol_nm |
f64 |
|
steps |
int |
|
system_sha256 |
str |
|
final_positions_sha256 |
str |
|
structural_pass |
bool |
|
technical_pass |
bool |
|
association_validated |
bool |
|
evidence_class |
str |
|
direct_oracle_result_sha256 |
str |
|
direct_oracle_path |
str |
|
direct_parity_pass |
bool |
bridge insulin_structure_backend
Section titled “bridge insulin_structure_backend”Persistent Sema HTTP service for evidence-bound live viewer dynamics.
struct LiveProfile
Section titled “struct LiveProfile”Fields
| field | type | descriptor |
|---|---|---|
model_id |
str |
|
association_rate |
f64 |
|
dissociation_rate |
f64 |
|
initial_state |
list[f64] |
|
evidence_ids |
list[str] |
|
scene_sha256 |
str |
|
population_cells |
int |
|
admission_evidence |
Phase8AdmissionEvidence |
|
adaptation |
AdaptationSummary |
def load_live_profile
Section titled “def load_live_profile”def load_live_profile() !{fs.read}Effects !{fs.read}
def response
Section titled “def response”def response(status: int, body: any) !{}Parameters
| name | type |
|---|---|
status |
int |
body |
any |
Effects !{}
def error_response
Section titled “def error_response”def error_response(status: int, code: str, detail: str) !{}Parameters
| name | type |
|---|---|
status |
int |
code |
str |
detail |
str |
Effects !{}
def active_species_registry
Section titled “def active_species_registry”def active_species_registry(profile: LiveProfile, session: dict[str, any])Parameters
| name | type |
|---|---|
profile |
LiveProfile |
session |
dict[str, any] |
def species_adjusted_program
Section titled “def species_adjusted_program”def species_adjusted_program(program: dict[str, any], registry: dict[str, any]) !{}Parameters
| name | type |
|---|---|
program |
dict[str, any] |
registry |
dict[str, any] |
Effects !{}
def status_response
Section titled “def status_response”def status_response(profile: LiveProfile, session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{}
def step_input_error
Section titled “def step_input_error”def step_input_error(payload: any) !{}Parameters
| name | type |
|---|---|
payload |
any |
Effects !{}
def canonical_step_request_identity
Section titled “def canonical_step_request_identity”def canonical_step_request_identity(payload: dict[str, any], profile: LiveProfile, session: dict[str, any], admission_branch: str, step_state: any, step_population: any, step_physiology: any, step_species: any) !{}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
admission_branch |
str |
step_state |
any |
step_population |
any |
step_physiology |
any |
step_species |
any |
Effects !{}
def live_step_response_body
Section titled “def live_step_response_body”def live_step_response_body(step: any, generation: int, molecular_generation: int) !{}Parameters
| name | type |
|---|---|
step |
any |
generation |
int |
molecular_generation |
int |
Effects !{}
def exploratory_step_response
Section titled “def exploratory_step_response”def exploratory_step_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{}
def step_response
Section titled “def step_response”def step_response(payload: any, profile: LiveProfile, session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
payload |
any |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{}
def has_intervention_fields
Section titled “def has_intervention_fields”def has_intervention_fields(payload: dict[str, any])Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
def intervention_response
Section titled “def intervention_response”def intervention_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{}
def store_species
Section titled “def store_species”def store_species(profile: LiveProfile, session: dict[str, any], registry: dict[str, any])Parameters
| name | type |
|---|---|
profile |
LiveProfile |
session |
dict[str, any] |
registry |
dict[str, any] |
def docking_identity
Section titled “def docking_identity”def docking_identity(target: dict[str, any], ligand: dict[str, any], budget: int) !{}Parameters
| name | type |
|---|---|
target |
dict[str, any] |
ligand |
dict[str, any] |
budget |
int |
Effects !{}
def dock_design
Section titled “def dock_design”def dock_design(session: dict[str, any], name: str, budget: int) !{fs.read}Parameters
| name | type |
|---|---|
session |
dict[str, any] |
name |
str |
budget |
int |
Effects !{fs.read}
def design_result_body
Section titled “def design_result_body”def design_result_body(design: dict[str, any], species: any, summary: list[str])Parameters
| name | type |
|---|---|
design |
dict[str, any] |
species |
any |
summary |
list[str] |
def registration_error_response
Section titled “def registration_error_response”def registration_error_response(registration: dict[str, str]) !{}Parameters
| name | type |
|---|---|
registration |
dict[str, str] |
Effects !{}
def set_design_mechanism
Section titled “def set_design_mechanism”def set_design_mechanism(compiled: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
compiled |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{}
def apply_design_command
Section titled “def apply_design_command”def apply_design_command(compiled: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
compiled |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{}
def design_mutation_identity
Section titled “def design_mutation_identity”def design_mutation_identity(payload: dict[str, any]) !{}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
Effects !{}
def design_response
Section titled “def design_response”def design_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{}
def dock_response
Section titled “def dock_response”def dock_response(payload: dict[str, any], session: dict[str, any]) !{fs.read}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
session |
dict[str, any] |
Effects !{fs.read}
def introduce_response
Section titled “def introduce_response”def introduce_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{fs.read}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{fs.read}
def invalidate_molecular_step_caches
Section titled “def invalidate_molecular_step_caches”def invalidate_molecular_step_caches(session: dict[str, any])Parameters
| name | type |
|---|---|
session |
dict[str, any] |
def advance_molecular_generation
Section titled “def advance_molecular_generation”def advance_molecular_generation(session: dict[str, any])Parameters
| name | type |
|---|---|
session |
dict[str, any] |
def molecular_mutation_identity
Section titled “def molecular_mutation_identity”def molecular_mutation_identity(kind: str, payload: dict[str, any]) !{}Parameters
| name | type |
|---|---|
kind |
str |
payload |
dict[str, any] |
Effects !{}
def retained_molecular_mutation
Section titled “def retained_molecular_mutation”def retained_molecular_mutation(identity: str, session: dict[str, any])Parameters
| name | type |
|---|---|
identity |
str |
session |
dict[str, any] |
def retain_molecular_mutation
Section titled “def retain_molecular_mutation”def retain_molecular_mutation(identity: str, body: dict[str, any], session: dict[str, any])Parameters
| name | type |
|---|---|
identity |
str |
body |
dict[str, any] |
session |
dict[str, any] |
def molecule_response
Section titled “def molecule_response”def molecule_response(payload: dict[str, any], session: dict[str, any]) !{fs.read}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
session |
dict[str, any] |
Effects !{fs.read}
def molecule_step_response
Section titled “def molecule_step_response”def molecule_step_response(payload: dict[str, any], session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
session |
dict[str, any] |
Effects !{}
def direct_molecular_operations
Section titled “def direct_molecular_operations”def direct_molecular_operations(operations: list[dict[str, any]])Parameters
| name | type |
|---|---|
operations |
list[dict[str, any]] |
def program_response
Section titled “def program_response”def program_response(payload: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{fs.read}Parameters
| name | type |
|---|---|
payload |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{fs.read}
def capabilities_response
Section titled “def capabilities_response”def capabilities_response() !{}Effects !{}
def live_response
Section titled “def live_response”def live_response(request: dict[str, any], profile: LiveProfile, session: dict[str, any]) !{ffi.call, fs.read}Parameters
| name | type |
|---|---|
request |
dict[str, any] |
profile |
LiveProfile |
session |
dict[str, any] |
Effects !{ffi.call, fs.read}
def serve_live
Section titled “def serve_live”def serve_live(port: int) -> None !{ffi.call, fs.read, net.listen}Parameters
| name | type |
|---|---|
port |
int |
Returns None
Effects !{ffi.call, fs.read, net.listen}
Pinned MACE-MP technical adapter with independent direct parity.
struct MaceProfileResult
Section titled “struct MaceProfileResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
platform |
str |
|
device |
str |
|
default_dtype |
str |
|
mace_torch_version |
str |
|
torch_version |
str |
|
checkpoint_url |
str |
|
checkpoint_sha256 |
str |
|
checkpoint_bytes |
int |
|
checkpoint_license |
str |
|
training_domain |
str |
|
provenance_sha256 |
str |
|
config_sha256 |
str |
|
system_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
direct_oracle_file_sha256 |
str |
|
direct_oracle_result_sha256 |
str |
|
atoms |
int |
|
base_energy_ev |
f64 |
|
displaced_energy_ev |
f64 |
|
ablation_energy_delta_ev |
f64 |
|
max_force_ev_per_angstrom |
f64 |
|
finite_difference_force_residual_ev_per_angstrom |
f64 |
|
translation_energy_residual_ev |
f64 |
|
translation_force_residual_ev_per_angstrom |
f64 |
|
direct_energy_residual_ev |
f64 |
|
direct_force_residual_ev_per_angstrom |
f64 |
|
finite_difference_pass |
bool |
|
translation_pass |
bool |
|
ablation_pass |
bool |
|
direct_parity_pass |
bool |
|
technical_pass |
bool |
|
reference_kind |
str |
|
replay_class |
str |
|
domain_status |
str |
|
uncertainty_available |
bool |
|
molecular_validated |
bool |
|
evidence_class |
str |
bridge mace_backend
Section titled “bridge mace_backend”mace_off
Section titled “mace_off”MACE-OFF23 molecular holdout, calibrated uncertainty, OOD, and ablation evidence.
struct MaceOffResult
Section titled “struct MaceOffResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
dataset_sha256 |
str |
|
model_sha256 |
list[str] |
|
provenance_sha256 |
str |
|
checkpoint_license |
str |
|
dataset_license |
str |
|
level_of_theory |
str |
|
calibration_configurations |
int |
|
heldout_configurations |
int |
|
unique_molecules |
int |
|
heldout_energy_rmse_mev_per_atom |
f64 |
|
heldout_force_rmse_mev_per_angstrom |
f64 |
|
symbolic_only_force_rmse_mev_per_angstrom |
f64 |
|
hybrid_force_rmse_mev_per_angstrom |
f64 |
|
conformal_scale |
f64 |
|
conformal_coverage |
f64 |
|
ood_minimum_distance_angstrom |
f64 |
|
ood_uncertainty_ratio |
f64 |
|
in_domain_force_disagreement_mev_per_angstrom |
f64 |
|
ood_force_disagreement_mev_per_angstrom |
f64 |
|
ood_blocked |
bool |
|
translation_energy_residual_ev |
f64 |
|
translation_force_residual_ev_per_angstrom |
f64 |
|
accuracy_pass |
bool |
|
uncertainty_pass |
bool |
|
symmetry_pass |
bool |
|
ood_pass |
bool |
|
ablation_pass |
bool |
|
molecular_validated |
bool |
|
evidence_class |
str |
|
direct_oracle_result_sha256 |
str |
|
direct_energy_residual |
f64 |
|
direct_force_residual |
f64 |
|
direct_parity_pass |
bool |
|
result_sha256 |
str |
|
result_path |
str |
bridge mace_off_backend
Section titled “bridge mace_off_backend”Sema-owned biological workflow with evidence-gated foreign kernels and non-authoritative projections.
def phase10_summary
Section titled “def phase10_summary”def phase10_summary(result: Phase10QualificationResult)Parameters
| name | type |
|---|---|
result |
Phase10QualificationResult |
def main
Section titled “def main”def main() !{ffi.call, fs.read, fs.write, net.listen}Effects !{ffi.call, fs.read, fs.write, net.listen}
mesoscopic
Section titled “mesoscopic”Uncertainty-preserving molecular-to-reaction-diffusion parameter transfer.
struct MesoscopicResult
Section titled “struct MesoscopicResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
source_result_sha256 |
str |
|
source_artifact_sha256 |
str |
|
source_kd_micromolar |
f64 |
|
source_kd_sem_micromolar |
f64 |
|
association_rate_per_micromolar_s |
f64 |
|
dissociation_rate_per_s |
f64 |
|
voxels |
int |
|
steps |
int |
|
dt_s |
f64 |
|
simulated_time_s |
f64 |
|
initial_mass_micromolar |
f64 |
|
final_mass_micromolar |
f64 |
|
mass_relative_residual |
f64 |
|
expected_monomer_micromolar |
f64 |
|
expected_dimer_micromolar |
f64 |
|
observed_monomer_micromolar |
f64 |
|
observed_dimer_micromolar |
f64 |
|
observed_kd_micromolar |
f64 |
|
kd_relative_residual |
f64 |
|
spatial_cv |
f64 |
|
dimer_uncertainty_min_micromolar |
f64 |
|
dimer_uncertainty_max_micromolar |
f64 |
|
rate_roundtrip_relative_residual |
f64 |
|
sbml_sha256 |
str |
|
bngl_sha256 |
str |
|
uncertainty_pass |
bool |
|
interchange_pass |
bool |
|
transfer_pass |
bool |
|
reverse_discrepancy_signaled |
bool |
|
adapter_backend_sha256 |
str |
|
readdy_status |
str |
|
readdy_unavailable_reason |
str |
|
readdy_version |
str |
|
readdy_source_commit |
str |
|
readdy_wheel_filename |
str |
|
readdy_wheel_sha256 |
str |
|
readdy_module_sha256 |
str |
|
readdy_platform |
str |
|
readdy_executed |
bool |
|
readdy_target_rate_evidence |
bool |
|
readdy_concentration_evidence |
bool |
|
readdy_spatial_evidence |
bool |
|
readdy_uncertainty_evidence |
bool |
|
readdy_association_events |
int |
|
readdy_dissociation_events |
int |
|
readdy_lower_uncertainty_dissociation_events |
int |
|
readdy_upper_uncertainty_dissociation_events |
int |
|
readdy_final_monomer_particles |
int |
|
readdy_final_dimer_particles |
int |
|
readdy_mass_relative_residual |
f64 |
|
readdy_mean_displacement_micrometers |
f64 |
|
readdy_observation_sha256 |
str |
|
readdy_observation_json |
str |
|
readdy_validated |
bool |
|
physicell_status |
str |
|
physicell_unavailable_reason |
str |
|
physicell_version |
str |
|
physicell_source_commit |
str |
|
physicell_source_url |
str |
|
physicell_executable |
str |
|
physicell_executed |
bool |
|
physicell_target_rate_evidence |
bool |
|
physicell_concentration_evidence |
bool |
|
physicell_spatial_evidence |
bool |
|
physicell_uncertainty_evidence |
bool |
|
physicell_validated |
bool |
|
scientific_validated |
bool |
|
evidence_class |
str |
|
result_sha256 |
str |
|
direct_oracle_result_sha256 |
str |
|
direct_oracle_path |
str |
|
direct_residual |
f64 |
|
direct_parity_pass |
bool |
|
phase8_technical_pass |
bool |
|
sbml_path |
str |
|
bngl_path |
str |
|
result_path |
str |
bridge mesoscopic_backend
Section titled “bridge mesoscopic_backend”models
Section titled “models”Typed symbolic, learned, and hybrid equation terms with fail-closed evidence gates.
enum TermImplementation
Section titled “enum TermImplementation”Variants
symboliclearnedhybrid
enum LearnedRole
Section titled “enum LearnedRole”Variants
energyforceratetransition_probabilitystructure_proposalclosureparameter
enum ApplicabilityDecision
Section titled “enum ApplicabilityDecision”Variants
applicableout_of_domainunknown
enum PredictionStatus
Section titled “enum PredictionStatus”Variants
proposedadmissibleblocked
struct LearnedModelManifest
Section titled “struct LearnedModelManifest”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
family |
str |
|
version |
str |
|
role |
LearnedRole |
|
architecture_sha256 |
str |
|
weights_sha256 |
str |
|
training_data_sha256 |
str |
|
validation_data_sha256 |
str |
|
license_id |
str |
|
preprocessing |
str |
|
input_units |
list[str] |
|
output_unit |
str |
|
chemical_domain |
str |
|
thermodynamic_domain |
str |
|
symmetry_contract |
str |
|
calibration_method |
str |
|
uncertainty_method |
str |
|
ood_method |
str |
|
backend_profile_id |
str |
|
evidence_ids |
list[str] |
|
validated |
bool |
struct EquationTermDescriptor
Section titled “struct EquationTermDescriptor”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
owner_model_id |
str |
|
implementation |
TermImplementation |
|
role |
LearnedRole |
|
input_units |
list[str] |
|
output_unit |
str |
|
symbolic_expression |
str |
|
learned_model_id |
str |
|
combination_rule |
str |
|
authoritative_outputs |
list[str] |
struct PredictionUncertainty
Section titled “struct PredictionUncertainty”Fields
| field | type | descriptor |
|---|---|---|
aleatoric |
f64 |
|
epistemic |
f64 |
|
lower |
f64 |
|
upper |
f64 |
|
coverage |
f64 |
|
calibrated |
bool |
struct HybridPrediction
Section titled “struct HybridPrediction”Fields
| field | type | descriptor |
|---|---|---|
term_id |
str |
|
manifest_id |
str |
|
symbolic_value |
f64 |
|
learned_value |
f64 |
|
gate |
f64 |
|
combined_value |
f64 |
|
output_unit |
str |
|
uncertainty |
PredictionUncertainty |
|
applicability |
ApplicabilityDecision |
|
ood_score |
f64 |
|
symbolic_residual |
f64 |
|
evidence_ids |
list[str] |
|
status |
PredictionStatus |
|
reason |
str |
def additive_hybrid_value
Section titled “def additive_hybrid_value”def additive_hybrid_value(symbolic_value: f64, learned_correction: f64, gate: f64) !{}Parameters
| name | type |
|---|---|
symbolic_value |
f64 |
learned_correction |
f64 |
gate |
f64 |
Effects !{}
def manifest_qualified
Section titled “def manifest_qualified”def manifest_qualified(manifest: LearnedModelManifest)Parameters
| name | type |
|---|---|
manifest |
LearnedModelManifest |
def term_matches_manifest
Section titled “def term_matches_manifest”def term_matches_manifest(term: EquationTermDescriptor, manifest: LearnedModelManifest)Parameters
| name | type |
|---|---|
term |
EquationTermDescriptor |
manifest |
LearnedModelManifest |
def term_descriptor_valid
Section titled “def term_descriptor_valid”def term_descriptor_valid(term: EquationTermDescriptor)Parameters
| name | type |
|---|---|
term |
EquationTermDescriptor |
def assess_hybrid_prediction
Section titled “def assess_hybrid_prediction”def assess_hybrid_prediction(term: EquationTermDescriptor, manifest: LearnedModelManifest, symbolic_value: f64, learned_value: f64, gate: f64, uncertainty: PredictionUncertainty, applicability: ApplicabilityDecision, ood_score: f64, symbolic_residual: f64, maximum_uncertainty: f64, maximum_residual: f64, evidence_ids: list[str]) -> HybridPrediction !{}Parameters
| name | type |
|---|---|
term |
EquationTermDescriptor |
manifest |
LearnedModelManifest |
symbolic_value |
f64 |
learned_value |
f64 |
gate |
f64 |
uncertainty |
PredictionUncertainty |
applicability |
ApplicabilityDecision |
ood_score |
f64 |
symbolic_residual |
f64 |
maximum_uncertainty |
f64 |
maximum_residual |
f64 |
evidence_ids |
list[str] |
Returns HybridPrediction
Effects !{}
def prediction_admissible
Section titled “def prediction_admissible”def prediction_admissible(prediction: HybridPrediction) -> bool !{}Parameters
| name | type |
|---|---|
prediction |
HybridPrediction |
Returns bool
Effects !{}
molecular
Section titled “molecular”Headless, bounded molecular state, topology, and dynamics owned by Sema.
def molecular_manifest
Section titled “def molecular_manifest”def molecular_manifest() !{fs.read}Effects !{fs.read}
def structure_key_supported
Section titled “def structure_key_supported”def structure_key_supported(key: str) -> bool !{fs.read}Parameters
| name | type |
|---|---|
key |
str |
Returns bool
Effects !{fs.read}
def structure_entry
Section titled “def structure_entry”def structure_entry(key: str) !{fs.read}Parameters
| name | type |
|---|---|
key |
str |
Effects !{fs.read}
def validate_record
Section titled “def validate_record”def validate_record(record: dict[str, any], encoding: str, components: int, maximum_items: int)Parameters
| name | type |
|---|---|
record |
dict[str, any] |
encoding |
str |
components |
int |
maximum_items |
int |
def atomic_radius
Section titled “def atomic_radius”def atomic_radius(atomic_number: int, radius_kind: str)Parameters
| name | type |
|---|---|
atomic_number |
int |
radius_kind |
str |
def atomic_name
Section titled “def atomic_name”def atomic_name(atomic_number: int)Parameters
| name | type |
|---|---|
atomic_number |
int |
def decoded_traces
Section titled “def decoded_traces”def decoded_traces(source: list[dict[str, any]]) !{}Parameters
| name | type |
|---|---|
source |
list[dict[str, any]] |
Effects !{}
def active_bond_pairs
Section titled “def active_bond_pairs”def active_bond_pairs(session: dict[str, any])Parameters
| name | type |
|---|---|
session |
dict[str, any] |
def topology_digest
Section titled “def topology_digest”def topology_digest(session: dict[str, any]) !{}Parameters
| name | type |
|---|---|
session |
dict[str, any] |
Effects !{}
def molecular_session_integrity
Section titled “def molecular_session_integrity”def molecular_session_integrity(session: dict[str, any]) -> f64 !{}Parameters
| name | type |
|---|---|
session |
dict[str, any] |
Returns f64
Effects !{}
def molecular_public_state
Section titled “def molecular_public_state”def molecular_public_state(session: dict[str, any]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
session |
dict[str, any] |
Returns dict[str, any]
Effects !{}
def load_molecular_session
Section titled “def load_molecular_session”def load_molecular_session(key: str) -> dict[str, any] !{fs.read}Parameters
| name | type |
|---|---|
key |
str |
Returns dict[str, any]
Effects !{fs.read}
def clone_molecular_session
Section titled “def clone_molecular_session”def clone_molecular_session(session: dict[str, any])Parameters
| name | type |
|---|---|
session |
dict[str, any] |
def find_bond_index
Section titled “def find_bond_index”def find_bond_index(session: dict[str, any], left: int, right: int)Parameters
| name | type |
|---|---|
session |
dict[str, any] |
left |
int |
right |
int |
def operation_valid
Section titled “def operation_valid”def operation_valid(session: dict[str, any], operation: dict[str, any])Parameters
| name | type |
|---|---|
session |
dict[str, any] |
operation |
dict[str, any] |
def apply_operation
Section titled “def apply_operation”def apply_operation(session: dict[str, any], operation: dict[str, any]) !{}Parameters
| name | type |
|---|---|
session |
dict[str, any] |
operation |
dict[str, any] |
Effects !{}
def apply_molecular_program
Section titled “def apply_molecular_program”def apply_molecular_program(session: dict[str, any], payload: dict[str, any]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
session |
dict[str, any] |
payload |
dict[str, any] |
Returns dict[str, any]
Effects !{}
def step_molecular_session
Section titled “def step_molecular_session”def step_molecular_session(session: dict[str, any], dt_s: f64) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
session |
dict[str, any] |
dt_s |
f64 |
Returns dict[str, any]
Effects !{}
openmm
Section titled “openmm”Pinned OpenMM bridge contracts for the first scientific vertical.
struct BackendProbe
Section titled “struct BackendProbe”Fields
| field | type | descriptor |
|---|---|---|
available |
bool |
|
engine |
str |
|
version |
str |
|
platforms |
list[str] |
|
detail |
str |
struct OpenMMRun
Section titled “struct OpenMMRun”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
benchmark_id |
str |
|
profile_id |
str |
|
engine_version |
str |
|
platform |
str |
|
platform_properties |
list[str] |
|
config_sha256 |
str |
|
input_sha256 |
str |
|
system_sha256 |
str |
|
atom_count |
int |
|
bond_count |
int |
|
steps |
int |
|
frames |
int |
|
initial_potential_energy_kj_mol |
f64 |
|
initial_max_force_kj_mol_nm |
f64 |
|
initial_force_sha256 |
str |
|
minimized_potential_energy_kj_mol |
f64 |
|
minimized_max_force_kj_mol_nm |
f64 |
|
minimized_force_sha256 |
str |
|
nve_initial_total_energy_kj_mol |
f64 |
|
nve_final_total_energy_kj_mol |
f64 |
|
nve_drift_kj_mol |
f64 |
|
frames_sha256 |
str |
|
state_arrays_sha256 |
str |
|
frames_path |
str |
|
initial_forces_path |
str |
|
minimized_forces_path |
str |
|
result_sha256 |
str |
bridge openmm_adapter
Section titled “bridge openmm_adapter”bridge openmm_backend
Section titled “bridge openmm_backend”phase10
Section titled “phase10”Fail-closed qualification of measured Phase 10 renderer and interaction evidence.
struct Phase10QualificationResult
Section titled “struct Phase10QualificationResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
evidence_sha256 |
str |
|
scene_sha256 |
str |
|
bundle_sha256 |
str |
|
external_reference_sha256 |
str |
|
scientific_result_sha256 |
str |
|
screenshot_sha256 |
list[str] |
|
scale_count |
int |
|
minimum_average_fps |
f64 |
|
interaction_hz |
int |
|
canonical_update_hz |
int |
|
pick_p95_ms |
f64 |
|
dropped_frames |
int |
|
gpu_allocated_bytes |
int |
|
gpu_resource_count |
int |
|
context_loss_recovered |
bool |
|
semantic_validation_pass |
bool |
|
viewer_disabled_parity_pass |
bool |
|
pixel_equality_observed |
bool |
|
visual_regression_replay_pass |
bool |
|
capture_provenance_status |
str |
|
profile_validated |
bool |
|
scientific_validated |
bool |
def covers_four_scales
Section titled “def covers_four_scales”def covers_four_scales(records: list[any], key: str)Parameters
| name | type |
|---|---|
records |
list[any] |
key |
str |
def qualify_phase10
Section titled “def qualify_phase10”def qualify_phase10(config_path: str) -> Phase10QualificationResult !{fs.read}Parameters
| name | type |
|---|---|
config_path |
str |
Returns Phase10QualificationResult
Effects !{fs.read}
physicell
Section titled “physicell”Pinned official PhysiCell 1.14.2 Apple-arm64 executable and stock XML field-coupling evidence.
struct PhysiCellFieldMetrics
Section titled “struct PhysiCellFieldMetrics”Fields
| field | type | descriptor |
|---|---|---|
mean_micromolar |
f64 |
|
minimum_micromolar |
f64 |
|
maximum_micromolar |
f64 |
|
spatial_cv |
f64 |
|
field_mass_micromolar_micrometer3 |
f64 |
struct PhysiCellSubstrateCellMetrics
Section titled “struct PhysiCellSubstrateCellMetrics”Fields
| field | type | descriptor |
|---|---|---|
uptake_rates_per_min |
list[list[f64]] |
|
net_export_rates_micromolar_micrometer3_per_min |
list[list[f64]] |
|
internalized_total_micromolar_micrometer3 |
list[f64] |
struct PhysiCellSnapshot
Section titled “struct PhysiCellSnapshot”Fields
| field | type | descriptor |
|---|---|---|
voxels |
int |
|
cells |
int |
|
total_volume_micrometer3 |
f64 |
|
substrates |
list[str] |
|
fields |
dict[str, PhysiCellFieldMetrics] |
|
cell_substrates |
PhysiCellSubstrateCellMetrics |
struct PhysiCellScenario
Section titled “struct PhysiCellScenario”Fields
| field | type | descriptor |
|---|---|---|
name |
str |
|
coupled |
bool |
|
configured_monomer_micromolar |
f64 |
|
configured_dimer_micromolar |
f64 |
|
initial |
PhysiCellSnapshot |
|
final |
PhysiCellSnapshot |
struct PhysiCellScenarioExecution
Section titled “struct PhysiCellScenarioExecution”Fields
| field | type | descriptor |
|---|---|---|
name |
str |
|
wall_runtime_s |
f64 |
|
captured_output_bytes |
int |
|
output_files |
int |
|
output_bytes |
int |
|
initial_xml_sha256 |
str |
|
initial_mat_sha256 |
str |
|
initial_cell_mat_sha256 |
str |
|
final_xml_sha256 |
str |
|
final_mat_sha256 |
str |
|
final_cell_mat_sha256 |
str |
struct PhysiCellExecution
Section titled “struct PhysiCellExecution”Fields
| field | type | descriptor |
|---|---|---|
scenario_executions |
list[PhysiCellScenarioExecution] |
|
total_wall_runtime_s |
f64 |
|
total_output_bytes |
int |
|
total_output_files |
int |
struct PhysiCellResult
Section titled “struct PhysiCellResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
config_path |
str |
|
phase8_result_sha256 |
str |
|
phase8_artifact_sha256 |
str |
|
release_version |
str |
|
release_asset_sha256 |
str |
|
release_asset_bytes |
int |
|
release_asset_id |
int |
|
tag_commit |
str |
|
tag_ref_sha |
str |
|
tag_commit_verified |
bool |
|
license |
str |
|
workflow_sha256 |
str |
|
fetch_manifest_schema |
str |
|
fetch_manifest_path |
str |
|
fetch_manifest_sha256 |
str |
|
fetch_evidence_sha256 |
str |
|
fetch_remote_verified |
bool |
|
fetch_manifest_pass |
bool |
|
binary_sha256 |
str |
|
binary_bytes |
int |
|
binary_architectures |
list[str] |
|
host_architecture |
str |
|
arm64_dependencies |
list[str] |
|
initial_concentration_residual_micromolar |
f64 |
|
uniform_spatial_cv |
f64 |
|
mass_relative_residual |
f64 |
|
coupled_monomer_mean_delta_micromolar |
f64 |
|
coupled_dimer_mean_delta_micromolar |
f64 |
|
coupled_spatial_cv |
f64 |
|
coupled_external_monomer_mass_delta_micromolar_micrometer3 |
f64 |
|
coupled_internalized_monomer_delta_micromolar_micrometer3 |
f64 |
|
coupled_external_dimer_mass_delta_micromolar_micrometer3 |
f64 |
|
coupled_internalized_dimer_delta_micromolar_micrometer3 |
f64 |
|
coupled_mass_transfer_relative_residual |
f64 |
|
executable_pass |
bool |
|
platform_pass |
bool |
|
config_xml_field_coupling_pass |
bool |
|
field_output_pass |
bool |
|
concentration_transfer_pass |
bool |
|
spatial_transfer_pass |
bool |
|
mass_transfer_pass |
bool |
|
uncertainty_bound_transfer_pass |
bool |
|
cell_secretion_uptake_coupling_pass |
bool |
|
failure_contract_pass |
bool |
|
missing_failure_typed |
bool |
|
corrupt_failure_typed |
bool |
|
wrong_arch_failure_typed |
bool |
|
timeout_failure_typed |
bool |
|
oversized_output_failure_typed |
bool |
|
manifest_missing_failure_typed |
bool |
|
manifest_unverified_failure_typed |
bool |
|
manifest_tampered_failure_typed |
bool |
|
corrupt_asset_failure_typed |
bool |
|
corrupt_binary_failure_typed |
bool |
|
timeout_descendants_reaped |
bool |
|
oversized_output_descendants_reaped |
bool |
|
typed_failure_classes |
list[str] |
|
target_rate_evidence |
bool |
|
insulin_reaction_supported |
bool |
|
scientific_uncertainty_evidence |
bool |
|
scientific_validated |
bool |
|
technical_qualified |
bool |
|
evidence_class |
str |
|
unsupported_semantics |
list[str] |
|
integration_guidance |
list[str] |
|
scenarios |
list[PhysiCellScenario] |
|
execution |
PhysiCellExecution |
|
result_sha256 |
str |
|
mode |
str |
|
direct_parity_pass |
bool |
|
direct_result_sha256 |
str |
|
direct_residual |
f64 |
|
direct_artifact_sha256 |
str |
|
artifact_directory |
str |
|
result_path |
str |
bridge physicell_backend
Section titled “bridge physicell_backend”physiology
Section titled “physiology”Evidence-bound glucose, insulin, beta-cell, immune, and graft physiology.
def initial_physiology_parameters
Section titled “def initial_physiology_parameters”def initial_physiology_parameters() -> dict[str, f64] !{}Returns dict[str, f64]
Effects !{}
def physiology_parameter_bounds
Section titled “def physiology_parameter_bounds”def physiology_parameter_bounds() -> dict[str, list[f64]] !{}Returns dict[str, list[f64]]
Effects !{}
def physiology_parameter_value_valid
Section titled “def physiology_parameter_value_valid”def physiology_parameter_value_valid(name: str, value: f64) -> bool !{}Parameters
| name | type |
|---|---|
name |
str |
value |
f64 |
Returns bool
Effects !{}
def initial_physiology_state
Section titled “def initial_physiology_state”def initial_physiology_state() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
def physiology_equations
Section titled “def physiology_equations”def physiology_equations() -> list[str] !{}Returns list[str]
Effects !{}
def physiology_rates
Section titled “def physiology_rates”def physiology_rates(parameters: dict[str, f64], signals: dict[str, f64])Parameters
| name | type |
|---|---|
parameters |
dict[str, f64] |
signals |
dict[str, f64] |
def bounded_physiology_values
Section titled “def bounded_physiology_values”def bounded_physiology_values(values: list[f64])Parameters
| name | type |
|---|---|
values |
list[f64] |
def step_physiology_state
Section titled “def step_physiology_state”def step_physiology_state(state: dict[str, any], dt_s: f64, signals: dict[str, f64], parameters: dict[str, f64]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
state |
dict[str, any] |
dt_s |
f64 |
signals |
dict[str, f64] |
parameters |
dict[str, f64] |
Returns dict[str, any]
Effects !{}
def physiology_public_state
Section titled “def physiology_public_state”def physiology_public_state(state: dict[str, any], signals: dict[str, f64], parameters: dict[str, f64]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
state |
dict[str, any] |
signals |
dict[str, f64] |
parameters |
dict[str, f64] |
Returns dict[str, any]
Effects !{}
portable
Section titled “portable”Measured Phase 9 ABI, CPU/MPS, process-loss, and checkpoint evidence.
struct PortabilityResult
Section titled “struct PortabilityResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
profile_identity_sha256 |
str |
|
config_sha256 |
str |
|
source_result_sha256 |
str |
|
source_artifact_sha256 |
str |
|
backend_identity_sha256 |
str |
|
backend_source_sha256 |
str |
|
sema_contract_source_sha256 |
str |
|
numpy_version |
str |
|
torch_version |
str |
|
python_version |
str |
|
cpu_backend |
str |
|
cpu_device |
str |
|
gpu_backend |
str |
|
gpu_device |
str |
|
mps_available |
bool |
|
mps_evidence_status |
str |
|
precision |
str |
|
batch |
int |
|
voxels |
int |
|
steps |
int |
|
repeats |
int |
|
concentration_residual_micromolar |
f64 |
|
cpu_mass_relative_residual |
f64 |
|
gpu_mass_relative_residual |
f64 |
|
cpu_p95_latency_ms |
f64 |
|
gpu_p95_latency_ms |
f64 |
|
cpu_throughput_voxel_steps_per_s |
f64 |
|
gpu_throughput_voxel_steps_per_s |
f64 |
|
gpu_allocated_bytes |
int |
|
gpu_host_transfer_bytes |
int |
|
abi_scope |
str |
|
bulk_elements |
int |
|
bulk_payload_bytes |
int |
|
bulk_calls |
int |
|
bulk_p95_latency_ms |
f64 |
|
bulk_checksum_residual |
f64 |
|
bulk_pointer_equal |
bool |
|
bulk_shares_memory |
bool |
|
cpu_zero_copy |
bool |
|
gpu_zero_copy |
bool |
|
sema_bridge_zero_copy_validated |
bool |
|
bulk_abi_pass |
bool |
|
distributed_evidence_kind |
str |
|
multiprocessing_start_method |
str |
|
distributed_worker_count |
int |
|
distributed_partition_batch |
int |
|
distributed_total_steps |
int |
|
worker_pids |
list[int] |
|
survivor_worker_ids |
list[int] |
|
survivor_worker_pids |
list[int] |
|
survivor_worker_exitcodes |
list[int] |
|
killed_worker_id |
int |
|
killed_worker_pid |
int |
|
killed_worker_exitcode |
int |
|
killed_worker_signal |
str |
|
recovery_worker_pid |
int |
|
recovery_worker_exitcode |
int |
|
recovery_resumed_step |
int |
|
stable_checkpoint_step |
int |
|
partial_checkpoint_step |
int |
|
partial_checkpoint_bytes |
int |
|
partial_checkpoint_intended_bytes |
int |
|
rejected_checkpoint_count |
int |
|
rejected_checkpoint_error_codes |
list[str] |
|
checkpoint_manifest_sha256 |
str |
|
distributed_residual_micromolar |
f64 |
|
corrupt_checkpoint_blocked |
bool |
|
partial_checkpoint_blocked |
bool |
|
worker_loss_failure_validated |
bool |
|
same_node_distributed_process_pass |
bool |
|
distributed_validated |
bool |
|
cross_node_distributed_validated |
bool |
|
checkpoint_pass |
bool |
|
device_loss_evidence_kind |
str |
|
device_loss_injection_attempted |
bool |
|
device_loss_injection_observed |
bool |
|
device_loss_recovery_pass |
bool |
|
device_loss_recovery_residual_micromolar |
f64 |
|
device_loss_failure_validated |
bool |
|
physical_device_loss_observed |
bool |
|
physical_device_loss_validated |
bool |
|
scientific_parity_pass |
bool |
|
cpu_profile_qualified |
bool |
|
gpu_profile_qualified |
bool |
|
single_node_portability_pass |
bool |
|
local_technical_pass |
bool |
|
portable_core_validated |
bool |
|
direct_parity_pass |
bool |
|
phase9_admitted |
bool |
|
phase9_validated |
bool |
|
scientific_validated |
bool |
|
evidence_class |
str |
|
direct_oracle_result_sha256 |
str |
|
direct_oracle_artifact_sha256 |
str |
|
direct_oracle_path |
str |
|
direct_residual |
f64 |
|
result_sha256 |
str |
|
result_path |
str |
bridge portable_backend
Section titled “bridge portable_backend”profiles
Section titled “profiles”Honest contracts for QM/MM, mesoscopic, cellular, and performance phases.
struct QmMmPartition
Section titled “struct QmMmPartition”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
qm_atom_indices |
list[int] |
|
mm_atom_indices |
list[int] |
|
boundary_atom_indices |
list[int] |
|
total_charge_e |
int |
|
spin_multiplicity |
int |
|
embedding |
str |
|
backend_profile_id |
str |
struct ParameterizationEdge
Section titled “struct ParameterizationEdge”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
source_model_id |
str |
|
target_model_id |
str |
|
parameter_names |
list[str] |
|
values |
list[f64] |
|
uncertainties |
list[f64] |
|
units |
list[str] |
|
evidence_ids |
list[str] |
struct PlatformBenchmark
Section titled “struct PlatformBenchmark”Fields
| field | type | descriptor |
|---|---|---|
profile_id |
str |
|
hardware |
str |
|
operating_system |
str |
|
backend |
str |
|
precision |
str |
|
model_digest |
str |
|
tolerance_profile |
str |
|
simulated_ns_per_day |
f64 |
|
p50_step_ms |
f64 |
|
p95_step_ms |
f64 |
|
resident_memory_bytes |
int |
|
transfer_bytes |
int |
|
observable_error |
f64 |
|
evidence_ids |
list[str] |
enum NativeKernelKind
Section titled “enum NativeKernelKind”Variants
sema_aotrust_nativec_abicpp_abiecosystem_bridge
enum AcceleratorKind
Section titled “enum AcceleratorKind”Variants
cpuapple_metalapple_mpsmlxcudahipwebgl2webgpu
struct KernelDemand
Section titled “struct KernelDemand”Fields
| field | type | descriptor |
|---|---|---|
operation |
str |
|
precision |
str |
|
tolerance_profile |
str |
|
minimum_throughput_per_s |
f64 |
|
maximum_p95_ms |
f64 |
|
maximum_observable_error |
f64 |
|
maximum_resident_memory_bytes |
int |
struct NativeAccelerationProfile
Section titled “struct NativeAccelerationProfile”Fields
| field | type | descriptor |
|---|---|---|
profile_id |
str |
|
kernel_id |
str |
|
native_kind |
NativeKernelKind |
|
accelerator |
AcceleratorKind |
|
device_name |
str |
|
precision |
str |
|
tolerance_profile |
str |
|
available |
bool |
|
qualified |
bool |
|
zero_copy |
bool |
|
unified_memory |
bool |
|
supported_operations |
list[str] |
|
measured_throughput_per_s |
f64 |
|
measured_p95_ms |
f64 |
|
observable_error |
f64 |
|
resident_memory_bytes |
int |
|
host_device_transfer_bytes |
int |
|
artifact_sha256 |
str |
|
model_sha256 |
str |
|
oracle_evidence_ids |
list[str] |
|
benchmark_evidence_ids |
list[str] |
struct AccelerationDecision
Section titled “struct AccelerationDecision”Fields
| field | type | descriptor |
|---|---|---|
selected |
bool |
|
profile_id |
str |
|
native_kind |
NativeKernelKind |
|
accelerator |
AcceleratorKind |
|
zero_copy |
bool |
|
reason |
str |
def operation_supported
Section titled “def operation_supported”def operation_supported(operation: str, supported_operations: list[str])Parameters
| name | type |
|---|---|
operation |
str |
supported_operations |
list[str] |
def acceleration_priority
Section titled “def acceleration_priority”def acceleration_priority(accelerator: AcceleratorKind)Parameters
| name | type |
|---|---|
accelerator |
AcceleratorKind |
def acceleration_profile_eligible
Section titled “def acceleration_profile_eligible”def acceleration_profile_eligible(profile: NativeAccelerationProfile, demand: KernelDemand)Parameters
| name | type |
|---|---|
profile |
NativeAccelerationProfile |
demand |
KernelDemand |
def select_native_acceleration
Section titled “def select_native_acceleration”def select_native_acceleration(demand: KernelDemand, profiles: list[NativeAccelerationProfile]) -> AccelerationDecision !{}Parameters
| name | type |
|---|---|
demand |
KernelDemand |
profiles |
list[NativeAccelerationProfile] |
Returns AccelerationDecision
Effects !{}
def indices_unique
Section titled “def indices_unique”def indices_unique(values: list[int])Parameters
| name | type |
|---|---|
values |
list[int] |
def lists_disjoint
Section titled “def lists_disjoint”def lists_disjoint(left_values: list[int], right_values: list[int])Parameters
| name | type |
|---|---|
left_values |
list[int] |
right_values |
list[int] |
def qmmm_partition_valid
Section titled “def qmmm_partition_valid”def qmmm_partition_valid(partition: QmMmPartition, atom_count: int) -> bool !{}Parameters
| name | type |
|---|---|
partition |
QmMmPartition |
atom_count |
int |
Returns bool
Effects !{}
def parameterization_valid
Section titled “def parameterization_valid”def parameterization_valid(edge: ParameterizationEdge) -> bool !{}Parameters
| name | type |
|---|---|
edge |
ParameterizationEdge |
Returns bool
Effects !{}
def benchmark_comparable
Section titled “def benchmark_comparable”def benchmark_comparable(reference: PlatformBenchmark, candidate: PlatformBenchmark) -> bool !{}Parameters
| name | type |
|---|---|
reference |
PlatformBenchmark |
candidate |
PlatformBenchmark |
Returns bool
Effects !{}
def unavailable_phase
Section titled “def unavailable_phase”def unavailable_phase(phase: int, profile_id: str, backend: str)Parameters
| name | type |
|---|---|
phase |
int |
profile_id |
str |
backend |
str |
programming
Section titled “programming”Typed, transactional biological programming plans for viewers and agents.
def initial_signal_values
Section titled “def initial_signal_values”def initial_signal_values()def initial_program_state
Section titled “def initial_program_state”def initial_program_state() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
def normalized_signal
Section titled “def normalized_signal”def normalized_signal(name: str)Parameters
| name | type |
|---|---|
name |
str |
def signal_bounds
Section titled “def signal_bounds”def signal_bounds() -> dict[str, list[f64]] !{}Returns dict[str, list[f64]]
Effects !{}
def signal_value_valid
Section titled “def signal_value_valid”def signal_value_valid(name: str, value: f64)Parameters
| name | type |
|---|---|
name |
str |
value |
f64 |
def signal_operation
Section titled “def signal_operation”def signal_operation(name: str, value: f64)Parameters
| name | type |
|---|---|
name |
str |
value |
f64 |
def design_command_result
Section titled “def design_command_result”def design_command_result(text: str)Parameters
| name | type |
|---|---|
text |
str |
def design_command_valid
Section titled “def design_command_valid”def design_command_valid(design: any) !{}Parameters
| name | type |
|---|---|
design |
any |
Effects !{}
def compile_biological_command
Section titled “def compile_biological_command”def compile_biological_command(command: str) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
command |
str |
Returns dict[str, any]
Effects !{}
def program_operation_valid
Section titled “def program_operation_valid”def program_operation_valid(operation: dict[str, any]) !{}Parameters
| name | type |
|---|---|
operation |
dict[str, any] |
Effects !{}
def apply_biological_program
Section titled “def apply_biological_program”def apply_biological_program(state: dict[str, any], payload: dict[str, any]) -> dict[str, any] !{}Parameters
| name | type |
|---|---|
state |
dict[str, any] |
payload |
dict[str, any] |
Returns dict[str, any]
Effects !{}
def programming_capabilities
Section titled “def programming_capabilities”def programming_capabilities() -> dict[str, any] !{}Returns dict[str, any]
Effects !{}
Fixed-partition electrostatic-embedding QM/MM technical evidence.
struct QmmmResult
Section titled “struct QmmmResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
backend |
str |
|
backend_version |
str |
|
method |
str |
|
basis |
str |
|
embedding |
str |
|
qm_atoms |
int |
|
mm_point_charges |
int |
|
charge_e |
int |
|
spin_2s |
int |
|
link_atoms |
int |
|
boundary_treatment |
str |
|
reaction_coordinate |
str |
|
coordinate_angstrom |
list[f64] |
|
energies_hartree |
list[f64] |
|
forces_hartree_per_bohr |
list[f64] |
|
reaction_span_kj_mol |
f64 |
|
energy_symmetry_residual_hartree |
f64 |
|
force_antisymmetry_residual_hartree_per_bohr |
f64 |
|
center_force_hartree_per_bohr |
f64 |
|
gradient_residual_hartree_per_bohr |
f64 |
|
symmetry_pass |
bool |
|
gradient_pass |
bool |
|
technical_pass |
bool |
|
evidence_class |
str |
|
adaptive_partition |
bool |
|
multicode_validated |
bool |
|
result_sha256 |
str |
|
direct_oracle_result_sha256 |
str |
|
direct_oracle_path |
str |
|
direct_energy_residual_hartree |
f64 |
|
direct_force_residual_hartree_per_bohr |
f64 |
|
direct_gradient_residual_hartree_per_bohr |
f64 |
|
direct_parity_pass |
bool |
|
result_path |
str |
bridge qmmm_backend
Section titled “bridge qmmm_backend”qmmm_multicode
Section titled “qmmm_multicode”Pinned 6S34 insulin fixed-partition QM/MM evidence with honest second-code gating.
struct QmmmMulticodeResult
Section titled “struct QmmmMulticodeResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
backend_source_path |
str |
|
backend_source_sha256 |
str |
|
sema_contract_source_path |
str |
|
sema_contract_source_sha256 |
str |
|
oracle_source_path |
str |
|
oracle_source_sha256 |
str |
|
structure_path |
str |
|
structure_sha256 |
str |
|
pdb_id |
str |
|
partition_id |
str |
|
partition_identity_sha256 |
str |
|
qm_atom_ids |
list[str] |
|
boundary_identities |
Any |
|
link_atom_ids |
list[str] |
|
embedding_site_identities |
Any |
|
embedding_model |
str |
|
embedding_total_charge_e |
f64 |
|
qm_charge_e |
int |
|
spin_multiplicity |
int |
|
source_reaction_coordinate_angstrom |
f64 |
|
reaction_coordinates_angstrom |
list[f64] |
|
primary_backend |
str |
|
primary_version |
str |
|
primary_method |
str |
|
primary_basis |
str |
|
primary_status |
str |
|
primary_executed |
bool |
|
primary_energies_hartree |
list[f64] |
|
primary_forces_hartree_per_angstrom |
list[f64] |
|
primary_mulliken_charges_e |
Any |
|
primary_scf_iterations |
list[int] |
|
primary_converged |
bool |
|
primary_charge_sum_residual_e |
f64 |
|
secondary_backend |
str |
|
secondary_requested_version |
str |
|
secondary_observed_version |
str |
|
secondary_status |
str |
|
secondary_failure_code |
str |
|
secondary_unavailable_reason |
str |
|
secondary_executed |
bool |
|
secondary_energies_hartree |
list[f64] |
|
secondary_forces_hartree_per_angstrom |
list[f64] |
|
secondary_atomic_charges_e |
Any |
|
secondary_converged |
bool |
|
partition_identity_pass |
bool |
|
primary_technical_pass |
bool |
|
multicode_energy_parity_pass |
bool |
|
multicode_force_parity_pass |
bool |
|
multicode_charge_parity_pass |
bool |
|
multicode_reaction_coordinate_parity_pass |
bool |
|
multicode_technical_pass |
bool |
|
insulin_partition_validated |
bool |
|
phase7_validated |
bool |
|
multicode_residuals_available |
bool |
|
maximum_energy_residual_hartree |
f64 |
|
maximum_force_residual_hartree_per_angstrom |
f64 |
|
maximum_atomic_charge_residual_e |
f64 |
|
scientific_validated |
bool |
|
evidence_class |
str |
|
platform |
str |
|
result_sha256 |
str |
|
direct_oracle_result_sha256 |
str |
|
direct_oracle_path |
str |
|
direct_residual |
f64 |
|
direct_parity_pass |
bool |
|
result_path |
str |
bridge qmmm_multicode_backend
Section titled “bridge qmmm_multicode_backend”def run_profile
Section titled “def run_profile”def run_profile(config_path: str, oracle_path: str, output_path: str) -> QmmmMulticodeResult !{ffi.call, fs.read, fs.write}Parameters
| name | type |
|---|---|
config_path |
str |
oracle_path |
str |
output_path |
str |
Returns QmmmMulticodeResult
Effects !{ffi.call, fs.read, fs.write}
rare_event
Section titled “rare_event”Bounded well-tempered metadynamics with an exact symmetry reference.
struct RareEventResult
Section titled “struct RareEventResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
benchmark_id |
str |
|
method |
str |
|
method_reference_doi |
str |
|
engine |
str |
|
engine_version |
str |
|
platform |
str |
|
config_sha256 |
str |
|
system_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
replay_class |
str |
|
reference_replay_class |
str |
|
evidence_class |
str |
|
replicas |
int |
|
grid_min_nm |
f64 |
|
grid_max_nm |
f64 |
|
grid_width |
int |
|
free_energy_mean_kj_mol |
list[f64] |
|
free_energy_sem_kj_mol |
list[f64] |
|
left_population_mean |
f64 |
|
left_population_sem |
f64 |
|
free_energy_difference_mean_kj_mol |
f64 |
|
free_energy_difference_sem_kj_mol |
f64 |
|
min_transitions |
int |
|
reference_left_population |
f64 |
|
reference_free_energy_difference_kj_mol |
f64 |
|
converged |
bool |
bridge rare_event_backend
Section titled “bridge rare_event_backend”readdy_calibration
Section titled “readdy_calibration”Preregistered ReaDDy calibration qualification with held-out, fail-closed evidence.
struct ReaddyCalibrationResult
Section titled “struct ReaddyCalibrationResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
execution_config_sha256 |
str |
|
evidence_sha256 |
str |
|
evidence_rebound_without_execution |
bool |
|
result_sha256 |
str |
|
source_digests |
dict[str, str] |
|
package_manifest |
dict[str, any] |
|
unit_mapping |
dict[str, any] |
|
target |
dict[str, f64] |
|
training_design |
dict[str, any] |
|
calibration_lock |
dict[str, any] |
|
heldout_design |
dict[str, any] |
|
heldout_evidence_admission |
dict[str, any] |
|
heldout_rates |
dict[str, any] |
|
condition_summaries |
list[dict[str, any]] |
|
statistics |
dict[str, any] |
|
gates |
dict[str, bool] |
|
qualification_pass |
bool |
|
calibration_evidence_status |
str |
|
failure_type |
str |
|
blockers |
list[str] |
|
phase8_scientific_validation |
bool |
|
scientific_validated |
bool |
|
scientific_validation_scope |
str |
|
training_evidence_manifest |
list[dict[str, str]] |
|
heldout_evidence_manifest |
list[dict[str, str]] |
|
runtime_seconds |
f64 |
bridge readdy_calibration_backend
Section titled “bridge readdy_calibration_backend”reference
Section titled “reference”Pinned condition-matched public molecular reference and published-timescale reproduction.
struct MolecularReferenceResult
Section titled “struct MolecularReferenceResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
reference_id |
str |
|
config_sha256 |
str |
|
artifact_sha256 |
str |
|
target_config_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
license |
str |
|
primary_reference |
str |
|
engine |
str |
|
force_field |
str |
|
water_model |
str |
|
integrator |
str |
|
temperature_k |
f64 |
|
observable |
str |
|
replicas |
int |
|
samples_per_replica |
int |
|
clusters |
int |
|
primary_lag_frames |
int |
|
slow_timescale_ps |
f64 |
|
fast_timescale_ps |
f64 |
|
slow_timescale_sem_ps |
f64 |
|
fast_timescale_sem_ps |
f64 |
|
right_population_mean |
f64 |
|
right_population_sem |
f64 |
|
right_population_by_replica |
list[f64] |
|
ensemble_transitions |
int |
|
ensemble_rhat |
f64 |
|
ensemble_converged |
bool |
|
effective_samples |
f64 |
|
lag_relative_spread_max |
f64 |
|
kmeans_iterations |
int |
|
kmeans_final_shift |
f64 |
|
reproduced |
bool |
|
condition_matched |
bool |
|
evidence_class |
str |
bridge molecular_reference
Section titled “bridge molecular_reference”Non-authoritative Rerun recording projection for canonical molecular frames.
struct RerunRecording
Section titled “struct RerunRecording”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
path |
str |
|
frames |
int |
|
bytes |
int |
|
sha256 |
str |
|
source_frames_sha256 |
str |
|
source_result_sha256 |
str |
|
coarse_result_sha256 |
str |
|
ensemble_result_sha256 |
str |
|
ensemble_sampling_converged |
bool |
|
rare_event_result_sha256 |
str |
|
rare_event_technical_converged |
bool |
|
mace_result_sha256 |
str |
|
mace_technical_pass |
bool |
|
mace_uncertainty_available |
bool |
|
mace_molecular_validated |
bool |
|
model_sha256 |
str |
|
parameter_sha256 |
str |
|
equation_terms |
int |
bridge rerun_projection
Section titled “bridge rerun_projection”resolution
Section titled “resolution”Approximation, negligibility, resolution-graph, and transactional transition contracts.
enum EdgeKind
Section titled “enum EdgeKind”Variants
composecouplerefinecoarsenrestrictprolongobserveparameterize
enum TransitionState
Section titled “enum TransitionState”Variants
requestedpreparedvalidatedcommittedblocked
struct ApproximationContract
Section titled “struct ApproximationContract”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
source_model_id |
str |
|
target_model_id |
str |
|
transform |
str |
|
preserved_observables |
list[str] |
|
marginalized_degrees |
list[str] |
|
calibration_domain |
str |
|
maximum_error |
f64 |
|
refine_threshold |
f64 |
|
evidence_ids |
list[str] |
|
valid |
bool |
struct NegligibilityCertificate
Section titled “struct NegligibilityCertificate”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
interaction_family |
str |
|
target_observable |
str |
|
comparison_scale |
str |
|
upper_bound_ratio |
f64 |
|
error_floor_ratio |
f64 |
|
activation_condition |
str |
|
evidence_ids |
list[str] |
|
valid |
bool |
struct ResolutionNode
Section titled “struct ResolutionNode”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
scale |
ModelScale |
|
model_version |
str |
|
resolved_degrees |
list[str] |
|
target_observables |
list[str] |
|
active |
bool |
struct ResolutionEdge
Section titled “struct ResolutionEdge”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
kind |
EdgeKind |
|
source_node_id |
str |
|
target_node_id |
str |
|
approximation |
ApproximationContract |
|
restriction |
str |
|
prolongation |
str |
|
checkpoint_only |
bool |
struct TransitionRecord
Section titled “struct TransitionRecord”Fields
| field | type | descriptor |
|---|---|---|
sequence |
int |
|
edge_id |
str |
|
from_state_version |
int |
|
to_state_version |
int |
|
state |
TransitionState |
|
reason |
str |
|
evidence_ids |
list[str] |
|
lost_information |
list[str] |
|
occurred_at_s |
f64 |
def approximation_valid
Section titled “def approximation_valid”def approximation_valid(contract: ApproximationContract)Parameters
| name | type |
|---|---|
contract |
ApproximationContract |
def negligibility_valid
Section titled “def negligibility_valid”def negligibility_valid(certificate: NegligibilityCertificate)Parameters
| name | type |
|---|---|
certificate |
NegligibilityCertificate |
def edge_valid
Section titled “def edge_valid”def edge_valid(edge: ResolutionEdge)Parameters
| name | type |
|---|---|
edge |
ResolutionEdge |
def prepare_transition
Section titled “def prepare_transition”def prepare_transition(sequence: int, edge: ResolutionEdge, state_version: int, occurred_at_s: f64) -> TransitionRecord !{}Parameters
| name | type |
|---|---|
sequence |
int |
edge |
ResolutionEdge |
state_version |
int |
occurred_at_s |
f64 |
Returns TransitionRecord
Effects !{}
def validate_transition
Section titled “def validate_transition”def validate_transition(record: TransitionRecord, evidence: list[EvidenceRecord], observable_error: f64, threshold: f64) -> TransitionRecord !{}Parameters
| name | type |
|---|---|
record |
TransitionRecord |
evidence |
list[EvidenceRecord] |
observable_error |
f64 |
threshold |
f64 |
Returns TransitionRecord
Effects !{}
def commit_transition
Section titled “def commit_transition”def commit_transition(record: TransitionRecord) -> TransitionRecord !{}Parameters
| name | type |
|---|---|
record |
TransitionRecord |
Returns TransitionRecord
Effects !{}
statistics
Section titled “statistics”Bounded ensemble diagnostics, coarse-state comparison, and PMF correction algebra.
struct BasinPopulations
Section titled “struct BasinPopulations”Fields
| field | type | descriptor |
|---|---|---|
alpha |
f64 |
|
beta |
f64 |
|
other |
f64 |
|
samples |
int |
struct EnsembleDiagnostics
Section titled “struct EnsembleDiagnostics”Fields
| field | type | descriptor |
|---|---|---|
samples |
int |
|
replicas |
int |
|
mean |
f64 |
|
variance |
f64 |
|
lag1_autocorrelation |
f64 |
|
effective_sample_size |
f64 |
|
converged |
bool |
struct DistributionComparison
Section titled “struct DistributionComparison”Fields
| field | type | descriptor |
|---|---|---|
total_variation |
f64 |
|
threshold |
f64 |
|
passed |
bool |
struct PmfCorrections
Section titled “struct PmfCorrections”Fields
| field | type | descriptor |
|---|---|---|
restraint_kj_mol |
f64 |
|
jacobian_kj_mol |
f64 |
|
finite_box_kj_mol |
f64 |
|
standard_state_kj_mol |
f64 |
struct PmfResult
Section titled “struct PmfResult”Fields
| field | type | descriptor |
|---|---|---|
raw_delta_g_kj_mol |
f64 |
|
corrected_delta_g_kj_mol |
f64 |
|
corrections |
PmfCorrections |
|
window_overlap_min |
f64 |
|
effective_sample_size |
f64 |
|
replicas |
int |
|
converged |
bool |
|
validated |
bool |
def basin_populations
Section titled “def basin_populations”def basin_populations(phi_values: list[f64], psi_values: list[f64]) -> BasinPopulations !{}Parameters
| name | type |
|---|---|
phi_values |
list[f64] |
psi_values |
list[f64] |
Returns BasinPopulations
Effects !{}
def compare_populations
Section titled “def compare_populations”def compare_populations(fine: BasinPopulations, coarse: BasinPopulations, threshold: f64) -> DistributionComparison !{}Parameters
| name | type |
|---|---|
fine |
BasinPopulations |
coarse |
BasinPopulations |
threshold |
f64 |
Returns DistributionComparison
Effects !{}
def sample_mean
Section titled “def sample_mean”def sample_mean(values: list[f64])Parameters
| name | type |
|---|---|
values |
list[f64] |
def sample_variance
Section titled “def sample_variance”def sample_variance(values: list[f64], average: f64)Parameters
| name | type |
|---|---|
values |
list[f64] |
average |
f64 |
def lag1_autocorrelation
Section titled “def lag1_autocorrelation”def lag1_autocorrelation(values: list[f64], average: f64, variance: f64)Parameters
| name | type |
|---|---|
values |
list[f64] |
average |
f64 |
variance |
f64 |
def effective_sample_size
Section titled “def effective_sample_size”def effective_sample_size(samples: int, autocorrelation: f64)Parameters
| name | type |
|---|---|
samples |
int |
autocorrelation |
f64 |
def diagnose_ensemble
Section titled “def diagnose_ensemble”def diagnose_ensemble(values: list[f64], replicas: int, minimum_effective_samples: f64) -> EnsembleDiagnostics !{}Parameters
| name | type |
|---|---|
values |
list[f64] |
replicas |
int |
minimum_effective_samples |
f64 |
Returns EnsembleDiagnostics
Effects !{}
def probability_free_energy
Section titled “def probability_free_energy”def probability_free_energy(probability: f64, temperature_k: f64)Parameters
| name | type |
|---|---|
probability |
f64 |
temperature_k |
f64 |
def corrected_pmf
Section titled “def corrected_pmf”def corrected_pmf(raw_delta_g_kj_mol: f64, corrections: PmfCorrections, window_overlap_min: f64, effective_samples: f64, replicas: int, converged: bool) -> PmfResult !{}Parameters
| name | type |
|---|---|
raw_delta_g_kj_mol |
f64 |
corrections |
PmfCorrections |
window_overlap_min |
f64 |
effective_samples |
f64 |
replicas |
int |
converged |
bool |
Returns PmfResult
Effects !{}
viewer
Section titled “viewer”Native scene verification, composition binding, and bounded viewer export.
struct ViewerSceneArtifact
Section titled “struct ViewerSceneArtifact”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
path |
str |
|
bytes |
int |
|
scene_sha256 |
str |
|
file_sha256 |
str |
|
source_result_sha256 |
str |
|
source_frames_sha256 |
str |
|
atoms |
int |
|
bonds |
int |
|
frames |
int |
|
volume_result_sha256 |
str |
|
volume_frames |
int |
|
cellular_voxels |
int |
|
tissue_voxels |
int |
|
scene_instances |
int |
|
protein_atoms |
int |
|
scenarios |
int |
def ala2_topology_bonds
Section titled “def ala2_topology_bonds”def ala2_topology_bonds()def parse_pinned_topology
Section titled “def parse_pinned_topology”def parse_pinned_topology(pdb_text: str) !{}Parameters
| name | type |
|---|---|
pdb_text |
str |
Effects !{}
def atom_style
Section titled “def atom_style”def atom_style(element: str)Parameters
| name | type |
|---|---|
element |
str |
def decorate_topology
Section titled “def decorate_topology”def decorate_topology(raw: dict[str, any])Parameters
| name | type |
|---|---|
raw |
dict[str, any] |
def load_frames
Section titled “def load_frames”def load_frames(source: dict[str, any]) !{fs.read}Parameters
| name | type |
|---|---|
source |
dict[str, any] |
Effects !{fs.read}
def measurement_sources
Section titled “def measurement_sources”def measurement_sources()def composition_profiles
Section titled “def composition_profiles”def composition_profiles()def prepare_viewer
Section titled “def prepare_viewer”def prepare_viewer() -> ViewerSceneArtifact !{ffi.call, fs.read, fs.write}Returns ViewerSceneArtifact
Effects !{ffi.call, fs.read, fs.write}
visualization
Section titled “visualization”Non-authoritative multiscale visual bindings and live equation-frame contracts.
enum FidelityClass
Section titled “enum FidelityClass”Variants
canonicalderivedinterpolatedillustrativeunknown
enum VisualScale
Section titled “enum VisualScale”Variants
field_quantumatomicmolecularcellulartissue
enum GeometryOrigin
Section titled “enum GeometryOrigin”Variants
measuredsimulatedreconstructedillustrativeunknown
enum EquationUpdateKind
Section titled “enum EquationUpdateKind”Variants
state_stepparameter_transitionstructural_transition
struct EntityFocusPath
Section titled “struct EntityFocusPath”Fields
| field | type | descriptor |
|---|---|---|
path_id |
str |
|
entity_ids |
list[str] |
|
selected_depth |
int |
struct ComplexityScenario
Section titled “struct ComplexityScenario”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
glucose_millimolar |
f64 |
|
oxygen_fraction |
f64 |
|
cytokine_fraction |
f64 |
|
insulin_demand_fraction |
f64 |
|
illustrative |
bool |
enum BiologicalEditKind
Section titled “enum BiologicalEditKind”Variants
signalmorphologymotilitythermalbond_strengthbond_formbond_breakreset
enum BiologicalEditTarget
Section titled “enum BiologicalEditTarget”Variants
allbeta_cellalpha_celldelta_cellacinar_celladipocyteimmune_cellvesselgranulemitochondrionreceptorprotein
struct BiologicalEditOperation
Section titled “struct BiologicalEditOperation”Fields
| field | type | descriptor |
|---|---|---|
kind |
BiologicalEditKind |
|
target |
BiologicalEditTarget |
|
scalar |
f64 |
|
atom_index_a |
int |
|
atom_index_b |
int |
|
compiled_equation |
str |
struct BiologicalEditPlan
Section titled “struct BiologicalEditPlan”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
request_id |
str |
|
natural_language |
str |
|
compiler_id |
str |
|
source_state_version |
int |
|
operations |
list[BiologicalEditOperation] |
struct BiologicalEditBudget
Section titled “struct BiologicalEditBudget”Fields
| field | type | descriptor |
|---|---|---|
max_operations |
int |
|
max_structural_edits |
int |
|
atom_count |
int |
|
max_visible_instances |
int |
|
candidate_visible_instances |
int |
struct BiologicalEditDecision
Section titled “struct BiologicalEditDecision”Fields
| field | type | descriptor |
|---|---|---|
request_id |
str |
|
admissible |
bool |
|
live_computed |
bool |
|
scientific_fidelity |
FidelityClass |
|
accepted_operations |
int |
|
reason |
str |
def biological_edit_operation_valid
Section titled “def biological_edit_operation_valid”def biological_edit_operation_valid(operation: BiologicalEditOperation, atom_count: int)Parameters
| name | type |
|---|---|
operation |
BiologicalEditOperation |
atom_count |
int |
def admit_biological_edit
Section titled “def admit_biological_edit”def admit_biological_edit(plan: BiologicalEditPlan, budget: BiologicalEditBudget)Parameters
| name | type |
|---|---|
plan |
BiologicalEditPlan |
budget |
BiologicalEditBudget |
struct FieldOfViewBudget
Section titled “struct FieldOfViewBudget”Fields
| field | type | descriptor |
|---|---|---|
field_of_view_m |
f64 |
|
candidate_instances |
int |
|
required_upload_bytes |
int |
|
desired_update_hz |
int |
|
max_visible_instances |
int |
|
max_upload_bytes |
int |
|
max_update_hz |
int |
struct MultiscaleComputeDecision
Section titled “struct MultiscaleComputeDecision”Fields
| field | type | descriptor |
|---|---|---|
scale |
VisualScale |
|
field_of_view_m |
f64 |
|
visible_instances |
int |
|
update_hz |
int |
|
admissible |
bool |
|
reason |
str |
def visual_scale_for_field
Section titled “def visual_scale_for_field”def visual_scale_for_field(field_of_view_m: f64)Parameters
| name | type |
|---|---|
field_of_view_m |
f64 |
def decide_multiscale_compute
Section titled “def decide_multiscale_compute”def decide_multiscale_compute(budget: FieldOfViewBudget) -> MultiscaleComputeDecision !{}Parameters
| name | type |
|---|---|
budget |
FieldOfViewBudget |
Returns MultiscaleComputeDecision
Effects !{}
def focus_path_valid
Section titled “def focus_path_valid”def focus_path_valid(path: EntityFocusPath) -> bool !{}Parameters
| name | type |
|---|---|
path |
EntityFocusPath |
Returns bool
Effects !{}
struct EquationTermSample
Section titled “struct EquationTermSample”Fields
| field | type | descriptor |
|---|---|---|
term_id |
str |
|
symbol |
str |
|
value |
f64 |
|
unit_symbol |
str |
|
owner_model_id |
str |
struct EquationStateSample
Section titled “struct EquationStateSample”Fields
| field | type | descriptor |
|---|---|---|
entity_id |
str |
|
model_id |
str |
|
model_version |
int |
|
equation_id |
str |
|
equation_version |
int |
|
parameter_version |
int |
|
update_kind |
EquationUpdateKind |
|
terms |
list[EquationTermSample] |
|
residuals |
list[EquationTermSample] |
|
active_constraints |
list[str] |
|
transition_id |
str |
|
cause |
str |
struct VisualPrimitiveBinding
Section titled “struct VisualPrimitiveBinding”Fields
| field | type | descriptor |
|---|---|---|
primitive_id |
str |
|
entity_id |
str |
|
observation_id |
str |
|
source_state_version |
int |
|
scale |
VisualScale |
|
fidelity |
FidelityClass |
|
origin |
GeometryOrigin |
|
source_algorithm |
str |
|
source_parameters |
list[str] |
struct VisualObservationEnvelope
Section titled “struct VisualObservationEnvelope”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
scenario_id |
str |
|
run_id |
str |
|
observation_id |
str |
|
physical_time_s |
f64 |
|
scheduler_tick |
int |
|
state_version |
int |
|
resolution_version |
int |
|
model_version |
int |
|
equation_version |
int |
|
parameter_version |
int |
|
source_frame_age_ms |
f64 |
|
bindings |
list[VisualPrimitiveBinding] |
|
equation_states |
list[EquationStateSample] |
|
dropped_frames |
int |
|
interpolation_ratio |
f64 |
def distinct_binding_ids
Section titled “def distinct_binding_ids”def distinct_binding_ids(bindings: list[VisualPrimitiveBinding])Parameters
| name | type |
|---|---|
bindings |
list[VisualPrimitiveBinding] |
def equations_cover_canonical_bindings
Section titled “def equations_cover_canonical_bindings”def equations_cover_canonical_bindings(bindings: list[VisualPrimitiveBinding], equations: list[EquationStateSample])Parameters
| name | type |
|---|---|
bindings |
list[VisualPrimitiveBinding] |
equations |
list[EquationStateSample] |
def validate_visual_observation
Section titled “def validate_visual_observation”def validate_visual_observation(frame: VisualObservationEnvelope) -> bool !{}Parameters
| name | type |
|---|---|
frame |
VisualObservationEnvelope |
Returns bool
Effects !{}
def unknown_binding
Section titled “def unknown_binding”def unknown_binding(primitive_id: str, entity_id: str, observation_id: str, state_version: int, scale: VisualScale, reason: str)Parameters
| name | type |
|---|---|
primitive_id |
str |
entity_id |
str |
observation_id |
str |
state_version |
int |
scale |
VisualScale |
reason |
str |
enum VisualRepresentation
Section titled “enum VisualRepresentation”Variants
particlestopology_bondsoccupancy_envelopescalar_volumesegmented_volumeinstanced_cellsinstanced_organellesinstanced_vesselsinstanced_proteins
struct SemanticScaleSource
Section titled “struct SemanticScaleSource”Fields
| field | type | descriptor |
|---|---|---|
source_id |
str |
|
scale |
VisualScale |
|
minimum_length_m |
f64 |
|
maximum_length_m |
f64 |
|
available |
bool |
|
fidelity |
FidelityClass |
|
origin |
GeometryOrigin |
|
observation_id |
str |
|
representation_ids |
list[VisualRepresentation] |
|
source_algorithm |
str |
struct ScaleDetailBinding
Section titled “struct ScaleDetailBinding”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
parent_scale |
VisualScale |
|
parent_selector |
str |
|
child_scale |
VisualScale |
|
child_model_id |
str |
|
default_child_kind |
str |
|
default_child_index |
int |
|
binding |
str |
|
fidelity |
FidelityClass |
|
evidence_ids |
list[str] |
struct MultiscaleCouplingEdge
Section titled “struct MultiscaleCouplingEdge”Fields
| field | type | descriptor |
|---|---|---|
id |
str |
|
source_scale |
VisualScale |
|
target_scale |
VisualScale |
|
source_observable |
str |
|
target_observable |
str |
|
coupling_expression |
str |
|
unit_symbol |
str |
|
maximum_error |
f64 |
|
evidence_ids |
list[str] |
|
validated |
bool |
def detail_refinement_admissible
Section titled “def detail_refinement_admissible”def detail_refinement_admissible(binding: ScaleDetailBinding, parent_entity_id: str)Parameters
| name | type |
|---|---|
binding |
ScaleDetailBinding |
parent_entity_id |
str |
def coupling_claim_admissible
Section titled “def coupling_claim_admissible”def coupling_claim_admissible(edge: MultiscaleCouplingEdge)Parameters
| name | type |
|---|---|
edge |
MultiscaleCouplingEdge |
struct ViewportQuery
Section titled “struct ViewportQuery”Fields
| field | type | descriptor |
|---|---|---|
query_id |
str |
|
requested_scale |
VisualScale |
|
field_of_view_m |
f64 |
|
observation_id |
str |
|
state_version |
int |
|
resolution_version |
int |
struct SemanticZoomDecision
Section titled “struct SemanticZoomDecision”Fields
| field | type | descriptor |
|---|---|---|
query_id |
str |
|
requested_scale |
VisualScale |
|
rendered_scale |
VisualScale |
|
renderable |
bool |
|
fidelity |
FidelityClass |
|
origin |
GeometryOrigin |
|
source_id |
str |
|
source_observation_id |
str |
|
representation_ids |
list[VisualRepresentation] |
|
reason |
str |
def decide_semantic_zoom
Section titled “def decide_semantic_zoom”def decide_semantic_zoom(query: ViewportQuery, sources: list[SemanticScaleSource]) -> SemanticZoomDecision !{}Parameters
| name | type |
|---|---|
query |
ViewportQuery |
sources |
list[SemanticScaleSource] |
Returns SemanticZoomDecision
Effects !{}
volume
Section titled “volume”Versioned cellular and tissue segment-volume frames for bounded live replay.
struct BiologicalVolumeResult
Section titled “struct BiologicalVolumeResult”Fields
| field | type | descriptor |
|---|---|---|
schema |
str |
|
profile_id |
str |
|
config_sha256 |
str |
|
source_result_sha256 |
str |
|
result_sha256 |
str |
|
result_path |
str |
|
frames |
int |
|
frame_interval_s |
f64 |
|
cellular_voxels |
int |
|
tissue_voxels |
int |
|
cellular_segments |
int |
|
tissue_segments |
int |
|
scene_instances |
int |
|
insulin_atoms |
int |
|
scenario_count |
int |
|
volume_payload_bytes |
int |
|
deterministic_pass |
bool |
|
source_binding_pass |
bool |
|
phase10_technical_pass |
bool |
|
scientific_validated |
bool |
|
evidence_class |
str |
bridge volume_backend
Section titled “bridge volume_backend”def run_volume_profile
Section titled “def run_volume_profile”def run_volume_profile(config_path: str, output_path: str) -> BiologicalVolumeResult !{ffi.call, fs.read, fs.write}Parameters
| name | type |
|---|---|
config_path |
str |
output_path |
str |
Returns BiologicalVolumeResult
Effects !{ffi.call, fs.read, fs.write}