eml-stdlib 0.4.0__py3-none-any.whl

eml_stdlib/biology/abilities/ballistic_armor.eml

@@ -0,0 +1,61 @@
+// ballistic_armor.eml -- armadillo plate / ballistic vest absorption.
+//
+// Kinetic energy delivered by a bullet:
+//   E_k = ½ * m * v²
+//
+// Armour absorbs a fraction of that energy; remaining energy
+// causes wound damage. Chain order 0.
+
+module ballistic_armor;
+
+@verify(lean, theorem = "kinetic_energy_nonneg")
+fn kinetic_energy(mass_kg: Real, velocity_mps: Real) -> Real
+    where chain_order <= 0,
+          domain: mass_kg >= 0.0
+    ensures (result >= 0.0)
+{
+    0.5 * mass_kg * velocity_mps * velocity_mps
+}
+
+// Energy absorbed by armor with given absorption coefficient
+// (dimensionless, [0,1]).
+@verify(lean, theorem = "armor_absorbed_in_band")
+fn energy_absorbed(mass_kg: Real, velocity_mps: Real,
+                   absorption_coeff: Real) -> Real
+    where chain_order <= 0,
+          domain: mass_kg >= 0.0
+    requires (absorption_coeff >= 0.0)
+    requires (absorption_coeff <= 1.0)
+    ensures (result >= 0.0)
+{
+    let e_k: Real = 0.5 * mass_kg * velocity_mps * velocity_mps;
+    e_k * absorption_coeff
+}
+
+// Energy that penetrates (delivered to flesh).
+@verify(lean, theorem = "armor_penetrating_energy_nonneg")
+fn energy_penetrating(mass_kg: Real, velocity_mps: Real,
+                      absorption_coeff: Real) -> Real
+    where chain_order <= 0,
+          domain: mass_kg >= 0.0
+    requires (absorption_coeff >= 0.0)
+    requires (absorption_coeff <= 1.0)
+    ensures (result >= 0.0)
+{
+    let e_k: Real = 0.5 * mass_kg * velocity_mps * velocity_mps;
+    e_k * (1.0 - absorption_coeff)
+}
+
+// Ricochet probability rises sharply for shallow impact angles.
+// θ_impact = angle between bullet velocity and surface normal.
+//   p_ricochet = 1 - cos(θ_impact)^2   for θ in (0, π/2)
+@verify(lean, theorem = "ricochet_probability_in_unit_interval")
+fn ricochet_probability(angle_rad: Real) -> Real
+    where chain_order <= 1,
+          domain: angle_rad >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let c: Real = clamp(cos(angle_rad), 0.0, 1.0);
+    1.0 - c * c
+}

eml_stdlib/biology/abilities/bite_force.eml

@@ -0,0 +1,48 @@
+// bite_force.eml -- jaw-power scaling for the beast's stage attacks.
+//
+// Bite force at the canines:
+//
+//   F_bite = k * BSL² * cos(θ_jaw)
+//
+// where BSL is the body's bite-strength linear factor (proxy for
+// mass-and-jaw-leverage compound) and θ_jaw the jaw opening angle.
+// Chain order 1 (cos). Used to compute how many points of damage
+// the beast deals per stage.
+
+module bite_force;
+
+@verify(lean, theorem = "bite_force_nonneg")
+fn bite_force_n(k: Real, bsl: Real, jaw_angle_rad: Real) -> Real
+    where chain_order <= 1,
+          domain: k >= 0.0 && bsl >= 0.0
+    ensures (result >= 0.0)
+{
+    let c: Real = clamp(cos(jaw_angle_rad), 0.0, 1.0);
+    k * bsl * bsl * c
+}
+
+// Damage delivered per bite, scaling with bite force and a wound
+// constant (HP per Newton, calibrated to game balance).
+@verify(lean, theorem = "bite_damage_nonneg")
+fn damage_per_bite(bite_force_n_in: Real, wound_constant: Real) -> Real
+    where chain_order <= 0,
+          domain: bite_force_n_in >= 0.0 && wound_constant >= 0.0
+    ensures (result >= 0.0)
+{
+    bite_force_n_in * wound_constant
+}
+
+// Stage-multiplier for the beast's bite, callable from beast_combat.
+//   stage 0 (hands):  0.10
+//   stage 1 (claws):  0.30
+//   stage 2 (bite):   0.60
+//   stage 3 (lunge):  0.80
+@verify(lean, theorem = "bite_stage_multiplier_nondecreasing")
+fn stage_multiplier(stage: Real) -> Real
+    where chain_order <= 0,
+          domain: stage >= 0.0
+    ensures (result >= 0.0)
+{
+    let s_clamped: Real = clamp(stage, 0.0, 3.0);
+    0.10 + 0.235 * s_clamped + 0.0166 * s_clamped * s_clamped
+}

