Integer Arithmetic Research Articles

Mathematics MOVES Me—Digital Solutions for Co-ordinating Enactive and Symbolic Resources: The Case of Positive and Negative Integer Arithmetic

Mathematics MOVES Me—Digital Solutions for Co-ordinating Enactive and Symbolic Resources: The Case of Positive and Negative Integer Arithmetic

A Secure Authentication Scheme with Local Differential Privacy in Edge Intelligence-Enabled VANET

Edge intelligence is a technology that integrates edge computing and artificial intelligence to achieve real-time and localized model generation. Thus, users can receive more precise and personalized services in vehicular ad hoc networks (VANETs) using edge intelligence. However, privacy and security challenges still exist, because sensitive data of the vehicle user is necessary for generating a high-accuracy AI model. In this paper, we propose an authentication scheme to preserve the privacy of user data in edge intelligence-enabled VANETs. The proposed scheme can establish a secure communication channel using fuzzy extractor, elliptic curve cryptography (ECC), and physical unclonable function (PUF) technology. The proposed data upload process can provide privacy of the data using local differential privacy and symmetric key encryption. We validate the security robustness of the proposed scheme using informal analysis, the Real-Or-Random (ROR) model, and the Scyther tool. Moreover, we evaluate the computation and communication efficiency of the proposed and related schemes using Multiprecision Integer and Rational Arithmetic Cryptographic Library (MIRACL) software development kit (SDK). We simulate the practical deployment of the proposed scheme using network simulator 3 (NS-3). Our results show that the proposed scheme has a performance improvement of 10∼48% compared to the state-of-the-art research. Thus, we can demonstrate that the proposed scheme provides comprehensive and secure communication for data management in edge intelligence-enabled VANET environments.

Provably Secure and Area-Efficient Modular Addition over Boolean Shares

Several cryptographic schemes, including lattice-based cryptography and the SHA-2 family of hash functions, involve both integer arithmetic and Boolean logic. Each of these classes of operations, considered separately, can be efficiently implemented under the masking countermeasure when resistance against vertical attacks is required. However, protecting interleaved arithmetic and logic operations is much more expensive, requiring either additional masking conversions to switch between masking schemes, or implementing arithmetic functions as nonlinear operations over a Boolean masking. Both solutions can be achieved by providing masked arithmetic addition over Boolean shares, which is an operation with relatively long latency and usually high area utilization in hardware. A further complication arises when the arithmetic performed by the scheme is over a prime modulus, which is common in lattice-based cryptography. In this work, we propose a first-order masked implementation of arithmetic addition over Boolean shares occupying a very small area, while still having reasonable latency. Our proposal is specifically tuned for efficient addition and subtraction modulo an arbitrary integer, but it can also be configured at runtime for power-of-two arithmetic. To the best of our knowledge, we propose the first such construction whose security is formally proven in the glitch+transition-robust probing model.

Weight-adaptive joint mixed-precision quantization and pruning for neural network-based equalization in short-reach direct detection links.

Neural network (NN)-based equalizers have been widely applied for dealing with nonlinear impairments in intensity-modulated direct detection (IM/DD) systems due to their excellent performance. However, the computational complexity (CC) is a major concern that limits the real-time application of NN-based receivers. In this Letter, we propose, to our knowledge, a novel weight-adaptive joint mixed-precision quantization and pruning approach to reduce the CC of NN-based equalizers, where only integer arithmetic is taken into account instead of floating-point operations. The NN connections are either directly cutoff or represented by a proper number of quantization bits by weight partitioning, leading to a hybrid compressed sparse network that computes much faster and consumes less hardware resources. The proposed approach is verified in a 50-Gb/s 25-km pulse amplitude modulation (PAM)-4 IM/DD link using a directly modulated laser (DML) in the C-band. Compared with the traditional fully connected NN-based equalizer operated with standard floating-point arithmetic, about 80% memory can be saved at a minimum network size without degrading the system performance. Quantization is also shown to be more suitable to over-parameterized NN-based equalizers compared with NNs selected at a minimum size.

