Fast Causal Inference — PAG learning via constraint-based methods. More...

#include <FCI.h>

Inheritance diagram for gum::learning::FCI:

Collaboration diagram for gum::learning::FCI:

Public Types
enum class	UCPriority : uint8_t { Standard , Sorted }
	Controls how collider candidates are ordered before orientation. More...
enum class	ApproximationSchemeSTATE : char { Undefined , Continue , Epsilon , Rate , Limit , TimeLimit , Stopped }
	The different state of an approximation scheme. More...

Public Member Functions
Constructors / Destructors
	FCI ()
	FCI (const FCI &)=default
	FCI (FCI &&) noexcept
	~FCI () override
FCI &	operator= (const FCI &)
FCI &	operator= (FCI &&) noexcept
FCI-specific parameterisation
void	setMaxPathLength (Size maxLen)
	maximum path length for R4 discriminating-path search; Size(-1) = unlimited
Size	maxPathLength () const
	maximum path length for R4 discriminating-path search; Size(-1) = unlimited
Learning
PAG	learnPAG (MixedGraph graph)
	primary FCI output: learn a PAG from the given node-only or partial graph
MixedGraph	learnMixedStructure (MixedGraph graph) override
	bridge for learnDAG/learnPDAG: runs learnPAG then converts via toMixedGraph()
std::vector< NodeId >	possibleDSep (const PAG &pag, NodeId x, NodeId y) const
	learnSkeleton() inherited from CIBasedLearning
CI test injection
void	setIndependenceTest (IndependenceTest &test)
	inject independence test (non-owning: caller manages lifetime)
Parameterisation
void	setAlpha (double alpha)
	maximum conditioning set size; Size(-1) = unlimited (default)
double	alpha () const
	maximum conditioning set size; Size(-1) = unlimited (default)
void	setMaxCondSetSize (Size max_k)
	maximum conditioning set size; Size(-1) = unlimited (default)
void	setStable (bool stable)
	stable mode: defer edge removals until end of each depth (default: true)
void	setExhaustiveSepSet (bool exhaustive)
	exhaustive sepset mode: accumulate union of all separating sets found at each depth, rather than stopping at the first (default: false)
bool	exhaustiveSepSet () const
	maximum conditioning set size; Size(-1) = unlimited (default)
void	setUCPriority (UCPriority p)
	collider candidate ordering (default: Standard)
UCPriority	ucPriority () const
	maximum conditioning set size; Size(-1) = unlimited (default)
Learning
MixedGraph	learnSkeleton (MixedGraph graph) override
	Phase 1: skeleton discovery via conditional independence tests.
Constraint setters
void	setForbiddenGraph (const gum::DiGraph &forbidGraph)
void	setMandatoryGraph (const gum::DAG &mandaGraph)
void	setMaxIndegree (gum::Size n)
void	addConstraints (const HashTable< std::pair< NodeId, NodeId >, char > &constraints)
const std::vector< Arc >	latentVariables () const
Learning — template methods (call the pure virtual interface)
PDAG	learnPDAG (MixedGraph graph)
	learns the essential graph (CPDAG)
DAG	learnDAG (MixedGraph graph)
	learns a DAG
template<GUM_Numeric GUM_SCALAR = double, typename PARAM_ESTIMATOR>
BayesNet< GUM_SCALAR >	learnBN (PARAM_ESTIMATOR &estimator, MixedGraph graph)
	learns structure then estimates parameters
Getters and setters
void	setEpsilon (double eps) override
	Given that we approximate f(t), stopping criterion on \|f(t+1)-f(t)\|.
double	epsilon () const override
	Returns the value of epsilon.
void	disableEpsilon () override
	Disable stopping criterion on epsilon.
void	enableEpsilon () override
	Enable stopping criterion on epsilon.
bool	isEnabledEpsilon () const override
	Returns true if stopping criterion on epsilon is enabled, false otherwise.
void	setMinEpsilonRate (double rate) override
	Given that we approximate f(t), stopping criterion on d/dt(\|f(t+1)-f(t)\|).
double	minEpsilonRate () const override
	Returns the value of the minimal epsilon rate.
void	disableMinEpsilonRate () override
	Disable stopping criterion on epsilon rate.
void	enableMinEpsilonRate () override
	Enable stopping criterion on epsilon rate.
bool	isEnabledMinEpsilonRate () const override
	Returns true if stopping criterion on epsilon rate is enabled, false otherwise.
void	setMaxIter (Size max) override
	Stopping criterion on number of iterations.
Size	maxIter () const override
	Returns the criterion on number of iterations.
void	disableMaxIter () override
	Disable stopping criterion on max iterations.
void	enableMaxIter () override
	Enable stopping criterion on max iterations.
bool	isEnabledMaxIter () const override
	Returns true if stopping criterion on max iterations is enabled, false otherwise.
void	setMaxTime (double timeout) override
	Stopping criterion on timeout.
double	maxTime () const override
	Returns the timeout (in seconds).
double	currentTime () const override
	Returns the current running time in second.
void	disableMaxTime () override
	Disable stopping criterion on timeout.
void	enableMaxTime () override
	Enable stopping criterion on timeout.
bool	isEnabledMaxTime () const override
	Returns true if stopping criterion on timeout is enabled, false otherwise.
void	setPeriodSize (Size p) override
	How many samples between two stopping is enable.
Size	periodSize () const override
	Returns the period size.
void	setVerbosity (bool v) override
	Set the verbosity on (true) or off (false).
bool	verbosity () const override
	Returns true if verbosity is enabled.
ApproximationSchemeSTATE	stateApproximationScheme () const override
	Returns the approximation scheme state.
Size	nbrIterations () const override
	Returns the number of iterations.
const std::vector< double > &	history () const override
	Returns the scheme history.
void	initApproximationScheme ()
	Initialise the scheme.
bool	startOfPeriod () const
	Returns true if we are at the beginning of a period (compute error is mandatory).
void	updateApproximationScheme (unsigned int incr=1)
	Update the scheme w.r.t the new error and increment steps.
Size	remainingBurnIn () const
	Returns the remaining burn in.
void	stopApproximationScheme ()
	Stop the approximation scheme.
bool	continueApproximationScheme (double error)
	Update the scheme w.r.t the new error.
Getters and setters
std::string	messageApproximationScheme () const
	Returns the approximation scheme message.

Public Attributes
Signaler< gum::NodeId, gum::NodeId, std::string, std::string >	onStructuralModification
Signaler< Size, double, double >	onProgress
	Progression, error and time.
Signaler< std::string_view >	onStop
	Criteria messageApproximationScheme.

Protected Member Functions
void	resolveOrientConflict_ (NodeId src, NodeId dst) override
	conflict hook override: FCI leaves circle marks — orientation conflicts are not recorded as latent couples here (only final ↔ edges in Phase 6 are)
Collider orientation (shared between PC and FCI Phase 2/4)
MixedGraph	orientUnshieldedColliders_ (MixedGraph graph)
	orient unshielded colliders in graph and return the updated graph
void	orientColliderArm_ (MixedGraph &graph, NodeId src, NodeId dst)
	orient one arm (src → dst) of a collider; calls resolveOrientConflict_ on conflict
Constraint checks
bool	isForbiddenArc_ (NodeId x, NodeId y) const
bool	isForbiddenEdge_ (NodeId x, NodeId y) const
bool	isMaxIndegree_ (const MixedGraph &graph, NodeId x)
bool	isArcValid_ (const MixedGraph &graph, NodeId x, NodeId y)

Protected Attributes
double	current_epsilon_
	Current epsilon.
double	last_epsilon_
	Last epsilon value.
double	current_rate_
	Current rate.
Size	current_step_
	The current step.
Timer	timer_
	The timer.
ApproximationSchemeSTATE	current_state_
	The current state.
std::vector< double >	history_
	The scheme history, used only if verbosity == true.
double	eps_
	Threshold for convergence.
bool	enabled_eps_
	If true, the threshold convergence is enabled.
double	min_rate_eps_
	Threshold for the epsilon rate.
bool	enabled_min_rate_eps_
	If true, the minimal threshold for epsilon rate is enabled.
double	max_time_
	The timeout.
bool	enabled_max_time_
	If true, the timeout is enabled.
Size	max_iter_
	The maximum iterations.
bool	enabled_max_iter_
	If true, the maximum iterations stopping criterion is enabled.
Size	burn_in_
	Number of iterations before checking stopping criteria.
Size	period_size_
	Checking criteria frequency.
bool	verbosity_
	If true, verbosity is enabled.
Shared state
IndependenceTest *	test_ {nullptr}
double	alpha_ = 0.05
Size	maxCondSetSize_ = Size(-1)
bool	stable_ = true
bool	exhaustiveSepSet_ = false
UCPriority	ucPriority_ = UCPriority::Standard
HashTable< std::pair< NodeId, NodeId >, SepSetEntry_ >	sepSet_

Private Member Functions
void	orientCollidersOnPAG_ (PAG &pag, const MixedGraph &topology)
	Phase 2 / Phase 4: orient unshielded colliders directly on the PAG. topology is used for unshielded-triple detection (adjacency queries only).
std::vector< NodeId >	computePossibleDSep_ (const PAG &pag, NodeId x, NodeId y) const
	Phase 3: return all nodes on possible-d-sep paths from x toward y (excl. x, y).
void	possibleDSepPhase_ (PAG &pag)
	Phase 3: prune PAG edges using possibleDSep conditioning sets.
bool	ruleR1_ (PAG &pag) const
	away from collider
bool	ruleR2_ (PAG &pag) const
	away from cycle
bool	ruleR3_ (PAG &pag) const
	double triangle
bool	ruleR5_ (PAG &pag) const
	uncovered circle path → undirected
bool	ruleR6_ (PAG &pag) const
	tail propagation from undirected edge
bool	ruleR7_ (PAG &pag) const
	tail propagation from A-oB
bool	ruleR4_ (PAG &pag) const
	discriminating path (uses CI test)
bool	ruleR8_ (PAG &pag) const
	away from ancestor (graph only)
bool	ruleR9_ (PAG &pag) const
	away from ancestor via uncovered pd-path
bool	ruleR10_ (PAG &pag) const
	away from ancestor via two semi-directed paths
void	applyOrientationRules_ (PAG &pag) const
	Phase 5: fixed-point loop over all orientation rules R1–R10.
bool	doDdpOrientation_ (PAG &pag, NodeId d, NodeId a, NodeId b, NodeId c, const HashTable< NodeId, NodeId > &previous) const
	R4 helper: orient B,C in a detected discriminating path D..A,B,C.
void	stopScheme_ (ApproximationSchemeSTATE new_state)
	Stop the scheme given a new state.

Private Attributes
Size	maxPathLength_ = Size(-1)

Common state (accessible to subclasses)
gum::Size	_maxIndegree_ {std::numeric_limits< gum::Size >::max()}
gum::DiGraph	_forbiddenGraph_
gum::DAG	_mandatoryGraph_
HashTable< std::pair< NodeId, NodeId >, char >	_initialMarks_
std::vector< Arc >	_latentCouples_
int	_maxLog_ {100}
const std::vector< NodeId >	_emptySet_

Graph utilities
void	orientDoubleHeadedArcs_ (MixedGraph &mg)
	Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.
std::vector< ThreePoints >	unshieldedTriples_ (const MixedGraph &graph)
	Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.
void	applyStructuralConstraints_ (MixedGraph &graph)
	Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.
MixedGraph	initGraph_ (const MixedGraph &template_graph)
	Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.
gum::MeekRules	meekRules_
	Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.
static bool	_existsDirectedPath_ (const MixedGraph &graph, NodeId n1, NodeId n2)
	Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.
static bool	_existsNonTrivialDirectedPath_ (const MixedGraph &graph, NodeId n1, NodeId n2)
	Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Detailed Description

Fast Causal Inference — PAG learning via constraint-based methods.

Phases:

Skeleton discovery (inherited from CIBasedLearning)
Initial PAG + unshielded colliders oriented as arrowheads
possibleDSep pruning (Phase 3 — to be added in later step)
Reset + re-orient colliders after possibleDSep (Phase 4 — later)
Orientation rules R1–R10 (Phase 5 — later)
Collect latentCouples from final PAG (Phase 6 — later)

learnMixedStructure() bridges to learnDAG/learnPDAG via toMixedGraph().

Definition at line 79 of file FCI.h.

Member Enumeration Documentation

◆ ApproximationSchemeSTATE

enum class gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE : char

stronginherited

The different state of an approximation scheme.

Enumerator
Undefined
Continue
Epsilon
Rate
Limit
TimeLimit
Stopped

Definition at line 87 of file IApproximationSchemeConfiguration.h.

                                        : char {
      Undefined,
      Continue,
      Epsilon,
      Rate,
      Limit,
      TimeLimit,
      Stopped
    };

◆ UCPriority

enum class gum::learning::CIBasedLearning::UCPriority : uint8_t

stronginherited

Controls how collider candidates are ordered before orientation.

Enumerator
Standard	process triples in natural traversal order
Sorted	descending p-value order (strongest evidence first)

Definition at line 84 of file CIBasedLearning.h.

                            : uint8_t {
        Standard,   
        Sorted,     
      };

Constructor & Destructor Documentation

◆ FCI() [1/3]

gum::learning::FCI::FCI ( )

default

Referenced by FCI(), FCI(), ~FCI(), operator=(), and operator=().

Here is the caller graph for this function:

◆ FCI() [2/3]

gum::learning::FCI::FCI ( const FCI & )

default

References FCI().

Here is the call graph for this function:

◆ FCI() [3/3]

gum::learning::FCI::FCI ( FCI && from )

noexcept

Definition at line 59 of file FCI.cpp.

59 :

60 CIBasedLearning(std::move(from)), maxPathLength_(from.maxPathLength_) {}

gum::learning::CIBasedLearning::CIBasedLearning

CIBasedLearning()

gum::learning::FCI::maxPathLength_

Size maxPathLength_

Definition FCI.h:165