eml_stdlib/biology/abilities/chromatophore.eml

@@ -0,0 +1,50 @@
+// chromatophore.eml -- gecko / cephalopod camouflage via Bragg reflection.
+//
+// Iridophore stacks reflect a band of wavelengths centred on:
+//
+//   λ = 2 * n * d * cos(θ)
+//
+// where n is refractive index, d the lamellar spacing, θ the
+// viewing angle. The chromatophore can dilate/contract d so the
+// reflected band shifts. Chain order 1 (cos).
+
+module chromatophore;
+
+@verify(lean, theorem = "bragg_wavelength_nonneg")
+fn bragg_wavelength(refractive_index: Real, spacing_nm: Real,
+                     angle_rad: Real) -> Real
+    where chain_order <= 1,
+          domain: refractive_index > 0.0 && spacing_nm > 0.0
+    ensures (result >= 0.0)
+{
+    let cos_t: Real = clamp(cos(angle_rad), 0.0, 1.0);
+    2.0 * refractive_index * spacing_nm * cos_t
+}
+
+// Camouflage transparency [0, 1] as a function of motion.
+// Stationary subject: full Bragg-tuned camouflage.
+// Moving subject: temporal mismatch leaks the silhouette.
+//   transparency = max_t * exp(-velocity / tau)
+@verify(lean, theorem = "camo_transparency_in_unit_interval")
+fn transparency(max_t: Real, velocity_mps: Real, tau_mps: Real) -> Real
+    where chain_order <= 1,
+          domain: max_t >= 0.0 && max_t <= 1.0 && tau_mps > 0.0
+    requires (velocity_mps >= 0.0)
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    max_t * exp(-velocity_mps / tau_mps)
+}
+
+// Detection contrast against the background at distance r.
+// contrast(r, transparency) = (1 - transparency) * base_contrast / r²
+@verify(lean, theorem = "camo_contrast_drops_with_distance")
+fn detection_contrast(transparency: Real, base_contrast: Real, r_m: Real) -> Real
+    where chain_order <= 0,
+          domain: r_m > 0.0 && base_contrast >= 0.0
+    requires (transparency >= 0.0)
+    requires (transparency <= 1.0)
+    ensures (result >= 0.0)
+{
+    (1.0 - transparency) * base_contrast / (r_m * r_m)
+}

eml_stdlib/biology/abilities/discharge.eml

