gum::DoorCriteria Class Reference

Implements Backdoor and Frontdoor criteria utilities for a DAG. More...

#include <doorCriteria.h>

Public Types
using	NodeSetVec = std::vector< NodeSet >
	Convenience type: list of candidate adjustment sets.

Static Public Member Functions
static bool	satisfiesBackdoorCriterion (const DAG &dag, NodeId X, NodeId Y, const NodeSet &Z)
	Check if Z satisfies the backdoor criterion relative to (X, Y).
static NodeSetVec	enumerateBackdoorSets (const DAG &dag, NodeId X, NodeId Y, const NodeSet &excluded_nodes=NodeSet(), std::size_t max_cardinality=0, bool only_minimal=true, bool stopAtFirst=false)
	Enumerate valid backdoor adjustment sets.
static NodeSetVec	enumerateBackdoorSets (const DAG &dag, NodeId X, NodeId Y, bool stopAtFirst)
	Enumerate valid backdoor adjustment sets — shorthand to set stopAtFirst only.
static std::optional< NodeSet >	firstBackdoor (const DAG &dag, NodeId X, NodeId Y, const NodeSet &excluded_nodes=NodeSet(), std::size_t max_cardinality=0, bool only_minimal=true)
	Directly return the first backdoor adjustment set if any.
static bool	satisfiesFrontdoorCriterion (const DAG &dag, NodeId X, NodeId Y, const NodeSet &Z)
	Check if Z satisfies the frontdoor criterion relative to (X, Y).
static NodeSetVec	enumerateFrontdoorSets (const DAG &dag, NodeId X, NodeId Y, const NodeSet &excluded_nodes=NodeSet(), std::size_t max_cardinality=0, bool only_minimal=true, bool stopAtFirst=false)
	Enumerate valid frontdoor adjustment sets.
static NodeSetVec	enumerateFrontdoorSets (const DAG &dag, NodeId X, NodeId Y, bool stopAtFirst)
	Enumerate valid frontdoor adjustment sets — shorthand to set stopAtFirst only.
static std::optional< NodeSet >	firstFrontdoor (const DAG &dag, NodeId X, NodeId Y, const NodeSet &excluded_nodes=NodeSet(), std::size_t max_cardinality=0, bool only_minimal=true)
	Directly return the first frontdoor adjustment set if any.
static bool	existsUnblockedDirectedPath (const DAG &dag, NodeId X, NodeId Y, const NodeSet &Z)
	Check whether there exists a directed path X->..->Y unblocked by Z.
static std::optional< NodeSet >	nodesOnDirectedPaths (const DAG &dag, NodeId X, NodeId Y)
	Compute nodes lying on some directed path from X to Y.
static NodeSet	backdoorReach (const DAG &dag, NodeId X)
	Compute the "backdoor reach" of a node.
static bool	hasBackdoorPath (const DAG &dag, NodeId X, NodeId Y, const NodeSet &Z)
	Test whether there exists an open backdoor path from X to Y given Z.

Static Private Member Functions
static bool	_isMinimalBackdoorAdjustment (const DAG &dag, NodeId X, NodeId Y, const NodeSet &Z)
	Check whether Z is a minimal backdoor adjustment set.
static bool	_isMinimalFrontdoorAdjustment (const DAG &dag, NodeId X, NodeId Y, const NodeSet &Z)
	Check whether Z is a minimal frontdoor adjustment set.
static bool	_existsUnblockedDirectedPath_ (const DAG &dag, NodeId X, NodeId Y, const NodeSet &Z, NodeSet &visited)

Detailed Description

Implements Backdoor and Frontdoor criteria utilities for a DAG.

This class provides helpers to:

• Check whether a conditioning set satisfies the backdoor/frontdoor criterion.
• Enumerate all valid backdoor/frontdoor adjustment sets.

The DAG is passed as the first argument to each method rather than stored in the object, making DoorCriteria a stateless utility class.

The implementation mirrors pyAgrum functionality.

Naming correspondences with pyAgrum:

