1. Motivation

A recurring problem across many domains is measuring the relative importance of one feature within a large group, and then determining whether that localized feature influences its environment macroscopically. The question is not merely which features are important in aggregate, but whether a small component of a complex system — when perturbed — produces changes that propagate outward in meaningful ways. This kind of reasoning sits at the intersection of local attribution and global causal inference, and it is rarely addressed well by standard feature-importance pipelines.

PerturbClaw was directly inspired by work in determining the relative importance of transcription factor to gene relationships in gene regulatory networks. In that setting, the question is whether a single transcription factor, among hundreds of candidates, meaningfully changes its influence on a target gene between two biological conditions — for example, disease versus healthy tissue. But the underlying concept generalizes far beyond genomics: measuring the influence of a small component of a large group, and then testing whether changing that component has a broader macroscopic influence, has widespread potential across scientific disciplines.

Inspired by work from Dibaeinia et al. (2024) (referred to here also as CIMLA), PerturbClaw generalizes a methodology originally designed for gene-transcription factor attribution modeling and expands it to measure feature importance across a host of disciplines. Given data from two conditions (e.g. disease vs. control, treated vs. untreated), this workflow estimates perturbation-relevant feature influence between paired conditions using nonlinear predictive models and attribution aggregation. The workflow trains condition-specific predictive ensembles, computes feature-level attribution scores, and quantifies attribution divergence using stability-aware aggregation metrics.

Under the assumptions described in Dibaeinia et al. (2024), attribution differences approximate graph-marginalized proxies for condition-specific local treatment effects and provide an interpretable estimate of perturbation-relevant feature influence beyond purely correlational importance scores.

Concrete domains where this question arises include:

• Genomics: regulatory influence may differ between disease and control conditions; identifying which transcription factors changed their influence on target genes is a core unsolved problem
• Neuroscience: stimulus conditions may alter which features of neural activity are most relevant to a behavioral outcome
• Climate modeling: relationships between atmospheric variables and regional outcomes shift across eras, and identifying which variables changed their predictive role is essential for attribution
• Materials science: processing conditions change which material properties most strongly predict performance outcomes

Static feature-importance pipelines are often insufficient for all of these settings. They may ignore nonlinear response structure, and they do not provide a stable summary of how local attributions diverge between conditions. A method that ranks features by their raw importance in a single model cannot distinguish genuine condition-driven changes from spurious differences driven by confounding or model instability.

PerturbClaw addresses this gap by packaging a reproducible workflow that separates predictive modeling, attribution estimation, and attribution aggregation into explicit stages that can be executed by agents and adapted across domains. The current reference implementation uses the CIMLA Python package as a backend for predictive modeling and attribution computation; however, the PerturbClaw workflow abstraction is independent of this implementation choice and supports alternative predictive estimators and attribution operators. PerturbClaw supports both single-target execution and scalable multi-target batch workflows through configuration-driven automation.

2. Method

Attribution grounding

The causal grounding used in PerturbClaw draws on the theoretical framework developed by Dibaeinia, Ojha & Sinha (2024), which was originally formulated for gene regulatory network inference. PerturbClaw's contribution is to recognize that this framework describes a general computational pattern — comparing condition-specific attribution landscapes over a shared evaluation set — that is not intrinsically biological and can be instantiated wherever paired tabular conditions and a continuous outcome exist. What follows presents the theoretical foundation as developed by Dibaeinia et al. (2024), followed by an explicit account of how PerturbClaw extends and generalizes it.

The inferential challenge. The goal is to reason about causal influence — how much does feature $t$ directly determine $Y_g$? — using only observational data. Pearl's do-calculus (Pearl, 2009) provides the formal language: the observational quantity $P(Y_g \mid X_t = x_t)$ conflates direct causal effects with confounding paths, whereas $P(Y_g \mid \mathrm{do}(X_t = x_t))$ isolates the downstream causal effect by severing all incoming arrows to $X_t$. This distinction is the foundation of the Local Treatment Effect defined below.

