S0-R1-C5.5-R3 Typed Causal Actor Frame Closure

core/quantitative_engine.py

@@ -878,53 +878,76 @@ Keywords: {keywords}"""
             r"causation|cause(?:s|d|ing)?)"
         )
         direct_patterns = (
-            r"\b(?:causes?|caused|causing)\b",
-            r"\b(?:leads?|led)\s+to\b",
-            r"\b(?:drives?|drove|driven)\b",
-            r"\b(?:determines?|determined)\b",
-            r"\b(?:produces?|produced)\b",
-            r"\b(?:results?|resulted)\s+in\b",
-            r"\b(?:transmits?|transmitted)\s+(?:an?\s+|the\s+)?causal\s+effect\b",
-            r"\bcausally\s+(?:transmits?|mediates?|affects?|influences?)\b",
-            r"\b(?:has|have|had|exerts?|exerted)\s+(?:an?\s+|the\s+)?causal\s+effect\b",
+            (r"\b(?:causes?|caused|causing)\b", "STRONG"),
+            (r"\b(?:leads?|led)\s+to\b", "STRONG"),
+            (r"\b(?:drives?|drove|driven)\b", "STRONG"),
+            (r"\b(?:determines?|determined)\b", "STRONG"),
+            (r"\b(?:produces?|produced)\b", "AMBIGUOUS_REPORTING"),
+            (r"\b(?:results?|resulted)\s+in\b", "AMBIGUOUS_REPORTING"),
+            (r"\b(?:yields?|yielded)\b", "AMBIGUOUS_REPORTING"),
+            (r"\b(?:generates?|generated)\b", "AMBIGUOUS_REPORTING"),
+            (r"\b(?:transmits?|transmitted)\s+(?:an?\s+|the\s+)?causal\s+effect\b", "STRONG"),
+            (r"\bcausally\s+(?:transmits?|mediates?|affects?|influences?)\b", "STRONG"),
+            (r"\b(?:has|have|had|exerts?|exerted)\s+(?:an?\s+|the\s+)?causal\s+effect\b", "STRONG"),
         )
 
-        def direct_match_is_statistical_reporting(match):
-            """Return True only for a statistical-operation -> statistical-artifact frame.
-
-            C5.5-R1: causal-looking verbs such as ``produced``/``resulted in``
-            are ambiguous in quantitative prose.  A bootstrap procedure producing
-            a confidence interval is statistical reporting, not a claim that one
-            study construct causes another.  The exemption therefore requires
-            *both* a statistical-operation source immediately before the verb and
-            a statistical-artifact target immediately after it.  Merely seeing
-            ``analysis`` or ``model`` is not enough; e.g. ``the analysis produced
-            higher engagement`` remains fail-closed.
+        def local_actor_text(match):
+            """Return the grammatical actor window immediately before a predicate.
+
+            R3 deliberately classifies the *actor* rather than maintaining an
+            ever-growing whitelist of reporting artefacts.  Leading adverbial or
+            prepositional phrases (``In the analysis, ...`` / ``Using Spearman
+            correlations, ...``) are peeled away so that a nearby mention of an
+            analysis cannot shield a later construct-level causal assertion.
             """
