CausalBoundingEngine Framework

• CausalBoundingEngine is an open-source Python package that applies partial identification methods to derive bounds on causal effects and counterfactual queries.
• It unifies symbolic, optimization-based, and information-theoretic techniques to handle intervention-level targets like ATE, PN, PS, and PNS through constrained optimization.
• Its decision support system employs a decision tree and Random Forest meta-selector to guide method selection based on simulation benchmarks and data characteristics.

Searching arXiv for recent and directly relevant papers on CausalBoundingEngine and causal bounding frameworks. CausalBoundingEngine is an open-source Python package that implements, extends, and unifies state-of-the-art algorithms for partial identification—returning bounds rather than point estimates—of causal effects and counterfactuals (Maringgele, 19 Aug 2025). Its central premise is that causal inference often hinges on strong assumptions such as no unmeasured confounding or perfect compliance, whereas partial identification derives ranges that remain compatible with observed data and stated structure. Within that program, the engine targets intervention-level effects such as the Average Treatment Effect (ATE) and counterfactual quantities such as the Probability of Necessity (PN), Probability of Sufficiency (PS), and Probability of Necessity and Sufficiency (PNS), while exposing a common interface across symbolic, optimization-based, and information-theoretic methods (Maringgele, 19 Aug 2025).

1. Conceptual basis

CausalBoundingEngine is rooted in the partial-identification view that the relevant object is not necessarily a point estimate but an identification region induced by data, causal structure, and optional restrictions. In discrete settings, this viewpoint often reduces to linear or polynomial optimization over response-type variables, with sharpness meaning that no narrower interval is compatible with the constraints (Jonzon et al., 2022, Duarte et al., 2021). In continuous settings, analogous programs optimize over function classes, copula parameterizations, or stochastic latent representations to bound interventional functionals under instrumental-variable or clustered-structure assumptions (Kilbertus et al., 2020, Padh et al., 2022).

This orientation places the engine in contrast with regression-style workflows that output a single number under a single structural model. In the package formulation, methods are compared by bound tightness, computational efficiency, and robustness to assumption violations, rather than by point-estimation accuracy alone (Maringgele, 19 Aug 2025). That design choice is shared by adjacent systems for symbolic DAG-based bounding, automated discrete polynomial programming, credal-network counterfactual bounding, and selection-bias-aware EM procedures (Jonzon et al., 2022, Duarte et al., 2021, Zaffalon et al., 2023, Zaffalon et al., 2022).

2. Formal targets and constraint language

For binary treatment $T \in \{0,1\}$ and binary outcome $Y \in \{0,1\}$, the engine uses the standard potential-outcomes definitions

$$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$

For counterfactual explanation, it uses

$$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$

$$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$

$$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$

These definitions are exposed directly in the unified package interface (Maringgele, 19 Aug 2025).

Across methods, the common pattern is constrained optimization over latent response-type or counterfactual distributions. In the package summary, the generic discrete program is written as

$$\min/\max_{p \in \mathcal{F}} \theta(p) \quad \text{s.t.} \quad A p = c,\ p \ge 0,\ \mathbf{1}^\top p = 1,$$

where $p$ encodes latent response-type probabilities and the constraints encode marginal consistency with observed or interventional data (Maringgele, 19 Aug 2025). In automated discrete causal inference, the same principle is generalized to polynomial programs with equality and inequality constraints induced by structural assumptions, while incomplete computation still yields valid outer bounds and an $\epsilon$-sharpness certificate (Duarte et al., 2021).

The information-theoretic branch augments this structure with entropy-based restrictions on hidden confounding. For intervention queries, the package uses a cap

$I(X; Y_{x_q}) \le H(U) \le \theta,$

and for joint counterfactuals it uses

$Y \in \{0,1\}$0

so that a weak-confounding assumption can tighten feasible sets without full ignorability (Maringgele, 19 Aug 2025).

3. Implemented method families

The package organizes algorithms into symbolic, optimization-based, and information-theoretic families (Maringgele, 19 Aug 2025).

Family	Methods	Core characteristic
Symbolic	manski, tianpearl, causaloptim	analytic or LP-derived bounds in discrete settings
Optimization-based	autobound, zhangbareinboim, zaffalonbounds	constrained polynomial, LP, or EM-based feasible-set search
Information-theoretic	entropybounds	entropy- or KL-constrained bounding under weak confounding

