Comprehensive Introduction to Fully Homomorphic Encryption for Dynamic Feedback Controller via LWE-based Cryptosystem

TL;DR

This paper introduces the LWE-based fully homomorphic encryption cryptosystem, explaining its principles, security features, and application to secure dynamic feedback control systems, with practical MATLAB examples.

Contribution

It provides a comprehensive, accessible overview of LWE-based FHE cryptosystems and demonstrates their application in stabilizing secure feedback control systems.

Findings

LWE cryptosystem supports fully homomorphic operations without decryption.

Error growth limits recursive homomorphic operations, but stability can be maintained in control systems.

MATLAB examples illustrate practical implementation for control engineers.

Abstract

The cryptosystem based on the Learning-with-Errors (LWE) problem is considered as a post-quantum cryptosystem, because it is not based on the factoring problem with large primes which is easily solved by a quantum computer. Moreover, the LWE-based cryptosystem allows fully homomorphic arithmetics so that two encrypted variables can be added and multiplied without decrypting them. This chapter provides a comprehensive introduction to the LWE-based cryptosystem with examples. A key to the security of the LWE-based cryptosystem is the injection of random errors in the ciphertexts, which however hinders unlimited recursive operation of homomorphic arithmetics on ciphertexts due to the growth of the error. We show that this limitation can be overcome when the cryptosystem is used for a dynamic feedback controller that guarantees stability of the closed-loop system. Finally, we illustrate through MATLAB codes how the LWE-based cryptosystem can be customized to build a secure feedback control system. This chapter is written for the control engineers who do not have background on cryptosystems.

Equations

$$[p]:=\left\{i\in \mathbb{Z}:-\frac{p}{2}\le i<\frac{p}{2}\right\}$$

$$\mathsf{b}\leftarrow (-\mathsf{A}\cdot \mathsf{sk}+Lm+\mathsf{e})\mathrm{mod}q$$

$$\lceil \frac{(\mathbf{m}\cdot \mathsf{s})\mathrm{mod}q}{L}\rfloor =\lceil \frac{Lm+\mathsf{e}}{L}\rfloor \to m$$

$$32{\mathsf{s}}_1+17{\mathsf{s}}_2-5{\mathsf{s}}_3+8{\mathsf{s}}_4+{\mathsf{e}}_1$$

$$-6{\mathsf{s}}_1+17{\mathsf{s}}_2+1{\mathsf{s}}_3+18{\mathsf{s}}_4+{\mathsf{e}}_2$$

$$44{\mathsf{s}}_1+32{\mathsf{s}}_2+12{\mathsf{s}}_3+28{\mathsf{s}}_4+{\mathsf{e}}_3$$

$$⋮$$

$$(\text{Computation complexity of A})\times \left(\frac{1}{\left|0.5-\text{Success probability of A}\right|}\right)>2^{\lambda }.$$

$$\frac{N}{\log q-\log r}\propto \frac{\lambda }{\log \lambda }.$$

$$\mathsf{Dec}\big{(}\mathsf{Enc}(m_{1})\;\ast_{\mathcal{C}}\;\mathsf{Enc}(m_{2})\big{)}=m_{1}\;\ast_{\mathcal{P}}\;m_{2}$$

$$\begin{array}{rl}\mathsf{Enc}(m_1)& {+}_{\mathcal{C}}\mathsf{Enc}(m_2)={\mathbf{m}}_1+{\mathbf{m}}_2\\ & =\left[-{\mathsf{A}}_1\cdot \mathsf{sk}+L{m}_1+{\mathsf{e}}_1,{\mathsf{A}}_1\right]+\left[-{\mathsf{A}}_2\cdot \mathsf{sk}+L{m}_2+{\mathsf{e}}_2,{\mathsf{A}}_2\right]\\ & =\left[-({\mathsf{A}}_1+{\mathsf{A}}_2)\cdot \mathsf{sk}+L(m_1+m_2)+({\mathsf{e}}_1+{\mathsf{e}}_2),{\mathsf{A}}_1+{\mathsf{A}}_2\right]\end{array}$$

$$\mathsf{Dec}({\mathbf{m}}_1+{\mathbf{m}}_2)=\lceil \frac{({\mathbf{m}}_1+{\mathbf{m}}_2)\cdot \mathsf{s}\mathrm{mod}q}{L}\rfloor =\lceil \frac{L(m_1+m_2)+{\mathsf{e}}_1+{\mathsf{e}}_2}{L}\rfloor =m_1+m_2$$

$${\mathbf{M}}_2=Enc2(m_2)=m_{2}R+\mathsf{Enc}(0_{\log q\cdot (N+1)\times 1})\in {\mathbb{Z}}_q^{\log q\cdot (N+1)\times (N+1)}$$

$$R:=[10^0,10^1,10^2,\cdots ,10^{\log q-1}{]}^T\otimes I_{N+1}$$

$$D(c):=\left[\begin{array}{cccc}{c}_0,& c_1,& \cdots ,& c_{\log q-1}\end{array}\right].$$

$$D\left([40,35,-27]\right)=D\left([40,35,73]\right)=[0,5,3,4,3,7]$$

$${\mathbf{M}}_2{\times }_{\mathcal{C}}{\mathbf{m}}_1:=D({\mathbf{m}}_1)\cdot {\mathbf{M}}_2\in {\mathbb{Z}}_q^{1\times (N+1)}$$

$$\displaystyle\begin{split}({\bf M_{2}\times_{\mathcal{C}}{\bf m_{1}}})\cdot{\sf s}=D({\bf m_{1}})\cdot{\bf M_{2}}\cdot{\sf s}&=D({\bf m_{1}})\cdot\big{(}m_{2}R+{\bf O}\big{)}\cdot{\sf s}\\ &=m_{2}{\bf m_{1}}\cdot{\sf s}+D({\bf m_{1}})\cdot{\sf e}_{\bf M_{2}}\end{split}$$

$$\begin{array}{rl}\mathsf{Dec}({\mathbf{M}}_2{\times }_{\mathcal{C}}{\mathbf{m}}_1)& =\lceil \frac{D({\mathbf{m}}_1)\cdot {\mathbf{M}}_2\cdot \mathsf{s}\mathrm{mod}q}{L}\rfloor \\ & =\lceil \frac{m_2(L{m}_1+{\mathsf{e}}_1)+D({\mathbf{m}}_1)\cdot {\mathsf{e}}_{{\mathbf{M}}_2}}{L}\rfloor =m_2{m}_1,\end{array}$$

$$\left|\frac{m_2{\mathsf{e}}_1}{L}+\frac{D({\mathbf{m}}_1)\cdot {\mathsf{e}}_{{\mathbf{M}}_2}}{L}\right|<\frac{1}{2}.$$