@@ -0,0 +1,45 @@
+// discharge.eml -- electric eel discharge waveform.
+//
+// Eel pulse voltage:
+//
+//   V(t) = V_peak * exp(-t / τ)
+//
+// where V_peak ≈ 860 V and τ ≈ 2 ms. Chain order 1.
+//
+// Used by the eel ability to compute EMP duration on hunter
+// instruments and stun damage on the beast.
+
+module discharge;
+
+const V_PEAK_DEFAULT: Real = 860.0     // Volts
+const TAU_DEFAULT:    Real = 0.002     // seconds
+
+@verify(lean, theorem = "discharge_voltage_nonneg")
+fn voltage(v_peak: Real, tau_s: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: v_peak >= 0.0 && tau_s > 0.0 && t_s >= 0.0
+    ensures (result >= 0.0)
+{
+    v_peak * exp(-t_s / tau_s)
+}
+
+// Default-parameters convenience.
+@verify(lean, theorem = "discharge_default_voltage_nonneg")
+fn voltage_default(t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: t_s >= 0.0
+    ensures (result >= 0.0)
+{
+    V_PEAK_DEFAULT * exp(-t_s / TAU_DEFAULT)
+}
+
+// Energy delivered per pulse (J), assuming constant body resistance.
+//   E = V_peak² * τ / (2 * R)
+@verify(lean, theorem = "discharge_energy_nonneg")
+fn pulse_energy(v_peak: Real, tau_s: Real, body_ohm: Real) -> Real
+    where chain_order <= 0,
+          domain: v_peak >= 0.0 && tau_s >= 0.0 && body_ohm > 0.0
+    ensures (result >= 0.0)
+{
+    v_peak * v_peak * tau_s / (2.0 * body_ohm)
+}

eml_stdlib/biology/abilities/elastic_energy.eml

@@ -0,0 +1,42 @@
+// elastic_energy.eml -- flea-style elastic-jump physics.
+//
+// A flea stores energy in its resilin pad, then releases it
+// instantaneously. Take-off velocity is governed by:
+//
+//   v = sqrt(2 * E / m)
+//
+// where E is stored elastic energy (J) and m the body mass (kg).
+// Chain order 1 (sqrt). Used by the beast jump ability.
+
+module elastic_energy;
+
+@verify(lean, theorem = "elastic_takeoff_velocity_nonneg")
+fn takeoff_velocity(elastic_energy_j: Real, mass_kg: Real) -> Real
+    where chain_order <= 1,
+          domain: elastic_energy_j >= 0.0 && mass_kg > 0.0
+    ensures (result >= 0.0)
+{
+    sqrt(2.0 * elastic_energy_j / mass_kg)
+}
+
+// Maximum jump height assuming straight-up release, no drag.
+//   h = v² / (2g)
+@verify(lean, theorem = "elastic_jump_height_nonneg")
+fn jump_height(elastic_energy_j: Real, mass_kg: Real, g: Real) -> Real
+    where chain_order <= 0,
+          domain: elastic_energy_j >= 0.0 && mass_kg > 0.0 && g > 0.0
+    ensures (result >= 0.0)
+{
+    elastic_energy_j / (mass_kg * g)
+}
+
+// Range of a 45° elastic launch (no drag, level ground).
+//   R = v² / g
+@verify(lean, theorem = "elastic_jump_range_nonneg")
+fn jump_range(elastic_energy_j: Real, mass_kg: Real, g: Real) -> Real
+    where chain_order <= 0,
+          domain: elastic_energy_j >= 0.0 && mass_kg > 0.0 && g > 0.0
+    ensures (result >= 0.0)
+{
+    2.0 * elastic_energy_j / (mass_kg * g)
+}

eml_stdlib/biology/abilities/locomotion.eml

@@ -0,0 +1,50 @@
+// locomotion.eml -- many-legged speed bonus model (centipede).
+//
+// Stride frequency f * stride length L = ground-speed v.
+// More legs in phase → higher achievable f at the same metabolic
+// cost. Linear surrogate:
+//
+//   v(n_legs) = v_base * (1 + α * (n_legs - 2))
+//
+// with α = 0.10 per pair beyond the bipedal baseline; chain 0.
+
+module locomotion;
+
+const ALPHA_PER_LEG_PAIR: Real = 0.10
+const N_LEGS_BASELINE:    Real = 2.0   // bipedal human reference
+
+@verify(lean, theorem = "locomotion_speed_grows_with_legs")
+fn ground_speed(v_base: Real, n_legs: Real) -> Real
+    where chain_order <= 0,
+          domain: v_base >= 0.0 && n_legs >= 0.0
+    ensures (result >= 0.0)
+{
+    let extra_pairs: Real = clamp((n_legs - N_LEGS_BASELINE) * 0.5, 0.0, 100.0);
+    v_base * (1.0 + ALPHA_PER_LEG_PAIR * extra_pairs)
+}
+
+// Same expressed as a multiplier on the base speed.
+@verify(lean, theorem = "locomotion_multiplier_geq_one")
+fn speed_multiplier(n_legs: Real) -> Real
+    where chain_order <= 0,
+          domain: n_legs >= 0.0
+    ensures (result >= 1.0)
+{
+    let extra_pairs: Real = clamp((n_legs - N_LEGS_BASELINE) * 0.5, 0.0, 100.0);
+    1.0 + ALPHA_PER_LEG_PAIR * extra_pairs
+}
+
+// Wall-climbing toggle threshold: enough legs and enough adhesion to
+// support body weight against gravity. Returns 1.0 if climbing is
+// possible, 0.0 otherwise (for clamp-style boolean dispatch).
+@verify(lean, theorem = "wall_climb_threshold_in_zero_one")
+fn wall_climb_capable(n_legs: Real, adhesion_n_per_leg: Real,
+                       body_weight_n: Real) -> Real
+    where chain_order <= 0,
+          domain: n_legs >= 0.0 && adhesion_n_per_leg >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let total_grip: Real = n_legs * adhesion_n_per_leg;
+    clamp((total_grip - body_weight_n) * 1.0e6, 0.0, 1.0)
+}

eml_stdlib/biology/abilities/muscle_power.eml

@@ -0,0 +1,47 @@
+// muscle_power.eml -- striated-muscle power-to-mass scaling.
+//
+// Peak power per kg of muscle ~ 250 W/kg in mammals. Power-to-weight
+// scales linearly with mass-fraction of muscle:
+//
+//   P_total = P_per_kg * mass_kg * muscle_fraction
+//
+// Chain order 0. Used by beast stage thresholds (each consumed
+// animal adds a small muscle-mass contribution).
+
+module muscle_power;
+
+const P_PER_KG: Real = 250.0   // W/kg, peak skeletal muscle
+
+@verify(lean, theorem = "muscle_power_nonneg")
+fn total_power(mass_kg: Real, muscle_fraction: Real) -> Real
+    where chain_order <= 0,
+          domain: mass_kg >= 0.0
+    requires (muscle_fraction >= 0.0)
+    requires (muscle_fraction <= 1.0)
+    ensures (result >= 0.0)
+{
+    P_PER_KG * mass_kg * muscle_fraction
+}
+
+// Power-to-weight ratio (W/kg total body).
+@verify(lean, theorem = "muscle_power_to_weight_nonneg")
+fn power_to_weight(muscle_fraction: Real) -> Real
+    where chain_order <= 0
+    requires (muscle_fraction >= 0.0)
+    requires (muscle_fraction <= 1.0)
+    ensures (result >= 0.0)
+{
+    P_PER_KG * muscle_fraction
+}
+
+// Top-speed proxy: P-to-W against drag = constant gives v ∝ ∛P.
+@verify(lean, theorem = "muscle_topspeed_proxy_nonneg")
+fn top_speed_proxy(muscle_fraction: Real, k_drag_inv_cube: Real) -> Real
+    where chain_order <= 1,
+          domain: k_drag_inv_cube >= 0.0
+    requires (muscle_fraction >= 0.0)
+    requires (muscle_fraction <= 1.0)
+    ensures (result >= 0.0)
+{
+    pow(P_PER_KG * muscle_fraction * k_drag_inv_cube, 0.333333)
+}

eml_stdlib/biology/abilities/sprint.eml

@@ -0,0 +1,36 @@
+// sprint.eml -- cheetah-style burst-acceleration model.
+//
+//   v(t) = v_max * (1 - exp(-t / τ))
+//
+// Asymptotic approach to peak speed; cheetahs hit ~95% of peak in
+// ~3 s. Chain order 1.
+
+module sprint;
+
+const V_MAX_CHEETAH:  Real = 33.3   // m/s (~120 km/h)
+const TAU_CHEETAH:    Real = 1.2    // seconds, time constant
+
+@verify(lean, theorem = "sprint_velocity_in_band")
+fn velocity(v_max: Real, tau_s: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: v_max >= 0.0 && tau_s > 0.0 && t_s >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= v_max)
+{
+    v_max * (1.0 - exp(-t_s / tau_s))
+}
+
+// Distance covered from cold start at time t.
+//   x(t) = v_max * (t - τ * (1 - exp(-t/τ)))
+@verify(lean, theorem = "sprint_distance_nonneg")
+fn distance_covered(v_max: Real, tau_s: Real, t_s: Real) -> Real
+    where chain_order <= 1,
+          domain: v_max >= 0.0 && tau_s > 0.0 && t_s >= 0.0
+    ensures (result >= 0.0)
+{
+    v_max * (t_s - tau_s * (1.0 - exp(-t_s / tau_s)))
+}
+
+// Burst duration before fatigue kicks in (cheetah ≈ 30 s).
+const BURST_LIMIT_S:   Real = 30.0
+const COOLDOWN_S:      Real = 30.0

eml_stdlib/biology/abilities/texture_match.eml

@@ -0,0 +1,49 @@
+// texture_match.eml -- octopus chromatic + textural skin matching.
+//
+// Per-pixel match score between the cephalopod's skin
+// and the surrounding background, integrated over a small patch:
+//
+//   match(p) = 1 - sqrt( ( ΔL² + Δa² + Δb² ) / S_max² )
+//
+// where (L, a, b) are perceptual colour coordinates and S_max
+// the worst-case distance. Output ∈ [0, 1].
+
+module texture_match;
+
+const S_MAX: Real = 256.0   // perceptual distance for 8-bit Lab range
+
+@verify(lean, theorem = "texture_match_in_unit_interval")
+fn match_score(d_l: Real, d_a: Real, d_b: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    let dist: Real = sqrt(d_l * d_l + d_a * d_a + d_b * d_b);
+    clamp(1.0 - dist / S_MAX, 0.0, 1.0)
+}
+
+// Detection probability at distance r given a match score.
+//   p_detect = (1 - match) * (1 / r²) * detector_sensitivity
+@verify(lean, theorem = "texture_detect_in_unit_interval")
+fn detection_probability(match_score: Real, r_m: Real,
+                          detector_sensitivity: Real) -> Real
+    where chain_order <= 0,
+          domain: r_m > 0.0 && detector_sensitivity >= 0.0
+    requires (match_score >= 0.0)
+    requires (match_score <= 1.0)
+    ensures (result >= 0.0)
+{
+    (1.0 - match_score) * detector_sensitivity / (r_m * r_m)
+}
+
+// Ink-cloud blinding decay: visibility recovers exponentially.
+//   visibility(t) = 1 - exp(-t / τ)
+@verify(lean, theorem = "ink_recovery_in_unit_interval")
+fn ink_visibility(t_s: Real, tau_s: Real) -> Real
+    where chain_order <= 1,
+          domain: t_s >= 0.0 && tau_s > 0.0
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    1.0 - exp(-t_s / tau_s)
+}