Local Treatment Effect (Dibaeinia et al., 2024, Definition 1). For feature $t$ and target $g$, the LTE at state $\mathbf{x}$ is:

$$\mathrm{LTE}$${t,g}(\mathbf{x}) = E!\left[Y_g \mid \mathrm{do}(X_t = x_t),, \mathrm{do}(\mathbf{X}{-t} = \mathbf{x}{-t})\right] - E!\left[Y_g \mid \mathrm{do}(X_t = \hat{x}t),, \mathrm{do}(\mathbf{X}{-t} = \mathbf{x}{-t})\right]

Intervening on all features simultaneously blocks backdoor paths through other observed features and isolates $X_t$'s direct structural contribution. The LTE is analogous to the Conditional Average Treatment Effect (CATE) in the causal inference literature, with $X_t$ playing the role of treatment, $Y_g$ the outcome, and $\mathbf{X}_{-t}$ covariates held fixed by intervention rather than by conditioning. In Dibaeinia et al. (2024), $X_t$ is a transcription factor and $Y_g$ is a target gene. PerturbClaw treats this as a general template: $X_t$ can be any input feature and $Y_g$ any continuous outcome — an atmospheric variable predicting regional temperature, a protein level predicting cell viability, a policy indicator predicting an economic outcome, or any other paired tabular setting. The causal reasoning is identical across all of these; only the domain label changes.

From LTE to estimable proxy (Dibaeinia et al., 2024, Section 3). Two obstacles prevent direct LTE estimation: the baseline $\hat{x}_t$ is arbitrary, and the true causal DAG $\psi$ is unobserved. Dibaeinia et al. (2024) resolve both by marginalization. Averaging over the baseline marginal $P(X_t)$ removes baseline dependence:

$$\mathrm{LTE}$${t,g}(\mathbf{x}) = E{\hat{x}t \sim P(X_t)}!\left[\mathrm{LTE}{t,g}(\mathbf{x}, \hat{x}_t)\right]

Averaging further over all causal DAGs $\psi$ in which $X_t$ has a direct edge to $Y_g$ removes graph dependence, yielding the graph-marginalized proxy $\alpha_{t,g}$:

$$\alpha_{t,g}(\mathbf{x}) = E_{\hat{x}$$t,,\psi}!\left[\mathrm{LTE}{t,g}(\mathbf{x},, \hat{x}_t,, \psi)\right]

Note that $\alpha_{t,g}$ is a statistical proxy, not the true causal effect: it averages over all allowed graphs, including unrealistic ones. Dibaeinia et al. (2024) are explicit that this is a first step toward full causal identification.

The SHAP connection (Dibaeinia et al., 2024, Main Theorem). Under three assumptions — (1) $f$ correctly specifies $E[Y_g \mid \mathbf{X}]$, (2) $P(\mathbf{X}, Y_g)$ is Markov with respect to the true DAG, and (3) the SHAP background distribution matches $P(X_t)$ — the SHAP value $\phi_t(f, \mathbf{x})$ approximates $\alpha_{t,g}(\mathbf{x})$:

$$\phi_t(f, \mathbf{x}) \approx \alpha_{t,g}(\mathbf{x}) = E_{\hat{x}$$t,,\psi}!\left[\mathrm{LTE}{t,g}(\mathbf{x},, \hat{x}_t,, \psi)\right]

The Shapley formula (Lundberg & Lee, 2017; Shapley, 1953) computes this as:

$$\phi_t(f, \mathbf{x}) = \sum_{S \subseteq M \setminus {t}} \frac{|S|!,(m - |S| - 1)!}{m!} \left[ f_{S \cup {t}}(\mathbf{x}) - f_S(\mathbf{x}) \right]$$

where $f_S(\mathbf{x}) = E_{\mathbf{X}_{M \setminus S}}!\left[f(\mathbf{X}) \mid \mathbf{X}_S = \mathbf{x}$S\right]fS​(x)=EXM∖S​​[f(X)∣XS​=xS​]. Intuitively, averaging over coalitions resembles the graph marginalization in $\alpha${t,g}, though this structural resemblance should be understood as motivation rather than formal equivalence.