$$\mathbf{F}{\times }_{\mathcal{C}}\mathbf{x}:=\sum _{j=1}^n\left[\begin{array}{c}D({\mathbf{x}}_j)\cdot {\mathbf{F}}_{1,j}\\ D({\mathbf{x}}_j)\cdot {\mathbf{F}}_{2,j}\\ ⋮\\ D({\mathbf{x}}_j)\cdot {\mathbf{F}}_{n,j}\end{array}\right]$$

$$\begin{array}{rl}(\mathbf{F}{\times }_{\mathcal{C}}\mathbf{x})\cdot \mathsf{s}& =\sum _{j=1}^n\left[\begin{array}{c}D({\mathbf{x}}_j)\cdot {\mathbf{F}}_{1,j}\cdot \mathsf{s}\\ D({\mathbf{x}}_j)\cdot {\mathbf{F}}_{2,j}\cdot \mathsf{s}\\ ⋮\\ D({\mathbf{x}}_j)\cdot {\mathbf{F}}_{n,j}\cdot \mathsf{s}\end{array}\right]=\sum _{j=1}^n\left[\begin{array}{c}{F}_{1,j}\cdot {\mathbf{x}}_j\cdot \mathsf{s}+D({\mathbf{x}}_j)\cdot {\mathsf{e}}_{{\mathbf{F}}_{1,j}}\\ F_{2,j}\cdot {\mathbf{x}}_j\cdot \mathsf{s}+D({\mathbf{x}}_j)\cdot {\mathsf{e}}_{{\mathbf{F}}_{2,j}}\\ ⋮\\ F_{n,j}\cdot {\mathbf{x}}_j\cdot \mathsf{s}+D({\mathbf{x}}_j)\cdot {\mathsf{e}}_{{\mathbf{F}}_{n,j}}\end{array}\right]\\ & =F\cdot \mathbf{x}\cdot \mathsf{s}+\sum _{j=1}^n\left[\begin{array}{c}D({\mathbf{x}}_j)\cdot {\mathsf{e}}_{{\mathbf{F}}_{1,j}}\\ D({\mathbf{x}}_j)\cdot {\mathsf{e}}_{{\mathbf{F}}_{2,j}}\\ ⋮\\ D({\mathbf{x}}_j)\cdot {\mathsf{e}}_{{\mathbf{F}}_{n,j}}\end{array}\right]=:F\cdot \mathbf{x}\cdot \mathsf{s}+\Delta (\mathbf{F},\mathbf{x})\end{array}$$

$$\begin{array}{rl}\mathsf{Dec}(\mathbf{F}{\times }_{\mathcal{C}}\mathbf{x})& =\lceil \frac{1}{L}\left(F\cdot \mathbf{x}\cdot \mathsf{s}+\Delta (\mathbf{F},\mathbf{x})\mathrm{mod}q\right)\rfloor \\ & =Fx+\lceil \frac{1}{L}\left(F\cdot {\mathsf{e}}_{\mathbf{x}}+\Delta (\mathbf{F},\mathbf{x})\right)\rfloor =Fx\end{array}$$

$$\mathbf{F}{\times }_{\mathcal{C}}\mathbf{x}+\mathbf{G}{\times }_{\mathcal{C}}\mathbf{y}$$

$$x_{\mathsf{p}}[t+1]=A{x}_{\mathsf{p}}[t]+Bu[t],y[t]=C{x}_{\mathsf{p}}[t].$$

$$x[t+1]$$

$$u[t]$$

$$y[t]⟶\bar{y}[t]:=\lceil \frac{y[t]}{R_y}\rfloor .$$

$$\frac{x[t+1]}{S_G{R}_y}=F\frac{x[t]}{S_G{R}_y}+\frac{G}{S_G}\frac{y[t]}{R_y}\stackrel{\text{truncation}}{\to }\bar{x}[t+1]=F\bar{x}[t]+\bar{G}\bar{y}[t]$$

$$\frac{u[t]}{S_{HJ}{S}_G{R}_y}=\frac{H}{S_{HJ}}\frac{x[t]}{S_G{R}_y}+\frac{J}{S_{HJ}{S}_G}\frac{y[t]}{R_y}\stackrel{\text{truncation}}{\to }\bar{u}[t]=\bar{H}\bar{x}[t]+\bar{J}\bar{y}[t],$$

$$\bar{x}[t+1]$$

$$\bar{u}[t]$$

$$\bar{u}[t]⟶u[t]=R_u\lceil \frac{R_y{S}_G{S}_{HJ}}{R_u}\bar{u}[t]\rfloor$$

Full text

1 Introduction

Applications of homomorphic cryptography to the feedback controller are relatively new. To the authors’ knowledge, the first contribution was made by Kogiso and Fujita 2015-cdc-kosigo in 2015, followed by Farokhi et al. 2016-necsys-farokhi and Kim et al. 2016-necsys-kim both in 2016. Interestingly, each of them uses different homomorphic encryption schemes; El-Gamal Ell85 , Paillier Pai99 , and LWE Gen09 are employed, respectively. \colororangeBecause other two schemes are introduced in other chapters in this book, this chapter is written for introducing the LWE-based cryptosystem and its customization for building a dynamic feedback controller.

Homomorphic encryption implies a cryptographic scheme in which arithmetic operations can be performed directly on the encrypted data (i.e., ciphertexts) without decrypting them. When applied to the control systems, security increases because there is no need to keep the secret key inside the controller (see Fig. 1), which is supposed to be a vulnerable point in the feedback loop. After the idea of homomorphic encryption appeared in 1978 by Rivest el al. rivest1978data , two semi-homomorphic encryption schemes were developed. One is the multiplicatively homomorphic scheme by El-Gamal Ell85 developed in 1985, and the other is the additively homomorphic scheme by Paillier Pai99 developed in 1999. Homomorphic encryption schemes that allow both addition and multiplication appeared around 2000, and they are called somewhat-homomorphic because, even if both arithmetics are enabled, the arithmetic operations can be performed only finite times on an encrypted variable. In 2009, Gentry Gen09 developed an algorithm called ‘bootstrapping’ which finally overcame the restriction of finite number of operations. By performing the bootstrapping regularly on the encrypted variable, the variable becomes like a newborn ciphertext and so it allows more operations on it. The encryption scheme with this algorithm is called fully homomorphic. However, fully homomorphic encryption sometimes simply implies a scheme that allows both addition and multiplication, and we follow this convention.