The symbolic layer includes classical worst-case ATE bounds, Tian–Pearl bounds for probabilities of causation, and the more general DAG/query machinery of causaloptim. The causaloptim system takes a DAG and a counterfactual query, constructs response-function variables, derives the linear system $Y \in \{0,1\}$1, and returns tight symbolic bounds using exact rational double-description via cddlib (Jonzon et al., 2022). That symbolic lineage is also related to logical-relation methods that derive bounds and inequality constraints from counterfactual implication and contradiction relations, including generalized instrumental inequalities and binary-IV sharp bounds (Finkelstein et al., 2020).

The optimization-based layer includes autobound for constrained response-type programs, zhangbareinboim for continuous outcomes in $Y \in \{0,1\}$2 under IV with imperfect compliance, and zaffalonbounds for EM-based sampling of compatible structural causal models (Maringgele, 19 Aug 2025). The broader literature extends this class in several directions: continuous-treatment IV bounding via gradient-based optimization over response-function parameterizations (Kilbertus et al., 2020); stochastic causal programming for multivariate continuous treatments using invertible generators and moment constraints (Padh et al., 2022); exact or approximate counterfactual bounds via credal-network mappings and causal EM in discrete SCMs (Zaffalon et al., 2023).

The information-theoretic layer centers on entropybounds. In the package, it is used for both ATE and a new PNS extension based on a KL-divergence cap on the joint counterfactual distribution (Maringgele, 19 Aug 2025). A conceptually related but distinct information-theoretic development appears in proxy-based proximal inference, where the average bridge error is bounded by a term proportional to $Y \in \{0,1\}$3, linking proxy quality to treatment-effect error under violated causal-bridge assumptions (Meng et al., 29 Sep 2025).

4. Architecture and method selection

CausalBoundingEngine wraps multiple external libraries and in-house implementations behind a unified interface. The package description separates algorithm adapters, query specification, assumption sets, and data interfaces. The symbolic layer includes in-house manski and tianpearl modules and a Python wrapper to R causaloptim; the optimization-based layer includes autobound, an in-house LP implementation for zhangbareinboim, and wrappers to Credici/Crema for zaffalonbounds; the information-theoretic layer implements entropybounds for both ATE and PNS (Maringgele, 19 Aug 2025).

The package also includes explicit decision support. A decision tree organizes method choice by outcome type, query, instrument availability, preference for symbolic bounds, desired conservativeness, and availability of an entropy cap $Y \in \{0,1\}$4 (Maringgele, 19 Aug 2025). In addition, a Random Forest meta-selector is trained on observable features such as $Y \in \{0,1\}$5, $Y \in \{0,1\}$6, $Y \in \{0,1\}$7, $Y \in \{0,1\}$8, $Y \in \{0,1\}$9, and $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$0, omitting $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$1-based features when no IV is available. Its reported out-of-sample accuracy versus a most-frequent-winner baseline is $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$2 vs $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$3 for BinaryConf ATE, $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$4 vs $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$5 for BinaryConf PNS, $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$6 vs $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$7 for BinaryIV ATE, and $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$8 vs $$\mathrm{ATE} = E[Y(1)-Y(0)] = P(Y=1 \mid do(T=1)) - P(Y=1 \mid do(T=0)).$$9 for BinaryIV PNS (Maringgele, 19 Aug 2025).

This selection layer is not merely ergonomic. It reflects a substantive result of the benchmark: there is no uniformly best bounding method. Strong instruments, balanced treatment, continuous outcomes, and entropy-cap credibility shift the preferred algorithm. That same pattern appears in adjacent frameworks: symbolic methods are often exact but may be limited by admissible DAG classes (Jonzon et al., 2022); EM-based SCM sampling is broad but expensive (Zaffalon et al., 2022, Zaffalon et al., 2023); PAG-based analytic bounds exploit Markov-equivalence invariants but depend on reliable graph learning and faithfulness (Bellot, 2023).

5. Empirical behavior and performance

The package benchmark spans 4 core scenarios—Binary Confounding, Binary Instrumental Variable, Continuous Confounding, and Continuous Instrumental Variable—plus a BinaryEntropyConf setting specialized to entropy-bounded methods. It uses $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$0 simulations per scenario, $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$1 observations per simulation, and a total of $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$2 algorithm runs (Maringgele, 19 Aug 2025).