References gum::learning::CIBasedLearning::CIBasedLearning(), FCI(), and maxPathLength_.

Here is the call graph for this function:

◆ ~FCI()

gum::learning::FCI::~FCI ( )

overridedefault

References FCI(), applyOrientationRules_(), computePossibleDSep_(), doDdpOrientation_(), learnMixedStructure(), learnPAG(), maxPathLength(), orientCollidersOnPAG_(), possibleDSep(), possibleDSepPhase_(), resolveOrientConflict_(), ruleR10_(), ruleR1_(), ruleR2_(), ruleR3_(), ruleR4_(), ruleR5_(), ruleR6_(), ruleR7_(), ruleR8_(), ruleR9_(), and setMaxPathLength().

Here is the call graph for this function:

Member Function Documentation

◆ _existsDirectedPath_()

bool gum::learning::ConstraintBasedLearning::_existsDirectedPath_	(	const MixedGraph &	graph,
		NodeId	n1,
		NodeId	n2 )

staticprotectedinherited

Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Definition at line 180 of file ConstraintBasedLearning.cpp.

                                                                             {
      List< NodeId > nodeFIFO;
      Set< NodeId >  mark;
 
      mark.insert(n2);
      nodeFIFO.pushBack(n2);
 
      NodeId current;
      while (!nodeFIFO.empty()) {
        current = nodeFIFO.front();
        nodeFIFO.popFront();
        for (const auto new_one: graph.parents(current)) {
          if (graph.existsArc(current, new_one)) continue;   // double arc — skip
          if (new_one == n1) return true;
          if (mark.exists(new_one)) continue;
          mark.insert(new_one);
          nodeFIFO.pushBack(new_one);
        }
      }
      return false;
    }

References gum::List< Val >::empty(), gum::Set< Key >::exists(), gum::List< Val >::front(), gum::Set< Key >::insert(), gum::List< Val >::popFront(), and gum::List< Val >::pushBack().

Referenced by _existsNonTrivialDirectedPath_(), gum::learning::Miic::_propagatingOrientationMiic_(), gum::learning::Miic::orientationMiic_(), gum::learning::CIBasedLearning::orientColliderArm_(), and orientDoubleHeadedArcs_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _existsNonTrivialDirectedPath_()

bool gum::learning::ConstraintBasedLearning::_existsNonTrivialDirectedPath_	(	const MixedGraph &	graph,
		NodeId	n1,
		NodeId	n2 )

staticprotectedinherited

Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Definition at line 169 of file ConstraintBasedLearning.cpp.

                                                                                       {
      for (const auto parent: graph.parents(n2)) {
        if (graph.existsArc(n2, parent)) continue;   // double arc — skip
        if (parent == n1) continue;                  // trivial path — not counted
        if (_existsDirectedPath_(graph, n1, parent)) return true;
      }
      return false;
    }

References _existsDirectedPath_().

Referenced by gum::learning::Miic::_orientingVstructureMiic_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addConstraints()

void gum::learning::ConstraintBasedLearning::addConstraints ( const HashTable< std::pair< NodeId, NodeId >, char > & constraints )

inherited

Definition at line 124 of file ConstraintBasedLearning.cpp.

                                                                         {
      _initialMarks_ = constraints;
    }

References _initialMarks_.

◆ alpha()

double gum::learning::CIBasedLearning::alpha ( ) const

inherited

maximum conditioning set size; Size(-1) = unlimited (default)

Definition at line 108 of file CIBasedLearning.cpp.

108{ return alpha_; }

gum::learning::CIBasedLearning::alpha_

double alpha_

Definition CIBasedLearning.h:181

References alpha_.

Referenced by ~CIBasedLearning(), and setAlpha().

Here is the caller graph for this function:

◆ applyOrientationRules_()

void gum::learning::FCI::applyOrientationRules_ ( PAG & pag ) const

private

Phase 5: fixed-point loop over all orientation rules R1–R10.

Definition at line 797 of file FCI.cpp.

                                                 {
    bool changed = true;
    while (changed) {
      changed = false;
      changed |= ruleR1_(pag);
      changed |= ruleR2_(pag);
      changed |= ruleR3_(pag);
      changed |= ruleR4_(pag);
      changed |= ruleR5_(pag);
      changed |= ruleR6_(pag);
      changed |= ruleR7_(pag);
      changed |= ruleR8_(pag);
      changed |= ruleR9_(pag);
      changed |= ruleR10_(pag);
    }
  }

References ruleR10_(), ruleR1_(), ruleR2_(), ruleR3_(), ruleR4_(), ruleR5_(), ruleR6_(), ruleR7_(), ruleR8_(), and ruleR9_().

Referenced by ~FCI(), and learnPAG().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ applyStructuralConstraints_()

void gum::learning::ConstraintBasedLearning::applyStructuralConstraints_ ( MixedGraph & graph )

protectedinherited

Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Definition at line 250 of file ConstraintBasedLearning.cpp.

                                                                               {
      for (const auto& arc: _mandatoryGraph_.arcs()) {
        if (graph.existsEdge(arc.head(), arc.tail())) graph.eraseEdge(Edge(arc.head(), arc.tail()));
        if (!graph.existsArc(arc.tail(), arc.head())) {
          GUM_SL_EMIT(arc.tail(),
                      arc.head(),
                      "Add Arc" << arc.tail() << "->" << arc.head(),
                      "Mandatory")
          graph.addArc(arc.tail(), arc.head());
        }
      }
      for (const Arc& arc: _forbiddenGraph_.arcs()) {
        if (graph.existsEdge(Edge(arc.tail(), arc.head()))) {
          graph.eraseEdge(Edge(arc.tail(), arc.head()));
          graph.addArc(arc.head(), arc.tail());
          GUM_SL_EMIT(arc.head(),
                      arc.tail(),
                      "Add Arc" << arc.head() << "->" << arc.tail(),
                      "Forbidden in the other orientation")
        }
      }
    }

References _forbiddenGraph_, _mandatoryGraph_, and GUM_SL_EMIT.

Referenced by gum::learning::PC::learnMixedStructure(), gum::learning::FCI::learnPAG(), and gum::learning::Miic::orientationMiic_().

Here is the caller graph for this function:

◆ computePossibleDSep_()

std::vector< NodeId > gum::learning::FCI::computePossibleDSep_	(	const PAG &	pag,
		NodeId	x,
		NodeId	y ) const

private

Phase 3: return all nodes on possible-d-sep paths from x toward y (excl. x, y).

Definition at line 248 of file FCI.cpp.

                                                                                        {
    std::set< NodeId >                        result;
    std::queue< std::pair< NodeId, NodeId > > bfsQueue;
    std::set< std::pair< NodeId, NodeId > >   visited;
 
    for (const NodeId b: pag.neighbours(x)) {
      if (b == y) { continue; }
      if (visited.insert({x, b}).second) {
        bfsQueue.emplace(x, b);
        result.insert(b);
      }
    }
 
    while (!bfsQueue.empty()) {
      const auto [a, b] = bfsQueue.front();
      bfsQueue.pop();
 
      for (const NodeId c: pag.neighbours(b)) {
        if (c == x || c == y || c == a) { continue; }
        // expand if B is a definite collider on (A, B, C) or A and C are adjacent
        // (Zhang 2008 / Colombo et al. criterion)
        if (pag.isDefCollider(a, b, c) || pag.existsEdge(a, c)) {
          if (visited.insert({b, c}).second) {
            bfsQueue.emplace(b, c);
            // FIX #3: only add c to PossibleDSep if it has a semi-directed path
            // back toward x or b (Zhang 2008 §3.2 filter).
            if (existsSemiDirectedPath_(pag, c, x) || existsSemiDirectedPath_(pag, c, b)) {
              result.insert(c);
            }
          }
        }
      }
    }
 
    result.erase(x);
    result.erase(y);
    return {result.begin(), result.end()};
  }

References gum::EdgeGraphPart::existsEdge(), gum::PAG::isDefCollider(), and gum::EdgeGraphPart::neighbours().

Referenced by ~FCI(), possibleDSep(), and possibleDSepPhase_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ continueApproximationScheme()

bool gum::ApproximationScheme::continueApproximationScheme ( double error )

inherited

Update the scheme w.r.t the new error.

Test the stopping criterion that are enabled.

Parameters

error The new error value.

Returns: false if state become != ApproximationSchemeSTATE::Continue

Exceptions

OperationNotAllowed Raised if state != ApproximationSchemeSTATE::Continue.

Definition at line 69 of file approximationScheme.cpp.

                                                                    {
    // For coherence, we fix the time used in the method
 
    double timer_step = timer_.step();
 
    if (enabled_max_time_) {
      if (timer_step > max_time_) {
        stopScheme_(ApproximationSchemeSTATE::TimeLimit);
        return false;
      }
    }
 
    if (!startOfPeriod()) { return true; }
 
    if (current_state_ != ApproximationSchemeSTATE::Continue) {
      GUM_ERROR(
          OperationNotAllowed,
          "state of the approximation scheme is not correct : " << messageApproximationScheme());
    }
 
    if (verbosity()) { history_.push_back(error); }
 
    if (enabled_max_iter_) {
      if (current_step_ >= max_iter_) {
        stopScheme_(ApproximationSchemeSTATE::Limit);
        return false;
      }
    }
 
    last_epsilon_    = current_epsilon_;
    current_epsilon_ = error;   // eps rate isEnabled needs it so affectation was
    // moved from eps isEnabled below
 
    if (enabled_eps_) {
      if (current_epsilon_ <= eps_) {
        stopScheme_(ApproximationSchemeSTATE::Epsilon);
        return false;
      }
    }
 
    if (last_epsilon_ >= 0.) {
      if (current_epsilon_ > .0) {
        // ! current_epsilon_ can be 0. AND epsilon
        // isEnabled can be disabled !
        current_rate_ = std::fabs((current_epsilon_ - last_epsilon_) / current_epsilon_);
      }
      // limit with current eps ---> 0 is | 1 - ( last_eps / 0 ) | --->
      // infinity the else means a return false if we isEnabled the rate below,
      // as we would have returned false if epsilon isEnabled was enabled
      else {
        current_rate_ = min_rate_eps_;
      }
 
      if (enabled_min_rate_eps_) {
        if (current_rate_ <= min_rate_eps_) {
          stopScheme_(ApproximationSchemeSTATE::Rate);
          return false;
        }
      }
    }
 
    if (stateApproximationScheme() == ApproximationSchemeSTATE::Continue) {
      if (onProgress.hasListener()) {
        GUM_EMIT3(onProgress, current_step_, current_epsilon_, timer_step);
      }
 
      return true;
    } else {
      return false;
    }
  }

References gum::IApproximationSchemeConfiguration::Continue, current_epsilon_, current_rate_, current_state_, current_step_, enabled_eps_, enabled_max_iter_, enabled_max_time_, enabled_min_rate_eps_, eps_, gum::IApproximationSchemeConfiguration::Epsilon, GUM_EMIT3, GUM_ERROR, history_, last_epsilon_, gum::IApproximationSchemeConfiguration::Limit, max_iter_, max_time_, gum::IApproximationSchemeConfiguration::messageApproximationScheme(), min_rate_eps_, gum::IApproximationSchemeConfiguration::onProgress, gum::IApproximationSchemeConfiguration::Rate, startOfPeriod(), stateApproximationScheme(), stopScheme_(), gum::IApproximationSchemeConfiguration::TimeLimit, timer_, and verbosity().

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::GreedyThickThinning::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::SamplingInference< GUM_SCALAR >::loopApproxInference_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByOrderedArcs_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByRandomOrder_(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceNodeToNeighbours_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ currentTime()

INLINE double gum::ApproximationScheme::currentTime ( ) const

overridevirtualinherited

Returns the current running time in second.

Returns: Returns the current running time in second.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 137 of file approximationScheme_inl.h.

137{ return timer_.step(); }

References timer_.

◆ disableEpsilon()

INLINE void gum::ApproximationScheme::disableEpsilon ( )

overridevirtualinherited

Disable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 75 of file approximationScheme_inl.h.

75{ enabled_eps_ = false; }

References enabled_eps_.

Referenced by gum::learning::EMApproximationScheme::EMApproximationScheme(), and gum::learning::EMApproximationScheme::setMinEpsilonRate().

Here is the caller graph for this function:

◆ disableMaxIter()

INLINE void gum::ApproximationScheme::disableMaxIter ( )

overridevirtualinherited

Disable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 116 of file approximationScheme_inl.h.

116{ enabled_max_iter_ = false; }

References enabled_max_iter_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing(), and gum::learning::GreedyThickThinning::GreedyThickThinning().

Here is the caller graph for this function:

◆ disableMaxTime()

INLINE void gum::ApproximationScheme::disableMaxTime ( )

overridevirtualinherited

Disable stopping criterion on timeout.

Returns: Disable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 140 of file approximationScheme_inl.h.

140{ enabled_max_time_ = false; }

References enabled_max_time_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing(), and gum::learning::GreedyThickThinning::GreedyThickThinning().

Here is the caller graph for this function:

◆ disableMinEpsilonRate()

INLINE void gum::ApproximationScheme::disableMinEpsilonRate ( )

overridevirtualinherited

Disable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 96 of file approximationScheme_inl.h.

96{ enabled_min_rate_eps_ = false; }

References enabled_min_rate_eps_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::learning::GreedyThickThinning::GreedyThickThinning(), gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), and gum::learning::EMApproximationScheme::setEpsilon().

Here is the caller graph for this function:

◆ doDdpOrientation_()

bool gum::learning::FCI::doDdpOrientation_	(	PAG &	pag,
		NodeId	d,
		NodeId	a,
		NodeId	b,
		NodeId	c,
		const HashTable< NodeId, NodeId > &	previous ) const

private

R4 helper: orient B,C in a detected discriminating path D..A,B,C.