In this chapter, we introduce the LWE-based fully homomorphic encryption scheme. We illustrate that, if the scheme is used with a stable closed-loop system then, interestingly, there is no need to employ the bootstrapping for infinite number of arithmetic operations as long as the system matrix of the controller consists of integer numbers, and the actuator and the sensor sacrifice their resolutions a little bit.111If one needs to use the bootstrapping because his/her application does not satisfies these conditions, then he/she may refer to 2016-necsys-kim in which a method to orchestrate the bootstrapping and the dynamic feedback controller has been presented. Moreover, by utilizing the fully homomorphic arithmetics, we are able to encrypt all the parameters in the controller, as seen in Fig. 1.

This chapter consists of three parts. In the first part (Section 2), we present an introduction to the LWE-based encryption, discuss the homomorphic arithmetics, and illustrate the error growth in the ciphertexts. The second part (Section 3) is about customization of the LWE-based cryptosystem for the linear time-invariant dynamic feedback controllers. In the last part (Section 4), we show the error growth can be handled by the stability, so that the dynamic controller operates seamlessly with unlimited times fully homomorphic arithmetics. In Section 5, we conclude the chapter with a discussion on the need for integer system matrix of the controller, which is related to one of future research issues. For pedagogical purposes, we simplify many issues that should be considered in practice, and instead, focus on the key ingredients of homomorphic encryptions. In the same respect, the codes presented in this chapter consist of simple MATLAB commands that may not be used in real applications even if it works for simple examples.

2 Cryptosystem based on Learning-with-Errors Problem

We first present how to encrypt and decrypt a message, in order for the reader to look and feel the ciphertexts in the LWE-based cryptosystem. Then, we briefly introduce the learning-with-errors (LWE) problem because the security of the presented cryptosystem is based on the hardness of this problem. We also explain how the homomorphic arithmetics are performed in the LWE-based cryptosystem.

Now, with $p\in{\mathbb{N}}$, let the set of integers bounded by $p/2$ be denoted by

[TABLE]

so that the cardinality of $[p]$ is $p$. In addition, we need the following set.

{tips}

Set of integers modulo $q$ Let ${\mathbb{Z}}_{q}$ be the set of integers modulo222In this chapter, all the modulus are chosen as powers of 10 for convenience of understanding while they are often powers of 2 in practice. $q\in{\mathbb{N}}$. This means that any two integers $a$ and $b$ are regarded as the same elements of ${\mathbb{Z}}_{q}$ if $(a-b)\text{ mod }q=0$.333$x\text{ mod }q$ is the remainder after division of $x$ by $q$. In this chapter, we suppose the remainder is an element of $[q]$; for example, if the remainder is greater than or equal to $q/2$, make it negative by subtracting $q$, e.g., $17\text{ mod }10=-3\in[10]$. By this rule, all the integers are related with other integers that have the same remainder when divided by $q$, and thus, $[q]$ can represent ${\mathbb{Z}}_{q}$ if any integer $a\in{\mathbb{Z}}_{q}$ is treated as $b\in[q]$ such that $(a-b)\text{ mod }q=0$. In this sense, ${\mathbb{Z}}_{q}$ is closed under addition, subtraction, and multiplication.

2.1 LWE-based Cryptosystem

Let the set $[p]$ be where the integer to be encrypted belongs to, and let us denote it by ${\mathcal{P}}$ and call it by the plaintext space. An element $m\in{\mathcal{P}}$ is called a message or a plaintext. The value of $p$ can be chosen as a power of 10 such that $|m|<p/2$ for all messages to be used. Now, let ${\mathbb{Z}}_{q}$ be a set of integers modulo $q$ where $q=Lp$ with $L$ being a power of 10. Finally, in order to encrypt and decrypt a message $m$, choose a secret key ${\sf sk}$ which is an integer vector of size $N$ such that ${\sf sk}\in{\mathbb{Z}}_{q}^{N}$. These $L$ and $N$ are the parameters of the LWE-based cryptosystem and their selection is discussed in more detail in Section 2.1.

Now, let us encrypt a column vector $m\in{\mathcal{P}}=[p]^{n}$ having $n$ elements in $[p]$. Whenever a new message $m$ is encrypted, a new random matrix ${\sf A}\in{\mathbb{Z}}_{q}^{n\times N}$ is sampled from the uniform distribution over ${\mathbb{Z}}_{q}^{n\times N}$, and a new vector ${\sf e}\in[r]^{n}$ is randomly sampled where $r<L$, so that each component ${\sf e_{\mathnormal{i}}}$ satisfies that $|{\sf e_{\mathnormal{i}}}|<L/2$ for $i=1,\cdots,n$. With them, compute

[TABLE]

where $\cdot$ is the standard multiplication of a matrix and a vector. Then, the ciphertext ${\bf m}$ of the plaintext vector $m$ is obtained by the matrix ${\bf m}=[{\sf b},{\sf A}]\in{\mathcal{C}}={\mathbb{Z}}^{n\times(N+1)}_{q}$ where ${\mathcal{C}}$ is called the ciphertext space. Define the secret key vector ${\sf s}:=[1,{\sf sk}^{T}]^{T}$ and let $\lceil\cdot\rfloor$ be the rounding operation for vectors.444We round away from zero for negative numbers, e.g., $\lceil-2.5\rfloor=-3$ while $\lceil-2.4\rfloor=-2$. When $a$ is a vector, $\lceil a\rfloor$ implies component-wise rounding. Then, the ciphertext ${\bf m}$ is decrypted as

[TABLE]

because the size of each element of ${\sf e}$ is less than $L/2$. One of the key ingredients in the LWE-based scheme is the vector ${\sf e}$, which is intentionally injected in the ciphertext by (2) (and is eliminated by the decryption (3)). This vector is called “error,” and it will be seen in Section 2.1 that this error makes this encryption scheme secure.

The discussions so far yield the MATLAB codes with an example parameter set

Ψenv.p = 1e4; env.L = 1e4; env.r = 1e1; env.N = 4; Ψ

which are put in a structure variable env. We randomly select a secret key by555Since the mod function in MATLAB always returns non-negative remainders, we use our customized function (starting with the capital M)

function y = Mod(x,p), y = mod(x,p); y = y - (y >= p/2)*p; end

in order to have signed results in the set like (1).666In order to run the codes in this chapter, please choose small numbers for the secret key in order not to cause the overflow of the double variable in MATLAB. An example is to replace env.q*env.L by 10 for example.

Ψsk = Mod(randi(env.qenv.L,[env.N, 1]), env.qenv.L); Ψ

Under these parameters, the codes are as follows.

{programcode}

Functions $\mathsf{Enc}$, $\mathsf{Dec}$

ΨΨfunction ciphertext = Enc(m,sk,env) ΨΨn = length(m); q = env.Lenv.p; ΨΨA = randi(q, [n, env.N]); ΨΨe = Mod(randi(env.r, [n,1]), env.r); ΨΨb = -Ask + env.Lm + e; ΨΨciphertext = Mod([b,A], q); ΨΨend ΨΨ ΨΨfunction plaintext = Dec(c,sk,env) ΨΨs = [1; sk]; ΨΨplaintext = round( Mod(cs, env.L*env.p)/env.L ); ΨΨend ΨΨ