Where PerturbClaw extends this framework. Dibaeinia et al. (2024) apply this theory to differential gene regulatory network inference in single-cell RNA sequencing data. PerturbClaw makes a different claim: that the computational pattern — fit condition-specific nonlinear models, compute SHAP attributions on a shared evaluation set, aggregate differences via RMS — is a general-purpose workflow whose validity does not depend on the biological context. PerturbClaw packages this pattern as a domain-independent executable workflow, with explicit separation between the theoretical grounding (drawn from Dibaeinia et al., 2024, with attribution), the backend implementation (currently the CIMLA package), and the workflow abstraction itself, which is independent of both and is PerturbClaw's primary contribution. A future version of PerturbClaw could substitute any attribution backend satisfying the three stated assumptions without altering the workflow structure or its causal rationale.

Caveats. The Markov condition is frequently violated in real systems through feedback, pleiotropy, and unmeasured common causes. Latent confounders not captured in $\mathbf{X}$ are not removed by the intervention on observed features and can distort $\alpha_{t,g}$. Selecting attribution data strategically — restricting to matched samples, homogeneous subpopulations, or time-aligned observations — can reduce the influence of latent confounders and improve the interpretability of RAD scores across domains.

The PerturbClaw workflow

PerturbClaw implements a domain-independent workflow template for estimating perturbation-relevant feature influence under partially observed causal structure. The workflow separates predictive modeling, attribution estimation, and attribution aggregation into independent reproducible stages, allowing substitution of model classes, attribution methods, and aggregation metrics across scientific domains. The current reference implementation uses the CIMLA Python package as a backend; however, the PerturbClaw workflow abstraction is independent of this implementation choice and is designed to support alternative predictive estimators and attribution operators as they become available.

The workflow follows a five-stage pipeline: predict → attribute → aggregate → compare → rank

Step 1 — Predict. Paired-condition matrices are loaded, normalized to zero mean and unit variance, and partitioned into train and test sets using a configurable split ratio. Normalization ensures that features on different measurement scales do not dominate the predictive model due to magnitude alone. If the target variable $Y_g$ also appears as an input feature, its column is randomly permuted to prevent the model from exploiting direct self-prediction. This permutation step is inherited from the CIMLA backend (Dibaeinia et al., 2024) and is applicable wherever target leakage is a risk. For large datasets that exceed available memory, the workflow supports a Dask-backed data path with HDF5 caching and batched iteration throughout the pipeline.

Step 2 — Attribute. Two independent nonlinear predictive models are trained: $f_0$ on condition 0 (control) and $f_1$ on condition 1 (case). Independence is essential — the models must not share weights, parameters, or training data — because the attribution comparison in Step 3 is only interpretable if each model has learned the predictive structure of its own condition without influence from the other. The reference implementation exposes two model classes through the CIMLA backend: Random Forest (RF), implemented via scikit-learn with 3-fold GridSearchCV over hyperparameter grids covering tree depth, feature subsampling rate, and minimum leaf size; and Neural Network (MLP with dropout), implemented via Keras/TensorFlow with configurable hidden layer widths, dropout rate, L2 regularization, and mini-batch training. Both are universal approximators capable of capturing nonlinear relationships between features and outcomes that linear methods would miss. Model quality is evaluated on held-out test data using $R^2$ and MSE; a test $R^2 < 0.3$ for either condition is a warning signal that the predictive model may be too noisy to yield reliable attribution scores.

Step 3 — Aggregate. Both trained models $f_0$ and $f_1$ are evaluated on the same attribution dataset — by default, the case-condition samples. This shared evaluation is a deliberate design choice: by holding the input distribution constant and varying only the model, the resulting attribution difference is attributable to a shift in predictive structure between conditions rather than to a difference in sample composition. For RF models, TreeSHAP (Lundberg et al., 2020) is used to compute exact Shapley values in polynomial time by exploiting the tree structure. For NN models, DeepSHAP is used, which approximates Shapley values using a background reference distribution sampled from the training data. In both cases, the result is two attribution matrices $\Phi_1$ and $\Phi_0$, each of shape $|X| \times m$, where rows are samples and columns are features. The per-sample, per-feature attribution difference $\Delta_t(\mathbf{x}) = \phi_t(f_1, \mathbf{x}) - \phi_t(f_0, \mathbf{x})$ forms the raw material for the aggregation step.

