In previous lessons you learned how to describe SISO LTI systems by transfer functions \( G(s) \) and how to interconnect them using block diagrams and reduction rules. A signal-flow graph (SFG) provides an equivalent representation in which nodes represent Laplace-domain signals and directed branches represent gains (typically transfer functions).

For a typical feedback system, a block diagram emphasizes physical components (controllers, plants, sensors), whereas the SFG emphasizes the algebraic structure of the underlying linear equations. This is especially useful when there are many feedback loops and summing/pickoff points, where block diagram reduction becomes tedious.

The conceptual pipeline from differential equations to a closed-loop transfer function using SFGs is:

flowchart TD
  DE["Dynamics: ODEs"] --> TF["Transfer function G(s)"]
  TF --> BD["Block diagram"]
  BD --> SFG["Signal-flow graph"]
  SFG --> MF["Apply Mason gain formula"]
  MF --> CLTF["Closed-loop transfer function T(s)"]
        

In an SFG for a SISO LTI system:

• Node: a scalar Laplace-domain signal, e.g. \( R(s), E(s), X(s), C(s) \).
• Branch: a directed connection from node \( X_i(s) \) to node \( X_j(s) \) with branch gain (or transmittance) \( T_{ji}(s) \).

Each internal node satisfies a node equation of the form

\[ X_j(s) \;=\; \sum_i T_{ji}(s)\,X_i(s) \;+\; U_j(s), \]

where \( U_j(s) \) collects any external excitations (e.g. reference or disturbance) directly injected into node \( j \).

Let an SFG have nodes indexed by \( 1,2,\dots,n \), with a chosen input node \( r \) and output node \( c \). We recall some graph-theoretic definitions specialized to signal-flow graphs.

Definition 1 (Branch gain). A branch from node \(i\) to node \(j\) carries branch gain \( T_{ji}(s) \). If there is no direct branch from \(i\) to \(j\), take \( T_{ji}(s) = 0 \).

Definition 2 (Forward path). A forward path \( P_k \) is a sequence of distinct nodes starting at the input node \( r \) and ending at the output node \( c \), following the direction of the branches and visiting no node more than once.

If the path passes through nodes \( i_0=r, i_1, \dots, i_m=c \), its path gain is

\[ P_k(s) \;=\; \prod_{\ell=0}^{m-1} T_{\,i_{\ell+1},\,i_\ell}(s). \]

Definition 3 (Loop and loop gain). A loop \( L_\ell \) is a closed path that starts and ends at the same node and visits no other node more than once. If the loop passes through nodes \( j_0, j_1, \dots, j_{p-1}, j_p=j_0 \), its loop gain is

\[ L_\ell(s) \;=\; \prod_{q=0}^{p-1} T_{\,j_{q+1},\,j_q}(s). \]

Definition 4 (Touching / non-touching loops). Two loops are said to touch if they have at least one node in common. A set of loops is non-touching if no two loops in the set share a node.

Definition 5 (Mason’s graph determinant). Let \( L_\ell(s) \) denote the loop gains of all individual loops. Define the graph determinant \( \Delta(s) \) as

\[ \Delta(s) \;=\; 1 \;-\; \sum_{\ell} L_\ell(s) \;+\; \sum_{\substack{\text{pairs of non-touching}\\\text{loops } (\ell_1,\ell_2)}} L_{\ell_1}(s)L_{\ell_2}(s) \;-\; \\ \sum_{\substack{\text{triples of pairwise}\\\text{non-touching loops } (\ell_1,\ell_2,\ell_3)}} L_{\ell_1}(s)L_{\ell_2}(s)L_{\ell_3}(s) \;+\;\cdots \]

The alternating signs continue with the number of loops in each non-touching set.

Definition 6 (Path cofactors). For each forward path \( P_k \), define \( \Delta_k(s) \) by forming \( \Delta(s) \) after removing all loops that touch path \( P_k \). That is, \( \Delta_k(s) \) is obtained by including only loops that do not share any node with the \(k\)-th forward path.

Mason’s Gain Formula. Let \( T(s) \) denote the input–output transfer function from reference node \( r \) to output node \( c \). Then

\[ T(s) \;=\; \frac{C(s)}{R(s)} \;=\; \frac{\displaystyle\sum_k P_k(s)\,\Delta_k(s)}{\Delta(s)}. \]

This compact expression encodes the effects of all forward paths and all feedback loops (including higher-order combinations of non-touching loops) in a single rational function of \(s\).

Consider the standard SISO negative-feedback configuration you have already seen:

• Forward path transfer function: \( G(s) \).
• Feedback transfer function: \( H(s) \).
• Reference input: \( R(s) \), output: \( C(s) \).

