Class CausalGraph

constructor

• new CausalGraph(nodes: readonly string[], adjacency?: Matrix): CausalGraph

  Parameters

  • nodes: readonly string[]
  • Optionaladjacency: Matrix

  Returns CausalGraph

Readonlynodes

adjacencyMatrix

• get adjacencyMatrix(): Matrix

  Returns Matrix

edges

• get edges(): CausalEdge[]

  Returns CausalEdge[]

nodeCount

• get nodeCount(): number

  Returns number

addEdge

• addEdge(from: string, to: string): void

  Parameters

  • from: string
  • to: string

  Returns void

ancestors

• ancestors(nodes: string[]): Set<string>

  All ancestors of the given nodes (including the nodes themselves). Uses iterative DFS on the transpose graph for stack-safety.

  Parameters

  • nodes: string[]

  Returns Set<string>

applyDomainKnowledge

• applyDomainKnowledge(dk: DomainKnowledge): void

  Parameters

  • dk: DomainKnowledge

  Returns void

children

• children(node: string): string[]

  Direct children of node (nodes with an edge node →).

  Parameters

  • node: string

  Returns string[]

clone

• clone(): CausalGraph

  Returns CausalGraph

descendants

• descendants(node: string): Set<string>

  All descendants of node (including the node itself). Uses iterative DFS for stack-safety.

  Parameters

  • node: string

  Returns Set<string>

do

• do(node: string): CausalGraph

  Do-surgery: return a new graph with all incoming edges to node removed.

  Parameters

  • node: string

  Returns CausalGraph

dSeparated

• dSeparated(x: string, y: string, z: string[]): boolean

  Strict d-separation test: are X and Y conditionally independent given Z?

  A trail (path treating edges as undirected) is d-connecting iff:

  1. For every non-collider node on the trail: it is NOT in Z.
  2. For every collider node on the trail: it IS in Z, or some descendant is in Z.

  Two nodes are d-separated by Z iff no d-connecting trail exists between them.

  Parameters

  • x: string

    — first node name

  • y: string

    — second node name

  • z: string[]

    — conditioning set (node names)

  Returns boolean

  true if X and Y are d-separated given Z

hasCycle

• hasCycle(): boolean

  Returns boolean

hasDirectedPath

• hasDirectedPath(from: string, to: string): boolean

  Whether there exists a directed path from from to to.

  Parameters

  • from: string
  • to: string

  Returns boolean

hasEdge

• hasEdge(from: string, to: string): boolean

  Parameters

  • from: string
  • to: string

  Returns boolean

isDAG

• isDAG(): boolean

  Returns boolean

neighbors

• neighbors(node: string): string[]

  Undirected neighbors of node (both directions exist).

  Parameters

  • node: string

  Returns string[]

nodeIndex

• nodeIndex(name: string): number

  Resolve a node name to its matrix index; throws if unknown.

  Parameters

  • name: string

  Returns number

parents

• parents(node: string): string[]

  Direct parents of node (nodes with an edge → node).

  Parameters

  • node: string

  Returns string[]

pdag2dag

• pdag2dag(): CausalGraph

  Convert a PDAG (partially directed acyclic graph) to a DAG.

  Algorithm (Dor & Tarsi 1992):

  1. Collect undirected edges (i—j where both i→j and j→i exist).
  2. While undirected edges remain: a. Find a sink among the undirected-component nodes: a node that has undirected edges but NO outgoing directed edges. b. Orient all undirected edges incident to the sink into the sink. c. Remove these edges from the undirected set.

  Returns CausalGraph

  a fully directed DAG

removeEdge

• removeEdge(from: string, to: string): void

  Parameters

  • from: string
  • to: string

  Returns void

shd

• shd(other: CausalGraph): number

  Structural Hamming Distance to another graph.

  Parameters

  • other: CausalGraph

  Returns number

toJSON

• toJSON(): {
      adjacency: number[][];
      edges: CausalEdge[];
      nodes: readonly string[];
  }

  Returns { adjacency: number[][]; edges: CausalEdge[]; nodes: readonly string[] }

topologicalSort

• topologicalSort(): string[]

  Kahn's algorithm for topological ordering.

  Returns string[]

toUndirected

• toUndirected(a: string, b: string): void

  Convert an undirected edge to directed a→b.

  Parameters

  • a: string
  • b: string

  Returns void

undirectedEdge

• undirectedEdge(a: string, b: string): void

  Add an undirected edge (both directions).

  Parameters

  • a: string
  • b: string

  Returns void

StaticfromEdges

• fromEdges(nodes: string[], edges: CausalEdge[]): CausalGraph

  Parameters

  • nodes: string[]
  • edges: CausalEdge[]

  Returns CausalGraph