Definition at line 539 of file FCI.cpp.

                                                                                 {
    // Reconstruct conditioning set: follow previous from d toward b
    std::vector< NodeId > path;
    NodeId                cur = d;
    while (previous.exists(cur)) {
      cur = previous[cur];
      path.push_back(cur);
    }
    // path = [previous[d], ..., b]
 
    const double pval1 = test_->statistics(d, c, path).second;
    const bool   ind1  = pval1 > alpha_;
 
    std::vector< NodeId > path_no_b;
    for (const NodeId n: path) {
      if (n != b) { path_no_b.push_back(n); }
    }
    const double pval2 = test_->statistics(d, c, path_no_b).second;
    const bool   ind2  = pval2 > alpha_;
 
    bool use_b_in_sep;
    if (!ind1 && !ind2) {
      // fall back to existing sepSet
      const bool has_dc = sepSet_.exists({d, c});
      const bool has_cd = sepSet_.exists({c, d});
      if (!has_dc && !has_cd) { return false; }
      const auto& cond = has_dc ? sepSet_[{d, c}].cond : sepSet_[{c, d}].cond;
      use_b_in_sep     = (std::ranges::find(cond, b) != cond.end());
    } else {
      use_b_in_sep = ind1;
    }
 
    if (use_b_in_sep) {
      pag.setMarkAt(c, b, EdgeMark::Tail);   // B→C: tail at B from C
      return true;
    }
    bool any = false;
    if (!isForbiddenArc_(a, b)) {
      pag.setMarkAt(a, b, EdgeMark::Arrowhead);
      any = true;
    }
    if (!isForbiddenArc_(c, b)) {
      pag.setMarkAt(c, b, EdgeMark::Arrowhead);
      any = true;
    }
    return any;
  }

References gum::learning::CIBasedLearning::alpha_, gum::Arrowhead, gum::HashTable< Key, Val >::exists(), gum::learning::ConstraintBasedLearning::isForbiddenArc_(), gum::learning::CIBasedLearning::sepSet_, gum::PAG::setMarkAt(), gum::Tail, and gum::learning::CIBasedLearning::test_.

Referenced by ~FCI(), and ruleR4_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enableEpsilon()

INLINE void gum::ApproximationScheme::enableEpsilon ( )

overridevirtualinherited

Enable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 78 of file approximationScheme_inl.h.

78{ enabled_eps_ = true; }

References enabled_eps_.

◆ enableMaxIter()

INLINE void gum::ApproximationScheme::enableMaxIter ( )

overridevirtualinherited

Enable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 119 of file approximationScheme_inl.h.

119{ enabled_max_iter_ = true; }

References enabled_max_iter_.

◆ enableMaxTime()

INLINE void gum::ApproximationScheme::enableMaxTime ( )

overridevirtualinherited

Enable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 143 of file approximationScheme_inl.h.

143{ enabled_max_time_ = true; }

References enabled_max_time_.

◆ enableMinEpsilonRate()

INLINE void gum::ApproximationScheme::enableMinEpsilonRate ( )

overridevirtualinherited

Enable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 99 of file approximationScheme_inl.h.

99{ enabled_min_rate_eps_ = true; }

References enabled_min_rate_eps_.

Referenced by gum::learning::EMApproximationScheme::EMApproximationScheme(), and gum::GibbsBNdistance< GUM_SCALAR >::computeKL_().

Here is the caller graph for this function:

◆ epsilon()

INLINE double gum::ApproximationScheme::epsilon ( ) const

overridevirtualinherited

Returns the value of epsilon.

Returns: Returns the value of epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 72 of file approximationScheme_inl.h.

72{ return eps_; }

References eps_.

Referenced by gum::ImportanceSampling< GUM_SCALAR >::onContextualize_(), and gum::ImportanceSampling< GUM_SCALAR >::unsharpenBN_().

Here is the caller graph for this function:

◆ exhaustiveSepSet()

bool gum::learning::CIBasedLearning::exhaustiveSepSet ( ) const

inherited

maximum conditioning set size; Size(-1) = unlimited (default)

Definition at line 116 of file CIBasedLearning.cpp.

116{ return exhaustiveSepSet_; }

gum::learning::CIBasedLearning::exhaustiveSepSet_

bool exhaustiveSepSet_

Definition CIBasedLearning.h:184

References exhaustiveSepSet_.

Referenced by ~CIBasedLearning().

Here is the caller graph for this function:

◆ history()

INLINE const std::vector< double > & gum::ApproximationScheme::history ( ) const

overridevirtualinherited

Returns the scheme history.

Returns: Returns the scheme history.

Exceptions

OperationNotAllowed Raised if the scheme did not performed or if verbosity is set to false.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 179 of file approximationScheme_inl.h.

                                                                       {
    if (stateApproximationScheme() == ApproximationSchemeSTATE::Undefined) {
      GUM_ERROR(OperationNotAllowed, "state of the approximation scheme is udefined")
    }
 
    if (!verbosity()) GUM_ERROR(OperationNotAllowed, "No history when verbosity=false")
 
    return history_;
  }

References GUM_ERROR, stateApproximationScheme(), and gum::IApproximationSchemeConfiguration::Undefined.

Here is the call graph for this function:

◆ initApproximationScheme()

INLINE void gum::ApproximationScheme::initApproximationScheme ( )

inherited

Initialise the scheme.

Definition at line 190 of file approximationScheme_inl.h.

                                                           {
    current_state_   = ApproximationSchemeSTATE::Continue;
    current_step_    = 0;
    current_epsilon_ = current_rate_ = -1.0;
    history_.clear();
    timer_.reset();
  }