eml_stdlib/biology/abilities/toxin.eml

@@ -0,0 +1,44 @@
+// toxin.eml -- viper-bite damage-over-time model.
+//
+// Toxin concentration in the bloodstream follows first-order
+// exponential clearance:
+//
+//   C(t) = C_0 * exp(-k * t)
+//
+// Damage rate is proportional to concentration above the LD50
+// threshold; integral over the wound's active window yields total
+// damage. Chain order 1.
+
+module toxin;
+
+@verify(lean, theorem = "toxin_concentration_nonneg")
+fn concentration(dose: Real, k_clearance: Real, t_seconds: Real) -> Real
+    where chain_order <= 1,
+          domain: dose >= 0.0 && k_clearance >= 0.0 && t_seconds >= 0.0
+    ensures (result >= 0.0)
+{
+    dose * exp(-k_clearance * t_seconds)
+}
+
+// Instantaneous damage rate (HP per second).
+@verify(lean, theorem = "toxin_damage_rate_nonneg")
+fn damage_rate(dose: Real, k_clearance: Real, t_seconds: Real,
+               toxicity: Real) -> Real
+    where chain_order <= 1,
+          domain: dose >= 0.0 && k_clearance >= 0.0 && t_seconds >= 0.0 && toxicity >= 0.0
+    ensures (result >= 0.0)
+{
+    toxicity * dose * exp(-k_clearance * t_seconds)
+}
+
+// Total damage integrated from t=0 to t=T.
+//   D = (toxicity * dose / k) * (1 - exp(-k*T))
+@verify(lean, theorem = "toxin_total_damage_nonneg")
+fn total_damage(dose: Real, k_clearance: Real, duration_s: Real,
+                toxicity: Real) -> Real
+    where chain_order <= 1,
+          domain: dose >= 0.0 && k_clearance > 0.0 && duration_s >= 0.0 && toxicity >= 0.0
+    ensures (result >= 0.0)
+{
+    (toxicity * dose / k_clearance) * (1.0 - exp(-k_clearance * duration_s))
+}