In BinaryConf ATE, autobound, causaloptim, and manski produce Net Width $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$3 with Invalid Rate $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$4, whereas zaffalonbounds yields Net Width $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$5, Invalid Rate $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$6, and Invalid $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$7 (Maringgele, 19 Aug 2025). In BinaryIV ATE, zaffalonbounds attains Net Width $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$8 with Invalid $$\mathrm{PN} = \mathbb{P}(Y_{x'} = 0 \mid X = x, Y = 1),$$9, while 2SLS yields Net Width $$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$0–$$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$1 and Invalid $$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$2–$$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$3 (Maringgele, 19 Aug 2025). In Continuous IV, zhangbareinboim yields Net Width $$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$4 with Invalid $$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$5, whereas 2SLS intervals have Invalid $$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$6–$$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$7 and remain wide (Maringgele, 19 Aug 2025). These comparisons encode a recurring package conclusion: classical confidence intervals are not interchangeable with causal bounds under partial identification.

The runtime profile is similarly heterogeneous. The average per-configuration runtime is about $$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$8 s for manski and tianpearl, about $$\mathrm{PS} = \mathbb{P}(Y_{x} = 1 \mid X = x', Y = 0),$$9 s for OLS, about $$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$0 s for 2SLS, about $$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$1 s for entropybounds, about $$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$2 s for zhangbareinboim, about $$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$3 s for autobound, about $$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$4 s for causaloptim, and about $$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$5 s for zaffalonbounds (Maringgele, 19 Aug 2025). The last figure reflects the cost of repeated EM-based exploration of compatible SCMs; it also explains why the package treats method selection as a first-class problem rather than as an afterthought.

6. Extensions, adjacent frameworks, and unresolved issues

The broader literature suggests that CausalBoundingEngine is best understood as one node in a larger research program on bounded causal inference. Symbolic DAG-based systems derive tight algebraic bounds from admissible graph classes and counterfactual queries (Jonzon et al., 2022). Automated polynomial programming extends this idea to confounding, selection, measurement error, noncompliance, and nonresponse, while reporting non-sharp outer bounds and an $$\mathrm{PNS} = \mathbb{P}(Y_{x} = 1,\, Y_{x'} = 0).$$6-sharpness certificate during computation (Duarte et al., 2021). The causal marginal polytope relaxes global response-type search to locally consistent marginals, trading sharpness for tractability (Zeitler et al., 2022). Logical-relation methods bound non-identified counterfactuals by exploiting implication and contradiction relations among counterfactual events (Finkelstein et al., 2020).

Selection bias and heterogeneous data integration form another major branch. One line proves unimodality of the selection-biased likelihood and uses causal EM to obtain point estimates for identifiable queries and bounds otherwise (Zaffalon et al., 2022). A related line remaps multiple observational, interventional, biased, and randomized datasets into an augmented selection-bias framework, again using causal EM to tighten counterfactual bounds (Zaffalon et al., 2022). A credal-network formulation provides exact counterfactual bounds for small discrete SCMs and EM-based inner approximations more generally, but also shows that exact causal inference is NP-hard even on polytrees (Zaffalon et al., 2023).

Further extensions broaden the object of bounding itself. Continuous-treatment IV models can be bounded through response-function parameterizations, copulas, and augmented Lagrangian optimization (Kilbertus et al., 2020). Multivariate continuous treatments can be handled by stochastic causal programming with invertible generators and low-order moment constraints (Padh et al., 2022). Probabilities of causation can be bounded more sharply when mediators are observed under no direct effect and no confounding (Dawid et al., 2014, Dawid et al., 2019), and partial causal diagrams can constrain PoC optimization even when the graph is incomplete (Xie et al., 16 Feb 2026). In proximal causal inference with negative controls, mutual-information bounds quantify the average error of the causal bridge when assumptions fail, suggesting a violation-aware extension of engine design beyond classical partial identification (Meng et al., 29 Sep 2025).

These extensions also mark the main unresolved issues. The package thesis explicitly notes that continuous outcomes beyond IV remain difficult, that autobound and causaloptim can diverge under noise or assumption violations, that entropy-bounded PNS remains conservative in high-entropy regimes, and that overconfident entropy caps or monotonicity assumptions can invalidate bounds (Maringgele, 19 Aug 2025). Adjacent work adds further caveats: PAG-based bounds depend on correct graph learning and faithfulness (Bellot, 2023); EM-based inner approximations require credible stopping diagnostics (Zaffalon et al., 2023, Zaffalon et al., 2022); and exact symbolic or LP methods may become combinatorially expensive as variable cardinalities and parent sets grow (Jonzon et al., 2022, Duarte et al., 2021). Taken together, those results position CausalBoundingEngine not as a single algorithm, but as a comparative computational framework for negotiating the trade-off between robustness, informativeness, and tractability in modern causal inference.