Previous lessons introduced quadratic performance descriptors of the form \( \mathbf{x}^{\top}\mathbf{Q}\mathbf{x} \) and \( \mathbf{u}^{\top}\mathbf{R}\mathbf{u} \). In this lesson, we interpret how changing the entries of \( \mathbf{Q} \) and \( \mathbf{R} \) affects the closed-loop response after feedback has been redesigned. For a continuous-time LTI plant

\[ \dot{\mathbf{x} }=\mathbf{A}\mathbf{x}+\mathbf{B}\mathbf{u},\qquad \mathbf{u}=-\mathbf{K}\mathbf{x}, \]

the closed-loop state matrix is \( \mathbf{A}_{cl}=\mathbf{A}-\mathbf{B}\mathbf{K} \). The weights influence the transient behavior only through the gain \( \mathbf{K} \) selected by the design procedure.

\[ \boxed{ \begin{aligned} &\text{Weights describe priorities;}\\ &\text{the redesigned feedback gain converts those priorities into closed-loop behavior.} \end{aligned} } \]

Therefore, two statements must be separated:

Fixed-controller statement: If \( \mathbf{K} \) is fixed, changing \( \mathbf{Q} \) or \( \mathbf{R} \) changes the numerical value assigned to a trajectory, but it does not change the trajectory itself.

Redesigned-controller statement: If the controller is recomputed after changing the weights, larger state weights usually demand stronger correction of those states, while larger input weights usually demand weaker actuator usage and slower transients.

Assume first that \( \mathbf{Q}=\operatorname{diag}(q_1,\dots,q_n) \) with \( q_i \ge 0 \). Then

\[ \mathbf{x}^{\top}\mathbf{Q}\mathbf{x}=\sum_{i=1}^{n}q_i x_i^2. \]

The level set \( \mathbf{x}^{\top}\mathbf{Q}\mathbf{x}=c \) is an ellipsoid. Along coordinate \( x_i \), the allowed radius is approximately \( \sqrt{c/q_i} \). Hence increasing \( q_i \) makes excursions in \( x_i \) more expensive and geometrically narrows the acceptable set along that coordinate.

\[ q_i \uparrow \quad \Longrightarrow \quad \sqrt{\frac{c}{q_i} }\downarrow \quad \Longrightarrow \quad \text{less tolerance for the state component }x_i. \]

Similarly, if \( \mathbf{R}=\operatorname{diag}(r_1,\dots,r_m) \) with \( r_j > 0 \), then

\[ \mathbf{u}^{\top}\mathbf{R}\mathbf{u}=\sum_{j=1}^{m}r_j u_j^2. \]

A large \( r_j \) makes the \( j \)-th actuator expensive. A controller designed with this penalty tends to avoid that actuator unless the state penalty justifies the effort.

Let a stabilizing feedback gain \( \mathbf{K} \) be fixed, and define \( \mathbf{A}_{cl}=\mathbf{A}-\mathbf{B}\mathbf{K} \). Consider the infinite-horizon quadratic evaluation of the trajectory:

\[ J_{\mathbf{K} }(\mathbf{x}_0)=\int_{0}^{\infty} \left(\mathbf{x}^{\top}\mathbf{Q}\mathbf{x}+ \mathbf{u}^{\top}\mathbf{R}\mathbf{u}\right)dt,\qquad \mathbf{u}=-\mathbf{K}\mathbf{x}. \]

Substituting the feedback law gives the closed-loop state-only weight

\[ \mathbf{M}_{\mathbf{K} }=\mathbf{Q}+\mathbf{K}^{\top} \mathbf{R}\mathbf{K}. \]

If \( \mathbf{A}_{cl} \) is asymptotically stable, the symmetric matrix \( \mathbf{S}_{\mathbf{K} } \) satisfying the Lyapunov equation

\[ \mathbf{A}_{cl}^{\top}\mathbf{S}_{\mathbf{K} }+ \mathbf{S}_{\mathbf{K} }\mathbf{A}_{cl} =-\mathbf{M}_{\mathbf{K} } \]

yields the exact identity