References ApproximationScheme(), gum::IApproximationSchemeConfiguration::Continue, current_state_, current_step_, and initApproximationScheme().

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), initApproximationScheme(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::GreedyThickThinning::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::SamplingInference< GUM_SCALAR >::loopApproxInference_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInference(), and gum::SamplingInference< GUM_SCALAR >::onStateChanged_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initGraph_()

MixedGraph gum::learning::ConstraintBasedLearning::initGraph_ ( const MixedGraph & template_graph )

protectedinherited

Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Definition at line 273 of file ConstraintBasedLearning.cpp.

                                                                                   {
      MixedGraph graph;
      for (NodeId n: template_graph.nodes())
        graph.addNodeWithId(n);
 
      auto addEdgeIfAllowed = [&](NodeId x, NodeId y) {
        if (x > y) std::swap(x, y);
        if (isForbiddenEdge_(x, y))
          GUM_SL_EMIT(x, y, "Remove " << x << " - " << y, "Constraints : Forbidden edge")
        else graph.addEdge(x, y);
      };
 
      if (template_graph.edges().empty()) {
        // node-only template: constraint-based learning always starts from complete graph
        const std::vector< NodeId > nodes(template_graph.nodes().begin(),
                                          template_graph.nodes().end());
        for (std::size_t i = 0; i < nodes.size(); ++i)
          for (std::size_t j = i + 1; j < nodes.size(); ++j)
            addEdgeIfAllowed(nodes[i], nodes[j]);
      } else {
        for (const auto& edge: template_graph.edges())
          addEdgeIfAllowed(edge.first(), edge.second());
      }
 
      return graph;
    }

References gum::NodeGraphPart::begin(), gum::EdgeGraphPart::edges(), gum::Set< Key >::empty(), gum::NodeGraphPart::end(), GUM_SL_EMIT, isForbiddenEdge_(), and gum::NodeGraphPart::nodes().

Referenced by gum::learning::Miic::learnMixedStructure(), gum::learning::CIBasedLearning::learnSkeleton(), and gum::learning::Miic::learnSkeleton().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isArcValid_()

bool gum::learning::ConstraintBasedLearning::isArcValid_	(	const MixedGraph &	graph,
		NodeId	x,
		NodeId	y )

protectedinherited

Definition at line 161 of file ConstraintBasedLearning.cpp.

                                                                                         {
      return !isForbiddenArc_(x, y) && !isMaxIndegree_(graph, y);
    }

References isForbiddenArc_(), and isMaxIndegree_().

Referenced by gum::learning::Miic::_orientingVstructureMiic_(), gum::learning::Miic::_propagatingOrientationMiic_(), and gum::learning::CIBasedLearning::orientColliderArm_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isEnabledEpsilon()

INLINE bool gum::ApproximationScheme::isEnabledEpsilon ( ) const

overridevirtualinherited

Returns true if stopping criterion on epsilon is enabled, false otherwise.

Returns: Returns true if stopping criterion on epsilon is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 82 of file approximationScheme_inl.h.

82{ return enabled_eps_; }

References enabled_eps_.

◆ isEnabledMaxIter()

INLINE bool gum::ApproximationScheme::isEnabledMaxIter ( ) const

overridevirtualinherited

Returns true if stopping criterion on max iterations is enabled, false otherwise.

Returns: Returns true if stopping criterion on max iterations is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 123 of file approximationScheme_inl.h.

123{ return enabled_max_iter_; }

References enabled_max_iter_.

◆ isEnabledMaxTime()

INLINE bool gum::ApproximationScheme::isEnabledMaxTime ( ) const

overridevirtualinherited

Returns true if stopping criterion on timeout is enabled, false otherwise.

Returns: Returns true if stopping criterion on timeout is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 147 of file approximationScheme_inl.h.

147{ return enabled_max_time_; }

References enabled_max_time_.

◆ isEnabledMinEpsilonRate()

INLINE bool gum::ApproximationScheme::isEnabledMinEpsilonRate ( ) const

overridevirtualinherited

Returns true if stopping criterion on epsilon rate is enabled, false otherwise.

Returns: Returns true if stopping criterion on epsilon rate is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 103 of file approximationScheme_inl.h.

103{ return enabled_min_rate_eps_; }

References enabled_min_rate_eps_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_().

Here is the caller graph for this function:

◆ isForbiddenArc_()

bool gum::learning::ConstraintBasedLearning::isForbiddenArc_	(	NodeId	x,
		NodeId	y ) const

protectedinherited

Definition at line 149 of file ConstraintBasedLearning.cpp.

                                                                          {
      return _forbiddenGraph_.existsArc(x, y);
    }

References _forbiddenGraph_.

Referenced by gum::learning::FCI::doDdpOrientation_(), isArcValid_(), gum::learning::FCI::orientCollidersOnPAG_(), gum::learning::FCI::ruleR1_(), and gum::learning::FCI::ruleR2_().

Here is the caller graph for this function:

◆ isForbiddenEdge_()

bool gum::learning::ConstraintBasedLearning::isForbiddenEdge_	(	NodeId	x,
		NodeId	y ) const

protectedinherited

Definition at line 153 of file ConstraintBasedLearning.cpp.

                                                                           {
      return _forbiddenGraph_.existsArc(x, y) && _forbiddenGraph_.existsArc(y, x);
    }

References _forbiddenGraph_.

Referenced by initGraph_().

Here is the caller graph for this function:

◆ isMaxIndegree_()

bool gum::learning::ConstraintBasedLearning::isMaxIndegree_	(	const MixedGraph &	graph,
		NodeId	x )

protectedinherited

Definition at line 157 of file ConstraintBasedLearning.cpp.

                                                                                  {
      return graph.parents(x).size() >= _maxIndegree_;
    }

References _maxIndegree_.

Referenced by isArcValid_().

Here is the caller graph for this function:

◆ latentVariables()

const std::vector< Arc > gum::learning::ConstraintBasedLearning::latentVariables ( ) const

inherited

Definition at line 129 of file ConstraintBasedLearning.cpp.

                                                                          {
      return _latentCouples_;
    }

References _latentCouples_.

◆ learnBN()

template<GUM_Numeric GUM_SCALAR, typename PARAM_ESTIMATOR>

BayesNet< GUM_SCALAR > gum::learning::ConstraintBasedLearning::learnBN	(	PARAM_ESTIMATOR &	estimator,
		MixedGraph	graph )

inherited

learns structure then estimates parameters

Definition at line 12 of file ConstraintBasedLearning_tpl.h.

                                                                                    {
      return DAG2BNLearner::createBN< GUM_SCALAR >(estimator, learnDAG(graph));
    }

References gum::learning::DAG2BNLearner::createBN(), and learnDAG().

Here is the call graph for this function:

◆ learnDAG()

DAG gum::learning::ConstraintBasedLearning::learnDAG ( MixedGraph graph )

inherited

learns a DAG

Definition at line 141 of file ConstraintBasedLearning.cpp.

                                                          {
      return meekRules_.propagateToDAG(learnMixedStructure(graph));
    }

References learnMixedStructure(), and meekRules_.

Referenced by learnBN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learnMixedStructure()

MixedGraph gum::learning::FCI::learnMixedStructure ( MixedGraph graph )

overridevirtual

bridge for learnDAG/learnPDAG: runs learnPAG then converts via toMixedGraph()

Implements gum::learning::ConstraintBasedLearning.

Definition at line 871 of file FCI.cpp.

                                                      {
    PAG        pag = learnPAG(std::move(graph));
    MixedGraph mg  = pag.toMixedGraph();
    orientDoubleHeadedArcs_(mg);
    return mg;
  }

References learnPAG(), gum::learning::ConstraintBasedLearning::orientDoubleHeadedArcs_(), and gum::PAG::toMixedGraph().

Referenced by ~FCI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learnPAG()

PAG gum::learning::FCI::learnPAG ( MixedGraph graph )

primary FCI output: learn a PAG from the given node-only or partial graph

Definition at line 818 of file FCI.cpp.

                                    {
    // Phase 1: skeleton discovery
    MixedGraph skeleton = learnSkeleton(std::move(graph));
    applyStructuralConstraints_(skeleton);
 
    // Build initial PAG from skeleton
    PAG pag;
    for (const NodeId n: skeleton.nodes()) {
      pag.addNodeWithId(n);
    }
    // undirected skeleton edges → Circle-Circle
    for (const Edge& e: skeleton.edges()) {
      pag.addEdge(e.first(), e.second());
    }
    // mandatory arcs → Tail-Arrowhead
    for (const Arc& a: skeleton.arcs()) {
      pag.addEdge(a.tail(), a.head(), EdgeMark::Tail, EdgeMark::Arrowhead);
    }
 
    // Phase 2: orient unshielded colliders on PAG
    orientCollidersOnPAG_(pag, skeleton);
 
    // Phase 3: possibleDSep pruning
    possibleDSepPhase_(pag);
 
    // Phase 4: reset marks to Circle, restore mandatory arcs, re-orient colliders
    pag.reorientAllWith(EdgeMark::Circle);
    for (const Arc& a: skeleton.arcs()) {
      if (pag.existsEdge(a.tail(), a.head())) {
        pag.setMarkAt(a.tail(), a.head(), EdgeMark::Arrowhead);
        pag.setMarkAt(a.head(), a.tail(), EdgeMark::Tail);
      }
    }
    orientCollidersOnPAG_(pag, pag.toMixedGraph());
 
    // Phase 5: orientation rules R1–R10 (fixed-point)
    applyOrientationRules_(pag);
 
    // Phase 6: collect bidirected edges (↔) as latent couples
    _latentCouples_.clear();
    for (const Edge& e: pag.edges()) {
      if (pag.isBidirected(e.first(), e.second())) {
        _latentCouples_.emplace_back(e.first(), e.second());
      }
    }
 
    return pag;
  }

References gum::learning::ConstraintBasedLearning::_latentCouples_, gum::PAG::addEdge(), gum::NodeGraphPart::addNodeWithId(), applyOrientationRules_(), gum::learning::ConstraintBasedLearning::applyStructuralConstraints_(), gum::ArcGraphPart::arcs(), gum::Arrowhead, gum::Circle, gum::EdgeGraphPart::edges(), gum::EdgeGraphPart::existsEdge(), gum::PAG::isBidirected(), gum::learning::CIBasedLearning::learnSkeleton(), gum::NodeGraphPart::nodes(), orientCollidersOnPAG_(), possibleDSepPhase_(), gum::PAG::reorientAllWith(), gum::PAG::setMarkAt(), gum::Tail, and gum::PAG::toMixedGraph().

Referenced by ~FCI(), and learnMixedStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learnPDAG()

PDAG gum::learning::ConstraintBasedLearning::learnPDAG ( MixedGraph graph )

inherited

learns the essential graph (CPDAG)

Definition at line 137 of file ConstraintBasedLearning.cpp.

                                                            {
      return meekRules_.propagateToCPDAG(learnMixedStructure(graph));
    }

References learnMixedStructure(), and meekRules_.

Here is the call graph for this function:

◆ learnSkeleton()

MixedGraph gum::learning::CIBasedLearning::learnSkeleton ( MixedGraph graph )

overridevirtualinherited

Phase 1: skeleton discovery via conditional independence tests.

Implements gum::learning::ConstraintBasedLearning.

Definition at line 126 of file CIBasedLearning.cpp.

                                                              {
      graph = initGraph_(graph);
      sepSet_.clear();
 
      Size d = 0;
      while (d <= maxCondSetSize_) {
        std::vector< Edge > edges(graph.edges().begin(), graph.edges().end());
 
        bool                anyTested = false;
        std::vector< Edge > toRemove;
 
        for (const Edge& edge: edges) {
          if (!graph.existsEdge(edge)) { continue; }
 
          const NodeId X = edge.first();
          const NodeId Y = edge.second();
 
          [&]() {
            if (d == 0) {
              anyTested         = true;
              const double pval = test_->statistics(X, Y, _emptySet_).second;
              if (pval <= alpha_) { return; }
              if (stable_) {
                toRemove.push_back(edge);
              } else {
                graph.eraseEdge(edge);
              }
              sepSet_.insert({X, Y}, {{}, pval});
              sepSet_.insert({Y, X}, {{}, pval});
              return;
            }
 
            bool               exh_found = false;
            std::set< NodeId > exh_union;
            double             exh_pval = 0.0;
 
            for (int dir = 0; dir < 2; ++dir) {
              const NodeId A = (dir == 0) ? X : Y;
              const NodeId B = (dir == 0) ? Y : X;
 
              std::vector< NodeId > adj;
              for (NodeId nb: graph.neighbours(A)) {
                if (nb != B) { adj.push_back(nb); }
              }
 
              if (static_cast< Size >(adj.size()) < d) { continue; }
              anyTested = true;
 
              std::vector< std::size_t > idx(d);
              std::iota(idx.begin(), idx.end(), std::size_t(0));
 
              for (;;) {
                std::vector< NodeId > cond(d);
                for (Size i = 0; i < d; ++i) {
                  cond[i] = adj[idx[i]];
                }
 
                const double pval = test_->statistics(A, B, cond).second;
                if (pval > alpha_) {
                  if (!exhaustiveSepSet_) {
                    if (stable_) {
                      toRemove.push_back(edge);
                    } else {
                      graph.eraseEdge(edge);
                    }
                    sepSet_.insert({X, Y}, {cond, pval});
                    sepSet_.insert({Y, X}, {cond, pval});
                    return;
                  }
                  exh_found = true;
                  if (exh_pval == 0.0) { exh_pval = pval; }
                  for (const NodeId n: cond) {
                    exh_union.insert(n);
                  }
                }
 
                int i = static_cast< int >(d) - 1;
                while (i >= 0 && idx[i] == adj.size() - d + static_cast< std::size_t >(i)) {
                  --i;
                }
                if (i < 0) { break; }
                ++idx[i];
                for (int j = i + 1; j < static_cast< int >(d); ++j) {
                  idx[j] = idx[j - 1] + 1;
                }
              }
            }
 
            if (exh_found) {
              if (stable_) {
                toRemove.push_back(edge);
              } else {
                graph.eraseEdge(edge);
              }
              const std::vector< NodeId > union_vec(exh_union.begin(), exh_union.end());
              sepSet_.insert({X, Y}, {union_vec, exh_pval});
              sepSet_.insert({Y, X}, {union_vec, exh_pval});
            }
          }();
        }
 
        if (stable_) {
          for (const Edge& e: toRemove) {
            if (graph.existsEdge(e)) { graph.eraseEdge(e); }
          }
        }
 
        if (!anyTested) { break; }
        ++d;
      }
 
      return graph;
    }

References gum::learning::ConstraintBasedLearning::_emptySet_, alpha_, exhaustiveSepSet_, gum::learning::ConstraintBasedLearning::initGraph_(), maxCondSetSize_, sepSet_, stable_, and test_.

Referenced by ~CIBasedLearning(), gum::learning::PC::learnMixedStructure(), and gum::learning::FCI::learnPAG().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ maxIter()

INLINE Size gum::ApproximationScheme::maxIter ( ) const

overridevirtualinherited

Returns the criterion on number of iterations.

Returns: Returns the criterion on number of iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 113 of file approximationScheme_inl.h.

113{ return max_iter_; }

References max_iter_.

◆ maxPathLength()

Size gum::learning::FCI::maxPathLength ( ) const

maximum path length for R4 discriminating-path search; Size(-1) = unlimited

Definition at line 84 of file FCI.cpp.

84{ return maxPathLength_; }

References maxPathLength_.

Referenced by ~FCI().

Here is the caller graph for this function:

◆ maxTime()

INLINE double gum::ApproximationScheme::maxTime ( ) const

overridevirtualinherited

Returns the timeout (in seconds).

Returns: Returns the timeout (in seconds).

Implements gum::IApproximationSchemeConfiguration.

Definition at line 134 of file approximationScheme_inl.h.

134{ return max_time_; }

References max_time_.

◆ messageApproximationScheme()

std::string gum::IApproximationSchemeConfiguration::messageApproximationScheme ( ) const

inherited

Returns the approximation scheme message.

Returns: Returns the approximation scheme message.

Definition at line 64 of file IApproximationSchemeConfiguration.cpp.

                                                                                {
    switch (stateApproximationScheme()) {
      case ApproximationSchemeSTATE::Continue : return "in progress";
 
      case ApproximationSchemeSTATE::Epsilon :
        return std::format("stopped with epsilon={}", epsilon());
 
      case ApproximationSchemeSTATE::Rate :
        return std::format("stopped with rate={}", minEpsilonRate());
 
      case ApproximationSchemeSTATE::Limit :
        return std::format("stopped with max iteration={}", maxIter());
 
      case ApproximationSchemeSTATE::TimeLimit :
        return std::format("stopped with timeout={}", maxTime());
 
      case ApproximationSchemeSTATE::Stopped : return "stopped on request";
 
      case ApproximationSchemeSTATE::Undefined : return "undefined state";
    }
    return {};
  }

References Continue, Epsilon, epsilon(), Limit, maxIter(), maxTime(), minEpsilonRate(), Rate, stateApproximationScheme(), Stopped, TimeLimit, and Undefined.

Referenced by gum::ApproximationScheme::continueApproximationScheme(), gum::credal::InferenceEngine< GUM_SCALAR >::getApproximationSchemeMsg(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::isEnabledMaxIter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minEpsilonRate()

INLINE double gum::ApproximationScheme::minEpsilonRate ( ) const

overridevirtualinherited

Returns the value of the minimal epsilon rate.

Returns: Returns the value of the minimal epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 93 of file approximationScheme_inl.h.

93{ return min_rate_eps_; }

References min_rate_eps_.

◆ nbrIterations()

INLINE Size gum::ApproximationScheme::nbrIterations ( ) const

overridevirtualinherited

Returns the number of iterations.

Returns: Returns the number of iterations.

Exceptions

OperationNotAllowed Raised if the scheme did not perform.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 170 of file approximationScheme_inl.h.

                                                       {
    if (stateApproximationScheme() == ApproximationSchemeSTATE::Undefined) {
      GUM_ERROR(OperationNotAllowed, "state of the approximation scheme is undefined")
    }
 
    return current_step_;
  }

References current_step_, GUM_ERROR, stateApproximationScheme(), and gum::IApproximationSchemeConfiguration::Undefined.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

FCI & gum::learning::FCI::operator= ( const FCI & from )

Definition at line 62 of file FCI.cpp.

                                   {
    if (this != &from) {
      CIBasedLearning::operator=(from);
      maxPathLength_ = from.maxPathLength_;
    }
    return *this;
  }

References FCI(), maxPathLength_, and gum::learning::CIBasedLearning::operator=().

Here is the call graph for this function:

◆ operator=() [2/2]

FCI & gum::learning::FCI::operator= ( FCI && from )

noexcept

Definition at line 70 of file FCI.cpp.

                                       {
    if (this != &from) {
      CIBasedLearning::operator=(std::move(from));
      maxPathLength_ = from.maxPathLength_;
    }
    return *this;
  }

References FCI(), maxPathLength_, and gum::learning::CIBasedLearning::operator=().

Here is the call graph for this function:

◆ orientColliderArm_()

void gum::learning::CIBasedLearning::orientColliderArm_	(	MixedGraph &	graph,
		NodeId	src,
		NodeId	dst )

protectedinherited

orient one arm (src → dst) of a collider; calls resolveOrientConflict_ on conflict

Definition at line 244 of file CIBasedLearning.cpp.

                                                                                      {
      if (graph.existsEdge(src, dst)) {
        if (isArcValid_(graph, src, dst) && !_existsDirectedPath_(graph, dst, src)) {
          graph.eraseEdge(Edge(src, dst));
          graph.addArc(src, dst);
          GUM_SL_EMIT(src, dst, "Orient " << src << " -> " << dst, "V-structure collider");
        } else {
          resolveOrientConflict_(src, dst);
          GUM_SL_EMIT(src,
                      dst,
                      "Conflict " << src << " -> " << dst,
                      "V-structure blocked by constraint");
        }
      } else if (graph.existsArc(dst, src)) {
        resolveOrientConflict_(src, dst);
        GUM_SL_EMIT(src, dst, "Conflict " << src << " -> " << dst, "V-structure conflict: latent?");
      }
      // existsArc(src, dst) → consistent, skip
    }

References gum::learning::ConstraintBasedLearning::_existsDirectedPath_(), GUM_SL_EMIT, gum::learning::ConstraintBasedLearning::isArcValid_(), and resolveOrientConflict_().

Referenced by orientUnshieldedColliders_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ orientCollidersOnPAG_()

void gum::learning::FCI::orientCollidersOnPAG_	(	PAG &	pag,
		const MixedGraph &	topology )

private

Phase 2 / Phase 4: orient unshielded colliders directly on the PAG. topology is used for unshielded-triple detection (adjacency queries only).

Definition at line 102 of file FCI.cpp.

                                                                      {
    const auto triples = unshieldedTriples_(topology);
 
    const auto isCollider = [&](NodeId X, NodeId Y, NodeId Z) -> bool {
      if (!sepSet_.exists({X, Y})) { return false; }
      const SepSetEntry_& entry = sepSet_[{X, Y}];
      return std::ranges::find(entry.cond, Z) == entry.cond.end();
    };
 
    if (ucPriority_ == UCPriority::Standard) {
      for (const ThreePoints& tp: triples) {
        const NodeId X = std::get< 0 >(tp);
        const NodeId Y = std::get< 1 >(tp);
        const NodeId Z = std::get< 2 >(tp);
        if (!isCollider(X, Y, Z)) { continue; }
        if (pag.existsEdge(X, Z) && !isForbiddenArc_(X, Z)) {
          pag.setMarkAt(X, Z, EdgeMark::Arrowhead);
        }
        if (pag.existsEdge(Y, Z) && !isForbiddenArc_(Y, Z)) {
          pag.setMarkAt(Y, Z, EdgeMark::Arrowhead);
        }
      }
    } else {
      struct Candidate {
        NodeId X, Y, Z;
        double pval;
      };
 
      std::vector< Candidate > candidates;
      candidates.reserve(triples.size());
 
      for (const ThreePoints& tp: triples) {
        const NodeId X = std::get< 0 >(tp);
        const NodeId Y = std::get< 1 >(tp);
        const NodeId Z = std::get< 2 >(tp);
        if (!isCollider(X, Y, Z)) { continue; }
        candidates.push_back({.X = X, .Y = Y, .Z = Z, .pval = sepSet_[{X, Y}].pval});
      }
 
      std::ranges::sort(candidates,
                        [](const Candidate& a, const Candidate& b) { return a.pval > b.pval; });
 
      for (const auto& [X, Y, Z, pval]: candidates) {
        if (pag.existsEdge(X, Z) && !isForbiddenArc_(X, Z)) {
          pag.setMarkAt(X, Z, EdgeMark::Arrowhead);
        }
        if (pag.existsEdge(Y, Z) && !isForbiddenArc_(Y, Z)) {
          pag.setMarkAt(Y, Z, EdgeMark::Arrowhead);
        }
      }
    }
  }

References gum::Arrowhead, gum::learning::CIBasedLearning::SepSetEntry_::cond, gum::EdgeGraphPart::existsEdge(), gum::learning::ConstraintBasedLearning::isForbiddenArc_(), gum::learning::CIBasedLearning::sepSet_, gum::PAG::setMarkAt(), gum::learning::CIBasedLearning::Standard, gum::learning::CIBasedLearning::ucPriority_, and gum::learning::ConstraintBasedLearning::unshieldedTriples_().

Referenced by ~FCI(), and learnPAG().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ orientDoubleHeadedArcs_()

void gum::learning::ConstraintBasedLearning::orientDoubleHeadedArcs_ ( MixedGraph & mg )

protectedinherited

Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Definition at line 204 of file ConstraintBasedLearning.cpp.

                                                                        {
      gum::ArcSet L;
      for (gum::NodeId x: mg.nodes())
        for (NodeId y: mg.parents(x))
          if (mg.parents(y).contains(x)) {
            if (x > y) continue;
            else L.insert(gum::Arc(x, y));
          }
 
      if (not L.empty()) {
        while (true) {
          bool withdrawFlag_L = false;
          for (auto arc: ArcSet(L)) {
            bool tail_head        = _existsDirectedPath_(mg, arc.tail(), arc.head());
            bool head_tail        = _existsDirectedPath_(mg, arc.head(), arc.tail());
            bool withdrawFlag_arc = false;
 
            if (tail_head && !head_tail) {
              mg.eraseArc(Arc(arc.head(), arc.tail()));
              withdrawFlag_arc = true;
            } else if (!tail_head && head_tail) {
              mg.eraseArc(Arc(arc.tail(), arc.head()));
              withdrawFlag_arc = true;
            } else if (!tail_head && !head_tail) {
              mg.eraseArc(Arc(arc.head(), arc.tail()));
              withdrawFlag_arc = true;
            }
 
            if (withdrawFlag_arc) {
              L.erase(arc);
              withdrawFlag_L = true;
            }
          }
          if (L.empty()) break;
 
          // no arc was processed this pass — break cycle by erasing one arc arbitrarily
          if (!withdrawFlag_L) {
            auto arc = *L.begin();
            mg.eraseArc(Arc(arc.head(), arc.tail()));
            mg.eraseArc(Arc(arc.tail(), arc.head()));
            L.erase(arc);
          }
        }
      }
    }

References _existsDirectedPath_(), gum::Set< Key >::begin(), gum::Set< Key >::contains(), gum::Set< Key >::empty(), gum::Set< Key >::erase(), gum::ArcGraphPart::eraseArc(), gum::Set< Key >::insert(), gum::NodeGraphPart::nodes(), and gum::ArcGraphPart::parents().

Referenced by gum::learning::FCI::learnMixedStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ orientUnshieldedColliders_()

MixedGraph gum::learning::CIBasedLearning::orientUnshieldedColliders_ ( MixedGraph graph )

protectedinherited

orient unshielded colliders in graph and return the updated graph

Definition at line 268 of file CIBasedLearning.cpp.

                                                                           {
      _latentCouples_.clear();
 
      const auto triples = unshieldedTriples_(graph);
 
      const auto isCollider = [&](NodeId X, NodeId Y, NodeId Z) -> bool {
        if (!sepSet_.exists({X, Y})) { return false; }
        const SepSetEntry_& entry = sepSet_[{X, Y}];
        return std::find(entry.cond.begin(), entry.cond.end(), Z) == entry.cond.end();
      };
 
      if (ucPriority_ == UCPriority::Standard) {
        for (const ThreePoints& tp: triples) {
          const NodeId X = std::get< 0 >(tp);
          const NodeId Y = std::get< 1 >(tp);
          const NodeId Z = std::get< 2 >(tp);
          if (!isCollider(X, Y, Z)) { continue; }
          orientColliderArm_(graph, X, Z);
          orientColliderArm_(graph, Y, Z);
        }
      } else {
        struct Candidate {
          NodeId X, Y, Z;
          double pval;
        };
 
        std::vector< Candidate > candidates;
        candidates.reserve(triples.size());
 
        for (const ThreePoints& tp: triples) {
          const NodeId X = std::get< 0 >(tp);
          const NodeId Y = std::get< 1 >(tp);
          const NodeId Z = std::get< 2 >(tp);
          if (!isCollider(X, Y, Z)) { continue; }
          candidates.push_back({X, Y, Z, sepSet_[{X, Y}].pval});
        }
 
        std::sort(candidates.begin(), candidates.end(), [](const Candidate& a, const Candidate& b) {
          return a.pval > b.pval;
        });
 
        for (const auto& [X, Y, Z, pval]: candidates) {
          orientColliderArm_(graph, X, Z);
          orientColliderArm_(graph, Y, Z);
        }
      }
 
      return graph;
    }

References gum::learning::ConstraintBasedLearning::_latentCouples_, gum::learning::CIBasedLearning::SepSetEntry_::cond, orientColliderArm_(), sepSet_, Standard, ucPriority_, and gum::learning::ConstraintBasedLearning::unshieldedTriples_().

Referenced by gum::learning::PC::learnMixedStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ periodSize()

INLINE Size gum::ApproximationScheme::periodSize ( ) const

overridevirtualinherited

Returns the period size.

Returns: Returns the period size.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 156 of file approximationScheme_inl.h.

156{ return period_size_; }

gum::ApproximationScheme::period_size_

Size period_size_

Checking criteria frequency.

Definition approximationScheme.h:426

References period_size_.

◆ possibleDSep()

std::vector< NodeId > gum::learning::FCI::possibleDSep	(	const PAG &	pag,
		NodeId	x,
		NodeId	y ) const

learnSkeleton() inherited from CIBasedLearning

return all nodes on possible-d-sep paths from x toward y (excl. x and y). Public accessor for testing and introspection.

Definition at line 86 of file FCI.cpp.

                                                                                {
    return computePossibleDSep_(pag, x, y);
  }

References computePossibleDSep_().

Referenced by ~FCI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ possibleDSepPhase_()

void gum::learning::FCI::possibleDSepPhase_ ( PAG & pag )

private

Phase 3: prune PAG edges using possibleDSep conditioning sets.

Definition at line 287 of file FCI.cpp.

                                       {
    // snapshot edges to avoid invalidation during removal
    const std::vector< Edge > edgeSnap(pag.edges().begin(), pag.edges().end());
 
    const auto tryRemove = [&](NodeId X, NodeId Y, const std::vector< NodeId >& dsep) {
      const Size maxK = (maxCondSetSize_ == Size(-1))
                          ? static_cast< Size >(dsep.size())
                          : std::min(maxCondSetSize_, static_cast< Size >(dsep.size()));
 
      // FIX #4: start at k=2; sizes 0 and 1 were already exhaustively tested
      // in Phase 1 (FAS skeleton discovery).
      for (Size k = 2; k <= maxK; ++k) {
        if (dsep.size() < k) { break; }
 
        std::vector< std::size_t > idx(k);
        std::iota(idx.begin(), idx.end(), std::size_t(0));
 
        for (;;) {
          std::vector< NodeId > cond(k);
          for (Size i = 0; i < k; ++i) {
            cond[i] = dsep[idx[i]];
          }
 
          const double pval = test_->statistics(X, Y, cond).second;
          if (pval > alpha_) {
            pag.eraseEdge(Edge(X, Y));
            sepSet_.set({X, Y}, SepSetEntry_{.cond = cond, .pval = pval});
            sepSet_.set({Y, X}, SepSetEntry_{.cond = cond, .pval = pval});
            return true;
          }
 
          if (k == 0) { break; }
          int i = static_cast< int >(k) - 1;
          while (i >= 0
                 && idx[static_cast< std::size_t >(i)]
                        == dsep.size() - k + static_cast< std::size_t >(i)) {
            --i;
          }
          if (i < 0) { break; }
          ++idx[static_cast< std::size_t >(i)];
          for (int j = i + 1; j < static_cast< int >(k); ++j) {
            idx[static_cast< std::size_t >(j)] = idx[static_cast< std::size_t >(j - 1)] + 1;
          }
        }
      }
      return false;
    };
 
    for (const Edge& edge: edgeSnap) {
      if (!pag.existsEdge(edge)) { continue; }
      const NodeId X = edge.first();
      const NodeId Y = edge.second();
 
      const auto dsepXY = computePossibleDSep_(pag, X, Y);
      if (tryRemove(X, Y, dsepXY)) { continue; }
 
      if (!pag.existsEdge(edge)) { continue; }
      const auto dsepYX = computePossibleDSep_(pag, Y, X);
      tryRemove(X, Y, dsepYX);
    }
  }

References gum::learning::CIBasedLearning::alpha_, gum::Set< Key >::begin(), computePossibleDSep_(), gum::EdgeGraphPart::edges(), gum::Set< Key >::end(), gum::PAG::eraseEdge(), gum::EdgeGraphPart::existsEdge(), gum::learning::CIBasedLearning::maxCondSetSize_, gum::learning::CIBasedLearning::sepSet_, and gum::learning::CIBasedLearning::test_.

Referenced by ~FCI(), and learnPAG().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remainingBurnIn()

INLINE Size gum::ApproximationScheme::remainingBurnIn ( ) const

inherited

Returns the remaining burn in.

Returns: Returns the remaining burn in.

Definition at line 213 of file approximationScheme_inl.h.

                                                         {
    if (burn_in_ > current_step_) {
      return burn_in_ - current_step_;
    } else {
      return 0;
    }
  }

References burn_in_, and current_step_.

◆ resolveOrientConflict_()

void gum::learning::FCI::resolveOrientConflict_	(	NodeId	src,
		NodeId	dst )

overrideprotectedvirtual

conflict hook override: FCI leaves circle marks — orientation conflicts are not recorded as latent couples here (only final ↔ edges in Phase 6 are)

Reimplemented from gum::learning::CIBasedLearning.

Definition at line 94 of file FCI.cpp.

                                                     {
    // no-op: circle marks remain; only final ↔ edges (Phase 6) become _latentCouples_
  }

Referenced by ~FCI().

Here is the caller graph for this function:

◆ ruleR10_()

bool gum::learning::FCI::ruleR10_ ( PAG & pag ) const

private

away from ancestor via two semi-directed paths

Definition at line 744 of file FCI.cpp.

                                   {
    bool changed = false;
    for (const NodeId c: pag.nodes()) {
      // all nodes with arrowhead into C
      std::vector< NodeId > into_c;
      for (const NodeId n: pag.neighbours(c)) {
        if (pag.isArrowhead(n, c)) { into_c.push_back(n); }
      }
      if (into_c.size() < 2) { continue; }
 
      for (const NodeId a: into_c) {
        if (!pag.isCircle(c, a)) { continue; }   // A o→ C
        // possible children of A (not C)
        std::vector< NodeId > a_children;
        for (const NodeId x: pag.neighbours(a)) {
          if (x == c) { continue; }
          if (!pag.isArrowhead(x, a)) { a_children.push_back(x); }
        }
        if (a_children.size() < 2) { continue; }
 
        bool oriented = false;
        for (std::size_t i = 0; i < into_c.size() && !oriented; ++i) {
          for (std::size_t j = i + 1; j < into_c.size() && !oriented; ++j) {
            const NodeId bd = into_c[i];
            const NodeId dd = into_c[j];
            if (!pag.isTail(c, bd)) { continue; }   // B→C
            if (!pag.isTail(c, dd)) { continue; }   // D→C
            for (std::size_t m = 0; m < a_children.size() && !oriented; ++m) {
              for (std::size_t n2 = m + 1; n2 < a_children.size() && !oriented; ++n2) {
                const NodeId ch1 = a_children[m];
                const NodeId ch2 = a_children[n2];
                if (pag.existsEdge(ch1, ch2)) { continue; }
                // FIX #6: check both (ch1→bd, ch2→dd) and (ch1→dd, ch2→bd).
                // Zhang 2008 R10 requires one path to B and one to D from two
                // non-adjacent children; either assignment of children to targets
                // is valid.
                const bool direct  = existsSemiDirectedPath_(pag, ch1, bd)
                                  && existsSemiDirectedPath_(pag, ch2, dd);
                const bool crossed = existsSemiDirectedPath_(pag, ch1, dd)
                                  && existsSemiDirectedPath_(pag, ch2, bd);
                if (!direct && !crossed) { continue; }
                pag.setMarkAt(c, a, EdgeMark::Tail);
                changed  = true;
                oriented = true;
              }
            }
          }
        }
      }
    }
    return changed;
  }

References gum::EdgeGraphPart::existsEdge(), gum::PAG::isArrowhead(), gum::PAG::isCircle(), gum::PAG::isTail(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::PAG::setMarkAt(), and gum::Tail.

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR1_()

bool gum::learning::FCI::ruleR1_ ( PAG & pag ) const

private

away from collider

Definition at line 354 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId b: pag.nodes()) {
      for (const NodeId a: pag.neighbours(b)) {
        if (!pag.isArrowhead(a, b)) { continue; }
        for (const NodeId c: pag.neighbours(b)) {
          if (c == a) { continue; }
          if (!pag.isCircle(c, b)) { continue; }
          if (pag.existsEdge(a, c)) { continue; }
          if (isForbiddenArc_(b, c)) { continue; }
          // FIX #1: do not overwrite an existing Tail at C (from B) with Arrowhead.
          // marks_[Arc(B,C)] == Tail means B *— C is already established;
          // upgrading it to B *→ C would contradict that orientation.
          if (pag.isTail(b, c)) { continue; }
          pag.setMarkAt(c, b, EdgeMark::Tail);
          pag.setMarkAt(b, c, EdgeMark::Arrowhead);
          changed = true;
        }
      }
    }
    return changed;
  }

References gum::Arrowhead, gum::EdgeGraphPart::existsEdge(), gum::PAG::isArrowhead(), gum::PAG::isCircle(), gum::learning::ConstraintBasedLearning::isForbiddenArc_(), gum::PAG::isTail(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::PAG::setMarkAt(), and gum::Tail.

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR2_()

bool gum::learning::FCI::ruleR2_ ( PAG & pag ) const

private

away from cycle

Definition at line 378 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId b: pag.nodes()) {
      for (const NodeId a: pag.neighbours(b)) {
        for (const NodeId c: pag.neighbours(b)) {
          if (a == c) { continue; }
          if (!pag.existsEdge(a, c)) { continue; }
          if (!pag.isCircle(a, c)) { continue; }      // circle at c from a
          if (!pag.isArrowhead(a, b)) { continue; }   // a *→ b
          if (!pag.isArrowhead(b, c)) { continue; }   // b *→ c
          if (!pag.isTail(b, a) && !pag.isTail(c, b)) { continue; }
          if (isForbiddenArc_(a, c)) { continue; }
          // FIX #1 (defensive): isCircle(a,c) already ensures the mark at C
          // from A is Circle, so isTail cannot be true here. Added for symmetry
          // with R1 and to make the guard explicit.
          if (pag.isTail(a, c)) { continue; }
          pag.setMarkAt(a, c, EdgeMark::Arrowhead);
          changed = true;
        }
      }
    }
    return changed;
  }

