# BooLSPLG: A Library with Parallel Algorithms for Boolean Functions and S-Boxes for GPU

^{1}

^{2}

^{3}

^{*}

## Abstract

**:**

## 1. Introduction

## 2. Main Definitions and Preliminaries

**Definition**

**1.**

**Definition**

**2.**

## 3. GPU and CUDA

## 4. Strategies in Algorithms and Data Organization

#### 4.1. Data Organization

#### 4.2. Strategies in Algorithms

Algorithm 1: Linearity of an S-box. | |

Input: | An S-box $S\_box$ |

Output: | The linearity $Lin(S\_box)$ |

sequential | copy $S\_box$ (as it is represented) to GPU memory |

sequential | $Lin(S\_box)=0$ |

sequential | for all component Boolean functions of $S\_box$ do |

{ | |

parallel | get TT of current component function f |

parallel | calculate ${W}^{f}$ (the Walsh spectrum of f) |

parallel | compute the linearity of f |

parallel | update the value of $Lin(S\_box)$ // using one thread |

} | |

sequential | copy linearity of S-box in RAM memory |

Algorithm 2: The autocorrelation of an S-box. | |

Input: | An S-box $S\_box$ |

Output: | $AC(S\_box)$ |

sequential | copy $S\_box$ to GPU memory |

sequential | current autocorrelation value $AC(S\_box)=0$ |

sequential | for all component Boolean functions of $S\_box$ do |

{ | |

parallel | get TT of current component function f |

parallel | calculate ${W}^{f}$ and $g={\left({W}^{f}\right)}^{2}$ |

parallel | compute ${2}^{-n}{W}^{g}$ |

parallel | update the value of $AC(S\_box)$ |

} | |

sequential | copy $AC(S\_box)$ in RAM memory |

Algorithm 3: The differential uniformity of an S-box | |

Input: | An S-box $S\_box$ |

Output: | $\delta (S\_box)$ |

sequential | copy $S\_box$ to GPU memory |

sequential | $\delta (S\_box)={2}^{n}$ |

sequential | for all $\Delta \in {\mathbb{F}}_{2}^{n}$ do |

{ | |

parallel | compute $DD{T}_{\Delta}(S\_box)$ |

parallel | find current $\delta (S\_box)$ |

} | |

sequential | copy $\delta (S\_box)$ in RAM memory |

## 5. Experimental Results

## 6. Conclusions and Future Work

## Author Contributions

## Funding

## Data Availability Statement

## Acknowledgments

## Conflicts of Interest

## Abbreviations

BoolSPLG | Boolean functions and S-box Parallel Library for GPU |

SIMD | Single Instruction, Multiple Data |

CUDA | Compute Unified Device Architecture |

GPU | Graphic Processing Unit |

CPU | Central Processing Unit |

ALU | Arithmetic-Logic Unit |

LAT | Linear Approximation Table |

TT | Truth Table |

PTT | Polarity Truth Table |

ANF | Algebraic Normal Form |

FWT | Fast Walsh Transform |

FMT | Fast Möbius Transform |

DDT | Difference Distribution Table |

ACT | Autocorrelation Table |

ADT | Algebraic Degree Table |

## References

