Package edu.cmu.tetrad.search

package edu.cmu.tetrad.search

This package contains classes for causal graph search algorithms.

Related Packages

Package	Description
edu.cmu.tetrad.search.blocks
edu.cmu.tetrad.search.ntad_test
edu.cmu.tetrad.search.score	This package contains classes for scoring causal graph models.
edu.cmu.tetrad.search.test	This package contains classes for testing causal graph search algorithms.
edu.cmu.tetrad.search.unmix
edu.cmu.tetrad.search.utils	This package contains utility classes for causal graph search algorithms.
edu.cmu.tetrad.search.work_in_progress	A package for algorithms that are not ready for prime time.

Class	Description
Boss	Implements Best Order Score Search (BOSS).
BossFci	Uses BOSS in the *-FCI algorithm.
BossPod	BOSS-POD is a class that implements the IGraphSearch interface.
Bpc	BuildPureClusters (BPC) inspired by Silva, Scheines, Glymour, Spirtes (JMLR 2006).
Cam	The Cam class implements the Causal Additive Model (CAM), designed for causal discovery from observational data.
Ccd	Cyclic Causal Discovery (CCD) after Richardson.
Cdnod	The Cdnod class implements the causal discovery algorithm for detecting changing dependencies with respect to a change index variable in a dataset.
Cdnod.Builder	Builder class for creating instances of the Cdnod class with customized parameters.
Cdnod.ColliderOrientationStyle	Enumeration representing different strategies for orienting colliders in causal discovery.
Cfci	Deprecated.
CheckKnowledge	Identifies violations of knowledge for a given graph.
ConditioningSetType	The type of conditioning set to use for the Markov check.
CpdagParentDistancesFromTrue	CpdagParentDistancesFromTrue computes the distances between true edge strengths in a true DAG and the range of estimated edge strengths in an output CPDAG.
CpdagParentDistancesFromTrue.DistanceType	The type of distance to calculate.
Cstar	Implements the CStaR algorithm (Stekhoven et al., 2012), which finds a CPDAG of that data and then tries all orientations of the undirected edges about a variable in the CPDAG to estimate a minimum bound on the effect for a given edge.
Cstar.CpdagAlgorithm	An enumeration of the options available for determining the CPDAG used for the algorithm.
Cstar.Record	Represents a single record in the returned table for CSTaR.
Cstar.SampleStyle	An enumeration of the methods for selecting samples from the full dataset.
CyclicSemScorer	The CyclicSemScorer class is designed for evaluating the fit of a directed graph with respect to data using a structural equation modeling (SEM) framework.
CyclicSemScorer.ScoreResult	Immutable result object representing the computed score from a scoring process.
Dagma	Implements the DAGMA algorithm.
DirectLingam	Implements the Direct-LiNGAM algorithm.
DmPc	The Detect-Mimic-PC (DM-PC) algorithm.
FactorAnalysis	Implements the classical Factor Analysis algorithm.
Fas	Implements the Fast Adjacency Search (FAS), which is the adjacency search of the PC algorithm (see).
Fasd	Adjusts FAS (see) for the deterministic case by refusing to removed edges based on conditional independence tests that are judged to be deterministic.
Fask	Implements the FASK (Fast Adjacency Skewness) algorithm.
Fask.LeftRight	An enumeration representing directional and functional types.
FaskOrig	Implements the FASK (Fast Adjacency Skewness) algorithm, which makes decisions for adjacency and orientation using a combination of conditional independence testing, judgments of nonlinear adjacency, and pairwise orientation due to non-Gaussianity.
FaskOrig.AdjacencyMethod	Enumerates the alternatives to use for finding the initial adjacencies for FASK.
FaskOrig.LeftRight	Enumerates the options left-right rules to use for FASK.
FastIca	FastICA (real-valued) translated for Tetrad.
FastIca.IcaResult	A record that represents the result of the Independent Component Analysis (ICA) process.
Fci	The Fci class implements the Fast Causal Inference (FCI) algorithm for discovering causal structures from data.
Fci.ColliderRule	The ColliderRule enum defines the rules or strategies used to handle collider structures in causal inference or related algorithms.
FciMax	Deprecated.
FciOrientDijkstra	A simple implementation of Dijkstra's algorithm for finding the shortest path in a graph.
FciOrientDijkstra.DijkstraEdge	Represents a node in Dijkstra's algorithm.
FciOrientDijkstra.Graph	Represents a graph for Dijkstra's algorithm.
Fcit	The FCI Targeted Testing (FCIT) algorithm implements a search algorithm for learning the structure of a graphical model from observational data with latent variables.
Fcit.START_WITH	Enumeration representing different start options.
Fges	Implements the Fast Greedy Equivalence Search (FGES) algorithm.
FgesFci	Uses FGES for the initial step of *-FCI.
FgesMb	Implements the Fast Greedy Equivalence Search (FGES) algorithm.
Fofc	Generalized Find Factor Clusters (GFFC).
Ftfc	Generalized Find Factor Clusters (GFFC).
Gfci	*-FCI implements a template modification of GFCI that starts with a given Markov CPDAG and then fixes that result to be correct for latent variables models.
Gffc	Generalized Find Factor Clusters (GFFC).
Gin	Minimal GIN: 1) Get clusters from TSC.
Grasp	Implements the GRaSP algorithms, which uses a certain procedure to search in the space of permutations of variables for ones that imply CPDAGs that are especially close to the CPDAG of the true model.
GraspFci	Uses GRaSP in the *-FCI algorithm.
GrowShrink	Implements the Grow-Shrink algorithm of Margaritis and Thrun, a simple yet correct and useful Markov blanket search.
IcaLingam	ICA-LiNGAM (Shimizu et al., 2006), with small numerical hardening to match the stabilized ICA-LiNG-D pipeline.
IcaLingD	ICA-LiNG-D (Lacerda, Spirtes, Ramsey, Hoyer, 2012).
Ida	Implements the IDA algorithm.
Ida.NodeEffects	Gives a list of nodes (parents or children) and corresponding minimum effects for the IDA algorithm.
IdaCheck	This calculates total effects and absolute total effects for an MPDAG G for all pairs distinct (x, y) of variables, where the total effect is obtained by regressing y on x ∪ S and reporting the regression coefficient.
IFas	The IFas interface represents a framework for performing fast adjacency search in graph structures.
IGraphSearch	Gives an interface for a search method that searches and returns a graph.
IMbSearch	Gives an interface for Markov blanket searches.
IndTestIod	Checks independence results by listing all tests with those variables, testing each one, and returning the resolution of these test results.
IsFges	Instance-Specific FGES: overrides just the bump computations to use ISScore, while the FGES base still runs the rest of the algorithm (caching, Meek, BES).
IsGFci	Implements instance-specific FGES-FCI, following the idea introduced by Fattaneh Jabbari in her dissertation (pp.
IsScore	Instance-Specific BIC (IS-BIC) score for discrete data.
KciSmokeTest	The KciSmokeTest class contains unit tests to evaluate the performance and correctness of the Kci class, specifically focusing on conditional independence tests.
LatentPurifier	Implements purification step of Silva et al.'s BuildPureClusters algorithm.
Lofs	Implements a number of methods which take a fixed graph as input and use linear, non-Gaussian methods to orient the edges in the graph.
Lofs.Rule	Give a list of options for rules for doing the non-Gaussian orientations.
Lofs.Score	Gives a list of options for non-Gaussian transformations that can be used for some scores.
MarkovCheck	Checks whether a graph is Markov given a data set.
MarkovCheck.AllSubsetsIndependenceFacts	Stores the set of m-separation facts and the set of m-connection facts for a graph, for the global check.
MarkovCheck.MarkovCheckRecord	A single record for the results of the Markov check.
MimbuildBollen	MimbuildBollen (BlockSpec version)
MimbuildPca	Mimbuild over the first principal components of (pure) clusters, driven by a BlockSpec.
MimbuildTrek	Deprecated.
ModelObserver	The ModelObserver interface is implemented by classes that want to observe changes in a model.
OrderedLocalMarkovProperty	Utility class for computing the ordered local Markov property of a maximal ancestral graph (MAG).
Pc	Pc (Unified "Classic PC")
Pc.AllowBidirected	Enum representing the permission to allow or disallow bidirected edges.
Pc.ColliderOrientationStyle	Enum representing the orientation style used for colliders in a computational context.
Pc.Triple	Public so callers can use it in results.
Pcd	Modifies the PC algorithm to handle the deterministic case.
PcMb	Searches for a CPDAG representing all the Markov blankets for a given target T consistent with the given independence information.
Pcmci	PCMCI (Runge et al.) — minimal, time-series implementation with lagged edges only (τ≥1).
Pcmci.Builder	Builder class for constructing instances of the Pcmci class.
PermutationSearch	Implements common elements of a permutation search.
RawMarginalIndependenceTest	Functional interface for performing a raw marginal independence test.
RecursiveBlocking	The RecursiveBlocking class implements a recursive procedure for constructing candidate separating sets between two nodes under PAG semantics.
RecursiveBlocking.Blockable	The Blockable enum represents the state of an entity in relation to its ability to be blocked.
RecursiveBlockingChokePointA	This class provides methods for identifying a minimal set of blocking nodes (a "choke point") that prevent all paths between two specified nodes in a graph using recursive and iterative mechanisms.
RecursiveBlockingChokePointB	Option B, but – completely ignores the direct edge x *-* y while searching, and – returns null if it proves impossible to block the remaining x–y paths with eligible non-colliders.
RecursiveDiscriminatingPathRule	Implements the R4 Discriminating Path rule in the final FCI orientation rules (Zhang 2008) using the block_paths_recursively method as a optimization.
Rfci	Implements the Really Fast Causal Inference (RFCI) algorithm, which aims to do a correct inference of inferrable causal structure under the assumption that unmeasured common causes of variables in the data may exist.
RlcdCore	Encapsulates RLCD’s heavy lifting:
RlcdCore.Stage1Output	Represents the output of the initial stage (stage 1) of a structure learning algorithm.
ScoredClusterFinder	ScoredClusterFinder ------------------- Given a DataSet and a subset of candidate variables Vsub (by column index), enumerate all clusters C ⊆ Vsub of a fixed size s and keep those for which a BIC-style RCCA score is maximized exactly at rank k when scored against D = Vsub \ C.
ScoredClusterFinder.ClusterHit	Result holder for one accepted cluster.
SepsetFinder	This class provides methods for finding sepsets in a given graph.
SingletonAttacher	Utility to attach singleton (measured) variables as children of latent blocks using a Wilks rank-drop criterion, analogous to the latent->latent hierarchy test.
Sp	Implements the SP (Sparsest Permutation) algorithm.
SpFci	Uses SP in place of FGES for the initial step in the *-FCI algorithm.
StarFci	*-FCI implements a template modification of GFCI that starts with a given Markov CPDAG and then fixes that result to be correct for latent variables models.
SuborderSearch	An interface for suborder searches for various types of permutation algorithms.
TestIGFCI_TCGA_Modern	Modernized translation of the legacy TestIGFCI_TCGA harness.
Tsc	The Tsc class provides methods and utilities for statistical computations, clustering, and rank-based analysis of variables.
TscHarnessTest	The TscHarnessTest class validates the Time Series Clustering (TSC) algorithm and its ability to handle various data scenarios, particularly with mixed ranks and different structural configurations.
TwoStep	Deprecated.
TwoStep.Result	The Result class encapsulates the output of the TwoStep algorithm's search process.