How do I find robustness in MIMO transfer function? Iterative Learning Control First of all, I going to give you a quick explanation how Iterative Learning Control(ILC) is. But first a quick history.
Iterative Learning Control is a very modern control technique who is most used for system who repeat its dynamical system. For example: Robotics.
ILC was invented at the 70's in Japan, but it took about 30 years for the idea to be used in the industry. Yes, ILC is an industry controller, not only for experiment.
The idea behind ILC is to remember the "past disturbances" in form of past tracking error and past input signal. Example: If you are holding a pencil and writing a round circle on a paper, when you have write the half circle, somebody push you and your circle didn't become 100% round. Then to try again to write the round circle and you remember that when you are at the half circle position, you are going to be peppered for that push again, so you can finish your circle and have it 100% round as you planned to have it in the beginning.
That how ILC works. In other words - ILC is feed forwarding the past disturbances into the system to handle the coming disturbance.
So let's assume that we have a feedback system:
$$ G_f(s) = \frac{u_{k+1}G(s)}{1+u_{k+1}G(s)}$$
Where $u_{k+1}$ is our controller output signal. In this case, I'm using transfer functions. But you can use state space models if you want. ILC is a SISO-contoller, but you can have multiple ILC controller for a MIMO system.
Anyway!
Our $u_{k+1}$ is:
$$u_{k+1} = Q(s)(u_k(t) + L(s)e_k(t)) + C(s)e_{k+1}(t)$$
So what does this mean? Well: $Q(s)$ is a low pass filter, for example butterworth. $u_k(s)$ is our past input signal and $e_k(t)$ is also our past tracking error. That means that we need to record our current input signal $u_{k+1}$ and current tracking error $e_{k+1}(t)$ for the system.
$k$ is our iteration state. We begin always with $k = 0$. 
The transfer function $L(s)$ is called our learning algorithm. I don't know why. 
$$L(s) = \delta s^\kappa$$
Where 
$$0 < \delta \leq 1$$
So how should you interpret
$$L(s) = \delta s^\kappa$$
??
The factor $\delta$ is a scale factor only for learning gain. The factor $\kappa$ is telling the system that "OK! Now we are going to use acceleration if $\kappa = 2$". In other words $\kappa$ is a time shift gain.
$L(s)$ works as an amplifier for the past error $e_{k}(t)$
So assume that we have $\kappa = 1$ and $\delta = 1$. Then we would have $L(s) = s$ as a transfer function for derivative for frequencies. And in this case, frequencies is our disturbances. You can see the difference for $L(s)$ if we are using $\kappa =1, 2$


And the last thing! $Cs(s)$ is our real controller. In this case, $C(s)$ can be a P, PI, PD, PID controller. Example:
$$C(s) = K_P + K_I\frac{1}{s} + K_Ds$$
So from this:
$$u_{k+1} = Q(s)(u_k(t) + L(s)e_k(t)) + C(s)e_{k+1}(t)$$
The feedback controller is:
$$C(s)e_{k+1}(t)$$
And the feed forward compensator for disturbance is:
$$Q(s)(u_k(t) + L(s)e_k(t))$$
Where the current error $e_k(t)$ is
$$e_k(t) = r(t) - y(t)$$
You may wonder: Why use $Q(s)$? Its for cutting of high frequency signals back to the controller. In some cases, you can set $Q(s) = 1$.
If this was not clear how ILC works. Have a look at this picture. This picture explains that for every iteration, the controller can stand against disturbance more and more.

Or look at this video: https://www.youtube.com/watch?v=sWilGsWQ1jo
Now for the question:
How do I find robustness in this loop transfer function?
$$0 = 1 + \begin{bmatrix}
Q(s)G(s) & Q(s)L(s)G(s)  & C(s)G(s) 
\end{bmatrix} \begin{bmatrix}
u_k(t)\\ 
e_k(t)\\ 
e_{k+1}(t)
\end{bmatrix}$$
It's from this feedback model:
$$ G_f(s) = \frac{u_{k+1}G(s)}{1+u_{k+1}G(s)}$$
Where if $u_{k+1}G(s)$ goes to $-1$, them our controller is not robust and not stable at all.
 A: The feed forward, updated by ILC, will give most of your reference tracking performance over time. Therefore $C(s)$ could be designed such that your closed loop system is stabilized and has good disturbance attenuation. For a common class of systems this would often imply a low bandwidth due to the waterbed effect. So designing $C(s)$ can be seen as a separate problem from ILC. So any robust control method can be used when designing $C(s)$.

