Fix replicate-weight scale invariance and BRR test fixtures

Normalize survey_weights_arr to sum=n in _precompute_structures() so
size_gt/size_gt_ctrl denominators are scale-invariant for replicate
designs. Fix BRR test fixtures to build combined replicate weights
(rep_r = weight * factor) honoring combined_weights=True semantics.
Add replicate scale-invariance tests for simple/event_study/group
aggregation.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: igerber

diff_diff/staggered_triple_diff.py

@@ -839,6 +839,12 @@ def _precompute_structures(
                 .reindex(all_units)
                 .values.astype(np.float64)
             )
+            # Normalize to sum=n for aggregation/rescaling (matches pweight
+            # convention). Raw weights preserved in resolved_survey_unit for
+            # replicate w_r/w_full ratios — those are inherently scale-invariant.
+            sw_sum = np.sum(survey_weights_arr)
+            if sw_sum > 0:
+                survey_weights_arr = survey_weights_arr * (len(survey_weights_arr) / sw_sum)
             resolved_survey_unit = collapse_survey_to_unit_level(
                 resolved_survey, df, unit, all_units
             )

tests/test_survey_staggered_ddd.py

@@ -378,12 +378,13 @@ def test_brr_replicate(self, sddd_data):
         rng = np.random.default_rng(99)
         n_units = data["unit"].nunique()
         R = 20
-        # Generate unit-level replicate weights
+        # Generate combined replicate weights: rep_r = weight * factor_r
+        # (combined_weights=True means each column includes full-sample weight)
         unit_ids = sorted(data["unit"].unique())
-        rep_matrix = 1.0 + rng.standard_normal((n_units, R)) * 0.1
-        rep_matrix = np.abs(rep_matrix)  # Ensure positive
+        base_w = data.groupby("unit")["weight"].first().reindex(unit_ids).values
         for r in range(R):
-            unit_w = dict(zip(unit_ids, rep_matrix[:, r]))
+            factor = np.abs(1.0 + rng.standard_normal(n_units) * 0.1)
+            unit_w = dict(zip(unit_ids, base_w * factor))
             data[f"rep_{r}"] = data["unit"].map(unit_w)
 
         rep_cols = [f"rep_{r}" for r in range(R)]
@@ -422,9 +423,10 @@ def test_brr_with_bootstrap_rejected(self, sddd_data):
         n_units = data["unit"].nunique()
         unit_ids = sorted(data["unit"].unique())
         R = 10
-        rep_matrix = np.abs(1.0 + rng.standard_normal((n_units, R)) * 0.1)
+        base_w = data.groupby("unit")["weight"].first().reindex(unit_ids).values
         for r in range(R):
-            unit_w = dict(zip(unit_ids, rep_matrix[:, r]))
+            factor = np.abs(1.0 + rng.standard_normal(n_units) * 0.1)
+            unit_w = dict(zip(unit_ids, base_w * factor))
             data[f"rep_{r}"] = data["unit"].map(unit_w)
 
         rep_cols = [f"rep_{r}" for r in range(R)]
@@ -449,6 +451,87 @@ def test_brr_with_bootstrap_rejected(self, sddd_data):
             )
 
 
+# ---------------------------------------------------------------------------
+# Replicate-weight scale invariance
+# ---------------------------------------------------------------------------
+
+
+def _make_brr_data(sddd_data, rng_seed=99, R=20):
+    """Helper: build combined BRR replicate weights for sddd_data."""
+    data = sddd_data.copy()
+    rng = np.random.default_rng(rng_seed)
+    unit_ids = sorted(data["unit"].unique())
+    n_units = len(unit_ids)
+    base_w = data.groupby("unit")["weight"].first().reindex(unit_ids).values
+    for r in range(R):
+        factor = np.abs(1.0 + rng.standard_normal(n_units) * 0.1)
+        unit_w = dict(zip(unit_ids, base_w * factor))
+        data[f"rep_{r}"] = data["unit"].map(unit_w)
+    rep_cols = [f"rep_{r}" for r in range(R)]
+    return data, rep_cols
+
+
+class TestReplicateScaleInvariance:
+    """Rescaling all weights + replicates by constant k must not change results."""
+
+    @pytest.mark.parametrize("agg", ["simple", "event_study", "group"])
+    def test_scale_invariance(self, sddd_data, agg):
+        data, rep_cols = _make_brr_data(sddd_data)
+        k = 5.0
+
+        sd1 = SurveyDesign(
+            weights="weight",
+            replicate_weights=rep_cols,
+            replicate_method="BRR",
+        )
+        est = StaggeredTripleDifference(estimation_method="reg")
+        res1 = est.fit(
+            data,
+            "outcome",
+            "unit",
+            "period",
+            "first_treat",
+            "eligibility",
+            aggregate=agg,
+            survey_design=sd1,
+        )
+
+        # Scale all weights and replicate columns by k
+        data_k = data.copy()
+        data_k["weight"] = data_k["weight"] * k
+        for col in rep_cols:
+            data_k[col] = data_k[col] * k
+
+        sd2 = SurveyDesign(
+            weights="weight",
+            replicate_weights=rep_cols,
+            replicate_method="BRR",
+        )
+        res2 = est.fit(
+            data_k,
+            "outcome",
+            "unit",
+            "period",
+            "first_treat",
+            "eligibility",
+            aggregate=agg,
+            survey_design=sd2,
+        )
+
+        np.testing.assert_allclose(
+            res2.overall_att,
+            res1.overall_att,
+            atol=1e-12,
+            err_msg=f"ATT changed with weight rescaling (agg={agg})",
+        )
+        np.testing.assert_allclose(
+            res2.overall_se,
+            res1.overall_se,
+            rtol=1e-6,
+            err_msg=f"SE changed with weight rescaling (agg={agg})",
+        )
+
+
 # ---------------------------------------------------------------------------
 # Survey-weighted aggregation point estimates
 # ---------------------------------------------------------------------------