- Shetty, V.S.; Anusha, R.; Dileep Kumar, M.J.; Hegde, P. A survey on performance analysis of block cipher algorithms. In Proceedings of the 2020 International Conference on Inventive Computation Technologies (ICICT), Coimbatore, India, 26–28 February 2020; pp. 167–174. [Google Scholar]
- Kelly, M.; Kaminsky, A.; Kurdziel, M.; Łukowiak, M.; Radziszowski, S. Customizable sponge-based authenticated encryption using 16-bit s-boxes. In Proceedings of the MILCOM 2015-2015 IEEE Military Communications Conference, Tampa, FL, USA, 26–28 October 2015; pp. 43–48. [Google Scholar]
- Canteaut, A.; Duval, S.; Leurent, G.; Naya-Plasencia, M.; Perrin, L.; Pornin, T.; Schrottenloher, A. Saturnin: A suite of lightweight symmetric algorithms for post-quantum security. IACR Trans. Symmetric Cryptol.
**2020**, 2020, 160–207. [Google Scholar] [CrossRef] - Matsui, M. New block encryption algorithm MISTY. In Proceedings of the International Workshop on Fast Software Encryption; Springer: Berlin/Heidelberg, Germany, 1997; pp. 54–68. [Google Scholar]
- Georgi, I.; Nikolay, N.; Svetla, N. Reversed Genetic Algorithms for Generation of Bijective S-boxes with Good Cryptographic Properties. IACR Cryptol. ePrint Arch.
**2014**, 2014, 801. [Google Scholar] - Beauchamp, K. Applications of Walsh and Related Functions. With an Introduction to Sequence Theory; Microelectronics and Signal Processing Series; Academic Press, Inc.: London, UK; Orlando, FL, USA, 1985; p. xvi+308. ISBN 0-12-084180-0. [Google Scholar]
- Bakoev, V. A method for fast computing the algebraic degree of boolean functions. In Proceedings of the 21st International Conference on Computer Systems and Technologies, Ruse, Bulgaria, 19–20 June 2020; pp. 141–147. [Google Scholar]
- Carlet, C.; Crama, Y.; Hammer, P.L. Chapter Eight—Boolean Functions for Cryptography and Error-Correcting Codes. In Boolean Models ad Methods Mathemaics, Computer Science, and Engineering; Cambridge University Press: Cambridge, UK, 2010. [Google Scholar]
- Sanders, J.; Kandrot, E. CUDA by Example: An Introduction to General-Purpose GPU Programming; Addison-Wesley Professional: Boston, MA, USA, 2010. [Google Scholar]
- Jeon, W.; Ko, G.; Lee, J.; Lee, H.; Ha, D.; Ro, W.W. Chapter Six—Deep learning with GPUs. In Hardware Accelerator Systems for Artificial Intelligence and Machine Learning; Advances in Computers; Kim, S., Deka, G.C., Eds.; Elsevier: Amsterdam, The Netherlands, 2021; Volume 122, pp. 167–215. [Google Scholar] [CrossRef]
- Xie, Z.; Kwak, A.S.; George, E.; Dozal, L.W.; Van, H.; Jah, M.; Furfaro, R.; Jansen, P. Extracting Space Situational Awareness Events from News Text. arXiv
**2022**, arXiv:2201.05721. [Google Scholar] - Stone, J.E.; Phillips, J.C.; Freddolino, P.L.; Hardy, D.J.; Trabuco, L.G.; Schulten, K. Accelerating molecular modeling applications with graphics processors. J. Comput. Chem.
**2007**, 28, 2618–2640. [Google Scholar] [CrossRef] [PubMed][Green Version] - Bikov, D.; Bouyukliev, I.; Bouyuklieva, S. Bijective S-boxes of different sizes obtained from quasi-cyclic codes. J. Algebra Comb. Discret. Struct. Appl.
**2019**, 6, 123–134. [Google Scholar] [CrossRef] - Zimmermann, P.; Casamayou, A.; Cohen, N.; Connan, G.; Dumont, T.; Fousse, L.; Maltey, F.; Meulien, M.; Mezzarobba, M.; Pernet, C.; et al. Computational mathematics with SageMath; SIAM: Philadelphia, PA, USA, 2018. [Google Scholar]
- Higham, D.J.; Higham, N.J. MATLAB Guide; SIAM: Philadelphia, PA, USA, 2016. [Google Scholar]
- Álvarez-Cubero, J.A.; Zufiria, P.J. Algorithm 959: VBF: A library of C++ classes for vector Boolean functions in cryptography. ACM Trans. Math. Softw. (TOMS)
**2016**, 42, 1–22. [Google Scholar] [CrossRef][Green Version] - Sasaki, Y.; Ling, S.; Guo, J.; Bao, Z.; Bao, Z.; Guo, J.; Ling, S.; Sasaki, Y.; Commons License, C. PEIGEN—A platform for evaluation, implementation, and generation of S-boxes. IACR Trans. Symmetric Cryptol.
**2019**, 2019, 330–394. [Google Scholar] - Picek, S.; Batina, L.; Jakobović, D.; Ege, B.; Golub, M. S-box, SET, match: A toolbox for S-box analysis. In Proceedings of the IFIP International Workshop on Information Security Theory and Practice; Springer: Berlin/Heidelberg, Germany, 2014; pp. 140–149. [Google Scholar]
- Barrachina, S.; Castillo, M.; Igual, F.D.; Mayo, R.; Quintana-Orti, E.S. Evaluation and tuning of the level 3 CUBLAS for graphics processors. In Proceedings of the 2008 IEEE International Symposium on Parallel and Distributed Processing, Miami, FL, USA, 14–18 April 2008; pp. 1–8. [Google Scholar]
- Naumov, M.; Chien, L.; Vandermersch, P.; Kapasi, U. Cusparse library. In Proceedings of the GPU Technology Conference, San Jose, CA, USA, 23 September 2010. [Google Scholar]
- Lobeiras, J.; Amor, M.; Doallo, R. BPLG: A tuned butterfly processing library for GPU architectures. Int. J. Parallel Program.
**2015**, 43, 1078–1102. [Google Scholar] [CrossRef] - Vasilache, N.; Johnson, J.; Mathieu, M.; Chintala, S.; Piantino, S.; LeCun, Y. Fast convolutional nets with fbfft: A GPU performance evaluation. arXiv
**2014**, arXiv:1412.7580. [Google Scholar] - Khadem, B.; Ghasemi, R. Improved algorithms in parallel evaluation of large cryptographic S-boxes. Int. J. Parallel Emergent Distrib. Syst.
**2020**, 35, 461–472. [Google Scholar] [CrossRef] - Kim, G.; Jeon, Y.; Kim, J. Speeding up LAT: Generating a Linear Approximation Table Using a Bitsliced Implementation. IEEE Access
**2022**, 10, 4919–4923. [Google Scholar] [CrossRef] - Preneel, B.; BRAEKEN, A. Cryptographic Properties of Boolean Functions and S-Boxes; Departement elektrotechniek (ESAT): Leuven, Belgium, 2006. [Google Scholar]
- Chabaud, F.; Vaudenay, S. Links between differential and linear cryptanalysis. In Proceedings of the Workshop on the Theory and Application of of Cryptographic Techniques; Springer: Berlin/Heidelberg, Germany, 1994; pp. 356–365. [Google Scholar]
- Bakoev, V. Fast computing the algebraic degree of Boolean functions. In Proceedings of the Algebraic Informatics: 8th International Conference, CAI 2019, Niš, Serbia, 30 June–4 July 2019; Springer: Berlin/Heidelberg, Germany, 2019; pp. 50–63. [Google Scholar]
- Good, I.J. The interaction algorithm and practical Fourier analysis. J. R. Stat. Soc. Ser. B Methodol.
**1958**, 20, 361–372. [Google Scholar] [CrossRef] - Hughes, C.J. Single-instruction multiple-data execution. Synth. Lect. Comput. Archit.
**2015**, 10, 1–121. [Google Scholar] - Joux, A. Algorithmic Cryptanalysis; Chapman and Hall/CRC: Boca Raton, FL, USA, 2009. [Google Scholar]
- Zhang, X.M.; Zheng, Y.; Imai, H. Relating differential distribution tables to other properties of of substitution boxes. Des. Codes Cryptogr.
**2000**, 19, 45–63. [Google Scholar] [CrossRef] - Bikov, D.; Bouyukliev, I. Parallel fast Walsh transform algorithm and its implementation with CUDA on GPUs. Cybern. Inf. Technol.
**2018**, 18, 21–43. [Google Scholar] [CrossRef][Green Version] - Bikov, D.; Bouyukliev, I. Parallel fast Möbius (Reed-Muller) transform and its implementation with CUDA on GPUs. In Proceedings of the International Workshop on Parallel Symbolic Computation, Kaiserslautern, Germany, 23–24 July 2017; pp. 1–6. [Google Scholar]