\[ J_{\mathbf{K} }(\mathbf{x}_0)= \mathbf{x}_0^{\top}\mathbf{S}_{\mathbf{K} }\mathbf{x}_0. \]

This identity is crucial: with \( \mathbf{K} \) fixed, the dynamics remain governed by \( \mathbf{A}_{cl} \). Changing \( \mathbf{Q} \) and \( \mathbf{R} \) changes \( \mathbf{M}_{\mathbf{K} } \) and the evaluated cost, but not the closed-loop poles.

Define the Lyapunov function \( V(\mathbf{x})=\mathbf{x}^{\top}\mathbf{S}_{\mathbf{K} }\mathbf{x} \). Along the closed-loop trajectory \( \dot{\mathbf{x} }=\mathbf{A}_{cl}\mathbf{x} \),

\[ \dot{V}= \mathbf{x}^{\top}\left(\mathbf{A}_{cl}^{\top}\mathbf{S}_{\mathbf{K} }+ \mathbf{S}_{\mathbf{K} }\mathbf{A}_{cl}\right)\mathbf{x}. \]

Using the Lyapunov equation,

\[ \dot{V}=-\mathbf{x}^{\top}\mathbf{M}_{\mathbf{K} }\mathbf{x} =-\left(\mathbf{x}^{\top}\mathbf{Q}\mathbf{x} +\mathbf{u}^{\top}\mathbf{R}\mathbf{u}\right). \]

Integrating from \( 0 \) to infinity gives

\[ \int_{0}^{\infty} \left(\mathbf{x}^{\top}\mathbf{Q}\mathbf{x} +\mathbf{u}^{\top}\mathbf{R}\mathbf{u}\right)dt =V(\mathbf{x}_0)-\lim_{t\to\infty}V(\mathbf{x}(t)). \]

Since \( \mathbf{A}_{cl} \) is asymptotically stable, \( \mathbf{x}(t) \) converges to zero, and therefore the limiting term is zero. Thus \( J_{\mathbf{K} }(\mathbf{x}_0)= \mathbf{x}_0^{\top}\mathbf{S}_{\mathbf{K} }\mathbf{x}_0 \).

The most common qualitative effects are summarized below. These effects assume that the feedback gain is redesigned after the weights are changed.

flowchart TD
  A["Choose performance priorities"] --> B["Increase selected \nstate weights q_i"]
  A --> C["Increase selected \ninput weights r_j"]
  A --> D["Add off-diagonal \nstate weights"]
  B --> E["Smaller tolerated excursions \nin those states"]
  E --> F["Usually faster correction \nand larger control effort"]
  C --> G["Actuator becomes \nmore expensive"]
  G --> H["Usually slower response \nand smoother input"]
  D --> I["Penalize coupled \nstate combinations"]
  I --> J["Controller reacts \nto state directions, \nnot only coordinates"]
  F --> K["Closed-loop poles and transient shape after redesign"]
  H --> K
  J --> K
        

A large weight on position-like states tends to reduce overshoot and steady excursion of those states. A large weight on velocity-like states tends to increase damping and smoothness. A large input penalty tends to reduce actuator peaks, often at the cost of slower convergence.

A one-state system gives a transparent analytic view. Consider

\[ \dot{x}=ax+bu,\qquad u=-kx,\qquad b > 0. \]

For the scalar quadratic criterion

\[ J=\int_{0}^{\infty}\left(qx^2+ru^2\right)dt,\qquad q\ge 0,\quad r > 0, \]

the stabilizing scalar solution has gain

\[ k=\frac{a+\sqrt{a^2+b^2q/r} }{b}. \]

Therefore, the closed-loop eigenvalue is

\[ \lambda_{cl}=a-bk=-\sqrt{a^2+b^2q/r}. \]

This formula makes the dominant trade-off explicit: increasing \( q/r \) pushes the scalar closed-loop pole farther left, so the response decays faster. Decreasing \( q/r \) makes the pole closer to the imaginary axis, so the response is slower and the input is smaller.

In multi-state systems, weights do not only penalize individual coordinates. A general symmetric positive semidefinite \( \mathbf{Q} \) can be diagonalized as