An example run shows encryption and decryption of a number 30:

Ψsk = Ψ-13203881Ψ Ψ-22462885 Ψ-28840424 Ψ4713455 Ψ Ψc = Enc(30,sk,env) Ψc = Ψ-43264645 21696438 -15923263 46660236 20129426 Ψ Ψm = Dec(c,sk,env) Ψm = Ψ30 Ψ

It is seen from the outcome that the message ${\tt 30}L$ is hiding in the number $-{\sf A}\cdot{\sf sk}+{\sf e}$ that is the first element of ${\bf m}$.

Necessity of error injection and the learning-with-errors problem

A measure for the security of a cryptosystem is how hard it is to find the secret key ${\sf sk}$ when arbitrarily many pairs $(m_{i},{\bf m}_{i})$ are given. In fact, the ciphertexts ${\bf m}_{i}$ are easily available to the adversary by eavesdropping the communication line, and there are many cases that the plaintexts $m_{i}$ are also obtainable. (For example, one may guess an email begins with the word “Dear” even if it is encrypted.) When the pair $m_{i}$ and ${\bf m}_{i}=[{\sf b}_{i},{\sf A}_{i}]$ is available, the adversary can easily obtain $(-{\sf A}_{i}\cdot{\sf sk}+{\sf e})$ as well as ${\sf A}_{i}$ by subtracting $Lm_{i}$ from ${\sf b}_{i}$ (see (2)). Hence, if there is no error injection of ${\sf e}$, then the problem of searching ${\sf sk}$ simply becomes solving a linear equation in ${\mathbb{Z}}^{N}_{q}$, which is not difficult.

Interestingly, with the error ${\sf e}$ injected, it was proved that solving (or, ‘learning’) ${\sf sk}$ becomes extremely difficult. This problem is called ‘learning-with-error (LWE)’ problem, which has been introduced in Regev09 . For example, with $\bar{\sf s}=[{\sf s_{1}},{\sf s_{2}},\dots,{\sf s_{4}}]^{T}=[3,-5,1,0]^{T}\in{\mathbb{Z}}^{4}_{100}$, consider a sequence of linear equations with errors:

[TABLE]

With the error (which need not be large; just a small error is enough, e.g., the error of $1,-1,1,\cdots$ is used in the above example), finding $\bar{\sf s}$ (and ${\sf e}_{i}$ as well) in the set ${\mathbb{Z}}^{4}_{100}$ becomers harder (and it becomes very difficult when the dimension gets higher). In fact, this problem is known to be as hard as the worst-case “lattice problem” so that the cryptosystem based on it becomes secure at the same level of difficulty to solve the problem. Actually, the cryptosystem based on the LWE problem is known to be as much secure as even the quantum computer takes long time to solve (and thus, it is known as a post-quantum cryptosystem NISTreport16 ). This is because the difficulty is not based on the factoring problem,777Factoring problem is to find large prime numbers $p$ and $q$ when $N=pq$ is given. This problem is supposed to be easily solved (i.e., in polynomial time) by quantum computers. which has been a basis for many other cryptosystems.

How to choose parameters for desired level of security?

An encryption scheme is called $\lambda$-bit secure, whose meaning is briefly introduced in this subsection. For this, let us consider a game between an adversary and a challenger. The rule is that, whenever the adversary submits two messages $m_{1}$ and $m_{2}$ to the challenger, the challenger randomly chooses one of them with equal probability and returns it back to the adversary after encrypting the chosen message. Then, the adversary guesses which one of $m_{1}$ and $m_{2}$ is encrypted by inspecting the received ciphertext. If the ratio of the adversary’s correct guess is not meaningfully greater than $0.5$ as the game repeats, then the encryption scheme is said to be indistinguishable. Let $\mathcal{A}$ denote the algorithm that the adversary uses in the game to guess. Then, the encryption scheme is called $\lambda$-bit secure if, for all available adversary’s algorithm $\mathcal{A}$, it holds that

[TABLE]

Clearly, large $\lambda$ implies that the adversary needs high computational complexity while the success rate is not very different from 0.5 for all possible attack algorithms.

For the case of the LWE-based cryptosystem used in this chapter, it is rather convenient to assess its level of security by using a useful tool, called ‘LWE estimator.’ This tool is implemented using Sage program language and an on-line version is also available.888https://bitbucket.org/malb/lwe-estimator When the parameters $p$, $L$, $r$, and $N$ of the LWE-based cryptosystem is given, the estimator computes expected number of operations to attack the encryption scheme by various attack algorithms $\mathcal{A}$, and finally returns $\lambda$. Below is an example for using the estimator with a specific parameter set.

Ψload(estimator.py) Ψp = 1e4; L = 1e4; r = 1e2; N = 20 Ψ_ = estimate_lwe(N, (r / (L * p)), (L * p)) Ψ

The following is the output of the estimator with the parameter set.

Ψusvp: rop: = 2^29.7, ... Ψdec: rop: = 2^32.3, ... Ψdual: rop: = 2^31.3, ... Ψ

Those values of rop mean the number of operations for each attack called usvp, dec, and dual. Therefore, we can say that the parameter set has at least 29.7-bit security. It is known that the security level $\lambda$ roughly has the following property:

[TABLE]

Therefore, increasing $N$ may easily lead to higher security.

2.2 Homomorphic Property of LWE-based Cryptosystem

As a control engineer, a reason for particular interest on the LWE-based cryptosystem is that it allows homomorphic arithmetics. By homomorphic arithmetics, we mean, for two plaintexts $m_{1}$ and $m_{2}$, it holds that

[TABLE]

where $\ast_{\mathcal{P}}$ and $\ast_{\mathcal{C}}$ are binary operations on the plaintext space ${\mathcal{P}}$ and the ciphertext space ${\mathcal{C}}$, respectively, and $\mathsf{Dec}$ and $\mathsf{Enc}$ symbolize the encryption and the decryption functions, respectively. The LWE-based cryptosystem provides both the homomorphic addition and the homomorphic multiplication.

The addition is defined in the following way:

[TABLE]

where $+_{{\mathcal{C}}}$ is the addition on the ciphertext space and $+$ is the standard matrix addition. To see the homomorphic property, observe that

[TABLE]

as long as $m_{1}+m_{2}\in[p]$ and each element of $|{\sf e_{1}}+{\sf e_{2}}|$ is less than $L/2$.