From classical block-diagram reduction, the closed-loop transfer function is

\[ T(s) \;=\; \frac{C(s)}{R(s)} \;=\; \frac{G(s)}{1 + G(s)H(s)}. \]

Let us now rediscover the same result using Mason’s formula.

Construct the SFG as follows:

• Nodes: \( R(s) \), \( E(s) \) (error), \( C(s) \) (output).
• Branches:
  • From \( R \) to \( E \) with gain \( 1 \).
  • From \( E \) to \( C \) with gain \( G(s) \).
  • From \( C \) back to \( E \) with gain \( -H(s) \) (negative feedback).

Identify forward paths and loops:

• There is only one forward path from \( R \) to \( C \): \( P_1(s) = 1\cdot G(s) = G(s) \).
• There is one loop that starts at \( E \), goes to \( C \) and returns: \( L_1(s) = G(s)\cdot(-H(s)) = -G(s)H(s) \).
• No two non-touching loops exist (there is only one loop).

The graph determinant becomes

\[ \Delta(s) = 1 - L_1(s) = 1 -\big(-G(s)H(s)\big) = 1 + G(s)H(s). \]

The loop \( L_1 \) clearly touches the forward path \( P_1 \), so \( \Delta_1(s) = 1 \). Applying Mason’s formula:

\[ T(s) \;=\; \frac{P_1(s)\,\Delta_1(s)}{\Delta(s)} \;=\; \frac{G(s)}{1 + G(s)H(s)}, \]

which coincides with the classical block-diagram result. In more complicated networks, Mason’s formula provides a systematic alternative to repeated block-diagram manipulations.

Let the SFG have internal node signals collected in a vector \( \mathbf{X}(s) \in \mathbb{C}^n \). Define an adjacency matrix \( \mathbf{A}(s) \) of size \( n\times n \) whose entry \( A_{ji}(s) \) equals the branch gain from node \( i \) to node \( j \). Let \( \mathbf{b}(s) \) encode how the input \( R(s) \) injects into each node, and let \( \mathbf{c} \) select the output node, so that \( C(s) = \mathbf{c}^\top \mathbf{X}(s) \). Then the node equations can be written compactly as

\[ \mathbf{X}(s) \;=\; \mathbf{A}(s)\,\mathbf{X}(s) + \mathbf{b}(s)\,R(s), \]

or

\[ \big(\mathbf{I} - \mathbf{A}(s)\big)\mathbf{X}(s) \;=\; \mathbf{b}(s)\,R(s). \]

Assuming \( \mathbf{I} - \mathbf{A}(s) \) is invertible for the values of \(s\) of interest,

\[ \mathbf{X}(s) \;=\; \big(\mathbf{I} - \mathbf{A}(s)\big)^{-1}\mathbf{b}(s)\,R(s), \qquad C(s) \;=\; \mathbf{c}^\top\big(\mathbf{I} - \mathbf{A}(s)\big)^{-1}\mathbf{b}(s)\,R(s). \]

Thus the transfer function is

\[ T(s) \;=\; \frac{C(s)}{R(s)} \;=\; \mathbf{c}^\top\big(\mathbf{I} - \mathbf{A}(s)\big)^{-1}\mathbf{b}(s). \]

Using Cramer’s rule and the adjugate of a matrix, one can express each entry of \( \big(\mathbf{I} - \mathbf{A}(s)\big)^{-1} \) as a ratio of cofactors and the determinant \( \det(\mathbf{I} - \mathbf{A}(s)) \). A classic result in graph theory shows that:

• The denominator \( \det(\mathbf{I} - \mathbf{A}(s)) \) expands into a sum over products of loop gains with the alternating signs that define \( \Delta(s) \).
• The numerators associated with paths from \( r \) to \( c \) correspond to the forward path gains multiplied by cofactors that exclude loops touching the path, leading to the factors \( \Delta_k(s) \).

Collecting these contributions yields precisely Mason’s gain formula. The full proof requires the combinatorial interpretation of determinants in terms of permutations and cycle decompositions, which you may study in more advanced linear algebra or graph theory courses.

For practical control design, the key is to apply Mason’s formula systematically. Given a block diagram of a linear system:

1. Identify all signals and represent them as nodes.
2. Replace each block and summing/pickoff junction with appropriate branches and gains.
3. List all forward paths from input node \( r \) to output node \( c \), and compute \( P_k(s) \).
4. List all individual loops and compute their gains \( L_\ell(s) \).
5. Determine all sets of non-touching loops (pairs, triples, etc.) and compute products of their gains.
6. Compute \( \Delta(s) \) and each \( \Delta_k(s) \) (excluding loops that touch \( P_k \)).
7. Insert everything into Mason’s formula to obtain \( T(s) \).