• enumerateBackdoorSets => pyagrum: backdoor_generator
• enumerateFrontdoorSets => pyagrum: frontdoor_generator
• existsUnblockedDirectedPath => pyagrum: exists_unblocked_directed_path
• nodesOnDirectedPaths => pyagrum: nodes_on_dipath
• backdoorReach => pyagrum: backdoor_reach
• hasBackdoorPath => pyagrum: backdoor_path
• satisfiesBackdoorCriterion => pyagrum: is_backdoor
• satisfiesFrontdoorCriterion => pyagrum: is_frontdoor

Definition at line 79 of file doorCriteria.h.

Member Typedef Documentation

NodeSetVec

using gum::DoorCriteria::NodeSetVec = std::vector< NodeSet >

Convenience type: list of candidate adjustment sets.

Definition at line 82 of file doorCriteria.h.

Member Function Documentation

_existsUnblockedDirectedPath_()

bool gum::DoorCriteria::_existsUnblockedDirectedPath_ ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & Z, NodeSet & visited )

staticprivate

Definition at line 421 of file doorCriteria.cpp.

                                                                           {
    if (visited.contains(X)) return false;
    visited.insert(X);
    if (dag.existsArc(X, Y)) return true;
    for (auto c: dag.children(X)) {
      if (!Z.contains(c) && _existsUnblockedDirectedPath_(dag, c, Y, Z, visited)) return true;
    }
    return false;
  }

References _existsUnblockedDirectedPath_(), gum::ArcGraphPart::children(), gum::Set< Key >::contains(), gum::ArcGraphPart::existsArc(), and gum::Set< Key >::insert().

Referenced by _existsUnblockedDirectedPath_(), and existsUnblockedDirectedPath().

Here is the call graph for this function:

Here is the caller graph for this function:

_isMinimalBackdoorAdjustment()

bool gum::DoorCriteria::_isMinimalBackdoorAdjustment ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & Z )

staticprivate

Check whether Z is a minimal backdoor adjustment set.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
Z	Candidate conditioning set.

Returns

True if Z is a valid backdoor set and no strict subset is valid.

Definition at line 514 of file doorCriteria.cpp.

                                                                    {
    for (auto z: Z) {
      NodeSet sub = Z;
      sub.erase(z);
      if (satisfiesBackdoorCriterion(dag, X, Y, sub)) return false;
    }
    return true;
  }

References gum::Set< Key >::erase(), and satisfiesBackdoorCriterion().

Here is the call graph for this function:

_isMinimalFrontdoorAdjustment()

bool gum::DoorCriteria::_isMinimalFrontdoorAdjustment ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & Z )

staticprivate

Check whether Z is a minimal frontdoor adjustment set.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
Z	Candidate conditioning set.

Returns

True if Z is a valid frontdoor set and no strict subset is valid.

Definition at line 526 of file doorCriteria.cpp.

                                                                     {
    if (Z.empty()) return false;   // frontdoor sets must be non-empty
    for (auto z: Z) {
      NodeSet sub = Z;
      sub.erase(z);
      if (satisfiesFrontdoorCriterion(dag, X, Y, sub)) return false;
    }
    return true;
  }

References gum::Set< Key >::empty(), gum::Set< Key >::erase(), and satisfiesFrontdoorCriterion().

Referenced by enumerateFrontdoorSets().

Here is the call graph for this function:

Here is the caller graph for this function:

backdoorReach()

NodeSet gum::DoorCriteria::backdoorReach ( const DAG & dag, NodeId X )

static

Compute the "backdoor reach" of a node.

Backdoor reach = set of nodes reachable from X by traversing one incoming edge (parent step) followed by any sequence of child steps.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Node of interest (typically the treatment).

Returns

Set of nodes in the backdoor reach of X.