Environment: | Platform | |
---|---|---|

CPU | Intel Xeon E5-2640, 2.50 GHz | |

Memory | 48 GB DDR3 1333 MHz | |

OS | Windows 7, 64-bit | |

IDE/Compiler | MSVC 2019 | |

CUDA SDK | 10.2 | |

GPU Driver | V 471.96 | |

GPU | Nvidia TITAN X (Pascal) | GeForce GTX TITAN |

Device 0 | Device 1 | |

Architecture | Pascal | Kepler |

CUDA Cores | 3584 | 2688 |

Boost Clock | 1531 MHz | 876 MHz |

Memory Speed | 10 Gbps | 6 Gbps |

Global Memory | 12 GB GDDR5X | 6 GB GDDR5 |

Memory Bandwidth | 480 (GB/s) | 288.38 (GB/s) |

Size | CPU (ms) | Device 0 (ms) | CPU vs. Dev 0 | Device 1 (ms) | CPU vs. Dev 1 |
---|---|---|---|---|---|

${2}^{8}$ (256) | 0.863 | 0.223 | ×3.86 | 0.14336 | ×6 |

${2}^{9}$ (512) | 7.654 | 0.340 | ×22.51 | 0.3576 | ×21.4 |

${2}^{10}$ (1024) | 15.855 | 0.318 | ×49.85 | 1.1442 | ×13.8 |