The following diagram summarizes this workflow:

flowchart TD
  S["Start from block diagram"] --> N["Define nodes (signals)"]
  N --> B["Draw directed branches with gains"]
  B --> FP["Enumerate forward paths Pk"]
  FP --> LP["Find loops and classify non-touching sets"]
  LP --> D["Compute Delta and Deltak"]
  D --> T["Evaluate T(s) = sum(Pk * Deltak) / Delta"]
        

For higher-order systems typical in robotics (e.g. multi-mass drives or linearized joint dynamics), the number of loops can grow quickly. In such cases, software implementations of the above procedure become essential.

In Python, symbolic tools such as sympy and control libraries such as python-control (widely used in robotics together with roboticstoolbox-python) allow us to both derive and verify closed-loop transfer functions obtained via Mason’s formula.

The example below computes the closed-loop transfer function for the simple feedback system of Section 3 using Mason’s formula and verifies it with python-control:

import sympy as sp

# Symbolic Laplace variable
s = sp.symbols('s')

# Example plant and sensor dynamics (e.g. simple robotic actuator plus encoder)
# G(s) = 10 / (s (s + 2)),   H(s) = 0.5
G = 10 / (s * (s + 2))
H = sp.Rational(1, 2)

# Mason's formula for single forward path and single loop:
# P1 = G, L1 = -G*H, Delta = 1 - L1 = 1 + G*H, Delta1 = 1
T_mason = sp.simplify(G / (1 + G*H))
print("Closed-loop TF from Mason:", T_mason)

# Numerical check using python-control (commonly used in robotics)
import control as ctrl

# Plant and sensor transfer functions in python-control
G_tf = ctrl.TransferFunction([10], [1, 2, 0])   # 10 / (s^2 + 2 s)
H_tf = ctrl.TransferFunction([0.5], [1])        # 0.5

# Negative feedback (unity reference, sensor H)
T_tf = ctrl.feedback(G_tf, H_tf, sign=-1)
print("Closed-loop TF from python-control:", T_tf)

# The rational form of T_tf should match the symbolic T_mason after simplification.
      

For more complex SFGs, you can represent an SFG as a Python data structure (e.g. adjacency lists of symbolic gains), implement functions to enumerate forward paths and loops, and then program Mason’s formula directly. In robotics, the resulting closed-loop transfer functions can be used to analyze axis position control, joint servo loops, or end-effector motion along a single Cartesian coordinate.

In C++, control and robotics projects (e.g. based on Eigen, ros_control, or Orocos) often work with numerical transfer functions or frequency-response data. Below is a simple numerical routine implementing Mason’s formula for the case of:

• a set of forward path gains P,
• a set of individual loop gains L,
• and a list of index sets corresponding to products of non-touching loops (for generality we accept arbitrary sizes).

#include <vector>
#include <cmath>

// Compute Delta(s) given loop gains and combinations of non-touching loops.
// nonTouching[k] is a vector of indices of loops forming one non-touching set.
double computeDelta(
    const std::vector<double>& L,
    const std::vector< std::vector<int> >& nonTouching)
{
    double Delta = 1.0;

    // Subtract sum of individual loops
    for (double Lj : L) {
        Delta -= Lj;
    }

    // Add/subtract higher-order products according to number of loops in each set
    for (const auto& idxSet : nonTouching) {
        double prod = 1.0;
        for (int idx : idxSet) {
            prod *= L.at(static_cast<std::size_t>(idx));
        }
        std::size_t m = idxSet.size();
        double sign = std::pow(-1.0, static_cast<int>(m));
        Delta += sign * prod;
    }

    return Delta;
}

// Mason gain for single input-single output (scalar gains)
double masonGain(
    const std::vector<double>& P,
    const std::vector<double>& L,
    const std::vector< std::vector<int> >& nonTouching,
    const std::vector< std::vector<int> >& touchingMask)
{
    double Delta = computeDelta(L, nonTouching);
    double num = 0.0;

    // For each forward path k, build Deltak by removing loops that touch path k.
    for (std::size_t k = 0; k < P.size(); ++k) {
        std::vector<double> Lk;
        std::vector< std::vector<int> > nonTouchingK;

        // Keep only loops not touching path k
        for (std::size_t j = 0; j < L.size(); ++j) {
            if (!touchingMask[k][j]) {
                Lk.push_back(L[j]);
            }
        }

        // For simplicity, we ignore recomputing non-touching sets for Lk here.
        // For many robotics SFGs with only a few loops, this can be enumerated explicitly.

        double Delta_k = computeDelta(Lk, nonTouchingK);
        num += P[k] * Delta_k;
    }

    return num / Delta;
}

