In Chapters 2 and 6 you learned that an LTI system with zero initial conditions can be described in the Laplace domain by algebraic relations between signals. A block diagram is a compact representation of those relations. Each block labeled by a transfer function \( G(s) \) enforces the constraint \( Y(s) = G(s)U(s) \) between its input and output. Summing junctions enforce linear superposition, and pickoff points replicate signals.

The key idea is that reducing a block diagram is equivalent to eliminating internal signals from a linear system of algebraic equations, while preserving the same external mapping \( \dfrac{Y(s)}{R(s)} \).

Suppose the diagram contains internal signals collected in a vector \( \mathbf{x}(s) \), with external input \( R(s) \) and output \( Y(s) \). Because every relation is linear, we can always write an equivalent linear system of equations of the form:

\[ \mathbf{A}(s)\mathbf{x}(s) + \mathbf{b}(s)R(s) = \mathbf{0}, \qquad Y(s) = \mathbf{c}(s)^\top \mathbf{x}(s) + d(s)R(s). \]

When the interconnection is well-posed (no algebraic inconsistencies), the internal variables can be eliminated (conceptually via linear algebra), giving: \( Y(s) = T(s)R(s) \) for a unique closed-form transfer function \( T(s) \). Block diagram algebra provides structured elimination rules that avoid writing all equations explicitly.

flowchart TD
  A["Start: identify external input R(s) and output Y(s)"] --> B["Label internal signals (u1, u2, ...)"]
  B --> C["Search for local patterns: series, parallel, simple feedback"]
  C --> D["If no pattern: legally relocate sum/pickoff to expose a pattern"]
  D --> E["Apply one reduction step; update diagram"]
  E --> F["Repeat until single block remains between R(s) and Y(s)"]
  F --> G["Result: equivalent transfer function T(s) = Y(s)/R(s)"]
        

Throughout, assume LTI blocks and Laplace-domain signals under zero initial conditions. We adopt the standard negative-feedback sign convention: a summing junction computes \( E(s) = R(s) - B(s) \).

2.1 Series (Cascade) Connection

Two blocks \( G_1(s) \) and \( G_2(s) \) are in series when the output of the first drives the input of the second:

\[ X(s) = G_1(s)R(s), \qquad Y(s) = G_2(s)X(s). \]

Claim: The equivalent transfer function is \( G_{\text{eq}}(s) = G_2(s)G_1(s) \).

Proof:

\[ Y(s) = G_2(s)X(s) = G_2(s)\big(G_1(s)R(s)\big) = \big(G_2(s)G_1(s)\big)R(s) \;\;\Longrightarrow\;\; \frac{Y(s)}{R(s)} = G_2(s)G_1(s). \]

2.2 Parallel Connection

Two blocks are in parallel when they receive the same input and their outputs sum:

\[ Y(s) = Y_1(s) + Y_2(s), \qquad Y_1(s)=G_1(s)R(s), \qquad Y_2(s)=G_2(s)R(s). \]

Claim: The equivalent transfer function is \( G_{\text{eq}}(s)=G_1(s)+G_2(s) \).

Proof:

\[ Y(s) = G_1(s)R(s) + G_2(s)R(s) = \big(G_1(s)+G_2(s)\big)R(s) \;\;\Longrightarrow\;\; \frac{Y(s)}{R(s)} = G_1(s)+G_2(s). \]

2.3 Single-Loop Feedback Connection

Consider the standard feedback interconnection with forward path \( G(s) \) and feedback path \( H(s) \): \( E(s) = R(s) - B(s) \), \( B(s)=H(s)Y(s) \), \( Y(s)=G(s)E(s) \).

Claim (negative feedback):

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

Proof:

\[ Y(s)=G(s)E(s)=G(s)\big(R(s)-B(s)\big)=G(s)\big(R(s)-H(s)Y(s)\big) = \\ G(s)R(s) - G(s)H(s)Y(s). \]