Definition at line 480 of file doorCriteria.cpp.

                                                              {
    NodeSet reach0;   // via a parent step
    NodeSet reach1;   // via a child step
 
    // Seed with 'a' to avoid parent->a->child zig-zag artifacts
    reach0.insert(a);
    reach1.insert(a);
 
    // parents of X are themselves in backdoor reach (X <- parent)
    for (auto pa: dag.parents(a))
      reach0.insert(pa);
 
    // Start the alternating traversal from each parent
    for (auto pa: dag.parents(a)) {
      _inner_br(dag, pa, /*pht=*/false, reach0, reach1);
    }
 
    NodeSet s = reach0;
    for (auto n: reach1)
      s.insert(n);
    s.erase(a);
    return s;
  }

References gum::Set< Key >::erase(), gum::Set< Key >::insert(), and gum::ArcGraphPart::parents().

Referenced by enumerateFrontdoorSets(), and satisfiesFrontdoorCriterion().

Here is the call graph for this function:

Here is the caller graph for this function:

enumerateBackdoorSets() [1/2]

DoorCriteria::NodeSetVec gum::DoorCriteria::enumerateBackdoorSets ( const DAG & dag, NodeId X, NodeId Y, bool stopAtFirst )

static

Enumerate valid backdoor adjustment sets — shorthand to set stopAtFirst only.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
stopAtFirst	If true, return only the first found set and stop early.

Returns

Vector of valid backdoor adjustment sets (at most one if stopAtFirst is true).

Definition at line 274 of file doorCriteria.cpp.

                                                                                              {
    return enumerateBackdoorSets(dag, X, Y, NodeSet{}, 0, true, stopAtFirst);
  }

References enumerateBackdoorSets().

Here is the call graph for this function:

enumerateBackdoorSets() [2/2]

DoorCriteria::NodeSetVec gum::DoorCriteria::enumerateBackdoorSets ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & excluded_nodes = NodeSet(), std::size_t max_cardinality = 0, bool only_minimal = true, bool stopAtFirst = false )

static

Enumerate valid backdoor adjustment sets.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
excluded_nodes	Nodes to exclude from candidate sets (e.g., latent variables).
max_cardinality	Maximum set size (0 = no limit).
only_minimal	If true, return only minimal adjustment sets.
stopAtFirst	If true, return only the first found set and stop early.

Returns

Vector of valid backdoor adjustment sets (at most one if stopAtFirst is true).

Definition at line 166 of file doorCriteria.cpp.

                                                                                           {
    NodeSetVec out;
 
    // Theoretical variant: if X has no parents, {} is a valid backdoor set.
    if (dag.parents(X).empty()) {
      out.emplace_back();
      return out;
    }
 
    // If Y is a parent of X, there is an open backdoor X<-Y that {} cannot block.
    if (dag.existsArc(Y, X)) return out;
 
    // Reduce around interest = {X, Y}; evidence = {}
    NodeSet Xset;
    Xset.insert(X);
    NodeSet Yset;
    Yset.insert(Y);
    NodeSet Zempty;
 
    // test {} first
    if (Separation::isBackdoorSeparated(dag, Xset, Yset, Zempty)) {
      out.push_back(Zempty);
      if (only_minimal || stopAtFirst) return out;
    }
 
    DAG G = Separation::reduceForDSeparation(dag, Xset, Yset, Zempty);
 
    // Candidate pool = nodes(G) \ (Desc(X) ∪ {X,Y} ∪ excluded_nodes)
    NodeSet descX = dag.descendants(X);
    NodeSet possible;
    for (auto n: G.nodes()) {
      if (n == X || n == Y) continue;
      if (excluded_nodes.contains(n)) continue;
      if (descX.contains(n)) continue;
      possible.insert(n);
    }
    if (possible.empty()) return out;
 
    auto              cand = _sortedVec(possible);
    const std::size_t N    = cand.size();
    const std::size_t Kmax = (max_cardinality == 0) ? N : std::min(max_cardinality, N);
 
    // Only prune supersets in only_minimal mode
    NodeSetVec chosen;
    const bool prune_supersets = only_minimal;
 
    NodeSet Xs;
    Xs.insert(X);
    NodeSet Ys;
    Ys.insert(Y);
 
    // pyagrum tries k >= 1 (never yields {} except our explicit no-parent case above)
    for (std::size_t k = 1; k <= Kmax; ++k) {
      std::vector< bool > pick(N, false);
      std::fill_n(pick.begin(), k, true);
      do {
        NodeSet Z;
        for (std::size_t i = 0; i < N; ++i)
          if (pick[i]) Z.insert(cand[i]);
 
        if (prune_supersets) {
          bool worth = true;
          for (const auto& s: chosen) {
            bool subset = true;
            for (auto u: s)
              if (!Z.contains(u)) {
                subset = false;
                break;
              }
            if (subset) {
              worth = false;
              break;
            }
          }
          if (!worth) continue;
        }
 
        if (Separation::isBackdoorSeparated(G, Xs, Ys, Z)) {
          if (only_minimal) {
            chosen.push_back(Z);
            out.push_back(Z);
          } else {
            out.push_back(Z);   // keep non-minimal supersets too (e.g., {U,W})
          }
          if (stopAtFirst) return out;
        }
 
      } while (std::prev_permutation(pick.begin(), pick.end()));
    }
 
    // Deterministic order + dedup
    std::sort(out.begin(), out.end(), _lexLess);
    out.erase(std::unique(out.begin(),
                          out.end(),
                          [](const NodeSet& a, const NodeSet& b) {
                            return _sortedVec(a) == _sortedVec(b);
                          }),
              out.end());
    return out;
  }