// Example: simple feedback P1 = G, one loop L1 = -G*H (no non-touching pairs)
int main()
{
    double G = 10.0;
    double H = 0.5;
    std::vector<double> P = {G};
    std::vector<double> L = {-G * H};
    std::vector< std::vector<int> > nonTouching;     // empty
    std::vector< std::vector<int> > touchingMask = {{1}}; // loop 0 touches path 0

    double T = masonGain(P, L, nonTouching, touchingMask);
    // T should equal G / (1 + G*H)
    return 0;
}
      

In a robotics controller running in C++ (e.g. a joint-space PD loop in ros_control), the numerical value of the closed-loop gain at selected frequencies can be computed via Mason’s formula and used to analyze stability margins or bandwidth, complementing time-domain simulations.

Java is less common than C++ or Python in low-level robotics, but it is used in educational robotics (e.g. FIRST/WPILib) and high-level control services. The following snippet implements a minimal helper for Mason’s formula with scalar gains:

import java.util.List;

public class Mason {

    // Compute Delta for scalar loop gains and precomputed products of non-touching loops
    public static double computeDelta(
            List<Double> loops,
            List<List<Integer>> nonTouchingSets) {

        double delta = 1.0;

        for (double L : loops) {
            delta -= L;
        }

        for (List<Integer> set : nonTouchingSets) {
            double prod = 1.0;
            for (int idx : set) {
                prod *= loops.get(idx);
            }
            int m = set.size();
            double sign = Math.pow(-1.0, m);
            delta += sign * prod;
        }
        return delta;
    }

    // Simple feedback example: T = G / (1 + G*H)
    public static double simpleFeedback(double G, double H) {
        double loopGain = -G * H;
        double delta = 1.0 - loopGain; // 1 + G*H
        return G / delta;
    }

    public static void main(String[] args) {
        double G = 10.0;
        double H = 0.5;
        double T = simpleFeedback(G, H);
        System.out.println("Closed-loop gain: " + T);
    }
}
      

In more advanced Java-based control frameworks, symbolic or polynomial representations (e.g. via Apache Commons Math) can replace scalar doubles, allowing you to manipulate transfer functions for robot joint controllers or drivetrain dynamics using the same Mason-based reasoning.

MATLAB and Simulink are standard tools in control engineering and robotics. Mason’s formula can be implemented analytically or used conceptually while MATLAB handles the algebra via the Control System Toolbox.

For the simple feedback system:

% Plant and sensor dynamics, e.g. linearized robotic joint
s = tf('s');
G = 10 / (s * (s + 2));   % actuator dynamics
H = 0.5;                  % sensor gain

% Closed-loop TF via Mason (single forward path, single loop)
T_mason = G / (1 + G*H);

% Closed-loop TF via built-in feedback function (negative feedback)
T_matlab = feedback(G, H, -1);

% Verify equality
T_simplified = minreal(T_mason - T_matlab)
      

In Simulink, the SFG structure is implicitly encoded in the block diagram model. Even though Simulink does not draw SFGs explicitly, the same graph-theoretic structure underlies its simulation. For robotics, Robotics System Toolbox combined with Control System Toolbox allows you to derive linearized models of manipulators or mobile robots and connect them in feedback loops whose closed-loop transfer functions agree with those obtained via Mason’s formula.

Wolfram Mathematica is well suited for symbolic manipulations of transfer functions and for prototyping control algorithms before porting them to embedded robotics platforms.

(* Define Laplace variable and plant/sensor dynamics *)
s = LaplaceTransformVariable;
G[s_] := 10/(s (s + 2));
H[s_] := 1/2;

(* Mason's formula for single path, single loop *)
Tclosed[s_] := FullSimplify[ G[s] / (1 + G[s] H[s]) ];

(* Same system using built-in transfer-function objects *)
sysG = TransferFunctionModel[10/{1, 2, 0}, s];
sysH = TransferFunctionModel[{1/2}/{1}, s];

sysClosed = SystemsModelFeedback[sysG, sysH];

(* Compare symbolic expressions of Tclosed and sysClosed *)
TransferFunctionExpand[sysClosed]
      

In more advanced use, Mathematica can derive SFGs symbolically from system equations and automatically compute the corresponding Mason determinants, providing a bridge between pure graph theory and practical control design.

In this lesson you learned how to represent linear feedback systems as signal-flow graphs, how to define forward paths, loops, and non-touching loop sets, and how Mason’s gain formula combines these elements into a single closed-loop transfer function. We connected the formula to the algebraic structure of \( \mathbf{I} - \mathbf{A}(s) \), and demonstrated implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica that are directly relevant to robotics control software. In later chapters, you will use these transfer functions to analyze time-domain responses, stability margins, and performance of linear control systems.