Let us now consider the homomorphic multiplication of two scalar plaintexts $m_{1}\in[p]$ and $m_{2}\in[p]$. Without loss of generality, let $m_{1}$ be the multiplicand and $m_{2}$ be the multiplier for the product $m_{2}m_{1}$. For the multiplicand $m_{1}$, we use the previous encryption function ${\bf m_{1}}=\mathsf{Enc}(m_{1})\in{\mathbb{Z}}^{1\times(N+1)}_{q}$ but for the multiplier $m_{2}$, we slightly change the encryption method999 In practice, parameters $d\in{\mathbb{N}}$ and $\nu\in{\mathbb{N}}$ is chosen such that $q=\nu^{d}$, which customizes the dimension of the ciphertext ${\bf M}_{2}$ as ${\bf M}_{2}\in{\mathbb{Z}}^{d(N+1)\times(N+1)}_{q}$. 101010This encryption was developed in GSW13 and the idea of using different encryption method for $m_{2}$ was introduced in CGG+16 , which is customized for our context in this chapter. as

[TABLE]

where $0_{\log q\cdot(N+1)\times 1}$ is the plaintext of zero vector in $[p]^{\log q\cdot(N+1)\times 1}$ and, with the Kronecker product being denoted by $\otimes$,

[TABLE]

where $I_{N+1}$ is the identity matrix of size $N+1$, so that $R$ is a matrix of $\log q\cdot(N+1)$ by $(N+1)$. Note that ${\bf O}:=\mathsf{Enc}(0_{\log q\cdot(N+1)\times 1})$ is a matrix in ${\mathbb{Z}}^{\log q\cdot(N+1)\times(N+1)}_{q}$, each row of which is an encryption of the plaintext 0 (but they are all different due to the randomness of ${\sf A}$ and ${\sf e}$). This modified encryption $\mathsf{Enc2}$ has the same level of security as $\mathsf{Enc}$ because the plaintext $m_{2}$ is still hiding in the ciphertext ${\bf O}$. Now we note that any vector $c$ in ${\mathbb{Z}}^{1\times(N+1)}_{q}$ can be represented using the radix of 10 as $c=\sum_{i=0}^{\log q-1}c_{i}\cdot 10^{i}$ in which each component of the row vector $c_{i}$ is one of the single digit $0,1,2,\cdots,9$. Therefore, one can define the function $D:{\mathbb{Z}}^{1\times(N+1)}_{q}\to{\mathbb{Z}}^{1\times\log q\cdot(N+1)}_{q}$ that decomposes the argument by its string of digits as

[TABLE]

An example when $q=10^{2}$ and $N=2$ is:

[TABLE]

because $[40,35,73]=[0,5,3]\cdot 10^{0}+[4,3,7]\cdot 10^{1}$. As a result, it follows that $c=D(c)R$ for any $c\in{\mathbb{Z}}^{1\times(N+1)}_{q}$. Now, the multiplication of two ciphertexts ${\bf m_{1}}=\mathsf{Enc}(m_{1})$ and ${\bf m_{2}}=\mathsf{Enc}(m_{2})$ can be done by, with ${\bf M_{2}}=\mathsf{Enc}2(\mathsf{Dec}({\bf m_{2}}))$,

[TABLE]

where $\cdot$ is the standard matrix multiplication. It should be noted that the operation $\mathsf{Enc}2(\mathsf{Dec}({\bf m_{2}}))$ requires the secret key ${\sf sk}$, and thus, the above operation is more suitable when the multiplier $m_{2}$ is encrypted as ${\bf M_{2}}=\mathsf{Enc}2(m_{2})$ a priori, and used repeatedly for different ${\bf m_{1}}$’s (which will be the case when we construct dynamic feedback controllers). In this case, the product of the multiplicand ${\bf m_{1}}$ with the multiplier ${\bf M_{2}}$ is simply performed as $D({\bf m_{1}})\cdot{\bf M_{2}}$. To see the homomorphic property, we first note that, with the secret key $\sf s$,

[TABLE]

where ${\sf e}_{\bf M_{2}}\in{\mathbb{Z}}^{\log q\cdot(N+1)\times 1}_{q}$ is the error vector inside the ciphertext ${\bf O}$. From this, we observe that multiplication by $\bf M_{2}$ is equivalent to multiplication by the plaintext $m_{2}$ plus an error. Then, we have the homomorphic property for multiplication as

[TABLE]

as long as $m_{2}m_{1}\in[p]$ and

[TABLE]

A sample run and the codes for two operations are as follows:

Ψq = env.p*env.L; Ψc1 = Enc(-2,sk,env); c2 = Enc(3,sk,env); c2m = Enc2(3,sk,env); Ψ Ψc_add = c1 + c2; Ψc_mul = Decomp(c1, q)*c2m; Ψ ΨDec(c_add,sk,env) Ψans = Ψ1 Ψ ΨDec(c_mul,sk,env) Ψans = Ψ-6 Ψ

{programcode}

Functions ${\sf Enc2}$, ${\sf Decomp}$

ΨΨfunction ciphertext = Enc2(m,sk,env) ΨΨq = env.Lenv.p; N = env.N; lq = log10(q); ΨΨR = kron( power(10, [0:1:lq-1]’), eye(N+1) ); ΨΨciphertext = Mod(mR + Enc(zeros(lq*(N+1),1), sk, env), q); ΨΨend ΨΨ ΨΨfunction strdigits = Decomp(c, q) ΨΨlq = log10(q); ΨΨc = mod(c, q); ΨΨstrdigits = []; ΨΨfor i=0:lq-1, ΨΨ Q = c - mod(c, 10^(lq-1-i)); ΨΨ strdigits = [ Q/10^(lq-1-i), strdigits ]; ΨΨ c = c - Q; ΨΨend ΨΨend ΨΨ

If a ciphertext ${\bf m_{1}}\in{\mathbb{Z}}^{1\times(N+1)}_{q}$ is multiplied with a plaintext $m_{2}\in[p]$, then it is simply performed by ${\bf m_{1}}m_{2}\pmod{q}$ because this case can be considered as a repeated homomorphic addition.

Finally, we close this section by presenting a code for obtaining the product of the ciphertext of a matrix $F\in[p]^{m\times n}$ and the ciphertext of a column vector $x\in[p]^{n}$ that is equivalent to the ciphertext of $Fx$. With ${\bf F}_{i,j}=\mathsf{Enc}2(F_{i,j})$ where $F_{i,j}$ is the $(i,j)$-th element of $F$, and ${\bf x}_{j}$ being the $j$-th row of ${\bf x}=\mathsf{Enc}(x)$, we define the multiplication as

[TABLE]

in which, we abuse the notation $\times_{\mathcal{C}}$ that was defined for a scalar product. Then, analogously to (8) and (9), it follows that

[TABLE]