eml_stdlib/biology/cone_l.eml

@@ -0,0 +1,36 @@
+// cone_l.eml
+//
+// Feline long-wavelength (L, "green-yellow") cone spectral
+// sensitivity. This is the cone that *almost* sees red — its
+// peak at 554 nm is shifted ~10 nm shorter than the human L
+// cone's 564 nm peak, which is why a red ball looks olive-yellow
+// to a cat: the response in the deep-red region (>600 nm) tails
+// off much faster.
+//
+// Source: Loop et al. (1987) and the Govardovskii et al. (2000)
+// visual-pigment template. λ_peak = 554 nm. σ ≈ 50 nm (FWHM
+// ≈ 118 nm), reflecting the wider long-wavelength tail of L
+// cones — without this the model would render deep red as
+// absolute black instead of the dark olive cats actually see.
+//
+//     L(λ) = exp(-((λ - 554)² / (2 · 50²)))
+//
+// This file does NOT define a "red" / M-wavelength cone — cats
+// don't have one, and adding a third cone here would silently
+// turn the model into a trichromat. Postcondition keeps the
+// output bounded.
+
+module cone_l;
+
+const CONE_L_PEAK_NM:  Real = 554.0
+const CONE_L_SIGMA_NM: Real =  50.0
+
+@verify(lean, theorem = "cone_l_sensitivity_bounded_unit")
+fn cone_l_sensitivity(wavelength_nm: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    exp(-((wavelength_nm - CONE_L_PEAK_NM) * (wavelength_nm - CONE_L_PEAK_NM))
+         / (2.0 * CONE_L_SIGMA_NM * CONE_L_SIGMA_NM))
+}