Step 4 — Compare. The attribution differences are aggregated into a single scalar per feature using the RMS attribution divergence statistic (RAD):

$$\mathrm{RAD}$${t,g} = \sqrt{\frac{1}{|X|}\sum{\mathbf{x} \in X}!\left[\phi_t(f_1, \mathbf{x}) - \phi_t(f_0, \mathbf{x})\right]^2}

The choice of RMS rather than a signed mean is principled: relationships often shift heterogeneously across the sample population — some samples show a positive attribution shift for feature $t$, others negative. A signed mean would cancel these opposing shifts and could report near-zero divergence even when large sample-level changes are occurring. RMS captures the magnitude of per-sample attribution change regardless of direction, making it sensitive to heterogeneous shifts that a mean-based statistic would mask. The RAD statistic is fully domain-agnostic: it makes no assumptions about what features or targets represent, and its interpretation — feature $t$'s attributional influence changed substantially between conditions — is equally valid whether $t$ is a transcription factor, an atmospheric variable, a drug concentration, or an economic indicator.

Step 5 — Rank. Features are ranked in descending order of $\mathrm{RAD}_{t,g}$. When the workflow is run across multiple targets — the typical use case, since a single run produces scores for one target at a time — rankings are aggregated across targets by averaging per-feature RAD scores, and a final ranked list identifies the features that most consistently changed their attributional influence across the full set of outcomes. High-ranking features are candidates for follow-up analysis: experimental validation in scientific domains, policy investigation in social science settings, or targeted data collection in engineering applications. The RAD score should be interpreted as a prioritization tool rather than a definitive causal claim — it identifies where condition-driven attribution shifts are largest, which is where causal investigation is most warranted.

3. Skill Design and Executability

The SKILL.md is structured as an agent-executable workflow with explicit commands, expected outputs, and validation steps:

1. Install dependencies and create the conda environment
2. Prepare paired-condition CSV inputs and a target definition
3. Configure a YAML file for RF or NN execution
4. Run the backend command cimla --config config.yaml
5. Verify outputs with python verify_output.py and rank features by $\mathrm{RAD}_{t,g}$

This design aligns with the Claw4S review emphasis on executability, reproducibility, and clarity for agents. The package includes a lightweight example run, a verification script, and a synthetic batch workflow for submission-safe demonstrations. The current executable backend is inherited from the upstream CIMLA package. For submission accuracy, the package documents the validated backend stack as Python 3.8.12 with the legacy CIMLA dependency set, rather than claiming a modernized environment that has not been verified.

Example run

The run_example.sh script executes the full PerturbClaw workflow on the provided example data end-to-end:

conda activate perturbclaw_env
bash run_example.sh
python verify_output.py

Expected output files in example_results/:

global_feature_importance.csv   # RAD scores — one per input feature
performance_group1.csv          # R2/MSE on train and test, condition 0
performance_group2.csv          # R2/MSE on train and test, condition 1

A well-fit model should have $R^2 > 0.3$ on the test set. If $R^2$ is near zero for both conditions, the target may not be predictable from these features and results should be interpreted cautiously.

Synthetic batch workflow

For submission-safe demonstrations without real identifiers or real measurements, the package includes a fully synthetic workflow:

bash run_synthetic_pipeline.sh

This path uses only synthetic entity names (TF001...TF200, GENE001...GENE200) and synthetic measurements. Default synthetic dataset parameters:

• 200 synthetic features (TF001...TF200)
• 200 synthetic targets (GENE001...GENE200)
• 600 samples in condition 0
• 800 samples in condition 1

4. Validated Backend Environment

Validated execution is currently tied to the legacy CIMLA stack. The inspected working environment is Linux-based. Apple Silicon (osx-arm64) support is not claimed by this package and may require Docker, x86 emulation, or upstream maintenance by the original CIMLA authors.