\[ \big(1 + G(s)H(s)\big)Y(s) = G(s)R(s) \;\;\Longrightarrow\;\; \frac{Y(s)}{R(s)} = \frac{G(s)}{1+G(s)H(s)}. \]

For positive feedback with \( E(s)=R(s)+H(s)Y(s) \), the same algebra yields:

\[ \frac{Y(s)}{R(s)} = \frac{G(s)}{1 - G(s)H(s)}. \]

2.4 A Useful Corollary: Equivalent Block Replacement Preserves Input-Output

Any local substitution that preserves the governing equations for the external signals is valid. In practice, each reduction rule above is justified by writing the equations, eliminating the internal variable(s), and obtaining the same \( Y(s)/R(s) \).

Many diagrams are not immediately reducible by the canonical rules because summing junctions or pickoff points are positioned “inside” loops or between blocks. The following transformations are equation-preserving and are used to expose series/parallel/feedback patterns.

3.1 Moving a Summing Junction Across a Block

Suppose a block \( G(s) \) follows a summing junction, so that the output is \( Y(s)=G(s)\big(U_1(s)+U_2(s)\big) \). If we move the summing junction after the block, then each branch must pass through an identical gain \( G(s) \).

Before: sum then \( G(s) \).

After (equivalent): \( G(s) \) on each input branch, then sum.

Proof (by equality of output expressions):

\[ Y(s)=G(s)\big(U_1(s)+U_2(s)\big)=G(s)U_1(s) + G(s)U_2(s), \]

which is exactly the expression produced by two parallel gains \( G(s) \) feeding a summing junction.

3.2 Moving a Pickoff Point Across a Block

If a signal is picked off after a block \( G(s) \), and you wish to move the pickoff point to before the block, then the moved branch must include the block \( G(s) \) to preserve the same tapped signal.

Algebraically, if the original tapped signal is \( X_{\text{tap}}(s)=Y(s)=G(s)U(s) \), then a tap before the block gives \( U(s) \); to recover \( Y(s) \) you must multiply by \( G(s) \).

3.3 Caution: Moving Blocks Across Summing Junctions Requires Invertibility

Some “reverse” moves (e.g., moving a sum from after a block to before it without duplicating the block) implicitly require division by \( G(s) \), i.e., the existence of \( G(s)^{-1} \). In block-diagram algebra used in control engineering, we treat such moves as legal only when they are implemented by explicit multiplication on the appropriate branches (as in Sections 3.1–3.2), avoiding any unstated inversion.

Consider the following interconnection. There is an inner (local) negative feedback loop around \( G_2(s) \) with feedback \( H_2(s) \), the result is summed in parallel with \( G_3(s) \), then cascaded with \( G_1(s) \) and \( G_4(s) \). Finally, an outer negative feedback \( H_1(s) \) closes the loop around the entire forward path.

flowchart TD
  R["R(s)"] --> S0["Sum0 (+,-)"]
  S0 --> G1["G1(s)"]
  G1 --> V["v"]
  V --> S1["Sum1 (+,-)"]
  S1 --> G2["G2(s)"]
  G2 --> W1["w1"]
  W1 --> H2["H2(s)"]
  H2 --> S1
  V --> G3["G3(s)"]
  G3 --> W2["w2"]
  W1 --> S2["Sum2 (+,+)"]
  W2 --> S2
  S2 --> G4["G4(s)"]
  G4 --> Y["Y(s)"]
  Y --> H1["H1(s)"]
  H1 --> S0
        

4.1 Step 1: Reduce the Inner Feedback Loop

The inner loop is a standard negative feedback interconnection with forward block \( G_2(s) \) and feedback \( H_2(s) \). Therefore, the equivalent transfer from \( v \) to \( w_1 \) is:

\[ G_{2,\text{cl}}(s) = \frac{w_1(s)}{v(s)} = \frac{G_2(s)}{1 + G_2(s)H_2(s)}. \]

