⚡ electrical engineering

Stable Inversion of Discrete-Time Linear Periodically Time-Varying Systems via Cyclic Reformulation

This paper presents a systematic method for constructing stable, causal, and real-valued inverse systems for discrete-time linear periodically time-varying (LPTV) plants by transforming them into equivalent LTI representations via cyclic reformulation, thereby avoiding the need for complex Floquet factors or noncausal processing while generalizing the minimum phase condition to periodic systems.

Original authors: Hiroshi Okajima

Published 2026-03-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hiroshi Okajima

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to bake a perfect cake, but your oven has a strange, repeating glitch. Every time you turn the dial to "350 degrees," it actually heats to 360. Five minutes later, it drops to 340. Then it goes back to 350. This is a Periodically Time-Varying System: the rules of the game change in a predictable, repeating loop.

Now, imagine you want to reverse this process. You have the perfectly baked cake (the output), and you want to figure out exactly what settings to put on the oven (the input) to get that result. This is called System Inversion.

The problem? Most existing methods for doing this are like trying to solve a Rubik's cube while wearing blindfolded, using a calculator that only speaks a foreign language, or waiting until the end of the week to figure out what you should have done this morning. They are either too complex, require "magic" (complex math), or need to know the future to work.

This paper by Hiroshi Okajima proposes a clever new way to solve this puzzle. Here is the breakdown using simple analogies.

The Problem: The Shifting Puzzle