\[ \mathbf{Q}=\mathbf{U}\boldsymbol{\Lambda}\mathbf{U}^{\top},\qquad \boldsymbol{\Lambda}=\operatorname{diag}(\lambda_1,\dots,\lambda_n), \quad \lambda_i\ge 0. \]

Then

\[ \mathbf{x}^{\top}\mathbf{Q}\mathbf{x}= \sum_{i=1}^{n}\lambda_i \left(\mathbf{u}_i^{\top}\mathbf{x}\right)^2. \]

Thus \( \mathbf{Q} \) penalizes directions \( \mathbf{u}_i \) in state space, not necessarily the original coordinates. Off-diagonal terms represent a preference about combinations such as \( x_1+x_2 \) or \( x_1-x_2 \). This is why coordinate scaling and physical units matter before selecting numerical weights.

\[ \boxed{ \begin{aligned} &\text{A large diagonal entry penalizes a coordinate;}\\ &\text{a large eigenvalue penalizes a state-space direction.} \end{aligned} } \]

Suppose a new state vector is defined by \( \mathbf{z}=\mathbf{T}\mathbf{x} \). Then \( \mathbf{x}=\mathbf{T}^{-1}\mathbf{z} \), and the same physical quadratic penalty can be written as

\[ \mathbf{x}^{\top}\mathbf{Q}_x\mathbf{x} =\mathbf{z}^{\top}\mathbf{Q}_z\mathbf{z},\qquad \mathbf{Q}_z=\mathbf{T}^{-\top}\mathbf{Q}_x\mathbf{T}^{-1}. \]

Therefore, the same numerical matrix is not generally meaningful under a change of units. For example, a position measured in meters and the same position measured in millimeters require different numerical weights if the physical penalty is to remain unchanged.

A practical normalization rule is to choose acceptable maximum magnitudes \( x_{i,\max} \) and \( u_{j,\max} \), then set

\[ q_i=\frac{1}{x_{i,\max}^2},\qquad r_j=\frac{1}{u_{j,\max}^2}. \]

This makes the normalized quantities \( x_i/x_{i,\max} \) and \( u_j/u_{j,\max} \) comparable inside the quadratic criterion.

Although exact pole locations require a design algorithm, the following qualitative relationships are robust in many controllable systems:

Large position/state-error weights: reduce large state deviations and often reduce settling time, but may create larger actuator peaks and sensitivity to unmodeled actuator limits.

Large velocity/rate weights: often increase damping, reduce oscillation, and make the response smoother, but may slow the movement of position-like states.

Large input weights: reduce input magnitude and energy, but can produce slower responses, larger state excursions, and weaker disturbance rejection.

Small input weights: permit aggressive control action, but may cause actuator saturation, noise amplification, and poor robustness if model uncertainty is present.

\[ \text{large } \mathbf{Q} \quad \text{relative to } \mathbf{R} \quad \Longrightarrow \quad \text{state regulation is prioritized over actuator economy}. \]

\[ \text{large } \mathbf{R} \quad \text{relative to } \mathbf{Q} \quad \Longrightarrow \quad \text{actuator economy is prioritized over fast state regulation}. \]

The following workflow is suitable before entering a full optimal control course. It keeps the focus on performance interpretation rather than on solving the general Riccati equation.

flowchart TD
  S["Start with physical limits and state meanings"] --> N["Normalize states and inputs"]
  N --> Q["Choose baseline diagonal Q and R"]
  Q --> D["Redesign feedback gain"]
  D --> SIM["Simulate initial response and disturbance response"]
  SIM --> CHECK["Check settling, overshoot, peak input, saturation"]
  CHECK --> DEC{"Acceptable trade-off?"}
  DEC -->|yes| DONE["Document final weights and response"]
  DEC -->|no| ADJ["Adjust one weight group at a time"]
  ADJ --> D
        

The most important practical rule is to adjust one group of weights at a time. If many weights are changed simultaneously, it becomes difficult to know whether a response change came from a state-priority change, an actuator-penalty change, or an interaction between the two.

Python: Use NumPy for matrices, SciPy for Riccati and Lyapunov equations, and Matplotlib for response comparison. The python-control package is also widely used for state-space systems, but the example below uses SciPy directly.