4.2 Step 2: Reduce the Parallel Combination

The two paths from \( v \) to the summing junction Sum2 are in parallel: one is \( G_{2,\text{cl}}(s) \), the other is \( G_3(s) \). Hence the equivalent block from \( v \) to the Sum2 output \( u \) is:

\[ G_{\parallel}(s) = \frac{u(s)}{v(s)} = G_3(s) + \frac{G_2(s)}{1 + G_2(s)H_2(s)}. \]

4.3 Step 3: Reduce the Series (Cascade) Forward Path

The forward path from Sum0 output \( e(s) \) to \( y(s) \) is a cascade: \( G_1(s) \), then \( G_{\parallel}(s) \), then \( G_4(s) \). Therefore:

\[ G_f(s) = \frac{Y(s)}{E(s)} = G_4(s)\,G_{\parallel}(s)\,G_1(s) = G_4(s)\left( G_3(s) + \frac{G_2(s)}{1 + G_2(s)H_2(s)} \right)G_1(s). \]

4.4 Step 4: Reduce the Outer Feedback Loop

The outer loop is negative feedback with forward transfer \( G_f(s) \) and feedback \( H_1(s) \). Hence the overall transfer is:

\[ T(s) \equiv \frac{Y(s)}{R(s)} = \frac{G_f(s)}{1 + G_f(s)H_1(s)}. \]

Substituting \( G_f(s) \) gives the final reduced form:

\[ \frac{Y(s)}{R(s)} = \frac{ G_4(s)\left( G_3(s) + \dfrac{G_2(s)}{1 + G_2(s)H_2(s)} \right)G_1(s) }{ 1 + H_1(s)\,G_4(s)\left( G_3(s) + \dfrac{G_2(s)}{1 + G_2(s)H_2(s)} \right)G_1(s) }. \]

In each environment, we compute the reduced transfer function for the worked example in Section 4 using both: (i) library primitives (when available), and (ii) a minimal from-scratch implementation of transfer-function algebra. We adopt a concrete numeric instance (you may substitute other transfer functions): \( G_1(s)=\dfrac{1}{s+1} \), \( G_2(s)=\dfrac{2}{s+2} \), \( G_3(s)=\dfrac{3}{s+3} \), \( G_4(s)=\dfrac{4}{s+4} \), \( H_1(s)=\dfrac{1}{s+5} \), \( H_2(s)=\dfrac{1}{s+6} \).

5.1 Python (library-first: python-control + sympy cross-check)

Recommended libraries for transfer-function manipulation in Python include: control (python-control), scipy.signal (basic LTI tools), and sympy (symbolic algebra).

import control as ct
import sympy as sp

# ----- Numeric TFs using python-control -----
s = ct.tf([1, 0], [1])  # s as a transfer function

G1 = 1/(s + 1)
G2 = 2/(s + 2)
G3 = 3/(s + 3)
G4 = 4/(s + 4)
H1 = 1/(s + 5)
H2 = 1/(s + 6)

# Inner loop: w1/v = G2 / (1 + G2*H2) for negative feedback
G2_cl = ct.feedback(G2, H2, sign=-1)

# Parallel: G3 + G2_cl
Gpar = ct.parallel(G3, G2_cl)

# Forward cascade: G4 * Gpar * G1
Gf = ct.series(G4, ct.series(Gpar, G1))

# Outer loop: Y/R = Gf / (1 + Gf*H1)
T = ct.feedback(Gf, H1, sign=-1)

print("Reduced transfer function T(s):")
print(T)

# ----- Symbolic cross-check using sympy -----
sp_s = sp.Symbol('s')
G1s = 1/(sp_s + 1)
G2s = 2/(sp_s + 2)
G3s = 3/(sp_s + 3)
G4s = 4/(sp_s + 4)
H1s = 1/(sp_s + 5)
H2s = 1/(sp_s + 6)

