diff --git a/experiments/universality/amplitude_process_controls.py b/experiments/universality/amplitude_process_controls.py new file mode 100644 index 000000000..0961070d7 --- /dev/null +++ b/experiments/universality/amplitude_process_controls.py @@ -0,0 +1,137 @@ +"""Exact finite-barcode dependence control; reference answers are exposed. + +The fixed amplitude A=2*U**3, with density 2*u for U in (0,1), has +P(A<=x)=min((x/2)**(2/3),1). Its second moment is one. A shared A +scales a complete barcode; independent per-bar amplitudes instead define +an ABSTRACT barcode surrogate with no established underlying field law +or covariance realization. All lifetimes are supplied positive finite +bars, in the same units as the inclusive threshold; essential bars are +excluded by the input contract. + +This uses the finite scaling/count identity in main#334, Sections 2-3/6: +https://github.com/d6g8k5htny-coder/main/blob/ +6bd133d591e43e75a9292463bb4bfde7a34984dc/ +experiments/universality/spectral_amplitude_crossover/PROOF.md +No Gaussian, continuum, asymptotic or process-limit theorem is consumed. +There is no sampler, blind experiment, novelty or scientific acceptance. +""" +from fractions import Fraction as Q +import json + +if __package__: + from .fold_controls import lifetime_bin_mass +else: + from fold_controls import lifetime_bin_mass + + +def _require(condition, message): + if not condition: + raise ValueError(message) + + +def _rational_sequence(values, name): + _require(type(values) in (list, tuple), name+' must be a list or tuple') + _require(all(type(value) is Q for value in values), + name+' must contain exact Fractions') + return tuple(values) + + +def short_bar_probabilities(lifetimes, threshold): + """Exact P(A*ell<=threshold); refuse every unsupported unsaturated root. + + Support clipping precedes root evaluation, after validating ALL inputs. + Continuous amplitude mass makes inclusive and strict endpoint CDFs equal. + """ + lengths = _rational_sequence(lifetimes, 'lifetimes') + _require(all(length > 0 for length in lengths), 'positive finite lifetimes required') + _require(type(threshold) is Q and threshold >= 0, + 'nonnegative exact Fraction threshold required') + probabilities = [] + for length in lengths: + if threshold == 0: + probability = Q(0) + elif threshold >= 2*length: + probability = Q(1) + else: + probability = lifetime_bin_mass( + Q(0), threshold, gap_coefficient=2*length, + radial_power=1, gap_order=3, weight=Q(2)) + probabilities.append(probability) + return tuple(probabilities) + + +def count_distribution(probabilities, *, coupling): + """Return P(N=k), k=0,...,m, for nested or independent short-bar events. + + In the shared-amplitude world all events are nested: sorting their CDF + probabilities gives the count tails. The independent world convolves + the individual Bernoulli laws. Marginals alone do not choose a world. + """ + marginals = _rational_sequence(probabilities, 'probabilities') + _require(all(0 <= p <= 1 for p in marginals), 'probabilities must lie in [0,1]') + _require(type(coupling) is str and coupling in ('shared', 'independent'), + 'coupling must be shared or independent') + if not marginals: + return (Q(1),) + if coupling == 'shared': + ordered = sorted(marginals, reverse=True) + return tuple([1-ordered[0]] + + [left-right for left, right in zip(ordered, ordered[1:])] + + [ordered[-1]]) + law = [Q(1)] + for p in marginals: + following = [Q(0)]*(len(law)+1) + for count, mass in enumerate(law): + following[count] += mass*(1-p) + following[count+1] += mass*p + law = following + return tuple(law) + + +def _probability_law(distribution): + law = _rational_sequence(distribution, 'distribution') + _require(bool(law) and all(p >= 0 for p in law) and sum(law) == 1, + 'a complete nonnegative probability law summing to one is required') + return law + + +def expected_count(distribution): + """Exact mean of a count law; this mean does not determine its coupling.""" + law = _probability_law(distribution) + return sum((count*mass for count, mass in enumerate(law)), Q(0)) + + +def pgf(distribution, z): + """Exact E[z**N] for a Fraction z in [0,1], including the 0**0 term.""" + law = _probability_law(distribution) + _require(type(z) is Q and 0 <= z <= 1, 'exact Fraction z in [0,1] required') + value = Q(0) + for mass in reversed(law): + value = mass + z*value + return value + + +def report(): + """Evaluate the known-answer control, with no field draws or inference.""" + marginals = short_bar_probabilities([Q(1), Q(8)], Q(1, 4)) + result = { + 'scope': 'EXACT_FINITE_BARCODE_DEPENDENCE_CONTROL', + 'reference_answers_exposed': True, + 'independent_world': 'ABSTRACT_BARCODE_SURROGATE', + 'field_realization_established': False, + 'theorem_conclusion_consumed': False, + 'scientific_effect': 'NONE', 'scientific_acceptance': False, + 'lifetimes': ['1', '8'], 'threshold': '1/4', + 'amplitude': 'A=2*U^3; U has density 2*u on (0,1)', + 'marginal_short_probabilities': [str(p) for p in marginals], + } + for coupling in ('shared', 'independent'): + law = count_distribution(marginals, coupling=coupling) + result[coupling] = {'count_probabilities': [str(p) for p in law], + 'mean': str(expected_count(law)), + 'pgf_at_half': str(pgf(law, Q(1, 2)))} + return result + + +if __name__ == '__main__': + print(json.dumps(report(), sort_keys=True, indent=2)) diff --git a/experiments/universality/test_amplitude_process_controls.py b/experiments/universality/test_amplitude_process_controls.py new file mode 100644 index 000000000..9da198cfa --- /dev/null +++ b/experiments/universality/test_amplitude_process_controls.py @@ -0,0 +1,137 @@ +"""Exact uniform-cell oracles for exposed finite dependence controls.""" +from fractions import Fraction as Q +import importlib +import importlib.util +from itertools import product +from math import lcm +import unittest + + +def enumerated_law(probabilities, shared): + """Integrate indicators by equiprobable uniform cells, without recursion.""" + denominator = lcm(*(p.denominator for p in probabilities)) if probabilities else 1 + cells = [Q(2*i+1, 2*denominator) for i in range(denominator)] + outcomes = ((u,)*len(probabilities) for u in cells) if shared else product(cells, repeat=len(probabilities)) + counts = [0]*(len(probabilities)+1) + total = 0 + for outcome in outcomes: + counts[sum(u < p for u, p in zip(outcome, probabilities))] += 1 + total += 1 + return tuple(Q(count, total) for count in counts) + + +class AmplitudeProcessControls(unittest.TestCase): + def setUp(self): + self.assertIsNotNone(importlib.util.find_spec('amplitude_process_controls'), + 'Exact dependence-control implementation is missing') + self.m = importlib.import_module('amplitude_process_controls') + + def test_exposed_fixture_has_equal_marginals_and_distinct_joint_laws(self): + probabilities = self.m.short_bar_probabilities([Q(1), Q(8)], Q(1, 4)) + self.assertEqual(probabilities, (Q(1, 4), Q(1, 16))) + shared = self.m.count_distribution(probabilities, coupling='shared') + independent = self.m.count_distribution(probabilities, coupling='independent') + self.assertEqual(shared, (Q(3, 4), Q(3, 16), Q(1, 16))) + self.assertEqual(independent, (Q(45, 64), Q(9, 32), Q(1, 64))) + self.assertEqual(self.m.expected_count(shared), Q(5, 16)) + self.assertEqual(self.m.expected_count(independent), Q(5, 16)) + self.assertEqual(self.m.pgf(shared, Q(1, 2)), Q(55, 64)) + self.assertEqual(self.m.pgf(independent, Q(1, 2)), Q(217, 256)) + + def test_complete_laws_agree_with_independent_uniform_cell_enumeration(self): + cases = [(), (Q(1, 2),), (Q(1, 3), Q(1, 2), Q(2, 3)), + (Q(1, 3),)*3, (Q(0), Q(1), Q(1, 2)), + (Q(0),)*3, (Q(1),)*3, (Q(1, 4), Q(1, 16))] + for probabilities in cases: + for coupling in ('shared', 'independent'): + with self.subTest(probabilities=probabilities, coupling=coupling): + actual = self.m.count_distribution(probabilities, coupling=coupling) + expected = enumerated_law(probabilities, coupling == 'shared') + self.assertEqual(actual, expected) + self.assertEqual(sum(actual), 1) + self.assertTrue(all(type(p) is Q and p >= 0 for p in actual)) + self.assertEqual(self.m.expected_count(actual), sum(probabilities, Q(0))) + for z in (Q(0), Q(1, 3), Q(1)): + direct = sum((p*z**i for i, p in enumerate(expected)), Q(0)) + self.assertEqual(self.m.pgf(actual, z), direct) + + def test_shared_law_is_invariant_to_order_and_ties(self): + for coupling in ('shared', 'independent'): + self.assertEqual(self.m.count_distribution((Q(2, 3), Q(1, 3), Q(1, 3)), coupling=coupling), + self.m.count_distribution((Q(1, 3), Q(1, 3), Q(2, 3)), coupling=coupling)) + # Per-bar probabilities keep input order and tied bars. + probabilities = self.m.short_bar_probabilities([Q(8), Q(1), Q(1)], Q(1, 4)) + self.assertEqual(probabilities, (Q(1, 16), Q(1, 4), Q(1, 4))) + self.assertEqual(self.m.count_distribution(probabilities, coupling='shared'), + (Q(3, 4), Q(0), Q(3, 16), Q(1, 16))) + + def test_zero_empty_and_support_clipping_precede_exact_root_evaluation(self): + self.assertEqual(self.m.short_bar_probabilities([], Q(1, 4)), ()) + self.assertEqual(self.m.short_bar_probabilities([Q(1), Q(8)], Q(0)), (Q(0), Q(0))) + self.assertEqual(self.m.short_bar_probabilities([Q(1), Q(8)], Q(2)), (Q(1), Q(1, 4))) + self.assertEqual(self.m.short_bar_probabilities([Q(1), Q(8)], Q(16)), (Q(1), Q(1))) + # A saturated term is exactly one even when its untruncated root is irrational. + self.assertEqual(self.m.short_bar_probabilities([Q(1)], Q(3)), (Q(1),)) + # ratio=8/27 has cube root 2/3; numerator roots must not be dropped. + self.assertEqual(self.m.short_bar_probabilities([Q(27, 16)], Q(1)), (Q(4, 9),)) + # Rational roots just inside the support edge pin saturation at threshold 2*length. + self.assertEqual(self.m.short_bar_probabilities([Q(1)], Q(2000, 1331)), (Q(100, 121),)) + self.assertEqual(self.m.short_bar_probabilities([Q(1)], Q(970299, 500000)), (Q(9801, 10000),)) + + def test_nonrational_root_refuses_the_complete_request(self): + for lifetimes in ([Q(1)], [Q(1, 2), Q(1)]): + with self.assertRaisesRegex(ValueError, 'root'): + self.m.short_bar_probabilities(lifetimes, Q(1)) + + def test_invalid_lifetimes_are_not_hidden_by_zero_or_saturation(self): + for lifetimes in ([Q(0)], [Q(-1)], [True], [1], [1.0], [Q(1), Q(0)]): + for threshold in (Q(0), Q(100)): + with self.subTest(lifetimes=lifetimes, threshold=threshold): + with self.assertRaises(ValueError): + self.m.short_bar_probabilities(lifetimes, threshold) + for lifetimes in (None, '1', {Q(1)}): + with self.assertRaises(ValueError): + self.m.short_bar_probabilities(lifetimes, Q(1)) + for threshold in (True, 1, 0.25, Q(-1)): + with self.assertRaises(ValueError): + self.m.short_bar_probabilities([], threshold) + + def test_invalid_marginals_and_coupling_are_rejected(self): + for probabilities in ([Q(-1)], [Q(2)], [True], [1], [0.5], None, '1'): + with self.assertRaises(ValueError): + self.m.count_distribution(probabilities, coupling='shared') + for coupling in ('unknown', '', None, True, []): + with self.assertRaises(ValueError): + self.m.count_distribution((), coupling=coupling) + + def test_pgf_and_mean_require_a_complete_exact_probability_law(self): + for law in ((), (Q(1, 2),), (Q(-1), Q(2)), (True,), (1,), None): + with self.assertRaises(ValueError): + self.m.expected_count(law) + with self.assertRaises(ValueError): + self.m.pgf(law, Q(1, 2)) + for z in (True, 0, 0.5, Q(-1), Q(2)): + with self.assertRaises(ValueError): + self.m.pgf((Q(1),), z) + + def test_report_preserves_abstract_and_exposed_scope(self): + report = self.m.report() + self.assertEqual(report['scope'], 'EXACT_FINITE_BARCODE_DEPENDENCE_CONTROL') + self.assertEqual(report['independent_world'], 'ABSTRACT_BARCODE_SURROGATE') + self.assertTrue(report['reference_answers_exposed']) + self.assertFalse(report['field_realization_established']) + self.assertFalse(report['theorem_conclusion_consumed']) + self.assertFalse(report['scientific_acceptance']) + self.assertEqual(report['scientific_effect'], 'NONE') + self.assertEqual(report['shared']['pgf_at_half'], '55/64') + self.assertEqual(report['independent']['pgf_at_half'], '217/256') + self.assertEqual((report['lifetimes'], report['threshold'], report['marginal_short_probabilities']), + (['1', '8'], '1/4', ['1/4', '1/16'])) + self.assertEqual(report['shared'], {'count_probabilities': ['3/4', '3/16', '1/16'], + 'mean': '5/16', 'pgf_at_half': '55/64'}) + self.assertEqual(report['independent'], {'count_probabilities': ['45/64', '9/32', '1/64'], + 'mean': '5/16', 'pgf_at_half': '217/256'}) + + +if __name__ == '__main__': + unittest.main()