References gum::Set< Key >::contains(), gum::DiGraph::descendants(), gum::Set< Key >::empty(), gum::ArcGraphPart::existsArc(), gum::Set< Key >::insert(), gum::Separation::isBackdoorSeparated(), gum::NodeGraphPart::nodes(), gum::ArcGraphPart::parents(), and gum::Separation::reduceForDSeparation().

Referenced by gum::CausalModel< GUM_SCALAR >::backDoor(), enumerateBackdoorSets(), and firstBackdoor().

Here is the call graph for this function:

Here is the caller graph for this function:

enumerateFrontdoorSets() [1/2]

DoorCriteria::NodeSetVec gum::DoorCriteria::enumerateFrontdoorSets ( const DAG & dag, NodeId X, NodeId Y, bool stopAtFirst )

static

Enumerate valid frontdoor adjustment sets — shorthand to set stopAtFirst only.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
stopAtFirst	If true, return only the first found set and stop early.

Returns

Vector of valid frontdoor adjustment sets (at most one if stopAtFirst is true).

Definition at line 407 of file doorCriteria.cpp.

                                                                                               {
    return enumerateFrontdoorSets(dag, X, Y, NodeSet{}, 0, true, stopAtFirst);
  }

References enumerateFrontdoorSets().

Here is the call graph for this function:

enumerateFrontdoorSets() [2/2]

DoorCriteria::NodeSetVec gum::DoorCriteria::enumerateFrontdoorSets ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & excluded_nodes = NodeSet(), std::size_t max_cardinality = 0, bool only_minimal = true, bool stopAtFirst = false )

static

Enumerate valid frontdoor adjustment sets.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
excluded_nodes	Nodes to exclude from candidate sets (e.g., latent variables).
max_cardinality	Maximum set size (0 = no limit).
only_minimal	If true, return only minimal adjustment sets.
stopAtFirst	If true, return only the first found set and stop early.

Returns

Vector of valid frontdoor adjustment sets (at most one if stopAtFirst is true).