G2_cls = G2s/(1 + G2s*H2s)
Gpar_s = G3s + G2_cls
Gf_s = G4s * Gpar_s * G1s
T_s = sp.simplify(Gf_s / (1 + Gf_s*H1s))

print("\nSymbolic T(s) simplified:")
print(T_s)

5.2 C++ (from scratch: polynomial + transfer-function algebra)

C++ has no standard built-in transfer-function type; a typical approach is to represent transfer functions as ratios of polynomials and implement the three canonical operations: series (multiplication), parallel (addition), and feedback.

#include <iostream>
#include <vector>
#include <stdexcept>

struct Poly {
  // Coefficients in descending powers: a0*s^n + a1*s^(n-1) + ... + an
  std::vector<double> c;

  static Poly add(const Poly& a, const Poly& b) {
    std::vector<double> ra = a.c, rb = b.c;
    if (ra.size() < rb.size()) ra.insert(ra.begin(), rb.size() - ra.size(), 0.0);
    if (rb.size() < ra.size()) rb.insert(rb.begin(), ra.size() - rb.size(), 0.0);
    Poly out;
    out.c.resize(ra.size());
    for (size_t i = 0; i != ra.size(); ++i) out.c[i] = ra[i] + rb[i];
    return out;
  }

  static Poly mul(const Poly& a, const Poly& b) {
    Poly out;
    out.c.assign(a.c.size() + b.c.size() - 1, 0.0);
    for (size_t i = 0; i != a.c.size(); ++i)
      for (size_t j = 0; j != b.c.size(); ++j)
        out.c[i + j] += a.c[i] * b.c[j];
    return out;
  }
};

struct TF {
  Poly num;
  Poly den; // assume den not identically zero

  static TF series(const TF& G, const TF& H) {
    return TF{ Poly::mul(G.num, H.num), Poly::mul(G.den, H.den) };
  }

  static TF parallel(const TF& G, const TF& H) {
    // G + H = (Gn/Gd) + (Hn/Hd) = (Gn*Hd + Hn*Gd)/(Gd*Hd)
    Poly left  = Poly::mul(G.num, H.den);
    Poly right = Poly::mul(H.num, G.den);
    return TF{ Poly::add(left, right), Poly::mul(G.den, H.den) };
  }

  static TF feedback(const TF& G, const TF& H, int sign /* -1 negative, +1 positive */) {
    // Negative feedback: G / (1 + G*H)
    // Positive feedback: G / (1 - G*H)
    TF GH = series(G, H); // (Gn*Hn)/(Gd*Hd)

    // 1 +/- GH = (Gd*Hd +/- Gn*Hn)/(Gd*Hd)
    Poly one = Poly{ std::vector<double>{1.0} };
    Poly common = Poly::mul(G.den, H.den);

    Poly top = Poly::mul(one, common);      // 1 * (Gd*Hd)
    Poly ghN = GH.num;                      // Gn*Hn
    if (sign == -1) {                       // 1 + GH
      top = Poly::add(top, ghN);
    } else if (sign == +1) {                // 1 - GH
      // top - ghN
      Poly neg = ghN; for (auto& x : neg.c) x = -x;
      top = Poly::add(top, neg);
    } else {
      throw std::invalid_argument("sign must be -1 or +1");
    }

    // G / (1 +/- GH) = (Gn/Gd) / ( (Gd*Hd +/- Gn*Hn)/(Gd*Hd) )
    //               = (Gn/Gd) * (Gd*Hd)/(Gd*Hd +/- Gn*Hn)
    TF out;
    out.num = Poly::mul(G.num, common);     // Gn*(Gd*Hd)
    out.den = Poly::mul(G.den, top);        // Gd*(Gd*Hd +/- Gn*Hn)
    return out;
  }
};