A blueprint for precise and fault-tolerant analog neural networks

Analog computing has reemerged as a promising avenue for accelerating deep neural networks (DNNs) to overcome the scalability challenges posed by traditional digital architectures. However, achieving high precision using analog technologies is challenging, as high-precision data converters are costly and impractical. In this work, we address this challenge by using the residue number system (RNS) and composing high-precision operations from multiple low-precision operations, thereby eliminating the need for high-precision data converters and information loss. Our study demonstrates that the RNS-based approach can achieve ≥99% FP32 accuracy with 6-bit integer arithmetic for DNN inference and 7-bit for DNN training. The reduced precision requirements imply that using RNS can achieve several orders of magnitude higher energy efficiency while maintaining the same throughput compared to conventional analog hardware with the same precision. We also present a fault-tolerant dataflow using redundant RNS to protect the computation against noise and errors inherent within analog hardware.

Towards Efficient Verification of Quantized Neural Networks

Quantization replaces floating point arithmetic with integer arithmetic in deep neural network models, providing more efficient on-device inference with less power and memory. In this work, we propose a framework for formally verifying the properties of quantized neural networks. Our baseline technique is based on integer linear programming which guarantees both soundness and completeness. We then show how efficiency can be improved by utilizing gradient-based heuristic search methods and also bound-propagation techniques. We evaluate our approach on perception networks quantized with PyTorch. Our results show that we can verify quantized networks with better scalability and efficiency than the previous state of the art.

Generalized Matrix Spectral Factorization with Symmetry and Construction of Quasi-Tight Framelets over Algebraic Number Fields

The rational field Q is highly desired in many applications. Algorithms using the rational number field Q algebraic number fields use only integer arithmetics and are easy to implement. Therefore, studying and designing systems and expansions with coefficients in Q or algebraic number fields is particularly interesting. This paper discusses constructing quasi-tight framelets with symmetry over an algebraic field. Compared to tight framelets, quasi-tight framelets have very similar structures but much more flexibility in construction. Several recent papers have explored the structure of quasi-tight framelets. The construction of symmetric quasi-tight framelets directly applies the generalized spectral factorization of 2×2 matrices of Laurent polynomials with specific symmetry structures. We adequately formulate the latter problem and establish the necessary and sufficient conditions for such a factorization over a general subfield F of C, including algebraic number fields as particular cases. Our proofs of the main results are constructive and thus serve as a guideline for construction. We provide several examples to demonstrate our main results.

SPIMulator: A Spintronic Processing-In-Memory Simulator for Racetracks

In-memory processing is becoming a popular method to alleviate the memory bottleneck of the von Neumann computing model. With the goal of improving both latency and energy cost associated with such in-memory processing, emerging non-volatile memory technologies, such as Spintronic magnetic memory, are of particular interest as they can provide a near-SRAM read/write performance and eliminate nearly all static energy without experiencing any endurance limitations. Spintronic Racetrack Memory (RM) further addresses density concerns of spin-transfer torque memory (STT-MRAM). Moreover, it has recently been demonstrated that portions of RM nanowires can function as a polymorphic gate, which can be leveraged to implement multi-operand bulk bitwise operations. With more complex control, they can also be leveraged to build arithmetic integer and floating point processing in memory (PIM) primitives. This paper proposes SPIMulator, a Spintronic PIM sim ulator that can simulate the storage and PIM architecture of executing PIM commands in Racetrack memory. SPIMulator functionally models the polymorphic gate properties recently proposed for Racetrack memory, which allows transverse access that determines the number of ‘1’s in a segment of each Racetrack nanowire. From this simulation, SPIMulator can report real-time performance statistics such as cycle count and energy. Thus, SPIMulator simulates the multi-operand bit-wise logic operations recently proposed and can be easily extended to implement new PIM operations as they are developed. Due to the functional nature of SPIMulator, it can serve as a programming environment that allows development of PIM-based codes for verification of new acceleration algorithms. We demonstrate the value of SPIMulator through the modeling and estimations of performance and energy consumption of a variety of example applications, including the Advanced Encryption Standard (AES) for encryption primarily based on logical and look-up operations; multiplication of matrices, a frequent requirement in scientific, signal processing, and machine learning algorithms; and bitmap indices a common search table employed for database lookups.

