gum::Counterfactual< GUM_ELEMENT > Class Template Reference

Computes a counterfactual distribution by building a twin model, then evaluating a causal effect on that twin and adapting the result back to the original model’s variables. More...

#include <counterfactual.h>

Collaboration diagram for gum::Counterfactual< GUM_ELEMENT >:

Public Types
using	VarName = std::string
using	ValName = std::string

Public Member Functions
	Counterfactual (const CausalModel< GUM_ELEMENT > &cm, const Set< std::string > &on, const Set< std::string > &whatif, const HashTable< VarName, ValName > &profile=HashTable< VarName, ValName >(), const HashTable< VarName, ValName > &values=HashTable< VarName, ValName >())
	Construct a counterfactual query using variable names.
	Counterfactual (const CausalModel< GUM_ELEMENT > &cm, const NodeSet &onIds, const NodeSet &whatifIds, const HashTable< NodeId, Idx > &profileIds=HashTable< NodeId, Idx >(), const HashTable< NodeId, Idx > &valuesIds=HashTable< NodeId, Idx >())
	Construct a counterfactual query using IDs (nodes/value IDs).
void	run ()
	Rebuild the internal CausalImpact (ctor already calls this).
const CausalModel< GUM_ELEMENT > &	originalModel () const
const CausalModel< GUM_ELEMENT > &	twinModel () const
const CausalImpact< GUM_ELEMENT > &	impact () const
	Symbolic result produced on the twin model.
const Tensor< GUM_ELEMENT > &	value () const
	Numeric result adapted to the original model’s variables.
const Set< std::string > &	on () const
const Set< std::string > &	whatif () const
const HashTable< VarName, ValName > &	profile () const
const HashTable< VarName, ValName > &	values () const
std::string	toString () const

Static Public Member Functions
static CausalModel< GUM_ELEMENT >	counterFactualModel (const CausalModel< GUM_ELEMENT > &cm, const HashTable< VarName, ValName > &profile, const Set< std::string > &whatif)
static CausalModel< GUM_ELEMENT >	counterFactualModel (const CausalModel< GUM_ELEMENT > &cm, const HashTable< NodeId, Idx > &profileIds, const NodeSet &whatifIds)

Private Member Functions
const CausalFormula< GUM_ELEMENT > &	_ciResult () const

Static Private Member Functions
static Tensor< GUM_ELEMENT >	_adaptToOriginalVariables_ (const Tensor< GUM_ELEMENT > &adj, const CausalModel< GUM_ELEMENT > &cm)
static Set< std::string >	_idsToNames_ (const CausalModel< GUM_ELEMENT > &cm, const NodeSet &ids)
static HashTable< VarName, ValName >	_idAssignToNameAssign_ (const CausalModel< GUM_ELEMENT > &cm, const HashTable< NodeId, Idx > &idAssign)

Private Attributes
const CausalModel< GUM_ELEMENT > &	_cm
Set< std::string >	_on
Set< std::string >	_whatif
HashTable< VarName, ValName >	_profile
HashTable< VarName, ValName >	_values
CausalModel< GUM_ELEMENT >	_twin
Tensor< GUM_ELEMENT >	_adaptedValue
std::unique_ptr< CausalImpact< GUM_ELEMENT > >	_ci

Detailed Description

template<GUM_Numeric GUM_ELEMENT>
class gum::Counterfactual< GUM_ELEMENT >

Computes a counterfactual distribution by building a twin model, then evaluating a causal effect on that twin and adapting the result back to the original model’s variables.

High-level workflow:

1. Build the twin causal model with ::counterFactualModel:
   • Start from the observational BN.
   • Identify idiosyncratic variables (parentless nodes) and remove any that are in whatif or latent.
   • Run inference on the original BN with the optional profile evidence and replace the priors of idiosyncratic variables in the twin by their posteriors from the original BN.
2. On the twin model, build a CausalImpact for the query P(on | do(whatif), …) and evaluate it numerically.
3. If values is provided, slice the numeric tensor using only the assignments present in the result (safe partial instantiation).
4. Adapt the evaluated tensor back to the original model by rebuilding a tensor with the same variable names (and order) as produced by the twin evaluation, but bound to the original BN’s variables.

Constructors:

