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.

abstract type Stochasticity

Supertype for all transition matrix stochasticity types.

struct Stochastic

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

struct SuperStochastic

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

struct NonStochastic

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

abstract type Connectivity

Supertype for all transition matrix connectivity types.

struct StronglyConnected

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

struct WeaklyConnected

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

struct Disconnected

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

abstract type TPTProblem

Supertype for all TPT problems.

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.

𝒫(tpt)

Return tpt.transition_matrix.P.

𝒜(tpt)

Return tpt.source.

ℬ(tpt)

Return tpt.target.

𝒮(tpt)

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

Ω(tpt)

Return the set of avoided states.

𝒜_true(tpt)

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

ℬ_true(tpt)

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

𝒞(tpt)

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

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

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 𝒜.

stationary_distribution(tpt)

Compute the stationary distribution of tpt.transition_matrix.P.

Errors when P is not strongly connected.

𝒫_backwards(tpt)

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

forward_committor(tpt)

Compute the forward committor.

backward_committor(tpt)

Compute the backward committor.

𝒮_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.

𝒫_plus(tpt)

The forward-reactive analogue of 𝒫.

remaining_time(tpt)

Compute the remaining time, aka the lead time.

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.

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.