All Classes and Interfaces
Class
Description
Abstract class for annotations.
This is a base class for bootstrap algorithms.
A base class for bootstrapping multi-dataset algorithms (such as IMaGES), parallel to
AbstractBootstrapAlgorithm for single-dataset algorithms.Abstract NB component.
Base class for variable specifications for DataSet.
Stores a knowledge object.
Adds Javabean property change events so that it can be used in a MVC type architecture.
Interface for scoring a target node in a graphical model based on its local structure,
specifically under an additive scoring framework.
This class represents a Causal Perceptron Network.
AdditiveNoiseSimulation
Parameters for model adequacy assessment.
Represents a report evaluating the adequacy of a model's performance relative to a baseline.
A confusion matrix for adjacencies--i.e.
The adjacency precision.
The adjacency precision.
The adjacency true positive rate.
The adjacency precision.
The adjacency recall.
The adjacency precision.
The adjacency precision.
The adjacency true positive rate.
v1: Propensity model = logistic regression via IRLS on mixed-feature basis.
v1: Configuration knobs with conservative defaults.
v1: Result object returned to UI/table.
Smoke test suite for the AdjustmentEffectEstimatorV1 class, which validates the functionality and stability
of the causal effect estimation methods.
PDAG harness for benchmarking adjustment-set generation and total-effect estimation.
A count-only variant of AdTree.
An implementation of a static AD tree based on Moore and Lee 1998 (mostly)
A count-only variant of AdTree.
An AD tree is a data structure used to store the data for a given dataset in a way that makes it easy to calculate
cell counts for a multidimensional contingency table for a given set of variables.
A test of the AD tree implementation.
Interface that algorithm must implement.
Sep 5, 2017 10:47:30 AM
Annotations for algorithms.
Algorithm descriptions.
Aug 30, 2017 3:14:40 PM
Common interface for the four cluster-recovery algorithms used in the
simulation study: TSC, BPC, FOFC, and FTFC.
A list of algorithm to be compared.
Author : Jeremy Espino MD Created 6/30/17 10:36 AM
A class for heuristically removing almost cycles from a PAG to avoid unfaithfulness in an estimated PAG.
Chooses a significance level for a constraint-based search the way
PenaltyDiscountCalibration chooses a penalty discount for a score: from a
budget on the expected number of spurious edges over the whole search, with an effect-size criterion alongside
it.A calibrated significance level together with what it costs on the recall side, per degrees-of-freedom class:
the level the false-edge budget allows, the smallest partial correlation each class of pair can then detect,
the level each class would need to detect a requested effect, whether the budget's level suffices for the
hardest class, the number of conditioning sets tried per pair, and the equivalent penalty discount.
One row of the sweep: a level and what it implies.
Calculates the F1 statistic for adjacencies.
Ancestor precision.
Ancestor recall.
The bidirected true positives.
The bidirected true positives.
Implements the Anderson-Darling test for normality, with P values calculated as in R's ad.test method (in package
nortest).
Represents a class that encapsulates a class along with its associated annotation.
Sep 6, 2017 11:11:38 AM
How a raw per-(SNP, trait) annotation matrix is turned into the adjustment scores that
EdgePriorFacade and EdgePriorScoreFacade scale by tau.Calculates updated marginals for a Bayes net by simulating data and calculating likelihood ratios.
The Ark class extends the NtadTest class and provides a mechanism to perform statistical operations based on tetrads
and their probabilities.
A confusion matrix for arrows--i.e.
The arrow precision.
The arrow precision.
The adjacency true positive rate.
The arrow precision.
The arrow precision.
The arrow recall.
The arrow recall.
The arrow precision.
The arrow precision.
A single immutable finding produced by a
DataAudit: a machine-readable code, a severity, the names of the
variables involved, a map of named numeric values supporting the finding, and a human-readable message.The severity of a finding.
The adjacency precision.
The adjacency precision.
Initializes a history array by setting the value of each variable to basal if it is unregulated (has no parents other
than itself one time step back) and to a random value chosen from a N(basal, initStDev) distribution otherwise.
Basic functionality that all graph-derived classes should provide.
Stores a time series in the "update" (rather than, say, the "repeated")
form--that is, for a given set of factors (the word "factor" is being used here to avoid ambiguity), only lags behind
the getModel time step are recorded temporally, with causal edges extending from lagged factors with lags >= 1 to
factors in the getModel time step (lag = 0) only.
Implements a space-efficient Lower Triangular Matrix of elements of type
shortBasic functionality of a Matrix
Wrapper for BE-GCM (Basis-Expanded Generalised Covariance Measure Test).
Wrapper for BF-BGe, the BGe (Normal-Wishart marginal likelihood) score over the basis-function embedding that BF-BIC
uses.
BF-BGe: the BGe score applied to the basis-function embedding used by
BasisFunctionBicScore.Wrapper for Basis Function BIC Score (Basis-BIC) version.
Calculates the basis function BIC score for a given dataset.
Calculates the basis function BIC score for a given dataset.
Wrapper for the full-sample (tabular) Basis Function BIC Score, delegating to
BasisFunctionBicScoreFullSample.Wrapper for BF-Blocks-Test.
Wrapper for BF-LRT (Basis Function Likelihood Ratio Test).
The
BayesBifParser class provides a set of static methods for parsing Bayesian Network Interchange Format
(BIF) files.Renders Bayes nets and related models in XML.
Feb 22, 2014 3:26:17 PM
Feb 22, 2014 3:35:38 PM
Interface implemented by Bayes instantiated models.
Takes an xml element representing a bayes semIm and converts it to a BayesIM
Calculates cell probabilities from conditional BayesIm probabilities on the fly without constructing the entire
table.
Bayes net simulation.
Implements a discrete Bayes parametric model--that is, a DAG together with a map from the nodes in the graph to a set
of discrete variables, specifying the number of categories for each variable and the name of each category for each
variable.
Calculates likelihood-based properties for discrete Bayes nets against data.
Result container for LR test.
Interface for a discrete Bayes updating algorithm.
Parses Bayes elements back to objects.
Renders Bayes nets and related models in XML.
This is a thread-safe version of BCInference.
An enum for the type of operation.
Feb 26, 2014 8:07:20 PM
Enum for the type of constraint.
Provides a method for computing the score of a model, called the BDe
metric (Bayesian Dirchlet likelihood equivalence), given a dataset (assumes no missing values) and a Bayes
parameterized network (assumes no latent variables).> 0
Calculates the BDe score (Bayes Dirichlet Equivalent) score for analyzing discrete multinomial data.
Wrapper for Fisher Z test.
Calculates the BDeu score, which the BDe (Bayes Dirichlet Equivalent) score with uniform priors.
BDeu score (Dirichlet–multinomial, decomposable) with tunable equivalent sample size ("samplePrior") and no structure
prior.
The CountObjects class encapsulates the counts of objects at different levels of a hierarchy, represented with
one-dimensional and two-dimensional arrays.
Extracts the backward step of GES for use GES but also in other algorithms.
An arrow in the search.
Implements a version of the BES (Best Equivalent Search) algorithm
that takes a permutation as input and yields a permtuation as output, where the related DAG or CPDAG models are
implied by the ordering or variables in these permutations.
Computes best-Jaccard precision and recall between a set of true clusters
and a set of recovered clusters.
Immutable result of a best-Jaccard evaluation.
Implements a Beta distribution for purposes of drawing random numbers.
Wrapper for Blocks BIC Score (Blocks-BIC) version.
Adjusts FGES-FCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies
and unshielded colliders.
Uses BOSS in the *-FCI algorithm.
BFCI-Bryan: BOSS followed by the from-scratch, sepset-map-as-state formulation of the gated StarFCI
extra-edge-removal step, with sepset RE-SELECTION (a gate-rejected separating set does not retire the pair;
the next separating set is tried) and NO saturating step.
BFCI-Bryan-Score: BFCI-Bryan (sepset re-selection under the legality gate) with a scoring step: a legal
candidate is committed only if the RICF Gaussian BIC of its MAG strictly improves on the committed model's,
following Bryan Andrews's "BFCI-Bryan with scoring" pseudocode.
BFCI-Bryan-Score:
BfciBryan with a SCORING STEP added to every gated move, following Bryan Andrews's
pseudocode "BFCI-Bryan with scoring".Adjusts FGES-FCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies
and unshielded colliders.
Uses BOSS in the sepset-projection *-FCI variant; see
StarFciC.Adjusts FGES-FCI to use a permutation algorithm (such as BOSS-Tuck) to do the initial steps of finding adjacencies
and unshielded colliders.
Uses BOSS in the sepset-projection-with-R4-fallback *-FCI variant; see
StarFciD./ Hidden from the interface on 2026-10-21 (no @Algorithm annotation): kept only so that saved sessions
EXPERIMENTAL: BFCI with a per-removal SCORE CHECK ("tests propose, scores dispose").
Wrapper for the BGe (Bayesian Gaussian equivalent) score, the Gaussian analog of BDeu: the local score is the exact
log marginal likelihood of a family under a Normal-Wishart prior rather than a BIC-penalized maximum likelihood.
Implements the BGe (Bayesian Gaussian equivalent) score of Geiger and Heckerman (1994, 2002), in the corrected form
given by Kuipers, Moffa, and Heckerman (2014).
Difference between the true and estimated BIC scores.
Difference between the true and estiamted BIC scores.
Estimated BIC score.
True BIC score.
A confusion matrix for bidireced edges--i.e.
The bidirected true positives.
The bidirected false negatives.
The BidirectedLatentPrecision class implements the Statistic interface and represents a statistic that calculates the
percentage of bidirected edges in an estimated graph for which a latent common cause exists in the true graph.
The BidirectedLatentPrecision class implements the Statistic interface and represents a statistic that calculates the
percentage of bidirected edges in an estimated graph for which a latent confounder exists in the true graph.
The bidirected edge precision.
The bidirected edge precision.
The bidirected true positives.
The bidirected true positives.
Implements an algorithm for revising regulatory models with expression data.
Implements a digraph to be used by the Biolingua algorithm.
Client of the Biolingua class, can be used to easily run the algorithm with different inputs.
An interface for discovering clusters or "blocks" of indices based on data and algorithmic techniques.
A utility class providing static factory methods for creating instances of various
BlockDiscoverer
implementations.An interface that extends functionality of the
IndependenceWrapper and HasParameters interfaces by
adding support for block-specific configuration in independence testing.Wrapper for Blocks BIC Score (Blocks-BIC) version.
BlocksBicScoreTrekSoft
Tagging interface for scores over blocks of variables.
Represents an interface for scoring data models using predefined block structures.
Deprecated.
Deprecated.
Wrapper for BF-Blocks-Test.
Represents a block specification that organizes data into blocks, each associated with a variable and a rank.
Text codec for BlockSpec: - Supports LHS names with optional rank: L1, L1(2) - Validates duplicate block names
(ERROR) - Warns if #index refers to a named variable (prefer name) - Preserves user-supplied names and ranks; does
not reorder blocks - Sorts members within each block (stable) and removes within-line duplicates
Represents an issue encountered during the parsing or processing of block specifications.
Represents the result of parsing a textual representation of a block specification.
Represents the severity level of a condition or situation.
BlocksTrekBicScore:
A trek-aware blocks-based BIC-style local score that mirrors the split construction used in block trek-separation tests.
Utility class for handling operations related to blocks, such as creating block variables, canonicalizing blocks,
ensuring valid indices, and applying various cluster policies.
An enumeration representing different naming modes for assigning names to latent variables in the context of
block specifications.
Tags an independence test that operates over blocks.
The BollenTing class extends the NtadTest class and provides statistical methods for computing tetrad and tetrads
statistics.
Stores a boolean function from a set of boolean-valued parents to a single boolean-valued column.
Updates a gene given a history using the formula Gi.0 = max(Gi.1 - decayRate * -Gi.1 + booleanInfluenceRate *
F(Parents(Gi) in the graph \ Gi.1), lowerBound), as described in Edwards and Glass, (2000), "Combinatorial explosion
in model gene networks", American Institute of Physics.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
Indicate algorithm can do bootstrapping.
Provides a static method for sampling with replacement from a dataset to create a new dataset with a sample size
supplied by the user.
BOSS (Best Order Score Search)
Implements Best Order Score Search (BOSS).
BOSS-CCD (Cyclic Causal Discovery with a BOSS adjacency superstructure).
BOSS-CCD: Cyclic Causal Discovery (Richardson's CCD) with the adjacency phase delegated to BOSS.
BOSS + score-based CD-NOD context augmentation.
BOSS-FCI, the former name of BFCI.
Six-arm study on linear Gaussian data.
Compares the ways Tetrad currently has of running BOSS on data with missing values, on simulated data whose
missingness is injected by
MissingnessInjector with a chem-shaped rate profile.Compares BOSS accuracy under the ways Tetrad has of handling missing values, with the two multiple-imputation
engines as separate arms: chained equations (
MiceLiteImputer) and conditional draws from an EM-fit
multivariate normal (MvnImputer).BOSS-POD, removed in Tetrad 8.0.0.
BOSS-TopK (Best Order Score Search, Top K).
Implements Best Order Score Search (BOSS), extended to return the top k models by score.
Deprecated.
Deprecated.
Deprecated.
Wraps a DataBox in such a way that mixed data sets can be stored.
BuildPureClusters (BPC) inspired by Silva, Scheines, Glymour, Spirtes (JMLR 2006).
Enumerates the algorithm types for BuildPureClusters, and Purify.
The
BpcBlockDiscoverer class is an implementation of the BlockDiscoverer interface, designed to
discover clusters or "blocks" of indices within a dataset using the BPC (Bayesian Partitioning for Causal Discovery)
algorithm.AlgorithmRunner implementation for the BPC (Build Pure Clusters)
algorithm.Enumerates the test types for BuildPureClusters, and Purify.
Implements a really simple idea for building pure clusters, just using the Purify algorithm.
An example script to simulate data and run a comparison analysis on it.
Stores a 2D array of byte data.
Shared cache + utilities for independence testing keyed by (X,Y|Z) using variable NAMES
for mapping into the test, but using a structured int-ID cache key for speed/GC reduction.
Enum representing deduplication strategies.
ErrorPolicy represents the policies that can be applied to handle errors
encountered during the execution of a process or task.
This record represents an evaluation with a binary indicator of independence
and an associated p-value.
Functional interface representing a provider responsible for generating implied facts
associated with a given vertex in a graph-like data structure.
A caching wrapper for IndependenceTest.
Represents the CAM algorithm, which is a causal additive model search algorithm.
Implements the CAM (Causal Additive Model) algorithm for causal discovery
from continuous observational data under the assumption that each variable
is a nonlinear additive function of its parents plus independent noise.
CAM scorer using penalized cubic B-splines (P-splines; Eilers & Marx).
Makes a new data set in which cases in the given data set that have been assigned multiplicies other than n = 1 are
copied out n times.
The CausalUnmixer class provides functionality for extracting unmixed results from datasets using a graph-less
approach.
The
Config class encapsulates the configuration settings used for the unmixing or clustering process
within the CausalUnmixer framework.The Cca class extends the NtadTest class and provides a mechanism to perform Canonical Correlation Analysis (CCA) as
a rank-based way of getting a p-value for a tetrad.
CCD (Cyclic Causal Discovery)
Cyclic Causal Discovery (CCD) after Richardson.
How Step B decides collider versus non-collider for an unshielded triple <a, b, c>.
Wrapper for Daudin Conditional Independence test.
CD-NOD wrapper for algcomparison.
Implements the CD-NOD (Causal Discovery from Non-stationary/heterogeneous Data)
algorithm, which learns a causal graph from data in the presence of context
variables that index changing causal mechanisms across data segments or
environments.
Builder class for creating instances of the Cdnod class with customized parameters.
Enumeration representing different strategies for orienting colliders in causal discovery.
Algcomparison wrapper for the CD-NOD-BOSS search
(
CdnodBoss): a BOSS backbone with
constraint-based collider orientation applied only to unshielded triples
that BOSS leaves fully undirected, followed by Meek closure.Implements a variant of the CD-NOD (Causal Discovery from Non-stationary/
heterogeneous Data) algorithm that uses BOSS (Best Order Score Search) for
the backbone rather than FAS.
Builder class for creating instances of the CdnodBoss class with customized parameters.
Strategies for the CI test's collider verdict in the audit.
One disagreement between the BOSS CPDAG and the CI test on an unshielded triple x *-* z *-* y.
CD-NOD wrapper for algcomparison.
CD-NOD-PAG runner where ALL Tier-0 variables are treated as contexts.
Functional interface representing a builder for constructing the baseline PAG.
Orients arrowheads in a PAG using context-based change/stability evidence, maintaining strong
PAG legality throughout.
Represents a cell table that stores the values of the cells in a table of arbitrary dimension, for use, e.g., in the
context of a contingency table--e.g.
Stores a cell count table of arbitrary dimension.
Stores a cell count table of arbitrary dimension.
Estimates probabilities from data by constructing the entire cell count table for the data.
Estimates the covariance matrix of data in which some values are censored rather than missing: a value at a
ceiling (a grade of 100, a detector at its maximum, a score at the top of its scale) is known only to be at least
that bound, and a value at a floor to be at most it.
CFCI (Conservative FCI).
Residual-vs-environment change test.
Thin wrapper around ChangeTest providing multi-context checks for the orienter.
Change/instability test used by CD-NOD-PAG.
Identifies violations of knowledge for a given graph.
Stage 5 of the missing-data experiments: simulated data shaped like a real dataset, with the real dataset's own
pattern of missing cells.
The canonical-correlation chi-square rank test used by RLCD, translated from
Chi2RankTest.py in the
causal-learn implementation.Wrapper for Fisher Z test.
Wraps a chi square distribution for purposes of drawing random samples.
Calculates chi-square or g-square for a conditional cross-tabulation table for independence question 0 _||_ 1 | 2, 3,
...max by summing up chi-square and degrees of freedom for each conditional table in turn, where rows or columns that
sum to less than a given threshold have been removed.
The type of cell table to use.
Simple class to store the parameters of the result returned by the G Square test.
The type of test to perform.
Generates (nonrecursively) all of the combinations of a choose b, where a, b are nonnegative integers and a >= b.
A confusion matrix for circles--i.e.
CirclePrecision is a class that implements the Statistic interface.
Implements the CircleRecall statistic, which calculates the circle recall value for a given true graph, estimated
graph, and data model.
CI Test Harness for Type I error + p-value uniformity diagnostics.
Immutable data container that represents a CiFact consisting of two integer values and an array of integers.
Represents a configuration record that encapsulates various parameters
used for the generation and evaluation of facts.
Represents the result of a computation or analysis process.
Represents the uniformity test results using Kolmogorov-Smirnov (KS) and Anderson-Darling (AD) tests.
This class contains a method classify which uses an instantiated Bayes net (BayesIm) provided in the constructor.
Interface implemented by classes that do discrete classification.
Performs a Bayesian classification of a test set based on a given training set.
An
IndependenceWrapper that runs the Fisher Z conditional independence test
implemented in the Python causal-learn library, bridging it into
Tetrad's IndependenceTest framework.An
IndependenceWrapper that runs the Kernel-based Conditional Independence (KCI)
test implemented in the Python causal-learn library, bridging it into Tetrad's
IndependenceTest framework.An
IndependenceWrapper that runs the Randomized Conditional Independence Test
(RCIT) implemented in the Python causal-learn library, bridging it into
Tetrad's IndependenceTest framework.Represents a clustering algorithm to cluster some data.
Provides some methods to check significance of clusters for clustering algroithms.
Gives the options for checking significance of clusters--could check the significance using a regression model,
or could check to see if the cluster is a clique, or could not do the check.
Generates (nonrecursively) all of the combinations of objects, where the number of objects in each dimension is
specified.
Iterates through all the posible combinations for a set of variables (each with a different number of possible
values).
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Gives the comparison of a target graph to a reference graph that is implemented in the interface.
Script to do a comparison of a list of algorithms using a list of statistics and a list of parameters and their
values.
Does a comparison of algorithm results across algorithm type, sample sizes, etc.
An enum of comparison graphs types.
An enumeration of the columns in the comparison table.
Does a comparison of algorithm results across algorithm type, sample sizes, etc.
An enum of table columns.
Created by jdramsey on 3/24/16.
An enumeration of the algorithms that can be used for structure learning.
An enumeration of the data types that can be used for structure learning.
An enumeration of the independence test types that can be used for structure learning.
An enumeration of the result types that can be used for structure learning.
.
Runs algorithm on data set (simulation is OK), printing out error statistics.
Checks conditional independence of variable in a continuous data set using Daudin's method.
Wrapper for Fisher Z test.
Implements a conditional Gaussian likelihood.
Gives return value for a conditional Gaussian likelihood, returning a likelihood value and the degrees of freedom
for it.
Wrapper for Fisher Z test.
Implements a conditional Gaussian BIC score for FGS, which calculates a BIC score for mixed discrete/Gaussian data
using the conditional Gaussian likelihood function.
A simulation method based on the conditional Gaussian assumption.
Conditional Kernel Density Estimation with multivariate conditioning.
Result of batchBivariateAllPairs(): provides indexed lookup so callers
don't have to track which result corresponds to which pair.
Represents the result of a conditional density estimation in a one-dimensional space.
Represents the result of a 2D conditional density estimation.
The type of conditioning set to use for the Markov check.
Created by IntelliJ IDEA.
Lazily enumerates the consistent DAG extensions of a DAG or CPDAG.
Represents a constant expression, that is an expression that always evaluates to the same value.
Looks up the value of a variable.
Specifies how a column (continuous or discrete) should be discretized.
Represents a real-valued variable.
Wrapper for the CORD conditional independence test backed by Eric's engine
(
IndTestCordEric): an omnibus, orthogonal rank-score test of Y ⊥ Z | X that is
sensitive to higher-moment, tail, and co-volatility dependence which a covariance-based test
(e.g., Fisher Z) cannot see.Interface for Cord engines.
Standalone validation harness for the CORD port.
CordEngine1 is an implementation of a conditional independence testing engine
based on the CORD methodology.
Encapsulates the results of a conditional independence test for the hypothesis
H0: Y is independent of Z given X.
The CordEngine2 class acts as an implementation of the Cord statistical engine, which is
designed for causal inference and related statistical procedures.
Encapsulates the result of a statistical hypothesis test, storing the relevant test metrics
and providing methods to evaluate the test outcome.
CordEngine3 provides a suite of tools and algorithms for model building,
evaluation, and statistical computations.
Represents the result of a statistical hypothesis test, encapsulating the p-value,
test statistic, test status, sample size, and dimensionality of the conditioning variable.
The CordEngine4 class is a data-driven machine learning engine designed for regression
and classification tasks.
Represents the result of a statistical test for conditional independence,
specifically designed to assess the relationship between variables under
the hypothesis H0: Y is conditionally independent of Z given X.
The CordEngine5 class implements the CORD (Conditional Randomization Discovery)
algorithm for testing the null hypothesis H0: Y is conditionally independent of Z given X.
The Result class represents the outcome of a statistical analysis, providing
values such as aggregated p-values, test statistics, and metadata about the
computation.
The two per-commit correctness gates shared by the latent-variable searches that remove edges from a Markov
start under a legality certificate: the *-FCI family (
StarFci and its subclasses), FCIT, and FCIT-ZM.Outputs 1 if the skeleton is correct, 0 if not..
Stores a correlation matrix together with variable names and sample size; intended as a representation of a data
set.
Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
Interface for computing covariances.
A pre-search audit of a supplied covariance (or correlation) matrix.
The thresholds used by a
CovarianceAudit's checks.Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
Jan 25, 2016 2:13:26 PM
Stores a covariance matrix together with variable names and sample size, intended as a representation of a data set.
Some comemon methods for the various covariance implementations.
Computes covariances using the standard calculation.
A cover in the sense of RLCD (Dong et al., ICLR 2024): a set of variable names that is treated as a single node
group during the rank-deficiency search.
Static set operations over
Covers, translating the module-level helpers in Cover.py and
misc.py of the causal-learn RLCD implementation.Conservative PC (CPC).
CpdagParentDistancesFromTrue computes the distances between true edge strengths in a true DAG and the range of
estimated edge strengths in an output CPDAG.
The type of distance to calculate.
An interface representing a map of probabilities or counts for nodes in a Bayesian network.
Represents a conditional probability table (CPT) in a Bayes net.
Represents a conditional probability table (CPT) in a Bayes net.
Implements the CPW (Cyclic Pairwise) algorithm for causal discovery from
continuous, causally sufficient observational data.
Simulation study of CPW on linear non-Gaussian acyclic model (LiNGAM) data, with FASK and
DirectLiNGAM as references.
Cstar class.
Implements the CStaR algorithm (Stekhoven et al., 2012), which finds a CPDAG from the data and then tries all
orientations of the undirected edges around each variable in the CPDAG to estimate a minimum bound on the causal
effect for a given edge.
An enumeration of the options available for determining the CPDAG used for the algorithm.
Represents a single record in the returned table for CSTaR.
An enumeration of the methods for selecting samples from the full dataset.
Provides a static method for finding the cutoff value for a symmetric probability distribution function about the
origin.
Result of k-fold cross-validation performed by NNEstimator#crossValidate(int).
Returns a cyclic graph build up from small cyclic graph components.
The CyclicSemScorer class is designed for evaluating the fit of a directed graph with respect to data using a
structural equation modeling (SEM) framework.
Immutable result object representing the computed score from a scoring process.
Utilities to stabilize arbitrary directed graphs with cycles.
Represents a directed acyclic graph--that is, a graph containing only directed edges, with no cycles.
Given a CPDAG, lists all the DAGs in that DPCAG.
Given a graph, lists all DAGs that result from directing the undirected edges in that graph every possible way.
Implements the DAGMA algorithm.
Implements the DAGMA algorithm.
Represents a functional interface for computing metrics on directed acyclic graphs (DAGs).
Represents a functional interface for computing a metric value from a
DataSet and Graph.Registry class that provides utility methods for working with DAG metrics.
Represents the result of a metric related to a Directed Acyclic Graph (DAG),
including its name, value, an associated note, and an indication of whether
a higher or lower value is considered better.
Represents the evaluation criteria for a metric, describing whether a higher
value, a lower value, or neither is considered "better" for the given context.
Utility class that provides a set of predefined metrics for evaluating
Directed Acyclic Graphs (DAGs).
Interface for a method that scores a DAG.
Estimates a SemIm given a CovarianceMatrix and a SemPm.
Utility class containing various scoring methods for Directed Acyclic Graphs (DAGs).
Determines sepsets, collider, and noncolliders by examining d-separation facts in a DAG.
Implements the DAG-adaptation of the Onion (DaO) simulation method for
generating linear data from a DAG, with exogenous errors drawn from one of
the reference implementation's five variance-matched families (Gaussian by
default; Exponential, Gumbel, Laplace, or Uniform via
daoErrorDistribution), as described in:A pre-search audit of a data matrix.
Thresholds for the audit's checks, with defaults.
Stores a 2D array of data.
Dec 15, 2018 11:10:30 AM
Interface implemented by classes whose purpose is to generate modifications of data sets.
DataForCalibrationRfci class.
Created by ajsedgewick on 9/4/15.
Interface implemented by classes, instantiations of which can serve as data models in Tetrad.
Stores a list of data models and keeps track of which one is selected.
A utility for resampling dataset.
Implements a rectangular data set, in the sense of being a dataset with a fixed number of columns and a fixed number
of rows, the length of each column being constant.
Utility class for creating a
DataSet instance from various inputs.Estimates maximum likelihood probabilities directly from data on the fly.
Data table implementation.
Data table implementation.
Data tools.
DataTransforms class.
The type of the data set--continuous if all continuous variables, discrete if all discrete variables; otherwise,
mixed.
Fast data loader for continuous or discrete data.
Some static utility methods for dealing with data sets.
Provides static methods for saving data to files.
Implements the DCI (Distributed Causal Inference) algorithm for learning causal structure over a set of variable from
multiple datasets that each may only measure proper overlapping subsets of that sets, or datasets with some variables
in common and others not.
The DefaultSetEndpointStrategy class implements the SetEndpointStrategy interface and provides a default strategy for
setting the endpoint of an edge in a graph.
Logger configuration.
A default implementation of the event.
The bidirected true positives.
The bidirected true positives.
Wrapper for DG-BGe, the BGe (Normal-Wishart marginal likelihood) score over the degenerate Gaussian indicator
embedding that DG-BIC uses.
DG-BGe: the BGe score applied to the degenerate Gaussian embedding of
DegenerateGaussianScore.Wrapper for degenerate Gaussian BIC score
Wrapper for DG LRT.
=This implements the degenerate Gaussian BIC score for FGES.
Type-safe enum of delimiter types for parsing data.
Jun 20, 2017 12:09:05 PM
Implements a test for simultaneously zero sextads in the style of Bollen, K.
Refactored implementation of the Delta Tetrad Test for Confirmatory Tetrad Analysis (CTA).
Implements a test for simultaneously zero sextads in the style of Bollen, K.
Refactored implementation of the Delta Tetrad Test for Confirmatory Tetrad Analysis (CTA).
Uses expectation-maximization to sort a a data set with data sampled from two or more multivariate Gaussian
distributions into its component data sets.
Created by user on 2/27/18.
The adjacency precision.
The adjacency precision.
Hand-run harness comparing the i.i.d.
Utility for checking whether classes are marked
@Deprecated.Simulates data with the anatomy of a designed physical experiment (the archetype is the NASA
Airfoil Self-Noise dataset), in contrast to an observational sample.
Turns the determinism findings of a
DataAudit into a list of variables whose removal would resolve them,
for a user to review.One suggested removal.
Fits and reports the linear equations behind deterministic (and near-deterministic) relations among the continuous
variables of a dataset.
One fitted constraint: determined = sum(coefficients * support) + intercept.
A reusable equation fitter for one dataset: the correlation matrix and its ridge-regularized inverse are
computed once, and each equation costs a few small solves.
The SemBicTest class implements the IndependenceWrapper interface and represents a test for independence based on SEM
BIC algorithm.
Simple implementation of a directed Graph edges are just represented by float values (a zero == no edge) stored in a
matrix.
Direct LiNGAM.
Implements the DirectLiNGAM algorithm for learning a linear non-Gaussian acyclic model.
Stores Dirichlet pseudocounts for the distributions of each variable conditional on particular combinations of its
parent values and, together with Bayes Pm and Dag, provides methods to manipulate these tables.
Estimates probabilities directly from data on the fly using maximum likelihood method.
Estimates a DirichletBayesIm from a DirichletBayesIm (the prior) and a data set.
Wraps a chi square distribution for purposes of drawing random samples.
Wrapper for Discrete BIC test.
Calculates the discrete BIC score.
Calculates the discrete BIC score.
Specifies how a column (continuous or discrete) should be discretized.
Utility methods for discrete conditional independence testing.
Gives an interface that can be used by various discrete scores.
Represents a discrete variable as a range of integer-valued categories 0, 1, ..., m - 1, where m is the number of
categories for the variable.
Type-safe enum of discrete variable types.
A continuous or discrete discretization spec (see).
Discretizes individual columns of discrete or continuous data.
A discretization specification for a continuous variable.
Represents a discriminating path in a graph.
Models the manner in which gene models are initialized differentially depending on the dishes that the cells are in.
Translates display names of lagged variables (e.g.
Interface for a dissilimarity metric.
Interface for a statistical distribution from which random values can be drawn.
The
Sampler class provides functionality for sampling values
from a specified probability distribution.Algorithm-comparison wrapper for the Murray-Watters/Glymour style Detect-Mimic
search, DM.
Implements a Murray-Watters/Glymour style Detect-Mimic search ("DM").
DM-FCIT, removed in Tetrad 8.0.0.
DM-PC, removed in Tetrad 8.0.0.
A hybrid detect-mimic heuristic.
A more robust detect-mimic heuristic for MIMIC-like structures.
Benchmark runner for the DM algorithm.
Implements the DM search.
Stores a 2D array of double data.
Replication harness for the zero-deletion ("testwise deletion of zeros") proposal of Dai, Ng, Luo, Spirtes,
Stojanov and Zhang, "Gene Regulatory Network Inference in the Presence of Dropouts: A Causal View" (ICLR 2024).
Wrapper for linear, Gaussian Extended BIC score (Chen and Chen).
Implements the extended BIC (EBIC) score.
Represents an edge node1 *-# node2 where * and # are endpoints of type Endpoint--that is, Endpoint.TAIL,
Endpoint.ARROW, or Endpoint.CIRCLE.
A property of an edge.
Stores a graph a list of lists of edges adjacent to each node in the graph, with an additional list storing all of
the edges in the graph.
A small, Python-friendly facade over the edge-prior machinery, intended to be driven from JPype.
The EdgePriorFacadeCheck class is a testing utility designed to evaluate the behavior of
the EdgePriorFacade and its associated functionalities.
An immutable, symmetric, name-keyed store of per-edge prior quantities, for use with
EdgePriorScore and
EdgePriorTest.Where a store's numbers came from.
What the stored numbers mean.
The `EdgePriorsAnchorCheck` class provides a test suite for verifying the functional
correctness of the anchoring behavior of the `EdgePriors` class.
The
EdgePriorsCheck class is a testing suite for verifying the behavior and correctness
of score adjustments and independence tests with edge priors.Wraps a
Score and adds an independent Bernoulli prior on each adjacency.A small, Python-friendly facade over the edge-prior machinery for score-based search,
intended to be driven from JPype.
The
EdgePriorsUsage class provides a sequence of computational steps for
exploring the effects of priors on edge decisions in genomic data analysis.Wraps an
IndependenceTest and gives each pair of variables its own significance level,
alpha_ij = w_ij * alpha, by testing the weighted p-value p_ij / w_ij against a common alpha.Strategy interface: given a seed edge E on graph G, return the full set of
mirrored edges that should be kept in sync with E.
This factory class produces edges of the types commonly used for Tetrad-style graphs.
A small color-vision-safe palette for shading graph edges by the sign and strength of an estimated effect.
The hue families.
Result of a single edge-strength computation performed by
NNEstimator.computeEdgeStrength(String, String, int).Apr 13, 2017 3:56:46 PM
An enumeration of the different types of edges.
Interface for classes that can set and retrieve the effective sample size.
Records the elapsed time of the algorithm in seconds.
Estimates parameters of the given Bayes net from the given data using maximum likelihood method.
Calculates some scores for Bayes nets as a whole.
Interface for an estimator.
The
Embedding class provides utilities for transforming datasets into embedded representations through basis
expansions and one-hot encoding.Represents the embedded data result, holding the original dataset, the transformed embedded dataset, and a
mapping between the indices of original variables and their corresponding transformed variables.
Estimates the mean and covariance matrix of a continuous dataset with missing values by maximum likelihood, under a
saturated multivariate Gaussian model, using the EM algorithm.
The result of an EM run: the estimated mean and covariance, together with convergence information.
A rank test over a covariance matrix estimated from incomplete data as a whole -- by EM under the missing-at-random
assumption (
EmCovarianceEstimator), or by pairwise deletion -- with a sample size chosen
per query from the pairwise-complete counts of the columns that query mentions.Only the cumulativeProbability, density, setShift methods are implemented.
Returns a sample empirical distribution for a particular expression.
The EmUnmix class provides functionality for applying the Expectation-Maximization (EM)
algorithm on residual signatures derived from a dataset to fit Gaussian mixtures.
Configuration class for the EmUnmix algorithm, providing parameters and settings to control
the behavior of the unmixing process.
A utility class for operations commonly used in the Expectation-Maximization (EM) algorithm.
A enumeration of the endpoint types that are permitted in Tetrad-style graphs: null (-), arrow (->),
circle (-o), start (-*), and null (no endpoint).
Represents an equation of the form Variable = Expression, where the Variable represents a column in some dataset.
Wrapper for the equivalence (TOST) test on the Fisher Z partial correlation.
Creates a random graph by the Erdos-Renyi method (probabiliy of edge fixed, # edges not).
The EssLikePython class provides methods for estimating the Effective Sample Size (ESS) of a dataset using procedures
that closely mimic functionality found my Python script.
Encapsulates the results of an estimation process, including average row correlation, effective sample size
(ESS), and the number of rows used in the computation.
Estimates the rank of a matrix.
An equation expression.
Stores information for a variable source about evidence we have for each variable as well as whether each variable
has been manipulated.
An example script to load in data sets and graphs from files and analyze them.
An example script to load in data sets and graphs from files and analyze them.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
An example script to simulate data and run a comparison analysis on it.
An example script to save out data files and graphs from a simulation.
An example script to save out data files and graphs from a simulation.
An example script to save out data files and graphs from a simulation.
An example script to simulate data and run a comparison analysis on it.
Oct 17, 2017 11:40:50 AM
Tags a file as experimental so it's not listed in the configuration.
Runs algorithm on data set (simulation is OK), printing out error statistics.
Wraps a chi square distribution for purposes of drawing random samples.
Represents a mathematical expression.
Represents a definition for some expression.
An enum of positions that an expression can occur in.
Thrown if the expression can't be parsed, for instance, if it has the wrong number of arguments.
Parses the tokens of an expression.
Manager for expressions, this includes all implementations of expression descriptors for the calculator.
Parses a string into a tree-like expression.
The type of restriction on parameters.
The
ExpressionSampler class provides functionality for parsing, storing, and
evaluating mathematical expressions.Represents the signature of the expression, for example sqrt(number).
Tags an an algorithm that loads up external graphs for inclusion in reports.
Returns a data set in variables for columns with missing values are augmented with an extra category that represents
the missing values, with missing values being reported as belong this category.
A tagging interface for algorithms that can be used for latent structure search.
Calculates the F1 statistic for adjacencies.
Calculates the F1 statistic for adjacencies.
Calculates the F1 statistic for arrowheads.
Calculates the F1 statistic for circles.
Calculates the F1 statistic for tails.
Factor analysis.
Implements the classical Factor Analysis algorithm.
Implements the procedure Factored-Bayesian-SEM found on page 6 of "The
Bayesian Structural EM Algorithm" by Nir Friedman.> 0
The bidirected true positives.
The bidirected true positives.
Fast Adjacency Search (FAS)--i.e., the PC adjacency step, which is used in many algorithms.
Implements the Fast Adjacency Search (FAS), which is the adjacency search of the PC algorithm (see).
A candidate deletion FAS declined because every accepting separating set it found at the
depth in question was contaminated by determinism (see
Fas.DeterminismGuard), and no
clean alternate of the same size existed.Functional hook: return true if
S functionally determines v
(Var(v|S) = 0, i.e.Adjusts FAS (see) for the deterministic case by refusing to removed edges based on conditional independence tests
that are judged to be deterministic.
Implements a modified version of the the "fast adjacency search" for use in the Distributed Causal Inference (DCI)
algorithm.
FASK algorithm.
Implements the FASK (Fast Adjacency Skewness) algorithm.
An enumeration representing directional and functional types.
The provenance of an orientation decision, recorded per edge in
Fask.getEdgeOrigins().The discrepancy statistic the two-cycle test compares the full sample against its
sign-truncated half-samples with.
Wraps the IMaGES algorithm for continuous variables.
Harness for comparing FASK and CPW edge-orientation accuracy across all five
pairwise left-right rules on random acyclic linear SEMs with Gumbel(0,1) errors.
Harness for tuning and comparing FASK left-right pairwise orientation rules
on random residualized linear SEMs with skewed errors.
Deprecated.
Deprecated.
Enumerates the alternatives to use for finding the initial adjacencies for FASK.
Enumerates the options left-right rules to use for FASK.
Wraps the pooled-FASK multi-dataset algorithm for continuous variables.
Orients a common adjacency graph over multiple datasets by pooling the FASK left-right
statistic across the datasets, rather than voting on per-dataset orientations as
FaskVote does.Pooled statistics for one edge.
The provenance of an orientation decision, recorded per edge in
FaskPool.getEdgeStats().The weighting scheme for pooling per-dataset left-right statistics.
FASK-PW (pairwise).
Size and power of FASK's two-cycle test,
Fask.twoCycleTest(double[], double[], double[][], double), under both
Fask.TwoCycleRule settings, on two-variable systems with six noise shapes.Wraps the MultiFask algorithm for continuous variables.
Implements a simple voting scheme for orienting a common adjacency graph using FASK.
FastICA (real-valued) translated for Tetrad.
A record that represents the result of the Independent Component Analysis (ICA) process.
Calculates the F1 statistic for adjacencies.
The Fast Causal Inference (FCI) algorithm.
The Fci class implements the Fast Causal Inference (FCI) algorithm for discovering causal structures from data.
The ColliderRule enum defines the rules or strategies used to handle collider structures in causal inference or
related algorithms.
FCI-CPW: Run FCI with internally constructed PW-forbidden knowledge, then orient edges
using a pairwise left-right rule on standardized data in cases that are safe under
no-selection-bias cyclic semantics:
Tail–tail (—) edges
Orient per pairwise rule.
Tail–circle (—o) edges
If pairwise prefers x→y, set x→y (symmetrically, if prefers y→x, set y→x).
Circle–circle (o–o) edges
If pairwise prefers x→y, set x o→y (symmetrically for y→x).
Runs FCI on multiple datasets using the IOD pooled dataset independence test.
FCI-Max.
Performs the final orientation steps of the FCI algorithms, which is a useful tool to use in a variety of FCI-like
algorithms.
A simple implementation of Dijkstra's algorithm for finding the shortest path in a graph.
Represents a node in Dijkstra's algorithm.
Represents a graph for Dijkstra's algorithm.
This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning
causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based
steps afterward.
The FCI Targeted Testing (FCIT) algorithm: learns a PAG from observational data
with latent variables.
Enumeration representing different start options.
The FCI Targeted Testing (FCIT) algorithm: learns a PAG from observational data
with latent variables.
Enumeration representing different start options.
The FcitBenchmarkHarness class serves as a benchmarking tool for evaluating various causal
inference algorithms.
The FcitBenchmarkHarness100 class serves as a benchmarking tool for evaluating
various causal discovery algorithms on synthetic data.
The FCI Targeted Testing (FCIT) algorithm: learns a PAG from observational data
with latent variables.
Enumeration representing different start options.
This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning
causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based
steps afterward.
A Markov-preserving variant of
FcitZm.Enumeration representing different start options.
This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning
causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based
steps afterward.
A Markov-preserving variant of
Fcit.Enumeration representing different start options.
FCIT's separator search: recursive blocking with an enumerated not-followed set,
spanned over all subsets of the common neighbours of the pair.
A found separator together with the p-value of the test that confirmed it.
Three-valued search outcome.
This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning
causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based
steps afterward.
FCIT-SL ("Step Lemma"): FCIT-ZM extended with a Step-Lemma-guided representative search.
Commit gate.
Enumeration representing different start options.
FCIT-SL ("Step Lemma"): FCIT-ZM extended with a Step-Lemma-guided representative search.
Commit gate.
Enumeration representing different start options.
KEEP-KNOWLEDGE VARIANT. This class is the knowledge-orientation-keeping variant of FcitSl,
parallel to StarFciKeepKnowledgeOrientations and FcitKeepKnowledgeOrientations.
Commit gate.
Enumeration representing different start options.
FCIT-SL-Score-Check: the FCIT-SL algorithm with a MAG BIC SCORE CHECK applied to every candidate the search
adjudicates.
FCIT-SL-SCORE-CHECK:
FcitSl with a MAG SCORE CHECK on every candidate the search adjudicates.Commit gate.
Enumeration representing different start options.
This class represents the FCI Targeted Testing (FCIT) algorithm, which is variant of the *-FCI algorithm for learning
causal structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based
steps afterward.
FCIT with a MAG-side legality gate.
How an accepted deletion is carried forward past the MAG legality gate.
Enumeration representing different start options.
FCIT with a MAG-side legality gate.
How an accepted deletion is carried forward past the MAG legality gate.
Enumeration representing different start options.
FCIT with a MAG-side legality gate.
How an accepted deletion is carried forward past the MAG legality gate.
Enumeration representing different start options.
Wrapper for FFCI test with a reduced parameter set.
A kernel-based conditional independence (CI) test for datasets containing any mix of
continuous and discrete variables, implementing the Feature-Function CI (FF-CI) framework.
FF-CI-Mixed: Feature-Function CI test for mixed continuous/discrete data.
Wrapper for FF-CI-Continuous test.
FF-CI (Fast Fourier / Feature-based Conditional Independence Test) for continuous data.
Represents different approximation methods that can be used for statistical or mathematical computations.
Enum representing the feature generation methods for random Fourier features (RFF) and orthogonal random features
(ORF).
FF-DML: Feature-Function Distributional Marginal Likelihood score (GP form, continuous)
Response channels for the distributional score.
Represents the types of features that can be used in random feature mappings.
FF-DML: Feature-Function Distributional Marginal Likelihood score (GP form, continuous)
Response channels for the distributional score.
Represents the types of features that can be used in random feature mappings.
Wrapper for FF-ML MIxed Marginal Likelihood Score.
FFML: Feature-Function Marginal Likelihood score for mixed (continuous + discrete) parents
Represents the type of features used in the model.
Wrapper for FF Marginal Likelihood Score.
FF-ML: Feature-Function Marginal Likelihood score (GP form, continuous)
Represents the types of features that can be used in random feature mappings.
FGES (the heuristic version).
Implements the Fast Greedy Equivalence Search (FGES) algorithm.
Requires that the parameter 'randomSelectionSize' be set to indicate how many datasets should be taken at a time
(randomly).
FGES-MB (the heuristic version).
Implements the Fast Greedy Equivalence Search (FGES) algorithm.
This Orients a given undirected graph such that the edges in the graph are a superset of the edges in the oriented
graph, using FGES method.
Clark's Figure 4, both components in one run, against the current PcAR + seeded-repair stack.
Machine-readable codes for the findings a
DataAudit can emit.First inflection point.
Wrapper for Fisher Z test.
Stores a 2D array of float data.
FLOP (Fast Learning of Order and Parents).
Implements the FLOP (Fast Learning of Order and Parents) algorithm.
Computes the principled initial variable order proposed in Section 4.1 of Wienobst, Henckel, and Weichwald (2026),
"Embracing Discrete Search: A Reasonable Approach to Causal Structure Learning" (the FLOP paper), for use with
order-based permutation searches such as BOSS or FLOP.
Generalized Find Factor Clusters (GFFC).
A concrete implementation of the
BlockDiscoverer interface that discovers clusters or "blocks" of indices
using the FOFC algorithm.AlgorithmRunner implementation for the FOFC (Find One Factor Clusters)
algorithm.Estimates whether the p-values under the null are Uniform usign the Markov Checker.
Estimates whether the p-values under the null are Uniform usign the Markov Checker.
Generalized Find Factor Clusters (GFFC).
A concrete implementation of the
BlockDiscoverer interface that discovers clusters or "blocks" of indices
using the FTFC algorithm.AlgorithmRunner implementation for the FOFC (Find One Factor Clusters)
algorithm.Interface for a single-argument, double-valued function that can be passed to mathematical routines.
Library-side helper for "Adjustment & Total Effects" style workflows.
Optional hook for computing adjustment sets.
Immutable eligibility result.
Optional hook for joint adjustment sets.
High-level eligibility states for total-effect computation.
Wraps a chi square distribution for purposes of drawing random samples.
Data are normal distributed.
Lightweight Gaussian Mixture EM with full or diagonal covariance.
Configuration class for the Gaussian Mixture Model (GMM) Expectation-Maximization (EM) algorithm.
Specifies the type of covariance matrix used in the Gaussian Mixture Model (GMM) implemented by the
GaussianMixtureEM class.
Represents the Gaussian Mixture Model (GMM) computed and used in the GaussianMixtureEM class.
GaussianPower class.
GaussianProcessRBF simulates a Gaussian Process (GP) with a Radial Basis Function (RBF) kernel.
Wrapper for KCI test.
Generalized Covariance Measure (GCM) conditional independence test.
Represents the type of regressor to be used in a statistical or machine learning model.
Created by Erich on 7/3/2016.
Created by Erich on 7/14/2016.
Created by Erich on 8/6/2016.
Created by Erich on 8/6/2016.
Created by Erich on 7/6/2016.
Created by Erich on 8/11/2016.
Implements the basic machinery used by all history objects.
Implements a parametric gene model.
Data with variables of general distribution.
Wrapper for the neural-net Generalized Additive Model (GAM) simulator.
GeneralAdditiveModel
Implements the Anderson-Darling test against the given CDF, with P values calculated as in R's ad.test method (in
package nortest).
Estimates a Generalized SEM I'M given a Generalized SEM PM and a data set.
Context.
Represents a generalized SEM-instantiated model.
Parametric model for a Generalized SEM model.
This class represents a Causal Perceptron Network.
General-noise simulator: X_j = f_j(Pa(X_j), e_j)
The GeneralSemSimulation class represents a simulation using a generalized structural equation model (SEM).
This was used for a simulation to test the FTFC and FOFC algorithm and contains some carefully selected functions to
test nonlinearity and non-Gaussianity.
The Fges-FCI class represents the Greedy Fast Causal Inference algorithm, adjusted as in *-FCI.
Uses FGES for the initial step of *-FCI.
The GFCI class represents the Greedy Fast Causal Inference algorithm, adjusted as in *-FCI.
Implements the GFCI (Greedy Fast Causal Inference) algorithm as described in:
Generalized Find Factor Clusters (GFFC).
A concrete implementation of the
BlockDiscoverer interface that discovers clusters or "blocks" of indices
using the FOFC algorithm.The GicScores class is an implementation of the ScoreWrapper interface that calculates the Generalized Information
Criterion (GIC) scores for a given data model.
Implements scores motivated by the Generalized Information Criterion (GIC) approach as given in Kim et al.
Gives the options for the rules to use for calculating the scores.
Wrapper for GIN (Generalized Independent Noise) residual-independence test.
Naming convention tests for giveGoodLatentNames(...).
GLASSO.
A translation from Tibshirani's 2008 Fortran implementation of glasso.
Return value of the algorithm.
GMAS: a latent-variable search that uses no independence tests.
GMAS: a latent-variable search that uses NO independence tests at all.
NL SEM simulation.
Implements a graph capable of storing edges of type N1 *-# N2 where * and # are endpoints of type Endpoint.
Provides s a data structure created mainly for use in the ION search algorithm.
Return a 1 if the graph is exactly right, 0 otherwise.
Utility class providing factory methods for creating instances of different types of
Graph objects.
Instantiations of this interface know how to randomize lag graphs in particular ways.
Contains methods which can be used to determine whether a directed graph is in the equivalence class determined by
the given PAG.
Implements a basic node in a graph--that is, a node that is not itself a variable.
Checks the graphoid axioms for a set of Independence Model statements.
Represents a graphoid independence fact--i.e., a fact in a general independence model (IM) X _||_Y | Z.
A harness for exploring graphoid closure of CI facts implied by a Markov Checker.
The graphoid closure type to use.
Instantiations of this interface know how to randomize update graphs in particular ways.
A utility for computing frequency probabilities.
Methods to load or save graphs.
Implements a pscudo-"score" that implmenets implements Chickering and Meek's (2002) locally consistent score
criterion.
Provides some graph utilities for search algorithm.
Gives the options for triple type for a conservative unshielded collider orientation, which may be "collider" or
"noncollider" or "ambiguous".
A utility class containing graph function from graph theory.
Transformations that transform one graph into another.
Jun 4, 2019 3:21:47 PM
Utility class for working with graphs.
Represents a comparison between two graphs.
The GraphType enum represents the types of graphs that can be used in the application.
Two-cycle errors.
GRaSP (Greedy Relaxations of Sparsest Permutation)
Implements the GRaSP algorithms, which uses a certain procedure to search in the space of permutations of variables
for ones that imply PDAGs that are especially close to the PDAG of the true model.
GRaSP-FCI, an implentatation of *-FCI using GRaSP.
Uses GRaSP in the *-FCI algorithm.
Implements the GRASP algorithms, with various execution flags.
Implements the G-regression estimator of Guo and Perković (2022) for total causal effects under
linearity and causal sufficiency, given an MPDAG.
The result of a bootstrapped G-regression estimate.
An estimator of an identified total effect when the causal structure is known only up to a partial ancestral
graph (PAG), so that latent confounding is allowed.
The result of a bootstrapped estimate.
Implements the Grow-Shrink algorithm of Margaritis and Thrun, a simple yet correct and useful Markov blanket search.
GrowShrinkTree class.
Wrapper for Fisher Z test.
Oracle head-to-head for FCIT-SL candidate generators: the class-walk default versus the
guided witness construction, with and without the legacy fallback.
The purpose of this little converter is to convert "effect" files into "cause" (BasicLagGraph) files.
Tags a gadget as having parameters
Tags a gadget as having parameters values.
Provides an interface for an algorithm can can get/set a value for penalty disoucnt.
Interface for Bff (Heuristic Best Significant Model Search) algorithm.
Heuristic Best Significant Model Search using a beam search.
A move.
Types of moves the algorithm can make.
The score.
Heuristic Best Significant Model Search using the GES algorithm.
A graph with a P value.
The score of a model.
Wrapper for linear, Gaussian SEM BIC score.
A BIC-style local score for structural equation models (SEMs) that replaces the
standard Gaussian log-likelihood with a heavier-tailed or more robust noise model,
making it better suited to data with outliers or non-Gaussian residuals.
Represents different types of statistical noise models used in data processing, signal processing, or
optimization problems.
An enumeration representing the types of non-Gaussian bonuses.
Model for a conditional histogram for mixed continuous and discrete variables.
Hsim class.
Created by Erich on 3/28/2016.
Created by Erich on 3/28/2016.
Created by Erich on 7/15/2016.
Created by Erich on 3/27/2016.
Created by ekummerfeld on 1/26/2017.
Created by Erich on 4/29/2016.
Created by Erich on 3/28/2016.
Created by Erich on 4/29/2016.
generate data from random graph, generated from parameters.
Created by Erich on 3/28/2016.
Created by Erich on 4/29/2016.
Created by Erich on 3/28/2016.
Created by Erich on 3/28/2016.
Created by Erich on 4/22/2016.
// * Wrapper for Huang Marginal Likelihood Score.
Kernel-based marginal likelihood score of Huang et al.
Provides an implemetation of the KuhnâMunkres assignment algorithm of
the year 1957.
Utilities to populate HybridCgPm cutpoints for discrete children that have continuous parents.
Represents the method used to compute and install cutpoints for continuous parents within a hybrid
continuous-discrete graphical model.
Computes per-edge significance for a
HybridCgModel.HybridCgIm against a dataset, and per-stratum t-tests for the linear
coefficients of continuous children.Model-level fit summary for a Hybrid CG structure against a dataset.
Significance summary for one edge.
Computes a per-edge strength summary for a
HybridCgModel.HybridCgIm and produces a display copy of its graph with edges
colored by that strength.The family an edge's strength belongs to.
Strength summary for one edge.
Estimator that prepares cutpoints (binning policy) and then runs MLE via HybridCgIm.HybridEstimator.
Saves and loads
HybridCgModel.HybridCgIm models (parameters plus the full parametric model they sit on) as JSON text.Mixed Continuous/Discrete model with discretization for discrete children that have continuous parents.
Represents a hybrid causal graph instantiated model (IM) derived from a hybrid causal graph probabilistic model (PM).
The HybridEstimator class estimates Hybrid Causal Graphical Models using Maximum Likelihood Estimation (MLE).
Represents a sample containing continuous and discrete data arrays along with a specified number of rows.
The HybridCgPm class represents a structural model for hybrid Bayesian networks, which may include both discrete
and continuous variables.
Result of
HybridCgEdgeSignificance.backwardPrune(HybridCgModel.HybridCgPm, DataSet, double, boolean): a per-child backward elimination of edges whose per-edge
likelihood-ratio test could not distinguish the reduced local model from the full one at the given level.One proposed edge deletion.
This class contains test cases for validating the behavior of row shapes
in the Hybrid Conditional Gaussian Parameter Model (HybridCgPm) when the
model includes a discrete child node with continuous parent nodes.
This class represents a Simulation using Structural Equation Modeling (SEM).
The `HybridCgVars` class provides utility methods for constructing and managing hybrid continuous and discrete
variables.
Implements IAMB.
Created by IntelliJ IDEA.
ICA-LiNGAM, the former name of LiNGAM.
ICA-LiNG-D, the former name of LiNG-D.
The Iterative Causal Discovery (ICD) algorithm.
Implements the Iterative Causal Discovery (ICD) algorithm for learning a Partial Ancestral Graph (PAG)
from observational data.
Interface for covariance matrices.
Implements the IDA algorithm.
Enumeration representing the types of IDA (Intervention-based Directed Acyclic analysis).
Gives a list of nodes (parents or children) and corresponding minimum effects for the IDA algorithm.
The IDA average squared distance.
This calculates total effects and absolute total effects for an PDAG 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.
IdaCheckAvgMaxSquaredDiffEstTrue calculates the average maximum squared difference between the estimated and true
values for a given data model and graphs.
Represents a statistic that calculates the average minimum squared difference between the estimated and true values
for a given data model and graphs.
IdaCheckAvgSquaredDifference is a class that implements the Statistic interface.
IdaMaximumSquaredDifference is a statistic that calculates the "IDA Average Maximum Squared Difference" between a
true graph and an estimated graph.
IdaMinimumSquaredDifference is a statistic that calculates the "IDA Average Minimum Squared Difference" between a
true graph and an estimated graph.
Identifiability, based on RowSummingExactUpdater
The IFas interface represents a framework for performing fast adjacency search in graph structures.
Gives an interface for a search method that searches and returns a graph.
Tagging interface for instantiated models.
Wraps the IMaGES algorithm for continuous variables.
Wraps the IMaGES algorithm for continuous variables.
Wraps the IMaGES algorithm for continuous variables.
Implements a score that aggregates results over multiple component scores, one per dataset, for use with the IMaGES
algorithm.
The weighting scheme used to aggregate component scores when sample sizes differ.
Gives an interface for Markov blanket searches.
The Implied Arrow Orientation Ratio Est statistic calculates the ratio of the number of implied arrows to the number
of arrows in unshielded colliders in the estimated graph.
The Implied Arrow Orientation Ratio Est statistic calculates the ratio of the number of implied arrows to the number
of arrows in unshielded colliders in the estimated graph.
The Implied Arrow Orientation Ratio Est statistic calculates the ratio of the number of implied arrows to the number
of arrows in unshielded colliders in the estimated graph.
Implies Legal MAG
Does MICE imputation with IMaGES-style pooling generalize beyond the linear Gaussian regime? Two phases, both
BOSS at 20% MCAR missingness:
MIXED: Lee-Hastie simulation, half the variables discrete, scored by degenerate-Gaussian BIC.
The search wrapper implementing
MissingDataPolicy.MULTIPLE_IMPUTATION: impute m completed datasets, run
the given algorithm on each, and pool the resulting graphs by edge frequency using the existing
GraphSampling machinery (so pooled graphs carry per-edge probabilities and render with the same GUI
visualization as bootstrap results).The result of a multiple-imputation search: the pooled graph (with per-edge frequencies attached by
GraphSampling) and the individual per-imputation graphs.
Counts conditional independence checks broken down by the call site that
issued them.
Stores a triple (x, y, z) of nodes.
Stores a list of independence facts.
Stores a single conditional independence result, e.g., whether X _||_ Y | Z1,...,Zn holds or does not, and the
p-value of the test.
Gives an interface that can be implemented by classes that do conditional independence testing.
May 14, 2019 11:25:02 AM
Interface that algorithm must implement.
Stores a "shapshot" of the indexedConnectivity of a lag graph, using
indices rather than Strings to refer to factors.
Stores a "shapshot" of the indexedLagGraph of a lag graph, using indices
rather than Strings to refer to factors.
Indexed matrix.
Holds an ordered pair (index, lag) to represent a causal parent of a factor, where the factor at the given index is
independently known.
Created by IntelliJ IDEA.
Basis-expanded Generalised Covariance Measure (GCM) conditional independence test.
Basis–function independence test using block–structured Wilks statistics.
Deprecated.
Deprecated.
Deprecated.
Equality mode for the Lemma-10 criterion.
Block-level CI test using Wilks-rank.
Checks the conditional independence X _||_ Y | S, where S is a set of discrete variable, and X and Y are discrete
variable not in S, by applying a conditional Chi Square test.
Checks conditional independence of variable in a continuous data set using a conditional correlation test for the
nonlinear nonGaussian with the additive error case.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all variables are either continuous or
discrete.
Tetrad
IndependenceTest adapter for the score-pooled CORD engine (CordEngine3), the
omnibus, orthogonal rank-score test of the full conditional law that keeps power against variance,
tail, and co-volatility dependence that covariance/mean tests (Fisher Z, GCM) miss.Tetrad
IndependenceTest adapter for Eric's CORD engine (CordEngine2), the omnibus,
orthogonal rank-score test of the full conditional law that keeps power against variance, tail, and
co-volatility dependence that covariance/mean tests (Fisher Z, GCM) miss.Deprecated.
Implements degenerate Gaussian test as a likelihood ratio test.
Deprecated.
Reports independence only on positive evidence that a partial correlation is negligible, by a
two-one-sided-test (TOST) equivalence test on the Fisher z scale.
Wrapper class for
IndependenceTest that enforces False Discovery Rate (FDR) control on independence
decisions.Fisher's Z CI test with shrinkage (RIDGE/Ledoit-Wolf) and optional pseudoinverse fallback.
Immutable, self-contained result of a single conditional-independence test.
Shrinkage mode.
Deprecated.
Calculates independence from multiple datasets from using the Fisher method of pooling independence results.
Deprecated.
Deprecated.
GIN (Generalized Independent Noise) conditional independence test.
Distance correlation (biased) with optional permutations.
Represents a ridge-regularized ordinary least squares (OLS) regressor.
Fast Pearson correlation t-test (linear).
How we compute residuals.
Unconditional independence backend rX ⟂ rY → p-value
Checks the conditional independence X _||_ Y | S, where S is a set of discrete variable, and X and Y are discrete
variable not in S, by applying a conditional G Square test.
Deprecated.
Checks conditional independence against a list of conditional independence facts, manually entered.
Checks independence results by listing all tests with those variables, testing each one, and returning the resolution
of these test results.
Deprecated.
A class that represents a pooled independence test for multiple data sets.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all searchVariables are either continuous or
discrete.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all searchVariables are either continuous or
discrete.
Performs a test of conditional independence X _||_ Y | Z1...Zn where all variables are either continuous or discrete.
Deprecated.
Uses BCInference by Cooper and Bui to calculate probabilistic conditional independence judgments.
Probabilistic conditional independence test using BDeu (population only).
Probabilistic conditional‐independence test using BDeu (instance‑specific split on Z).
RCoT (Randomized Conditional Correlation Test) using Random Fourier Features + residualization + CCA
Deprecated.
Gives a method of interpreting a test as a score.
Checks independence facts for variables associated with a sepset by simply querying the sepset
A conditional independence test for data gathered in several domains (batches, sites, cohorts, countries) whose
causal structure is shared but whose linear coefficients, means, and noise variances may differ by domain -- the
Phase 1 test of LCD-NOD (Dong, Dai, Ng, Spirtes, and Zhang, ICML 2026).
Deprecated.
Use IndTestBlocksTs instead.
Initializes a history array.
Instance-augmented SEM-BIC score for continuous data.
Wrapper for InstanceAugmentedSemBicScore that: - pulls the testing DataSet from Params.TESTING_DATA (injected by the
algorithm wrapper), - takes the instance row from Params.INSTANCE_ROW, - aligns columns by training variable names, -
uses alpha from Params.IS_ALPHA (default 1.0).
Marker interface for scores that include an instance-specific component.
Estimates probabilities directly from data on the fly using maximum likelihood method, with the exception that if
rows do not exist in the data satisfying a required condition because certain values are unattested, an attempt is
made to remove each relevant column in turn, record the estimated probability with column removed from the condition
(if it is defined), and then return the average over the estimated probabilities calculated this way.
Stores a 2D array of integer data.
Integrates under a function from one endpoint to another.
Implements the Inter-IAMB algorithm.
Returns edges whose entries in the precision matrix exceed a certain threshold.
Runs the ION (Integration of Overlapping Networks) algorithm on multiple datasets whose variable sets may overlap
only partially.
Implements the ION (Integration of Overlapping Networks) algorithm for distributed causal inference.
Provides a static method which implements a correct version of Reiter's hitting set algorithm as described by
Greiner, Smith, and Wilkerson in "A Correction to the Algorithm in Reiter's Theory of Diagnosis" Artificial
Intellegence 41 (1989) (see for detailed specification).
Provides an interface for Purify algorithm.
Instance‑Specific BDeu score (discrete), using the Dirichlet–multinomial posterior predictive term for the
instance row (Jabbari).
Instance‑Specific BDeu (IS‑BDeu) score.
Wrapper for ISBDeuScore (discrete).
Instance-Specific BIC (IS-BIC) score for discrete data.
An interface for SemIM's; see implementations.
IS-FGES (Instance-Specific FGES) wrapper for the algcomparison interface.
Instance-Specific FGES: reuses the FGES search machinery but overrides the
bump computations to use
IsScore (instance-specific) rather than the
pure population score.IS-GFCI (Instance-Specific GFCI) wrapper for the algcomparison interface.
Instance-specific FGES→FCI wrapper ("IS-GFCI").
Instance‑specific scoring contract used by IS‑FGES / IS‑GFCI and related algorithms.
This class contains methods which implement the algorithm described in the paper " " by Ideker, Thorsen and Karp.
A gene.
Joins two tabular data sets on a key, in the manner of a database join: each row of the left data set is looked
up in the right data set by its key value(s), and the right data set's non-key columns are appended to it.
Which unmatched rows to keep.
The joined data set and a findings-only report.
Stores some utility items for displaying JOptionPane messages.
Dec 9, 2016 5:43:47 PM
Exact junction-tree inference over a
BayesIm supporting:
Soft evidence via allowed categories mask (Proposition)
Hard evidence via node=category
Marginals, conditionals, and joint marginals (all conditional on evidence)
This class is designed specifically to satisfy the methods required by
JunctionTreeUpdater.RowSummingExactUpdater-style updater plumbing, but uses JunctionTreeInference
for marginals/joints/conditionals.
Test class for verifying the functionality of operations related to junction tree updates in Bayesian networks.
Wrapper for KCI test.
The Kci class implements the Kernel-based Conditional Independence (KCI) test for statistical independence between
variables.
Enum representing the type of kernel function used in kernel-based computations.
The
KciSmokeTest class contains unit tests to evaluate the performance and correctness of the Kci
class, specifically focusing on conditional independence tests.Wrapper for KVC BIC score.
KCI-inspired local score for continuous variables.
Enumeration representing different modes for bandwidth computation.
Gives an implemented that is implemented by classes that evaluate scalar valued kernels
Soces the Gaussian kernel for a given bandwidth.
Wrapper for Kernel Marginal Likelihood Score.
KML: Kernel Marginal Likelihood score for mixed (continuous + discrete) parents
Kernel Marginal Likelihood (KML) score for continuous variables.
Provides various kernel utilities.
Implements the "batch" version of the K Means clustering algorithm-- that is, in one sweep, assign each point to its
nearest center, and then in a second sweep, reset each center to the mean of the cluster for that center, repeating
until convergence.
Implements the K-Means clustering algorithm using the k-means++ initialization method and iterative refinement.
Represents the result of a clustering operation using the KMeans algorithm.
Stores information about required and forbidden edges and common causes for use in algorithm.
Implements a knowledge edge X-->Y as a simple ordered pair of strings.
Represents a "Other Group" in Knowledge, which can be understood as: Group1 -> Group2 where there are edges
between all members of Group1 to Group2.
Implementation of the KnowledgeSatisfied class.
An additional, named tier structure over (a subset of) the variables of a
Knowledge
object, independent of the main temporal tiers and of every other tier structure.Interface implemented by classes that are capable of participating in the transfer of knowledge objects.
Deprecated.
wrapper class for passing factor+edge via a propertyChange event
Identifies a particular factor (by name) at a particular lag (integer).
Implements a graph allowing nodes in the getModel time lag to have parents taken from previous time lags.
Lag graph.
LagGraphParams class.
SVAR-style lag mirroring policy.
Stores a SEM model, pared down, for purposes of simulating data sets with large numbers of variables and sample
sizes.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Shared post-processing refinements applied to the latent-variable graph
produced by Trek-MIMIC-style searches.
The evolving latent structure discovered by RLCD over one partition of observed variables: a dictionary from
covers (latent or observed non-sink groups) to their children, together with the bookkeeping sets the search
reads (active set, non-sink set, children of non-atomic covers, pending rank-deficient sets and clusters).
A signed adjacency matrix with its variable names.
The value stored for each cover key: children, strict subcovers, "fake children" (the measured descendants not
fully adjacent in the stage-1 skeleton; only used to decide whether an update changed anything), and the
refined flag (always false in the reachable code).
One recorded rank-deficient set: the covers found rank deficient, the non-sinks used in the test, and the list
of original rank-deficient sets merged into it (Python keeps this as the third list element; it is carried
along but, as in the Python, not used by the downstream logic).
Evaluates the adequacy of latent-latent connections in an estimated MIMIC-style graph against
a true graph.
Unordered pair of latent names representing latent-latent adjacency.
Signature of a latent node based on its measured parents and measured children.
Result object for a latent-latent adequacy evaluation.
The LatentNameAssigner class is responsible for assigning suitable latent names to
blocks in a Block Specification (BlockSpec) based on provided clusters and naming modes.
A Config instance with the current builder's configuration settings.
Builder class for constructing instances of the Config class with customizable properties.
Recovers measured parents of already recovered latent variables.
Implements purification step of Silva et al.'s BuildPureClusters algorithm.
A tagging interface for algorithms that can be used for latent structure search.
LayoutUtil class.
The layouts that can serve as the default layout: the ones that need
nothing but the graph.
Lays out a graph by linearly summing repulsive force between all nodes
and attractive force between adjacent nodes.
Lays out a graph by placing springs between the nodes and letting the
system settle (one node at a time).
Callback interface for reporting layout progress.
Supplies the rendered box size of each node, so a layout can space nodes
by what they actually take up on screen.
No-op listener for headless / non-GUI use.
Swing adapter that wraps a
ProgressMonitor.A version of the Lee and Hastic simulation.
The LegalCpdag class implements the Statistic interface and provides methods to evaluate whether an estimated graph
is a Legal CPDAG.
Legal PAG
Determines whether nodes indexed as (n1, center, n2) form a legal pair of edges in a graph for purposes of some
algorithm that uses this information.
Legendre BIC score
Represents the result of a local fit in a statistical model.
A likelihood-ratio conditional independence (CI) test built on top of
LegendreBicScore local polynomial fits.Lazily enumerates the Loyal Equivalent Graphs (LEGs) of a directed Markov equivalence class by
walking the class transformationally, via Zhang & Spirtes' legitimate directed-edge
reversals rather than by re-orienting the circle component from scratch.
The MNARDataSimulator class provides functionality to simulate Missing Not at Random (MNAR) data.
This class represents a continuous MNAR simulation.
Linear Fisher Model.
Implements a linear update function, Gi.0 = L(Parents(G0.0)) + ei, where P
is a polynomial function and ei is a random noise term.
Represents a linear function in an n-dimensional space (R^n -> R).
Data with Gaussian variables that have linear relationships.
Linearizing ("un-warping") transform: estimates, for each variable, a monotone
Yeo-Johnson transform chosen to make that variable's relations to the other
variables as LINEAR as possible, and returns the dataset with all transforms
applied (columns standardized).
Linear regression using EJML's QR-based solve (stable).
Implements a particular simulation for experimental purposes.
A simulation method based on the mixed variable polynomial assumption.
IcaLingam class implements the Algorithm and ReturnsBootstrapGraphs interface.
LiNGAM (Shimizu et al., 2006), with small numerical hardening to match the stabilized LiNG-D pipeline.
An example script to simulate data and run a comparison analysis on it.
IcaLingD is an implementation of the Algorithm interface that performs the LiNG-D algorithm for discovering
causal models for the linear non-Gaussian case where the underlying model might be cyclic.
LiNG-D (Lacerda, Spirtes, Ramsey, Hoyer, 2012).
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
Load data sets and graphs from a directory.
A confusion matrix for local graph accuracy check --i.e.
The LocalGraphPrecision class implements the Statistic interface and represents the Local Graph Precision statistic.
LocalGraphRecall implements the Statistic interface and represents the local graph recall statistic.
Sundry methods for logging data.
Implements a logistic regression algorithm based on a Javascript implementation by John Pezzullo.
The result of a logistic regression.
Represents a lognormal distribution for purposes of sampling.
A logarithmic transform to apply to a single variable: the direction (log or unlog), the offset a, and the
base.
Sets up streams for logging via the Java logging API.
Contains utilities for logging search steps.
Stores a 2D array of long data.
Reshapes a long-format data set (one row per unit per occasion, e.g., one row per student per assessment) into a
wide-format data set (one row per unit, one column per occasion per measured variable).
How multiple long rows for the same (unit, level) combination are combined into one wide cell.
The wide data set, the unit keys in row order (one list of row-key values per wide row), and a findings-only
report.
This is merely a main program used to read a binarized measurement data set and to instantiate a BoolSearch and run
one or more search methods of that instance.
This is merely a main program used to read a binarized measurement data set and to instantiate a BoolSearch and run
one or more search methods of that instance.
Class that makes some very simple tests on the classes LtMatrix, Graph, and Biolingua
LTestPredictorSearch class.
LTestQnet3 class.
LTestReveal class.
This is merely a main program used to read a binarized measurement data set and to instantiate a RevealSearch and run
one or more search methods of that instance.
This is merely a main program used to read a binarized measurement data set and to instantiate a RevealSearch and run
one or more search methods of that instance.
LTestSsys1 class.
Implements a space-efficient Lower Triangular Matrix of elements of type
shortImplements a space-efficient Lower Triangular Matrix of elements of type
floatWrapper for LV-BOSS: the fully score-based latent-variable search that embeds a MAG projection
inside a BOSS-style search over orders, scored by the exact RICF Gaussian MAG BIC
(
MagRicfBicScorer).LV-BOSS: a fully score-based latent-variable search that embeds the MAG projection inside a
BOSS-style search over orders.
This class represents the FCIT algorithm, which is an implementation of the FGES-FCI algorithm for learning causal
structures from observational data using the BOSS algorithm as an initial CPDAG and using all score-based steps
afterward.
LV-Heuristic is a class that implements the IGraphSearch interface.
Gives a BIC score for a linear, Gaussian MAG (Mixed Ancestral Graph).
Takes a MAG in a PAG using Zhang's method and then reports the MAG DG BIC score for it.
Wrapper for degenerate Gaussian BIC score
Gives a BIC score for a linear, Gaussian MAG (Mixed Ancestral Graph).
Takes a MAG in a PAG using Zhang's method and then reports the MAG DG BIC score for it.
Projects a total order of the observed variables to a high-scoring ancestral graph consistent with
that order: the latent-variable analog of BOSS's grow-shrink projection, and the inner step of the
planned LV-BOSS.
Exact Gaussian BIC for a MAG (more generally, for any ADMG over the data's variables with directed and
bidirected edges only), computed by maximum likelihood via RICF (
RicfEjml), with a district-wise
decomposition and a cache so that searches re-scoring many similar graphs pay only for the districts
that changed.Gives a BIC score for a linear, Gaussian MAG (Mixed Ancestral Graph).
Takes a MAG in a PAG using Zhang's method and then reports the MAG SEM BIC score for it.
Converts a MAG to a PAG.
Interface for a Bayes updating algorithm that's capable of doing manipulation.
Stores information for a variable source about evidence we have for each variable as well as whether each variable
has been manipulated.
Constructs as a (manual) update graph.
Stores the parameters needed to generate a new lag graph, whether randomized or manually constructed.
Maps a parameter to the matrix element where its value is stored in the
model.
Search-agnostic Markov-audit utilities: given ANY graph and an independence test, find the
conditional independencies the graph entails that the data reject, with the family-wise false
discovery rate controlled, and derive from those failures the vertex set a targeted repair
should be seeded at.
Checks whether a graph is Markov given a data set.
Stores the set of m-separation facts and the set of m-connection facts for a graph, for the global check.
A single record for the results of the Markov check.
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Represents a markov check statistic that calculates the Binomial P value for whether the p-values for the estimated
graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Binomial P value for whether the p-values for the estimated
graph are distributed as U(0, 1).
Tagging interface.
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Calculates the Anderson Darling P value for the Markov check of whether the p-values for the estimated graph are
distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Represents a markov check statistic that calculates the Kolmogorov-Smirnoff P value for whether the p-values for the
estimated graph are distributed as U(0, 1).
Parametric-bootstrap null reference for the Markov check
The real-data check statistics and the null distributions, with empirical p-values and
component timings.
The simulator used to generate null draws from the fitted (data, DAG) model.
Calculates the Matthew's correlation coefficient for adjacencies.
Calculates the Matthew's correlation coefficient for adjacencies.
Some extra mathematical functions not contained in org.apache.commons.math3.util.TMath.
Implements a Matrix of elements of type
shortWraps the EJML linear algebra library for most uses in Tetrad.
Implements a Matrix of elements of type
floatClass Matrix includes several public static functions performing matrix operations.
Checks whether a PAG is maximal.
MaximalMag statistic.
Provides some useful utilities for dealing with Markov blankets and Markov blanket DAGs.
Calculates the number of tests Kolmogorov-Smirnoff under the null hypothesis H0 of independence for the Markov check
of whether the p-values for the estimated graph are distributed as U(0, 1).
Calculates the number of tests Kolmogorov-Smirnoff under the alternative hypothesis H1 of dependennce for the Markov
check of whether the p-values for the estimated graph are distributed as U(0, 1).
Returns a data set in which missing values in each column are filled using the mean of that column.
Simulates measurement genetic data using an underlying GeneHistory object
to generate individual cell data.
Wraps MeasurementSimulator so that it may be used as a parameter object.
Implements Meek's complete orientation rule set for PC (Chris Meek (1995), "Causal inference and causal explanation
orienting.
Tags a session node as "memorable", so that it won't be forgotten when a model is destroyed.
A "lite" chained-equations (MICE-style) multiple imputer for continuous, discrete, or mixed data, using
predictive mean matching (PMM) as the single imputation engine for both variable types.
Reports elapsed time in wall time, user time, and CPU time in milliseconds.
An enum for the type of time.
Mimbuild Bollen.
MimbuildBollen (BlockSpec version)
Mimbuild PCA.
Mimbuild over the first principal components of (pure) clusters, driven by a BlockSpec.
Deprecated.
Benchmark harness for MIMIC-style algorithms.
Produces a readable text report for a MIMIC benchmark run.
Produces a tab-delimited benchmark report for a MIMIC benchmark run.
Stores the results of multiple benchmark trials and provides simple averages by algorithm.
Stores summary statistics from evaluating an estimated MIMIC graph against a true model.
Evaluates estimated MIMIC-style graphs against a true
MimicModel.Stores a generated MIMIC model together with the designated input, latent, and output
variables.
Interface for running a MIMIC-style search algorithm inside the benchmark harness.
Stores the complete result of one benchmark trial.
Quantile-grid binning for conditioning variables Z, returning groups of row indices.
Configuration for minimax-style quantile-grid binning used to approximate conditioning on Z.
Wrapper for Minimax binning test.
Minimax CI test: a stratified, permutation-calibrated, nonparametric conditional
independence test for mixed data (continuous + discrete).
Cache for quantile-grid binning groups used by minimax-style conditional independence tests/scores.
Some utilities for generating misclassification tables for graphs.
A descriptive audit of the missingness in a dataset, intended to be computed (and logged) before a search is run on
real data, and to give the user the evidence needed to choose a
MissingDataPolicy.The result of Little's MCAR test: the chi-square statistic, its degrees of freedom, the p-value, and pattern
accounting.
An explicit statement of how missing values in a dataset are to be handled by a score, independence test, or search
wrapper.
Stage 3 of the missing-data experiments: how well does BOSS recover the graph, and the causes of a designated
target, under each missingness mechanism and each way Tetrad has of handling missing values?
Stage 2 of the missing-data experiments: does each missing-data policy make the linear Gaussian BIC score rank
the true DAG above its single-edge neighbours?
An immutable specification of how missing data are to be handled: a
MissingDataPolicy together with the
parameters that policy needs (EM settings for MissingDataPolicy.EM_COVARIANCE, the number of imputations
for MissingDataPolicy.MULTIPLE_IMPUTATION, and so on).How the effective sample size used by penalized scores (e.g., the n in BIC) is determined when the analysis
runs on a covariance matrix estimated from incomplete data.
Small shared utilities for the missing-data policies: listwise deletion, resolution of a possibly-null
MissingDataSpec to a policy (with a logged warning where the historical behavior was a silent switch), a
cheap missingness summary suitable for logging from constructors, and the effective-sample-size calculation for
analyses run on covariance matrices estimated from incomplete data.Appends missingness indicators to a dataset.
The augmented dataset together with a record of what was done, for logging and for the session box to display.
Options controlling which indicators are added and what is attached to the result.
Injects missing values into a dataset under a per-cell logistic propensity, with optional terms that make the
mechanism MAR or MNAR as well as MCAR.
One term in the deletion propensity of a target variable: the effect of a driver variable's standardized
value, or of its missingness indicator, on the log odds that the target is deleted.
The terms of the deletion mechanism beyond the per-variable level and the row effect.
The mechanism class of an injection.
What the mechanism was, and how monotone the realized pattern is.
A report of what was actually injected, for checking that the realized pattern is the intended one.
The injected data together with its reports.
The injection specification.
Works out what dropping every variable whose missingness rate exceeds a threshold would do to a dataset,
without dropping anything.
A variable that a threshold would drop, with what is needed to judge whether dropping it is safe.
The consequence of applying one threshold.
A capability declaration for scores and independence tests, stating what the component itself can do with data
containing missing values.
Data with variables that have linear relationship.
Stores a 2D array of double continuousData.
Stage 4 of the missing-data experiments: on mixed continuous and discrete data, which way of handling missing
values works best with the embedded scores, degenerate Gaussian BIC (DG-BIC) and optionally basis-function BIC
(BF-BIC)?
Represents a Gaussian mixture model -- a dataset with data sampled from two or more multivariate Gaussian
distributions.
Wraps a chi square distribution for purposes of drawing random samples.
Estimates parameters of the given Bayes net from the given data using maximum likelihood method.
Estimates parameters of the given Bayes net from the given data using maximum likelihood method.
Stores a table of probabilities for a Bayes net and, together with BayesPm and Dag, provides methods to manipulate
this table.
An enumeration representing the different types of CptMap.
The InitializationMethod enum represents different methods of initializing a class object.
Stores a table of probabilities for a Bayes net and, together with BayesPm and Dag, provides methods to manipulate
this table.
Implements the MMHC algorithm.
Implements the Min-Max Markov Blanks (MMMB) algorithm as defined in Tsamardinos, Aliferis, and Statnikov, Time and
Sample Efficient Discovery of Markov Blankets and Direct Causal Relations (KDD 2003).
Creates a data set in which missing values in each column are filled using the mode of that column.
Provides static methods for generating variants of an input graph.
The ModelObserver interface is implemented by classes that want to observe changes in a model.
Wrapper for M-separation test.
Oracle ChangeTest backed by a known true graph, for exhaustive verification harnesses.
Wrapper for Fisher Z test.
Checks independence facts for variables associated with the nodes in a given graph by checking m-separation facts on
the underlying nodes.
The MsepVertexCutFinder class is responsible for finding "choke points" within a given directed acyclic graph (DAG)
using d-separation principles.
Implements an algorithm that takes multiple data sets as input.
A score wrapper that can construct its per-data-set scores jointly, coordinating any
data-dependent representation choices across the data sets.
Aug 7, 2018 10:21:59 AM
Represents a multidimensional second-degree Taylor series approximation for a differentiable function.
Stores a table of cells with int values of arbitrary dimension.
Implements the Anderson-Darling test against the given CDF, with P values calculated as in R's ad.test method (in
package nortest).
The MultiLayerPerceptron class represents a simple feedforward neural network with one output and support for
multiple hidden layers.
The MultiLayerPerceptronDjl class provides a customizable implementation of a Multi-Layer Perceptron (MLP) for tasks
like regression or classification using the Deep Java Library (DJL).
This class implements a 1-dimensional Multi-Layer Perceptron (MLP) function.
Represents a random Multi-layer Perceptron (MLP) function from R^n to R.
Wrapper for Fisher Z test.
An interface for multiple-imputation methods: given a dataset with missing values, produce m completed copies in
which every missing entry has been replaced by a draw from an imputation model, with observed entries unchanged.
Harness comparing the multi-subject cyclic methods in Tetrad on a common cyclic
simulation: CCD and CPW, each run with the multi-dataset Fisher-pooled Fisher Z test,
and FASK-Vote and FASK-Pool, each run with all five adjacency settings of
PooledAdjacencySearch.Method.Allows a view of a matrix to be created that is a subset of the original matrix, to allow parts of a matrix to be set
using indices in the view.
A multiple imputer for continuous data under a saturated multivariate normal model.
Deprecated.
An example script to load in data sets and graphs from files and analyze them.
Calculates Mixed Variables Polynomial likelihood.
Deprecated.
Implements a mixed variable polynomial BIC score.
Companion study to
NabiIdentificationProbe: does the Nabi et al.Numerical probe of the identification boundary in Nabi, Bhattacharya and Shpitser, "Full Law Identification in
Graphical Models of Missing Data: Completeness Results" (PMLR 119, 2020).
Specifies the protocol used in Tetrad for variable names.
Provides functionality for natural sorting of strings and objects.
Represents a natural key for a possibly-lagged node name of the form
"name" or "name:lag".Represents a natural key, which consists of a string prefix and an optional numeric suffix.
NbComponent interface.
NbFunction class.
NbFunctionAnd class.
NbFunctionOr class.
NbFunctionSum class.
NbFunctionSV class.
NbGene class.
NbGeneAnd class.
NbGeneOr class.
NetBuilderModel class.
Pure-library neural-network estimator for a DAG factorization.
Tuning parameters for
NNEstimator.No almost cyclic paths condition.
No cyclic paths condition.
Represents an object with a name, node type, and position that can serve as a node in a graph.
Represents the adequacy summary of a specific node in a model with information about its
characteristics, performance metrics, and improvement over a baseline.
Immutable per-node summary produced by k-fold cross-validation in
NNEstimator#crossValidate(int).
An unordered pair of nodes.
The adjacency precision.
The adjacency precision.
An enum of the node types in a graph (MEASURED, LATENT, ERROR).
Node variable type.
Number of NOT X~~>Y in true graph for which also NOT X~~>Y in estimated graph.
Number of NOT X~~>Y in true graph for which also NOT X~~>Y in estimated graph.
Indicates an algorithm is nonexecutable.
A linear SEM simulation whose exogenous noises are drawn independently from the distribution given by the
customNoiseExpression parameter (default Exp(1)) rather than from Gaussians.
Represents a nonlinear function of linear model for generating synthetic data based on a directed acyclic graph
(DAG).
Represents the type of distortion applied in a nonlinear additive causal model.
This class represents a nonlinear functions of linear simulation.
Practical nonlinearity tests for conditional mean E(Y|X).
Represents cleaned data for nonlinearity tests, with NaNs removed from y and X.
Encapsulates the result of a statistical test, including the test statistic, p-value,
and the decision to reject the null hypothesis.
Calculates the F1 statistic for adjacencies.
A normal distribution that allows its parameters to be set and allows random sampling.
The bidirected true positives.
The bidirected true positives.
Returns row positions for placing rooks for an n x n matrix so the rooks
cannot attach each other, with a given boolean[][] specification of where rooks are allowed to be placed.
NtadExplorer contains utility methods for identifying and analyzing rank-deficient m×m variable subsets (n-tads)
within a dataset.
Represents the result of a near-total aggregate decomposition (NTAD) analysis.
Simple harness / demo driver for NtadExplorer.
NtadTest is an abstract base class for implementing ntad-based statistical tests.
The adjacency precision.
Represents the NumberEdgesEst statistic, which calculates the number of arrows in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of arrows not in unshielded colliders in the
estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of unshielded colliders in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of edges in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of edges in colliders in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of edges in unshielded colliders in the
estimated graph.
The NumberEdgesTrue class is an implementation of the Statistic interface.
Provides an application-wide "memory" of the number format to be used.
Wraps a 2D array of Number objects in such a way that mixed data sets can be stored.
Prints the number of edges in the estimated graph.
Prints the number of edges in the true graph.
Represents the NumberEdgesEst statistic, which calculates the number of tails in the estimated graph.
Represents the NumberEdgesEst statistic, which calculates the number of unshielded colliders in the estimated graph.
The bidirected edge precision.
The adjacency precision.
The adjacency precision.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The former name of the statistic now called
NumCompatiblePotentiallyDirectedEdgeAncestors.The former name of the statistic now called
NumCompatiblePotentiallyDirectedEdgeNonAncestors.The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Counts the number of X<->Y edges for which a latent confounder of X and Y exists.
The bidirected true positives.
The bidirected true positives.
Represents a statistic that calculates the number of correct visible ancestors in the true graph that are also
visible ancestors in the estimated graph.
The number of covering adjacencies in an estimated PAG compared to the true PAG.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Number of X-->Y in est.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The number of adjacencies in the estimated graph but not in the true graph.
The number of genuine adjacencies in an estimated PAG compared to the true PAG.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
Number of X---Y in est.
Number of parameters for a discrete Bayes model of the data.
Number of Xo->Y in est.
The bidirected true positives.
Number of X---Y in est.
Represents a statistic that calculates the number of correct visible ancestors in the true graph that are also
visible ancestors in the estimated graph.
A class that implements the Statistic interface to calculate the number of visible edges in the true PAG.
Simulates data with the anatomy of a real observational scientific dataset (the archetype is
the Algerian Forest Fires dataset, but with all complications defaulted off this is a plain
mixed-data cross-sectional study).
Computes the complete Ordered Local Markov Property (OLMP) for an acyclic
directed mixed graph (ADMG), as defined and proved sound and complete by Richardson
(2003, Scandinavian Journal of Statistics 30:145-157, Theorem 2).
Utility class for computing the ordered local Markov property of a maximal ancestral graph (MAG).
An ordered pair of objects.
A confusion matrix for orientations:
The orientation precision.
Represents an implementation of the Statistic interface that calculates the Orientation Recall.
Utilities for computing the Henckel–Perković–Maathuis O-set (optimal adjustment set)
in DAGs and amenable CPDAGs.
Unit tests for OSet (Henckel–Perković–Maathuis O-sets).
Represents a graph that's output by a genetic search algorithm.
The PagAdjacencyPrecision class implements the Statistic interface and represents the adjacency precision compared to
the true PAG (Partially Ancestral Graph).
A class that implements the PagAdjacencyRecall statistic.
A thread-safe, identity-preserving cache that converts DAGs or MAGs to PAGs.
Unit tests for PagCache:
1) Repeated calls on same source return the SAME PAG object (identity preserved).
Utility class for handling operations related to partially oriented edges in a PAG (Partial Ancestral Graph).
The PagLegalityCheck class provides utility methods for validating the legality of Partial Ancestral Graphs (PAGs)
and Maximal Ancestral Graphs (MAGs).
Stores a result for checking whether a graph is a legal MAG--(a) whether it is (a boolean), and (b) the reason
why it is not, if it is not (a String).
Stores a result for checking whether a graph is a legal PAG--(a) whether it is (a boolean), and (b) the reason
why it is not, if it is not (a String).
PAG-Sampling-RFCI, the former name of the class now called PagSamplingRfci.
Jan 29, 2023 3:45:09 PM
Jan 29, 2023 4:10:52 PM
Decides, empirically, whether evaluating a covariate-adjustment functional at the RICF-fitted covariance matrix
beats evaluating it at the sample covariance matrix, when the causal structure is known as a PAG.
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.
Give a list of options for rules for doing the non-Gaussian orientations.
Gives a list of options for non-Gaussian transformations that can be used for some scores.
Estimates a covariance matrix from data with missing values by pairwise deletion, without a model of the data.
Computes the pairwise Markov property for an acyclic directed mixed graph
(ADMG).
An enum of the types of the various comparisons a parameter may have with respect to one another for SEM estimation.
A class for implementing constraints on the values of the freeParameters of of instances of the SemIm class.
Enum for representing different types of parameter constraints.
Describes a parameter.
Stores descriptions of the parameters for the simulation box.
Stores information about the identity of a SEM parameter--its name, its type (COEF, COVAR), and the node(s) it is
associated with.
Adds a column to the output table in which values for the given parameter are listed.
Implements an ordered pair of objects (a, b) suitable for storing in HashSets.
Stores a list of named parameters with their values.
Renders the effective parameter settings of a configured algorithm as plain text suitable
for copying into an email, a lab notebook, or a script - one
name = value line per
parameter, grouped into the same sections the parameter panel displays (algorithm, score,
test, bootstrapping), with section titles taken from the annotations.The result of applying pasted settings text: the section titles encountered, the names of
parameters whose values were applied, and the lines that were skipped (with reasons).
A harness for evaluating a search algorithm over a grid of parameter settings and recording, per setting, the
evidence a parameter choice should rest on: the point-estimate graph on the full data, a probability-annotated
aggregate of searches on shared resamples (edge probabilities displaying identically to bootstrap results
elsewhere in Tetrad), the StARS-style adjacency instability across those resamples, and Markov-check statistics
for the point graph if a Markov-check test is configured.
A utility to create/modify parameters.
Tags a class that can return values for parameters.
Static final string constants for use in parameter maps.
An enum of the free parameter types for SEM models (COEF, MEAN, VAR, COVAR).
Builds a parent *superset* per node without assuming a single pooled DAG.
Represents the configuration settings used for statistical screening and optional bagging operations in the
parent superset construction process.
Represents the type of correlation score used for statistical calculations or comparisons.
Calculates partial correlation using the recursive method.
Frequency function of partial correlation r(12|34...k), assuming that the true partial correlation is equal to zero.
Result of a partial edge strength computation performed by
NNEstimator.computePartialEdgeStrength(String, String, int).Paths class.
An algorithm to find all cliques in a graph.
Represents the result of a CPDAG legality check.
Enumeration representing various violations associated with CPDAGs (Completed Partially Directed Acyclic Graphs).
Peter/Clark algorithm (PC).
Implements the PC (Peter–Clark) causal discovery algorithm for learning a
causal graph from conditional independence information.
Enum representing whether bidirected edges are allowed in the graph.
An enumeration that defines the styles of collider orientation in a graph or network.
A utility class that encapsulates a triplet of nodes.
Peter/Clark algorithm with adjacency-rescue (PcAR): PC augmented with detection, and optionally
repair, of cancelled unfaithful-triangle edges.
Implements the PC (Peter–Clark) causal discovery algorithm for learning a
causal graph from conditional independence information.
Enum representing whether bidirected edges are allowed in the graph.
How unshielded triples x - z - y with x and y nonadjacent are decided to be colliders.
A candidate rescuer: the deleted pair, the sepset that removed it, which clash test caught
it, and whether a RECOVER action was actually taken for this deletion.
A
PcAR.RecoveryOddsEstimator implementing Sec.A diagnostic Markov-audit flag: an implied independence x _||_ y | conditioningSet that did
not hold under a fresh test.
Functional hook for a real Markov-audit implication pass, given the finished graph and the
test.
A bidirected orientation clash: the edge
u-z, present in the graph, that two
different unshielded triples demand carry an arrowhead in opposite directions (CLASH-PASS
lines 6-7).Functional hook supplying posterior odds that a flagged deletion is a genuine edge, for the
RECOVER decision.
What to do with a tier-1 (orientation-clash) positive.
A utility class that encapsulates a triplet of nodes.
PC.
Modifies the PC algorithm to handle the deterministic case.
PC-Max.
PC.
Searches for a CPDAG representing all the Markov blankets for a given target T consistent with the given independence
information.
PCMCI wrapper for algcomparison.
PCMCI (Runge et al.) — minimal, time-series implementation with
lagged edges only (τ≥1).
Builder class for constructing instances of the Pcmci class.
Implements PDAG/PAG IDA with **incremental FCI propagation** after each local orientation at X.
The
IDA_TYPE enum represents the different algorithmic approaches
available in IDA (Intervention Distribution Adjustment) processes.Convenience container used elsewhere in Tetrad.
The result of the PAG branch: the possible total effects, together with a count of the refinements that
could not be estimated.
Provides a suite of unit tests for evaluating the functionality of the PagIda algorithm when applied to partially
directed acyclic graphs (PAGs).
Chooses a BIC penalty discount so that the expected number of spurious edges over a whole search meets a budget,
for any score whose gain from adding one parent has the form
The null distribution of the per-pair LRT for one degrees-of-freedom class, as a scaled chi-square
kappa * chi-square(nu) fitted to its first two moments (Satterthwaite), together with how many null pairs
belong to the class.
A calibrated penalty discount together with everything needed to interpret it: the degrees-of-freedom histogram
it was computed from, the per-class false-positive levels it implies, the recall-side effect floor, and a sweep
of the same quantities over a range of penalty discounts.
One row of the sweep: a penalty discount and what it implies.
The adjacency precision.
The adjacency precision.
Per-fact effective sample sizes from block structure
Runs some basic performance tests of various algorithm.
Contains some tests for Dan Malinsky, that might be of interest to others.
Generates all of the permutations of [0,..., numObjects - 1], where numObjects is numObjects nonnegative integer.
Stores a matrix together with a row and column permutation.
Implements common elements of a permutation search.
Implements common elements of a permutation search.
Searches for a legal-but-non-genuine PAG reachable by a single spurious-edge
deletion from a genuine legal Markov PAG; reports a discriminating-path census
(now over all phantom DDPs) and dumps near-misses for inspection.
Runs the real FCIT on every small latent DAG (oracle independence) and compares
the result to the true PAG, to test whether the constructed cold deadlocks are
actually reachable by FCIT's own edge-removal trajectory.
Parallel exhaustive enumeration over small latent DAGs that either proves no
legal-non-genuine PAG exists up to a given size or prints a witness, while
censusing phantom spine length and probing the under-commitment mechanism.
Exhaustive enumeration over DISTINCT TRUE PAGs, running PKE9's analysis once per
PAG.
PKE11: enumerate DISTINCT TRUE PAGs (magspace or dagsweep, as in PKE10) and, once per
PAG, run the real FcitSl from a GRaSP start, oracle-driven, reporting every PAG whose
terminal graph is not exactly G* (PKE8's end-to-end check over PKE10's population).
pke12: enumerate DISTINCT TRUE PAGs (magspace or dagsweep, as in PKE10) and, once per
PAG, run the real Fcit from a GRaSP start, oracle-driven, reporting every PAG whose
terminal graph is not exactly G* (PKE8's end-to-end check over PKE10's population).
pke13: enumerate DISTINCT TRUE PAGs (magspace or dagsweep, as in PKE10) and, once per
PAG, run the real GraspFci from a GRaSP start, oracle-driven, reporting every PAG whose
terminal graph is not exactly G* (PKE8's end-to-end check over PKE10's population).
pke14: enumerate DISTINCT TRUE PAGs (magspace or dagsweep, as in PKE10) and, once per
PAG, run the real FcitZm from a GRaSP start, oracle-driven, reporting every PAG whose
terminal graph is not exactly G* (PKE8's end-to-end check over PKE10's population).
pke15: enumerate DISTINCT TRUE PAGs (magspace or dagsweep, as in PKE10) and, once per
PAG, run the real BfciC from a BOSS start, oracle-driven, reporting every PAG whose
terminal graph is not exactly G* (PKE8's end-to-end check over PKE10's population).
pke16: enumerate DISTINCT TRUE PAGs (magspace or dagsweep, as in PKE10) and, once per
PAG, run the real BfciBryan from a BOSS start, oracle-driven, reporting every PAG whose
terminal graph is not exactly G* (PKE8's end-to-end check over PKE10's population).
pke17: enumerate DISTINCT TRUE PAGs (magspace or dagsweep, as in PKE10) and, once per
PAG, run the real Bfci from a BOSS start, oracle-driven, reporting every PAG whose
terminal graph is not exactly G* (PKE8's end-to-end check over PKE10's population).
Parallel exhaustive enumeration over small latent DAGs that either proves no
legal-non-genuine PAG exists up to a given size or prints a witness, while
censusing phantom spine length and probing the under-commitment mechanism.
Parallel exhaustive enumeration over small latent DAGs that either proves no
legal-non-genuine PAG exists up to a given size or prints a witness, while
censusing phantom spine length and probing the under-commitment mechanism.
Enumerator.
Enumerator.
Enumerator.
PKE7: does any gated Markov state exist that the latest FCIT-SL move set cannot solve?
PKE8: run the real FcitSl from GRaSP starts, oracle-driven, and report every class
whose terminal PAG is not exactly G*.
Parallel exhaustive enumeration over small latent DAGs, run under the corrected
(spanning, fully-covered) sepset regime, that either certifies the reachability
appendix's claims at a given size or prints witnesses.
Parallel exhaustive enumeration over small latent DAGs that either proves no
legal-non-genuine PAG exists up to a given size or prints a witness, while
censusing phantom spine length and probing the under-commitment mechanism.
Seeded random-sampling search that runs the PhantomKernelEnumerator probes on
PhantomCounterexampleHarness-style models, to surface diverse witnesses (in
particular deeper-spine phantoms) for analysis.
Checks determinism for PhantomKernelEnumerator5.
Simple command-line driver for PlotMatrixMimicSimulator.
PlotMatrixMimicSimulator (continuous-only, v1)
Tagging interface for parametric models.
Implements an n-dimensional point.
Stores a (x, y) point without having to use awt classes.
Wraps a chi square distribution for purposes of drawing random samples.
The SemBicTest class implements the IndependenceWrapper interface and represents a test for independence based on SEM
BIC algorithm.
Wrapper for the Poisson prior score (Bryan)
Implements Poisson prior score, a novel (unpubished) score that replaces the penalty term in BIC by the log of the
Poisson distribution.
Implements a polynomial as a sum of a list of terms whose variables are identified as integers in the set {0, 1, 2,
...}.
Implements a polynomial update function, Gi.0 = P(Parents(G0.0)) + ei,
where P is a polynomial function and ei is a random noise term.
Implements a term in a polymonial whose variables are mapped to indices in
in the set {0, 1, 2, ...}.
Estimates a common adjacency (skeleton) structure across multiple datasets sharing the
same variables.
How the common adjacency structure is estimated.
Degenerate-Gaussian likelihood-ratio conditional-independence testing under multiple imputation, pooled by
the rules for likelihood-ratio statistics: Meng and Rubin (1992) ("D3", the default, which is what the micd
package Witte et al.
The pooling rule.
The test-side counterpart of
PooledScoreWrapper: builds the inner test on each pooled data set and combines
them with IndTestMulti using Fisher's method (default) or Tippett's method on the per-data-set p-values,
per Params.POOLED_TEST_METHOD (data sets are assumed
independent of one another, e.g.The RLCD rank test over several imputations of one data set with missing values: each question RLCD asks is
answered once, from all of the imputations, instead of once per imputation.
A score wrapper that pools several data sets into one IMaGES score built from an inner score wrapper.
An algorithm that can take several imputations of one data set with missing values and run ONE search over them,
with the uncertainty from the missing values carried into each of its statistical decisions.
Implements the Possible-M-Sep search step of Spirtes, et al's (1993) FCI algorithm (pp 144-145).
Finds possible d-connecting undirectedPaths for the IonSearch.
This class represents a post-nonlinear SEM model.
Represents a Post-nonlinear Causal Model (Zhang and Hyvarinen, 2009, 2012).
Created by Erich on 8/21/2016.
Result of
NNEstimator.pruneByPredictiveContribution(int, double):
a per-child backward elimination of parents whose held-out predictive
contribution is not distinguishable from zero.One proposed edge deletion.
A helper class to encapsulate logic for preserving a Markov property for subsequent testing after an initial local
Markov graph has been found.
Initializes a graph by adding the previous time step only of each variable.
Uses BCInference by Cooper and Bui to calculate probabilistic conditional independence judgments.
Dec 17, 2018 3:44:46 PM
Implements a number of important functions from probability and
statistics.> 0
Spawns a persistent Python process running kci_server.py and communicates using JSONL over stdin/stdout.
Proportion of semi(X, Y) in estimated graph for which there is no semi(Y, X) in true graph.
Proportion of semi(X, Y) in true graph for which there is no semi(Y, Z) in estimated graph.
Represents propositions over the variables of a particular BayesIm describing an event of a fairly general
sort--namely, conjunctions of propositions that particular variables take on values from a particular disjunctive
list of categories.
Implemented by a
Score whose local score difference can be mapped back to a likelihood-ratio statistic with
a known reference distribution, so that the score can report a genuine p-value in addition to its accept/reject
verdict.A simulation whose design implies background knowledge that an analyst of the resulting data
would legitimately have - typically tiers given by the roles of the variables (design factors
before derived quantities before responses; context before system before indices before
outcomes) - and that can supply it for each emitted data model.
Implments a sextad-based Purify method.
Implements a tetrad-based purify method.
Estimates whether the p-values under the null are Uniform usign the Markov Checker.
Estimates whether the p-values under the null are Uniform using the Markov Checker.
An interface for performing conditional independence tests using Python.
Deprecated.
The PythonKciIndependenceTest class implements an independence test using the kernel
conditional independence (KCI) test provided through a Python backend, such as
causallearn.
The PythonRcitIndependenceTest class implements an independence test using the kernel
conditional independence (RCIT) test provided through a Python backend, such as
causallearn.
A utility class for working with Python-related resources.
Utilities for converting a quadratic-form statistic
Q = sum_i lambda_i * Z_i^2, Z_i ~ N(0,1),
into a p-value using fast analytic transforms that use the full eigen-spectrum.
The FCI orientation rules are almost entirely taken up with an examination of the FCI graph, but there are two rules
that require looking at the distribution.
The FciOrientDataExaminationStrategyTestBased class implements the FciOrientDataExaminationStrategy interface and
provides methods for checking unshielded colliders and determining orientations based on the Discriminating Path
Rule.
Enum representing the different types of blocking strategies.
R1.
R2.
R3.
A modified implementation of Dijkstra's shortest path algorithm for the R5 and R9 rules from Zhang, J.
Represents a node in Dijkstra's algorithm.
Represents a graph for Dijkstra's algorithm.
The rule that is being implemented, R5 or R9.
A distribution from which noise values are drawn.
Creates a random graph by adding forward edges.
The RandomFourier class generates a random Fourier series with specified cosine and sine amplitudes and frequency
terms.
A utility class for generating and evaluating random mathematical functions, including polynomials, Fourier series,
piecewise linear functions, radial basis functions, and sampled Gaussian processes.
An interface to represent a random graph of some sort.
The RandomGraph class provides methods for generating random graphs.
Generates random DAGs uniformly with certain classes of DAGs using variants of Markov chain algorithm by
Malancon, Dutour, and Philippe.
Creates a random graph by adding forward edges.
Flexible MIM (Multiple Indicator Model) generator.
Specification for a block of groups sharing the same rank and number of children per latent.
Enum representing the mode of linking between latent nodes across groups in the meta-DAG.
Creates a random graph by adding forward edges.
Flexible MIMIC (Multiple Indicators Multiple Causes) graph generator.
Specification for a block of MIMIC groups sharing the same structure.
Generates random MIMIC models.
A class that generates and evaluates a monotonic piecewise linear function defined over a specified domain and range.
Represents a piecewise linear function with randomly generated breakpoints and values.
Represents a bijective, piecewise linear function whose control points are generated randomly.
This class generates and evaluates a random piecewise cubic spline function.
A class that represents a Random Radial Basis Function (RBF) system.
Provides a static method for sampling without replacement from a dataset to create a new dataset with a sample size
supplied by the user.
Creates a random graph by adding forward edges.
Creates a random graph by adding forward edges.
Provides a common random number generator to be used throughout Tetrad, to avoid problems that happen when random
number generators are created more often than once per millisecond.
Wrapper for linear, Gaussian SEM BIC score.
Deprecated.
Rank Independence Test TS, the former name of the test now called Rank Independence Test TS Singletons.
Deprecated.
Deprecated.
A rank test over two (possibly overlapping) column sets of a data matrix, as used by RLCD.
The RankTests class provides a suite of methods and utilities for performing rank estimation and hypothesis testing
in Canonical Correlation Analysis (CCA) and Regularized Canonical Correlation Analysis (RCCA).
Represents an entry in the RCCA (Regularized Canonical Correlation Analysis) data structure.
Functional interface for performing a raw marginal independence test.
RBExperiments class.
Wrapper for RCIT test.
A Java implementation of the RCIT (Randomized Conditional Independence Test) and its
variant RCoT (Randomized Conditional correlation Test), following the architecture of
FfCiContinuous but with the feature-block construction described in:
Strobl, Zhang, and Visweswaran (2019).The Approx enumeration defines the types of approximation methods that can be used
for statistical computations or tests within the Rcit class.
An enumeration representing the types of features that can be used for
generating random feature mappings for RBF kernels.
ReadControl class.
ReadIdeker class.
Jan 27, 2016 4:46:07 PM
Jan 27, 2016 5:35:01 PM
Jan 27, 2016 5:37:40 PM
Feb 9, 2016 3:13:19 PM
Feb 9, 2016 3:14:08 PM
Feb 9, 2016 3:15:29 PM
Represents an adjustment mechanism for defining adjustment sets in causal inference across different types of
graphical models.
Represents the policy to be used for handling collisions in a specific context.
Represents the type of graph being analyzed for adjustment set definition.
NoAmenablePolicy is an enumeration that defines the possible policies to handle cases where a certain condition
or requirement is not amenable.
The RaMode enum represents the modes in which a specific operation or functionality can be executed.
Recursive adjustment for the case of multiple treatments X and multiple outcomes Y.
Sanity checks for AdjustmentMultiple:
Implements a procedure for constructing candidate separating sets between two
nodes under PAG semantics.
Three-valued result of path-blocking analysis.
The result of a blocking-set search.
A single endpoint mark: the endpoint at
at on the edge between
from and at.Selects the search strategy used by
RecursiveBlocking.blockPathsRecursively(Graph, Node, Node, Set, Set, int, int, int, int, boolean).Implements a recursive procedure for constructing candidate separating
sets between two nodes under PAG semantics.
The Blockable enum represents the state of an entity in relation to its
ability to be blocked.
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.
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.Differential / equivalence harness for the memoized continuation cache added
to
RecursiveBlocking.findPathToTargetVisit(Graph, Node, Node, Node, Set, Set, int, Set, Map, Set, int, int, long, int[]).The
RecursiveBlocking class implements a recursive procedure for
constructing candidate separating sets between two nodes under PAG semantics,
with optional verbose tracing for debugging and pedagogy.The Blockable enum represents the state of an entity in relation to its
ability to be blocked.
Lightweight indented tracer.
Finds separating sets for the discriminating path rule (R4 of the final FCI orientation rules, Zhang 2008) by
recursive path blocking rather than by searching over subsets of adjacents.
Tokenizes the given input character sequence using the type of delimiter specified bythe given CPDAG.
Implements a multiple regression model, allowing data to be specified either as a tabular data set or as a covariance
matrix plus list of means.
Implements a regression model from correlations--that is, from a correlation matrix, a list of standard deviations,
and a list of means.
Implements a regression model from tabular continuous data.
Stores the various components of a regression result so they can be passed around together more easily.
Sundry utilities for regression.
Utility class for regression-related functionalities, including linear and logistic regression.
v1: Represents the result of a logistic regression fit using IRLS.
v1: OLS fit via QR-based least squares: beta = argmin ||X*beta - y||_2.
Utility for reidentifying variables for multiple indicator structure searches.
EdgeListGraph subclass that applies an
EdgeReplicationPolicy whenever edges are added/removed or endpoints
are oriented.Tests for ReplicatingGraph with LagReplicationPolicy.
Reproduces the PKE14 SKELETON_DIFF violation ca....aaaa.acccacacacaccc and diagnoses it.
Sep 12, 2018 4:07:46 PM
The covariance among the measured variables that an estimated SEM leaves unexplained: the sample covariance
minus the covariance the model implies, with the model's error variances put back on the diagonal.
Interface for local regressors used to compute residual signatures: X ~ f(Pa).
Utilities for computing residual matrices given a regressor and either (a) a graph with parent sets, or (b) an
explicit parent map.
Provides some utilities for resolving inconsistencies that arise
between sepsets learned for overlapping datasets.
Gives the method to be used to resolve sepsets when they conflict.
Utilities for resolving inconsistencies that arise between sepsets learned for overlapping datasets.
A method for combining p values.
Implements a restricted version of the BOSS (Best Order Score Search) algorithm
that focuses search on a set of target variables and their immediate causes.
ReturnsBootstrapGraphs interface.
Provides the methods for computing mutual information between expression levels between genes and, for a given gene,
between points in time determined by a lag value.
Provides the methods for computing mutual information between expression levels between genes and, for a given gene,
between points in time determined by a lag value.
RevealOutputGraph class.
RevealOutputGraph class.
RevealOutputGraph class.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
This class contains as a member variable (cases) the time series data stored in an int array of microarray
measurements.
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.
Runs RFCI-BSC, which is RFCI with bootstrap sampling of PAGs.
Implements the RFCI-BSC (Really Fast Causal Inference with Bayesian Scoring
of Constraints) algorithm for learning PAGs (Partial Ancestral Graphs) from
discrete data with probabilistic uncertainty quantification.
Wrapper for linear, Gaussian SEM BIC score.
RCIT-inspired local score for continuous variables.
Defines the bandwidth selection modes for sigma calculation in the model.
Implements ICF as specified in Drton and Richardson (2003), Iterative Conditional Fitting for Gaussian Ancestral
Graph Models, using hints from previous implementations by Drton in the ggm package in R and by Silva in the Purify
class.
The fit con graph result.
RICF result.
Residual Iterative Conditional Fitting (RICF) for Gaussian ADMG / MAG models
(directed and bidirected edges only; no undirected/selection block).
Result of RICF: the implied covariance, the error covariance, both coefficient
matrices (
Beta and I - Beta), the sweep count, the final
convergence metric, and the Gaussian log-likelihood of the fitted model.Wrapper for the RLCD algorithm (Rank-based Latent Causal Discovery; Dong et al., ICLR 2024), which learns a graph
over the observed variables and newly introduced latent variables from rank constraints on the covariance matrix.
Rank-based Latent Causal Discovery (RLCD), from Dong, Huang, Ng, Song, Zheng, Jin, Legaspi, Spirtes, and Zhang,
"A versatile causal discovery framework to allow causally-related hidden variables," ICLR 2024.
Stage-1 search methods.
A watch-the-output accuracy study of RLCD on linear non-Gaussian data with latent variables, comparing the plain
search with the two recent additions:
Rlcd.setResolveTwoIndicatorLatents(boolean) and temporal-tier
knowledge, which RLCD now reads as constraining ancestry through latents.Stage 2 of RLCD over one partition of observed variables: the rank-deficiency search for clusters, translating
the module-level functions
findClusters, findClusters_at_k,
findClusters_at_k_by_nonsinks, structuralRankTest, and
findClusters_finish of RLCD_alg.py in causal-learn.Summarizes how stable an RLCD output is across repeated runs on resampled data.
A watch-the-output study of
Rlcd.setResolveTwoIndicatorLatents(boolean): RLCD is run with the step off and
on, on the same data, and the output is scored for how it represents the pair X1, X2.RoadmapTest: EM baseline vs Residual-clustering across scenarios.
Calculates a ROC curve and AUC (area under curve) for a list of scored cases whose inclusion in category C is known.
Utility class for estimating the average pairwise row correlation of a data matrix and computing the effective sample
size (Neff) based on the correlations.
Represents the result of an average pairwise row correlation estimation, containing the adjusted average row
correlation value, the effective sample size, and the number of row pairs used in the computation.
Interface for tests that can have their rows set on the fly.
Performs updating operations on a BayesIm by summing over cells in the joint probability table for the BayesIm.
RSkew.
RSkewE.
Rubin's rules for pooling a scalar estimate across the m completed data sets of a multiple imputation.
A pooled parameter.
An example script to save out data files and graphs from a simulation.
The RunEvaluation class is responsible for configuring parameters, executing
mimic benchmark trials, and generating a report based on the results.
RunKemmeren class.
Represents a generic sampling interface that provides a method
to obtain a sampled value.
Implements a conservative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
Implements a conservative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
An example script to save out data files and graphs from a simulation.
An example script to save out data files and graphs from a simulation.
Returns a scale free graph.
Sep 1, 2017 10:51:13 AM
Interface for a score.
Sep 26, 2017 1:14:01 AM
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.
Result holder for one accepted cluster.
May 14, 2019 11:23:54 AM
Stores a graph with a score for the graph.
Gives a way of interpreting a score as an independence test.
Interface for a class that represents a scoring of a SEM model.
Author : Jeremy Espino MD Created 1/12/18 2:05 PM
Interface that algorithm must implement.
Harness drop-in: checks whether the graph FCIT starts from (the PAG of the
BOSS/GRaSP DAG, i.e.
Encapsulates the results of evaluating the consistency of a seed graph with
the true graph in terms of Markov properties and related graph discrepancies.
Generates (nonrecursively) all of the selections from a items, where a is a nonnegative integer.
Wrapper for linear, Gaussian SEM BIC score.
Implements the linear, Gaussian BIC score, with a 'penalty discount' multiplier on the BIC penalty.
Represents a covariance matrix and regression coefficients.
A record that encapsulates the result of a likelihood computation.
Gives two options for calculating the BIC score, one describe by Chickering and the other due to Nandy et al.
Implements the continuous BIC score for FGES.
Scores an entire DAG using the SemBicScore.
The SemBicTest class implements the IndependenceWrapper interface and represents a test for independence based on SEM
BIC algorithm.
Estimates a SemIm given a CovarianceMatrix and a SemPm.
Implements the Gibbs sampler apporach to obtain samples of arbitrary size from the posterior distribution over the
freeParameters of a SEM given a continuous dataset and a SemPm.
Stores the freeParameters for an instance of a SemEstimatorGibbs.
Stores information for a SemIm about evidence we have for each variable as well as whether each variable has been
manipulated.
Represents the graphical structure of a structural equation model.
Calculates the F1 statistic for adjacencies.
The bidirected true positives.
A class implementing the Semidirected-Rec statistic.
Stores an instantiated structural equation model (SEM), with error covariance terms, possibly cyclic, suitable for
estimation and simulation.
Represents the result of a cyclic simulation.
Represents the result of a computation or analysis, encapsulating the following:
- The shrinkage mode used in an independent test.
This class provides functionality for rendering a parameterized structural equation model (SEM)
into lavaan syntax.
Stores information for a BayesIm about evidence we have for each variable as well as whether each variable has been
manipulated.
Interface for algorithm that optimize the fitting function of a SemIm model by adjusting its freeParameters in search
of a global maximum.
Optimizes a DAG SEM with hidden variables using expectation-maximization.
Optimizes a SEM using Powell's method from the Apache library.
Optimizes a DAG SEM by regressing each varaible onto its parents using a linear regression.
Optimizes a SEM using RICF for ADMGs (no selection bias).
Optimizes a SEM by randomly selecting points in cubes of decreasing size about a given point.
Parametric model for Structural Equation Models.
Represents propositions over the variables of a particular BayesIm describing and event of a fairly general
sort--namely, conjunctions of propositions that particular variables take on values from a particular disjunctive
list of categories.
Computes Satorra-Bentler robust ("sandwich") standard errors and the Satorra-Bentler
scaled chi-square for an estimated SEM, correcting normal-theory inference for
non-normal (e.g., heavy-tailed) data.
This class represents a Simulation using Structural Equation Modeling (SEM).
Random starting values for a SEM's free parameters that respect the scale of the sample covariance.
Includes methods for estimating the standard errors of the freeParameters of
an estimated SEM.
SEM the discretize.
Calculates updated structural equation models given evidence of the form X1=x1',...,The main task of such and
algorithm is to calculate P(X = x' | evidence), where evidence takes the form of a Proposition over the variables in
the Bayes net, possibly with additional information about which variables in the Bayes net have been manipulated.
This class takes an xml element representing a SEM semIm and converts it to a SemIM
This class converts a SemIm into xml.
Harness comparing the number of independence tests (d-separation oracle queries)
required by two methods to find a separating set for each non-adjacent pair
in a random DAG:
Exhaustive enumeration (PC-style): subsets of Adj(x) and Adj(y) in
greedy depth order.
Iterative-deepening recursive blocking (RB): calls
blockPathsRecursivelyFull with increasing path-length caps.
Harness measuring the number of independence tests (m-separation oracle queries)
required by iterative-deepening recursive blocking to find a separating set for
each sampled non-adjacent pair in a random PAG.
This class provides methods for finding sepsets in a given graph.
Stores a map from pairs of nodes to separating sets--that is, for each unordered pair of nodes {node1, node2} in
a graph, stores a set of nodes conditional on which node1 and node2 are independent (where the nodes are considered
as variables) or stores null if the pair was not judged to be independent.
This is the same as the usual SepsetMap described below, but also keeps up with the individual sets of conditioning
nodes for d-separation relations for use with the Distributed Causal Inference (DCI) algorithm.
Provides a covenience interface for classes that can generate and keep track of sepsets.
Provides a SepsetProducer that selects the first sepset it comes to from among the extra sepsets or the adjacents of
i or k, or null if none is found.
Provides a SepsetProducer that selects the first sepset it comes to from among the extra sepsets or the adjacents of
i or k, or null if none is found.
The class SepsetsMaxP implements the SepsetProducer interface and provides methods for generating sepsets based on a
given graph and an independence test.
The SepsetsMinP class is a concrete implementation of the SepsetProducer interface.
Provides a sepset producer using conditional independence tests to generate
the Sepset map, for the case where possible dsep sets are required.
Provides a sepset producer using conditional independence tests to generate
the Sepset map.
The SetEndpointStrategy interface provides a strategy for setting the endpoint of an edge in a graph.
Represents an ordered sextad of nodes.
Represents an ordered sextad of variables.
Shallow-commit ("near-x") variant of
RecursiveBlocking.ShallowRecursiveBlockingStack plus a delta-replay continuation memo.Explicit-stack (no JVM recursion) port of
ShallowRecursiveBlocking
(the recursive "near-x" shallow-commit reference).Tries to find a good shifting of variables to minimize average BIC for
time-series data.
Stores a 2D array of short data.
SimpleDataLoader class.
Randomizes a graph using existing factors by first removing all edges and then adding for each factor (a) an edge
from the same factor at time lag 1 and (b) a given number of factors chosen uniformly from all lagged factors with
lag > 0.
SimulateNetwork class.
SimulateNetworkMain class.
The interface that simulations must implement.
Some simulations may wish to implement this interface to specify a simulation path, which will be printed in the
output.
A list of simulations to be compared.
Top-level harness for the TSC simulation study.
Mean metrics for one algorithm at one sample-size level.
Results for one sample-size level within a study.
Aggregated results for one complete study (one rank condition).
Simulation harness for the TSBI (Trek-Separation Block Independence) test.
Mean metrics for one sample-size level.
Aggregated results for the complete TSBI study.
Jun 4, 2019 3:10:49 PM
Jun 4, 2019 5:21:45 PM
Created by jdramsey on 12/22/15.
A
Simulation implementation that returns a single supplied data set.Stores a single graph for use in simulations, etc.
PC.
Utility to attach singleton (measured) variables as children of latent blocks using a Wilks rank-drop criterion,
analogous to the latent->latent hierarchy test.
Enum representing policies for handling clusters in a single cluster analysis context.
A pretend distribution that always returns the given value when nextRandom() is called.
Skew.
SkewE.
SP (Sparsest Permutation)
Implements the SP (Sparsest Permutation) algorithm.
Adjusts GFCI to use a permutation algorithm (in this case SP) to do the initial steps of finding adjacencies and
unshielded colliders.
Uses SP in place of FGES for the initial step in the *-FCI algorithm.
Wraps a chi square distribution for purposes of drawing random samples.
Specifies how a column (continuous or discrete) should be discretized.
Euclidean dissimilarity metric--i.e., the sum of the differences in corresponding variable values.
Stability selection: runs the wrapped algorithm on resamples of the data and returns the graph containing exactly
those edges (with orientation) appearing in more than "percentStability" of the resample graphs.
A special SEM model in which variances of variables are always 1 and means of variables are always 0.
The initialization method for the model.
Stores a coefficient range--i.e.
Standardized SEM simulation.
*-FCI (StarFCI): the shipping latent-variable search of the StarFCI paper (Ramsey, Andrews, and Spirtes), in the
sepset-map-as-state formulation due to Bryan Andrews.
*-FCI (StarFCI): the GFCI-template latent-variable search of the StarFCI paper (Ramsey, Andrews, and Spirtes,
"StarFCI: A GFCI-Template Latent-Variable Search that Returns a PAG by Construction"), with the Markov-CPDAG
initializer abstracted (
StarFciB.getMarkovCpdag(boolean)) and supplied by subclasses: Gfci (from FGES),
Bfci (from BOSS), GraspFci (from GRaSP), SpFci (from SP).EXPERIMENTAL VARIANT (2026-10-19): StarFci with the PAG inference replaced by SEPSET PROJECTION.
EXPERIMENTAL VARIANT (2026-10-19): StarFciC (sepset projection) PLUS the recursive-blocking R4 fallback.
Deprecated.
Legacy shell over
StarFciOriginal; extend StarFci instead.Deprecated.
The knowledge handling of this class has been consolidated into
StarFci (formerly
StarFciGuaranteePag); with empty knowledge the two already coincided.ORIGINAL *-FCI implementation (CPDAG-collider copy plus sepset stamps, frozen sepsets, saturating step, gated
or ungated), preserved under this name on 2026-10-21 when
StarFci was replaced by the sepset-projection
/ re-selection formulation (formerly BfciBryan).StARS (Stability Approach to Regularization Selection): selects a value for one numeric parameter of a wrapped
algorithm by sweeping the parameter over [low, high] in steps of 0.5, measuring the StARS adjacency instability of
the algorithm's output over a fixed set of resamples at each value, choosing the value with the largest
instability strictly below the cutoff (Params "StARS.cutoff"), and then running the wrapped algorithm on the full
data at the chosen value.
The interface that each statistic needs to implement.
A list of statistics and their utility weights.
Contains a number of basic statistical functions.
Creates a table of stored cell probabilities for the given list of
variables.
///////////////////////////////////////////////////////////////////
Stores a file for reading in a lag graph from a file.
The RLCD rank test pooled over the strata of a discrete domain (batch, site, cohort) variable, after Theorem 4 of
Dong, Dai, Ng, Spirtes, and Zhang (ICML 2026), the Phase 1 test of their LCD-NOD framework.
The permutation form of the stratified (domain-pooled) rank test, after Theorem 5 of Dong, Dai, Ng, Spirtes, and
Zhang (ICML 2026).
Wrapper for the stratified (domain-pooled) rank conditional independence test, IndTestStratifiedRank -- the Phase
1 test of LCD-NOD (Dong, Dai, Ng, Spirtes, and Zhang, ICML 2026).
A watch-the-output harness for the stratified (domain-pooled) rank test of Dong et al.
Rank tests for cross-covariance matrices pooled across the strata of a discrete domain (or batch, site, cohort)
variable, after Theorem 4 of Dong, Dai, Ng, Spirtes, and Zhang, "Identifying Partially Observed Causal Models from
Heterogeneous/Nonstationary Data" (ICML 2026), the Phase 1 test of their LCD-NOD framework.
A watch-the-output runner for trying the stratified (domain-pooled) rank tests on a real data file.
Replication harness for Strobl, Visweswaran and Spirtes, "Fast Causal Inference with Non-Random Missingness
by Test-Wise Deletion" (Int J Data Sci Anal, 2018).
Scores a recovered structural graph against the true structural graph using
adjacency and arrowhead precision and recall.
Immutable result of a structural graph scoring comparison.
Calculates the structural Hamming distance (SHD) between the estimated graph and the true graph.
Generates (nonrecursively) all of the sublists of size b from a list of size a, where a, b are nonnegative integers
and a >= b.
An interface for suborder searches for various types of permutation algorithms.
An interface for suborder searches for various types of permutation algorithms.
The full record of a
ParameterSweep: the evaluated settings with their evidence (point graphs, resample
edge probabilities, adjacency instability, Markov-check statistics, timing) plus enough configuration metadata to
make the sweep reproducible.The immutable result of evaluating one parameter setting in a
ParameterSweep: the setting itself, the
point-estimate graph searched on the full data, a probability-annotated graph aggregating the resample searches
(in the same display convention as bootstrap results elsewhere in Tetrad), the StARS-style adjacency instability
over the resamples, Markov-check statistics for the point graph (if a Markov-check test was configured), and
timing.Markov-check statistics for a point graph, mirroring the statistics returned by
MarkovCheck: for the implied independencies ("Ind") and implied dependencies
("Dep") respectively, the Anderson-Darling p-value for uniformity of the local p-values, the
Kolmogorov-Smirnov p-value, the binomial p-value, the fraction of facts judged dependent, and the number of
facts tested.Implements a space-efficient symmetric matrix (of elements of type
short), storing only the lower
triangular portion of itImplements a space-efficient symmetric matrix (of elements of type
short), storing only the lower
triangular portion of itA confusion matrix for tails--i.e.
TailPrecision is a class that implements the Statistic interface.
Implements the TailRecall statistic, which calculates the tail recall value for a given true graph, estimated graph,
and data model.
Tags algorithm comparison wrappers that can take a covariance matrix as input.
Tags a gadget that takes a data model list as argument to its constructor.
Tags an algorithm that can take an external graph as input.
TakesGraph interface.
Tags an algorithm as using an independence wrapper.
Tags an algorithm as using a score wrapper.
Tanh.
This cancels all processes that check the TaskManager.getInstance().isCanceled() method.
This class is for running a list of tasks that implement Callable.
Represents a Taylor series expansion for a mathematical function.
Tests if the derivative f'(x) is positive for a Taylor series function over a range of x given its derivatives at 0.
Expands templates for the generalized SEM PM.
Sanity test for Adjustment:
For random graphs and random (X,Y), each returned adjustment set Z must:
- NOT block any amenable (causal) path X => Y (i.e., those must stay m-connecting)
- Block every backdoor path between X and Y (i.e., those must be NOT m-connecting)
Tests the BooleanFunction class.
Test the degenerate Gaussian score.
Better-targeted unmixing tests with ground-truth labels + ARI.
Represents labeled data consisting of a dataset and corresponding labels.
Tests the pre-search data audit.
Test the degenerate Gaussian score.
Tests for HybridCgModel.
CLI runner used to reproduce the original IGFCI-on-TCGA workflow.
Tests the IndexedConnectivity class by constructing graphs with randomly chosen parameters and seeing if they have
the required properties.
Tests the IndexedLagGraph class by constructing graphs with randomly chosen parameters and seeing if they have the
required properties.
CLI runner for instance-specific FGES on TCGA-like discrete data.
Tests the MeasurementSimulator class using diagnostics devised by Richard Scheines.
Checks that a score wrapper's missing-data policies agree across the three independent places a policy has to be
admitted before a user can reach it:
the score class's own policy switch, which throws on a policy it does not implement;
the wrapper's
getParameters(), which is what an interface reads to decide whether to render the
control at all;
the native-policy set the wrapper passes to MissingDataUtils
.gate, which rejects anything outside it before the score is ever constructed.
Regression tests for
NonlinearityTests, pinning two fixes verified by the calibration harness:
Internal centering: the tests fit without an intercept column, so before the fix any linear
relationship with a nonzero intercept (the typical case for raw real data) was misspecified under the null and all
of RESET, the conditional-moment test, and the additive-hinge test rejected "linearity" with probability near 1.Aug 31, 2017 4:42:08 PM
Sep 26, 2017 1:18:28 AM
Tests the Polynomial class.
Tests the PolynomialTerm class.
Test the Reveal evaluator.
Tests the SimpleRandomizer class by constructing graphs with randomly chosen parameters and seeing if they have the
required properties.
Tests the behavior of TsUtils.createLagData(DataSet, int, Knowledge) and its
interaction with BOSS via a ReplicatingGraph.
Test-wise (family-wise) covariance estimation for components whose local calculations consume a covariance
submatrix and a sample size: for a requested column set, the sample covariance matrix is computed over exactly the
rows that are complete on those columns, together with the number of such rows.
The covariance matrix of a column set over the rows complete on that set, the number of such rows, and the
rows themselves.
A rank test by testwise deletion: each rank query is answered from the rows that are complete on the columns that
query mentions, with its own sample size.
Maps out where test-wise deletion fails and where it is fine, before any decision about its place in the
interface.
Computes, and caches, the row subsets used by test-wise deletion: for a given set of columns, the rows of a dataset
on which all of those columns are observed.
Represents an ordered sextad of nodes.
Represents an ordered tetrad (quartet) of nodes, where the order of nodes within {i, j} and {k, l} does not matter,
but the order of the pairs <{i, j}, {k, l}> does matter.
Represents a logging utility used throughout tetrad.
Represents an empty configuration for the logger.
Represents an output stream that can get its own length.
Represents the configuration for the logger.
Represents an event which is just an id and a description.
An event associated with the
TetradLoggerListener.A listener for tetrad's logger.
Represents a ordered tetrad of variables, (i, j, k, l).
Nov 10, 2017 4:14:31 PM
Interface to tag a class that is part of the set of serializable classes
in the Tetrad API.
Interface to tag a class that should be exluded from the set of
TetradSerializable classes, even if it implements the TetradSerializable interface.
Contains methods used by TestSerialization to ensure that previous "stable" versions of Tetrad will by loadable by
later "stable" versions of Tetrad.
Provides an interface for classes that test tetrad constraints.
Implements different tests of tetrad constraints: using Wishart's test (CPS, Wishart 1928); Bollen's test (Bollen,
1990) or a more computationally intensive test that fits one/two factor Gaussian models.
Implements a test of tetrad constraints with discrete variables.
Implements a test of tetrad constraints in a known correlation matrix.
Stores a 2D array of Strings for printing out tables.
An enum of delimiters.
Implements and extends a scorer extending Teyssier, M., and Koller, D.
Deprecated.
Deprecated.
Helper class for the orientation stages.
The part of background knowledge that constrains ancestry, not only adjacency: a variable in a strictly later
temporal tier than another cannot be its cause, directly or through any intermediary, latent ones included.
Represents a time series graph--that is, a graph with a fixed number S of lags, with edges into initial lags
only--that is, into nodes in the first R lags, for some R.
Represents a NodeId with a name and a lag value.
Nov 14, 2017 12:00:31 PM
An enum of graph types to compare.
Aug 7, 2019 6:17:29 PM
Stores time series data as a list of continuous columns.
Time series SEM simulation.
Unified math interface for Tetrad.
Enumerates the available implementation strategies for mathematical computations.
Allowable tokens.
Simple driver:
args[0] = input data path (tab-delimited with header)
args[1] = input DAG path (one directed edge per line, like "A -> B" or "A-->B" or "A->B")
args[2] = output data path (tab-delimited)
args[3] = output DAG path (edge list)
args[4] = (optional) nSamples (default = input N)
The
TrainedDagAdequacy class provides methods to evaluate the adequacy of a trained
Directed Acyclic Graph (DAG) by comparing real data and simulated data generated from
the DAG model.Trained DAG model.
Trained DAG simulator (ANM): learn local mechanisms from a real dataset and resimulate
Class representing a report for a node in the simulation results.
Defines various configuration parameters for simulations involving
directed acyclic graphs (DAGs).
Represents the result of a simulation, encapsulating the simulation data, variables,
the true Directed Acyclic Graph (DAG), and optional diagnostic information.
Trained DAG simulator (GNM): learn local mechanisms with non-additive noise and resimulate
Represents a report for a single node in a trained directed acyclic graph (DAG) structure.
Represents a configuration class containing various hyperparameters and settings
used for the simulation and training of a directed acyclic graph (DAG) model.
Represents the result of a simulation, containing continuous and discrete data
for variables, metadata about the simulation, and support for generating reports.
Trained DAG simulator (GNM): learn local mechanisms with non-additive noise and resimulate
Represents a report for a single node in a trained directed acyclic graph (DAG) structure.
Encapsulates configuration parameters for the TrainedDagSimulatorGNM class.
Represents the result of a simulation, containing continuous and discrete data
for variables, metadata about the simulation, and support for generating reports.
Trained DAG simulator (GNM): learn local mechanisms with non-additive noise and resimulate
Represents a report for a single node in a trained directed acyclic graph (DAG) structure.
Encapsulates configuration parameters for the TrainedDagSimulatorGNM class.
Represents the result of a simulation, containing continuous and discrete data
for variables, metadata about the simulation, and support for generating reports.
Represents a transformation on some dataset.
Builds the shared TSC/BOSS-based measurement model used by BossTrekMimic-style searches.
Result of building the shared measurement model.
Builds the shared PC/TSC-based measurement model used by TrekMimic-style searches.
Result of building the shared measurement model.
Algorithm-comparison wrapper for the Trek-MIMIC search.
Implements the Trek-MIMIC algorithm for recovering latent structure from
measured data, including both the latent-latent skeleton and the measured
parents (inputs) of each latent variable.
Benchmark runner for Trek-MIMIC.
Wrapper for Rank independence test.
A block-level conditional independence test based on trek separation, operating under
linear latent factor measurement models.
The
TRffBicScore class is a scoring mechanism designed to evaluate the fit and complexity
of a data model.TRFF BIC score (mixed)
A record that encapsulates the results of a local fit operation, consisting of
the log-likelihood value, the effective degrees of freedom, and the number
of observations used.
A pair of local fits computed on a shared design matrix in which the reduced model's
columns are a prefix of the full model's columns, so the models are nested by
construction.
Wrapper for the TRFF likelihood-ratio CI test built on
TRffBicScore.Likelihood-ratio CI test based on nested
TRffBicScore local fits.Stores a triple (x, y, z) of nodes.
Marks a search algorithm as a triad classifier and returns the triad classifications if makes.
Extracts true latent clusters from a graph produced by
RandomMim.Represents the statistic of False Negatives for Arrows compared to the true DAG.
The class TrueDagFalseNegativesTails implements the Statistic interface to calculate the number of false negatives
for tails compared to the true Directed Acyclic Graph (DAG).
Represents a statistic that calculates the false positives for arrows compared to the true directed acyclic graph
(DAG).
TrueDagFalsePositiveTails is a class that implements the Statistic interface.
The proportion of X*->Y in the estimated graph for which there is no path Y~~>X in the true graph.
A class that implements the Statistic interface to calculate the proportion of X-->Y edges in the estimated graph for
which there is a path X~~>Y in the true graph.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
The bidirected true positives.
A normal distribution that allows its parameters to be set and allows random sampling.
Runs the PC algorithm with the TSBI (Trek-Separation Block Independence) test
as its conditional independence oracle, given a pre-determined block clustering.
Trek Separation Clusters (TSC): a rank-based algorithm for recovering the
latent-cluster structure of a pure measurement model from an observed
correlation or covariance matrix.
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.
AlgorithmRunner implementation for the TSC algorithm.The
TscTestBlockDiscoverer class is an implementation of the BlockDiscoverer interface that utilizes
the Testing Strong Causal structures (TSC) algorithm to identify and discover clusters or blocks of variables from a
given dataset.Finds the PAG to which a DAG belongs, for a time series model.
Contains some utilities for doing autoregression.
Gives a result consisting of the residuals and collapsed var graphs.
The 2-cycle precision.
The 2-cycle precision.
The 2-cycle precision.
The 2-cycle recall.
The 2-cycle precision.
Tells a direct edge between two indicators from a latent common cause, using third-order cumulants.
The answer.
The result of the test.
Deprecated.
Deprecated.
The Result class encapsulates the output of the TwoStep algorithm's search process.
Underlines class.
For given a, b (a < b), returns a point chosen uniformly from [a, b].
The UniformityTest class provides methods to calculate the p-value of a list of points using the Kolmogorov-Smirnov
test and determine if the distribution is uniform.
Interface to tag classes that should not be cloned by marshalling.> 0
Sep 19, 2017 1:56:20 PM
The
UnmixDiagnostics class provides utilities for evaluating and diagnosing results from unsupervised mixture
models, such as Gaussian Mixture Models and related clustering techniques.Represents the Bayesian Information Criterion (BIC) values for mixture models with K=1 and K=2 clusters and the
difference (delta) between these values.
Represents the entropy statistics of clustering results in the context of mixture models.
Represents the difference between two clustering graphs in terms of structural and adjacency metrics.
Represents the result of a stability analysis of clustering, typically performed by evaluating the Adjusted Rand
Index (ARI) across multiple independent runs.
Container for unmixing output (labels, per-cluster datasets, optional graphs).
Minimal, UI-friendly spec for the unmixer.
The ColliderStyle enum represents different styles for handling colliders during graph learning processes.
The CovarianceMode enum represents different modes for handling covariance calculations during graph learning
processes.
The GraphLearner enum represents different algorithms or strategies used for graph learning processes within a
system.
The SupersetScore enum represents statistical ranking correlation coefficients that can be used to assess the
relationship between two rankings.
Represents a Bayes IM in which all of the conditional probability tables have been updated to take into account
evidence.
Implements a function from the previous time steps of a history array to the getModel time step.
Lazily enumerates EVERY valid causal order of a DAG or CPDAG, each exactly once.
Interface implemented by classes, instantiations of which are capable of serving as variables for columns in a
DataSet.
Exact inference engine over a
BayesIm supporting:
Soft evidence via allowed categories (Proposition)
Hard evidence via node=category
Marginals, conditionals, and joint marginals (all conditional on evidence)
This class is designed specifically to satisfy the methods required by
JunctionTreeUpdater.RowSummingExactUpdater-style updater plumbing, but uses VariableEliminationInference
for marginals/joints/conditionals.
An Expression for a variable.
Inteface implemented by classes, instantiations of which are associated with lists of variables.
Feb 9, 2016 3:18:03 PM
Feb 9, 2016 3:18:44 PM
Feb 9, 2016 3:19:52 PM
Harness to test whether BOSS performance correlates with varsortability.
Implements the "fast adjacency search" used in several causal algorithm in this package.
Implements a convervative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
An enum of triple types.
Implements a convervative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
Implements a convervative version of PC, in which the Markov condition is assumed but faithfulness is tested
locally.
An enum of the types of triples that can be found in a graph.
Vector wrapping matrix library.
Represents the getModel Tetrad version.
The VertexRepairBattery class is responsible for executing a comprehensive suite of tests
to evaluate vertex repair algorithms.
The VertexRepairBattery2 class is responsible for conducting and evaluating a comprehensive
suite of tests on the VertexRepair algorithm under various configurations.
Greedy local-search model-repair algorithm for causal graphs.
Graph types supported by the repair search.
A single proposed graph modification, together with metadata needed for
display and deduplication.
Callback interface for repair-progress events fired by
VertexRepairSearch.Which repair sweep strategy to use.
Represents a scored candidate with various metrics including violations, probabilities,
and whether it passes certain guards.
Simulation harness for VertexRepairSearch.
Which algorithm to use to produce the initial graph before repair.
Hand-run wall-time benchmark for
VertexRepairSearch, comparing full per-edit
invalidation against affected-only invalidation on simulated CPDAG and PAG repair
problems.Stores a 2D array of double data.
Stores a 2D array of int data.
This version of Vicinity finds nearby nodes by searching with an expanding cube Prior to Vicinity4, versions of
Vicinity looked at the 3 axis independently instead of collectively.
Unit tests for violations in causal discovery algorithms.
Implements the Washdown algorithm,
Joint, dependence-aware Markov check for a DAG or CPDAG.
Multiplier distribution for the wild bootstrap.
Ordinary least squares residualization.
Pluggable residualization.
Outcome of a check: omnibus p-values plus per-constraint diagnostics.
The Wishart class is a concrete implementation of the NtadTest abstract class, specifically for statistical tests
based on the Wishart distribution.
Replication harness for Witte, Foraita and Didelez, "Multiple imputation and test-wise deletion for causal
discovery with incomplete cohort data" (arXiv:2108.13331, 2021).
Wrapper for linear, Gaussian Extended BIC score (Chen and Chen).
Implements an unpublished score based on a risk bound due to Zhang and Shen.