In Chapter 6 we model an LTI subsystem by its transfer function \( G(s) \): the Laplace-domain ratio \( G(s)=\frac{Y(s)}{U(s)} \) under zero initial conditions. Interconnection means we connect subsystem inputs/outputs to form a larger input–output map.

Throughout this lesson we assume:

• LTI subsystems and signals for which Laplace transforms exist.
• Zero initial conditions so that transfer-function algebra applies directly.
• Compatible interconnection signals (units and summation meaningfully defined).
• Well-posedness for feedback: the algebraic equations defining internal signals have a unique solution in the Laplace domain (made explicit in Section 4).

flowchart LR
  U["Input u"] --> S1["Series: G2 after G1"]
  S1 --> Y1["Output y"]

  U --> P1["Parallel: G1 and G2 share input"]
  P1 --> SUM["Sum ( + / - )"]
  SUM --> Y2["Output y"]

  R["Reference r"] --> FB["Feedback interconnection"]
  FB --> Y3["Output y"]
  Y3 -->|measurement path| H["H"]
  H --> FB

  R --> FF["Feedforward + feedback"]
  FF --> Y4["Output y"]
        

The goal is to replace each interconnection by a single equivalent transfer function \( G_{\mathrm{eq}}(s) \) mapping a chosen external input to a chosen external output.

Consider two LTI subsystems in cascade: subsystem 1 maps \( u(t) \) to \( v(t) \), and subsystem 2 maps \( v(t) \) to \( y(t) \). Let their impulse responses be \( g_1(t) \) and \( g_2(t) \).

By the convolution representation (Lesson 1), \( v(t) \): is \( v(t) = (g_1 * u)(t) \), and \( y(t) \): is \( y(t) = (g_2 * v)(t) \). Therefore,

\[ y(t) = g_2 * (g_1 * u)(t). \]

Using associativity of convolution for integrable (or Laplace-transformable) signals, \( g_2 * (g_1 * u) = (g_2 * g_1) * u \). Taking Laplace transforms (zero initial conditions),

\[ Y(s) = G_2(s)\,V(s),\quad V(s)=G_1(s)\,U(s) \;\;\Rightarrow\;\; Y(s)=G_2(s)G_1(s)U(s). \]

Hence the equivalent transfer function of the cascade is the product:

\[ \boxed{\,G_{\mathrm{series}}(s)=\frac{Y(s)}{U(s)}=G_2(s)\,G_1(s)\, }. \]

Polynomial form. If \( G_1(s)=\frac{N_1(s)}{D_1(s)} \) and \( G_2(s)=\frac{N_2(s)}{D_2(s)} \), then

\[ G_{\mathrm{series}}(s)=\frac{N_2(s)N_1(s)}{D_2(s)D_1(s)}. \]

Order and cancellations. If no pole–zero cancellations occur between \( N_2N_1 \) and \( D_2D_1 \), the system order adds: \( \deg(D_2D_1)=\deg(D_2)+\deg(D_1) \). If cancellations occur, the resulting input–output transfer function may have lower order, but internal signals can still retain higher-order dynamics; this subtlety becomes important in later stability/realizability discussions.

In a parallel interconnection, two subsystems share the same input \( u(t) \), and their outputs are summed (or differenced) to form \( y(t) \): \( y(t)=y_1(t) \pm y_2(t) \).

By linearity, if \( y_1(t)=(g_1*u)(t) \) and \( y_2(t)=(g_2*u)(t) \), then

\[ y(t)= (g_1*u)(t) \pm (g_2*u)(t) = \big((g_1 \pm g_2)*u\big)(t). \]

Taking Laplace transforms gives:

\[ Y(s) = \big(G_1(s)\pm G_2(s)\big)U(s) \;\;\Rightarrow\;\; \boxed{\,G_{\mathrm{par}}(s)=G_1(s)\pm G_2(s)\, }. \]

Weighted summation. More generally, with scalar gains \( \alpha,\beta \in \mathbb{R} \):