References gum::Arrowhead, gum::EdgeGraphPart::existsEdge(), gum::PAG::isArrowhead(), gum::PAG::isCircle(), gum::learning::ConstraintBasedLearning::isForbiddenArc_(), gum::PAG::isTail(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), and gum::PAG::setMarkAt().

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR3_()

bool gum::learning::FCI::ruleR3_ ( PAG & pag ) const

private

double triangle

Definition at line 405 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId b: pag.nodes()) {
      std::vector< NodeId > into_arrows, into_circles;
      for (const NodeId n: pag.neighbours(b)) {
        if (pag.isArrowhead(n, b)) { into_arrows.push_back(n); }
        if (pag.isCircle(n, b)) { into_circles.push_back(n); }
      }
      if (into_arrows.size() < 2) { continue; }
 
      for (const NodeId d: into_circles) {
        for (std::size_t i = 0; i < into_arrows.size(); ++i) {
          for (std::size_t j = i + 1; j < into_arrows.size(); ++j) {
            const NodeId a = into_arrows[i];
            const NodeId c = into_arrows[j];
            if (pag.existsEdge(a, c)) { continue; }   // A, C not adjacent
            if (!pag.existsEdge(a, d)) { continue; }
            if (!pag.existsEdge(c, d)) { continue; }
            if (!pag.isCircle(a, d)) { continue; }    // circle at d from a
            if (!pag.isCircle(c, d)) { continue; }    // circle at d from c
            // D is non-collider on A-D-C: D ∈ sepSet(A,C)
            bool nonCollider = false;
            for (const auto& key: {std::make_pair(a, c), std::make_pair(c, a)}) {
              if (sepSet_.exists(key)) {
                const auto& cond = sepSet_[key].cond;
                if (std::ranges::find(cond, d) != cond.end()) {
                  nonCollider = true;
                  break;
                }
              }
            }
            if (!nonCollider) { continue; }
            pag.setMarkAt(d, b, EdgeMark::Arrowhead);
            changed = true;
          }
        }
      }
    }
    return changed;
  }