• Names API: Counterfactual(cm, on, whatif, profile, values) where on and whatif are sets of variable names; profile and values are name→label assignments. profile is used as observational evidence when computing posteriors for the idiosyncratic roots; values gives the specific do-assignments when evaluating the effect and for optional numeric slicing.
• IDs API: Counterfactual(cm, onIds, whatifIds, profileIds, valuesIds) same semantics, using node/value identifiers.

Results:

• value() returns the numeric tensor adapted to the original model’s variables (order mirrors the twin evaluation’s variable sequence).
• getResult() exposes the symbolic CausalFormula produced on the twin model (variable names match those of the original BN).

Notes:

• profile and values can be empty.
• values is not required to build the formula; it is used for the twin evaluation and optional numeric slicing.
• Exceptions from evidence insertion, inference, CPT replacement and tensor building may propagate (e.g., unknown variable/label names, inconsistent domains).

Template Parameters

GUM_ELEMENT

Numeric type used in potentials (e.g., double).

Definition at line 102 of file counterfactual.h.

Member Typedef Documentation

ValName

template<GUM_Numeric GUM_ELEMENT>

using gum::Counterfactual< GUM_ELEMENT >::ValName = std::string

Definition at line 105 of file counterfactual.h.

VarName

template<GUM_Numeric GUM_ELEMENT>

using gum::Counterfactual< GUM_ELEMENT >::VarName = std::string

Definition at line 104 of file counterfactual.h.

Constructor & Destructor Documentation

Counterfactual() [1/2]

template<GUM_Numeric GUM_ELEMENT>

gum::Counterfactual< GUM_ELEMENT >::Counterfactual	(	const CausalModel< GUM_ELEMENT > &	cm,
		const Set< std::string > &	on,
		const Set< std::string > &	whatif,
		const HashTable< VarName, ValName > &	profile = HashTable< VarName, ValName >(),
		const HashTable< VarName, ValName > &	values = HashTable< VarName, ValName >() )

Construct a counterfactual query using variable names.

Builds a twin model from cm using profile as observational evidence to update idiosyncratic roots, then evaluates the causal effect P(on | do(whatif), …). If values is provided, the evaluated tensor is optionally sliced by these assignments (only for variables present in the result), and finally adapted to the original BN’s variables.

Parameters

cm	Source causal model (provides the observational BN).
on	Set of variable names to query in the effect.
whatif	Set of variable names intervened by do(·).
profile	Name→label evidence used when computing posteriors in the original BN for idiosyncratic roots. May be empty.
values	Name→label assignments for the intervention values to use during numeric evaluation and optional slicing. May be empty.

Definition at line 53 of file counterfactual_tpl.h.

                                                                                             :
      _cm(cm), _on(on), _whatif(whatif), _profile(profile), _values(values),
      _twin(counterFactualModel(cm, profile, whatif)), _adaptedValue(), _ci(nullptr) {
    run();
  }

References _adaptedValue, _ci, _cm, _on, _profile, _twin, _values, _whatif, counterFactualModel(), on(), profile(), run(), values(), and whatif().

Referenced by Counterfactual().

Here is the call graph for this function:

Here is the caller graph for this function:

Counterfactual() [2/2]

template<GUM_Numeric GUM_ELEMENT>

gum::Counterfactual< GUM_ELEMENT >::Counterfactual	(	const CausalModel< GUM_ELEMENT > &	cm,
		const NodeSet &	onIds,
		const NodeSet &	whatifIds,
		const HashTable< NodeId, Idx > &	profileIds = HashTable< NodeId, Idx >(),
		const HashTable< NodeId, Idx > &	valuesIds = HashTable< NodeId, Idx >() )

Construct a counterfactual query using IDs (nodes/value IDs).

Same semantics as the names-based constructor, but using node identifiers and value identifiers directly.

Parameters

cm	Source causal model.
onIds	Node IDs to query in the effect.
whatifIds	Node IDs to intervene on via do(·).
profileIds	NodeId→ValueId evidence for posterior update of idiosyncratic roots. May be empty.
valuesIds	NodeId→ValueId assignments for the intervention values during numeric evaluation and optional slicing. May be empty.

Definition at line 64 of file counterfactual_tpl.h.

                                                                                             :
      Counterfactual< GUM_ELEMENT >(cm,
                                    _idsToNames_(cm, onIds),
                                    _idsToNames_(cm, whatifIds),
                                    _idAssignToNameAssign_(cm, profileIds),
                                    _idAssignToNameAssign_(cm, valuesIds)) {}