Definition at line 278 of file doorCriteria.cpp.

                                                                                            {
    NodeSetVec out;
 
    // pyagrum early exit: if X is a parent of Y, yield nothing
    for (auto p: dag.parents(Y)) {
      if (p == X) { return out; }
    }
 
    // Candidate pool
    auto possibleOpt = nodesOnDirectedPaths(dag, X, Y);
    bool noDiPath    = !possibleOpt.has_value();
 
    NodeSet possible;
    if (possibleOpt.has_value()) { possible = *possibleOpt; }
 
    if (noDiPath) {
      // No directed path: use weakly connected component containing both X and Y (undirected BFS)
      NodeSet cc;
      {
        std::vector< NodeId > st;
        st.push_back(X);
        cc.insert(X);
        while (!st.empty()) {
          NodeId u = st.back();
          st.pop_back();
          for (auto v: dag.parents(u))
            if (!cc.contains(v)) {
              cc.insert(v);
              st.push_back(v);
            }
          for (auto v: dag.children(u))
            if (!cc.contains(v)) {
              cc.insert(v);
              st.push_back(v);
            }
        }
      }
      if (!cc.contains(Y)) { return out; }
      noDiPath = true;
      possible = cc;
      possible.erase(X);
      possible.erase(Y);
    } else {
      possible.erase(X);
      possible.erase(Y);
    }
 
    // Prune by backdoor reach of X and user exclusions
    NodeSet br = backdoorReach(dag, X);
    for (auto n: br) {
      possible.erase(n);
    }
    for (auto n: excluded_nodes) {
      possible.erase(n);
    }
 
    // Remove "impossible" z with a backdoor to Y given X, on a reduced graph:
    // interest = {X, Y} ∪ possible; evidence = {} (parity with pyagrum)
    NodeSet Xset;
    Xset.insert(X);
    NodeSet Yset = possible;
    Yset.insert(Y);
    NodeSet Zempty;
 
    DAG g = Separation::reduceForDSeparation(dag, Xset, Yset, Zempty);
 
    NodeSet impossible;
    NodeSet condX;
    condX.insert(X);
    for (auto z: possible) {
      NodeSet Zs;
      Zs.insert(z);
      if (!Separation::isBackdoorSeparated(g, Zs, NodeSet{Y}, condX)) { impossible.insert(z); }
    }
    for (auto z: impossible) {
      possible.erase(z);
    }
 
    if (possible.empty()) { return out; }
 
    auto cand = _sortedVec(possible);
 
    if (noDiPath) {
      // pyagrum: yield each singleton
      for (auto n: cand) {
        NodeSet Z;
        Z.insert(n);
        out.push_back(Z);
        if (stopAtFirst) { return out; }
      }
    } else {
      const std::size_t N    = cand.size();
      const std::size_t Kmax = (max_cardinality == 0) ? N : std::min(max_cardinality, N);
      for (std::size_t k = 1; k <= Kmax; ++k) {
        std::vector< bool > pick(N, false);
        std::fill_n(pick.begin(), k, true);
        do {
          NodeSet Z;
          for (std::size_t i = 0; i < N; ++i) {
            if (pick[i]) { Z.insert(cand[i]); }
          }
          // (FD-1): must block all directed X->Y paths
          if (!existsUnblockedDirectedPath(dag, X, Y, Z)) {
            if (!only_minimal || _isMinimalFrontdoorAdjustment(dag, X, Y, Z)) {
              out.push_back(Z);
              if (stopAtFirst) { return out; }
            }
          }
        } while (std::prev_permutation(pick.begin(), pick.end()));
      }
    }
 
    std::sort(out.begin(), out.end(), _lexLess);
    out.erase(std::unique(out.begin(),
                          out.end(),
                          [](const NodeSet& a, const NodeSet& b) {
                            return _sortedVec(a) == _sortedVec(b);
                          }),
              out.end());
    return out;
  }

References _isMinimalFrontdoorAdjustment(), backdoorReach(), gum::ArcGraphPart::children(), gum::Set< Key >::contains(), gum::Set< Key >::empty(), gum::Set< Key >::erase(), existsUnblockedDirectedPath(), gum::Set< Key >::insert(), gum::Separation::isBackdoorSeparated(), nodesOnDirectedPaths(), gum::ArcGraphPart::parents(), and gum::Separation::reduceForDSeparation().

Referenced by enumerateFrontdoorSets(), firstFrontdoor(), and gum::CausalModel< GUM_SCALAR >::frontDoor().

Here is the call graph for this function:

Here is the caller graph for this function:

existsUnblockedDirectedPath()

bool gum::DoorCriteria::existsUnblockedDirectedPath ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & Z )

static

Check whether there exists a directed path X->..->Y unblocked by Z.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Start node.
Y	End node.
Z	Conditioning set (nodes that block traversal if encountered).

Returns

True if an unblocked directed path exists from X to Y.

Definition at line 413 of file doorCriteria.cpp.

                                                                   {
    NodeSet visited;
    return _existsUnblockedDirectedPath_(dag, X, Y, Z, visited);
  }

References _existsUnblockedDirectedPath_().

Referenced by enumerateFrontdoorSets(), and satisfiesFrontdoorCriterion().

Here is the call graph for this function:

Here is the caller graph for this function:

firstBackdoor()

INLINE std::optional< NodeSet > gum::DoorCriteria::firstBackdoor ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & excluded_nodes = NodeSet(), std::size_t max_cardinality = 0, bool only_minimal = true )

static

Directly return the first backdoor adjustment set if any.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
excluded_nodes	Nodes to exclude from candidate sets (e.g., latent variables).
max_cardinality	Maximum set size (0 = no limit).
only_minimal	If true, return only minimal adjustment sets.

Returns

std::optional<NodeSet> The first valid backdoor adjustment set found, or std::nullopt if none exists.

Definition at line 48 of file doorCriteria_inl.h.

                                                                                           {
    auto bds
        = enumerateBackdoorSets(dag, X, Y, excluded_nodes, max_cardinality, only_minimal, true);
    if (bds.empty()) { return std::nullopt; }
    return bds.front();
  }

References enumerateBackdoorSets().

Here is the call graph for this function:

firstFrontdoor()

INLINE std::optional< NodeSet > gum::DoorCriteria::firstFrontdoor ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & excluded_nodes = NodeSet(), std::size_t max_cardinality = 0, bool only_minimal = true )

static

Directly return the first frontdoor adjustment set if any.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
excluded_nodes	Nodes to exclude from candidate sets (e.g., latent variables).
max_cardinality	Maximum set size (0 = no limit).
only_minimal	If true, return only minimal adjustment sets.

Returns

std::optional<NodeSet> The first valid frontdoor adjustment set found, or std::nullopt if none exists.

Definition at line 60 of file doorCriteria_inl.h.

                                                                                            {
    auto fds
        = enumerateFrontdoorSets(dag, X, Y, excluded_nodes, max_cardinality, only_minimal, true);
    if (fds.empty()) { return std::nullopt; }
    return fds.front();
  }

References enumerateFrontdoorSets().

Here is the call graph for this function:

hasBackdoorPath()

bool gum::DoorCriteria::hasBackdoorPath ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & Z )

static

Test whether there exists an open backdoor path from X to Y given Z.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
Z	Conditioning set.

Returns

True if there exists at least one unblocked backdoor path.

Definition at line 504 of file doorCriteria.cpp.

                                                                                         {
    NodeSet Xs;
    Xs.insert(X);
    NodeSet Ys;
    Ys.insert(Y);
    return !Separation::isBackdoorSeparated(dag, Xs, Ys, Z);
  }

References gum::Set< Key >::insert(), and gum::Separation::isBackdoorSeparated().

Here is the call graph for this function:

nodesOnDirectedPaths()

std::optional< NodeSet > gum::DoorCriteria::nodesOnDirectedPaths ( const DAG & dag, NodeId X, NodeId Y )

static

Compute nodes lying on some directed path from X to Y.

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Start node.
Y	End node.

Returns

Set of nodes on at least one X->..->Y directed path.

Definition at line 435 of file doorCriteria.cpp.

                                                                                              {
    const NodeSet f = dag.descendants(X);   // forward reach
    const NodeSet r = dag.ancestors(Y);     // reverse reach
 
    if (!f.contains(Y)) return std::nullopt;
 
    NodeSet res;
    // A node is on some X->...->Y path iff reachable from X and can reach Y.
    for (auto n: f)
      if (r.contains(n)) res.insert(n);
 
    // To match pyagrum version:
    // - do not include X
    // - do not include Y
    res.erase(X);
    res.erase(Y);
 
    return res;
  }