References gum::Arrowhead, gum::EdgeGraphPart::existsEdge(), gum::PAG::isArrowhead(), gum::PAG::isCircle(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::learning::CIBasedLearning::sepSet_, and gum::PAG::setMarkAt().

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR4_()

bool gum::learning::FCI::ruleR4_ ( PAG & pag ) const

private

discriminating path (uses CI test)

Definition at line 595 of file FCI.cpp.

                                  {
    bool changed = false;
 
    for (const NodeId b: pag.nodes()) {
      // possA: nodes A where B *→ A
      std::vector< NodeId > poss_a;
      for (const NodeId a: pag.neighbours(b)) {
        if (pag.isArrowhead(b, a)) { poss_a.push_back(a); }
      }
      // possC: nodes C where circle at B from C, AND B *→ C
      std::vector< NodeId > poss_c;
      for (const NodeId c: pag.neighbours(b)) {
        if (pag.isCircle(c, b) && pag.isArrowhead(b, c)) { poss_c.push_back(c); }
      }
 
      for (const NodeId a: poss_a) {
        for (const NodeId c: poss_c) {
          if (a == c) { continue; }
          if (!pag.existsEdge(a, c)) { continue; }
          if (!pag.isArrowhead(a, c) || !pag.isTail(c, a)) { continue; }   // A→C (parent)
 
          // BFS backward from A to find discriminating path D…A,B,C
          HashTable< NodeId, NodeId > previous;
          previous.insert(a, b);
 
          // parents of C: nodes with directed edge into C
          std::set< NodeId > c_parents;
          for (const NodeId n: pag.neighbours(c)) {
            if (pag.isArrowhead(n, c) && pag.isTail(c, n)) { c_parents.insert(n); }
          }
 
          std::queue< NodeId > q;
          std::set< NodeId >   visited{a, b};
          q.push(a);
 
          // FIX #2: track BFS depth to respect maxPathLength_.
          // cur_lvl_size counts nodes remaining at the current BFS level;
          // nxt_lvl_size accumulates nodes pushed for the next level.
          // distance is incremented each time we exhaust the current level.
          int  distance     = 0;
          Size cur_lvl_size = 1;   // node_a is the sole node at level 0
          Size nxt_lvl_size = 0;
 
          bool found = false;
          while (!q.empty() && !found) {
            const NodeId t = q.front();
            q.pop();
 
            const NodeId prev_t = previous[t];
 
            // nodes D with arrowhead INTO t
            for (const NodeId d: pag.neighbours(t)) {
              if (visited.count(d) > 0) { continue; }
              if (!pag.isArrowhead(d, t)) { continue; }
              // t must be def collider on (d, t, prev_t)
              if (!pag.isArrowhead(prev_t, t)) { continue; }
 
              previous.set(d, t);
 
              if (!pag.existsEdge(d, c) && d != c) {
                // found discriminating path
                if (doDdpOrientation_(pag, d, a, b, c, previous)) {
                  changed = true;
                  found   = true;
                  break;
                }
              }
              if (c_parents.count(d) > 0) {
                q.push(d);
                visited.insert(d);
                ++nxt_lvl_size;
              }
            }
 
            if (!found) {
              --cur_lvl_size;
              if (cur_lvl_size == 0) {
                ++distance;
                if (maxPathLength_ != Size(-1) && static_cast< Size >(distance) > maxPathLength_) {
                  break;
                }
                cur_lvl_size = nxt_lvl_size;
                nxt_lvl_size = 0;
              }
            }
          }
        }
      }
    }
    return changed;
  }

References doDdpOrientation_(), gum::EdgeGraphPart::existsEdge(), gum::HashTable< Key, Val >::insert(), gum::PAG::isArrowhead(), gum::PAG::isCircle(), gum::PAG::isTail(), maxPathLength_, gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), and gum::HashTable< Key, Val >::set().

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR5_()

bool gum::learning::FCI::ruleR5_ ( PAG & pag ) const

private

uncovered circle path → undirected

Definition at line 449 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId b: pag.nodes()) {
      for (const NodeId a: pag.neighbours(b)) {
        if (!pag.isCircle(a, b) || !pag.isCircle(b, a)) { continue; }
        for (const NodeId c: pag.neighbours(a)) {
          if (c == b) { continue; }
          if (pag.existsEdge(b, c)) { continue; }   // B not adj C
          if (!pag.isCircle(a, c) || !pag.isCircle(c, a)) { continue; }
          for (const NodeId d: pag.neighbours(b)) {
            if (d == a || d == c) { continue; }
            if (pag.existsEdge(a, d)) { continue; }   // A not adj D
            if (!pag.isCircle(b, d) || !pag.isCircle(d, b)) { continue; }
            const std::vector< NodeId >          excludes{a, b};
            std::vector< std::vector< NodeId > > paths;
            std::vector< NodeId >                path{c};
            std::set< NodeId >                   visited{c};
            findUncoveredCirclePaths_(pag, d, path, visited, excludes, paths);
            for (const auto& p: paths) {
              changed = true;
              pag.setMarkAt(b, a, EdgeMark::Tail);
              pag.setMarkAt(a, b, EdgeMark::Tail);
              pag.setMarkAt(c, a, EdgeMark::Tail);
              pag.setMarkAt(a, c, EdgeMark::Tail);
              pag.setMarkAt(b, p.back(), EdgeMark::Tail);
              pag.setMarkAt(p.back(), b, EdgeMark::Tail);
              for (std::size_t k = 0; k + 1 < p.size(); ++k) {
                pag.setMarkAt(p[k + 1], p[k], EdgeMark::Tail);
                pag.setMarkAt(p[k], p[k + 1], EdgeMark::Tail);
              }
            }
          }
        }
      }
    }
    return changed;
  }

References gum::EdgeGraphPart::existsEdge(), gum::PAG::isCircle(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::PAG::setMarkAt(), and gum::Tail.

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR6_()

bool gum::learning::FCI::ruleR6_ ( PAG & pag ) const

private

tail propagation from undirected edge

Definition at line 489 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId b: pag.nodes()) {
      bool has_undirected = false;
      for (const NodeId a: pag.neighbours(b)) {
        if (pag.isTail(a, b) && pag.isTail(b, a)) {
          has_undirected = true;
          break;
        }
      }
      if (!has_undirected) { continue; }
      for (const NodeId c: pag.neighbours(b)) {
        if (pag.isCircle(c, b)) {
          pag.setMarkAt(c, b, EdgeMark::Tail);
          changed = true;
        }
      }
    }
    return changed;
  }

References gum::PAG::isCircle(), gum::PAG::isTail(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::PAG::setMarkAt(), and gum::Tail.

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR7_()

bool gum::learning::FCI::ruleR7_ ( PAG & pag ) const

private

tail propagation from A-oB

Definition at line 512 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId b: pag.nodes()) {
      std::vector< NodeId > a_list;
      for (const NodeId a: pag.neighbours(b)) {
        if (pag.isCircle(a, b) && pag.isTail(b, a)) { a_list.push_back(a); }
      }
      if (a_list.empty()) { continue; }
      for (const NodeId c: pag.neighbours(b)) {
        if (!pag.isCircle(c, b)) { continue; }
        for (const NodeId a: a_list) {
          if (a == c) { continue; }
          if (!pag.existsEdge(a, c)) {
            pag.setMarkAt(c, b, EdgeMark::Tail);
            changed = true;
            break;
          }
        }
      }
    }
    return changed;
  }

References gum::EdgeGraphPart::existsEdge(), gum::PAG::isCircle(), gum::PAG::isTail(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::PAG::setMarkAt(), and gum::Tail.

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR8_()

bool gum::learning::FCI::ruleR8_ ( PAG & pag ) const

private

away from ancestor (graph only)

Definition at line 693 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId b: pag.nodes()) {
      for (const NodeId a: pag.neighbours(b)) {
        for (const NodeId c: pag.neighbours(b)) {
          if (a == c) { continue; }
          if (!pag.existsEdge(a, c)) { continue; }
          if (!pag.isArrowhead(a, c)) { continue; }   // A *→ C
          if (!pag.isCircle(c, a)) { continue; }      // circle at A from C
          if (!pag.isArrowhead(b, c)) { continue; }   // B *→ C
          if (!pag.isTail(c, b)) { continue; }        // Tail at B from C (B→C directed)
          const bool case1 = pag.isArrowhead(a, b) && pag.isTail(b, a);   // A→B
          const bool case2 = pag.isCircle(a, b) && pag.isTail(b, a);      // A-oB
          if (!case1 && !case2) { continue; }
          // FIX #1 (defensive): isCircle(c,a) already ensures this is not Arrowhead,
          // but guard explicitly for clarity.
          if (pag.isArrowhead(c, a)) { continue; }
          pag.setMarkAt(c, a, EdgeMark::Tail);   // A→C: tail at A from C
          changed = true;
        }
      }
    }
    return changed;
  }