Locally Tight Programs

Abstract Program completion is a translation from the language of logic programs into the language of first-order theories. Its original definition has been extended to programs that include integer arithmetic, accept input, and distinguish between output predicates and auxiliary predicates. For tight programs, that generalization of completion is known to match the stable model semantics, which is the basis of answer set programming. We show that the tightness condition in this theorem can be replaced by a less restrictive “local tightness” requirement. From this fact we conclude that the proof assistant anthem-p2p can be used to verify equivalence between locally tight programs.

Parikh’s Theorem Made Symbolic

Parikh’s Theorem is a fundamental result in automata theory with numerous applications in computer science. These include software verification (e.g. infinite-state verification, string constraints, and theory of arrays), verification of cryptographic protocols (e.g. using Horn clauses modulo equational theories) and database querying (e.g. evaluating path-queries in graph databases), among others. Parikh’s Theorem states that the letter-counting abstraction of a language recognized by finite automata or context-free grammars is definable in Linear Integer Arithmetic (a.k.a. Presburger Arithmetic). In fact, there is a linear-time algorithm computing existential Presburger formulas capturing such abstractions, which enables an efficient analysis via SMT-solvers. Unfortunately, real-world applications typically require large alphabets (e.g. Unicode, containing a ‍million of characters) — which are well-known to be not amenable to explicit treatment of the alphabets — or even worse infinite alphabets. Symbolic automata have proven in the last decade to be an effective algorithmic framework for handling large finite or even infinite alphabets. A symbolic automaton employs an effective boolean algebra, which offers a symbolic representation of character sets (i.e. in terms of predicates) and often lends itself to an exponentially more succinct representation of a language. Instead of letter-counting, Parikh’s Theorem for symbolic automata amounts to counting the number of times different predicates are satisfied by an input sequence. Unfortunately, naively applying Parikh’s Theorem from classical automata theory to symbolic automata yields existential Presburger formulas of exponential size. In this paper, we provide a new construction for Parikh’s Theorem for symbolic automata and grammars, which avoids this exponential blowup: our algorithm computes an existential formula in polynomial-time over (quantifier-free) Presburger and the base theory. In fact, our algorithm extends to the model of parametric symbolic grammars, which are one of the most expressive models of languages over infinite alphabets. We have implemented our algorithm and show it can be used to solve string constraints that are difficult to solve by existing solvers.

Ramsey Quantifiers in Linear Arithmetics

We study Satisfiability Modulo Theories (SMT) enriched with the so-called Ramsey quantifiers, which assert the existence of cliques (complete graphs) in the graph induced by some formulas. The extended framework is known to have applications in proving program termination (in particular, whether a transitive binary predicate is well-founded), and monadic decomposability of SMT formulas. Our main result is a new algorithm for eliminating Ramsey quantifiers from three common SMT theories: Linear Integer Arithmetic (LIA), Linear Real Arithmetic (LRA), and Linear Integer Real Arithmetic (LIRA). In particular, if we work only with existentially quantified formulas, then our algorithm runs in polynomial time and produces a formula of linear size. One immediate consequence is that checking well-foundedness of a given formula in the aforementioned theory defining a transitive predicate can be straightforwardly handled by highly optimized SMT-solvers. We show also how this provides a uniform semi-algorithm for verifying termination and liveness with completeness guarantee (in fact, with an optimal computational complexity) for several well-known classes of infinite-state systems, which include succinct timed systems, one-counter systems, and monotonic counter systems. Another immediate consequence is a solution to an open problem on checking monadic decomposability of a given relation in quantifier-free fragments of LRA and LIRA, which is an important problem in automated reasoning and constraint databases. Our result immediately implies decidability of this problem with an optimal complexity (coNP-complete) and enables exploitation of SMT-solvers. It also provides a termination guarantee for the generic monadic decomposition algorithm of Veanes et al. for LIA, LRA, and LIRA. We report encouraging experimental results on a prototype implementation of our algorithms on micro-benchmarks.