I find that this block diagram helps illustrate what ILC is doing:

If we first assume that $Q(s)=1$ then in order for the ILC signal $f_{k+1}$ to compensate for the residual error $e_j$ the next period $L(s)$ should be chosen such that it completely compensates for it. It can be shown that the transfer function from $f_k$ to $e_j$ is minus the process sensitivity
$$
\frac{\mathcal{L}\{e_j\}(s)}{\mathcal{L}\{f_k\}(s)} = \frac{-G(s)}{1 + G(s)\,C(s)} = -G(s)\,S(s) \tag{1}
$$
with $S(s)=(1+G(s)\,C(s))^{-1}$, the sensitivity transfer function.
Assuming that the same error would be obtained, so $e_{j+1}=e_j$ if $f_{k+1}=f_k$. Therefore by adding $L(s)\,e_j$ to $f_k$ to get $f_{k+1}$, then the new error can be expressed as
$$
\begin{align}
e_{j+1} &= e_j - G(s)\,S(s)\,(f_{k+1} - f_k) \\
&= e_j - G(s)\,S(s)\,L(s)\,e_j \\
&= (1 - G(s)\,S(s)\,L(s)) e_j
\end{align} \tag{2}
$$
The right hand side would be equal to zero if
$$
L(s) = \frac{1}{G(s)\,S(s)} = \frac{1 + G(s)\,C(s)}{G(s)}. \tag{3}
$$

The updated feed forward signal can be written as
$$
f_{k+1} = Q(s) (1 - L(s)\,G(s)\,S(s)) f_k. \tag{4}
$$
However often we do not know the process sensitivity exactly, namely it is often measured as a frequency response function or a fitted model onto a time domain input output data. So transfer function used to define $L(s)$ will always have some uncertainty in practice. Another option might be that the process sensitivity is non minimum phase (has a "unstable" zero), then $L(s)$, which is defined as its inverse, is unstable. So in that case $L(s)$ can only be an approximation of the inverse of the process sensitivity.
So $L(s)$ is always not exactly equal to the inverse of $G(s)\,S(s)$. So in order for the feed forward signal to remain bounded equation $(4)$ should be stable, which can be formulated as
$$
\left|Q(j\,\omega) (1 - L(j\,\omega)\,G(j\,\omega)\,S(j\,\omega))\right|  < 1\quad \forall \omega \tag{5}
$$
So $Q(s)$, or mainly its absolute value, can be used to guarantee this by letting its magnitude go below zero dB when $|1 - L(j\,\omega)\,G(j\,\omega)\,S(j\,\omega)|>1$. This does often indeed comes down do a low pass filter of a certain order, such as a Butterworth filter. To make sure $Q(s)$ won't induce (damped) oscillations, you can also use a zero phase filter. This basically filters the signal twice; once forwards in time and another time backwards in time. This does make it noncausal, but the entire time series is known so if the next iteration does not start immediately after the previous one, then it can be computed.

You can also make ILC more robust to disturbances by changing the "learning rate" by multiplying $L(s)$ by a scalar $\alpha$. It can be shown using equation $(5)$ that the ILC will remain stable when choosing $0<\alpha<2$ if $|Q(s)|\leq1$ (values for $\alpha$ bigger then one are not really useful).
Namely the contributions to the error of each iteration will be a combination of incomplete feed forward and disturbances. But with normal ILC with $\alpha=1$ it is only assumed that the error is only due to incomplete feed forward. So the next iteration it will also try to compensate for previous disturbances, but those will be different each iteration. So the next iteration ILC will try to compensate for both the last disturbances and the wrong feed forward due to disturbances compensation of the previous iteration, ect. Now by setting $\alpha$ to a smaller value then ILC will not completely try to compensate for the disturbances, but over iterations will still converge to the correct feed forward signal. The accumulation of the disturbance terms over the iterations should roughly average out to zero. The effect of different $\alpha$ can be seen in the figure below:

It can be noted that this figure is from a lecture slide from a course I took, so I do not know what model was used to generate this.
You can also let $\alpha$ change between iterations, namely by starting at one to initially, which will give a faster converges to the correct feed forward signal, and change it to a lower value once the disturbance contribution starts to dominate.