C++: Use Eigen or Armadillo for matrix computations. The example below uses a scalar closed-form derivation so that the qualitative dependency on \( q/r \) is visible without external dependencies.

Java: Use EJML or Apache Commons Math for matrix computations in larger examples. The Java example also uses the scalar closed-form formula.

MATLAB/Simulink: Use lqr, ss, initial, and Simulink feedback blocks. Simulink is especially useful for comparing saturation, disturbances, and actuator constraints.

Wolfram Mathematica: Use symbolic manipulation, NDSolveValue, and plotting to study analytic formulas and qualitative dependencies.

Chapter28_Lesson4.py

# Chapter28_Lesson4.py
# Qualitative effect of Q and R weights on closed-loop behavior.
#
# Libraries:
#   numpy, scipy, matplotlib
# Optional modern-control ecosystem:
#   python-control can also compute lqr(A, B, Q, R), but this file uses SciPy directly.

import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import solve_continuous_are
from scipy.integrate import solve_ivp


def lqr_gain(A, B, Q, R):
    """Continuous-time LQR gain K = R^{-1} B^T P."""
    P = solve_continuous_are(A, B, Q, R)
    K = np.linalg.solve(R, B.T @ P)
    eig_cl = np.linalg.eigvals(A - B @ K)
    return K, P, eig_cl


def simulate_closed_loop(A, B, K, x0, t_final=8.0):
    """Simulate x_dot = (A - B K) x from an initial condition."""
    Acl = A - B @ K

    def rhs(t, x):
        return Acl @ x

    sol = solve_ivp(rhs, (0.0, t_final), x0, max_step=0.01, dense_output=True)
    t = np.linspace(0.0, t_final, 900)
    X = sol.sol(t)
    U = -K @ X
    return t, X, U


def main():
    # A lightly damped second-order system:
    # x1 = position-like state, x2 = velocity-like state, u = force-like input.
    A = np.array([[0.0, 1.0],
                  [-1.0, -0.15]])
    B = np.array([[0.0],
                  [1.0]])

    cases = {
        "balanced": (np.diag([1.0, 1.0]), np.array([[1.0]])),
        "high_position_weight": (np.diag([25.0, 1.0]), np.array([[1.0]])),
        "high_velocity_weight": (np.diag([1.0, 25.0]), np.array([[1.0]])),
        "high_input_penalty": (np.diag([1.0, 1.0]), np.array([[25.0]])),
        "low_input_penalty": (np.diag([1.0, 1.0]), np.array([[0.04]])),
    }

    x0 = np.array([1.0, 0.0])
    summary = []

    plt.figure(figsize=(10, 6))
    for name, (Q, R) in cases.items():
        K, P, eig_cl = lqr_gain(A, B, Q, R)
        t, X, U = simulate_closed_loop(A, B, K, x0)
        J0 = float(x0.T @ P @ x0)
        summary.append((name, K, eig_cl, J0, np.max(np.abs(U))))
        plt.plot(t, X[0, :], label=f"{name}: x1")

    plt.xlabel("time [s]")
    plt.ylabel("state x1")
    plt.title("Changing Q and R reshapes the closed-loop transient after redesign")
    plt.grid(True)
    plt.legend()
    plt.tight_layout()
    plt.show()

    print("\nQualitative tuning table")
    print("-" * 92)
    print(f"{'case':25s} {'K':27s} {'closed-loop eigenvalues':30s} {'J(x0)':>8s} {'max|u|':>8s}")
    print("-" * 92)
    for name, K, eig_cl, J0, umax in summary:
        k_str = np.array2string(K, precision=3, suppress_small=True)
        e_str = np.array2string(eig_cl, precision=3, suppress_small=True)
        print(f"{name:25s} {k_str:27s} {e_str:30s} {J0:8.3f} {umax:8.3f}")


if __name__ == "__main__":
    main()

Chapter28_Lesson4.cpp

// Chapter28_Lesson4.cpp
// Scalar closed-form LQR illustration for qualitative Q/R effects.
// Compile example:
//   g++ -std=c++17 Chapter28_Lesson4.cpp -O2 -o Chapter28_Lesson4