5. Generalizability

PerturbClaw is explicitly framed as a domain-general workflow abstraction. The workflow requires only paired conditions, tabular predictors, a continuous outcome, and an attribution-capable predictive model. Example applications:

• Drug response: condition 0 = untreated cells, condition 1 = drug-treated; features = protein levels; target = cell viability
• Climate science: condition 0 = pre-2000 climate, condition 1 = post-2000; features = atmospheric variables; target = regional temperature
• Economics: condition 0 = pre-policy period, condition 1 = post-policy; features = economic indicators; target = unemployment rate
• Neuroscience: condition 0 = baseline stimulus, condition 1 = active stimulus; features = neural firing rates; target = behavioral outcome
• Materials science: condition 0 = standard processing, condition 1 = modified processing; features = material properties; target = yield strength

The core question — which features differ most in attributional influence between two conditions? — is domain-agnostic, and $\mathrm{RAD}_{t,g}$ provides a portable aggregation target for that question.

6. Evidence and Positioning

The reference implementation is grounded in the empirical results reported by Dibaeinia et al. (2024), where the underlying method was evaluated on synthetic and real biological datasets. On synthetic scRNA-seq data generated by the SERGIO simulator with known ground-truth regulatory networks, the method outperforms all competing approaches (GENIE3-diff, BoostDiff, DoubleML-diff, co-expression baselines) in both AUROC and AUPRC. The advantage is largest in the high-confounding condition, where competing methods degrade substantially while the attribution-based approach maintains high performance.

PerturbClaw does not claim to replace those experiments; instead, it turns the methodological pattern into an executable, reusable workflow suitable for CLAW-style review and adaptation across domains. For this submission package, emphasis is placed on executable reproducibility, portability through synthetic paired-condition data, clarity of the predict–attribute–aggregate–compare–rank decomposition, and faithful documentation of the validated dependency stack.

7. Limitations

The workflow should not be interpreted as exact causal identification. The attribution differences are assumption-dependent proxies, and latent confounding or model misspecification can distort them. Specifically:

• $\alpha_{t,g}$ averages the LTE over all allowed causal diagrams, including unrealistic ones — making it a statistical proxy rather than the true causal effect in the underlying network. Selecting attribution data strategically — for example, by restricting to matched samples, homogeneous subpopulations, or time-aligned observations — can reduce the influence of latent confounders and improve the interpretability of RAD scores across domains.
• Latent confounders such as unmeasured subpopulation structure are not fully removed by the intervention on observed features.
• SHAP-based attribution is computationally expensive for large feature sets; sampling and batching strategies are important in practice.

There is also an implementation-level limitation: the reference backend depends on a legacy Python 3.8.12 stack and has been validated in a Linux environment. Cross-platform support, especially on Apple Silicon, should be treated as a separate engineering problem rather than assumed from the current package.

References

• Dibaeinia P., Ojha A., Sinha S. (2024). Interpretable AI for inference of causal molecular relationships from omics data. Science Advances, 11(7), eadk0837.
• Pearl, J. (2009). Causality: Models, Reasoning, and Inference. Cambridge University Press.
• Lundberg, S.M. & Lee, S.I. (2017). A unified approach to interpreting model predictions. NeurIPS.
• Lundberg, S.M. et al. (2020). From local explanations to global understanding with explainable AI for trees. Nature Machine Intelligence (TreeSHAP).
• Dibaeinia P. & Sinha S. (2020). SERGIO: a single-cell expression simulator guided by gene regulatory networks. Cell Systems.
• Shapley, L.S. (1953). A value for n-person games. Contributions to the Theory of Games.

Reproducibility: Skill File

Key execution commands:

conda env create -f environment.yml
conda activate perturbclaw_env
pip install CIMLA
bash run_example.sh
python verify_output.py
bash run_synthetic_pipeline.sh

All commands are run from the submission directory. No API keys or GPU are required for the RF backend. The synthetic workflow is the recommended demonstration path for external review.