${2}^{11}$ (2048) | 68.343 | 62.774 | ×1 | 72 | ×1 |

${2}^{12}$ (4096) | 314.927 | 149.562 | ×2.1 | 186.106 | ×1.68 |

${2}^{13}$ (8192) | 1257.97 | 287.688 | ×4.83 | 347.72 | ×3.6 |

${2}^{14}$ (16,384) | 5686.84 | 622.29 | ×9.13 | 759.53 | ×7.5 |

${2}^{15}$ (32,768) | 24,083.8 | 1239.54 | ×19.42 | 2141.55 | ×11.2 |

${2}^{16}$ (65,536) | 99,800.3 | 2446.03 | ×40.8 | 6289.8 | ×15.86 |

${2}^{17}$ (131,072) | 442,678 | 6165.59 | ×71.8 | 22,772 | ×19.43 |

${2}^{18}$ (262,144) | 1,677,921 | 22,029.27 | ×76.1 | 90,089 | ×18.62 |

${2}^{19}$ (524,288) | 7,562,247 | 90,786.66 | ×83.29 | 375,519 | ×20.13 |

${2}^{20}$ (1,048,576) | 29,638,868 | 418,942 | ×70.7 | 1,618,402 | ×18.3 |

Size | CPU (ms) | Device 0 (ms) | CPU vs. Dev 0 | Device 1 (ms) | CPU vs. Dev 1 |
---|---|---|---|---|---|

${2}^{8}$ (256) | 2.020 | 0.206 | ×9.8 | 0.319 | ×6.3 |

${2}^{9}$ (512) | 14.212 | 0.435 | ×32.67 | 0.393 | ×36.13 |

${2}^{10}$ (1024) | 37.940 | 0.463 | ×81.94 | 1.462 | ×25.95 |

${2}^{11}$ (2048) | 185.673 | 132.284 | ×1.4 | 144.06 | ×1.28 |

${2}^{12}$ (4096) | 771.527 | 209.130 | ×3.68 | 253.18 | ×3 |

${2}^{13}$ (8192) | 3142.98 | 503.77 | ×6.23 | 418.54 | ×7.5 |

${2}^{14}$ (16,384) | 13,555.2 | 866.02 | ×15.65 | 1094.63 | ×12.3 |

${2}^{15}$ (32,768) | 57,324.5 | 1931.21 | ×29.68 | 3189.85 | ×18 |

${2}^{16}$ (65,536) | 238,216.4 | 3813.45 | ×62.46 | 9621.8 | ×24.76 |

${2}^{17}$ (131,072) | 1,060,294 | 9396.38 | ×112.84 | 34,810.46 | ×30.45 |

${2}^{18}$ (262,144) | 3,832,308 | 33,814.94 | ×113.33 | 133,629.15 | ×28.67 |

${2}^{19}$ (524,288) | 16,860,299 | 138,108.15 | ×122.1 | 566,914 | ×29.7 |

${2}^{20}$ (1,048,576) | 68,227,870 | 629,515 | ×108.38 | 2,411,828 | ×28.2 |

Size | CPU (ms) | Device 0 (ms) | CPU vs. Dev 0 | Device 1 (ms) | CPU vs. Dev 1 |
---|---|---|---|---|---|

${2}^{8}$ (256) | 0.282 | 0.208 | ×1 | 0.136 | ×2 |