IEEE-754 Precision- p base-β Arithmetic Implemented in Binary

We show how an IEEE-754 conformant precision- p base-β arithmetic can be implemented based on some binary floating-point and/or integer arithmetic. This includes the four basic operations and square root subject to the five IEEE-754 rounding modes, namely the nearest roundings with roundTiesToEven and roundTiesToAway, the directed roundings downwards and upwards, as well as rounding towards zero. Exceptional values like ∞ of NaN are covered according to the IEEE-754 arithmetic standard. The results of the precision- p base-β operations are computed using some underlying precision- q binary arithmetic. We distinguish two cases. When using a precision- q binary integer arithmetic, the base-β precision p is limited for all operations by β 2 p ≤ 2 q , whereas using a precision- q binary floating-point arithmetic imposes stronger limits on the base-β precision, namely β 2 p ≤ 2 q for addition and multiplication, β 2 p ≤ 2 q-1 for division and β 2 p ≤ 2 q -3 for the square root. Those limitations cannot be improved. The algorithms are implemented in a Matlab/Octave flbeta-toolbox with the choice of using uint64 or binary64 as underlying arithmetic. The former allows larger precisions, the latter is advantageous for the square root, whereas computing times are similar. The flbeta-toolbox offers precision- p base-β scalar, vector and matrix operations including sparse matrices as well as corresponding interval operations. The base β can be chosen in the range β ∊ [2,64]. The flbeta-toolbox will be part of Version 13 of INTLAB [ 18 ], the Matlab/Octave toolbox for reliable computing.

A smart contract-based robotic surgery authentication system for healthcare using 6G-Tactile Internet

An intelligent robotic surgical system, utilizing the capabilities of 6G-enabled Tactile Internet (TI) and blockchain technology, holds remarkable promise for providing remote healthcare services in real-time. This system has the potential to deliver high-quality and reliable healthcare services with a focus on responsiveness. It holds considerable benefits for society, particularly in terms of achieving exceptionally accurate surgical diagnoses. Yet, contemporary robotic surgery systems face challenges such as security, privacy, reliability, latency, and the costly implications of blockchain-based storage. These issues curtail the immediate global implementation of tactile internet in surgical procedures. In order to address the previously mentioned concerns, we present a new solution referred to as “A Smart Contract-Based Robotic Surgery Authentication System for Healthcare Using 6G-Tactile Internet”. It is an innovative framework for intelligent and blockchain-driven tactile internet. By incorporating a smart contract, we aim to effectively tackle the challenges associated with security, privacy, and the transparency. The introduced approach also effectively thwarts the implementation of malicious commands that might be transmitted by an unauthorized individual. The utilization of the 6G communication channel substantially reduces the latency challenges associated with exchanging surgical commands. The security of the suggested protocol is formally showcased through the utilization of the Real-Or-Random Oracle (ROR) model and Scyther simulation tool. Furthermore, an informal security analysis is conducted to validate and support the findings from the formal security analyses. We conduct simulations of the proposed protocol utilizing the Multi-precision Integer and Rational Arithmetic Cryptographic Library (MIRACL). Moreover, the performance and comparative analysis illustrate that the presented solution outperforms currently existing approaches.

Software Support for Arbitrary Precision Arithmetic in Programming Languages