#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>

struct CaseData {
    std::string name;
    double q;
    double r;
};

int main() {
    // Scalar unstable or lightly stable plant: x_dot = a x + b u, u = -k x.
    // For q > 0, r > 0, the stabilizing scalar LQR solution gives:
    // k = (a + sqrt(a^2 + b^2 q/r)) / b, assuming b > 0.
    const double a = 0.4;
    const double b = 1.0;
    const double x0 = 1.0;

    std::vector<CaseData> cases = {
        {"balanced", 1.0, 1.0},
        {"larger_state_weight", 25.0, 1.0},
        {"larger_input_weight", 1.0, 25.0},
        {"small_input_weight", 1.0, 0.04}
    };

    std::cout << std::fixed << std::setprecision(5);
    std::cout << "case, q, r, k, closed_loop_lambda, settling_indicator, initial_u\n";

    for (const auto& c : cases) {
        double k = (a + std::sqrt(a * a + b * b * c.q / c.r)) / b;
        double lambda_cl = a - b * k;
        double settling_indicator = -1.0 / lambda_cl;  // smaller means faster decay
        double u0 = -k * x0;

        std::cout << c.name << ", "
                  << c.q << ", "
                  << c.r << ", "
                  << k << ", "
                  << lambda_cl << ", "
                  << settling_indicator << ", "
                  << u0 << "\n";
    }

    return 0;
}

Chapter28_Lesson4.java

// Chapter28_Lesson4.java
// Scalar closed-form LQR illustration for qualitative Q/R effects.
// Compile and run:
//   javac Chapter28_Lesson4.java
//   java Chapter28_Lesson4

public class Chapter28_Lesson4 {
    static class CaseData {
        String name;
        double q;
        double r;

        CaseData(String name, double q, double r) {
            this.name = name;
            this.q = q;
            this.r = r;
        }
    }

    public static void main(String[] args) {
        // Scalar plant: x_dot = a x + b u, u = -k x.
        // Stabilizing scalar LQR gain:
        // k = (a + sqrt(a^2 + b^2 q/r)) / b, for b > 0.
        double a = 0.4;
        double b = 1.0;
        double x0 = 1.0;

        CaseData[] cases = {
            new CaseData("balanced", 1.0, 1.0),
            new CaseData("larger_state_weight", 25.0, 1.0),
            new CaseData("larger_input_weight", 1.0, 25.0),
            new CaseData("small_input_weight", 1.0, 0.04)
        };

        System.out.println("case, q, r, k, closed_loop_lambda, settling_indicator, initial_u");

        for (CaseData c : cases) {
            double k = (a + Math.sqrt(a * a + b * b * c.q / c.r)) / b;
            double lambdaCl = a - b * k;
            double settlingIndicator = -1.0 / lambdaCl;
            double u0 = -k * x0;

            System.out.printf(
                "%s, %.5f, %.5f, %.5f, %.5f, %.5f, %.5f%n",
                c.name, c.q, c.r, k, lambdaCl, settlingIndicator, u0
            );
        }
    }
}

Chapter28_Lesson4.m

% Chapter28_Lesson4.m
% Qualitative effect of different Q and R weights on closed-loop behavior.
% Requires: Control System Toolbox for lqr, ss, and initial.
% Simulink extension:
%   Use a State-Space block with Acl = A - B*K for each case, or build
%   the feedback loop with State-Space Plant, Gain K, Sum, and Scope blocks.

clear; clc; close all;

A = [0 1; -1 -0.15];
B = [0; 1];
C = eye(2);
D = zeros(2,1);
x0 = [1; 0];

cases = {
    'balanced',             diag([1 1]),       1;
    'high_position_weight', diag([25 1]),      1;
    'high_velocity_weight', diag([1 25]),      1;
    'high_input_penalty',   diag([1 1]),       25;
    'low_input_penalty',    diag([1 1]),       0.04
};

t = linspace(0, 8, 900);

figure; hold on; grid on;
title('Changing Q and R changes the redesigned closed-loop transient');
xlabel('time [s]');
ylabel('state x_1');

