# Formal Verification of Fractional-Order PID Control Systems Using Higher-Order Logic

^{*}

## Abstract

**:**

## 1. Introduction

- The relationship between fractional-order calculus and integral-order calculus was verified in HOL. It serves as a theoretical foundation for the verification of fractional-order control;
- The formal model of fractional-order PID control was created, and the relationship between fractional-order PID control and integral-order PID control was also verified;
- Fractional-order control was analyzed in the HOL theorem prover. Some formalization models were proposed, including the formalization of fractional-order systems, the formalization of fractional-order Laplace transform, and the formalization of the fractional-order closed-loop control;
- A robot fractional-order PID control system was verified. The performance of the fractional-order PID control is herein shown.

## 2. HOL System

## 3. Design of the Fractional-Order PID Controller

#### 3.1. PID Controller for Robot

#### 3.2. Fractional-Order PID Controller for Robot

## 4. Formalization of Fractional-Order PID Control Systems

#### 4.1. Formalization of the Relationship between Fractional-Order Calculus and Integral-Order Calculus

**Definition**

**1.**

`|-!g w c d q.frac_cal g w c d q = lim(\n. 2 rpow (&n * w) *`

`(sum(0,SUC (flr((d-c) * (2 pow n)))) (\(m:num).`

`((~1) pow m * (rbino_coe w m) * g(q-(&m/(2 pow n)))))))`

- where g indicates a function of the class (real -> real), and w represents a true value that denotes the degree of the fractional order. As for c and d, these denote the bottom and top bounds of the fractional-order algorithm, separately. flr represents a function of rounding the true value. That is, the largest number smaller than or equivalent to a true integer.

**Case 1.**

**Theorem**

**1.**

`|- fraction g 0 c d x = g x`

`lim (\n.2 rpow 0 * sum (0,SUC (flr ((d − c) * 2 pow n)))`

`(\m. −1 pow m * rbino_coe 0 m * g (x − &m/2 pow n))) = g x`

`lim.`

**Lemma**

**1.**

`|- sum (0,SUC m) g = sum (0,1) g + sum (1,m) g`

**Lemma**

**2.**

`|-!g. (!j. n <= j/\ j <= n + h ==> (g j = 0)) ==> (sum (n,h) g = 0)`

**Case 2.**

**Theorem**

**2.**

