Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
137 changes: 137 additions & 0 deletions experiments/universality/amplitude_process_controls.py
Original file line number Diff line number Diff line change
@@ -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))
137 changes: 137 additions & 0 deletions experiments/universality/test_amplitude_process_controls.py
Original file line number Diff line number Diff line change
@@ -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()
Loading