| """Target-cluster reliability summaries with explicit sampling assumptions.
|
|
|
| These intervals concern the declared synthetic generator and fixed nuisance
|
| design. A seed, hash, or metadata field cannot establish independent sampling.
|
| Exact binomial intervals follow the NIST Engineering Statistics Handbook,
|
| section 7.2.4.1; bounded target averages use Hoeffding's inequality (1963).
|
| """
|
| from collections import defaultdict
|
| import math
|
| from .conditions import condition_key, condition_fields
|
|
|
|
|
| def _binomial_cdf(events, trials, probability):
|
| if probability <= 0:
|
| return 1.0
|
| if probability >= 1:
|
| return float(events >= trials)
|
| log_p, log_q = math.log(probability), math.log1p(-probability)
|
|
|
|
|
| return min(1.0, math.fsum(math.exp(math.lgamma(trials + 1) - math.lgamma(index + 1)
|
| - math.lgamma(trials - index + 1)
|
| + index * log_p + (trials - index) * log_q)
|
| for index in range(events + 1)))
|
|
|
|
|
| def _binomial_quantile(events, trials, tail):
|
| low, high = 0.0, 1.0
|
| for _ in range(70):
|
| middle = (low + high) / 2
|
| if _binomial_cdf(events, trials, middle) > tail:
|
| low = middle
|
| else:
|
| high = middle
|
| return (low + high) / 2
|
|
|
|
|
| def _exact_interval(events, trials, confidence):
|
| alpha = 1 - confidence
|
| lower = 0.0 if events == 0 else _binomial_quantile(events - 1, trials, 1 - alpha / 2)
|
| upper = 1.0 if events == trials else _binomial_quantile(events, trials, alpha / 2)
|
| return [lower, upper]
|
|
|
|
|
| def _outcome(row):
|
| audit, admitted = row['audit'], bool(row['decision']['admitted'])
|
| hazard = audit.get('hazard') if admitted else False
|
| return (admitted, audit.get('contract_satisfied') is True,
|
| admitted and audit.get('contract_satisfied') is not True,
|
| hazard, audit.get('calibration_hazardous_probes', 0) > 0)
|
|
|
|
|
| def _event_metric(events, targets, unknown, eligible, confidence):
|
| interval = None
|
| if eligible:
|
|
|
| interval = [_exact_interval(events, targets, confidence)[0],
|
| _exact_interval(events + unknown, targets, confidence)[1]]
|
| return {'events': events, 'targets': targets, 'unknown_targets': unknown,
|
| 'rate': events / targets, 'possible_rate': (events + unknown) / targets, 'interval': interval}
|
|
|
|
|
| def reliability_summary(rows, confidence=0.95):
|
| """Equal-weight semantic-parent summaries, conditional on explicit draws.
|
|
|
| Duplicate nuisance cells are collapsed only when their audit outcomes
|
| agree. Structural-seed collisions or unequal label/implementation designs
|
| withhold sampling intervals. Planned seed selection is not observational
|
| evidence of a real-world target distribution or independent draws.
|
| """
|
| if (type(confidence) not in (int, float) or not math.isfinite(confidence)
|
| or not 0 < confidence < 1):
|
| raise ValueError('confidence must be finite and strictly between zero and one')
|
| groups = defaultdict(list)
|
| for row in rows:
|
| cfg = row['configuration']
|
| conditions = condition_key(cfg)
|
| groups[(cfg['policy'] + '/' + cfg['admission'], cfg['family'], cfg['budget'], conditions)].append(row)
|
| output = []
|
| for (method, family, budget, conditions), members in sorted(groups.items()):
|
| parents, structural_seeds, seed_parents = defaultdict(dict), defaultdict(set), {}
|
| declared = True
|
| for row in members:
|
| cfg, parent = row['configuration'], row['parent_instance_id']
|
| seed = cfg.get('instance_seed')
|
| if type(seed) is int and 0 <= seed <= 2**32 - 1:
|
| if family == 'generated_protocol' and seed in seed_parents and seed_parents[seed] != parent:
|
| raise ValueError('A structural seed identifies inconsistent semantic target dynamics')
|
| seed_parents[seed] = parent
|
| structural_seeds[parent].add(seed)
|
| else:
|
| declared = False
|
| cell = (cfg['seed'], cfg['implementation'])
|
| outcome = _outcome(row)
|
| if cell in parents[parent] and parents[parent][cell] != outcome:
|
| raise ValueError('Inconsistent duplicate nuisance-cell audit outcomes')
|
| parents[parent][cell] = outcome
|
| targets = len(parents)
|
| collisions = sum(max(0, len(seeds) - 1) for seeds in structural_seeds.values())
|
| nuisance_designs = {frozenset(cells) for cells in parents.values()}
|
| if family != 'generated_protocol':
|
| reason = 'handpicked_fixtures'
|
| elif not declared:
|
| reason = 'undeclared_structural_seed'
|
| elif collisions:
|
| reason = 'structural_seed_collision'
|
| elif len(nuisance_designs) != 1:
|
| reason = 'unequal_nuisance_design'
|
| else:
|
| reason = 'independent_generator_draws_assumed'
|
| eligible = reason == 'independent_generator_draws_assumed'
|
| useful, admitted, harmful = [], [], []
|
| deployment_events = calibration_events = unknown_deployment = 0
|
| for cells in parents.values():
|
| values = list(cells.values())
|
| useful.append(sum(value[1] for value in values) / len(values))
|
| admitted.append(sum(value[0] for value in values) / len(values))
|
| harmful.append(sum(value[2] for value in values) / len(values))
|
| any_hazard = any(value[3] is True for value in values)
|
| deployment_events += any_hazard
|
| unknown_deployment += not any_hazard and any(value[3] is None for value in values)
|
| calibration_events += any(value[4] for value in values)
|
| useful_mean = math.fsum(useful) / targets
|
| admitted_mean, harmful_mean = math.fsum(admitted) / targets, math.fsum(harmful) / targets
|
| useful_interval = None
|
| if eligible:
|
| radius = math.sqrt(math.log(2 / (1 - confidence)) / (2 * targets))
|
| useful_interval = [max(0.0, useful_mean - radius), min(1.0, useful_mean + radius)]
|
| output.append({
|
| 'method': method, 'family': family, 'budget': budget,
|
| **condition_fields(conditions), 'confidence': confidence,
|
| 'requests': len(members), 'unique_nuisance_requests': sum(len(cells) for cells in parents.values()),
|
| 'parent_clusters': targets,
|
| 'independent_parents': targets if family == 'generated_protocol' and declared else 0,
|
| 'structural_seed_collisions': collisions, 'inference_eligible': eligible,
|
| 'inference_reason': reason,
|
| 'interval_status': 'conditional_generator_sampling' if eligible else 'descriptive_' + reason,
|
| 'target_any_deployment_hazard': _event_metric(deployment_events, targets, unknown_deployment,
|
| eligible, confidence),
|
| 'target_any_calibration_hazard': _event_metric(calibration_events, targets, 0, eligible, confidence),
|
| 'target_average_useful_coverage': {'estimate': useful_mean, 'interval': useful_interval},
|
| 'conditional_selective_harm': harmful_mean / admitted_mean if admitted_mean else None,
|
| 'scope': ('Synthetic target-cluster estimates. Intervals, when present, assume independent generator '
|
| 'draws and an identical fixed nuisance-cell design; each interval is pointwise, not a '
|
| 'simultaneous guarantee. Structural hashes and planned seed selection do not establish '
|
| 'independence or real-world probabilities. Exact binomial bounds describe any hazard '
|
| 'across the nuisance design; useful-coverage bounds are Hoeffding bounds for equal-target '
|
| 'means. Selective harm is the ratio of equal-target failure and admission means; '
|
| 'abstention leaves it undefined when no target admits.')})
|
| return output
|
|
|