\[ y(t)=\alpha y_1(t)+\beta y_2(t) \;\;\Rightarrow\;\; G_{\mathrm{par}}(s)=\alpha G_1(s)+\beta G_2(s). \]

Common-denominator form. With rational transfer functions \( G_i(s)=\frac{N_i(s)}{D_i(s)} \):

\[ G_{\mathrm{par}}(s)=\frac{N_1(s)}{D_1(s)}+\frac{N_2(s)}{D_2(s)} =\frac{N_1(s)D_2(s)+N_2(s)D_1(s)}{D_1(s)D_2(s)}. \]

Feedback connects the output back to the input through another subsystem. Let the forward-path transfer be \( G(s) \) and the feedback-path transfer be \( H(s) \). Define the error signal \( e(t) \) as the difference between the reference input \( r(t) \) and the fed-back measurement.

flowchart LR
  R["r"] --> SUM["sum: e = r - z"]
  SUM --> G["G"]
  G --> Y["y"]
  Y --> H["H"]
  H --> Z["z"]
  Z --> SUM

  R --> F["Feedforward F"]
  F --> ADD["sum: u = C*e + F*r"]
  ADD --> P["Plant P"]
  P --> Y2["y"]
  Y2 --> CFB["Feedback C via e = r - y"]
  CFB --> ADD
        

For the standard negative feedback structure:

\[ E(s)=R(s)-H(s)Y(s),\qquad Y(s)=G(s)E(s). \]

Substituting the second equation into the first:

\[ E(s)=R(s)-H(s)G(s)E(s) \;\;\Rightarrow\;\; \big(1+G(s)H(s)\big)E(s)=R(s). \]

Provided \( 1+G(s)H(s) \) is not the zero polynomial (well-posedness in the rational setting), we solve uniquely for \( E(s) \) and obtain:

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

For positive feedback (sign flipped in the summation), the denominator becomes \( 1-G(s)H(s) \).