static void printPoly(const Poly& p) {
  std::cout << "[";
  for (size_t i = 0; i != p.c.size(); ++i) {
    std::cout << p.c[i];
    if (i + 1 != p.c.size()) std::cout << ", ";
  }
  std::cout << "]";
}

static void printTF(const TF& tf) {
  std::cout << "num="; printPoly(tf.num);
  std::cout << " , den="; printPoly(tf.den) << "\n";
}

int main() {
  // G1 = 1/(s+1)  => num=[1], den=[1,1]
  TF G1{ Poly{{1.0}}, Poly{{1.0, 1.0}} };
  TF G2{ Poly{{2.0}}, Poly{{1.0, 2.0}} };
  TF G3{ Poly{{3.0}}, Poly{{1.0, 3.0}} };
  TF G4{ Poly{{4.0}}, Poly{{1.0, 4.0}} };
  TF H1{ Poly{{1.0}}, Poly{{1.0, 5.0}} };
  TF H2{ Poly{{1.0}}, Poly{{1.0, 6.0}} };

  TF G2_cl = TF::feedback(G2, H2, -1);          // inner negative feedback
  TF Gpar  = TF::parallel(G3, G2_cl);           // parallel
  TF Gf    = TF::series(G4, TF::series(Gpar, G1)); // cascade
  TF T     = TF::feedback(Gf, H1, -1);          // outer negative feedback

  std::cout << "Reduced T(s):\n";
  printTF(T);
  return 0;
}

5.3 Java (from scratch: polynomial arrays + TF operations)

In Java, a minimal implementation mirrors the C++ approach. For larger projects, you may integrate polynomial utilities from Apache Commons Math, but below is a self-contained core.

import java.util.Arrays;

class Poly {
  // Descending coefficients
  public final double[] c;

  public Poly(double[] c) { this.c = c; }

  public static Poly add(Poly a, Poly b) {
    int n = Math.max(a.c.length, b.c.length);
    double[] ra = new double[n];
    double[] rb = new double[n];
    System.arraycopy(a.c, 0, ra, n - a.c.length, a.c.length);
    System.arraycopy(b.c, 0, rb, n - b.c.length, b.c.length);
    double[] out = new double[n];
    for (int i = 0; i != n; ++i) out[i] = ra[i] + rb[i];
    return new Poly(out);
  }

  public static Poly mul(Poly a, Poly b) {
    double[] out = new double[a.c.length + b.c.length - 1];
    for (int i = 0; i != a.c.length; ++i)
      for (int j = 0; j != b.c.length; ++j)
        out[i + j] += a.c[i] * b.c[j];
    return new Poly(out);
  }

  public static Poly neg(Poly a) {
    double[] out = Arrays.copyOf(a.c, a.c.length);
    for (int i = 0; i != out.length; ++i) out[i] = -out[i];
    return new Poly(out);
  }
}

class TF {
  public final Poly num;
  public final Poly den;

  public TF(Poly num, Poly den) { this.num = num; this.den = den; }

  public static TF series(TF G, TF H) {
    return new TF(Poly.mul(G.num, H.num), Poly.mul(G.den, H.den));
  }

  public static TF parallel(TF G, TF H) {
    Poly left  = Poly.mul(G.num, H.den);
    Poly right = Poly.mul(H.num, G.den);
    return new TF(Poly.add(left, right), Poly.mul(G.den, H.den));
  }

  public static TF feedback(TF G, TF H, int sign /* -1 negative, +1 positive */) {
    TF GH = series(G, H);
    Poly one = new Poly(new double[]{1.0});
    Poly common = Poly.mul(G.den, H.den);

    Poly top = Poly.mul(one, common); // common
    if (sign == -1) top = Poly.add(top, GH.num);         // 1 + GH
    else if (sign == +1) top = Poly.add(top, Poly.neg(GH.num)); // 1 - GH
    else throw new IllegalArgumentException("sign must be -1 or +1");

    Poly outNum = Poly.mul(G.num, common);
    Poly outDen = Poly.mul(G.den, top);
    return new TF(outNum, outDen);
  }