Arbitrary precision arithmetic, also known as bignum arithmetic, is a computational technique that allows programmers to perform arithmetic operations on numbers with significantly higher precision and magnitude than what is typically supported by the built-in numerical data types in programming languages. This technique is especially useful when working with extremely large or extremely precise numbers, such as in cryptography or scientific computations. Arbitrary precision arithmetic has many applications in the areas of Cryptography, Numerical Computation, Statistical Analysis, and High Precision measurements. For example, the calculation of the modulus in the RSA algorithm involves numbers with 1024-bit numbers and higher. An arithmetic calculation involving Multiplication and exponentiation of such numbers using Modulo arithmetic cannot be easily carried out in the existing programming Languages unless special software is provided. We can calculate the mathematical constant Pi to many thousand decimal places using the support provided in Programming Languages. Many programming languages provide built-in support for libraries for arbitrary precision arithmetic. We discuss the support provided in C/C++, Java and Python Languages with examples. Besides Programming Languages, Toolkits like Matlab and Sagemath also are used for scientific computation and special software support provided in these toolkits can enable arbitrary precision arithmetic. Most Programming Languages have support for floating-point arithmetic. We also discuss how arbitrary precision floating point arithmetic. can be supported in C/C++, Java, and Python. In addition, we discuss support for arbitrary precision integer arithmetic in Ruby, Javascript and Matlab and support for arbitrary precision floating point arithmetic in the Perl Language. Finally, we provide an example of computing the constant Pi to many decimal places using the sagemath tool.

Secure Groups for Threshold Cryptography and Number-Theoretic Multiparty Computation

In this paper, we introduce secure groups as a cryptographic scheme representing finite groups together with a range of operations, including the group operation, inversion, random sampling, and encoding/decoding maps. We construct secure groups from oblivious group representations combined with cryptographic protocols, implementing the operations securely. We present both generic and specific constructions, in the latter case specifically for number-theoretic groups commonly used in cryptography. These include Schnorr groups (with quadratic residues as a special case), Weierstrass and Edwards elliptic curve groups, and class groups of imaginary quadratic number fields. For concreteness, we develop our protocols in the setting of secure multiparty computation based on Shamir secret sharing over a finite field, abstracted away by formulating our solutions in terms of an arithmetic black box for secure finite field arithmetic or for secure integer arithmetic. Secure finite field arithmetic suffices for many groups, including Schnorr groups and elliptic curve groups. For class groups, we need secure integer arithmetic to implement Shanks’ classical algorithms for the composition of binary quadratic forms, which we will combine with our adaptation of a particular form reduction algorithm due to Agarwal and Frandsen. As a main result of independent interest, we also present an efficient protocol for the secure computation of the extended greatest common divisor. The protocol is based on Bernstein and Yang’s constant-time 2-adic algorithm, which we adapt to work purely over the integers. This yields a much better approach for multiparty computation but raises a new concern about the growth of the Bézout coefficients. By a careful analysis, we are able to prove that the Bézout coefficients in our protocol will never exceed 3max(a,b) in absolute value for inputs a and b. We have integrated secure groups in the Python package MPyC and have implemented threshold ElGamal and threshold DSA in terms of secure groups. We also mention how our results support verifiable multiparty computation, allowing parties to jointly create a publicly verifiable proof of correctness for the results accompanying the results of a secure computation.

A Methodology and Open-Source Tools to Implement Convolutional Neural Networks Quantized with TensorFlow Lite on FPGAs

Convolutional neural networks (CNNs) are used for classification, as they can extract complex features from input data. The training and inference of these networks typically require platforms with CPUs and GPUs. To execute the forward propagation of neural networks in low-power devices with limited resources, TensorFlow introduced TFLite. This library enables the inference process on microcontrollers by quantizing the network parameters and utilizing integer arithmetic. A limitation of TFLite is that it does not support CNNs to perform inference on FPGAs, a critical need for embedded applications that require parallelism. Here, we present a methodology and open-source tools for implementing CNNs quantized with TFLite on FPGAs. We developed a customizable accelerator for AXI-Lite-based systems on chips (SoCs), and we tested it on a Digilent Zybo-Z7 board featuring the XC7Z020 FPGA and an ARM processor at 667 MHz. Moreover, we evaluated this approach by employing CNNs trained to identify handwritten characters using the MNIST dataset and facial expressions with the JAFFE database. We validated the accelerator results with TFLite running on a laptop with an AMD 16-thread CPU running at 4.2 GHz and 16 GB RAM. The accelerator’s power consumption was 11× lower than the laptop while keeping a reasonable execution time.