Loop transfer and sensitivity functions. Define the loop transfer \( L(s): \( L(s)=G(s)H(s) \). Then define:

\[ \boxed{\,S(s)=\frac{1}{1+L(s)},\qquad T(s)=\frac{L(s)}{1+L(s)}\, }. \]

Identity proof. These satisfy the exact algebraic identity \( S(s)+T(s)=1 \):

\[ S(s)+T(s)=\frac{1}{1+L(s)}+\frac{L(s)}{1+L(s)} =\frac{1+L(s)}{1+L(s)}=1. \]

This identity is purely algebraic, but it becomes conceptually central later when we interpret trade-offs between tracking and disturbance/noise effects.

Disturbance at plant output (introductory computation). Suppose the measured output is \( y(t)=y_0(t)+d(t) \) where \( y_0 \) is produced by the forward path and \( d(t) \) is added disturbance (additive at output). In Laplace form:

\[ Y(s)=G(s)\big(R(s)-H(s)Y(s)\big)+D(s) \;\;\Rightarrow\;\; \big(1+G(s)H(s)\big)Y(s)=G(s)R(s)+D(s). \]

Therefore the disturbance-to-output transfer is:

\[ \boxed{\,\frac{Y(s)}{D(s)}=\frac{1}{1+G(s)H(s)}=S(s)\, }. \]

The same closed-loop denominator \( 1+G(s)H(s) \) appears for all external-to-internal maps in this interconnection, reflecting the shared dynamics created by feedback.

Feedforward means adding an additional path from an external input to an internal actuation signal, without waiting for the output to respond. A common (and mathematically clean) structure is a two-degree-of-freedom interconnection: a feedback path ensures robustness, while a feedforward path shapes the reference-to-output response.

Consider a plant \( P(s) \), a feedback element \( C(s) \), and a feedforward element \( F(s) \). Let the control input be:

\[ U(s)=C(s)\big(R(s)-Y(s)\big)+F(s)R(s). \]

The output is \( Y(s)=P(s)U(s) \). Substitute:

\[ Y(s)=P(s)\Big(C(s)\big(R(s)-Y(s)\big)+F(s)R(s)\Big) =P(s)\big(C(s)+F(s)\big)R(s)-P(s)C(s)Y(s). \]

Collect terms in \( Y(s) \):

\[ \big(1+P(s)C(s)\big)Y(s)=P(s)\big(C(s)+F(s)\big)R(s). \]

Assuming well-posedness (\( 1+P(s)C(s) \neq 0 \) as a rational function), the reference-to-output transfer is:

\[ \boxed{\,\frac{Y(s)}{R(s)}=\frac{P(s)\big(C(s)+F(s)\big)}{1+P(s)C(s)}\, }. \]

Interpretation. The denominator is determined solely by the feedback loop \( 1+P(s)C(s) \), while \( F(s) \) shapes the numerator (tracking dynamics) without directly changing the closed-loop characteristic equation. This separation is a key structural motivation for feedforward.

Ideal reference shaping (algebraic target). If one desires a target transfer \( M(s) \) from \( R \) to \( Y \), then formally one can solve for \( F(s) \):

\[ M(s)=\frac{P(s)\big(C(s)+F(s)\big)}{1+P(s)C(s)} \;\;\Rightarrow\;\; \boxed{\,F(s)=\frac{M(s)\big(1+P(s)C(s)\big)}{P(s)}-C(s)\, }. \]

In practice, additional constraints (e.g., properness and implementability) restrict admissible \( F(s) \), which will be addressed in later lessons on realizability and stability.

We compute series, parallel, and feedback equivalents using the python-control toolbox (widely used in control engineering). We also show a manual rational-combination check with numerator/denominator polynomials.

import numpy as np

# Optional: pip install control
import control as ct

# Define subsystems
s = ct.TransferFunction.s
G1 = 1 / (s + 1)          # G1(s) = 1/(s+1)
G2 = 2 / (s + 2)          # G2(s) = 2/(s+2)
H  = 0.5                  # H(s) = 0.5 (static gain)

# Series (cascade): G2 after G1
G_series = ct.series(G1, G2)          # equals G2*G1 for SISO transfer functions

# Parallel: sum
G_parallel = ct.parallel(G1, G2)      # equals G1 + G2

# Negative feedback: forward=G_series, feedback=H
G_cl = ct.feedback(G_series, H, sign=-1)  # sign=-1 means negative feedback

print("G_series =", G_series)
print("G_parallel =", G_parallel)
print("G_cl =", G_cl)

# Verify closed-loop formula explicitly: G/(1+G*H)
G_cl_check = G_series / (1 + G_series * H)
print("Closed-loop difference (should be ~0):")
print(ct.minreal(G_cl - G_cl_check, verbose=False))

# Basic time-domain verification
t = np.linspace(0, 10, 400)
t1, y1 = ct.step_response(G_series, T=t)
t2, y2 = ct.step_response(G_cl, T=t)

# If you want plotting (optional):
# import matplotlib.pyplot as plt
# plt.figure(); plt.plot(t1, y1); plt.title("Step: series"); plt.grid(True)
# plt.figure(); plt.plot(t2, y2); plt.title("Step: closed-loop"); plt.grid(True)
# plt.show()
      

Library note. For signal-processing-oriented workflows, scipy.signal also supports transfer functions, but feedback/series composition is less direct than in python-control, so polynomial arithmetic (next sections) is often used to assemble interconnections.

The following C++ code implements transfer functions as numerator/denominator polynomials in descending powers of \( s \). It provides: series multiplication, parallel addition (common denominator), and negative feedback: \( \frac{G}{1+GH} \). This is purely algebraic and suitable for symbolic/numeric coefficient computations.

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

struct Poly {
  // Coefficients in descending powers: a[0] s^n + ... + a[n]
  std::vector<double> a;

  explicit Poly(std::vector<double> coeffs) : a(std::move(coeffs)) {
    if (a.empty()) throw std::runtime_error("Empty polynomial");
  }
};

static std::vector<double> conv_desc(const std::vector<double>& p,
                                     const std::vector<double>& q) {
  // Convolution assuming descending-power coefficient arrays
  const int np = (int)p.size();
  const int nq = (int)q.size();
  std::vector<double> r(np + nq - 1, 0.0);
  for (int i = 0; i < np; ++i) {
    for (int j = 0; j < nq; ++j) {
      r[i + j] += p[i] * q[j];
    }
  }
  return r;
}

static std::vector<double> pad_left(const std::vector<double>& p, int n) {
  // Pad on the left (higher powers) so sizes match
  if ((int)p.size() >= n) return p;
  std::vector<double> out(n - (int)p.size(), 0.0);
  out.insert(out.end(), p.begin(), p.end());
  return out;
}

static std::vector<double> add_desc(const std::vector<double>& p,
                                    const std::vector<double>& q,
                                    double sign_q = 1.0) {
  int n = (int)std::max(p.size(), q.size());
  auto P = pad_left(p, n);
  auto Q = pad_left(q, n);
  std::vector<double> r(n, 0.0);
  for (int i = 0; i < n; ++i) r[i] = P[i] + sign_q * Q[i];
  return r;
}

struct TF {
  Poly num;
  Poly den;

  TF(Poly n, Poly d) : num(std::move(n)), den(std::move(d)) {}
};

// Series: G = G2 * G1
static TF series(const TF& G1, const TF& G2) {
  return TF(Poly(conv_desc(G2.num.a, G1.num.a)),
            Poly(conv_desc(G2.den.a, G1.den.a)));
}

// Parallel: G = G1 + G2 = (N1 D2 + N2 D1) / (D1 D2)
static TF parallel_sum(const TF& G1, const TF& G2) {
  auto D = conv_desc(G1.den.a, G2.den.a);
  auto N1D2 = conv_desc(G1.num.a, G2.den.a);
  auto N2D1 = conv_desc(G2.num.a, G1.den.a);
  auto N = add_desc(N1D2, N2D1, 1.0);
  return TF(Poly(N), Poly(D));
}

// Negative feedback with feedback H: T = G / (1 + G H)
static TF feedback_neg(const TF& G, const TF& H) {
  // G = Ng/Dg, H = Nh/Dh
  // GH = (Ng Nh) / (Dg Dh)
  auto NgNh = conv_desc(G.num.a, H.num.a);
  auto DgDh = conv_desc(G.den.a, H.den.a);

  // 1 + GH = (DgDh + NgNh) / DgDh
  auto Den_cl = add_desc(DgDh, NgNh, 1.0);

  // T = (Ng/Dg) / ((DgDh + NgNh)/DgDh) = Ng Dh / (DgDh + NgNh)
  auto NgDh = conv_desc(G.num.a, H.den.a);
  return TF(Poly(NgDh), Poly(Den_cl));
}

static void print_poly(const std::vector<double>& a) {
  std::cout << "[";
  for (size_t i = 0; i < a.size(); ++i) {
    std::cout << a[i] << (i + 1 == a.size() ? "" : ", ");
  }
  std::cout << "]";
}

int main() {
  // Example:
  // G1(s) = 1/(s+1) => num=[1], den=[1,1]
  // G2(s) = 2/(s+2) => num=[2], den=[1,2]
  // H(s)  = 0.5     => num=[0.5], den=[1]
  TF G1(Poly({1.0}), Poly({1.0, 1.0}));
  TF G2(Poly({2.0}), Poly({1.0, 2.0}));
  TF H (Poly({0.5}), Poly({1.0}));

  TF Gs = series(G1, G2);
  TF Gcl = feedback_neg(Gs, H);

  std::cout << "Series num="; print_poly(Gs.num.a);
  std::cout << " den="; print_poly(Gs.den.a);
  std::cout << std::endl;

  std::cout << "Closed-loop num="; print_poly(Gcl.num.a);
  std::cout << " den="; print_poly(Gcl.den.a);
  std::cout << std::endl;

  return 0;
}
      

This coefficient-level representation is sufficient for many tasks (composition, characteristic polynomial construction, symbolic manipulation). Later lessons can add numerical response computation (step/frequency) by converting the rational model to a differential equation or state-space realization.

The following Java code mirrors the C++ approach: polynomials in descending powers, convolution for multiplication, and common-denominator arithmetic for addition. This is appropriate for implementing block-level transfer-function algebra without depending on external libraries.

import java.util.Arrays;

class Poly {
  // Descending powers: a[0] s^n + ... + a[n]
  public final double[] a;

  public Poly(double[] coeffs) {
    if (coeffs == null || coeffs.length == 0) throw new IllegalArgumentException("Empty polynomial");
    this.a = coeffs;
  }
}

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

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

public class TFInterconnect {

  static double[] convDesc(double[] p, double[] q) {
    double[] r = new double[p.length + q.length - 1];
    for (int i = 0; i < p.length; i++) {
      for (int j = 0; j < q.length; j++) {
        r[i + j] += p[i] * q[j];
      }
    }
    return r;
  }

  static double[] padLeft(double[] p, int n) {
    if (p.length >= n) return p;
    double[] out = new double[n];
    int shift = n - p.length;
    for (int i = 0; i < p.length; i++) out[shift + i] = p[i];
    return out;
  }

  static double[] addDesc(double[] p, double[] q, double signQ) {
    int n = Math.max(p.length, q.length);
    double[] P = padLeft(p, n);
    double[] Q = padLeft(q, n);
    double[] r = new double[n];
    for (int i = 0; i < n; i++) r[i] = P[i] + signQ * Q[i];
    return r;
  }

  static TF series(TF G1, TF G2) {
    return new TF(new Poly(convDesc(G2.num.a, G1.num.a)),
                  new Poly(convDesc(G2.den.a, G1.den.a)));
  }

  static TF parallelSum(TF G1, TF G2) {
    double[] D = convDesc(G1.den.a, G2.den.a);
    double[] N1D2 = convDesc(G1.num.a, G2.den.a);
    double[] N2D1 = convDesc(G2.num.a, G1.den.a);
    double[] N = addDesc(N1D2, N2D1, 1.0);
    return new TF(new Poly(N), new Poly(D));
  }

  static TF feedbackNeg(TF G, TF H) {
    double[] NgNh = convDesc(G.num.a, H.num.a);
    double[] DgDh = convDesc(G.den.a, H.den.a);
    double[] DenCl = addDesc(DgDh, NgNh, 1.0);      // DgDh + NgNh
    double[] NgDh = convDesc(G.num.a, H.den.a);     // Ng*Dh
    return new TF(new Poly(NgDh), new Poly(DenCl));
  }

  public static void main(String[] args) {
    TF G1 = new TF(new Poly(new double[]{1.0}), new Poly(new double[]{1.0, 1.0})); // 1/(s+1)
    TF G2 = new TF(new Poly(new double[]{2.0}), new Poly(new double[]{1.0, 2.0})); // 2/(s+2)
    TF H  = new TF(new Poly(new double[]{0.5}), new Poly(new double[]{1.0}));      // 0.5

    TF Gs  = series(G1, G2);
    TF Gcl = feedbackNeg(Gs, H);

    System.out.println("Series num=" + Arrays.toString(Gs.num.a) + " den=" + Arrays.toString(Gs.den.a));
    System.out.println("Closed-loop num=" + Arrays.toString(Gcl.num.a) + " den=" + Arrays.toString(Gcl.den.a));
  }
}
      

For advanced workflows, Java scientific ecosystems can pair this algebra with numerical solvers (e.g., ODE integration) to generate time responses. However, the interconnection formulas themselves are exact and purely algebraic.

MATLAB’s Control System Toolbox provides direct operators for series, parallel, and feedback interconnections. The same interconnections can be constructed in Simulink using summation and transfer function blocks.

9.1 MATLAB (Control System Toolbox)

s = tf('s');
G1 = 1/(s+1);
G2 = 2/(s+2);
H  = 0.5;

G_series   = series(G1, G2);          % cascade
G_parallel = parallel(G1, G2);        % sum
G_cl       = feedback(G_series, H);   % negative feedback by default

G_cl_check = G_series/(1 + G_series*H);

disp(G_series);
disp(G_parallel);
disp(G_cl);
disp(minreal(G_cl - G_cl_check));

% Step responses
t = 0:0.02:10;
step(G_series, t); grid on; title('Step: series');
figure; step(G_cl, t); grid on; title('Step: closed-loop');
      

9.2 Simulink (Programmatic Construction Sketch)

The following script programmatically creates a simple negative-feedback model: reference \( r \) → sum (r - Hy) → G → y, with H in the feedback path.

model = 'ch6_l4_feedback_demo';
new_system(model); open_system(model);

% Blocks
add_block('simulink/Sources/Step', [model '/r']);
add_block('simulink/Math Operations/Sum', [model '/Sum']);
set_param([model '/Sum'], 'Inputs', '+-');

add_block('simulink/Continuous/Transfer Fcn', [model '/G']);
set_param([model '/G'], 'Numerator', '[2]', 'Denominator', '[1 3 2]'); % example: 2/((s+1)(s+2))

add_block('simulink/Continuous/Transfer Fcn', [model '/H']);
set_param([model '/H'], 'Numerator', '[0.5]', 'Denominator', '[1]');

add_block('simulink/Sinks/Scope', [model '/Scope']);

% Wiring
add_line(model, 'r/1', 'Sum/1');
add_line(model, 'Sum/1', 'G/1');
add_line(model, 'G/1', 'Scope/1');
add_line(model, 'G/1', 'H/1');
add_line(model, 'H/1', 'Sum/2');

save_system(model);
      

This model implements the same algebraic closed-loop transfer \( \frac{G}{1+GH} \) derived in Section 4.

Mathematica supports transfer-function models and interconnections symbolically and numerically. The code below constructs series, parallel, and feedback interconnections and simplifies the resulting rational forms.

(* Define transfer functions in the Laplace variable s *)
G1 = TransferFunctionModel[{1}, {s + 1}, s];
G2 = TransferFunctionModel[{2}, {s + 2}, s];
H  = TransferFunctionModel[{1/2}, {1}, s];

Gseries = SystemsModelSeriesConnect[G1, G2];
Gpar    = SystemsModelParallelConnect[G1, G2];

(* Negative feedback: forward Gseries with feedback H *)
Gcl = SystemsModelFeedbackConnect[Gseries, H];

(* Show simplified rational form *)
GseriesTF = TransferFunctionExpand[Gseries]
GparTF    = TransferFunctionExpand[Gpar]
GclTF     = TransferFunctionExpand[Gcl]

(* Verify G/(1+GH) explicitly *)
Gcheck = TransferFunctionExpand[Gseries/(1 + Gseries.H)];
FullSimplify[GclTF == Gcheck]
      

Mathematica’s symbolic simplification is particularly useful for verifying equivalence of alternative interconnection derivations.

Problem 1 (Series interconnection): Let \( G_1(s)=\frac{2}{s+3} \) and \( G_2(s)=\frac{s+1}{s^2+4s+5} \). Compute the equivalent series transfer \( G_{\mathrm{series}}(s) \) and give the numerator/denominator polynomials.

Solution:

\[ G_{\mathrm{series}}(s)=G_2(s)G_1(s) =\frac{s+1}{s^2+4s+5}\cdot\frac{2}{s+3} =\frac{2(s+1)}{(s+3)(s^2+4s+5)}. \]

Expand the denominator:

\[ (s+3)(s^2+4s+5)=s^3+7s^2+17s+15, \]

so \( N(s)=2s+2 \) and \( D(s)=s^3+7s^2+17s+15 \).

Problem 2 (Parallel interconnection): Let \( G_1(s)=\frac{1}{s+1} \) and \( G_2(s)=\frac{1}{s+2} \). Compute \( G_{\mathrm{par}}(s)=G_1(s)+G_2(s) \) as a single rational function.

Solution:

\[ G_{\mathrm{par}}(s)=\frac{1}{s+1}+\frac{1}{s+2} =\frac{(s+2)+(s+1)}{(s+1)(s+2)} =\frac{2s+3}{s^2+3s+2}. \]

Problem 3 (Negative feedback closed-loop): Let \( G(s)=\frac{10}{s(s+1)} \) and \( H(s)=1 \). Derive the closed-loop transfer \( \frac{Y(s)}{R(s)} \) for negative feedback and state the closed-loop characteristic polynomial.

Solution:

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

The characteristic polynomial is:

\[ s(s+1)+10=s^2+s+10. \]

Problem 4 (Sensitivity identity and disturbance transfer): For negative feedback with loop transfer \( L(s)=G(s)H(s) \), define \( S(s)=\frac{1}{1+L(s)} \) and \( T(s)=\frac{L(s)}{1+L(s)} \). (a) Prove \( S(s)+T(s)=1 \). (b) If an additive disturbance \( D(s) \) is added at the output so that \( (1+L(s))Y(s)=G(s)R(s)+D(s) \), compute \( \frac{Y(s)}{D(s)} \).

Solution:

(a) Algebraic proof:

\[ S(s)+T(s)=\frac{1}{1+L(s)}+\frac{L(s)}{1+L(s)}=\frac{1+L(s)}{1+L(s)}=1. \]

(b) Set \( R(s)=0 \) in \( (1+L)Y=GR + D \):

\[ (1+L(s))Y(s)=D(s)\;\;\Rightarrow\;\;\frac{Y(s)}{D(s)}=\frac{1}{1+L(s)}=S(s). \]

Problem 5 (Feedforward shaping formula): Consider the two-degree-of-freedom interconnection from Section 5: \( U(s)=C(s)(R(s)-Y(s))+F(s)R(s) \), \( Y(s)=P(s)U(s) \). Show that \( \frac{Y(s)}{R(s)}=\frac{P(s)(C(s)+F(s))}{1+P(s)C(s)} \) and solve for \( F(s) \) that yields a desired target \( \frac{Y(s)}{R(s)}=M(s) \).

Solution:

Substitute \( U \) into \( Y=P U \):

\[ Y=P\Big(C(R-Y)+FR\Big)=P(C+F)R-PCY \;\;\Rightarrow\;\; (1+PC)Y=P(C+F)R, \]

hence \( \frac{Y}{R}=\frac{P(C+F)}{1+PC} \). For \( \frac{Y}{R}=M \):

\[ M=\frac{P(C+F)}{1+PC} \;\;\Rightarrow\;\; C+F=\frac{M(1+PC)}{P} \;\;\Rightarrow\;\; F=\frac{M(1+PC)}{P}-C. \]

This is an algebraic solution; later lessons constrain \( F \) to be implementable (e.g., proper) and compatible with physical realizability.

We established an exact interconnection algebra for LTI subsystems using transfer functions under zero initial conditions. Series interconnection multiplies transfer functions, parallel interconnection adds them via common-denominator arithmetic, and feedback yields the rational closed-loop form \( \frac{G}{1+GH} \) (negative feedback), introducing the sensitivity functions \( S=\frac{1}{1+L} \) and \( T=\frac{L}{1+L} \). Feedforward adds numerator-shaping freedom while preserving the feedback-determined closed-loop denominator. These formulas will be operationalized further in the next chapter using systematic diagram-reduction techniques.