  public void print(String name) {
    System.out.println(name + ": num=" + Arrays.toString(num.c) + ", den=" + Arrays.toString(den.c));
  }
}

public class BlockDiagramReductionDemo {
  public static void main(String[] args) {
    TF G1 = new TF(new Poly(new double[]{1.0}), new Poly(new double[]{1.0, 1.0}));
    TF G2 = new TF(new Poly(new double[]{2.0}), new Poly(new double[]{1.0, 2.0}));
    TF G3 = new TF(new Poly(new double[]{3.0}), new Poly(new double[]{1.0, 3.0}));
    TF G4 = new TF(new Poly(new double[]{4.0}), new Poly(new double[]{1.0, 4.0}));
    TF H1 = new TF(new Poly(new double[]{1.0}), new Poly(new double[]{1.0, 5.0}));
    TF H2 = new TF(new Poly(new double[]{1.0}), new Poly(new double[]{1.0, 6.0}));

    TF G2cl = TF.feedback(G2, H2, -1);
    TF Gpar = TF.parallel(G3, G2cl);
    TF Gf   = TF.series(G4, TF.series(Gpar, G1));
    TF T    = TF.feedback(Gf, H1, -1);

    T.print("Reduced T(s)");
  }
}

5.4 MATLAB and Simulink (Control System Toolbox)

MATLAB provides direct primitives for the reduction rules via transfer-function objects. This is the most concise way to apply the algebra exactly as proved in Section 2.

% Define transfer functions
s = tf('s');

G1 = 1/(s + 1);
G2 = 2/(s + 2);
G3 = 3/(s + 3);
G4 = 4/(s + 4);
H1 = 1/(s + 5);
H2 = 1/(s + 6);

% Inner negative feedback around G2 with H2
G2_cl = feedback(G2, H2);      % default is negative feedback

% Parallel combination with G3
Gpar = G3 + G2_cl;

% Forward cascade
Gf = G4 * Gpar * G1;

% Outer negative feedback
T = feedback(Gf, H1);

T_simplified = minreal(T);     % optional cancellation if applicable
disp(T_simplified);

Simulink guidance (diagram construction): create the interconnection using Sum blocks for Sum0, Sum1, Sum2 and Transfer Fcn blocks for \( G_1,G_2,G_3,G_4,H_1,H_2 \). Ensure the signs on Sum0 and Sum1 match the negative-feedback convention used in Section 4. The reduction computed above should match the input-output transfer you obtain using Simulink linear analysis tools (e.g., selecting input at \( R \) and output at \( Y \)).

5.5 Wolfram Mathematica (TransferFunctionModel + interconnection)

Mathematica provides symbolic LTI interconnections. The following uses transfer-function models and standard connections.

(* Define Laplace variable and transfer functions *)
s =.;

G1 = TransferFunctionModel[{1}, {1, 1}, s];
G2 = TransferFunctionModel[{2}, {1, 2}, s];
G3 = TransferFunctionModel[{3}, {1, 3}, s];
G4 = TransferFunctionModel[{4}, {1, 4}, s];
H1 = TransferFunctionModel[{1}, {1, 5}, s];
H2 = TransferFunctionModel[{1}, {1, 6}, s];

(* Inner negative feedback *)
G2cl = SystemsModelFeedbackConnect[G2, H2];

(* Parallel and series connections *)
Gpar = SystemsModelParallelConnect[G3, G2cl];
Gf   = SystemsModelSeriesConnect[G4, SystemsModelSeriesConnect[Gpar, G1]];

(* Outer negative feedback *)
T = SystemsModelFeedbackConnect[Gf, H1];

(* Expand to a rational function form *)
Texpr = TransferFunctionExpand[T];
Simplify[Texpr]