fprintf('\n%-24s %-24s %-28s %-12s\n', 'case', 'K', 'eig(A-BK)', 'max|u|');
fprintf('%s\n', repmat('-', 1, 92));

for i = 1:size(cases,1)
    name = cases{i,1};
    Q = cases{i,2};
    R = cases{i,3};

    K = lqr(A, B, Q, R);
    Acl = A - B*K;
    sys_cl = ss(Acl, B, C, D);

    [y, t_out, x] = initial(sys_cl, x0, t);
    u = -(K*x')';

    plot(t_out, y(:,1), 'DisplayName', name);

    lam = eig(Acl);
    fprintf('%-24s [%.4f %.4f]      [% .4f%+.4fi, % .4f%+.4fi]   %.4f\n', ...
        name, K(1), K(2), ...
        real(lam(1)), imag(lam(1)), ...
        real(lam(2)), imag(lam(2)), ...
        max(abs(u)));
end

legend('Location','best');

% In Simulink:
% 1. Put the plant in a State-Space block: x_dot = A x + B u, y = x.
% 2. Feed y into a Gain block K.
% 3. Use a Sum block to implement u = -K x.
% 4. Repeat for each Q,R case and compare Scope outputs.

Chapter28_Lesson4.nb

(* Chapter28_Lesson4.nb *)
(* Wolfram Mathematica notebook-style code. Save as .nb or paste cells into a notebook. *)

ClearAll["Global`*"];

a = 0.4;
b = 1.0;
x0 = 1.0;

cases = {
   <|"name" -> "balanced", "q" -> 1.0, "r" -> 1.0|>,
   <|"name" -> "larger_state_weight", "q" -> 25.0, "r" -> 1.0|>,
   <|"name" -> "larger_input_weight", "q" -> 1.0, "r" -> 25.0|>,
   <|"name" -> "small_input_weight", "q" -> 1.0, "r" -> 0.04|>
};

gain[a_, b_, q_, r_] := (a + Sqrt[a^2 + b^2 q/r])/b;
lambdaCL[a_, b_, q_, r_] := a - b gain[a, b, q, r];

table = cases /. c_Association :> {
    c["name"],
    c["q"],
    c["r"],
    gain[a, b, c["q"], c["r"]],
    lambdaCL[a, b, c["q"], c["r"]],
    -1/lambdaCL[a, b, c["q"], c["r"]],
    -gain[a, b, c["q"], c["r"]] x0
};

Grid[
  Prepend[table, {"case", "q", "r", "k", "lambda_cl", "settling indicator", "u(0)"}],
  Frame -> All
]

sols = Table[
   Module[{k = gain[a, b, c["q"], c["r"]], x},
    x = NDSolveValue[
      {x'[t] == (a - b k) x[t], x[0] == x0},
      x,
      {t, 0, 8}
    ];
    {c["name"], x}
   ],
   {c, cases}
];

Plot[
 Evaluate[sols[[All, 2]][t]],
 {t, 0, 8},
 PlotLegends -> sols[[All, 1]],
 AxesLabel -> {"time [s]", "x(t)"},
 PlotLabel -> "Qualitative effect of q/r on scalar closed-loop decay"
]

Problem 1 (Fixed feedback versus redesigned feedback): Let \( \mathbf{u}=-\mathbf{K}\mathbf{x} \) be fixed. Show that changing \( \mathbf{Q} \) and \( \mathbf{R} \) does not change the closed-loop poles.

Solution: The closed-loop state equation is \( \dot{\mathbf{x} }=(\mathbf{A}-\mathbf{B}\mathbf{K})\mathbf{x} \). Its poles are the eigenvalues of \( \mathbf{A}-\mathbf{B}\mathbf{K} \). If \( \mathbf{K} \) is unchanged, then \( \mathbf{A}-\mathbf{B}\mathbf{K} \) is unchanged, so its eigenvalues are unchanged. The weights only change the evaluated number \( J_{\mathbf{K} } \).

Problem 2 (Ellipsoid radius): Suppose \( \mathbf{Q}=\operatorname{diag}(q_1,q_2) \) with \( q_1,q_2 > 0 \). Find the intercepts of \( \mathbf{x}^{\top}\mathbf{Q}\mathbf{x}=c \) on the \( x_1 \) and \( x_2 \) axes.

Solution: The level set is \( q_1x_1^2+q_2x_2^2=c \). On the \( x_1 \) axis, \( x_2=0 \), so \( x_1=\pm\sqrt{c/q_1} \). On the \( x_2 \) axis, \( x_1=0 \), so \( x_2=\pm\sqrt{c/q_2} \). Increasing \( q_i \) reduces the allowed radius along that axis.

Problem 3 (Scalar closed-loop pole): For \( \dot{x}=ax+bu \), \( u=-kx \), and scalar quadratic weights \( q\ge 0 \), \( r > 0 \), use the stabilizing scalar formula to show how \( q/r \) changes the closed-loop pole.

Solution: The scalar stabilizing gain is

\[ k=\frac{a+\sqrt{a^2+b^2q/r} }{b}. \]

Therefore,

\[ \lambda_{cl}=a-bk=-\sqrt{a^2+b^2q/r}. \]

As \( q/r \) increases, \( |\lambda_{cl}| \) increases, and the scalar response decays faster. The price is larger feedback gain and larger input magnitude for the same initial condition.

Problem 4 (Coordinate scaling): Let \( \mathbf{z}=\mathbf{T}\mathbf{x} \). Derive the transformed state weight \( \mathbf{Q}_z \) that preserves the same physical penalty.

Solution: Since \( \mathbf{x}=\mathbf{T}^{-1}\mathbf{z} \),

\[ \mathbf{x}^{\top}\mathbf{Q}_x\mathbf{x} =(\mathbf{T}^{-1}\mathbf{z})^{\top} \mathbf{Q}_x(\mathbf{T}^{-1}\mathbf{z}) =\mathbf{z}^{\top}\mathbf{T}^{-\top}\mathbf{Q}_x \mathbf{T}^{-1}\mathbf{z}. \]

Hence \( \mathbf{Q}_z=\mathbf{T}^{-\top}\mathbf{Q}_x\mathbf{T}^{-1} \). This shows why weights must be adjusted when units or coordinates are changed.

Problem 5 (Monotonicity of evaluated cost for fixed feedback): Let \( \mathbf{K} \) be fixed and stabilizing. Suppose \( \mathbf{Q}_2-\mathbf{Q}_1 \) is positive semidefinite and \( \mathbf{R} \) is unchanged. Show that \( J_2(\mathbf{x}_0)\ge J_1(\mathbf{x}_0) \) for every initial state.

Solution: For the same closed-loop trajectory,

\[ J_2-J_1=\int_0^\infty \mathbf{x}(t)^{\top}(\mathbf{Q}_2-\mathbf{Q}_1)\mathbf{x}(t)\,dt. \]

Since \( \mathbf{Q}_2-\mathbf{Q}_1 \) is positive semidefinite, the integrand is nonnegative for all \( t \). Therefore \( J_2(\mathbf{x}_0)\ge J_1(\mathbf{x}_0) \).

Problem 6 (Input penalty and initial control): In the scalar formula, assume \( a=0.4 \), \( b=1 \), and \( q=1 \). Compare qualitatively \( r=0.04 \) and \( r=25 \).

Solution: For \( r=0.04 \), the ratio \( q/r=25 \) is large, so the gain is large and the pole is far left. The response is fast but the initial input \( u(0)=-kx(0) \) is large. For \( r=25 \), the ratio \( q/r=0.04 \) is small, so the gain is smaller and the pole is closer to the imaginary axis. The response is slower but actuator effort is lower.

Different weights encode different performance priorities. Larger state weights reduce tolerance for selected coordinates or directions. Larger input weights increase actuator economy and usually produce smoother but slower responses. The key technical distinction is that weights alone do not change the closed-loop behavior; behavior changes only when the feedback gain is redesigned. Scalar formulas, quadratic geometry, and Lyapunov cost identities provide a rigorous foundation for interpreting these trade-offs before studying full optimal state-feedback design.