API

backward_committor(tpt)

Compute the backward committor.

current2arrows(f, x, y; excluded = nothing)

Compute forward current vectors in a 2D physical space.

Return (u, v) where u[i] and v[i] are the x and y components of vector centered at (x, y) and pointing in the direction of the weighted average by f[i,:] of each other point.

Arguments

• f: forward_current computed from stationary_statistics.
• x: A Vector of points [x1, x2, ...]
• y: A Vector of points [y1, y2, ...]

Optional Arguments

• excluded: If a Vector{<:Integer} is provided, rows and columns corresponding to them are excluded from f. When excluded === nothing, the last index of f is excluded automatically.

forward_committor(tpt)

Compute the forward committor.

hitting_location_distribution(tpt)

Compute the distribution of target-hitting locations.

Return a matrix R such that R[i, j] is the probability that - starting in state i - the first visit to B occurs in state j. Note that R[i, j] == 0 for all j ∉ B.

nonstationary_statistics(tpt, horizon; B_to_S::Symbol = :interior, initial_dist = :stat)

Compute and return the following statistics in a NamedTuple:

• density
• reactive_density
• tAB_cdf

Arguments

• tpt: The TPTProblem.
• horizon: The time step at which to cut off the calculation. Note that the horizon value does NOT enforce that trajectories leaving A hit B by that time.

Optional Arguments

• initial_dist: A Symbol determining how the initial distribution inside 𝒜 has calculated.
  • :stat: The initial distribution is equal to stationary distribution of 𝒫(tpt) restricted 𝒜.
  • :uniform: A uniform distribution supported on 𝒜.

remaining_time(tpt)

Compute the remaining time, aka the lead time.

stationary_distribution(tpt)

Compute the stationary distribution of tpt.transition_matrix.P.

Errors when P is not strongly connected.

stationary_statistics(tpt)

Compute and return the following statistics in a NamedTuple:

• stationary_distribution
• forward_committor
• backward_committor
• reactive_density
• reactive_current
• forward_current
• reactive_rate
• reactive_time
• remaining_time
• hitting_location_distribution

Ω(tpt)

Return the set of avoided states.

ℬ(tpt)

Return tpt.target.

ℬ_true(tpt)

Return the set of states that are members of the target, but are not avoided.

𝒜(tpt)

Return tpt.source.

𝒜_true(tpt)

Return the set of states that are members of the source, but are not avoided.

𝒞(tpt)

Return the set of states that are not in the source or target.

𝒫(tpt)

Return tpt.transition_matrix.P.

𝒫_backwards(tpt)

Compute the "backwards" transition matrix; return a Matrix.

𝒫_plus(tpt)

The forward-reactive analogue of 𝒫.

𝒮(tpt)

Return all possible indices implied by the transition matrix, i.e. 1:size(P, 1).

𝒮_plus(tpt)

The set of indices i such that

• if i is in B_true, then i is in S_plus
• if i is outside B_true, then i is in S_plus if both
  • q_minus[i] > 0.0
  • sum(P[i, j]*qp[j] for j in sets.S) > 0.0

Intuitively: i is either in B_true, or could have come from A_true and is connected to a state that is reactively connected to B.

abstract type Connectivity

Supertype for all transition matrix connectivity types.

struct Disconnected

A Connectivity such that the directed graph implied by the transition matrix is disconnected.

struct HomogeneousTPTProblem

A TPTProblem where the transition matrix is homogeneous, i.e. time-independent.

Fields

• transition_matrix: A TransitionMatrix.
• source: A vector of indices defining the TPT source, aka A.
• target: A vector of indices defining the TPT target, aka B.

Constructor

HomogeneousTPTProblem(P, source, target; avoid = Int64[])

Build a HomogeneousTPTProblem where each argument of the constructor maps to the corresponding field.

Optional Arguments

• avoid: Indices provided here will be appended to both A and B and will hence be avoided by transition path theory.

struct NonStochastic

A Stochasticity such that the row sums of the transition matrix are incomparable to 1.

struct Stochastic

A Stochasticity such that the row sums of the transition matrix are all equal to 1.

abstract type Stochasticity

Supertype for all transition matrix stochasticity types.

struct StronglyConnected

A Connectivity such that the directed graph implied by the transition matrix is strongly connected.

struct SubStochastic

A Stochasticity such that the row sums of the transition matrix are all strictly less than 1.

struct SuperStochastic

A Stochasticity such that the row sums of the transition matrix are all strictly greater than 1.

abstract type TPTProblem

Supertype for all TPT problems.

struct TransitionMatrix{S, C}

A transition probability matrix with Stochasticity S and Connectivity C.

Fields

• P: The transition probability Matrix itself.
• stochasticity: S
• connectivity: C

Constructors

TransitionMatrix(P_size; n_zeros = 0, normalize = true, seed = 1234)

Construct a randomly generated transition matrix.

Arguments

• P_size: The number of rows (== columns) of the matrix.

Optional Arguments

• n_zeros: This many zeros will be placed in the matrix at random. If this results in a row of the matrix having all zeros, a 1 will be placed randomly in that row.
• normalize: Whether to normalize the row sums of the resulting matrix.
• seed: A seed for reproducible randomness.

TransitionMatrix(P)

Construct a TransitionMatrix from a matrix P. The properties of P are inferred automatically.

Arguments

• P: The transition matrix.

struct WeaklyConnected

A Connectivity such that the directed graph implied by the transition matrix is weakly connected.