where ${\sf e}_{{\bf F}_{i,j}}$ is the error inside ${\bf F}_{i,j}$, and the homomorphic property is obtained as

[TABLE]

as long as $Fx\in[p]^{m}$ and the error $|F\cdot{\sf e}_{\bf x}+\Delta({\bf F},{\bf x})|$ is less than $L/2$.

Therefore, the operation

[TABLE]

where $+$ is the standard addition, corresponds to the plaintext operation $Fx+Gy$ with two matrices $F$ and $G$, and two vectors $x$ and $y$. An example code and a sample run are as follows.

ΨF = [1, 2; 3, 4]; ΨcF = Enc2Mat(F,sk,env); Ψ Ψx = [1;2]; Ψcx = Enc(x,sk,env); Ψ ΨcFcx = MatMult(cF,cx,env); ΨDec(cFcx,sk,env) Ψans = Ψ5 Ψ11 Ψ

{programcode}

Functions ${\sf Enc2Mat}$, ${\sf MatMult}$

ΨΨfunction cA = Enc2Mat(A,sk,env) ΨΨq = env.penv.L; N = env.N; [n1,n2] = size(A); ΨΨcA = zeros(log10(q)(N+1), N+1, n1, n2); ΨΨfor i=1:n1, ΨΨ for j=1:n2, ΨΨ cA(:,:,i,j) = Enc2(A(i,j),sk,env); ΨΨ end ΨΨend ΨΨend ΨΨ ΨΨfunction Mm = MatMult(M,m,env) ΨΨ[n1,n2,n3,n4] = size(M); q = env.penv.L; ΨΨMm = zeros(n3,env.N+1); ΨΨfor i=1:n3, ΨΨ for j=1:n4, ΨΨ Mm(i,:) = ... ΨΨ Mod(Mm(i,:) + Decomp(m(j,:),env.penv.L) * M(:,:,i,j), q); ΨΨ end ΨΨend ΨΨend ΨΨ

Error growth problem caused by error injection

As can be seen in (2), a newborn scalar ciphertext ${\bf m}$ has its error ${\sf e}$ whose size is less than $r/2$; that is, $\|{\sf e}\|_{\infty}\leq r/2$ where $\|\cdot\|_{\infty}$ is the infinity norm of a vector. However, the size of the error inside a ciphertext can grow as the arithmetic operations are performed on the variable. For example, if $\mathsf{MaxError}({\bf m})$ measures the maximum size of the worst-case error in ${\bf m}$, then $\mathsf{MaxError}({\bf m_{1}}+{\bf m_{2}})=\mathsf{MaxError}({\bf m_{1}})+\mathsf{MaxError}({\bf m_{2}})$ and $\mathsf{MaxError}({\bf m_{1}}m_{2})=m_{2}\mathsf{MaxError}({\bf m_{1}})$ for a plaintext $m_{2}$, which can be seen from (4). The multiplication may cause more increase of the error as can be seen in (10). That is, the error in the product ${\bf m}_{\sf prod}$ of the multiplicand ${\bf m_{1}}$ and the multiplier ${\bf M_{2}}$ leads to $\mathsf{MaxError}({\bf m}_{\sf prod})=m_{2}\mathsf{MaxError}({\bf m_{1}})+9(r/2)\log q$ because each element of ${\sf e_{\bf M_{2}}}$ is the error of the newborn ciphertext so that its absolute value is less than $r/2$ and the component of $D({\bf m_{1}})$ ranges from 0 to 9. It is noted that the first term $m_{2}\mathsf{MaxError}({\bf m_{1}})$ is natural, but the amount of the second term may always add whenever the multiplication is performed.

The discussions so far show that, if the arithmetic operations are performed many times on the ciphertext, then the error may grow unbounded in the worst case, and it may damage the message in the ciphertext. Damage of the message happens when the size of the error in the ciphertext becomes larger than $L/2$. Indeed, the following example shows this phenomenon:

Ψc = Enc(1,sk,env);

ΨDec(3*c,sk,env) Ψans = Ψ3

ΨDec(3000*c,sk,env) Ψans = Ψ2999 Ψ

The error growth problem restricts the number of consecutive arithmetic operation on the ciphertext. In order to overcome the restriction, the blueprint of ‘bootstrapping’ procedure has been developed in Gen09 . In a nutshell, the grown-up error can be eliminated if the ciphertext is once decrypted and encrypted back again. The bootstrapping algorithm reduces the size of error by performing this process without the knowledge of the secret key. However, the complexity of the bootstrapping process hinders from being used for dynamic feedback controls. We discuss how to overcome this problem without bootstrapping in Section 4.

3 LWE-based Cryptosystem and Dynamic Feedback Controller

For a comprehensive discussion with dynamic controllers, let us consider a discrete-time single-input-single-output linear time-invariant plant:

[TABLE]

To control the plant (12), we suppose that a discrete-time linear time-invariant dynamic feedback controller has been designed as

[TABLE]

where $x\in{\mathbb{R}}^{n}$ is the state of the controller, $y\in{\mathbb{R}}$ is the controller input, and $u\in{\mathbb{R}}$ is the controller output. Note that they are real numbers in general, and not yet quantized. In order to implement the controller by a digital computer, we need to quantize the signals $y$, $u$, and $x$, and to use the cryptosystem for the controller, we also need to make them integer values. This procedure is called ‘quantization’ in this chapter.

Quantization is performed both on the sensor signal $y[t]$, on the control parameters, and finally on the actuator signal $u[t]$. The quantization level for $y[t]$ is often determined by the specification of the sensor under the name of resolution $R_{y}$. Therefore, we define the quantized integer value of the signal $y[t]$ as

[TABLE]

For example, with $R_{y}=0.1$, the signal $y[t]=12.11$ becomes $\bar{y}[t]=121$. This procedure is performed at the sensor stage before the encryption. On the other hand, the matrices in (13) are composed of real numbers in general. These numbers should be truncated for digital implementation, but it is often the case when the significant digits of them include fractional parts. In this case, we can “scale” the controller (13) by taking advantages of the linear system. Before discussing the scaling, we assume that the matrix $F$ consists of integer numbers so that the scaling for $F$ is not necessary. This is an important restriction and we will discuss this issue in detail in Section 5. Now, take $G=[5.19,38]^{T}$ for example. If those numbers are to be kept up to the fraction $1/10=:S_{G}$, then the quantized $G$ can be defined as $\bar{G}:=\lceil G/S_{G}\rfloor$ so that $\bar{G}=[52,380]^{T}$. By dividing (13a) by $R_{y}S_{G}$, we obtain the quantized equation as

[TABLE]

