"""PB fixed-design signed paired-response calculator; synthetic counts are not field data. Usage: python3 paired_core.py input.json Input: {"alpha":"0.05", "groups":[{"outcomes":{"000":..., ...}}, ...], "null_bound":"0.0000001"} (null_bound optional). Bits are (X_rho, X_2rho, X_3rho). Exactly two groups in H1,H2 order. Coverage requires iid complete triples within each group, a fixed design, and correct marginals. Group/arm independence is not required. A supplied B0 must be valid independently of these data; this calculator cannot establish that. 80-digit Decimal arithmetic, an additive 1e-60 safety allowance, alpha>=1e-30, and n<=1e18 keep numerical roundoff far below the displayed confidence radius. This is a numerical implementation, not a formally verified interval engine. """ import argparse from decimal import Decimal, localcontext, InvalidOperation import json from pathlib import Path KEYS = tuple(f'{i:03b}' for i in range(8)) GUARD = Decimal('1e-60') MAX_N = 10**18 def number(value, name, lower, upper, lower_open=False): if isinstance(value, (bool, float)) or not isinstance(value, (str, int, Decimal)): raise ValueError(f'{name}: use an integer or decimal string') try: ans = Decimal(value) except (InvalidOperation, ValueError): raise ValueError(f'{name}: invalid decimal') from None if not ans.is_finite() or ans < lower or ans > upper or (lower_open and ans == lower): raise ValueError(f'{name}: outside supported range') return ans def radius(mean, s): raw = Decimal(5)/3*s + (2*mean*s + Decimal(7)/3*s*s).sqrt() return min(Decimal(1), raw + GUARD) def calculate(data): if not isinstance(data, dict) or set(data) - {'alpha', 'groups', 'null_bound'}: raise ValueError('input must contain alpha, groups, and optionally null_bound') alpha = number(data.get('alpha'), 'alpha', Decimal('1e-30'), Decimal(1)) if alpha == 1: raise ValueError('alpha must be less than 1') groups = data.get('groups') if not isinstance(groups, list) or len(groups) != 2: raise ValueError('exactly two groups are required in H1,H2 order') b0 = None if 'null_bound' in data: b0 = number(data['null_bound'], 'null_bound', Decimal(0), Decimal(2)) with localcontext() as ctx: ctx.prec = 80 t = (Decimal(16)/alpha).ln() + GUARD entries = [] for j, group in enumerate(groups, 1): if not isinstance(group, dict) or set(group) != {'outcomes'}: raise ValueError(f'group {j}: expected outcomes only') counts = group['outcomes'] if not isinstance(counts, dict) or set(counts) - set(KEYS): raise ValueError(f'group {j}: invalid outcome keys') if any(type(v) is not int or v < 0 for v in counts.values()): raise ValueError(f'group {j}: counts must be nonnegative integers') n = sum(counts.values()) if not 1 <= n <= MAX_N: raise ValueError(f'group {j}: n must be between 1 and {MAX_N}') s = t/n responses = {} for i in (2, 3): plus = sum(v for key, v in counts.items() if int(key[i-1])-int(key[0]) == 1) minus = sum(v for key, v in counts.items() if int(key[i-1])-int(key[0]) == -1) pplus, pminus = Decimal(plus)/n, Decimal(minus)/n responses[i] = {'positive_count': plus, 'negative_count': minus, 'estimate': pplus-pminus, 'radius': radius(pplus, s)+radius(pminus, s)} entries.append({'n': n, 'responses': responses}) a, b = entries[0]['responses'], entries[1]['responses'] ah, bh = {i:a[i]['estimate'] for i in (2,3)}, {i:b[i]['estimate'] for i in (2,3)} ar, br = {i:a[i]['radius'] for i in (2,3)}, {i:b[i]['radius'] for i in (2,3)} dhat = bh[3]*ah[2]-ah[3]*bh[2] rd = abs(bh[3])*ar[2]+abs(ah[2])*br[3]+abs(ah[3])*br[2]+abs(bh[2])*ar[3]+br[3]*ar[2]+ar[3]*br[2]+GUARD lower, upper = dhat-rd, dhat+rd return {'alpha': alpha, 'groups': entries, 'determinant': dhat, 'determinant_radius': rd, 'lower': lower, 'upper': upper, 'finite_sign_certificate': lower > 0, 'null_bound': b0, 'conditional_null_exclusion_certificate': None if b0 is None else lower > b0, 'scope': 'fixed design; iid complete triples within each group; null bound must be externally valid', 'arithmetic': '80-digit Decimal with 1e-60 allowance; numerical, not formal interval verification'} def serializable(value): if isinstance(value, Decimal): return str(value) if isinstance(value, dict): return {str(k):serializable(v) for k,v in value.items()} if isinstance(value, list): return [serializable(v) for v in value] return value def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('input', type=Path) args = parser.parse_args() try: result = calculate(json.loads(args.input.read_text())) except (ValueError, OSError) as exc: parser.exit(2, f'Invalid input: {exc}\n') print(json.dumps(serializable(result), ensure_ascii=False, indent=2)) if __name__ == '__main__': main()