References gum::EdgeGraphPart::existsEdge(), gum::PAG::isArrowhead(), gum::PAG::isCircle(), gum::PAG::isTail(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::PAG::setMarkAt(), and gum::Tail.

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ruleR9_()

bool gum::learning::FCI::ruleR9_ ( PAG & pag ) const

private

away from ancestor via uncovered pd-path

Definition at line 719 of file FCI.cpp.

                                  {
    bool changed = false;
    for (const NodeId c: pag.nodes()) {
      for (const NodeId a: pag.neighbours(c)) {
        if (!pag.isArrowhead(a, c)) { continue; }   // A *→ C
        if (!pag.isCircle(c, a)) { continue; }      // circle at A from C (A o→ C)
        bool oriented = false;
        for (const NodeId b: pag.neighbours(a)) {
          if (b == c) { continue; }
          if (pag.existsEdge(b, c)) { continue; }    // B not adjacent C
          if (pag.isArrowhead(b, a)) { continue; }   // B must be possible child of A
          if (existsUncoveredPdPath_(pag, a, b, c)) {
            pag.setMarkAt(c, a, EdgeMark::Tail);
            changed  = true;
            oriented = true;
            break;
          }
        }
        if (oriented) { continue; }
      }
    }
    return changed;
  }

References gum::EdgeGraphPart::existsEdge(), gum::PAG::isArrowhead(), gum::PAG::isCircle(), gum::EdgeGraphPart::neighbours(), gum::NodeGraphPart::nodes(), gum::PAG::setMarkAt(), and gum::Tail.

Referenced by ~FCI(), and applyOrientationRules_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setAlpha()

void gum::learning::CIBasedLearning::setAlpha ( double alpha )

inherited

maximum conditioning set size; Size(-1) = unlimited (default)

Definition at line 106 of file CIBasedLearning.cpp.

106{ alpha_ = alpha; }

gum::learning::CIBasedLearning::alpha

double alpha() const

maximum conditioning set size; Size(-1) = unlimited (default)

Definition CIBasedLearning.cpp:108

References alpha(), and alpha_.

Referenced by ~CIBasedLearning().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setEpsilon()

INLINE void gum::ApproximationScheme::setEpsilon ( double eps )

overridevirtualinherited

Given that we approximate f(t), stopping criterion on |f(t+1)-f(t)|.

If the criterion was disabled it will be enabled.

Parameters

eps	The new epsilon value.

Exceptions

OutOfBounds Raised if eps < 0.

Implements gum::IApproximationSchemeConfiguration.

Reimplemented in gum::learning::EMApproximationScheme.

Definition at line 64 of file approximationScheme_inl.h.

                                                        {
    if (eps < 0.) { GUM_ERROR(OutOfBounds, "eps should be >=0") }
 
    eps_         = eps;
    enabled_eps_ = true;
  }

References enabled_eps_, eps_, and GUM_ERROR.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsSampling< GUM_SCALAR >::GibbsSampling(), gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::learning::GreedyThickThinning::GreedyThickThinning(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), and gum::learning::EMApproximationScheme::setEpsilon().

Here is the caller graph for this function:

◆ setExhaustiveSepSet()

void gum::learning::CIBasedLearning::setExhaustiveSepSet ( bool exhaustive )

inherited

exhaustive sepset mode: accumulate union of all separating sets found at each depth, rather than stopping at the first (default: false)

Definition at line 114 of file CIBasedLearning.cpp.

114{ exhaustiveSepSet_ = exhaustive; }

References exhaustiveSepSet_.

Referenced by ~CIBasedLearning().

Here is the caller graph for this function:

◆ setForbiddenGraph()

void gum::learning::ConstraintBasedLearning::setForbiddenGraph ( const gum::DiGraph & forbidGraph )

inherited

Definition at line 118 of file ConstraintBasedLearning.cpp.

                                                                                 {
      _forbiddenGraph_ = forbidGraph;
    }

References _forbiddenGraph_.

◆ setIndependenceTest()

void gum::learning::CIBasedLearning::setIndependenceTest ( IndependenceTest & test )

inherited

inject independence test (non-owning: caller manages lifetime)

Definition at line 104 of file CIBasedLearning.cpp.

104{ test_ = &test; }

References test_.

Referenced by ~CIBasedLearning().

Here is the caller graph for this function:

◆ setMandatoryGraph()

void gum::learning::ConstraintBasedLearning::setMandatoryGraph ( const gum::DAG & mandaGraph )

inherited

Definition at line 114 of file ConstraintBasedLearning.cpp.

                                                                            {
      _mandatoryGraph_ = mandaGraph;
    }

References _mandatoryGraph_.

◆ setMaxCondSetSize()

void gum::learning::CIBasedLearning::setMaxCondSetSize ( Size max_k )

inherited

maximum conditioning set size; Size(-1) = unlimited (default)

Definition at line 110 of file CIBasedLearning.cpp.

110{ maxCondSetSize_ = max_k; }

References maxCondSetSize_.

Referenced by ~CIBasedLearning().

Here is the caller graph for this function:

◆ setMaxIndegree()

void gum::learning::ConstraintBasedLearning::setMaxIndegree ( gum::Size n )

inherited

Definition at line 122 of file ConstraintBasedLearning.cpp.

122{ _maxIndegree_ = n; }

References _maxIndegree_.

◆ setMaxIter()

INLINE void gum::ApproximationScheme::setMaxIter ( Size max )

overridevirtualinherited

Stopping criterion on number of iterations.

If the criterion was disabled it will be enabled.

Parameters

max	The maximum number of iterations.

Exceptions

OutOfBounds Raised if max <= 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 106 of file approximationScheme_inl.h.

                                                      {
    if (max < 1) { GUM_ERROR(OutOfBounds, "max should be >=1") }
    max_iter_         = max;
    enabled_max_iter_ = true;
  }

References enabled_max_iter_, GUM_ERROR, and max_iter_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

◆ setMaxPathLength()

void gum::learning::FCI::setMaxPathLength ( Size maxLen )

maximum path length for R4 discriminating-path search; Size(-1) = unlimited

Definition at line 82 of file FCI.cpp.

82{ maxPathLength_ = maxLen; }

References maxPathLength_.

Referenced by ~FCI().

Here is the caller graph for this function:

◆ setMaxTime()

INLINE void gum::ApproximationScheme::setMaxTime ( double timeout )

overridevirtualinherited

Stopping criterion on timeout.

If the criterion was disabled it will be enabled.

Parameters

timeout The timeout value in seconds.

Exceptions

OutOfBounds Raised if timeout <= 0.0.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 127 of file approximationScheme_inl.h.

                                                            {
    if (timeout <= 0.) { GUM_ERROR(OutOfBounds, "timeout should be >0.") }
    max_time_         = timeout;
    enabled_max_time_ = true;
  }

References enabled_max_time_, GUM_ERROR, and max_time_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

◆ setMinEpsilonRate()

INLINE void gum::ApproximationScheme::setMinEpsilonRate ( double rate )

overridevirtualinherited

Given that we approximate f(t), stopping criterion on d/dt(|f(t+1)-f(t)|).

If the criterion was disabled it will be enabled

Parameters

rate	The minimal epsilon rate.

Exceptions

OutOfBounds if rate<0

Implements gum::IApproximationSchemeConfiguration.

Reimplemented in gum::learning::EMApproximationScheme.

Definition at line 85 of file approximationScheme_inl.h.

                                                                {
    if (rate < 0) { GUM_ERROR(OutOfBounds, "rate should be >=0") }
 
    min_rate_eps_         = rate;
    enabled_min_rate_eps_ = true;
  }

References enabled_min_rate_eps_, GUM_ERROR, and min_rate_eps_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsSampling< GUM_SCALAR >::GibbsSampling(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), and gum::learning::EMApproximationScheme::setMinEpsilonRate().

Here is the caller graph for this function:

◆ setPeriodSize()

INLINE void gum::ApproximationScheme::setPeriodSize ( Size p )

overridevirtualinherited

How many samples between two stopping is enable.

Parameters

p	The new period value.

Exceptions

OutOfBounds Raised if p < 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 150 of file approximationScheme_inl.h.

                                                       {
    if (p < 1) { GUM_ERROR(OutOfBounds, "p should be >=1") }
 
    period_size_ = p;
  }

References GUM_ERROR.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

◆ setStable()

void gum::learning::CIBasedLearning::setStable ( bool stable )

inherited

stable mode: defer edge removals until end of each depth (default: true)

Definition at line 112 of file CIBasedLearning.cpp.

112{ stable_ = stable; }

References stable_.

Referenced by ~CIBasedLearning().

Here is the caller graph for this function:

◆ setUCPriority()

void gum::learning::CIBasedLearning::setUCPriority ( UCPriority p )

inherited

collider candidate ordering (default: Standard)

Definition at line 118 of file CIBasedLearning.cpp.

118{ ucPriority_ = p; }

References ucPriority_.

Referenced by ~CIBasedLearning().

Here is the caller graph for this function:

◆ setVerbosity()

INLINE void gum::ApproximationScheme::setVerbosity ( bool v )

overridevirtualinherited

Set the verbosity on (true) or off (false).

Parameters

v	If true, then verbosity is turned on.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 159 of file approximationScheme_inl.h.

159{ verbosity_ = v; }

gum::ApproximationScheme::verbosity_

bool verbosity_

If true, verbosity is enabled.

Definition approximationScheme.h:429

References verbosity_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

◆ startOfPeriod()

INLINE bool gum::ApproximationScheme::startOfPeriod ( ) const

inherited

Returns true if we are at the beginning of a period (compute error is mandatory).

Returns: Returns true if we are at the beginning of a period (compute error is mandatory).

Definition at line 200 of file approximationScheme_inl.h.

                                                       {
    if (current_step_ < burn_in_) { return false; }
 
    if (period_size_ == 1) { return true; }
 
    return ((current_step_ - burn_in_) % period_size_ == 0);
  }

Referenced by continueApproximationScheme().

Here is the caller graph for this function:

◆ stateApproximationScheme()

INLINE IApproximationSchemeConfiguration::ApproximationSchemeSTATE gum::ApproximationScheme::stateApproximationScheme ( ) const

overridevirtualinherited

Returns the approximation scheme state.

Returns: Returns the approximation scheme state.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 165 of file approximationScheme_inl.h.

                                                             {
    return current_state_;
  }

Referenced by continueApproximationScheme(), history(), and nbrIterations().

Here is the caller graph for this function:

◆ stopApproximationScheme()

INLINE void gum::ApproximationScheme::stopApproximationScheme ( )

inherited

Stop the approximation scheme.

Definition at line 222 of file approximationScheme_inl.h.

                                                           {
    if (current_state_ == ApproximationSchemeSTATE::Continue) {
      stopScheme_(ApproximationSchemeSTATE::Stopped);
    }
  }

Referenced by gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::GreedyThickThinning::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceNodeToNeighbours_().

Here is the caller graph for this function:

◆ stopScheme_()

INLINE void gum::ApproximationScheme::stopScheme_ ( ApproximationSchemeSTATE new_state )

privateinherited

Stop the scheme given a new state.

Parameters

new_state The scheme new state.

Definition at line 231 of file approximationScheme_inl.h.

                                                                                 {
    if (new_state == ApproximationSchemeSTATE::Continue) { return; }
 
    if (new_state == ApproximationSchemeSTATE::Undefined) { return; }
 
    current_state_ = new_state;
    timer_.pause();
 
    if (onStop.hasListener()) { GUM_EMIT1(onStop, messageApproximationScheme()); }
  }

References gum::IApproximationSchemeConfiguration::Continue, and gum::IApproximationSchemeConfiguration::Undefined.

Referenced by continueApproximationScheme(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::disableMaxIter().

Here is the caller graph for this function:

◆ ucPriority()

CIBasedLearning::UCPriority gum::learning::CIBasedLearning::ucPriority ( ) const

inherited

maximum conditioning set size; Size(-1) = unlimited (default)

Definition at line 120 of file CIBasedLearning.cpp.

120{ return ucPriority_; }

References ucPriority_.

Referenced by ~CIBasedLearning().

Here is the caller graph for this function:

◆ unshieldedTriples_()

std::vector< ThreePoints > gum::learning::ConstraintBasedLearning::unshieldedTriples_ ( const MixedGraph & graph )

protectedinherited

Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Definition at line 301 of file ConstraintBasedLearning.cpp.

                                                                           {
      std::vector< ThreePoints > triples;
      for (NodeId z: graph) {
        for (NodeId x: graph.neighbours(z)) {
          for (NodeId y: graph.neighbours(z)) {
            if (y < x && !graph.existsEdge(x, y) && !graph.existsArc(x, y)
                && !graph.existsArc(y, x)) {
              triples.emplace_back(x, y, z);
            }
          }
        }
      }
      return triples;
    }

Referenced by gum::learning::FCI::orientCollidersOnPAG_(), and gum::learning::CIBasedLearning::orientUnshieldedColliders_().

Here is the caller graph for this function:

◆ updateApproximationScheme()

INLINE void gum::ApproximationScheme::updateApproximationScheme ( unsigned int incr = 1 )

inherited

Update the scheme w.r.t the new error and increment steps.

Parameters

incr	The new increment steps.

Definition at line 209 of file approximationScheme_inl.h.

                                                                              {
    current_step_ += incr;
  }

References current_step_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::GreedyThickThinning::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::SamplingInference< GUM_SCALAR >::loopApproxInference_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByOrderedArcs_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByRandomOrder_(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceNodeToNeighbours_().

Here is the caller graph for this function:

◆ verbosity()

INLINE bool gum::ApproximationScheme::verbosity ( ) const

overridevirtualinherited

Returns true if verbosity is enabled.

Returns: Returns true if verbosity is enabled.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 161 of file approximationScheme_inl.h.

161{ return verbosity_; }

References verbosity_.

Referenced by ApproximationScheme(), gum::learning::EMApproximationScheme::EMApproximationScheme(), and continueApproximationScheme().

Here is the caller graph for this function:

Member Data Documentation

◆ _emptySet_

const std::vector< NodeId > gum::learning::ConstraintBasedLearning::_emptySet_

protectedinherited

Definition at line 201 of file ConstraintBasedLearning.h.

Referenced by gum::learning::Miic::initiation_(), and gum::learning::CIBasedLearning::learnSkeleton().

◆ _forbiddenGraph_

gum::DiGraph gum::learning::ConstraintBasedLearning::_forbiddenGraph_

protectedinherited

Definition at line 196 of file ConstraintBasedLearning.h.

Referenced by ConstraintBasedLearning(), ConstraintBasedLearning(), applyStructuralConstraints_(), isForbiddenArc_(), isForbiddenEdge_(), operator=(), operator=(), gum::learning::Miic::orientationMiic_(), and setForbiddenGraph().

◆ _initialMarks_

HashTable< std::pair< NodeId, NodeId >, char > gum::learning::ConstraintBasedLearning::_initialMarks_

protectedinherited

Definition at line 198 of file ConstraintBasedLearning.h.

Referenced by ConstraintBasedLearning(), ConstraintBasedLearning(), addConstraints(), operator=(), operator=(), and gum::learning::Miic::orientationMiic_().

◆ _latentCouples_

std::vector< Arc > gum::learning::ConstraintBasedLearning::_latentCouples_

protectedinherited

Definition at line 199 of file ConstraintBasedLearning.h.

Referenced by ConstraintBasedLearning(), ConstraintBasedLearning(), gum::learning::Miic::_isNotLatentCouple_(), gum::learning::Miic::_orientingVstructureMiic_(), gum::learning::Miic::_propagatingOrientationMiic_(), latentVariables(), gum::learning::Miic::learnMixedStructure(), gum::learning::FCI::learnPAG(), gum::learning::Miic::learnSkeleton(), operator=(), operator=(), gum::learning::Miic::orientationMiic_(), gum::learning::CIBasedLearning::orientUnshieldedColliders_(), and gum::learning::CIBasedLearning::resolveOrientConflict_().

◆ _mandatoryGraph_

gum::DAG gum::learning::ConstraintBasedLearning::_mandatoryGraph_

protectedinherited

Definition at line 197 of file ConstraintBasedLearning.h.

Referenced by ConstraintBasedLearning(), ConstraintBasedLearning(), applyStructuralConstraints_(), operator=(), operator=(), gum::learning::Miic::orientationMiic_(), and setMandatoryGraph().

◆ _maxIndegree_

gum::Size gum::learning::ConstraintBasedLearning::_maxIndegree_ {std::numeric_limits< gum::Size >::max()}

privateinherited

Definition at line 204 of file ConstraintBasedLearning.h.

204{std::numeric_limits< gum::Size >::max()};

Referenced by ConstraintBasedLearning(), ConstraintBasedLearning(), isMaxIndegree_(), operator=(), operator=(), and setMaxIndegree().

◆ _maxLog_

int gum::learning::ConstraintBasedLearning::_maxLog_ {100}

protectedinherited

Definition at line 200 of file ConstraintBasedLearning.h.

200{100};

Referenced by ConstraintBasedLearning(), ConstraintBasedLearning(), ConstraintBasedLearning(), ConstraintBasedLearning(), gum::learning::Miic::findBestContributor_(), operator=(), and operator=().

◆ alpha_

double gum::learning::CIBasedLearning::alpha_ = 0.05

protectedinherited

Definition at line 181 of file CIBasedLearning.h.

Referenced by CIBasedLearning(), alpha(), gum::learning::FCI::doDdpOrientation_(), learnSkeleton(), operator=(), operator=(), gum::learning::FCI::possibleDSepPhase_(), and setAlpha().

◆ burn_in_

Size gum::ApproximationScheme::burn_in_

protectedinherited

Number of iterations before checking stopping criteria.

Definition at line 423 of file approximationScheme.h.

Referenced by ApproximationScheme(), gum::GibbsBNdistance< GUM_SCALAR >::burnIn(), gum::GibbsSampling< GUM_SCALAR >::burnIn(), remainingBurnIn(), gum::GibbsBNdistance< GUM_SCALAR >::setBurnIn(), and gum::GibbsSampling< GUM_SCALAR >::setBurnIn().

◆ current_epsilon_

double gum::ApproximationScheme::current_epsilon_

protectedinherited

Current epsilon.

Definition at line 378 of file approximationScheme.h.

Referenced by continueApproximationScheme().

◆ current_rate_

double gum::ApproximationScheme::current_rate_

protectedinherited

Current rate.

Definition at line 384 of file approximationScheme.h.

Referenced by continueApproximationScheme().

◆ current_state_

ApproximationSchemeSTATE gum::ApproximationScheme::current_state_

protectedinherited

The current state.

Definition at line 393 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), and initApproximationScheme().

◆ current_step_

Size gum::ApproximationScheme::current_step_

protectedinherited

The current step.

Definition at line 387 of file approximationScheme.h.

Referenced by continueApproximationScheme(), initApproximationScheme(), gum::learning::Miic::initiation_(), gum::learning::SimpleMiic::initiation_(), gum::learning::Miic::iteration_(), gum::learning::SimpleMiic::iteration_(), gum::learning::Miic::learnMixedStructure(), gum::learning::SimpleMiic::learnMixedStructure(), gum::learning::Miic::learnSkeleton(), nbrIterations(), gum::learning::SimpleMiic::orientationLatents_(), gum::learning::Miic::orientationMiic_(), gum::learning::SimpleMiic::orientationMiic_(), remainingBurnIn(), and updateApproximationScheme().

◆ enabled_eps_

bool gum::ApproximationScheme::enabled_eps_

protectedinherited

If true, the threshold convergence is enabled.

Definition at line 402 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), disableEpsilon(), enableEpsilon(), isEnabledEpsilon(), and setEpsilon().

◆ enabled_max_iter_

bool gum::ApproximationScheme::enabled_max_iter_

protectedinherited

If true, the maximum iterations stopping criterion is enabled.

Definition at line 420 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), disableMaxIter(), enableMaxIter(), isEnabledMaxIter(), and setMaxIter().