where $\bar{x}[t]:=x[t]/(S_{G}R_{y})$ which becomes integer for all $t>0$ if the initial condition is set as $\bar{x}[0]=\lceil x[0]/(S_{G}R_{y})\rfloor$. Since there may be still some significant fractional numbers in the matrices $H$ or $J/S_{G}$ in general, the output equation (13b) is scaled with additional scaling factor $S_{HJ}$ as

[TABLE]

where $\bar{H}:=\lceil H/S_{HJ}\rfloor$, $\bar{J}:=\lceil J/(S_{HJ}S_{G})\rfloor$, and $\bar{u}[t]:=u[t]/(S_{HJ}S_{G}R_{y})$. Therefore, the quantized controller

[TABLE]

is composed of integer values, and the state $\bar{x}[t]$ evolves on the integer state-space. Finally, the real number input $u[t]$ is obtained by

[TABLE]

at the actuator stage, where $R_{u}$ is the resolution of the actuator. If $R_{y}S_{G}S_{HJ}/R_{u}$ is an integer then the rounding doesn’t work because $\bar{u}[t]$ is integer. It is clear that the digital implementation of (13), given by (14), (15), and (16), works well if the truncation error is small.

Since the quantized controller (15) consists of all the integer matrices and vectors, it is straightforward to convert it to the homomorphically encrypted controller

[TABLE]

where the operations on the ciphertexts should be understood as explained in Section 2.2. Note that ${\bf y}[t]=\mathsf{Enc}(y[t])$ is always a newborn ciphertext for each $t$ because it is encrypted and transmitted from the sensor stage. Moreover, the ciphertexts ${\bf F}$, ${\bf G}$, ${\bf H}$, and ${\bf J}$ can be considered as all newborn ciphertexts because they are generated when the controller is set and not updated by the control operation. The equation (17) is solved at each time step with the initial condition ${\bf x}[0]=\mathsf{Enc}(\bar{x}[0])$. Under this setting, two new ciphertexts ${\bf x}[t+1]$ and ${\bf u}[t]$ are created at each time step, or the system (17) is considered to be driven by ${\bf y}[t]$ with ${\bf x}[0]$. The vector ${\bf x}[0]$ also has the newborn error, but the error in ${\bf x}[t]$ may grow as time goes on because of the recursion in (17a).

As an example, consider a first-order plant given by $x_{\sf p}[t+1]=\sqrt{2}x_{\sf p}[t]+u[t]$ and $y[t]=x_{\sf p}[t]$, for which a first-order dynamic feedback controller $x[t+1]=-1\cdot x[t]+1\cdot y[t]$ and $u[t]=-1.414\cdot x[t]+0\cdot y[t]$ stabilizes the closed-loop system. With the parameters $R_{y}=10^{-3}$, $S_{G}=1$, $S_{HJ}=10^{-3}$, and $R_{u}=R_{y}S_{G}S_{HJ}=10^{-6}$ the simulation can be done for timesteps = 150 as follows.111111An example parameter set for this example is ${\tt env.p=1e9}$, ${\tt env.L=100}$, and ${\tt env.r=10}$.

ΨA = sqrt(2); B = 1; C = 1; % plant ΨF = -1; G = 1; H = -1.414; J = 0; % controller ΨRy = 1e-3; Sg = 1e0; Shj = 1e-3; ΨG_ = round(G/Sg); H_ = round(H/Shj); J_ = round(J/(SgShj)); ΨcFG = Enc2Mat([F,G_],sk,env); cHJ = Enc2Mat([H_,J_],sk,env); Ψxp = -3.4; x = 4.3; % i.c. of plant and ctr Ψcx = Enc(round(x/(RySg)), sk, env); Ψ Ψfor i = 1:timesteps Ψ y = Cxp; % Plant output Ψ cy = Enc(round(y/Ry), sk, env); % Encryption Ψ cu = MatMult(cHJ, [cx;cy], env); % Controller output Ψ u = RySgShjDec(cu, sk, env); % Plant input after Dec Ψ xp = Axp + Bu; % Plant update Ψ cx = MatMult(cFG, [cx;cy], env); % Controller update Ψend Ψ

4 Controlled Error Growth by Closed-loop Stability

As mentioned previously, the growth of the error in the ciphertext ${\bf x}[t]$ is of major concern in this section. We have to suppress its growth not to go unbounded.

Actually, the source of error growth is the arithmetic operations in (17). To see both the message and the error in the state ${\bf x}[t]$, let us decrypt the dynamics (17) with the secret key $\sf s$ except the rounding operation; i.e., we define

[TABLE]

so that $\mathsf{Dec}({\bf x}[t])=\lceil\xi[t]\rfloor$, and see the evolution of $\xi$-system over real-valued signals, which in turn is equivalent to the operation of (17). According to the homomorphic property (11), the $\xi$-system is derived as

[TABLE]

in which ${\sf e}_{{\bf y}[t]}$ and ${\sf e}_{{\bf x}[0]}$ are the errors injected to the encryptions ${\bf y}[t]$ and ${\bf x}[0]$, respectively, $\Delta({\bf F},{\bf x}[t])$, $\Delta({\bf G},{\bf y}[t])$, $\Delta({\bf H},{\bf x}[t])$, and $\Delta({\bf J},{\bf y}[t])$ are the errors caused by ciphertext multiplication, which are defined as the same as in (11), and $\bar{u}^{\prime}[t]$ is defined as $\bar{u}^{\prime}[t]:=({\bf u}[t]\cdot{\sf s}\mod q)/L$ so that $\mathsf{Dec}({\bf u}[t])=\lceil\bar{u}^{\prime}[t]\rfloor$.

For the comparison with the quantized controller (15), the first observation is that if there is no error injected to ciphertexts ${\bf y}[t]$, ${\bf x}[0]$, and $\{{\bf F},{\bf G},{\bf H},{\bf J}\}$ so that $\Delta_{1}[t]$, $\Delta_{2}[t]$, and ${\sf e}_{{\bf x}[0]}$ are all zero, the operation of (18) is exactly the same way as the operation of (15). Then, with the control perspective, the signals $\Delta_{1}[t]$ and $\Delta_{2}[t]$ can be understood as external disturbances injected to the feedback loop, and the quantity ${\sf e}_{{\bf x}[0]}$ can be regarded as perturbation of the initial condition (see Fig. 2). Here, the sizes of $\Delta_{1}[t]$, $\Delta_{2}[t]$, and ${\sf e}_{{\bf x}[0]}$ can be made arbitrarily small by increasing the parameter $L$ for the encryption. This is because $\|{\sf e}_{{\bf y}[t]}/L\|_{\infty}$ and $\|{\sf e}_{{\bf x}[0]}/L\|_{\infty}$ are less than $r/(2L)$, and the disturbance caused by multiplication of $\{{\bf x}[t],{\bf y}[t]\}$ by $\{{\bf F},{\bf G},{\bf H},{\bf J}\}$ can also be made arbitrary small with the choice of $L$; for example, as seen in (11), the size of signal $\Delta({\bf F},{\bf x}[t])/L$ is bounded as

