狀態空間：現代控制、可控性與可觀性

   The state-space model — every linear system, one shape:

      ẋ = A x + B u        <- how the state evolves (the dynamics)
      y = C x + D u        <- what the sensors measure (the readout)

   x : state vector   (n×1)   the system's memory
   u : input vector   (m×1)   the knobs you can turn (actuators)
   y : output vector  (p×1)   the dials you can read (sensors)

   A : n×n   system matrix     internal coupling — the heart of it
   B : n×m   input matrix      where inputs push the state
   C : p×n   output matrix     which states the sensors see
   D : p×m   feed-through      usually 0

        u ──►[ B ]──►(+)──► ẋ ──[ ∫ ]──┬──► x ──►[ C ]──►(+)──► y
                      ▲                 │                  ▲
                      └──────[ A ]◄─────┘          [ D ]◄──┘
                         the feedback OF NATURE

   Why eigenvalues = poles  (the one derivation worth doing)

   Take ẋ = A x  and look for a natural mode  x(t) = v · e^{λt}
   (v is a fixed direction, the whole vector just scales by e^{λt})

      ẋ = λ v e^{λt}        and        A x = A v e^{λt}

   Set them equal and cancel e^{λt}:

            λ v = A v        <-  the EIGENVALUE equation

   So each natural mode of the system IS an eigenvector v of A,
   and it decays/grows like e^{λt} where λ is its eigenvalue.

   The transfer function makes the same numbers explicit:

        G(s) = C (sI − A)^{-1} B + D
                       └────┬────┘
        poles = where  det(sI − A) = 0   =   eigenvalues of A

   STABLE  ⇔  every eigenvalue of A has  Re(λ) < 0
             (every pole in the left half-plane)

   The two tests — both are rank checks on a stacked matrix:

   CONTROLLABILITY (n states, can inputs reach everywhere?)

        ┌                                  ┐
   𝒞 =  │  B   AB   A²B  ...  A^{n-1}B      │      controllable
        └                                  ┘   ⇔  rank(𝒞) = n

   OBSERVABILITY (can outputs reveal every state?)

        ┌      C      ┐
        │     CA      │
   𝒪 =  │    CA²      │                       observable
        │     ⋮       │                    ⇔  rank(𝒪) = n
        │  CA^{n-1}   │
        └             ┘

   FULL RANK  =  green light.   RANK DEFICIENT  =  a mode you
   can't touch (uncontrollable) or can't see (unobservable).

   Beautiful duality:  (A, B) controllable  ⇔  (Aᵀ, Bᵀ) observable.
   Every steering theorem has a free seeing-theorem twin.

   STATE FEEDBACK  →  re-write the system's eigenvalues

   Plant:        ẋ = A x + B u
   Control law:  u = −K x            (feed back ALL states, gain row K)

   Close the loop (substitute u):

        ẋ = A x + B(−K x) = (A − BK) x
                              └───┬───┘
                         NEW system matrix

   Its eigenvalues = the CLOSED-LOOP poles, and they are now
   yours to set:  pick desired poles → solve for K.

   ┌──────────────────────────────────────────────────────────┐
   │  POLE-PLACEMENT THEOREM                                   │
   │  If (A, B) is CONTROLLABLE, a gain K exists that places   │
   │  the eigenvalues of (A − BK) at ANY locations you choose. │
   └──────────────────────────────────────────────────────────┘

   In code:   K = place(A, B, desired_poles)     # MATLAB / python-control

   THE OBSERVER  (a.k.a. estimator) — a model that watches itself

   Run a copy of the plant in software, state estimate x̂:

        x̂̇ = A x̂ + B u  +  L (y − C x̂)
             └─ predict ─┘   └──── correct ────┘
                            measured − expected output

   Estimation error  e = x − x̂  obeys:

        ė = (A − L C) e

   Choose the observer gain L so the eigenvalues of (A − LC)
   are FAST and stable  →  x̂ rushes toward the true x,
   no matter the starting guess.   (place() again — by duality!)

   ┌──────────────────────────────────────────────────────────┐
   │  SEPARATION PRINCIPLE                                     │
   │  Design K (control) and L (estimation) INDEPENDENTLY.    │
   │  Feed x̂ into the controller:  u = −K x̂.  The combined    │
   │  closed-loop poles = eig(A−BK) ∪ eig(A−LC). They don't   │
   │  interfere. Pick observer poles ~5–10× faster than       │
   │  the control poles, and you're done.                     │
   └──────────────────────────────────────────────────────────┘

   CLASSICAL (rung 7)              STATE SPACE (rung 8)
   ─────────────────────          ─────────────────────────
   G(s) transfer function   ↔     ẋ = Ax + Bu,  y = Cx + Du
   poles (denom. roots)     ≡     eigenvalues of A
   one input / one output         many inputs / many outputs
   Bode, Nyquist, margins         eig(), place(), rank tests
   loop-shaping by hand           pole placement + observer
   data-driven, robust            model-driven, scalable

   Same plant, two coordinate systems on the same truth.

   NEXT HORIZON ─────────────────────────────────────────►
   Pole placement asks "WHERE should the poles go?" — you
   still guess. OPTIMAL CONTROL (LQR) asks instead:

      minimise   J = ∫ ( xᵀQx + uᵀRu ) dt
                       └─error─┘ └─effort─┘

   Q penalises being off-target, R penalises control effort.
   Solve once (the Riccati equation) → the BEST K falls out,
   no pole-guessing. Pair it with a Kalman filter and you get
   LQG — the workhorse of aerospace & robotics control.