The pcalg package for R can be used for the following two purposes: Causal structure learning and estimation of causal effects from observational data. In this document, we give a brief overview of the methodology, and demonstrate the package's functionality in both toy examples and applications.

We consider the problem of learning causal information between random variables in directed acyclic graphs (DAGs) when allowing arbitrarily many latent and selection variables. The FCI (Fast Causal Inference) algorithm has been explicitly designed to infer conditional independence and causal information in such settings. However, FCI is computationally infeasible for large graphs. We therefore propose the new RFCI algorithm, which is much faster than FCI. In some situations the output of RFCI is slightly less informative, in particular with respect to conditional independence information. However, we prove that any causal information in the output of RFCI is correct in the asymptotic limit. We also define a class of graphs on which the outputs of FCI and RFCI are identical. We prove consistency of FCI and RFCI in sparse high-dimensional settings, and demonstrate in simulations that the estimation performances of the algorithms are very similar. All software is implemented in the R-package pcalg.

No abstract

We generalize Pearl's back-door criterion for directed acyclic graphs (DAGs) to more general types of graphs that describe Markov equivalence classes of DAGs and/or allow for arbitrarily many hidden variables. We also give easily checkable necessary and sufficient graphical criteria for the existence of a set of variables that satisfies our generalized back-door criterion, when considering a single intervention and a single outcome variable. Moreover, if such a set exists, we provide an explicit set that fulfills the criterion. We illustrate the results in several examples. R-code is available in the R-package pcalg.1. Introduction. Causal Bayesian networks are widely used for causal reasoning [e.g., Glymour et al. (1987), Koller and Friedman (2009), Pearl (1995, 2000, 2009, Scheines (1993, 2000)]. In particular, if the causal structure is known and represented by a directed acyclic graph (DAG), this framework allows one to deduce post-intervention distributions and causal effects from the pre-intervention (or observational) distribution. Hence, if the causal DAG is known, one can estimate causal effects from observational data. Covariate adjustment is often used for this purpose. The back-door criterion [Pearl (1993)] is a graphical criterion that is sufficient for adjustment, in the sense that a set of variables can be used for covariate adjustment if it satisfies the back-door criterion for the given graph.In practice, there are two important complications. First, the underlying DAG may be unknown. In this case one can try to estimate the DAG, but in general one cannot identify the underlying DAG uniquely. Instead, one can identify its Markov equivalence class, which consists of all DAGs that encode the same conditional independence relationships as the underlying DAG. Such a Markov equivalence class can be represented uniquely

Reflective programming is becoming popular due to the increasing set of dynamic services provided by execution environments like JVM and CLR. With custom attributes Microsoft introduced an extensible model of reflection for CLR: they can be used as additional decorations on element declarations. The same notion has been introduced in Java 1.5. The annotation model, both in Java and in C#, limits annotations to classes and class members. In this paper we describe [a]C# a , an extension of the C# programming language, that allows programmers to annotate statements and code blocks and retrieve these annotations at run-time. We show how this extension can be reduced to the existing model. A set of operations on annotated code blocks to retrieve annotations and manipulate bytecode is introduced. We also discuss how to use [a]C# to annotate programs giving hints on how to parallelize a sequential method and how it can be implemented by means of the abstractions provided by the run-time of the language. Finally, we show how our model for custom attributes has been realized.