`|-!g c d x.frac_cal_exists g (&n) c d x/\`

`n_deriv_exists n g x/\ c < d/\ 0 < n`

`==> (frac_cal g (&n) c d x = n_deriv n g x)`

`(d-c)`becomes greater than 0 in the GL definition, and $\lfloor (d-c)*{2}^{n\u2019}\rfloor $ also tends to infinity. A logarithm based on 2 needs to be used for the simplification of ${2}^{n\u2019}$. There is no logarithm based on 2 in the library of HOL. Thus, a logarithm based on 2 is formally defined in HOL.

**Definition**

**2.**

`|-!x. log2 x = ln x/ln 2`

**Lemma**

**3.**

`|-!x. 0 < x ==> (2 rpow log2 x = x)`

**Case 3.**

**Theorem**

**3.**

`|-!g c d x. c < d ==> (frac_cal g (−1) c d x = integral (c,d) g x)`

- where
`c`and`d`denote the bottom and top boundsof integration,separately. Formalizations of the binomial factor and the index’s properties should be used during the verification of this theorem. The main difficultyin proving this theory is the certification of lemmas:

**Lemma**

**4.**

`|-!m. −1 pow m * rbino_coe (−1) m = 1`

**Lemma**

**5.**

`|-!c d. 0 < c ==> (c rpow -d = 1/c rpow d)`

**Theorem**

**4.**

`|-!g c d x n.c < d /\ FRAC_CAL_N_INTEGRAL_LEMMA`

`/\ frac_cal_indexadd ==>`

`(frac_cal g (-&n) c d x = integral_n (c,d) n g x)`

- where
`c`and`d`denote the bottom and top boundsof thefractional-order calculus, respectively. The`&`is a type of conversion symbol from an integer into a real number. The mathematical induction method is used for the proof of this theorem. When$\alpha =-1$, the relationship of thefractional-orderintegration and integration was verified as Theorem 3. Then, the iteration relationship between the (n + 1)-fold integration and n-fold integration was verified. The most important part of this proof is presented as follows:$${}_{a}D{}_{b}^{-n-1}g(x)=\frac{1}{(n-1)!}{\displaystyle \underset{a}{\overset{b}{\int}}{(b-x)}^{n-1}\left[{\displaystyle \underset{a}{\overset{x}{\int}}g(y)dy}\right]}dx=-\frac{{(b-x)}^{n}{\displaystyle \underset{a}{\overset{x}{\int}}g(y)dy}}{n!}|{}_{x=a}^{x=b}+\frac{1}{n!}{\displaystyle \underset{a}{\overset{b}{\int}}{(b-x)}^{n}g(x)dx}=\frac{1}{n!}{\displaystyle \underset{a}{\overset{b}{\int}}{(b-x)}^{n}g(x)dx}$$

#### 4.2. Formal Model of the Fractional-Order PID Controller

**Definition**

**3.**

`|-!Lambda Mu K_P K_I K_D e_tt.u_t Lambda Mu K_P K_I K_D e_t t =`

`K_P * e_t t + K_I * frac_cal e_t (-Lambda) 0 t t`

`+ K_D * frac_cal e_t Mu 0 t t`

`u_t`denotesan operator export signal.

`e_t`representsa controller input sign. The Lambdaand Muindicate an integral order anda differential order. The

`K_P, K_I,`and

`K_D`denote proportiongaining, integration constant, and derivative constant, separately.

**Theorem**

**5.**

`|- 0 < t /\`

`(Lambda = 1) /\ (Mu = 1) /\`

`frac_cal_exists e_t 1 0 t t/\deriv_exists e_t t ==>`

`(u_t Lambda Mu K_P K_I K_D e_t t = K_P * e_t t +`

`K_I * integral (0,t) e_t t + K_D * deriv e_t t)`

**Theorem**

**6.**

`|- 0 < t/\ (Lambda = 1)/\ (Mu = 0) ==>`

`(u_t Lambda Mu K_P K_I K_D e_t t = (K_P + K_D) * e_t t`

`+ K_I * integral (0,t) e_t t)`

**Theorem**

**7.**

`|- 0 < t/\ (Lambda = 0)/\ (Mu = 1)/\ frac_cal_exists e_t 1 0 t t`

`/\ deriv_`

`exists`

`e_t t ==> (u_t Lambda Mu K_P K_I K_D e_t t`

`= (K_P + K_I) * e_t t + K_D * deriv e_t t)`

**Theorem**

**8.**

`|- 0 < t /\ (Lambda = 0) /\ (Mu = 0) ==>`

`(u_t Lambda Mu K_P K_I K_D e_t t = (K_P + K_I + K_D) * e_t t)`

`frac_cal_exists`and

`derive_exists`functions guarantee the existence of fractional-order calculus and traditional differentiation.

#### 4.3. Formalization of the Fractional-Order Closed-Loop System

**Definition**

**4.**

`|- FRAC_ORDER_SYSTEM <=> !n p a y u t.0 <= p 0/\`

`(!j. j < n ==> p j < p (SUC j))`

`==>(sum (0,SUC n) (\i. a i * frac_cal y (p i) 0 t t) = u t)`

`i`and the type is num-> real. $p(j)$ represents the ${\beta}_{j}$ of Equation (13). $p(j)$ is also a function in which the variable is

`j`and the type is num-> real. Here, to meet the HOL idea that all symbols can be played using a keyboard, the body of the function is written as

`p`instead of $\beta $. The antecedent

`(!j. j < n ==> p j < p (SUC j))`satisfies the requirement that the degree of fractional-order calculus increases within the fractional-order regime.

**Definition**

**5.**

`|-!s g t. LAPLACE s g t = lim(\n.lim(\b.integral (1/2 pow n,&b)`

`(\t. g t * exp (-(s * t))) t))`

`lim`is the seeking limit, and the integral is a quadrature. The Laplace transform is a conversion of the system between the temporal region with frequent region. In order to formally verify the fractional-order controller, this paper introduces fractional-order Laplace transform. The formal expression of fractional-order Laplace transformation can be constructed in the following:

**Definition**

**6.**

`|- FRAC_LAPLACE <=> !F s g t v.(F s = LAPLACE s g t) ==>`

`(s rpow v * F s = frac_cal g v 0 t t)`

`F s = LAPLACE s`

`g`

`t`satisfies the requirement that the fractional-order Laplace transformation function g(t) must satisfy the relevant conditions of traditional Laplace transformation. g(t) represents the function before the transformation. F(s) represents the function after the transform.

`frac_cal`represents the formalized definition of fractional-order calculus.

**Theorem**

**9.**

`|- 0 < s/\ 0 < E s/\ FRAC_LAPLACE/\ (LAPLACE s u t = U s)`

`/\ (LAPLACE s e t = E s)/\ (u t = u_t Lambda Mu K_P K_I K_D e_t t)`

`==>(U s/E s = K_P + K_I * s rpow -Lambda + K_D * s rpow Mu)`

`LAPLACE sut = U s`and

`LAPLACE set = E s`satisfy the requirement that the import function e(t), with the output function u(t) of the controller, satisfy the Laplace transform. Then, the fractional-order Laplace transform’s formalized definition,

`FRAC_LAPLACE,`is applied to deduce the fractional-order Laplace transform of e(t) and u(t). Finally, the fractional-order PID control transfer function could be induced as

`K_P + K_I*s rpow–Lambda + K_D*s rpow Mu`. In the verification, the main process includes:

`g ‘(0<s)/\(0 < E(s))/\ FRAC_LAPLACE/\(LAPLACE s u = U(s))/\(LAPLACE s e = E(s))/\ (u t = u_t Lambda Mu K_P K_I K_D e t) ==>`

`(U(s)/E(s) = K_P + K_I * s rpow (-Lambda) + K_D * s rpow Mu)‘;`

`e (DISCH_TAC THEN ONCE_ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC);`

`e(KNOW_TAC(--‘!(v:real).frac_cal e v 0 t t = s rpow v * E(s)‘--));`

`e(GEN_TAC);`

`e(ONCE_REWRITE_TAC[FRAC_LAPLACE]);`

`e(REPEAT STRIP_TAC);`

`e(POP_ASSUM MP_TAC);`

`e(RW_TAC real_ss[REAL_MUL_ASSOC]).`

**Theorem**

**10.**

`|-0 < s/\ (!i. 0 < a i)/\ U s <> 0/\(LAPLACE s u t = U s)`

`/\ (LAPLACE s y t = Y s) /\FRAC_LAPLACE/\ FRAC_ORDER_SYSTEM`

`==>(Y s/U s = 1/sum (0,SUC n) (\i. a i * s rpow p i))`

`U s<> 0`satisfies the requirement that

`U(s)`is not equal to zero. The antecedents

`0 < sand !i. 0 < a(i)`can deduce that the requirement

`sum (0,SUC n) (\i. a i * s rpow p i))`is not equal to zero. Therefore, they can perform a divisor. Under these conditions, the

`FRAC_ORDER_SYSTEM`can be expressed as

`1/sum (0,SUC n) (\i. a i * s rpow p i)`. In the verification, the main process includes:

`e(REPEAT STRIP_TAC);`

`e(POP_ASSUM MP_TAC);`

`e(ONCE_REWRITE_TAC[FRAC_LAPLACE]);`

`e(KNOW_TAC(--‘!(i:num).a(i) *frac_cal y (p i) 0 t t = a(i) * s rpow (p i) * Y(s)‘--));`

`e(GEN_TAC);`

`e(RW_TAC real_ss[REAL_EQ_LMUL2]);`

`e (DISCH_TAC THEN ONCE_ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC);`

`e(CONV_TAC SYM_CONV);`

`e(KNOW_TAC(--‘Y s * inv (U s) * sum (0,SUC n) (\i. a i * s rpow p i) = Y s * sum (0,SUC n) (\i. a i * s rpow p i) * inv (U s)‘--));`

`e(CONV_TAC(AC_CONV(REAL_MUL_ASSOC,REAL_MUL_COMM))).`

**Definition**

**7.**

`|-!a p n Lambda Mu K_P K_I K_D s.G_s a p n Lambda Mu K_P K_I K_D s`

`= G_f a p s n * G_c Lambda Mu K_P K_I K_D s/`

`(1 + G_f a p s n * G_c Lambda Mu K_P K_I K_D s)`

`G_f, G_c, G_s,`respectively, represent the transfer functions of fractional-order control objective, fractional-order PID, and fractional-order closed-loop system.

`G_s`can be obtained through

`G_f`and

`G_c`. To facilitate the application of this, this paper generalizes the definition of fractional-order closed-loop systems. The formalization is shown by the following:

**Theorem**

**11.**

`|-!n a s p K_P K_D K_I Lambda Mu. 0 < s/\ (!i. 0 < a i)`

`/\ u_t Lambda Mu K_P K_I K_D e_t t <> 0 ==>`

`(G_s a p n Lambda Mu K_P K_I K_D s = (K_D * s rpow (Lambda + Mu)`

`+ K_P * s rpow Lambda + K_I)/(sum (0,SUC n)`

`(\i. a i * s rpow (p i + Lambda)) +`

`K_D * s rpow (Lambda + Mu) + K_P * s rpow Lambda + K_I))`

- where
`Lambda`and`Mu`denote the integrationdegreewith differentiationdegree.`K_P, K_I,`and`K_D`represent the proportion gaining, integration coefficient, and differentiation coefficient, respectively.`s`indicates a transfer functionfor the variables. The antecedents`0 < s`and`(!i. 0 < a i)`can induce the`sum (0,SUC n) (\i. a i * s rpow p i)`as not being equal zero. Then,that`s rpow Lambda * sum (0,SUC n) (\i. a i * s rpow p i)`is not equal to zero can be provenaccording to the fact that`s rpow Lambda`is greater than zero. That`(1 + 1/sum (0,SUC n) (\i. a i * s rpow p i) * (K_P + K_I * s rpow -Lambda + K_D * s rpow Mu))`is not equal to zero can be inducedby the fact that the transfer function of the controlsystem`u_t Lambda Mu K_P K_I K_D e_t t`is not equal to zero. In the verification, the main process includes:

`e(RW_TAC real_ss[FRAC_ORDER_SYSTEM_TRANSFER,FRAC_PID_TRANSFER]);`

`e(MATCH_MP_TAC REAL_DIV_MUL2);`

`e (DISCH_TAC THEN ONCE_ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC);`

`e(KNOW_TAC(--‘(s rpow Lambda * sum (0,SUC n) (\i. a i * s rpow p i) * (1/sum (0,SUC n) (\i. a i * s rpow p i) * (K_P + K_I * s rpow -Lambda + K_D * s rpow Mu))) = (s rpow Lambda * (K_P + K_I * s rpow -Lambda + K_D * s rpow Mu))‘--));`

`e(ONCE_REWRITE_TAC[GSYM REAL_MUL_ASSOC]);`

`e(ONCE_ASM_REWRITE_TAC[]).`

## 5. Higher-Order Logic Verification

**Definition**

**8.**

`|-!x. unit x = if 0 < x then 1 else 0`

**Definition**

**9**

`|- FRAC_CAL_CONST <=> !v t c. 0 < v/\`

`(frac_cal (\t. c) v 0 t t = 0)`

**Theorem**

**12.**

`|-`∀

`t.0<t/\ FRAC_CAL_CONST ==>`

`((6.58 * frac_cal (\t. unit t) 0.8 0 t t +`

`7.99 * frac_cal (\t. unit t)0.2 0 t t + 20.915)/`

`(0.00001196 * frac_cal (\t. unit t) 3.2 0 t t +`

`0.002404 * frac_cal (\t. unit t) 2.2 0 t t +`

`0.7523 * frac_cal (\t. unit t) 1.2 0 t t +`

`6.58 * frac_cal (\t. unit t) 0.8 0 t t +`

`7.99 * frac_cal (\t. unit t) 0.2 0 t t + 20.915) = 1)`

`frac_cal`denotes the formalized definition of fractional-order calculus.

`FRAC_CAL_CONST`stands for the equation that the fractional-order calculus of a constant is 0, namely, ${}_{0}D{}_{t}^{\alpha}C=0$. Here, C is a constant. $\alpha $ stands for a fractional degree, and represents an actual number larger than 0. The system input unit is a unit-step response, which is a jump function with a value of 1 when time t is greater than 0. The antecedent of theorem t is greater than 0 and is determined by the current system, which guarantees that the unit-step response will be 1. After this, the conclusion, that, in terms of the property that the fractional-order calculus of a constant becomes zero, is drawn. The stability of the theorem is expressed as 1 and the conclusion that the theorem holds will be automatically drawn when the left side of the equation of the theorem is calculated to be 1. The result of the proof is shown in Figure 2, which is that the fractional-order control system has a steady state output. In the verification, the main process includes:

`e(RW_TAC real_ss[]);`

`e(KNOW_TAC(--‘(frac_cal (\t. unit t) 0.8 0 t t = 0)‘--));`

`e(FULL_SIMP_TAC real_ss[FRAC_CAL_UNIT]);`

`e (ONCE_ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC);`

`e (POP_ASSUM K_TAC).`

## 6. Conclusions

## Author Contributions

## Funding

## Institutional Review Board Statement

## Informed Consent Statement

## Data Availability Statement

## Conflicts of Interest

## References

- Berner, J.; Soltesz, K.; Hägglund, T.; Åström, K.J. An experimental comparison of PID autotuners. Control Eng. Pract.
**2018**, 73, 124–133. [Google Scholar] [CrossRef] - Lee, D.; Lee, S.J.; Yim, S.C. Reinforcement learning-based adaptive PID controller for DPS. Ocean Eng.
**2020**, 216, 108053. [Google Scholar] [CrossRef] - Yu, H.; Guan, Z.; Chen, T.; Yamamoto, T. Design of data-driven PID controllers with adaptive updating rules. Automatica
**2020**, 121, 109185. [Google Scholar] [CrossRef] - Wang, L.; Liu, J.; Yang, C.; Wu, D. A novel interval dynamic reliability computation approach for the risk evaluation of vibration active control systems based on PID controllers. Appl. Math. Model.
**2020**, 92, 422–446. [Google Scholar] [CrossRef] - Schiavo, M.; Padula, F.; Latronico, N.; Merigo, L.; Paltenghi, M.; Visioli, A. Performance evaluation of an optimized PID controller for propofol and remifentanil coadministration in general anesthesia. IFAC J. Syst. Control
**2020**, 15, 100121. [Google Scholar] [CrossRef] - Euzébio, T.A.; Yamashita, A.S.; Pinto, T.V.; Barros, P.R. SISO approaches for linear programming based methods for tuning decentralized PID controllers. J. Process Control
**2020**, 94, 75–96. [Google Scholar] [CrossRef] - Somefun, O.A.; Akingbade, K.; Dahunsi, F. The dilemma of PID tuning. Annu. Rev. Control
**2021**, 52, 65–74. [Google Scholar] [CrossRef] - Bassi, J.S.; Gbenga, D.E.; Afeez, A.; Opeoluwa, O.D.; Mohammed, K.B. Metaheuristic algorithms for PID controller parameters tuning: Review, approaches and open problems. Heliyon
**2022**, 8, e09399. [Google Scholar] - Timis, D.D.; Muresan, C.I.; Dulf, E.-H. Design and Experimental Results of an Adaptive Fractional-Order Controller for a Quadrotor. Fractal Fract.
**2022**, 6, 204. [Google Scholar] [CrossRef] - Xiao, M.; Tao, B.; Zheng, W.X.; Jiang, G. Fractional-Order PID Controller Synthesis for Bifurcation of Fraction-al-Order Small-World Networks. IEEE Trans. Syst. Man Cybern.-Syst.
**2021**, 51, 4334–4346. [Google Scholar] [CrossRef] - Podlubny, I. Fractional-Order Systems and Fractional-Order Controllers; UEF03-94; The Academy of Sciences Institute of Experimental Physics: Kosice, Slovakia, 1994. [Google Scholar]
- Hammad, A.; Abo-Dahab, S.M.; Abdlrahim, H.R.; Kilany, A.A. Fractional calculus of the rmoelastic p-waves reflection under influence of gravity and electromagnetic fields. Fractals
**2020**, 28, 2040037. [Google Scholar] - Guo, C.W.; Baleanu, D.; Wei, H.L. Lyapunov functions for Riemann–Liouville-like fractional difference equa-tions. Appl. Math. Comput.
**2017**, 314, 228–236. [Google Scholar] - Wu, G.-C.; Baleanu, D.; Huang, L.-L. Novel Mittag-Leffler stability of linear fractional delay difference equations with impulse. Appl. Math. Lett.
**2018**, 82, 71–78. [Google Scholar] [CrossRef] - Huang, L.-L.; Wu, G.-C.; Baleanu, D.; Wang, H.-Y. Discrete fractional calculus for interval–valued systems. Fuzzy Sets Syst.
**2020**, 404, 141–158. [Google Scholar] [CrossRef] - Muresan, C.I.; Birs, I.; Ionescu, C.; De Keyser, R. A Review of Recent Developments in Autotuning Methods for Fractional-Order Controllers. Fractal Fract.
**2022**, 6, 37. [Google Scholar] [CrossRef] - Gabriel, L.; Grandi, J.O. Trierweiler. Tuning of Fractional Order PID Controllers based on the Frequency Response Ap-proximation Method. IFAC-Pap. Online
**2019**, 52, 982–987. [Google Scholar] - WeiJia, Z.; Ying, L.; Xiao, H.W.; You, G.P.; Yang, Q.C. fractional-order PIλDμ controller design for satisfying time and frequency domain specifications simultaneously. ISA Trans.
**2017**, 68, 212–222. [Google Scholar] - Dastjerdi, A.A.; Saikumar, N.; Hassan, S.; Hossein, N. Tuning guidelines for fractional order PID controllers: Rules of thumb. Mechatronics
**2018**, 56, 26–36. [Google Scholar] [CrossRef] - Zamani, A.-A.; Tavakoli, S.; Etedali, S. Fractional order PID control design for semi-active control of smart base-isolated structures: A multi-objective cuckoo search approach. ISA Trans.
**2017**, 67, 222–232. [Google Scholar] [CrossRef] - Deep, S.A.; Sudhansu, K.M. A multi-agent based symbiotic organisms search algorithm for tuning fractional order PID controller. Measurement
**2020**, 155, 107559. [Google Scholar] - Bongulwar, M.; Patre, B. Design of PIλDμ controller for global power control of Pressurized Heavy Water Reactor. ISA Trans.
**2017**, 69, 234–241. [Google Scholar] [CrossRef] [PubMed] - Bowen, J.; Hinchey, M. Ten commandments of formal methods. Computer
**1995**, 28, 56–63. [Google Scholar] [CrossRef] - Beckert, B.; Hähnle, R.; Schmitt, P.H. Verification of Object-Oriented Software, the KeY Approach; Springer: Berlin/Heidelberg, Germany, 2007. [Google Scholar]
- Gordon, M.J.C.; Melham, T.F. Introduction to HOL: A Theorem Proving Environment for Higher Order Logic; Cambridge University Press: Cambridge, UK, 1993. [Google Scholar]
- Rushby, J. Integrated Formal Verification: Using Model Checking with Automated Abstraction, Invariant Generation, and Theorem Proving. In International SPIN Workshop on Model Checking of Software; Springer: Berlin/Heidelberg, Germany, 1999; pp. 1–11. [Google Scholar]
- Han, J.G.; Du, H.M. Formal Verification of Digital Hardware; Peking University Press: Beijing, China, 2001; 12p. [Google Scholar]
- Täubig, H.; Frese, U.; Hertzberg, C.; Lüth, C.; Mohr, S.; Vorobev, E.; Walter, D. Guaran-teeing Functional Safety: Design for Provability and Computer-Aided Verification. Auton. Robot.
**2012**, 32, 303–331. [Google Scholar] [CrossRef] - Siddique, U.; Hasan, O. Formal analysis of fractional-order systems in HOL. In Formal Methods in Computer-Aided Design; IEEE: Piscataway, NJ, USA, 2011; pp. 163–170. [Google Scholar]
- Zhao, C.; Jiang, M. Fractional-Order Systems and Higher Order Logic Formal Verification; Sciences Press: Beijing, China, 2022; pp. 86–103. [Google Scholar]
- Harrison, J. Handbook of Practical Logic and Automated Reasoning; Cambridge University Press (CUP): New York, NY, USA, 2009. [Google Scholar]
- Harrison, J. Theorem Proving with the Real Numbers; Springer: Berlin/Heidelberg, Germany, 1998. [Google Scholar]
- Sharma, R.; Gaur, P.; Mittal, A.P. Performance analysis of two-degree of freedom fractional-order PID controllers for robotic manipulator with payload. ISA Trans.
**2015**, 58, 279–291. [Google Scholar] [CrossRef] - Lazarević, M.P.; Batalov, S.A.; Latinović, T.S. Fractional PID Controller Tuned by Genetic Algorithms for a Three DOF’s Robot System Driven by DC motors. IFAC Proc. Vol.
**2013**, 46, 385–390. [Google Scholar] [CrossRef] - Alassar, A.Z.; Abuhadrous, I.M.; Elaydi, H.A. Modeling and Control of 5DOF Robot Arm Using Supervisory Control. Master’s Thesis, Faculty of Engineering, Electrical Engineering Department, Islamic University, Gaza, Palestine, 2010. [Google Scholar]

Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations. |

© 2022 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Zhao, C.; Jiang, M.; Huang, Y.
Formal Verification of Fractional-Order PID Control Systems Using Higher-Order Logic. *Fractal Fract.* **2022**, *6*, 485.
https://doi.org/10.3390/fractalfract6090485

**AMA Style**

Zhao C, Jiang M, Huang Y.
Formal Verification of Fractional-Order PID Control Systems Using Higher-Order Logic. *Fractal and Fractional*. 2022; 6(9):485.
https://doi.org/10.3390/fractalfract6090485

**Chicago/Turabian Style**

Zhao, Chunna, Murong Jiang, and Yaqun Huang.
2022. "Formal Verification of Fractional-Order PID Control Systems Using Higher-Order Logic" *Fractal and Fractional* 6, no. 9: 485.
https://doi.org/10.3390/fractalfract6090485