"""Pure joint-response coupling and recorded semantic corrections. Shared empirical ranks are a model prior, not recovered human correlations. All indices are zero based; answer option IDs are one based. Inputs are never modified, and this module performs no file or network access. """ from __future__ import annotations import copy import json import re import numpy as np from scipy.optimize import linear_sum_assignment from scipy.spatial.distance import cdist from scipy.stats import rankdata def components(inp): """Keep items used by one canonical statistic in an indivisible group.""" n = len(inp["prompts"][0]["questions"]) parent = list(range(n)) used = set() def root(i): while parent[i] != i: parent[i] = parent[parent[i]] i = parent[i] return i def join(items): items = sorted(set(items)) assert all(0 <= j < n for j in items) used.update(items) for j in items[1:]: parent[root(j)] = root(items[0]) for effect in inp["effects"]: metadata = {"identifiability": effect["identifiability"], "statistic_spec": effect["statistic_spec"]} join([int(s) - 1 for s in re.findall(r"item_(\d+)", json.dumps(metadata))]) for block in inp["blocks"]: join([j for j, _ in block]) join(inp["categorical"]) groups = {} for j in sorted(used): groups.setdefault(root(j), []).append(j) free = sorted(set(range(n)) - used) return sorted(groups.values(), key=lambda x: x[0]), free def rank_matrix(a): return rankdata(a, axis=0, method="average") / (len(a) + 1.) def joint_diagnostic(a, reference, groups, free): blocks = groups + ([free] if free else []) owner = {j: k for k, block in enumerate(blocks) for j in block} with np.errstate(divide="ignore", invalid="ignore"): ca = np.atleast_2d(np.corrcoef(rank_matrix(a), rowvar=False)) cr = np.atleast_2d(np.corrcoef(rank_matrix(reference), rowvar=False)) diffs = [] inversions = 0 for i in range(a.shape[1]): for j in range(i): if owner[i] == owner[j]: continue if np.isfinite(ca[i, j]) and np.isfinite(cr[i, j]): diffs.append(abs(float(ca[i, j] - cr[i, j]))) inversions += ca[i, j] * cr[i, j] < 0 and min(abs(ca[i, j]), abs(cr[i, j])) > .1 return {"between_component_rank_correlation_MAE": float(np.mean(diffs)) if diffs else None, "correlation_pairs": len(diffs), "opposite_sign_pairs_above_0_1": int(inversions), "unique_joint_vectors": len(np.unique(a, axis=0)), "constant_items": int((np.std(a, axis=0) == 0).sum())} def couple(prompt, a, initial, groups, free, rng): """Transport whole fitted components to a shared initial-model rank prior.""" n, _ = a.shape assert initial.shape == a.shape proposals = [] for _ in range(4): out = initial.copy() permutations = [] cost = 0. for block in groups: if len(groups) == 1 and not free: ix = np.arange(n) else: target = rank_matrix(initial[:, block]) donors = rank_matrix(a[:, block]) distances = cdist(target, donors, "sqeuclidean") / len(block) _, ix = linear_sum_assignment(distances + rng.uniform(0, 1e-10, distances.shape)) cost += float(distances[np.arange(n), ix].mean()) out[:, block] = a[ix][:, block] permutations.append(ix) assert sorted(map(tuple, out[:, block])) == sorted(map(tuple, a[:, block])) assert not free or np.array_equal(out[:, free], initial[:, free]) diag = joint_diagnostic(out, initial, groups, free) score = diag["between_component_rank_correlation_MAE"] proposals.append((float(score) if score is not None else 0., cost, out, permutations, diag)) _, _, out, permutations, after = min(proposals, key=lambda x: x[:2]) before = joint_diagnostic(a, initial, groups, free) retained = False if (not free and before["between_component_rank_correlation_MAE"] is not None and after["between_component_rank_correlation_MAE"] > before["between_component_rank_correlation_MAE"] + 1e-10): out = a.copy() permutations = [np.arange(n) for _ in groups] retained = True result = {key: copy.deepcopy(prompt[key]) for key in ("study_id", "condition_key", "condition_id", "original_n", "questions", "messages")} result["respondents"] = out.tolist() result["protected_components"] = copy.deepcopy(groups) result["free_items"] = list(free) result["retained_coupling"] = retained result["respondent_provenance"] = [] for i in range(n): parts = [{"items": list(block), "source": "fitted", "condition_key": prompt["condition_key"], "respondent_index": int(ix[i])} for block, ix in zip(groups, permutations)] if free: parts.append({"items": list(free), "source": "initial", "condition_key": prompt["condition_key"], "respondent_index": i}) result["respondent_provenance"].append({"components": parts}) return result def balance_audience(populations): """Preserve pooled response vectors and n; audience balance is a prior.""" by = {q["condition_id"]: q for q in populations} rng = np.random.default_rng(20260908) for left, right in [("A", "B"), ("C", "D"), ("E", "F")]: p, q = by[left], by[right] n1, n2 = p["original_n"], q["original_n"] x, y = np.array(p["respondents"]), np.array(q["respondents"]) x[:, 0] = 4 - x[:, 0] y[:, 0] = y[:, 0] - 4 pool = np.concatenate([x, y]) provenance = p["respondent_provenance"] + q["respondent_provenance"] features = np.column_stack([pool, pool ** 2]).astype(float) features /= np.maximum(features.std(0), 1.) target = features.sum(0) * n1 / (n1 + n2) best = np.arange(n1 + n2) best_cost = float("inf") for _ in range(1000): ix = rng.permutation(n1 + n2) err = features[ix[:n1]].sum(0) - target cost = float(err @ err) if cost < best_cost: best, best_cost = ix, cost err = features[best[:n1]].sum(0) - target for _ in range(20000): i = int(rng.integers(n1)) j = int(rng.integers(n1, n1 + n2)) trial = err - features[best[i]] + features[best[j]] cost = float(trial @ trial) if cost < best_cost - 1e-12: best[i], best[j] = best[j], best[i] err = trial best_cost = cost a = pool[best[:n1]].copy() b = pool[best[n1:]].copy() assert sorted(map(tuple, pool)) == sorted(map(tuple, np.concatenate([a, b]))) a[:, 0] = 4 - a[:, 0] b[:, 0] = b[:, 0] + 4 for dest, values, indices in [(p, a, best[:n1]), (q, b, best[n1:])]: dest["respondents"] = values.tolist() new_provenance = [] for ix in indices: pr = copy.deepcopy(provenance[int(ix)]) source_condition = left if ix < n1 else right pr["audience_reassignment"] = { "from_condition": source_condition, "to_condition": dest["condition_id"], "recoded_item": 0, "option_mapping": "8-option_id" if source_condition != dest["condition_id"] else "identity"} new_provenance.append(pr) dest["respondent_provenance"] = new_provenance def repair_prompts(populations, policy): """Apply recorded wording corrections supplied with the study inputs.""" for row in populations: for edit in policy["wording_corrections"]: selectors = {key: edit[key] for key in ("condition_key", "study_id") if key in edit} if not selectors: raise ValueError("A wording correction must identify its study or condition") if any(row[key] != value for key, value in selectors.items()): continue text = row["messages"][1]["content"] if edit["only_if_present"] and edit["match"] not in text: continue assert text.count(edit["match"]) == 1 assert all(fragment in text for fragment in edit["required"]) row["messages"][1]["content"] = text.replace(edit["before"], edit["after"]) def semantic_rules(populations, free_items, policy): """Correct only explicitly specified free-item facts, not human frequencies.""" for q in populations: key = q["condition_key"] for edit in policy["prompt_edits"]: if edit["condition_key"] != key: continue text = q["messages"][1]["content"] assert text.count(edit["before"]) == 1, (key, "stimulus source changed") q["messages"][1]["content"] = text.replace(edit["before"], edit["after"]) for rule in policy["facts"]: if rule["condition_key"] != key: continue j, value = rule["item_index"], rule["expected_option_id"] assert j in free_items, (key, j, "cannot alter canonical dependency") assert rule["question"] in q["messages"][1]["content"] assert q["questions"][j]["options"][value - 1]["text"] == rule["expected_option_text"] for answer, lineage in zip(q["respondents"], q["respondent_provenance"]): if answer[j] == value: continue lineage.setdefault("semantic_overrides", []).append({ "rule_id": rule["rule_id"], "item_index": j, "before_option_id": answer[j], "after_option_id": value}) answer[j] = value q["semantic_rules"] = [r["rule_id"] for r in policy["facts"] if r["condition_key"] == key] def finalize_study(inp, respondents, recipe, policy): """Finalize fitted responses without reading saved final populations. Preserve prompt order and the shared per-study RNG stream. The caller supplies integer option matrices after construct/moment transformations. """ groups, free = components(inp) rng = np.random.default_rng(int(recipe["transport_seed"])) expected_keys = {q["condition_key"] for q in inp["prompts"]} assert len(expected_keys) == len(inp["prompts"]) assert set(respondents) == expected_keys populations = [] for prompt in inp["prompts"]: assert prompt["study_id"] == inp["study"] key = prompt["condition_key"] a = np.array(respondents[key], dtype=int) assert np.array_equal(a, np.asarray(respondents[key])) assert a.shape == (prompt["original_n"], len(prompt["questions"])) initial = np.array(inp["sources"]["Chiron"][key], dtype=int) populations.append(couple(prompt, a, initial, groups, free, rng)) if inp["study"] == "JEP_1_6b": balance_audience(populations) repair_prompts(populations, policy) semantic_rules(populations, free, policy) for q in populations: a = np.array(q["respondents"]) assert a.shape == (q["original_n"], len(q["questions"])) assert all(1 <= int(value) <= len(q["questions"][j]["options"]) for row in a for j, value in enumerate(row)) assert len(q["respondent_provenance"]) == q["original_n"] return populations