The problems below are designed to be solvable using only the rules and transformations introduced in this lesson: series, parallel, and (single-loop) feedback, plus algebraic relocation logic from Section 3.

Problem 1 (Series + Parallel): A signal \( R(s) \) enters a parallel pair \( G_a(s) \) and \( G_b(s) \), whose outputs are summed, and then the result passes through \( G_c(s) \). Derive \( \dfrac{Y(s)}{R(s)} \).

Solution:

Parallel first: \( G_{\parallel}(s)=G_a(s)+G_b(s) \). Then series with \( G_c(s) \).

\[ \frac{Y(s)}{R(s)} = G_c(s)\big(G_a(s)+G_b(s)\big). \]

Problem 2 (Single Negative Feedback): A forward block \( G(s) \) is in negative feedback with \( H(s) \). Show that the closed-loop transfer satisfies \( T(s)=\dfrac{G(s)}{1+G(s)H(s)} \).

Solution:

Write the loop equations: \( E(s)=R(s)-H(s)Y(s) \) and \( Y(s)=G(s)E(s) \). Substitute and solve for \( Y(s)/R(s) \):

\[ Y(s)=G(s)\big(R(s)-H(s)Y(s)\big)=G(s)R(s)-G(s)H(s)Y(s) \;\;\Longrightarrow\;\; \\ (1+G(s)H(s))Y(s)=G(s)R(s), \]

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

Problem 3 (Inner Loop + Parallel): Let \( G_2(s) \) be in negative feedback with \( H_2(s) \). The resulting equivalent block is placed in parallel with \( G_3(s) \). Derive the equivalent transfer from the shared input \( V(s) \) to the summed output \( U(s) \).

Solution:

Inner loop gives \( G_{2,\text{cl}}(s)=\dfrac{G_2(s)}{1+G_2(s)H_2(s)} \). Parallel addition yields:

\[ \frac{U(s)}{V(s)} = G_3(s) + \frac{G_2(s)}{1+G_2(s)H_2(s)}. \]

Problem 4 (Two Cascaded Feedback Reductions): Consider a forward cascade \( G_1(s) \) then \( G_2(s) \). First, \( G_2(s) \) is in negative feedback with \( H_2(s) \). Second, the entire cascade is in negative feedback with \( H_1(s) \). Derive \( \dfrac{Y(s)}{R(s)} \) in closed form.

Solution:

Reduce the inner loop first: \( G_{2,\text{cl}}(s)=\dfrac{G_2(s)}{1+G_2(s)H_2(s)} \). The forward path becomes \( G_f(s)=G_{2,\text{cl}}(s)G_1(s) \). Apply the outer negative feedback with \( H_1(s) \):

\[ \frac{Y(s)}{R(s)} = \frac{G_f(s)}{1+G_f(s)H_1(s)} = \frac{ \left(\dfrac{G_2(s)}{1+G_2(s)H_2(s)}\right)G_1(s) }{ 1 + H_1(s)\left(\dfrac{G_2(s)}{1+G_2(s)H_2(s)}\right)G_1(s) }. \]

Problem 5 (Closed-Loop Sensitivity Identity): For negative feedback \( T(s)=\dfrac{G(s)}{1+G(s)H(s)} \), show that \( 1 - H(s)T(s) = \dfrac{1}{1+G(s)H(s)} \).

Solution:

Substitute \( T(s) \) and simplify:

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

This identity is frequently used to simplify algebra in interconnected block diagrams, because it converts a mixed expression involving \( T(s) \) back into an explicit loop factor \( 1+G(s)H(s) \).

We established block diagram algebra as structured elimination of internal Laplace-domain variables and proved the three canonical reduction rules: series multiplication, parallel addition, and feedback closure. We then formalized legal relocation operations for summing and pickoff points to expose reducible patterns. A worked example demonstrated a disciplined reduction order (inner loop, parallel, cascade, outer loop). Finally, we implemented the same reduction in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.