◆ enabled_max_time_

bool gum::ApproximationScheme::enabled_max_time_

protectedinherited

If true, the timeout is enabled.

Definition at line 414 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), disableMaxTime(), enableMaxTime(), isEnabledMaxTime(), and setMaxTime().

◆ enabled_min_rate_eps_

bool gum::ApproximationScheme::enabled_min_rate_eps_

protectedinherited

If true, the minimal threshold for epsilon rate is enabled.

Definition at line 408 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), disableMinEpsilonRate(), enableMinEpsilonRate(), isEnabledMinEpsilonRate(), and setMinEpsilonRate().

◆ eps_

double gum::ApproximationScheme::eps_

protectedinherited

Threshold for convergence.

Definition at line 399 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), epsilon(), and setEpsilon().

◆ exhaustiveSepSet_

bool gum::learning::CIBasedLearning::exhaustiveSepSet_ = false

protectedinherited

Definition at line 184 of file CIBasedLearning.h.

Referenced by CIBasedLearning(), exhaustiveSepSet(), learnSkeleton(), operator=(), operator=(), and setExhaustiveSepSet().

◆ history_

std::vector< double > gum::ApproximationScheme::history_

protectedinherited

The scheme history, used only if verbosity == true.

Definition at line 396 of file approximationScheme.h.

Referenced by continueApproximationScheme().

◆ last_epsilon_

double gum::ApproximationScheme::last_epsilon_

protectedinherited

Last epsilon value.

Definition at line 381 of file approximationScheme.h.

Referenced by continueApproximationScheme().

◆ max_iter_

Size gum::ApproximationScheme::max_iter_

protectedinherited

The maximum iterations.

Definition at line 417 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), maxIter(), and setMaxIter().

◆ max_time_

double gum::ApproximationScheme::max_time_

protectedinherited

The timeout.

Definition at line 411 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), maxTime(), and setMaxTime().

◆ maxCondSetSize_

Size gum::learning::CIBasedLearning::maxCondSetSize_ = Size(-1)

protectedinherited

Definition at line 182 of file CIBasedLearning.h.

Referenced by CIBasedLearning(), learnSkeleton(), operator=(), operator=(), gum::learning::FCI::possibleDSepPhase_(), and setMaxCondSetSize().

◆ maxPathLength_

Size gum::learning::FCI::maxPathLength_ = Size(-1)

private

Definition at line 165 of file FCI.h.

Referenced by FCI(), maxPathLength(), operator=(), operator=(), ruleR4_(), and setMaxPathLength().

◆ meekRules_

gum::MeekRules gum::learning::ConstraintBasedLearning::meekRules_

protectedinherited

Builds a complete MixedGraph on the nodes of template_graph, minus edges forbidden by structural constraints. Every constraint-based skeleton phase must start from this graph so forbidden pairs are never tested by CI.

Definition at line 176 of file ConstraintBasedLearning.h.

Referenced by learnDAG(), gum::learning::Miic::learnMixedStructure(), and learnPDAG().

◆ min_rate_eps_

double gum::ApproximationScheme::min_rate_eps_

protectedinherited

Threshold for the epsilon rate.

Definition at line 405 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), minEpsilonRate(), and setMinEpsilonRate().

◆ onProgress

Signaler< Size, double, double > gum::IApproximationSchemeConfiguration::onProgress

inherited

Progression, error and time.

Definition at line 81 of file IApproximationSchemeConfiguration.h.

Referenced by gum::ApproximationScheme::continueApproximationScheme(), gum::learning::IBNLearner::distributeProgress(), gum::learning::Miic::initiation_(), gum::learning::SimpleMiic::initiation_(), gum::learning::Miic::iteration_(), gum::learning::SimpleMiic::iteration_(), gum::learning::SimpleMiic::orientationLatents_(), gum::learning::Miic::orientationMiic_(), and gum::learning::SimpleMiic::orientationMiic_().

◆ onStop

Signaler< std::string_view > gum::IApproximationSchemeConfiguration::onStop

inherited

Criteria messageApproximationScheme.

Definition at line 84 of file IApproximationSchemeConfiguration.h.

Referenced by gum::learning::IBNLearner::distributeStop().

◆ onStructuralModification

Signaler< gum::NodeId, gum::NodeId, std::string, std::string > gum::learning::ConstraintBasedLearning::onStructuralModification

inherited

Definition at line 145 of file ConstraintBasedLearning.h.

◆ period_size_

Size gum::ApproximationScheme::period_size_

protectedinherited

Checking criteria frequency.

Definition at line 426 of file approximationScheme.h.

Referenced by ApproximationScheme(), and periodSize().

◆ sepSet_

HashTable< std::pair< NodeId, NodeId >, SepSetEntry_ > gum::learning::CIBasedLearning::sepSet_

protectedinherited

Definition at line 187 of file CIBasedLearning.h.

Referenced by CIBasedLearning(), gum::learning::FCI::doDdpOrientation_(), learnSkeleton(), operator=(), operator=(), gum::learning::FCI::orientCollidersOnPAG_(), orientUnshieldedColliders_(), gum::learning::FCI::possibleDSepPhase_(), and gum::learning::FCI::ruleR3_().

◆ stable_

bool gum::learning::CIBasedLearning::stable_ = true

protectedinherited

Definition at line 183 of file CIBasedLearning.h.

Referenced by CIBasedLearning(), learnSkeleton(), operator=(), operator=(), and setStable().

◆ test_

IndependenceTest* gum::learning::CIBasedLearning::test_ {nullptr}

protectedinherited

Definition at line 180 of file CIBasedLearning.h.

180{nullptr};

Referenced by CIBasedLearning(), gum::learning::FCI::doDdpOrientation_(), learnSkeleton(), operator=(), operator=(), gum::learning::FCI::possibleDSepPhase_(), and setIndependenceTest().

◆ timer_

Timer gum::ApproximationScheme::timer_

protectedinherited

The timer.

Definition at line 390 of file approximationScheme.h.

Referenced by continueApproximationScheme(), currentTime(), gum::learning::Miic::initiation_(), gum::learning::SimpleMiic::initiation_(), gum::learning::Miic::iteration_(), gum::learning::SimpleMiic::iteration_(), gum::learning::Miic::learnMixedStructure(), gum::learning::SimpleMiic::learnMixedStructure(), gum::learning::Miic::learnSkeleton(), gum::learning::SimpleMiic::orientationLatents_(), gum::learning::Miic::orientationMiic_(), and gum::learning::SimpleMiic::orientationMiic_().

◆ ucPriority_

UCPriority gum::learning::CIBasedLearning::ucPriority_ = UCPriority::Standard

protectedinherited

Definition at line 185 of file CIBasedLearning.h.

Referenced by CIBasedLearning(), operator=(), operator=(), gum::learning::FCI::orientCollidersOnPAG_(), orientUnshieldedColliders_(), setUCPriority(), and ucPriority().

◆ verbosity_

bool gum::ApproximationScheme::verbosity_

protectedinherited

If true, verbosity is enabled.

Definition at line 429 of file approximationScheme.h.

Referenced by ApproximationScheme(), setVerbosity(), and verbosity().

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

agrum/BN/learning/FCI.h
agrum/BN/learning/FCI.cpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Common state (accessible to subclasses)

Graph utilities

Detailed Description

Member Enumeration Documentation

◆ ApproximationSchemeSTATE

◆ UCPriority

Constructor & Destructor Documentation

◆ FCI() [1/3]

◆ FCI() [2/3]

◆ FCI() [3/3]

◆ ~FCI()

Member Function Documentation

◆ _existsDirectedPath_()

◆ _existsNonTrivialDirectedPath_()

◆ addConstraints()

◆ alpha()

◆ applyOrientationRules_()

◆ applyStructuralConstraints_()

◆ computePossibleDSep_()

◆ continueApproximationScheme()

◆ currentTime()

◆ disableEpsilon()

◆ disableMaxIter()

◆ disableMaxTime()

◆ disableMinEpsilonRate()

◆ doDdpOrientation_()

◆ enableEpsilon()

◆ enableMaxIter()

◆ enableMaxTime()

◆ enableMinEpsilonRate()

◆ epsilon()

◆ exhaustiveSepSet()

◆ history()

◆ initApproximationScheme()

◆ initGraph_()

◆ isArcValid_()

◆ isEnabledEpsilon()

◆ isEnabledMaxIter()

◆ isEnabledMaxTime()

◆ isEnabledMinEpsilonRate()

◆ isForbiddenArc_()

◆ isForbiddenEdge_()

◆ isMaxIndegree_()

◆ latentVariables()

◆ learnBN()

◆ learnDAG()

◆ learnMixedStructure()

◆ learnPAG()

◆ learnPDAG()

◆ learnSkeleton()

◆ maxIter()

◆ maxPathLength()

◆ maxTime()

◆ messageApproximationScheme()

◆ minEpsilonRate()

◆ nbrIterations()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ orientColliderArm_()

◆ orientCollidersOnPAG_()

◆ orientDoubleHeadedArcs_()

◆ orientUnshieldedColliders_()

◆ periodSize()

◆ possibleDSep()

◆ possibleDSepPhase_()

◆ remainingBurnIn()

◆ resolveOrientConflict_()

◆ ruleR10_()

◆ ruleR1_()

◆ ruleR2_()

◆ ruleR3_()

◆ ruleR4_()

◆ ruleR5_()