References gum::DiGraph::ancestors(), gum::Set< Key >::contains(), gum::DiGraph::descendants(), gum::Set< Key >::erase(), and gum::Set< Key >::insert().

Referenced by enumerateFrontdoorSets().

Here is the call graph for this function:

Here is the caller graph for this function:

satisfiesBackdoorCriterion()

bool gum::DoorCriteria::satisfiesBackdoorCriterion ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & Z )

static

Check if Z satisfies the backdoor criterion relative to (X, Y).

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
Z	Conditioning set.

Returns

True if Z blocks all backdoor paths from X to Y.

Definition at line 110 of file doorCriteria.cpp.

                                                                  {
    // Rule-out illegal contents up front:
    // - Z must not contain X (conditioning on X is not a valid adjustment set)
    // - Z must not contain Y (keep parity with enumeration/universe)
    if (Z.contains(X) || Z.contains(Y)) return false;
 
    // - Z must not contain any descendant of X
    NodeSet descX = dag.descendants(X);
    for (auto dx: descX) {
      if (Z.contains(dx)) return false;
    }
 
    // Backdoor blocking condition in G_{underline X}
    NodeSet Xs;
    Xs.insert(X);
    NodeSet Ys;
    Ys.insert(Y);
    return Separation::isBackdoorSeparated(dag, Xs, Ys, Z);
  }

References gum::Set< Key >::contains(), gum::DiGraph::descendants(), gum::Set< Key >::insert(), and gum::Separation::isBackdoorSeparated().

Referenced by _isMinimalBackdoorAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

satisfiesFrontdoorCriterion()

bool gum::DoorCriteria::satisfiesFrontdoorCriterion ( const DAG & dag, NodeId X, NodeId Y, const NodeSet & Z )

static

Check if Z satisfies the frontdoor criterion relative to (X, Y).

Parameters

dag	Directed acyclic graph representing the causal structure.
X	Cause variable.
Y	Effect variable.
Z	Conditioning set.

Returns

True if Z satisfies all three frontdoor conditions (FD-1, FD-2, FD-3).

Definition at line 133 of file doorCriteria.cpp.

                                                                   {
    if (Z.empty()) return false;
 
    // (FD-1) Z must intercept all directed X->...->Y paths
    if (existsUnblockedDirectedPath(dag, X, Y, Z)) return false;
 
    // (FD-2) Z ∩ backdoor_reach(X) = {}
    NodeSet br = backdoorReach(dag, X);
    for (auto z: Z)
      if (br.contains(z)) return false;
 
    // (FD-3) check on a d-separation reduced graph with interest = Z ∪ {X,Y}
    NodeSet Xset;
    Xset.insert(X);
    NodeSet Yset;
    Yset.insert(Y);
    // interest = X ∪ Y ∪ Z  -> pass Xset, Yset, Z as-is
    DAG reduced = Separation::reduceForDSeparation(dag, Xset, Yset, Z);
 
    NodeSet condX;
    condX.insert(X);
    for (auto z: Z) {
      NodeSet Zs;
      Zs.insert(z);
      // backdoor_path(reduced, z, y, {x}) == !isBackdoorSeparated(reduced, {z}, {y}, {x})
      if (!Separation::isBackdoorSeparated(reduced, Zs, Yset, condX)) return false;
    }
    return true;
  }

References backdoorReach(), gum::Set< Key >::contains(), gum::Set< Key >::empty(), existsUnblockedDirectedPath(), gum::Set< Key >::insert(), gum::Separation::isBackdoorSeparated(), and gum::Separation::reduceForDSeparation().

Referenced by _isMinimalFrontdoorAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• agrum/CM/doorCriteria.h
• agrum/CM/doorCriteria.cpp
• agrum/CM/doorCriteria_inl.h