${2}^{9}$ (512) | 1.908 | 0.432 | ×4.416 | 0.351 | ×5.4 |

${2}^{10}$ (1024) | 3.591 | 0.366 | ×9.811 | 1.053 | ×3.4 |

${2}^{11}$ (2048) | 14.269 | 0.705 | ×20.23 | 1.313 | ×10.8 |

${2}^{12}$ (4096) | 69.932 | 1.710 | ×40.89 | 2.914 | ×24 |

${2}^{13}$ (8192) | 245.719 | 5.773 | ×42.56 | 11.27 | ×22 |

${2}^{14}$ (16,384) | 998.174 | 21.022 | ×47.48 | 37.64 | ×27 |

${2}^{15}$ (32,768) | 4059.71 | 990.88 | ×4.1 | 1497.6 | ×2.7 |

${2}^{16}$ (65,536) | 18,307.9 | 1924.91 | ×9.5 | 4345 | ×4.2 |

${2}^{17}$ (131,072) | 86,983.9 | 4206.78 | ×20.68 | 14,988.47 | ×5.8 |

${2}^{18}$ (262,144) | 453,136 | 14,319.73 | ×31.64 | 55,269.61 | ×8.2 |

${2}^{19}$ (524,288) | 1,925,444 | 61,572 | ×31.27 | 283,692 | ×6.7 |

${2}^{20}$ (1,048,576) | 9,312,785 | 730,660 | ×12.7 | 1,531,534 | ×6 |

Size | CPU (ms) | Device 0 | Device 0 | CPU vs. Dev0 | CPU vs. Dev0 | Device 1 | Device 1 | CPU vs. Dev1 | CPU vs. Dev1 |
---|---|---|---|---|---|---|---|---|---|

Base (ms) | Bitwise | Base | Bitwise | Base (ms) | Bitwise | Base | Bitwise | ||

${2}^{8}$ | 1.127 | 0.122 | 0.115 | ×9.23 | ×9.8 | 0.3193 | 0.2692 | ×3.5 | ×14.1 |

${2}^{9}$ | 10.099 | 0.201 | 0.202 | ×49.9 | ×49 | 0.7321 | 0.3087 | ×13.6 | ×32.46 |

${2}^{10}$ | 20.396 | 0.318 | 0.142 | ×64.1 | ×143.6 | 1.1814 | 0.7277 | ×17.2 | ×28 |

${2}^{11}$ | 102.390 | 76.042 | 12.447 | ×1.3 | ×8.2 | 78.66 | 23.71 | ×1.3 | ×4.3 |

${2}^{12}$ | 369.589 | 162.987 | 28.963 | ×2.2 | ×12.7 | 220.58 | 42.9 | ×1.6 | ×8.6 |

${2}^{13}$ | 1754.26 | 307.870 | 54.385 | ×5.69 | ×32.2 | 366 | 65.68 | ×4.8 | ×26.9 |

${2}^{14}$ | 6822.06 | 720.525 | 279.5 | ×9.4 | ×24.45 | 822.66 | 767.35 | ×8.3 | ×8.9 |

${2}^{15}$ | 28,395.3 | 1410.75 | 489.42 | ×20.1 | ×58 | 2221 | 2658.13 | ×12.78 | ×10.6 |

${2}^{16}$ | 117,070.8 | 2961.87 | 1593.99 | ×39.5 | ×73.5 | 6400 | 9964 | ×18.29 | ×11.74 |

${2}^{17}$ | 492,150.2 | 6421.09 | 6470 | ×76.6 | ×76 | 22,974 | 26,110 | ×21.42 | ×18.84 |

${2}^{18}$ | 1,699,950 | 22,824.7 | 12,011.3 | ×74.48 | ×141.53 | 84,706 | 56,085 | ×20 | ×30.1 |

${2}^{19}$ | 7,327,083 | 90,603.8 | 32,384.5 | ×80.87 | ×226.2 | 356,180 | 122,500 | ×20.5 | ×59.8 |

${2}^{20}$ | 29,481,099 | 416,376 | 83,943 | ×70.8 | ×351.2 | 1,530,321 | 478,612 | ×19.2 | ×61.59 |