References Counterfactual(), _idAssignToNameAssign_(), and _idsToNames_().

Here is the call graph for this function:

Member Function Documentation

_adaptToOriginalVariables_()

template<GUM_Numeric GUM_ELEMENT>

Tensor< GUM_ELEMENT > gum::Counterfactual< GUM_ELEMENT >::_adaptToOriginalVariables_ ( const Tensor< GUM_ELEMENT > & adj, const CausalModel< GUM_ELEMENT > & cm )

staticprivate

Definition at line 189 of file counterfactual_tpl.h.

                                            {
    Tensor< GUM_ELEMENT > res;
    const auto&           bn = cm.observationalBN();
 
    // keep adj variable order
    for (const auto& v: adj.variablesSequence()) {
      res.add(bn.variableFromName(v->name()));
    }
    res.fillWith(adj);
    return res;
  }

References gum::MultiDimDecorator< GUM_SCALAR >::add(), gum::Tensor< GUM_SCALAR >::fillWith(), gum::CausalModel< GUM_SCALAR >::observationalBN(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

_ciResult()

template<GUM_Numeric GUM_ELEMENT>

const CausalFormula< GUM_ELEMENT > & gum::Counterfactual< GUM_ELEMENT >::_ciResult ( ) const

private

Definition at line 206 of file counterfactual_tpl.h.

                                                                                     {
    return _ci->getResult();   // public accessor in CausalImpact
  }

References _ci.

Referenced by toString().

Here is the caller graph for this function:

_idAssignToNameAssign_()

template<GUM_Numeric GUM_ELEMENT>

HashTable< typename Counterfactual< GUM_ELEMENT >::VarName, typename Counterfactual< GUM_ELEMENT >::ValName > gum::Counterfactual< GUM_ELEMENT >::_idAssignToNameAssign_ ( const CausalModel< GUM_ELEMENT > & cm, const HashTable< NodeId, Idx > & idAssign )

staticprivate

Definition at line 289 of file counterfactual_tpl.h.

                                                      {
    HashTable< VarName, ValName > out;
    const auto&                   bn = cm.observationalBN();
    for (const auto& kv: idAssign) {
      const NodeId nid   = kv.first;
      const Idx    valId = kv.second;
      const auto&  var   = bn.variable(nid);   // reference by id
      out.insert(var.name(), var.label(valId));
    }
    return out;
  }

References gum::HashTable< Key, Val >::insert(), and gum::CausalModel< GUM_SCALAR >::observationalBN().

Referenced by Counterfactual().

Here is the call graph for this function:

Here is the caller graph for this function:

_idsToNames_()

template<GUM_Numeric GUM_ELEMENT>

Set< std::string > gum::Counterfactual< GUM_ELEMENT >::_idsToNames_ ( const CausalModel< GUM_ELEMENT > & cm, const NodeSet & ids )

staticprivate

Definition at line 275 of file counterfactual_tpl.h.

                                                                                         {
    Set< std::string > out;
    const auto&        bn = cm.observationalBN();
    for (auto nid: ids) {
      const auto& var = bn.variable(nid);   // reference by id
      out.insert(var.name());
    }
    return out;
  }

References gum::Set< Key >::insert(), and gum::CausalModel< GUM_SCALAR >::observationalBN().

Referenced by Counterfactual().

Here is the call graph for this function:

Here is the caller graph for this function:

counterFactualModel() [1/2]

template<GUM_Numeric GUM_ELEMENT>

CausalModel< GUM_ELEMENT > gum::Counterfactual< GUM_ELEMENT >::counterFactualModel ( const CausalModel< GUM_ELEMENT > & cm, const HashTable< NodeId, Idx > & profileIds, const NodeSet & whatifIds )

static

Definition at line 127 of file counterfactual_tpl.h.

                                                                                   {
    const auto& origBN = cm.observationalBN();
    // 1) idiosyncratic = parentless \ (whatif ∪ latent)
    NodeSet idiosyncratic;
    for (auto nid: origBN.nodes()) {
      if (origBN.parents(nid).size() == 0) { idiosyncratic.insert(nid); }
    }
    for (auto id: whatifIds) {
      idiosyncratic.erase(id);
    }
    for (auto id: cm.latentVariablesIds()) {
      idiosyncratic.erase(id);
    }
 
    // 2) posterior(idiosyncratic | profile) in ORIGINAL BN
    CausalModel< GUM_ELEMENT > twincm(origBN);
    {
      gum::LazyPropagation< GUM_ELEMENT > ie(&origBN);
      if (!profileIds.empty()) {
        for (const auto& kv: profileIds) {
          const NodeId nid   = kv.first;
          const Idx    valId = kv.second;
          ie.addEvidence(nid, valId);
        }
      }
      ie.makeInference();
      auto& twinBN = twincm.observationalBN();
      for (auto f: idiosyncratic) {
        const auto&                 name   = origBN.variable(f).name();
        const NodeId                twinId = twinBN.idFromName(name);
        const Tensor< GUM_ELEMENT > post   = ie.posterior(f);
        twinBN.cpt(twinId).fillWith(post);
      }
    }
    return twincm;
  }

References gum::GraphicalModelInference< GUM_SCALAR >::addEvidence(), gum::HashTable< Key, Val >::empty(), gum::Set< Key >::erase(), gum::Set< Key >::insert(), gum::CausalModel< GUM_SCALAR >::latentVariablesIds(), gum::GraphicalModelInference< GUM_SCALAR >::makeInference(), gum::CausalModel< GUM_SCALAR >::observationalBN(), and gum::JointTargetedInference< GUM_SCALAR >::posterior().

Here is the call graph for this function:

counterFactualModel() [2/2]

template<GUM_Numeric GUM_ELEMENT>

CausalModel< GUM_ELEMENT > gum::Counterfactual< GUM_ELEMENT >::counterFactualModel ( const CausalModel< GUM_ELEMENT > & cm, const HashTable< VarName, ValName > & profile, const Set< std::string > & whatif )

static

Definition at line 78 of file counterfactual_tpl.h.

                                                 {
    const auto&                origBN = cm.observationalBN();
    CausalModel< GUM_ELEMENT > twincm(origBN);   // copy (serves as clone)
 
    // 1) idiosyncratic = parentless \ (whatif ∪ latent)
    NodeSet whatifIds;
    for (const auto& w: whatif) {
      whatifIds.insert(cm.idFromName(w));
    }
    NodeSet idiosyncratic;
    for (auto nid: origBN.nodes()) {
      if (origBN.parents(nid).size() == 0) { idiosyncratic.insert(nid); }
    }
    for (auto id: whatifIds) {
      idiosyncratic.erase(id);
    }
    for (auto id: cm.latentVariablesIds()) {
      idiosyncratic.erase(id);
    }
 
    // 2) posterior(idiosyncratic | profile) in ORIGINAL BN
    gum::LazyPropagation< GUM_ELEMENT > ie(&origBN);
    if (!profile.empty()) {
      for (const auto& kv: profile) {
        const auto&  varName = kv.first;
        const auto&  valName = kv.second;
        const NodeId nid     = cm.idFromName(varName);
        const auto&  var     = origBN.variable(nid);
        const Idx    valId   = var.index(valName);
        ie.addEvidence(nid, valId);
      }
    }
    ie.makeInference();
    // 3) Replace priors in the twin with posteriors from the original
    auto& twinBN = twincm.observationalBN();
    for (auto f: idiosyncratic) {
      const auto&                 name   = origBN.variable(f).name();
      auto                        twinId = twinBN.idFromName(name);
      const Tensor< GUM_ELEMENT > post   = ie.posterior(f);
      twinBN.cpt(twinId).fillWith(post);
    }
    return twincm;
  }

References gum::GraphicalModelInference< GUM_SCALAR >::addEvidence(), gum::Set< Key >::erase(), gum::CausalModel< GUM_SCALAR >::idFromName(), gum::Set< Key >::insert(), gum::CausalModel< GUM_SCALAR >::latentVariablesIds(), gum::GraphicalModelInference< GUM_SCALAR >::makeInference(), gum::CausalModel< GUM_SCALAR >::observationalBN(), gum::JointTargetedInference< GUM_SCALAR >::posterior(), profile(), and whatif().

Referenced by Counterfactual().

Here is the call graph for this function:

Here is the caller graph for this function:

impact()

template<GUM_Numeric GUM_ELEMENT>

const CausalImpact< GUM_ELEMENT > & gum::Counterfactual< GUM_ELEMENT >::impact

(

)

const

Symbolic result produced on the twin model.

Exposes the CausalImpact built over the twin model. Variable names follow those of the original BN.

Returns

const CausalImpact<GUM_ELEMENT>& The causal formula.

Definition at line 379 of file counterfactual_tpl.h.

                                                                                 {
    return *_ci;
  }

References _ci.

on()

template<GUM_Numeric GUM_ELEMENT>

const Set< std::string > & gum::Counterfactual< GUM_ELEMENT >::on

(

)

const

Definition at line 389 of file counterfactual_tpl.h.

                                                                  {
    return _on;
  }

References _on.

Referenced by Counterfactual().

Here is the caller graph for this function:

originalModel()

template<GUM_Numeric GUM_ELEMENT>

const CausalModel< GUM_ELEMENT > & gum::Counterfactual< GUM_ELEMENT >::originalModel

(

)

const

Definition at line 369 of file counterfactual_tpl.h.

                                                                                       {
    return _cm;
  }

References _cm.

profile()

template<GUM_Numeric GUM_ELEMENT>

const HashTable< typename Counterfactual< GUM_ELEMENT >::VarName, typename Counterfactual< GUM_ELEMENT >::ValName > & gum::Counterfactual< GUM_ELEMENT >::profile

(

)

const

Definition at line 401 of file counterfactual_tpl.h.

                                                   {
    return _profile;
  }

References _profile.

Referenced by Counterfactual(), and counterFactualModel().

Here is the caller graph for this function:

run()

template<GUM_Numeric GUM_ELEMENT>

void gum::Counterfactual< GUM_ELEMENT >::run

(

)

Rebuild the internal CausalImpact (ctor already calls this).

Definition at line 169 of file counterfactual_tpl.h.

                                          {
    // Build symbolic effect on the twin
    _ci = std::make_unique< CausalImpact< GUM_ELEMENT > >(_twin, _on, _whatif);
 
    // Numeric evaluation on the twin
    Tensor< GUM_ELEMENT > adj = _ci->eval();
 
    // Slice by specified intervention values (partial instantiation, safe if some names are absent)
    if (!_values.empty() && adj.nbrDim() > 0) {
      auto I = makeInstantiationFromValues(adj, _values);   // keeps only vars present in `adj`
      if (I.nbrDim() > 0) adj = adj.extract(I);
    }
 
    // Adapt tensor to ORIGINAL model variables
    _adaptedValue = _adaptToOriginalVariables_(adj, _cm);
  }

References _adaptedValue, _adaptToOriginalVariables_(), _ci, _cm, _on, _twin, _values, _whatif, and gum::makeInstantiationFromValues().

Referenced by Counterfactual().

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

template<GUM_Numeric GUM_ELEMENT>

std::string gum::Counterfactual< GUM_ELEMENT >::toString

(

)

const

Definition at line 213 of file counterfactual_tpl.h.

                                                          {
    std::stringstream os;
    os << "[Counterfactual]\n";
 
    os << " on = {";
    {
      bool first = true;
      for (const auto& s: _on) {
        if (!first) os << ", ";
        os << s;
        first = false;
      }
    }
    os << "}\n whatif = {";
    {
      bool first = true;
      for (const auto& s: _whatif) {
        if (!first) os << ", ";
        os << s;
        first = false;
      }
    }
    os << "}\n";
 
    if (!_profile.empty()) {
      os << " profile: ";
      bool first = true;
      for (const auto& [k, v]: _profile) {
        if (!first) os << ", ";
        os << k << "=" << v;
        first = false;
      }
      os << "\n";
    }
 
    if (!_values.empty()) {
      os << " values: ";
      bool first = true;
      for (const auto& [k, v]: _values) {
        if (!first) os << ", ";
        os << k << "=" << v;
        first = false;
      }
      os << "\n";
    }
 
    os << " result (symbolic): ";
    if (_ci && _ci->isIdentified()) os << _ciResult().toString() << "\n";
    else os << "<unidentified>\n";
 
    if (_adaptedValue.nbrDim() > 0) {
      os << " value (adapted to original variables):\n";
      os << _adaptedValue << "\n";
    }
 
    return os.str();
  }

References _adaptedValue, _ci, _ciResult(), _on, _profile, _values, and _whatif.

Here is the call graph for this function:

twinModel()

template<GUM_Numeric GUM_ELEMENT>

const CausalModel< GUM_ELEMENT > & gum::Counterfactual< GUM_ELEMENT >::twinModel

(

)

const

Definition at line 374 of file counterfactual_tpl.h.

                                                                                   {
    return _twin;
  }

References _twin.

value()

template<GUM_Numeric GUM_ELEMENT>

const Tensor< GUM_ELEMENT > & gum::Counterfactual< GUM_ELEMENT >::value

(

)

const

Numeric result adapted to the original model’s variables.

The tensor’s variable sequence mirrors that of the evaluated effect on the twin, but each variable object belongs to the original BN (so downstream code may use original variable references).

Returns

const Tensor<GUM_ELEMENT>& The adapted numeric tensor. It may be empty (nbrDim()==0) if the effect is not identifiable or if evaluation failed.

Definition at line 384 of file counterfactual_tpl.h.

                                                                          {
    return _adaptedValue;
  }

References _adaptedValue.

Referenced by gum::counterfactual().

Here is the caller graph for this function:

values()

template<GUM_Numeric GUM_ELEMENT>

const HashTable< typename Counterfactual< GUM_ELEMENT >::VarName, typename Counterfactual< GUM_ELEMENT >::ValName > & gum::Counterfactual< GUM_ELEMENT >::values

(

)

const

Definition at line 408 of file counterfactual_tpl.h.

                                                  {
    return _values;
  }

References _values.

Referenced by Counterfactual().

Here is the caller graph for this function:

whatif()

template<GUM_Numeric GUM_ELEMENT>

const Set< std::string > & gum::Counterfactual< GUM_ELEMENT >::whatif

(

)

const

Definition at line 394 of file counterfactual_tpl.h.

                                                                      {
    return _whatif;
  }

References _whatif.

Referenced by Counterfactual(), and counterFactualModel().

Here is the caller graph for this function:

Member Data Documentation

_adaptedValue

template<GUM_Numeric GUM_ELEMENT>

Tensor< GUM_ELEMENT > gum::Counterfactual< GUM_ELEMENT >::_adaptedValue

private

Definition at line 224 of file counterfactual.h.

Referenced by Counterfactual(), run(), toString(), and value().

_ci

template<GUM_Numeric GUM_ELEMENT>

std::unique_ptr< CausalImpact< GUM_ELEMENT > > gum::Counterfactual< GUM_ELEMENT >::_ci

private

Definition at line 226 of file counterfactual.h.

Referenced by Counterfactual(), _ciResult(), impact(), run(), and toString().

_cm

template<GUM_Numeric GUM_ELEMENT>

const CausalModel< GUM_ELEMENT >& gum::Counterfactual< GUM_ELEMENT >::_cm

private

Definition at line 217 of file counterfactual.h.

Referenced by Counterfactual(), originalModel(), and run().

_on

template<GUM_Numeric GUM_ELEMENT>

Set< std::string > gum::Counterfactual< GUM_ELEMENT >::_on

private

Definition at line 218 of file counterfactual.h.

Referenced by Counterfactual(), on(), run(), and toString().

_profile

template<GUM_Numeric GUM_ELEMENT>

HashTable< VarName, ValName > gum::Counterfactual< GUM_ELEMENT >::_profile

private

Definition at line 220 of file counterfactual.h.

Referenced by Counterfactual(), profile(), and toString().

_twin

template<GUM_Numeric GUM_ELEMENT>

CausalModel< GUM_ELEMENT > gum::Counterfactual< GUM_ELEMENT >::_twin

private

Definition at line 223 of file counterfactual.h.

Referenced by Counterfactual(), run(), and twinModel().

_values

template<GUM_Numeric GUM_ELEMENT>

HashTable< VarName, ValName > gum::Counterfactual< GUM_ELEMENT >::_values

private

Definition at line 221 of file counterfactual.h.

Referenced by Counterfactual(), run(), toString(), and values().

_whatif

template<GUM_Numeric GUM_ELEMENT>

Set< std::string > gum::Counterfactual< GUM_ELEMENT >::_whatif

private

Definition at line 219 of file counterfactual.h.

Referenced by Counterfactual(), run(), toString(), and whatif().

---

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

• agrum/CM/counterfactual.h
• agrum/CM/counterfactual_tpl.h