-            prefix = value[max(0, match.start() - 180):match.start()]
-            suffix = value[match.end():min(len(value), match.end() + 180)]
-
-            # Keep the source local to the current grammatical frame rather than
-            # letting an earlier sentence mention of an analysis whitelist a later
-            # construct-level causal assertion.
-            source = re.split(r"[.;!?]", prefix)[-1]
-            source_pattern = (
-                r"\b(?:bootstrap(?:\s+resampling|\s+procedure|\s+computation)?|"
-                r"resampling(?:\s+procedure|\s+algorithm)?|"
-                r"regression\s+(?:analysis|model)|"
-                r"association\s+(?:analysis|model)|"
+            prefix = value[max(0, match.start() - 260):match.start()]
+            actor = re.split(r"[.;!?]", prefix)[-1].strip()
+            lead = re.match(
+                r"^(?:in|using|with|based\s+on|according\s+to|after|before|when|while|because|"
+                r"although|though|given|under|for|as)\b[^,]{0,180},\s*(.+)$",
+                actor,
+                flags=re.I,
+            )
+            if lead:
+                actor = lead.group(1).strip()
+            return actor[-220:]
+
+        def actor_type(match):
+            """Classify the predicate subject as analytical, weak-analytical, or other.
+
+            ``ANALYTICAL_ACTOR`` is intentionally restricted to explicit
+            statistical/diagnostic actors.  Generic ``model``/``procedure`` terms
+            are weak because they can also denote the substantive AI system or an
+            intervention; they are exempt only when the predicate target is a
+            recognisable reporting artefact.
+            """
+            actor = local_actor_text(match)
+            strong_actor = (
+                r"\b(?:analysis|analyses|"
+                r"bootstrap(?:\s+(?:resampling|procedure|computation|analysis))?|"
+                r"resampling(?:\s+(?:procedure|analysis|computation))?|"
+                r"regression\s+(?:analysis|model)|association\s+(?:analysis|model)|"
                 r"mediation\s+(?:analysis|model)|"
-                r"estimation(?:\s+procedure|\s+method)?|estimator|"
-                r"statistical\s+(?:analysis|model|procedure|method)|"
-                r"analysis|analyses|model|procedure|method|algorithm|"
-                r"computation|calculation)\b"
+                r"estimation(?:\s+(?:procedure|method|analysis))?|estimator|"
+                r"statistical\s+(?:analysis|model|procedure|method|test)|"
+                r"robustness\s+(?:check|test|analysis)|"
+                r"sensitivity\s+(?:check|test|analysis)|"
+                r"diagnostic\s+(?:check|test|analysis)|"
+                r"rank[- ]order\s+(?:robustness\s+)?check|"
+                r"(?:spearman|pearson|rank[- ]order)\s+correlations?|"
+                r"correlation\s+(?:analysis|matrix|check|test)|"
+                r"hypothesis\s+test|significance\s+test|"
+                r"variance\s+inflation\s+factor(?:\s+check)?|vif(?:\s+check)?|"
+                r"measurement\s+assessment|descriptive\s+analysis)\b"
             )
-            if not re.search(source_pattern, source, flags=re.I):
-                return False
-
-            # The target must be a recognisable statistical artefact.  Do not use
-            # generic outcomes such as ``result`` or ``change`` because those can
-            # also be substantive dependent variables.
+            if re.search(strong_actor, actor, flags=re.I):
+                return "ANALYTICAL_ACTOR"
+            if re.search(r"\b(?:model|procedure|method|computation|calculation)\b", actor, flags=re.I):
+                return "WEAK_ANALYTICAL_ACTOR"
+            return "OTHER_ACTOR"
+
+        def predicate_target_is_reporting_output(match):
+            suffix = value[match.end():min(len(value), match.end() + 220)]
             target_pattern = (
                 r"^\s*(?:(?:an?|the|this|that|these|those|following|reported|"
                 r"standardized|standardised|numerical|estimated|95\s*percent|95%)\s+){0,6}"
@@ -935,10 +958,33 @@ Keywords: {keywords}"""
                 r"correlations?|covariances?|variances?|loadings?|"
                 r"test\s+statistics?|p[- ]?values?|vif(?:s|\s+values)?|"
                 r"cronbach(?:'s)?\s+alpha|composite\s+reliability|"
-                r"average\s+variance\s+extracted|ave|numerical\s+estimates?|estimates?)\b"
+                r"average\s+variance\s+extracted|ave|numerical\s+estimates?|estimates?|"
+                r"(?:a\s+)?pattern(?:\s+of\s+(?:associations|correlations|estimates))?|"
+                r"(?:a\s+)?(?:similar|consistent|comparable)\s+pattern|"
+                r"findings?|results?)\b"
             )
             return bool(re.search(target_pattern, suffix, flags=re.I))
 
+        def direct_match_is_analytical_reporting(match, predicate_kind):
+            actor = actor_type(match)
+            if predicate_kind == "AMBIGUOUS_REPORTING":
+                # ``analysis/check/test produced/resulted/yielded/generated ...``
+                # describes what an analytical operation reported.  It is not a
+                # study-construct causal assertion even when the following prose is
+                # stylistically loose (e.g. ``the analysis produced higher
+                # engagement``).  The CAR layer may flag wording separately; this
+                # causal gate must not terminate the manuscript for it.
+                if actor == "ANALYTICAL_ACTOR":
+                    return True
+                if actor == "WEAK_ANALYTICAL_ACTOR" and predicate_target_is_reporting_output(match):
+                    return True
+                return False
+
+            # Strong causal predicates remain fail-closed.  Preserve only the
+            # narrow statistical-reporting idiom already accepted by R1, such as
+            # ``the analysis led to the following numerical estimate``.
+            return actor in {"ANALYTICAL_ACTOR", "WEAK_ANALYTICAL_ACTOR"} and predicate_target_is_reporting_output(match)
+
         def direct_match_is_disclaimed(match):
             prefix = value[max(0, match.start() - 220):match.start()]
             if re.search(
@@ -974,12 +1020,12 @@ Keywords: {keywords}"""
             return False
 
         saw_disclaimed_direct = False
-        for pattern in direct_patterns:
+        for pattern, predicate_kind in direct_patterns:
             for match in re.finditer(pattern, value, flags=re.I):
                 if direct_match_is_disclaimed(match):
                     saw_disclaimed_direct = True
                     continue
-                if direct_match_is_statistical_reporting(match):
+                if direct_match_is_analytical_reporting(match, predicate_kind):
                     continue
                 return "AFFIRMATIVE_CAUSAL"