eml_stdlib/biology/cone_s.eml

@@ -0,0 +1,32 @@
+// cone_s.eml
+//
+// Feline short-wavelength (S, "blue") cone spectral sensitivity.
+// Cats are dichromats — only S and L cones, no medium-wavelength
+// "red" cone. The S cone is the cleaner of the two; its peak at
+// 450 nm is well-isolated from the L cone at 554 nm.
+//
+// Source: Loop et al. (1987), "Cone receptor population in the
+// adult cat retina." Peak λ ≈ 450 nm, FWHM ≈ 70 nm → σ ≈ 30 nm
+// (the cone curve is narrower than the rod's because cone opsins
+// have tighter absorption profiles).
+//
+//     S(λ) = exp(-((λ - 450)² / (2 · 30²)))
+//
+// Postcondition pins the sensitivity to [0, 1]; values outside
+// would corrupt every downstream channel of the cat-vision
+// transform.
+
+module cone_s;
+
+const CONE_S_PEAK_NM:  Real = 450.0
+const CONE_S_SIGMA_NM: Real =  30.0
+
+@verify(lean, theorem = "cone_s_sensitivity_bounded_unit")
+fn cone_s_sensitivity(wavelength_nm: Real) -> Real
+    where chain_order <= 1
+    ensures (result >= 0.0)
+    ensures (result <= 1.0)
+{
+    exp(-((wavelength_nm - CONE_S_PEAK_NM) * (wavelength_nm - CONE_S_PEAK_NM))
+         / (2.0 * CONE_S_SIGMA_NM * CONE_S_SIGMA_NM))
+}

eml_stdlib/biology/cryptochrome.eml

@@ -0,0 +1,44 @@
+// cryptochrome.eml
+//
+// Cryptochrome radical-pair magnetoreception. Cryptochrome (CRY)
+// is a flavoprotein in the bird retina; absorbing a blue-light
+// photon excites a flavin/tryptophan radical pair whose singlet
+// vs. triplet recombination yield depends on the orientation of
+// the geomagnetic field relative to the molecular axis:
+//
+//     Φ(B, θ) = 1/3 + (2/15) · (γ · B · τ)² · (3·cos²(θ) - 1)
+//
+// θ is the angle between the field vector and the radical-pair
+// axis; γ is the gyromagnetic ratio (~28 GHz/T); τ is the
+// recombination lifetime (~µs). The term `3·cos²(θ) - 1` is the
+// signature P₂ Legendre polynomial — the same anisotropy
+// signature seen in NMR and EPR spectra. This is "quantum
+// biology" in the strict sense: the spin-coherence of the
+// radical pair has to outlast environmental decoherence to
+// transmit a usable signal (Hore & Mouritsen 2016).
+//
+// Postcondition: Φ ∈ [0, 1] — it's a quantum yield, a probability.
+
+module cryptochrome;
+
+const ONE_THIRD:   Real = 0.3333333333333333
+
+@verify(lean, theorem = "cryptochrome_yield_in_unit_interval")
+fn cryptochrome_yield(
+    field_strength_T: Real{b | b >= 0.0},
+    angle_rad:        Real,
+    coupling:         Real{c | c >= 0.0},
+) -> Real{r | 0.0 <= r && r <= 1.0}
+    where chain_order <= 1
+{
+    // (γ·B·τ)² is bundled into `coupling` for clean units; the
+    // model is qualitative, not quantitative, in this file (the
+    // exact pre-factor is a tuning parameter for a given CRY
+    // isoform). The clamp pins the postcondition.
+    clamp(
+        ONE_THIRD + (2.0 / 15.0) * coupling
+            * (3.0 * cos(angle_rad) * cos(angle_rad) - 1.0),
+        0.0,
+        1.0
+    )
+}