Creating the First Confidential GPUs

Today's datacenter GPU has a long and storied 3D graphics heritage. In the 1990s, graphics chips for PCs and consoles had fixed pipelines for geometry, rasterization, and pixels using integer and fixed-point arithmetic. In 1999, NVIDIA invented the modern GPU, which put a set of programmable cores at the heart of the chip, enabling rich 3D scene generation with great efficiency. It did not take long for developers and researchers to realize 'I could run compute on those parallel cores, and it would be blazing fast.' In 2004, Ian Buck created Brook at Stanford, the first compute library for GPUs, and in 2006, NVIDIA created CUDA, which is the gold standard for accelerated computing on GPUs today.

Local Search For Satisfiability Modulo Integer Arithmetic Theories

Satisfiability Modulo Theories (SMT) refers to the problem of deciding the satisfiability of a formula with respect to certain background first-order theories. In this article, we focus on Satisfiablity Modulo Integer Arithmetic, which is referred to as SMT(IA), including both linear and non-linear integer arithmetic theories. Dominant approaches to SMT rely on calling a CDCL-based SAT solver, either in a lazy or eager flavour. Local search, a competitive approach to solving combinatorial problems including SAT, however, has not been well studied for SMT. We develop the first local-search algorithm for SMT(IA) by directly operating on variables, breaking through the traditional framework. We propose a local-search framework by considering the distinctions between Boolean and integer variables. Moreover, we design a novel operator and scoring functions tailored for integer arithmetic, as well as a two-level operation selection heuristic. Putting these together, we develop a local search SMT(IA) solver called LocalSMT. Experiments are carried out to evaluate LocalSMT on benchmark sets from SMT-LIB. The results show that LocalSMT is competitive and complementary with state-of-the-art SMT solvers, and performs particularly well on those formulae with only integer variables. A simple sequential portfolio with Z3 improves the state-of-the-art on satisfiable benchmark sets from SMT-LIB.

Integer Arithmetic Algorithm for Fundamental Frequency Identification of Oceanic Currents.

Underwater sensor networks play a crucial role in collecting valuable data to monitor offshore aquaculture infrastructures. The number of deployed devices not only impacts the bandwidth for a highly constrained communication environment, but also the cost of the sensor network. On the other hand, industrial and literature current meters work as raw data loggers, and most of the calculations to determine the fundamental frequencies are performed offline on a desktop computer or in the cloud. Belonging to the edge computing research area, this paper presents an algorithm to extract the fundamental frequencies of water currents in an underwater sensor network deployed in offshore aquaculture infrastructures. The target sensor node is based on a commercial ultra-low-power microcontroller. The proposed fundamental frequency identification algorithm only requires the use of an integer arithmetic unit. Our approach exploits the mathematical properties of the finite impulse response (FIR) filtering in the integer domain. The design and implementation of the presented algorithm are discussed in detail in terms of FIR tuning/coefficient selection, memory usage and variable domain for its mathematical formulation aimed at reducing the computational effort required. The approach is validated using a shallow water current model and real-world raw data from an offshore aquaculture infrastructure. The extracted frequencies have a maximum error below a 4%.

Efficient matrix key homomorphic encryption of medical images

A sure way of providing privacy to sensitive images is to encrypt them, especially when they are stored in a public cloud server. Homomorphic encryption enables arithmetic operations over encrypted data without access to the secret key. This facility can be well harnessed for secure outsourced image processing by exploiting the available computational capabilities of modern cloud servers. This paper presents a new homomorphic image encryption scheme that uses integer matrix keys. The homomorphic operations are carried out in the finite field Zp to avail the advantages of integer arithmetic and to limit the cipher text sizes to reasonable levels. Our method does not use any error vector as in learning with errors (LWE) to improve the security.