Think of the oven as a machine with a repeating cycle (let's say it changes its behavior every 3 seconds).

Second 1: It acts like Machine A.
Second 2: It acts like Machine B.
Second 3: It acts like Machine C.
Second 4: It goes back to Machine A.

If you try to reverse this, you can't just use one simple "undo" button because the button you need changes every second.

Old Method 1 (Floquet): This method tries to break the machine down into its "soul" using complex numbers (imaginary math). It works, but the result is a ghostly, non-causal solution that requires you to know the future to fix the past. It's like trying to un-bake a cake by looking at a crystal ball.
Old Method 2 (Lifting): This method grabs 3 seconds of data at once and treats it as one giant chunk. It works, but it's slow. You can't adjust the oven dial second-by-second; you have to wait for the whole 3-second block to finish before you can make a move.

The Solution: The "Cyclic Reformulation" Trick

The author's method is like taking a strip of film and taping the end to the beginning to make a loop.

Instead of fighting the changing rules, the author says: "Let's pretend the machine isn't changing at all. Let's just look at the whole loop as one big, static machine."

This is called Cyclic Reformulation.

Step 1: The Loop. Instead of watching the oven change every second, we imagine a giant machine that has 3 "rooms" inside it. Room 1 is Machine A, Room 2 is Machine B, Room 3 is Machine C. The machine moves a ball from Room 1 to 2 to 3 and back to 1. To an outside observer, this giant machine looks constant (it never changes its rules).
Step 2: The Inversion. Now that we have a "constant" machine, we can use standard, easy math to find the "undo" button. Since the machine is now static, the math is simple and familiar.
Step 3: The Translation. Once we have the "undo" button for the giant loop, we peel it apart. We look at the "Room 1" part of the undo button, the "Room 2" part, and the "Room 3" part. We then reassemble them into a new, real-time controller that changes its settings every second, exactly matching the original oven's glitch.

Why is this better?

No Magic: It doesn't need complex numbers or "imaginary" math. Everything stays in the real world.
Real-Time: Unlike the "Lifting" method, this doesn't make you wait for a block of time. It gives you a rule for every single second. You can adjust the dial instantly.
Causal: You don't need to see the future. You just need the current output to figure out the current input.

The "Stability" Check

There is one catch. Just like a car with bad brakes, some ovens are impossible to reverse safely. If the oven's internal "glitch" is too wild (mathematically, if it has "unstable zeros"), trying to reverse it will cause the cake to explode (the math will blow up).

The paper provides a simple test: Is the "Loop" machine stable?

If the loop is stable, the reverse button works perfectly.
If the loop is unstable, the reverse button will make things worse.

The authors prove that if the "Loop" machine is stable, their new method will create a perfect, real-time reverse controller that can reconstruct the original input signal exactly, even if you start with the wrong settings.

The Two Scenarios

The paper handles two types of ovens:

Instant Ovens (Relative Degree 0): The oven reacts immediately. If you turn the dial, the heat changes instantly. The math here is a direct, simple formula.
Delayed Ovens (Relative Degree > 0): The oven takes a few seconds to react. If you turn the dial, nothing happens for a moment, then the heat changes. The math here is slightly more complex (it requires looking a few steps ahead), but the same "Loop" trick works perfectly.

The Bottom Line

This paper gives engineers a universal toolkit to reverse-engineer systems that change their rules in a repeating pattern. It turns a messy, time-varying nightmare into a clean, static puzzle, solves it with standard tools, and then translates the answer back into a real-time, step-by-step guide.

It's like taking a song that changes key every bar, writing it down as a single, static chord progression, figuring out the harmony, and then rewriting the song so you can play it perfectly in real-time without needing a crystal ball.

1. Problem Statement

The paper addresses the challenge of constructing stable inverse systems for Discrete-Time Linear Periodically Time-Varying (LPTV) systems.

Context: Inverse systems are critical for feedforward control, output tracking, and Iterative Learning Control (ILC), particularly in multirate and periodic systems (e.g., high-precision positioning, non-equidistant sampling).
Limitations of Existing Methods:
- Floquet-based approaches: Require complex-valued arithmetic, noncausal processing (preview), and do not yield closed-form state-space realizations suitable for direct causal implementation.
- Lifting-based approaches: Transform the system into an equivalent LTI system operating on an $N$ -step block time scale. While effective, they produce finite-time input sequences rather than step-by-step periodic state-space realizations in the original time domain.
- Signal Processing methods: Often lack a state-space control framework and typically assume a non-zero direct feedthrough term (relative degree zero).
Goal: Develop a systematic method to construct causal, real-valued, closed-form state-space inverse systems for LPTV plants that operate at the original sampling rate, avoiding complex arithmetic and noncausal processing (for minimum phase systems).

2. Methodology: Cyclic Reformulation Framework

The proposed approach relies on Cyclic Reformulation, a technique that transforms an $N$ -periodic LPTV system into an equivalent Linear Time-Invariant (LTI) system while preserving the step-by-step input-output relationship (unlike lifting, which operates on block time).

The inversion procedure consists of three systematic steps:

Step 1: Cyclic Reformulation

The original LPTV system $(A_k, B_k, C_k, D_k)$ with period $N$ is transformed into an equivalent LTI system $(\check{A}, \check{B}, \check{C}, \check{D})$ .

State/Signal Expansion: The state, input, and output vectors are expanded to dimension $Nn$, $Nm$, and $Np$ respectively.
Structure: The resulting matrices exhibit a 1-shift block-circulant structure. Specifically, $\check{A}$ and $\check{B}$ are block-circulant matrices where the blocks shift cyclically, while $\check{C}$ and $\check{D}$ are block-diagonal.
Key Property: The eigenvalues of the monodromy matrix of the original system relate to the eigenvalues of $\check{A}$ such that $\rho(\check{A}) = \rho(\Phi)^{1/N}$ .

Step 2: LTI Inverse Construction

Standard LTI inversion theory is applied to the cycled system $\check{P}$ .

Relative Degree Zero ( $D_k$ nonsingular): The inverse $\check{P}^{-1}$ is constructed using the standard formula involving $\check{D}^{-1}$ .
Higher Relative Degree ( $D_k = 0$ ): The inverse is constructed using periodic Markov parameters. The paper introduces a cycled shift matrix ( $\check{S}_p$ ) to handle the time delay inherent in higher relative degree systems.
Stability Condition: The stability of the LTI inverse $\check{P}^{-1}$ is determined by the transmission zeros of $\check{P}$ . If $\check{P}$ is minimum phase (all transmission zeros inside the unit disk), the inverse is stable.

Step 3: Parameter Extraction

The periodic matrices of the original inverse system are recovered from the block structure of the cycled inverse $\check{P}^{-1}$ .

Structure Preservation: The paper proves that the inverse of the cycled system retains the specific block-circulant structure required to map back to the original time domain.
Shift Absorption: For relative degree $r \geq 1$ , a shift operation is applied to the input/output signals to align time phases, ensuring the extracted matrices correspond to the correct time steps $k \pmod N$ .
Result: Explicit, closed-form expressions for the periodic inverse matrices $(\Gamma_k, \Lambda_k, \Omega_k, \Pi_k)$ are derived.

3. Key Contributions

Unified Inversion Framework: Proposes a method that reduces the LPTV inversion problem exactly to an LTI inversion problem via cyclic reformulation, avoiding complex-valued Floquet factors and noncausal processing.
Explicit Closed-Form Solutions:
- Relative Degree Zero: Derives explicit formulas (Theorem 1) for the inverse system matrices when the direct feedthrough term $D_k$ is nonsingular.
- Higher Relative Degree: Derives explicit formulas (Theorem 3) for $r$ -step-delayed inverses using periodic Markov parameters when $D_k=0$ .
Stability Characterization: Establishes that the stability of the constructed inverse system is equivalent to the minimum phase condition of the cycled LTI plant. Specifically, the inverse is stable if and only if the transmission zeros of the cycled system lie strictly inside the unit disk (Theorem 2).
Causal Realization: Unlike Floquet methods, the resulting inverse is a finite-dimensional, causal (or $r$ -step delayed), real-valued state-space system operating at the original sampling rate.

4. Results and Validation

The paper validates the theory through numerical examples:

Scalar LPTV System (Relative Degree 0): Demonstrated exact input reconstruction with rapid convergence of error due to a small spectral radius of the inverse monodromy matrix ( $\rho \approx 0.0067$ ).
Non-Scalar LPTV System (Relative Degree 0): Compared against Floquet-based methods. The proposed method yielded real-valued, causal matrices, whereas the Floquet approach required complex arithmetic and noncausal operators.
Higher Relative Degree ( $r=1$ ): Successfully constructed a 1-step-delayed inverse using periodic Markov parameters. The simulation showed exact reconstruction of the input signal when initial conditions were matched, and geometric decay of error when mismatched.

5. Significance and Impact

Practical Implementation: The method provides a direct path to implementing stable inverses in real-time control applications (e.g., feedforward control, ILC) without the computational overhead of complex arithmetic or the latency of block-based lifting.
Theoretical Unification: It bridges the gap between LTI inversion theory and periodic systems, showing that cyclic reformulation preserves the algebraic structures necessary for inversion.
Limitations and Future Work: The current framework is restricted to periodically minimum phase systems. For non-minimum phase systems, the causal inverse is unstable. The author suggests future work on extending the method to non-minimum phase cases via noncausal inversion of the cycled plant and handling systems with non-uniform relative degrees (e.g., in multirate systems where $D_k$ is singular at some phases).

In summary, this paper offers a rigorous, constructive, and computationally efficient framework for stable inversion of LPTV systems, significantly advancing the capabilities for controlling multirate and periodic dynamical systems.