eml_stdlib/biology/geomagnetic_field.eml

@@ -0,0 +1,32 @@
+// geomagnetic_field.eml
+//
+// Earth's magnetic field magnitude as a function of geomagnetic
+// latitude. Modeled as a centered axial dipole — the leading-order
+// approximation that captures ~95 % of the surface field:
+//
+//     B(λ) = B_eq · √(1 + 3 · sin²(λ))
+//
+// B_eq ≈ 30 µT at the equator; the field is twice as strong
+// (~60 µT) at the poles where field lines converge. Pigeons
+// navigate using the *magnitude* component of this map for the
+// "map" sense and the inclination angle (separate file) for
+// "compass" — the famous Wiltschko (1972) bicomponent model.
+//
+// Postcondition: B > 0 everywhere on Earth's surface (the dipole
+// has no zeros). The Cryptochrome model downstream takes B as
+// an input and would divide-by-zero on a vanishing field.
+
+module geomagnetic_field;
+
+const B_EQUATORIAL_T: Real = 3.0e-5   // 30 µT — IGRF equatorial baseline
+
+@verify(lean, theorem = "geomagnetic_field_strictly_positive")
+fn geomagnetic_field(latitude_rad: Real)
+    -> Real{r | r >= B_EQUATORIAL_T}
+    where chain_order <= 1
+{
+    // sqrt(1 + 3·sin²) ≥ 1 ⇒ result ≥ B_eq. We use max() as the
+    // outer guard so the postcondition is one-line provable.
+    max(B_EQUATORIAL_T,
+        B_EQUATORIAL_T * sqrt(1.0 + 3.0 * sin(latitude_rad) * sin(latitude_rad)))
+}

eml_stdlib/biology/goldman_equation.eml

@@ -0,0 +1,41 @@
+// goldman_equation.eml -- Goldman-Hodgkin-Katz voltage equation.
+//
+// Resting membrane potential when multiple ions cross a permeable
+// membrane:
+//
+//   V_m = (RT / F) * ln( (P_K[K+]_o + P_Na[Na+]_o + P_Cl[Cl-]_i)
+//                       / (P_K[K+]_i + P_Na[Na+]_i + P_Cl[Cl-]_o) )
+//
+// The single-ion limit collapses to the Nernst equation. Chain
+// order 1.
+
+module goldman_equation;
+
+const R_GAS:  Real = 8.314462618   // J / (mol K)
+const F_FAR:  Real = 96485.33212   // C / mol
+
+// Three-ion form (K+, Na+, Cl-) at body temperature.
+@verify(lean, theorem = "goldman_voltage_sign_matches_log_argument")
+fn membrane_potential(t_kelvin: Real,
+                      p_k:  Real, k_out:  Real, k_in:  Real,
+                      p_na: Real, na_out: Real, na_in: Real,
+                      p_cl: Real, cl_out: Real, cl_in: Real) -> Real
+    where chain_order <= 1,
+          domain: t_kelvin > 0.0
+{
+    let num = p_k * k_out + p_na * na_out + p_cl * cl_in;
+    let den = p_k * k_in  + p_na * na_in  + p_cl * cl_out;
+    (R_GAS * t_kelvin / F_FAR) * ln(num / den)
+}
+
+// Nernst equation: single-ion limit.
+@verify(lean, theorem = "nernst_voltage_sign_matches_concentration_ratio")
+fn nernst(t_kelvin: Real, valence: Real, c_out: Real, c_in: Real) -> Real
+    where chain_order <= 1,
+          domain: t_kelvin > 0.0 && valence != 0.0 && c_in > 0.0
+{
+    (R_GAS * t_kelvin / (valence * F_FAR)) * ln(c_out / c_in)
+}
+
+// Body-temperature pre-factor RT/F at 37 deg C, in mV.
+const RT_OVER_F_BODY_MV: Real = 26.7148