[TABLE]

Now, in terms of the error growth problem of the controller state, the difference $\xi[t]-\bar{x}[t]$ corresponds to the error of our concern. One might expect that the size of $\xi[t]-\bar{x}[t]$ can be made arbitrarily small by increasing $L$, but it is not true due to the rounding operations in the sensor and actuator; for example, if the difference $\xi[t]-\bar{x}[t]$ is so small that the difference of actuator inputs is less than the size of input resolution, it is truncated and the difference is not compensated in the closed-loop stability. As a result, the error eventually grows up to the resolution range, but is controlled not to grow more than that. Therefore, the damage of the message in the ciphertexts ${\bf x}[t]$ is inevitable, but it can be limited up to the last a few digits. Motivated by this fact, one may intentionally enhance the resolutions by a few more digits in order to preserve the significant figures. In this way, as long as the injected errors $\Delta_{1}[t]$, $\Delta_{2}[t]$, and ${\sf e}_{{\bf x}[0]}/L$ are sufficiently small, the error (i.e., the difference $\xi[t]-\bar{x}[t]$) is controlled not to grow unbounded by the closed-loop stability. See a simulation result in Fig. 3.

In the rest of this section, we analyze the control performance in terms of the encryption as well as the quantization. The detailed quantitative analysis is omitted but can be found in we19 . For this, let us recall that $\mathsf{Dec}({\bf u}[t])=\lceil\bar{u}^{\prime}[t]\rfloor$. This leads to, by (16),

[TABLE]

where

[TABLE]

in which, $\Delta_{\mathsf{Dec}}$ implies the error caused by the rounding in the decryption, and $\Delta_{u}$ implies the error by the quantization of the input stage. Now, for the sake of simplicity, let us assume that $G=S_{G}\bar{G}$, $H=S_{HJ}\bar{H}$, and $J=S_{HJ}S_{G}\bar{J}$, which means there is no error due to the scaling of the matrices. By defining $\xi^{\prime}:=R_{y}S_{G}\xi$, we obtain from (18) that

[TABLE]

in which, $\Delta_{y}$ is the error caused by the quantization at the sensor stage. Putting together, the closed-loop system of the plant (12) and the controller (18) is equivalently described by

[TABLE]

with the initial condition of the controller is set to be

[TABLE]

where $x[0]$ is the initial condition of (13). Note that all the braced terms (i.e., errors) can be made arbitrarily small with sufficiently small $R_{y}$ and $R_{u}$ and with sufficiently large $L$. Moreover, with all these errors being zero, the above system is nothing but the closed-loop system of the plant (12) and the controller (13), which is supposed to be asymptotically stable. Therefore, it is seen that the control performance with the encrypted controller (17) can be made arbitrarily close to the nominal control performance with the linear controller (13).

5 Conclusion and Need for Integer System Matrix

In this chapter, with the use of fully homomorphic encryption, we have seen a method as well as an illustrative example to implement a dynamic feedback controller over encrypted data. Exploiting both additively and multiplicatively homomorphic properties of LWE-based scheme, all the operations in the controller are performed over encrypted parameters and signals. Once the designed controller (13) is converted to the dynamical system (15) over integer, it can be directly encrypted as (17). From the nature of fully homomorphic encryption schemes, the error injected to the encryption ${\bf y}[t]$ may be accumulated in the controller state ${\bf x}[t]$ under the recursive state update and may affect the message. However, from the control perspective, it has been seen that the effect of error is controlled and suppressed by the stability of the closed-loop system.

For the concluding remark, let us revisit that the encryption scheme for the dynamic controller (13) is based on the assumption that all entries of the system matrix $F$ are integers. To see the necessity of this assumption, let us suppose the matrix $F$ consists of non-integer real numbers. One may attempt the scaling of $F$ as $\lceil F/S_{F}\rfloor$ with the scaling factor $1/S_{F}>1$ in order to keep the fractional part of $F$, but this scaling is hopeless because it results in recursive multiplication by $1/S_{F}$ for each update of the controller. Indeed, for this case, it can be checked that the state $\bar{x}[t]$ of the quantized controller (15a) is multiplied by $\lceil F/S_{F}\rfloor$ (instead of $F$) for each time step, so (15a) should be remodeled as the form

[TABLE]

with the relation $\bar{x}[t]=x[t]/(S_{F}^{t}S_{G}R_{y})$. However, encryption of (19) is hopeless, because in this case the message of the encrypted state is unbounded due to the term $1/S_{F}^{t}$. It will lose its value when it eventually go beyond the bound $\pm p/2$ of the plaintext space $[p]$ represented as (1), unless the state is reset to eliminate the accumulated scaling factor.

This problem, which is from the constraint that encrypted variables can be multiplied by scaled real numbers only a finite number of times, is in fact one of the main difficulties of encrypting dynamic controllers having non-integer system matrix121212The problem is the same for encrypted controllers based on additively homomorphic encryption schemes. See Cheon18 for the details.. In this respect, one may find potential benefits of using proportional-integral-derivative (PID) controllers or finite-impulse-response (FIR) filters for the design of encrypted control system, because they can be realized with the matrix $F$ being integer as follows:

• •

Given an FIR filter written as $C(z)=\sum_{i=0}^{n}b_{n-i}z^{-i}$, and the dynamic feedback controller can be realized as

[TABLE]

• •

A discrete PID controller in the parallel form is given by

[TABLE]

where $k_{p}$, $k_{i}$, and $k_{d}$ are the proportional, integral, and derivative gains, respectively, $T_{s}$ is the sampling time, and $N_{d}\in{\mathbb{N}}$ is the parameter for the derivative filter. This controller can be realized as

[TABLE]

where $b_{1}=k_{i}T_{s}-k_{d}N_{d}^{2}/T_{s}$, $b_{0}=k_{i}T_{s}N_{d}-k_{i}T_{s}+k_{d}N_{d}^{2}/T_{s}$, and $b_{2}=k_{p}+k_{d}N_{d}/T_{s}$.

Another idea of approximating the effect of non-integer real numbers of $F$ has been presented in Cheon18 by using stable pole-zero cancellation. However, it was done at the cost of increased steady-state error in control performance. Further research is called for in this direction.

Acknowledgement

The authors are grateful to Prof. Jung Hee Cheon and Dr. Yongsoo Song, Department of Mathematical Sciences, Seoul National University, for helpful discussions. This work was supported by National Research Foundation of Korea (NRF) grant funded by the Korea government (Ministry of Science and ICT) (No. NRF-2017R1E1A1A03070342).