S-Boxes | Lin | nl | $\mathit{\delta}$ | $\mathit{deg}\left(\mathit{S}\right)$ (max) | $\mathit{AC}\left(\mathit{S}\right)$ | Number |
---|---|---|---|---|---|---|

QCS-boxes, $n=16$ | ||||||

C2, ${M}_{1}$, m = 13,107, r = 5 | 512 | 32,512 | 4 | 15 | 512 | 5 |

S-boxes, random | 1532 | 32,002 | 22 | 15 | 2344, 2248 | 2 |

$n=16$ | 1532 | 32,002 | 20 | 15 | 2568–2208 | 34 |

1532 | 32,002 | 18 | 15 | 2432–2224 | 39 | |

S-boxes, random | 1528 | 32,004 | 20 | 15 | 2504–2232 | 23 |

$n=16$ | 1528 | 32,004 | 18 | 15 | 2416–2264 | 17 |

S-boxes, random | 1524 | 32,006 | 20 | 15 | 2512–2240 | 8 |

$n=16$ | 1524 | 32,006 | 18 | 15 | 2392–2216 | 7 |

S-boxes, random | 1520 | 32,008 | 20 | 15 | 2288, 2280, 2184 | 3 |

$n=16$ | 1520 | 32,008 | 18 | 15 | 2352–2264 | 5 |

S-boxes, random | 1516 | 32,010 | 20 | 15 | 2280 | 1 |

$n=16$ | 1516 | 32,010 | 18 | 15 | 2312 | 1 |

Lin | $\mathit{\delta}$ | deg | AC | ||||||||
---|---|---|---|---|---|---|---|---|---|---|---|

Size | Sage | SET | BoolSPLG | Sage | SET | BoolSPLG | Sage | SET | BoolSPLG | SET | BoolSPLG |

${2}^{8}$ | 0.66 s | 2 ms | 0.22 ms | 0.096 s | 0.4 ms | 0.2 ms | 0.12 s | 3 ms | 0.1 ms | 2 ms | 0.2 ms |

${2}^{9}$ | 1.94 s | 5 ms | 0.34 ms | 0.35 s | 2 ms | 0.4 ms | 0.14 s | 18 ms | 0.2 ms | 7 ms | 0.4 ms |

${2}^{10}$ | 7.2 s | 39 ms | 0.32 ms | 1.44 s | 8 ms | 0.3 ms | 0.18 s | 52 ms | 0.1 ms | 48 ms | 0.4 ms |

${2}^{11}$ | 26.3 s | 246 ms | 62 ms | 6.2 s | 83 ms | 0.7 ms | 0.22 s | 374 ms | 12 ms | 0.4 s | 132 ms |

${2}^{12}$ | 99 s | 1.5 s | 149 ms | 29 s | 0.5 s | 1.7 ms | 0.39 s | 2.3 s | 28 ms | 2.7 s | 209 ms |

${2}^{13}$ | N/A | 7.9 s | 284 ms | N/A | 2.1 s | 5.7 ms | 1 s | 12.4 s | 54 ms | 14 s | 503 ms |

${2}^{14}$ | N/A | 66 s | 662 ms | N/A | 9.9 s | 21 ms | 1.6 s | 91 s | 279 ms | 102 s | 866 ms |

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |

© 2023 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**

Bikov, D.; Bouyukliev, I.; Dzhumalieva-Stoeva, M.
BooLSPLG: A Library with Parallel Algorithms for Boolean Functions and S-Boxes for GPU. *Mathematics* **2023**, *11*, 1864.
https://doi.org/10.3390/math11081864

**AMA Style**

Bikov D, Bouyukliev I, Dzhumalieva-Stoeva M.
BooLSPLG: A Library with Parallel Algorithms for Boolean Functions and S-Boxes for GPU. *Mathematics*. 2023; 11(8):1864.
https://doi.org/10.3390/math11081864

**Chicago/Turabian Style**

Bikov, Dushan, Iliya Bouyukliev, and Mariya Dzhumalieva-Stoeva.
2023. "BooLSPLG: A Library with Parallel Algorithms for Boolean Functions and S-Boxes for GPU" *Mathematics* 11, no. 8: 1864.
https://doi.org/10.3390/math11081864