<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.4 20241031//EN" "JATS-journalpublishing1-4.dtd">
<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" article-type="research-article" dtd-version="1.4" xml:lang="en">
  <front>
    <journal-meta>
      <journal-id journal-id-type="publisher-id">ait</journal-id>
      <journal-title-group>
        <journal-title>Advances in Internet of Things</journal-title>
      </journal-title-group>
      <issn pub-type="epub">2161-6825</issn>
      <issn pub-type="ppub">2161-6817</issn>
      <publisher>
        <publisher-name>Scientific Research Publishing</publisher-name>
      </publisher>
    </journal-meta>
    <article-meta>
      <article-id pub-id-type="doi">10.4236/ait.2026.164006</article-id>
      <article-id pub-id-type="publisher-id">ait-154588</article-id>
      <article-categories>
        <subj-group>
          <subject>Article</subject>
        </subj-group>
        <subj-group>
          <subject>Computer Science</subject>
          <subject>Communications</subject>
        </subj-group>
      </article-categories>
      <title-group>
        <article-title>An Overview of Post-Quantum Cryptography Families</article-title>
      </title-group>
      <contrib-group>
        <contrib contrib-type="author" corresp="yes">
          <contrib-id contrib-id-type="orcid">0000-0003-4671-6146</contrib-id>
          <name name-style="western">
            <surname>Elmalih</surname>
            <given-names>Wiam Abdelrahman</given-names>
          </name>
          <xref ref-type="aff" rid="aff1">1</xref>
          <xref ref-type="aff" rid="aff2">2</xref>
        </contrib>
        <contrib contrib-type="author">
          <name name-style="western">
            <surname>Agbinya</surname>
            <given-names>Johnson Ihyeh</given-names>
          </name>
          <xref ref-type="aff" rid="aff3">3</xref>
        </contrib>
      </contrib-group>
      <aff id="aff1"><label>1</label> College of Computer Sciences and Information Technology, Sudan University of Science and Technology, Khartoum, Sudan </aff>
      <aff id="aff2"><label>2</label> College of Science, Northern Border University, Arar, Saudi Arabia </aff>
      <aff id="aff3"><label>3</label> School of Information Technology and Engineering, Melbourne Institute of Technology, Melbourne, Australia </aff>
      <author-notes>
        <fn fn-type="conflict" id="fn-conflict">
          <p>The authors declare no conflicts of interest regarding the publication of this paper.</p>
        </fn>
      </author-notes>
      <pub-date pub-type="epub">
        <day>19</day>
        <month>10</month>
        <year>2026</year>
      </pub-date>
      <pub-date pub-type="collection">
        <month>10</month>
        <year>2026</year>
      </pub-date>
      <volume>16</volume>
      <issue>04</issue>
      <fpage>77</fpage>
      <lpage>105</lpage>
      <history>
        <date date-type="received">
          <day>19</day>
          <month>08</month>
          <year>2026</year>
        </date>
        <date date-type="accepted">
          <day>16</day>
          <month>10</month>
          <year>2026</year>
        </date>
        <date date-type="published">
          <day>19</day>
          <month>10</month>
          <year>2026</year>
        </date>
      </history>
      <permissions>
        <copyright-statement>© 2026 by the authors and Scientific Research Publishing Inc.</copyright-statement>
        <copyright-year>2026</copyright-year>
        <license license-type="open-access">
          <license-p> This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license ( <ext-link ext-link-type="uri" xlink:href="https://creativecommons.org/licenses/by/4.0/">https://creativecommons.org/licenses/by/4.0/</ext-link> ). </license-p>
        </license>
      </permissions>
      <self-uri content-type="doi" xlink:href="https://doi.org/10.4236/ait.2026.164006">https://doi.org/10.4236/ait.2026.164006</self-uri>
      <abstract>
        <p>Quantum computing is a distinct field of computational science that uses principles from quantum mechanics to tackle problems that traditional computing struggles with in speed, size, and complexity. Classical cryptography relies on the complexity of mathematical problems such as large-number factorization, but quantum systems can solve them much faster. This threat necessitates the development and implementation of cryptographic methods resistant to attacks from both classical and quantum systems, known as Post-Quantum Cryptography (PQC). Strong cryptographic algorithms are crucial to counter vulnerabilities in pre-quantum systems. This paper reviews the challenges and solutions for securing communication amid advances in quantum computing. It stresses the urgent need to shift from classical cryptographic systems, which are susceptible to quantum threats, to PQC. The discussion includes theoretical frameworks and practical implementations, covering quantum principles, Quantum Key Distribution (QKD), and standard PQC algorithms. Additionally, it briefly introduces Number Theoretic Transform (NTT) concepts, which enhance polynomial multiplication speed—an essential operation in PQC—by reducing computational complexity from <inline-formula><mml:math></mml:math></inline-formula></p>
        <p>O(</p>
        <p>n</p>
        <p>2</p>
        <p>)</p>
        <p>to <inline-formula><mml:math></mml:math></inline-formula></p>
        <p>O(</p>
        <p>nlogn</p>
        <p>)</p>
        <p>. The paper demonstrates the NTT/Inverse Number Theoretic Transform (INTT) hardware core in Python, focusing on its application to ML-KEM Polynomial arithmetic. Results indicate that NTT outperforms INTT in execution time and throughput. The paper concludes with an overview of security assumptions, cryptanalysis, and the current status of standardization.</p>
      </abstract>
      <kwd-group kwd-group-type="author-generated" xml:lang="en">
        <kwd>Quantum Cryptography</kwd>
        <kwd>Quantum Key Distribution</kwd>
        <kwd>Post-Quantum Cryptography</kwd>
        <kwd>Lattice-Based Cryptography</kwd>
        <kwd>Number Theoretic Transform</kwd>
      </kwd-group>
    </article-meta>
  </front>
  <body>
    <sec id="sec1">
      <title>1. Introduction</title>
      <p>The modern world relies heavily on telecommunications, with the Internet serving as a crucial medium for communication between parties [<xref ref-type="bibr" rid="B1">1</xref>]. Protecting the privacy of transmitted data is essential, but it also creates challenges for securing communication networks. Various techniques and algorithms aim to enhance the security of these systems, ensuring data confidentiality and integrity through cryptographic methods [<xref ref-type="bibr" rid="B2">2</xref>].</p>
      <p>A cryptosystem encompasses the framework and implementation of cryptographic algorithms designed to safeguard information. It is based on mathematical problems that are difficult for classical computers to solve, though quantum computers can tackle certain complex issues much more efficiently. Unlike classical computers, which use bits that are either 0 or 1, quantum computers employ qubits, which can represent multiple states simultaneously. This capability speeds up specific calculations, making classical cryptographic protocols less effective against security threats [<xref ref-type="bibr" rid="B3">3</xref>]. Shor’s and Grover’s algorithms illustrate the impact of quantum algorithms. </p>
      <p>In 1994, Peter Shor developed two quantum algorithms that can solve key problems underpinning current cryptographic systems: the Prime Factorization Problem and the Discrete Logarithm Problem. Unlike classical approaches, which require exponential time, Shor’s algorithms operate in polynomial time by finding periods using the Quantum Fourier Transform. Although probabilistic, the chances of successful factorization improve with multiple runs [<xref ref-type="bibr" rid="B4">4</xref>].</p>
      <p>Published in 1996, Grover’s algorithm enables efficient searching of unordered databases in <inline-formula><mml:math><mml:mrow><mml:mi> O </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:msup><mml:mi> n </mml:mi><mml:mrow><mml:mrow><mml:mn> 1 </mml:mn><mml:mo> / </mml:mo><mml:mn> 2 </mml:mn></mml:mrow></mml:mrow></mml:msup></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> time on quantum systems. It utilizes quantum parallelism and interference through operations that modify the database to efficiently locate target elements. This algorithm can be repeated to increase the likelihood of finding an element and applies to various contexts, such as computing means or finding function inverses. It also helps quantum cryptanalysts break algorithms and search for keys in symmetric systems [<xref ref-type="bibr" rid="B4">4</xref>].</p>
      <p>PQC ciphers are designed to replace classical cryptographic algorithms that are vulnerable to quantum attacks. Since 2016, the National Institute of Standards and Technology (NIST) has conducted an extensive standardization process for these ciphers. This paper reviews and implements NIST-standardized PQC ciphers, providing an overview of their historical development and standardization to assess their reliability. The paper is structured as follows: Section 2 presents background information on quantum cryptography. Section 3 examines Post-Quantum Cryptography, including the standardization process and established methods. Section 4 compares these methods and describes the strategies of major companies such as IBM, Google, and Microsoft in pursuing quantum capabilities. Section 5 details the implementation of the CRYSTALS-Kyber NTT and INTT algorithms, and Section 6 discusses the results. Section 7 provides the conclusions.</p>
    </sec>
    <sec id="sec2">
      <title>2. Quantum Cryptography</title>
      <p>Quantum cryptography promises secure communication protocols that surpass the limitations of classical cryptography. Quantum cryptography is one of the most critical areas of convergence between fundamental physics and information security. It uses quantum-physics principles to transfer or store data with complete security. </p>
      <sec id="sec2dot1">
        <title>2.1. Core Principles of Quantum Mechanics</title>
        <p><bold>Quantum</bold><bold>Superposition:</bold> Classical computing encodes information in bits, each representing either 0 or 1. In contrast, quantum computing encodes information in quantum bits (qubits). A qubit is a two-level quantum system with two orthogonal basis states, typically denoted as <inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> | </mml:mo><mml:mn> 0 </mml:mn><mml:mo> 〉 </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> and <inline-formula><mml:math display="inline"><mml:mrow><mml:mrow><mml:mo> | </mml:mo><mml:mn> 1 </mml:mn><mml:mo> 〉 </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> . Unlike classical bits, a qubit can exist in the states |0⟩, <inline-formula><mml:math display="inline"><mml:mrow><mml:mrow><mml:mo> | </mml:mo><mml:mn> 1 </mml:mn><mml:mo> 〉 </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> , or any linear combination of them. This property, known as superposition, is represented as shown [<xref ref-type="bibr" rid="B5">5</xref>]:</p>
        <disp-formula id="FD1">
          <label>(1)</label>
          <mml:math>
            <mml:mrow>
              <mml:mrow>
                <mml:mo>|</mml:mo>
                <mml:mi>ψ</mml:mi>
                <mml:mo>〉</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:mi>α</mml:mi>
              <mml:mrow>
                <mml:mo>|</mml:mo>
                <mml:mn>0</mml:mn>
                <mml:mo>〉</mml:mo>
              </mml:mrow>
              <mml:mo>+</mml:mo>
              <mml:mi>β</mml:mi>
              <mml:mrow>
                <mml:mo>|</mml:mo>
                <mml:mn>1</mml:mn>
                <mml:mo>〉</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>here, <inline-formula><mml:math><mml:mi> α </mml:mi></mml:math></inline-formula> and <inline-formula><mml:math><mml:mi> β </mml:mi></mml:math></inline-formula> are complex probability amplitudes corresponding to each basis state, and they satisfy the normalization condition <inline-formula><mml:math><mml:mrow><mml:msup><mml:mrow><mml:mrow><mml:mo> | </mml:mo><mml:mi> α </mml:mi><mml:mo> | </mml:mo></mml:mrow></mml:mrow><mml:mn> 2 </mml:mn></mml:msup><mml:mo> + </mml:mo><mml:msup><mml:mrow><mml:mrow><mml:mo> | </mml:mo><mml:mi> β </mml:mi><mml:mo> | </mml:mo></mml:mrow></mml:mrow><mml:mn> 2 </mml:mn></mml:msup><mml:mo> = </mml:mo><mml:mn> 1 </mml:mn></mml:mrow></mml:math></inline-formula></p>
        <p><bold>Quantum</bold><bold>Entanglement</bold> is a phenomenon in which the quantum states of two or more objects become correlated, such that the state of one object influences the state of the others, even when separated by large distances. According to quantum theory, particles can exist in multiple states simultaneously and may become inextricably linked, or “entangled”, despite physical separation. Quantum entanglement is mathematically described using the formalism of quantum states in a Hilbert space, which encompasses all possible states of a quantum system. Entangled states are represented using notation that explicitly shows the relationship between the quantum states of the particles involved. The creation of <italic>n</italic>-qubit entangled states can be achieved using a Hadamard gate and (<italic>n</italic> − 1) Controlled-NOT (C-NOT) gates. One of the most famous entangled states is the Bell state:</p>
        <disp-formula id="FD2">
          <label>(2)</label>
          <mml:math display="inline">
            <mml:mtable columnalign="left">
              <mml:mtr>
                <mml:mtd>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:mn>00</mml:mn>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>↦</mml:mo>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>ψ</mml:mi>
                        <mml:mrow>
                          <mml:mn>00</mml:mn>
                        </mml:mrow>
                      </mml:msub>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>:</mml:mo>
                  <mml:mo>=</mml:mo>
                  <mml:mfrac>
                    <mml:mn>1</mml:mn>
                    <mml:mrow>
                      <mml:msqrt>
                        <mml:mn>2</mml:mn>
                      </mml:msqrt>
                    </mml:mrow>
                  </mml:mfrac>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>00</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                      <mml:mo>+</mml:mo>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>11</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:mn>01</mml:mn>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>↦</mml:mo>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>ψ</mml:mi>
                        <mml:mrow>
                          <mml:mn>01</mml:mn>
                        </mml:mrow>
                      </mml:msub>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>:</mml:mo>
                  <mml:mo>=</mml:mo>
                  <mml:mfrac>
                    <mml:mn>1</mml:mn>
                    <mml:mrow>
                      <mml:msqrt>
                        <mml:mn>2</mml:mn>
                      </mml:msqrt>
                    </mml:mrow>
                  </mml:mfrac>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>01</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                      <mml:mo>+</mml:mo>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>10</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:mn>10</mml:mn>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>↦</mml:mo>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>ψ</mml:mi>
                        <mml:mrow>
                          <mml:mn>10</mml:mn>
                        </mml:mrow>
                      </mml:msub>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>:</mml:mo>
                  <mml:mo>=</mml:mo>
                  <mml:mfrac>
                    <mml:mn>1</mml:mn>
                    <mml:mrow>
                      <mml:msqrt>
                        <mml:mn>2</mml:mn>
                      </mml:msqrt>
                    </mml:mrow>
                  </mml:mfrac>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>00</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                      <mml:mo>−</mml:mo>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>11</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:mn>11</mml:mn>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>↦</mml:mo>
                  <mml:mrow>
                    <mml:mo>|</mml:mo>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>ψ</mml:mi>
                        <mml:mrow>
                          <mml:mn>11</mml:mn>
                        </mml:mrow>
                      </mml:msub>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>:</mml:mo>
                  <mml:mo>=</mml:mo>
                  <mml:mfrac>
                    <mml:mn>1</mml:mn>
                    <mml:mrow>
                      <mml:msqrt>
                        <mml:mn>2</mml:mn>
                      </mml:msqrt>
                    </mml:mrow>
                  </mml:mfrac>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>01</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                      <mml:mo>−</mml:mo>
                      <mml:mrow>
                        <mml:mo>|</mml:mo>
                        <mml:mrow>
                          <mml:mn>10</mml:mn>
                        </mml:mrow>
                        <mml:mo>〉</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:math>
        </disp-formula>
        <p>Quantum repeaters cannot be constructed because quantum particle states cannot be duplicated. However, particles at either end of a network can be connected via a chain of linked particles, creating a repeater effect that forms the foundation of a quantum network. This connection enables the development of advanced protocols like quantum teleportation.</p>
        <p><bold>Quantum</bold><bold>Teleportation:</bold> This technique transfers quantum information between two locations via a classical link, meaning the information cannot be transmitted faster than the speed of light. Despite its name, quantum teleportation does not involve the physical movement of information; rather, it involves transferring the state of quantum information via entanglement.</p>
        <p><bold>Heisenberg</bold><bold>Uncertainty</bold><bold>Principle:</bold> Introduced in 1927 by German physicist Werner Heisenberg, this principle highlights the limitations in precisely knowing certain pairs of physical quantities, such as position and momentum. It establishes a fundamental relationship, stating that both variables cannot be known with absolute precision simultaneously. Mathematically, it sets a lower bound on the uncertainties of complementary variables.</p>
        <p><bold>Photon</bold><bold>Polarization</bold><bold>Principle</bold><bold>:</bold> Polarization is a phenomenon associated with the wave nature of electromagnetic radiation, arising from interactions between electric and magnetic fields. Light waves can be classified as unpolarized, with vibrations occurring in multiple planes, or polarized, with vibrations limited to a single plane. Polarization describes the orientation of electric field vectors perpendicular to the direction of wave propagation. A single photon’s polarization represents a two-state quantum system, or qubit, with horizontal and vertical polarizations as the logical states. Other polarization states are combinations of these two. The typical polarization-state pairs are shown in <bold>Table 1</bold> below.</p>
        <p><bold>Table 1.</bold> Representation of light polarization as a two-level system or qubit.</p>
        <table-wrap id="tbl1">
          <label>Table 1</label>
          <table>
            <tbody>
              <tr>
                <td>Basis</td>
                <td>Representation</td>
                <td colspan="2">Bit 0</td>
                <td colspan="2">Bit 1</td>
                <td>State</td>
              </tr>
              <tr>
                <td>Rectilinear</td>
                <td>
                  <inline-formula>
                    <mml:math display="inline">
                      <mml:mo>⊕</mml:mo>
                    </mml:math>
                  </inline-formula>
                </td>
                <td>|0⟩0˚</td>
                <td>
                </td>
                <td>|1⟩90˚</td>
                <td>
                </td>
                <td>
                  <inline-formula>
                    <mml:math display="inline">
                      <mml:mrow>
                        <mml:mrow>
                          <mml:mo>|</mml:mo>
                          <mml:mn>0</mml:mn>
                          <mml:mo>〉</mml:mo>
                        </mml:mrow>
                        <mml:mo>=</mml:mo>
                        <mml:mrow>
                          <mml:mo>(</mml:mo>
                          <mml:mrow>
                            <mml:mn>1</mml:mn>
                            <mml:mo>,</mml:mo>
                            <mml:mn>0</mml:mn>
                          </mml:mrow>
                          <mml:mo>)</mml:mo>
                        </mml:mrow>
                      </mml:mrow>
                    </mml:math>
                  </inline-formula>
                  <inline-formula>
                    <mml:math display="inline">
                      <mml:mrow>
                        <mml:mrow>
                          <mml:mo>|</mml:mo>
                          <mml:mn>1</mml:mn>
                          <mml:mo>〉</mml:mo>
                        </mml:mrow>
                        <mml:mo>=</mml:mo>
                        <mml:mrow>
                          <mml:mo>(</mml:mo>
                          <mml:mrow>
                            <mml:mn>0</mml:mn>
                            <mml:mo>,</mml:mo>
                            <mml:mn>1</mml:mn>
                          </mml:mrow>
                          <mml:mo>)</mml:mo>
                        </mml:mrow>
                      </mml:mrow>
                    </mml:math>
                  </inline-formula>
                </td>
              </tr>
              <tr>
                <td>Diagonal</td>
                <td>
                  <inline-formula>
                    <mml:math display="inline">
                      <mml:mo>⊗</mml:mo>
                    </mml:math>
                  </inline-formula>
                </td>
                <td>|+⟩45˚</td>
                <td>
                </td>
                <td>|−⟩−45˚</td>
                <td>
                </td>
                <td>
                  <inline-formula>
                    <mml:math>
                      <mml:mrow>
                        <mml:mrow>
                          <mml:mo>|</mml:mo>
                          <mml:mrow>
                            <mml:mo>+</mml:mo>
                            <mml:msup>
                              <mml:mrow>
                                <mml:mn>45</mml:mn>
                              </mml:mrow>
                              <mml:mo>∘</mml:mo>
                            </mml:msup>
                          </mml:mrow>
                          <mml:mo>〉</mml:mo>
                        </mml:mrow>
                        <mml:mo>=</mml:mo>
                        <mml:mfrac>
                          <mml:mn>1</mml:mn>
                          <mml:mrow>
                            <mml:msqrt>
                              <mml:mn>2</mml:mn>
                            </mml:msqrt>
                          </mml:mrow>
                        </mml:mfrac>
                        <mml:mrow>
                          <mml:mo>(</mml:mo>
                          <mml:mrow>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>0</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                            <mml:mo>+</mml:mo>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>1</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                          </mml:mrow>
                          <mml:mo>)</mml:mo>
                        </mml:mrow>
                      </mml:mrow>
                    </mml:math>
                  </inline-formula>
                  <inline-formula>
                    <mml:math>
                      <mml:mrow>
                        <mml:mrow>
                          <mml:mo>|</mml:mo>
                          <mml:mrow>
                            <mml:mo>−</mml:mo>
                            <mml:msup>
                              <mml:mrow>
                                <mml:mn>45</mml:mn>
                              </mml:mrow>
                              <mml:mo>∘</mml:mo>
                            </mml:msup>
                          </mml:mrow>
                          <mml:mo>〉</mml:mo>
                        </mml:mrow>
                        <mml:mo>=</mml:mo>
                        <mml:mfrac>
                          <mml:mn>1</mml:mn>
                          <mml:mrow>
                            <mml:msqrt>
                              <mml:mn>2</mml:mn>
                            </mml:msqrt>
                          </mml:mrow>
                        </mml:mfrac>
                        <mml:mrow>
                          <mml:mo>(</mml:mo>
                          <mml:mrow>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>0</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                            <mml:mo>−</mml:mo>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>1</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                          </mml:mrow>
                          <mml:mo>)</mml:mo>
                        </mml:mrow>
                      </mml:mrow>
                    </mml:math>
                  </inline-formula>
                </td>
              </tr>
              <tr>
                <td>Circular</td>
                <td>O</td>
                <td>
                  |
                  <italic>R</italic>
                  ⟩
                </td>
                <td>
                </td>
                <td>
                  |
                  <italic>L</italic>
                  ⟩
                </td>
                <td>
                </td>
                <td>
                  <inline-formula>
                    <mml:math>
                      <mml:mrow>
                        <mml:mrow>
                          <mml:mo>|</mml:mo>
                          <mml:mi>L</mml:mi>
                          <mml:mo>〉</mml:mo>
                        </mml:mrow>
                        <mml:mo>=</mml:mo>
                        <mml:mfrac>
                          <mml:mn>1</mml:mn>
                          <mml:mrow>
                            <mml:msqrt>
                              <mml:mn>2</mml:mn>
                            </mml:msqrt>
                          </mml:mrow>
                        </mml:mfrac>
                        <mml:mrow>
                          <mml:mo>(</mml:mo>
                          <mml:mrow>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>0</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                            <mml:mo>+</mml:mo>
                            <mml:mi>i</mml:mi>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>1</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                          </mml:mrow>
                          <mml:mo>)</mml:mo>
                        </mml:mrow>
                      </mml:mrow>
                    </mml:math>
                  </inline-formula>
                  <inline-formula>
                    <mml:math display="inline">
                      <mml:mrow>
                        <mml:mrow>
                          <mml:mo>|</mml:mo>
                          <mml:mi>R</mml:mi>
                          <mml:mo>〉</mml:mo>
                        </mml:mrow>
                        <mml:mo>=</mml:mo>
                        <mml:mfrac>
                          <mml:mn>1</mml:mn>
                          <mml:mrow>
                            <mml:msqrt>
                              <mml:mn>2</mml:mn>
                            </mml:msqrt>
                          </mml:mrow>
                        </mml:mfrac>
                        <mml:mrow>
                          <mml:mo>(</mml:mo>
                          <mml:mrow>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>0</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                            <mml:mo>−</mml:mo>
                            <mml:mi>i</mml:mi>
                            <mml:mrow>
                              <mml:mo>|</mml:mo>
                              <mml:mn>1</mml:mn>
                              <mml:mo>〉</mml:mo>
                            </mml:mrow>
                          </mml:mrow>
                          <mml:mo>)</mml:mo>
                        </mml:mrow>
                      </mml:mrow>
                    </mml:math>
                  </inline-formula>
                </td>
              </tr>
            </tbody>
          </table>
        </table-wrap>
        <p><bold>The</bold><bold>No</bold><bold>-cloning</bold><bold>theorem</bold> is a principle in quantum mechanics stating that identical copies of arbitrary unknown quantum states cannot be made. Introduced by Wootters, Zurek, and Dieks in 1982, it has significant implications for quantum computing. While orthogonal states like {|0⟩, |1⟩} can be copied as with classical bits, replicating an arbitrary single-qubit state is impossible.</p>
      </sec>
      <sec id="sec2dot2">
        <title>2.2. Quantum Key Distribution (QKD)</title>
        <p>A significant challenge in classical cryptography is safe key generation and exchange, particularly in unsecured environments. When two parties communicate, they must share information over public channels, exposing them to potential attacks. A key advancement in quantum cryptography is Quantum Key Distribution (QKD) [<xref ref-type="bibr" rid="B6">6</xref>].</p>
        <p>QKD uses quantum mechanics to generate a secret key over a quantum channel, ensuring security based on the laws of physics. The randomness of quantum states and measurements facilitates key generation, and the no-cloning theorem guarantees uniqueness. The Uncertainty Principle further protects QKD against interception attempts [<xref ref-type="bibr" rid="B7">7</xref>]. QKD protocols can be categorized into [<xref ref-type="bibr" rid="B8">8</xref>]:</p>
        <p><bold>Continuo</bold><bold>us</bold><bold>Variable</bold><bold>(CV)</bold><bold>QKD:</bold> Information is encoded through position and momentum quadratures of a quantized electromagnetic field in an infinite-dimensional Hilbert space, exemplified by the Gaussian modulation protocol.<bold>Discrete</bold><bold>Variable</bold><bold>(</bold><bold>DV)</bold><bold>QKD:</bold> This approach uses finite-dimensional discrete variables like phase and polarization, including protocols such as BB84, B92, and SARG04.<bold>Distributed</bold><bold>Phase Reference</bold><bold>(</bold><bold>DPR)</bold><bold>QKD</bold><bold>:</bold> In DPR protocols, a single photon is not required for encoding; in fact, Key information is encoded using the phase difference or arrival times of photons, employing weak coherent pulses. DPR protocols include Differential Phase Shift (DPS) QKD and Coherent One-Way (COW) QKD.</p>
        <p>Based on the architecture of protocols, DV-QKD protocols can be regrouped into two categories:</p>
        <p><bold>Prepare-</bold><bold>and-measure</bold><bold>protocols:</bold> These measure unknown quantum states, helping detect eavesdropping and assess intercepted data.<bold>Entanglem</bold><bold>ent-based</bold><bold>protocols:</bold> These involve linked quantum states where the measurement of one affects the other, alerting involved parties if an eavesdropper interferes with a trusted node. <xref ref-type="fig" rid="fig1">Figure 1</xref> represents the classification of QKD protocols. </p>
        <fig id="fig1">
          <label>Figure 1</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId53.jpeg?20261019032332" />
        </fig>
        <p><bold>Figure 1</bold><bold>.</bold> Classification of QKD protocols.</p>
        <p>Each QKD protocol has its own advantages and disadvantages, so the best choice depends on the specific use case. A QKD protocol works in two main phases. First is the quantum transmission phase, where the sender and receiver exchange and measure quantum states. Next is the post-processing phase, where the bit strings from the quantum phase are turned into a pair of secure keys. For QKD to work, it requires two channels: a quantum channel and a classical channel, used to exchange messages. In the quantum channel, a beam of photons is sent, with each photon encoded by its polarization [<xref ref-type="bibr" rid="B7">7</xref>]. <xref ref-type="fig" rid="fig2">Figure 2</xref> shows a basic QKD process.</p>
        <p>QKD provides information-theoretic security; however, it depends on authenticated classical channels during post-processing. Without authentication, these channels are vulnerable to man-in-the-middle attacks. Conventional approaches require communicating parties to pre-share symmetric keys through physical meetings, which is not feasible for multi-user QKD networks. A comprehensive security analysis of QKD must explicitly consider authentication overhead; discrepancies between theoretical proofs and practical implementation security, including side-channel countermeasures; endpoint security assumptions about device trust and key storage; and the potential for hybrid approaches that combine QKD with post-quantum cryptographic authentication.</p>
        <p>QKD is already practical and can be used with today’s technology, even without quantum computers. However, QKD only handles key distribution and does not replace the encryption systems we rely on to keep our communication secure. </p>
        <fig id="fig2">
          <label>Figure 2</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId54.jpeg?20261019032331" />
        </fig>
        <p><bold>Figure 2.</bold> Basic key distribution protocol process [Generated by AI].</p>
      </sec>
    </sec>
    <sec id="sec3">
      <title>3. Post-Quantum Cryptography</title>
      <p>If large-scale quantum computers are built, they could break many currently deployed public-key cryptosystems. Such a development would significantly compromise the confidentiality and integrity of digital communications across the Internet and other platforms. Consequently, research has intensified into public-key cryptosystems that remain secure against adversaries equipped with both quantum and classical computers. This area of study is commonly known as Post-Quantum Cryptography (PQC), or quantum-resistant cryptography. The primary objective of PQC is to develop cryptographic systems that are secure against both quantum and classical computational threats and can interoperate with existing communication protocols and networks. Focusing on PQC matters even though large-scale quantum computers are not yet available. Here are a few reasons why [<xref ref-type="bibr" rid="B9">9</xref>]:</p>
      <p>Preparation: By developing PQC algorithms now, we can be prepared for future risks posed by quantum computers. Since cryptographic systems protect data for many years, it is important to plan for possible quantum attacks.Longevity: PQC algorithms protect against both classical and quantum attacks. They will stay secure even as classical computers become more powerful.Adoption: Developing, testing, and adopting new cryptographic systems takes time.</p>
      <sec id="sec3dot1">
        <title>3.1. NIST Post-Quantum Cryptography Standardization</title>
        <p>The National Institute of Standards and Technology (NIST) launched a process to select quantum-resistant public-key cryptographic algorithms, aiming to establish robust standards to counter quantum-computer attacks. This initiative focuses on algorithms for digital signatures, public-key encryption, and key establishment, building on NIST’s previous standards like DES, AES, and SHA.</p>
        <p>In February 2016, NIST called for global contributions to develop post-quantum cryptography standards. By November 2017, 82 draft algorithms had been submitted, and 69 were accepted for the initial standardization phase. After thorough reviews, 26 candidates advanced in January 2019: 17 key establishment mechanisms and 9 digital signatures, chosen for their potential based on analysis and community feedback [<xref ref-type="bibr" rid="B10">10</xref>].</p>
        <p>The second round included further evaluation, resulting in seven finalists and eight alternates selected in July 2020. NIST planned to standardize a select few finalists and alternates after a fourth round. This third round lasted about 18 months, during which NIST conducted detailed assessments of the theoretical and empirical security evidence, along with performance benchmarking.</p>
        <p>In July 2022, NIST identified four final algorithms: Crystals-Kyber for key establishment and Crystals-Dilithium, Falcon, and Sphincs+ for digital signatures, with Crystals-Dilithium recommended as the primary choice. The process also set four alternate KEM candidates—BIKE, Classic McEliece, HQC, and SIKE—for further evaluation [<xref ref-type="bibr" rid="B10">10</xref>]. The fourth round began at the end of 2022 and focused on security validation. During this phase, SIKE was deemed insecure, and feedback collected from the cryptographic community proved insightful. </p>
        <p>In August 2024, NIST completed the PQC standardization process by issuing three Federal Information Processing Standards (FIPS) specifying particular algorithms. The approved standards are the Module Lattice-Based Key Encapsulation Mechanism (ML-KEM) [<xref ref-type="bibr" rid="B11">11</xref>] from CRYSTALS-Kyber for key encapsulation, the Module Lattice-Based Digital Signature Algorithm (ML-DSA) [<xref ref-type="bibr" rid="B12">12</xref>] from CRYSTALS-Dilithium for digital signatures, and the Stateless Hash-Based Digital Signature Algorithm (SLH-DSA) [<xref ref-type="bibr" rid="B13">13</xref>] from SPHINCS+ for hash-based digital signatures. These algorithms are authorized for use in both federal and commercial environments. A fourth algorithm, the FFNTT-based NTRU Lattice Digital Signature Algorithm (FN-DSA), related to Falcon, remains in draft status with final approval anticipated in late 2026 or early 2027.</p>
        <p>By March 2025, NIST announced HQC for standardization, aiming to finalize it in 2027 [<xref ref-type="bibr" rid="B14">14</xref>]. The PQC standardization process can be summarized in <xref ref-type="fig" rid="fig3">Figure 3</xref>.</p>
        <fig id="fig3">
          <label>Figure 3</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId55.jpeg?20261019032333" />
        </fig>
        <p><bold>Figure 3.</bold> PQC standardization process of NIST.</p>
      </sec>
      <sec id="sec3dot2">
        <title>3.2. Post-Quantum Cryptography Families</title>
        <p>Cryptographic systems are categorized by their security foundations. PQC relies on complex mathematical challenges to ensure resilience against classical and quantum threats. Noteworthy families include lattice-based, isogeny-based, multivariate, code-based, and hash-based cryptography [<xref ref-type="bibr" rid="B15">15</xref>].</p>
        <p>This review examines cryptographic families evaluated by the NIST Post-Quantum Cryptography Standardization Project. The comparison is based on criteria including the underlying mathematical problems and their anticipated resistance to quantum attacks; key, signature, and ciphertext sizes; and computational efficiency for key generation, encryption, signing, decryption, and verification. Additional considerations include memory requirements, practical deployment, and the strength of security proofs. To clarify algorithm status, three categories are defined: 1) officially standardized schemes with finalized NIST FIPS designations which are suitable for practical implementation; 2) selected but not yet finalized candidates which remain in draft status; and 3) obsolete or compromised schemes such as Rainbow and SIKE, which were eliminated following successful cryptanalytic attacks. <xref ref-type="fig" rid="fig4">Figure 4</xref> shows the cryptosystem families and the algorithms used.</p>
        <p>3.2.1. Lattice-Based Cryptography Methods</p>
        <p>Lattice-based cryptography relies on complex mathematical structures called lattices to develop encryption methods resilient to quantum attacks. These lattices consist of regularly spaced points in a multi-dimensional space. A vector indicates a specific point, with the origin represented by all zeros. Vectors can be categorized as “far” (larger norm) or “short” (smaller norm) based on their distance from the origin. A basis, a select group of vectors, can represent all points in the lattice by ensuring no two points lie along the same line from the origin [<xref ref-type="bibr" rid="B1">1</xref>].</p>
        <fig id="fig4">
          <label>Figure 4</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId56.jpeg?20261019032334" />
        </fig>
        <p><bold>Figure 4.</bold> Post-quantum cryptography methods.</p>
        <p><bold>Definition</bold><bold>1</bold>. <italic>A</italic><italic>set</italic><italic>of</italic><italic>vectors</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> v </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> v </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> v </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow><mml:mo> ∈ </mml:mo><mml:msup><mml:mi> ℝ </mml:mi><mml:mi> n </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula><italic>is</italic><italic>linearly</italic><italic>independent</italic><italic>if</italic><italic>the</italic><italic>equation</italic></p>
        <disp-formula id="FD3">
          <label>(3)</label>
          <mml:math>
            <mml:mrow>
              <mml:msub>
                <mml:mi>α</mml:mi>
                <mml:mn>1</mml:mn>
              </mml:msub>
              <mml:msub>
                <mml:mi>v</mml:mi>
                <mml:mn>1</mml:mn>
              </mml:msub>
              <mml:mo>+</mml:mo>
              <mml:msub>
                <mml:mi>α</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msub>
              <mml:msub>
                <mml:mi>v</mml:mi>
                <mml:mn>2</mml:mn>
              </mml:msub>
              <mml:mo>+</mml:mo>
              <mml:mo>⋯</mml:mo>
              <mml:mo>+</mml:mo>
              <mml:msub>
                <mml:mi>α</mml:mi>
                <mml:mi>m</mml:mi>
              </mml:msub>
              <mml:msub>
                <mml:mi>v</mml:mi>
                <mml:mi>m</mml:mi>
              </mml:msub>
              <mml:mo>=</mml:mo>
              <mml:mn>0</mml:mn>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p><italic>accepts</italic><italic>only</italic><italic>the</italic><italic>trivial</italic><italic>solution</italic><inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> α </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> = </mml:mo><mml:msub><mml:mi> α </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> = </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> = </mml:mo><mml:msub><mml:mi> α </mml:mi><mml:mi> m </mml:mi></mml:msub><mml:mo> = </mml:mo><mml:mn> 0 </mml:mn></mml:mrow></mml:math></inline-formula> .</p>
        <p><bold>Definition</bold><bold>2.</bold><italic>Given</italic><italic>n</italic><italic>linearly</italic><italic>independent</italic><italic>vectors</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow><mml:mo> ∈ </mml:mo><mml:msup><mml:mi> ℝ </mml:mi><mml:mi> n </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula> , <italic>the</italic><italic>lattice</italic><italic>generated</italic><italic>by</italic><italic>them</italic><italic>is</italic><italic>defined</italic><italic>as</italic><italic>the</italic><italic>set</italic></p>
        <disp-formula id="FD4">
          <label>(4)</label>
          <mml:math>
            <mml:mrow>
              <mml:mi>ℒ</mml:mi>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mrow>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mn>1</mml:mn>
                  </mml:msub>
                  <mml:mo>,</mml:mo>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msub>
                  <mml:mo>,</mml:mo>
                  <mml:mo>⋯</mml:mo>
                  <mml:mo>,</mml:mo>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mi>m</mml:mi>
                  </mml:msub>
                </mml:mrow>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>{</mml:mo>
                <mml:mrow>
                  <mml:mstyle displaystyle="true">
                    <mml:msub>
                      <mml:mo>∑</mml:mo>
                      <mml:mi>i</mml:mi>
                    </mml:msub>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>x</mml:mi>
                        <mml:mi>i</mml:mi>
                      </mml:msub>
                      <mml:msub>
                        <mml:mi>b</mml:mi>
                        <mml:mi>i</mml:mi>
                      </mml:msub>
                    </mml:mrow>
                  </mml:mstyle>
                  <mml:mo>:</mml:mo>
                  <mml:msub>
                    <mml:mi>x</mml:mi>
                    <mml:mi>i</mml:mi>
                  </mml:msub>
                  <mml:mo>∈</mml:mo>
                  <mml:mi>ℤ</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mn>1</mml:mn>
                  <mml:mo>≤</mml:mo>
                  <mml:mi>i</mml:mi>
                  <mml:mo>≤</mml:mo>
                  <mml:mi>n</mml:mi>
                </mml:mrow>
                <mml:mo>}</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p><italic>The</italic><italic>set</italic><italic>of</italic><italic>vectors</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>is</italic><italic>called</italic><italic>the</italic><italic>basis</italic><italic>of</italic><italic>the</italic><italic>lattice</italic><italic>L</italic>.</p>
        <p><italic>Let</italic><italic>B</italic><italic>denote</italic><italic>the</italic><italic>n</italic> × <italic>m</italic><italic>matrix</italic><italic>with</italic><italic>columns</italic><inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula> , <italic>then</italic><italic>a</italic><italic>lattice</italic><italic>can</italic><italic>be</italic><italic>written</italic><italic>as</italic></p>
        <disp-formula id="FD5">
          <label>(5)</label>
          <mml:math>
            <mml:mrow>
              <mml:mi>ℒ</mml:mi>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mi>B</mml:mi>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:mi>ℒ</mml:mi>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mrow>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mn>1</mml:mn>
                  </mml:msub>
                  <mml:mo>,</mml:mo>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msub>
                  <mml:mo>,</mml:mo>
                  <mml:mo>⋯</mml:mo>
                  <mml:mo>,</mml:mo>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mi>m</mml:mi>
                  </mml:msub>
                </mml:mrow>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>{</mml:mo>
                <mml:mrow>
                  <mml:mi>B</mml:mi>
                  <mml:mi>x</mml:mi>
                  <mml:mo>|</mml:mo>
                  <mml:mi>x</mml:mi>
                  <mml:mo>∈</mml:mo>
                  <mml:msup>
                    <mml:mi>ℤ</mml:mi>
                    <mml:mi>n</mml:mi>
                  </mml:msup>
                </mml:mrow>
                <mml:mo>}</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p><italic>Matrix</italic><italic>B</italic><italic>is</italic><italic>called</italic><italic>a</italic><italic>basis</italic><italic>matrix</italic>. <italic>A</italic><italic>basis</italic><italic>for</italic><italic>L</italic><italic>is</italic><italic>any</italic><italic>set</italic><italic>of</italic><italic>linearly</italic><italic>independent</italic><italic>vectors</italic><italic>that</italic><italic>spans</italic><italic>L</italic>.</p>
        <p><bold>Definition</bold><bold>3.</bold><italic>The</italic><italic>rank</italic><italic>of</italic><italic>a</italic><italic>lattice</italic><italic>L</italic><italic>is</italic><italic>defined</italic><italic>as</italic><italic>the</italic><italic>number</italic><italic>of</italic><italic>elements</italic><italic>in</italic><italic>any</italic><italic>basis</italic><italic>of</italic><italic>L</italic>, <italic>which</italic><italic>equals</italic><italic>the</italic><italic>dimension</italic><italic>of</italic><italic>the</italic><italic>vector</italic><italic>subspace</italic><italic>spanned</italic><italic>by</italic><italic>L</italic>.</p>
        <p><italic>We</italic><italic>call</italic><italic>m</italic><italic>the</italic><italic>rank</italic><italic>of</italic><italic>the</italic><italic>lattice</italic>, <italic>and</italic><italic>n</italic><italic>the</italic><italic>dimension</italic>. <italic>If</italic><inline-formula><mml:math><mml:mrow><mml:mi> n </mml:mi><mml:mo> = </mml:mo><mml:mi> m </mml:mi></mml:mrow></mml:math></inline-formula> ,<italic>t</italic><italic>he</italic><italic>lattice</italic><italic>L</italic><italic>is</italic><italic>called</italic><italic>a</italic><italic>full</italic>-<italic>rank</italic><italic>lattice</italic>.</p>
        <p>Lattice <italic>L</italic> may be generated by various bases, and this concept is generalized using an unimodular matrix.</p>
        <p><bold>Definition</bold><bold>4.</bold><italic>A</italic><italic>matrix</italic><inline-formula><mml:math><mml:mrow><mml:mi> U </mml:mi><mml:mo> ∈ </mml:mo><mml:msup><mml:mi> ℤ </mml:mi><mml:mrow><mml:mi> n </mml:mi><mml:mo> × </mml:mo><mml:mi> n </mml:mi></mml:mrow></mml:msup></mml:mrow></mml:math></inline-formula><italic>is</italic><italic>called</italic><italic>unimodular</italic><italic>if</italic><italic>det</italic><inline-formula><mml:math><mml:mrow><mml:mi> U </mml:mi><mml:mo> = </mml:mo><mml:mo> ± </mml:mo><mml:mn> 1 </mml:mn></mml:mrow></mml:math></inline-formula> .</p>
        <p><bold>Definition</bold><bold>5.</bold><italic>Let</italic><italic>L</italic><italic>be</italic><italic>a</italic><italic>lattice</italic><italic>with</italic><italic>dimension</italic><italic>n</italic><italic>and</italic><inline-formula><mml:math display="inline"><mml:mrow><mml:mi> B </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>a</italic><italic>basis</italic><italic>of</italic><italic>the</italic><italic>lattice</italic>. <italic>We</italic><italic>define</italic><italic>the</italic><italic>fundamental</italic><italic>parallelepiped</italic><italic>of</italic><italic>L</italic><italic>to</italic><italic>be</italic><italic>the</italic><italic>set</italic></p>
        <fig id="fig5">
          <label>Figure 5</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId83.svg?20261019032334" />
        </fig>
        <p><xref>(6)</xref></p>
        <p><bold>Definition</bold><bold>6.</bold> Let <inline-formula><mml:math><mml:mrow><mml:mi> L </mml:mi><mml:mo> = </mml:mo><mml:mi> L </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> B </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> be a lattice of rank <italic>n</italic>, and let <italic>B</italic> be a basis of <italic>L</italic>. <italic>The</italic><italic>determinant</italic><italic>of</italic><italic>L</italic>, denoted by det(<italic>L</italic>), <italic>is</italic><italic>the</italic><italic>n</italic>-<italic>dimensional</italic><italic>volume</italic><italic>of</italic></p>
        <fig id="fig6">
          <label>Figure 6</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId87.svg?20261019032334" />
        </fig>
        <p>. The determinant can be written as</p>
        <disp-formula id="FD7">
          <label>(7)</label>
          <mml:math>
            <mml:mrow>
              <mml:mi>det</mml:mi>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mi>ℒ</mml:mi>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:msqrt>
                <mml:mrow>
                  <mml:mi>det</mml:mi>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:msup>
                        <mml:mi>B</mml:mi>
                        <mml:mtext>T</mml:mtext>
                      </mml:msup>
                      <mml:mi>B</mml:mi>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mrow>
              </mml:msqrt>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p><bold>Definition</bold><bold>7.</bold> For any lattice <italic>L</italic> = <italic>L</italic>(<italic>B</italic>), we define the minimum distance of <italic>L</italic> as the smallest distance between any two lattice points:</p>
        <disp-formula id="FD8">
          <label>(8)</label>
          <mml:math>
            <mml:mrow>
              <mml:msub>
                <mml:mi>λ</mml:mi>
                <mml:mn>1</mml:mn>
              </mml:msub>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mi>ℒ</mml:mi>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:mi>inf</mml:mi>
              <mml:mrow>
                <mml:mo>{</mml:mo>
                <mml:mrow>
                  <mml:mrow>
                    <mml:mo>‖</mml:mo>
                    <mml:mrow>
                      <mml:mi>x</mml:mi>
                      <mml:mo>−</mml:mo>
                      <mml:mi>y</mml:mi>
                    </mml:mrow>
                    <mml:mo>‖</mml:mo>
                  </mml:mrow>
                  <mml:mo>:</mml:mo>
                  <mml:mi>x</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>y</mml:mi>
                  <mml:mo>∈</mml:mo>
                  <mml:mi>ℒ</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>x</mml:mi>
                  <mml:mo>≠</mml:mo>
                  <mml:mi>y</mml:mi>
                </mml:mrow>
                <mml:mo>}</mml:mo>
              </mml:mrow>
              <mml:mo>.</mml:mo>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>Lattice problems are particularly vital because they resist efficient solutions, even on quantum computers. This ensures secure protocols against future quantum attacks [<xref ref-type="bibr" rid="B16">16</xref>].</p>
        <p><italic>A</italic>. <italic>Shortest</italic><italic>Vector</italic><italic>Problem</italic> (<italic>SVP</italic>)</p>
        <p>The primary computational challenge in lattice theory is the Shortest Vector Problem (SVP). Because a lattice <inline-formula><mml:math><mml:mi> L </mml:mi></mml:math></inline-formula> is discrete, it has a nonzero element <inline-formula><mml:math><mml:mrow><mml:mi> v </mml:mi><mml:mo> ∈ </mml:mo><mml:mi> L </mml:mi></mml:mrow></mml:math></inline-formula> of minimum length under, say, the Euclidean norm. The fundamental parameter of a lattice is the length of its shortest nonzero vector, denoted as <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> λ </mml:mi><mml:mn> 1 </mml:mn></mml:msub></mml:mrow></mml:math></inline-formula> .</p>
        <p><bold>Definitio</bold><bold>n</bold><bold>8.</bold> (<italic>Shortest</italic><italic>Vector</italic><italic>Problem</italic>). <italic>Given</italic><italic>a</italic><italic>basis</italic><inline-formula><mml:math><mml:mrow><mml:mi> B </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>of</italic><italic>lattice</italic><italic>L</italic>(<italic>B</italic>), <italic>find</italic><italic>the</italic><italic>nonzero</italic><italic>vector</italic>, <italic>i.e.</italic>, <italic>find</italic><inline-formula><mml:math><mml:mrow><mml:mi> v </mml:mi><mml:mo> ∈ </mml:mo><mml:mi> L </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> B </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>for</italic><italic>which</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ‖ </mml:mo><mml:mi> v </mml:mi><mml:mo> ‖ </mml:mo></mml:mrow><mml:mo> = </mml:mo><mml:msub><mml:mi> λ </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> L </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> B </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> .</p>
        <p><xref ref-type="fig" rid="fig5">Figure 5</xref> shows the vector closest to the origin.</p>
        <fig id="fig7">
          <label>Figure 7</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId107.jpeg?20261019032333" />
        </fig>
        <p><bold>Figure 5.</bold> The shortest vector problem [<xref ref-type="bibr" rid="B17">17</xref>].</p>
        <p><italic>B</italic>. <italic>Closest</italic><italic>Vector</italic><italic>Problem</italic> (<italic>CVP</italic>)</p>
        <p>CVP is a computational problem in lattices that is closely related to the Shortest Vector Problem (SVP). In the CVP, a lattice <inline-formula><mml:math><mml:mi> L </mml:mi></mml:math></inline-formula> and a target point <inline-formula><mml:math><mml:mi> x </mml:mi></mml:math></inline-formula> are given, and the objective is to identify the lattice point closest to <inline-formula><mml:math><mml:mi> x </mml:mi></mml:math></inline-formula> . This problem is highly challenging because it is NP-hard. Moreover, it is considered more difficult than the SVP, which seeks the shortest non-zero lattice vector. Let <inline-formula><mml:math><mml:mi> L </mml:mi></mml:math></inline-formula> denote a lattice and let <inline-formula><mml:math><mml:mi> t </mml:mi></mml:math></inline-formula> be a fixed point in <inline-formula><mml:math><mml:mrow><mml:msup><mml:mi> ℝ </mml:mi><mml:mi> n </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula> . The distance is defined as follows:</p>
        <disp-formula id="FD9">
          <label>(9)</label>
          <mml:math>
            <mml:mrow>
              <mml:mi>d</mml:mi>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mrow>
                  <mml:mi>t</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>ℒ</mml:mi>
                </mml:mrow>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>:</mml:mo>
              <mml:msub>
                <mml:mrow>
                  <mml:mi>min</mml:mi>
                </mml:mrow>
                <mml:mrow>
                  <mml:mi>x</mml:mi>
                  <mml:mo>∈</mml:mo>
                  <mml:mi>ℒ</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mrow>
                <mml:mo>‖</mml:mo>
                <mml:mrow>
                  <mml:mi>x</mml:mi>
                  <mml:mo>−</mml:mo>
                  <mml:mi>t</mml:mi>
                </mml:mrow>
                <mml:mo>‖</mml:mo>
              </mml:mrow>
              <mml:mo>.</mml:mo>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p><bold>Definition</bold><bold>9.</bold> (<italic>Closest</italic><italic>Vector</italic><italic>Problem</italic>). <italic>Given</italic><italic>a</italic><italic>basis</italic><inline-formula><mml:math><mml:mrow><mml:mi> B </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>of</italic><italic>a</italic><italic>lattice</italic><italic>L</italic>(<italic>B</italic>) <italic>and</italic><italic>a</italic><italic>target</italic><italic>vector</italic><italic>t</italic>, <italic>which</italic><italic>may</italic><italic>not</italic><italic>belong</italic><italic>to</italic><italic>the</italic><italic>lattice</italic>, <italic>find</italic><italic>the</italic><italic>lattice</italic><italic>point</italic><inline-formula><mml:math><mml:mrow><mml:mi> v </mml:mi><mml:mo> ∈ </mml:mo><mml:mi> L </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> B </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>closest</italic><italic>to</italic><italic>t</italic>.</p>
        <p>Therefore, the requested nonzero vector <inline-formula><mml:math><mml:mrow><mml:mi> v </mml:mi><mml:mo> ∈ </mml:mo><mml:mi> L </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> B </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> is the one for which <inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ‖ </mml:mo><mml:mrow><mml:mi> t </mml:mi><mml:mo> − </mml:mo><mml:mi> v </mml:mi></mml:mrow><mml:mo> ‖ </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> is minimal, <italic>i.e.</italic>, <inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ‖ </mml:mo><mml:mi> v </mml:mi><mml:mo> ‖ </mml:mo></mml:mrow><mml:mo> = </mml:mo><mml:mi> d </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> t </mml:mi><mml:mo> , </mml:mo><mml:mi> L </mml:mi></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> , as represented in <xref ref-type="fig" rid="fig6">Figure 6</xref>.</p>
        <fig id="fig8">
          <label>Figure 8</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId132.jpeg?20261019032334" />
        </fig>
        <p><bold>Figure 6.</bold> The closest vector problem [<xref ref-type="bibr" rid="B17">17</xref>].</p>
        <p><italic>C</italic>. <italic>Shortest</italic><italic>Independent</italic><italic>Vectors</italic><italic>Problem</italic> (<italic>SIVP</italic>)</p>
        <p>The primary objective is to identify a new basis that generates the same lattice while minimizing the length of the longest vector. <xref ref-type="fig" rid="fig7">Figure 7</xref> illustrates this problem.</p>
        <fig id="fig9">
          <label>Figure 9</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId133.jpeg?20261019032334" />
        </fig>
        <p><bold>Figure 7.</bold> Shortest Independent Vector Problem (SIVP) [<xref ref-type="bibr" rid="B17">17</xref>].</p>
        <p><bold>Definition</bold><bold>10</bold><bold>.</bold><italic>Shortest</italic><italic>Independent</italic><italic>Vectors</italic><italic>Problem</italic> (<italic>SIVP</italic>). <italic>Given</italic><italic>a</italic><italic>basis</italic><inline-formula><mml:math><mml:mrow><mml:mi> B </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> b </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> b </mml:mi><mml:mi> m </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>of</italic><italic>a</italic><italic>lattice</italic><inline-formula><mml:math><mml:mrow><mml:mi> L </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> B </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> , <italic>find</italic><italic>n</italic><italic>linearly</italic><italic>independent</italic><italic>vectors</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> v </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> v </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> v </mml:mi><mml:mi> n </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula><italic>that</italic><italic>belong</italic><italic>to</italic><italic>the</italic><italic>lattice</italic><italic>such</italic><italic>that</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ‖ </mml:mo><mml:mrow><mml:msub><mml:mi> v </mml:mi><mml:mi> i </mml:mi></mml:msub></mml:mrow><mml:mo> ‖ </mml:mo></mml:mrow><mml:mo> ≤ </mml:mo><mml:msub><mml:mi> λ </mml:mi><mml:mi> n </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula><italic>for</italic><inline-formula><mml:math><mml:mrow><mml:mn> 1 </mml:mn><mml:mo> ≤ </mml:mo><mml:mi> i </mml:mi><mml:mo> ≤ </mml:mo><mml:mi> n </mml:mi></mml:mrow></mml:math></inline-formula> .</p>
        <p><italic>D</italic>. <italic>Learning</italic><italic>with</italic><italic>Error</italic> (<italic>LWE</italic>) <italic>Problem</italic></p>
        <p>LWE has emerged as a fundamental element in efficient lattice-based protocols and is recognized as a significant milestone in the theoretical basis of PQC. This cryptosystem is believed to be as hard as the most difficult lattice problems. It generalizes the Learning Parity with Noise (LPN) problem to larger moduli. Specifically, the LWE problem considers a secret vector <inline-formula><mml:math><mml:mrow><mml:mi> s </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:msub><mml:mi> s </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> s </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> s </mml:mi><mml:mi> n </mml:mi></mml:msub></mml:mrow><mml:mo> ) </mml:mo></mml:mrow><mml:mo> ∈ </mml:mo><mml:msup><mml:mi> ℤ </mml:mi><mml:mi> n </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula> with integer coefficients and <inline-formula><mml:math><mml:mi> m </mml:mi></mml:math></inline-formula> linear equations, such that:</p>
        <disp-formula id="FD10">
          <label>(10)</label>
          <mml:math>
            <mml:mtable columnalign="left">
              <mml:mtr>
                <mml:mtd>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mn>11</mml:mn>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mn>1</mml:mn>
                  </mml:msub>
                  <mml:mo>+</mml:mo>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mn>12</mml:mn>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msub>
                  <mml:mo>+</mml:mo>
                  <mml:mo>⋯</mml:mo>
                  <mml:mo>+</mml:mo>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mn>1</mml:mn>
                      <mml:mi>n</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mi>n</mml:mi>
                  </mml:msub>
                  <mml:mo>≈</mml:mo>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mn>1</mml:mn>
                  </mml:msub>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mn>21</mml:mn>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mn>1</mml:mn>
                  </mml:msub>
                  <mml:mo>+</mml:mo>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mn>22</mml:mn>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msub>
                  <mml:mo>+</mml:mo>
                  <mml:mo>⋯</mml:mo>
                  <mml:mo>+</mml:mo>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mn>2</mml:mn>
                      <mml:mi>n</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mi>n</mml:mi>
                  </mml:msub>
                  <mml:mo>≈</mml:mo>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msub>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd>
                  <mml:mtext>
                     
                  </mml:mtext>
                  <mml:mtext>
                     
                  </mml:mtext>
                  <mml:mtext>
                     
                  </mml:mtext>
                  <mml:mo>⋮</mml:mo>
                </mml:mtd>
              </mml:mtr>
              <mml:mtr>
                <mml:mtd>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mi>m</mml:mi>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mn>1</mml:mn>
                  </mml:msub>
                  <mml:mo>+</mml:mo>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mi>m</mml:mi>
                      <mml:mn>2</mml:mn>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mn>2</mml:mn>
                  </mml:msub>
                  <mml:mo>+</mml:mo>
                  <mml:mo>⋯</mml:mo>
                  <mml:mo>+</mml:mo>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mrow>
                      <mml:mi>m</mml:mi>
                      <mml:mi>n</mml:mi>
                    </mml:mrow>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>s</mml:mi>
                    <mml:mi>n</mml:mi>
                  </mml:msub>
                  <mml:mo>≈</mml:mo>
                  <mml:msub>
                    <mml:mi>b</mml:mi>
                    <mml:mi>m</mml:mi>
                  </mml:msub>
                </mml:mtd>
              </mml:mtr>
            </mml:mtable>
          </mml:math>
        </disp-formula>
        <p>By adding noise to linear equations, the LWE problem complicates tasks like Gaussian elimination, rendering the resulting equations ineffective in providing useful information. Error accumulation makes it difficult to arrive at the correct outcome.</p>
        <p><bold>Definition</bold><bold>11.</bold> (<italic>LWE</italic>) <italic>Let</italic><italic>n</italic>, <italic>q</italic><italic>be</italic><italic>positive</italic><italic>integers</italic>, <italic>and</italic><italic>x</italic><italic>be</italic><italic>a</italic><italic>probability</italic><italic>distributio</italic><italic>n</italic><italic>on</italic><inline-formula><mml:math><mml:mi> ℤ </mml:mi></mml:math></inline-formula><italic>and</italic><italic>s</italic><italic>be</italic><italic>a</italic><italic>secret</italic><italic>vector</italic><italic>in</italic><inline-formula><mml:math><mml:mrow><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula> . <italic>We</italic><italic>denote</italic><italic>by</italic><inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> L </mml:mi><mml:mrow><mml:mi> s </mml:mi><mml:mo> , </mml:mo><mml:mi> x </mml:mi></mml:mrow></mml:msub></mml:mrow></mml:math></inline-formula><italic>the</italic><italic>probab</italic><italic>ility</italic><italic>distrib</italic><italic>ution</italic><italic>on</italic><inline-formula><mml:math><mml:mrow><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup><mml:mo> × </mml:mo><mml:msub><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula><italic>obtained</italic><italic>by</italic><italic>choosing</italic><inline-formula><mml:math><mml:mrow><mml:mi> a </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula><italic>uniformly</italic><italic>at</italic><italic>random</italic>, <italic>choosing</italic><inline-formula><mml:math><mml:mrow><mml:mi> e </mml:mi><mml:mo> ∈ </mml:mo><mml:mi> ℤ </mml:mi></mml:mrow></mml:math></inline-formula> . <italic>According</italic><italic>to</italic><italic>x</italic>, <italic>and</italic><italic>considering</italic><italic>it</italic><italic>in</italic><inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula><italic>and</italic><italic>returning</italic></p>
        <disp-formula id="FD11">
          <label>(11)</label>
          <mml:math>
            <mml:mrow>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mrow>
                  <mml:mi>a</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>b</mml:mi>
                </mml:mrow>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mrow>
                  <mml:mi>a</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mrow>
                    <mml:mo>〈</mml:mo>
                    <mml:mrow>
                      <mml:mi>a</mml:mi>
                      <mml:mo>,</mml:mo>
                      <mml:mi>s</mml:mi>
                    </mml:mrow>
                    <mml:mo>〉</mml:mo>
                  </mml:mrow>
                  <mml:mo>+</mml:mo>
                  <mml:mi>e</mml:mi>
                </mml:mrow>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>∈</mml:mo>
              <mml:msubsup>
                <mml:mi>ℤ</mml:mi>
                <mml:mi>q</mml:mi>
                <mml:mi>n</mml:mi>
              </mml:msubsup>
              <mml:mo>×</mml:mo>
              <mml:msub>
                <mml:mi>ℤ</mml:mi>
                <mml:mi>q</mml:mi>
              </mml:msub>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>Decision-LWE is the problem of deciding whether pairs <inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> a </mml:mi><mml:mo> , </mml:mo><mml:mi> b </mml:mi></mml:mrow><mml:mo> ) </mml:mo></mml:mrow><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup><mml:mo> × </mml:mo><mml:msub><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula> are sampled according to <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> L </mml:mi><mml:mrow><mml:mi> s </mml:mi><mml:mo> , </mml:mo><mml:mi> x </mml:mi></mml:mrow></mml:msub></mml:mrow></mml:math></inline-formula> or the uniform distribution on <inline-formula><mml:math><mml:mrow><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup><mml:mo> × </mml:mo><mml:msub><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula> .</p>
        <p>Search-LWE is the problem of recovering <italic>s</italic> from <inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> a </mml:mi><mml:mo> , </mml:mo><mml:mi> b </mml:mi></mml:mrow><mml:mo> ) </mml:mo></mml:mrow><mml:mo> = </mml:mo><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> a </mml:mi><mml:mo> , </mml:mo><mml:mrow><mml:mo> 〈 </mml:mo><mml:mrow><mml:mi> a </mml:mi><mml:mo> , </mml:mo><mml:mi> s </mml:mi></mml:mrow><mml:mo> 〉 </mml:mo></mml:mrow><mml:mo> + </mml:mo><mml:mi> e </mml:mi></mml:mrow><mml:mo> ) </mml:mo></mml:mrow><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup><mml:mo> × </mml:mo><mml:msub><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula> sampled according to <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> L </mml:mi><mml:mrow><mml:mi> s </mml:mi><mml:mo> , </mml:mo><mml:mi> x </mml:mi></mml:mrow></mml:msub></mml:mrow></mml:math></inline-formula> .</p>
        <p>The solution is asked to lie in a subset <inline-formula><mml:math><mml:mrow><mml:mi> S </mml:mi><mml:mo> ⊂ </mml:mo><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> m </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula> . Where <italic>S</italic> can be a subset such that <inline-formula><mml:math><mml:mrow><mml:mi> S </mml:mi><mml:mo></mml:mo><mml:mo> = </mml:mo><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:mn> 0 </mml:mn><mml:mo> , </mml:mo><mml:mn> 1 </mml:mn></mml:mrow><mml:mo> } </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> or, in general, the set of all solutions <inline-formula><mml:math><mml:mrow><mml:mi> S </mml:mi><mml:mo> = </mml:mo><mml:msup><mml:mrow><mml:mrow><mml:mo> [ </mml:mo><mml:mrow><mml:mo> − </mml:mo><mml:mi> B </mml:mi><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:mi> B </mml:mi></mml:mrow><mml:mo> ] </mml:mo></mml:mrow></mml:mrow><mml:mi> m </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula> , and each coordinate takes an absolute value bounded by some number <inline-formula><mml:math><mml:mrow><mml:mi> B </mml:mi><mml:mo> ≪ </mml:mo><mml:mrow><mml:mi> q </mml:mi><mml:mo> / </mml:mo><mml:mn> 2 </mml:mn></mml:mrow></mml:mrow></mml:math></inline-formula> . This is the Short Integer Solution (SIS) problem. The LWE problem is regarded as an analog of the SIS problem. To further improve efficiency while preserving security, the M-LWE problem generalizes LWE by introducing a ring structure. For a polynomial ring <inline-formula><mml:math><mml:mrow><mml:mi> R </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mrow><mml:mi> ℤ </mml:mi><mml:mrow><mml:mo> [ </mml:mo><mml:mi> X </mml:mi><mml:mo> ] </mml:mo></mml:mrow></mml:mrow><mml:mo> / </mml:mo><mml:mrow><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:msup><mml:mi> X </mml:mi><mml:mi> n </mml:mi></mml:msup><mml:mo> + </mml:mo><mml:mn> 1 </mml:mn></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:mrow></mml:mrow></mml:math></inline-formula> and modulus <italic>q</italic>, M-LWE is defined over the module <inline-formula><mml:math><mml:mrow><mml:msubsup><mml:mi> R </mml:mi><mml:mi> q </mml:mi><mml:mi> k </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula> as follows [<xref ref-type="bibr" rid="B18">18</xref>]:</p>
        <disp-formula id="FD12">
          <label>(12)</label>
          <mml:math>
            <mml:mrow>
              <mml:msub>
                <mml:mrow>
                  <mml:mtext>M-LWE</mml:mtext>
                </mml:mrow>
                <mml:mrow>
                  <mml:mi>n</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>k</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>q</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>x</mml:mi>
                </mml:mrow>
              </mml:msub>
              <mml:mo>:</mml:mo>
              <mml:mtext>Given</mml:mtext>
              <mml:mtext>
                 
              </mml:mtext>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mrow>
                  <mml:mi>A</mml:mi>
                  <mml:mo>,</mml:mo>
                  <mml:mi>b</mml:mi>
                  <mml:mo>=</mml:mo>
                  <mml:mi>A</mml:mi>
                  <mml:mi>S</mml:mi>
                  <mml:mo>+</mml:mo>
                  <mml:mi>e</mml:mi>
                </mml:mrow>
                <mml:mo>)</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>with <inline-formula><mml:math><mml:mrow><mml:mi> A </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi> R </mml:mi><mml:mi> q </mml:mi><mml:mrow><mml:mi> k </mml:mi><mml:mo> × </mml:mo><mml:mi> k </mml:mi></mml:mrow></mml:msubsup><mml:mo> , </mml:mo><mml:mi> s </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi> R </mml:mi><mml:mi> q </mml:mi><mml:mi> k </mml:mi></mml:msubsup><mml:mo> , </mml:mo><mml:mi> e </mml:mi><mml:mo> ← </mml:mo><mml:msup><mml:mi> x </mml:mi><mml:mi> k </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula> distinguishing this distribution from uniform.</p>
        <p>This refinement underpins NIST’s standardized schemes: the Module-Lattice Key Encapsulation Mechanism (ML-KEM) and the Module-Lattice Digital Signature Algorithm (ML-DSA). These constructions balance rigorous theoretical guarantees with computational efficiency, rendering them suitable for practical deployment and ensuring they inherit the robust hardness assumptions of classical lattice problems [<xref ref-type="bibr" rid="B18">18</xref>].</p>
        <p><italic>E</italic>. <italic>Short</italic><italic>Integer</italic><italic>Solution</italic> (<italic>SIS</italic>) <italic>Problem</italic></p>
        <p>The Short Integer Solution (SIS) problem requires identifying a nonzero short vector in a specific class of random lattices, known as random <italic>q</italic>-ary lattices.</p>
        <p><bold>Definition</bold><bold>12.</bold> (<italic>The</italic><italic>Short</italic><italic>Integer</italic><italic>Solution</italic><italic>problem</italic>) <italic>parameterized</italic><italic>by</italic><italic>positive</italic><italic>integers</italic><italic>n</italic>, <italic>m</italic>, <italic>and</italic><italic>q</italic>, <italic>denoted</italic><italic>by</italic> SIS<italic><sub>n</sub></italic><sub>,</sub><italic><sub>m</sub></italic><sub>,</sub><italic><sub>q</sub></italic><sub>,</sub><italic><sub>β</sub></italic>. <italic>Given</italic><italic>m</italic><italic>uniformly</italic><italic>random</italic><italic>vector</italic><inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> a </mml:mi><mml:mi> i </mml:mi></mml:msub><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula><italic>forming</italic><italic>the</italic><italic>column</italic><italic>of</italic><italic>a</italic><italic>matrix</italic><inline-formula><mml:math><mml:mrow><mml:mi> A </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi><mml:mrow><mml:mi> n </mml:mi><mml:mo> × </mml:mo><mml:mi> m </mml:mi></mml:mrow></mml:msubsup></mml:mrow></mml:math></inline-formula> , <italic>find</italic><italic>a</italic><italic>nonzero</italic><italic>integer</italic><italic>vector</italic><inline-formula><mml:math><mml:mrow><mml:mi> z </mml:mi><mml:mo> ∈ </mml:mo><mml:msup><mml:mi> ℤ </mml:mi><mml:mi> m </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula><italic>of</italic><italic>norm</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ‖ </mml:mo><mml:mi> z </mml:mi><mml:mo> ‖ </mml:mo></mml:mrow><mml:mo> ≤ </mml:mo><mml:mi> β </mml:mi></mml:mrow></mml:math></inline-formula> , <italic>such</italic><italic>that</italic>:</p>
        <disp-formula id="FD13">
          <label>(13)</label>
          <mml:math>
            <mml:mrow>
              <mml:msub>
                <mml:mi>f</mml:mi>
                <mml:mi>A</mml:mi>
              </mml:msub>
              <mml:mrow>
                <mml:mo>(</mml:mo>
                <mml:mi>z</mml:mi>
                <mml:mo>)</mml:mo>
              </mml:mrow>
              <mml:mo>:</mml:mo>
              <mml:mo>=</mml:mo>
              <mml:mi>A</mml:mi>
              <mml:mi>z</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mstyle displaystyle="true">
                <mml:msub>
                  <mml:mo>∑</mml:mo>
                  <mml:mi>i</mml:mi>
                </mml:msub>
                <mml:mrow>
                  <mml:msub>
                    <mml:mi>a</mml:mi>
                    <mml:mi>i</mml:mi>
                  </mml:msub>
                  <mml:msub>
                    <mml:mi>z</mml:mi>
                    <mml:mi>i</mml:mi>
                  </mml:msub>
                </mml:mrow>
              </mml:mstyle>
              <mml:mo>=</mml:mo>
              <mml:mn>0</mml:mn>
              <mml:mo>∈</mml:mo>
              <mml:msubsup>
                <mml:mi>ℤ</mml:mi>
                <mml:mi>q</mml:mi>
                <mml:mi>n</mml:mi>
              </mml:msubsup>
              <mml:mo>.</mml:mo>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>In terms of a lattice problem, the SIS problem states that, given a lattice generated by A, find a nonzero integer vector <inline-formula><mml:math><mml:mrow><mml:mi> z </mml:mi><mml:mo> ∈ </mml:mo><mml:msup><mml:mi> ℤ </mml:mi><mml:mi> n </mml:mi></mml:msup></mml:mrow></mml:math></inline-formula> such that: </p>
        <disp-formula id="FD14">
          <label>(14)</label>
          <mml:math>
            <mml:mrow>
              <mml:mi>A</mml:mi>
              <mml:mo>⋅</mml:mo>
              <mml:mi>z</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mn>0</mml:mn>
              <mml:mi>mod</mml:mi>
              <mml:mi>q</mml:mi>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>Lattice-based cryptography is a promising approach to PQC for its security, flexibility, and resistance to quantum attacks. A distinguishing characteristic of lattice-based cryptography is its reliance on worst-case security, whereas most other cryptosystems are based on average-case security. Several lattice-based algorithms are leading candidates, each offering distinct advantages in terms of security, computational efficiency, and practical usability.</p>
        <p><bold>CRYSTAL</bold><bold>-KYBER</bold> is part of the <bold>Cry</bold>ptographic <bold>S</bold>ui<bold>t</bold>e for <bold>A</bold>lgebraic <bold>L</bold>attice<bold>s</bold> (CRYSTAL) family of primitives. In late 2022, the National Institute of Standards and Technology (NIST) standardized the CRYSTALS-Kyber algorithm, citing its strong security, efficient hardware and software implementations across multiple platforms, and compatibility with most existing internet protocols and cryptographic applications [<xref ref-type="bibr" rid="B15">15</xref>]. KYBER has been proposed as a public-key algorithm offering security levels comparable to Advanced Encryption Standard (AES) schemes. It functions as a Key Encapsulation Mechanism (KEM) and is based on the computational hardness of the Module-Learning-With-Errors (MLWE) problem. A KEM consists of three algorithms: Key Generation, Encapsulation, and Decapsulation. In a standard key-establishment procedure, the recipient generates a public-private key pair. The sender then uses the recipient’s public key to perform the encapsulation operation, which produces both a ciphertext and a shared secret. The recipient applies the corresponding private key to decapsulate the ciphertext and independently derive the same shared secret. This shared secret may be used directly or processed through a key-derivation function to generate a symmetric session key, enabling efficient authenticated encryption and secure communication. Consequently, Kyber is not primarily intended for encrypting application data. Its main function is to provide a quantum-resistant way to establish cryptographic keying material, after which symmetric-key cryptography can efficiently secure the exchanged data.</p>
        <p><bold>SABER</bold> is a finalist in the Public-Key Encryption (PKE) category for PQC, with security based on the hardness of the MLWR problem. Developed by Banerjee, Peikert, and Rosen at EUROCRYPT 2012, SABER achieves Indistinguishability under Chosen-Plaintext Attack (IND-CPA). The scheme employs a hierarchical structure of algorithms. First, it constructs a CPA-secure public-key encryption scheme based on the MLWR problem. Subsequently, a post-quantum adaptation of the Fujisaki-Okamoto transform constructs a Chosen-Ciphertext Attack (CCA)-secure KEM scheme [<xref ref-type="bibr" rid="B19">19</xref>].</p>
        <p><bold>CRYSTALS-Dilithium</bold> is a digital signature scheme that relies on the complexity of the Module Short Integer Solution (MSIS) and MLWE problems. As part of the CRYSTALS suite, NIST selected it as a finalist in the post-quantum cryptography standardization process in July 2020. The scheme operates within a polynomial ring defined by two integers, <italic>n</italic> and <italic>q</italic>, with a matrix of polynomials used in its operations. Security levels can be adjusted by varying the matrix dimensions, enabling optimization across different levels. Dilithium offers four parameter sets: weak, medium, recommended, and very high, with the recommended level featuring 2.7 KB signatures and 1.5 KB public keys.</p>
        <p><bold>NTRU</bold> (<bold>N</bold>-th degree <bold>T</bold>runcated polynomial <bold>R</bold>ing <bold>U</bold>nit), introduced in 1998 by Hoffstein, Pipher, and Silverman, represents the first practical public-key encryption scheme utilizing lattices over polynomial rings. It supports both encryption (NTRUencrypt) and digital signatures (NTRUSign). Its security hinges on the difficult shortest vector problem in lattice reduction, for which no known polynomial-time solution exists. In 2009, the IEEE approved NTRU for standardization. Although NIST did not select NTRU as one of the top four quantum-resistant algorithms, it offers advantages over competitors such as KYBER and Saber, including a compact ciphertext and potentially faster encryption and decryption [<xref ref-type="bibr" rid="B20">20</xref>].</p>
        <p><bold>Falco</bold><bold>n</bold> (<bold>Fa</bold>st-Fourier <bold>L</bold>attice-based <bold>Co</bold>mpact Signatures over <bold>N</bold>TRU) is a cryptographic signature algorithm that was submitted to the NIST Post-Quantum Cryptography Project on November 30, 2017. It is based on NTRU and employs lattice-based techniques to provide a robust solution for digital signing in the context of quantum computing. The algorithm utilizes a technique based on the work of Gentry, Peikert, and Vaikuntanathan, combined with Fast Fourier sampling, to generate signatures. Falcon’s core elements are polynomials with integer coefficients, usually of degree that is a power of two, such as 512 or 1024. It performs calculations in the field of <inline-formula><mml:math display="inline"><mml:mrow><mml:mrow><mml:mrow><mml:mi> Q </mml:mi><mml:mrow><mml:mo> [ </mml:mo><mml:mi> x </mml:mi><mml:mo> ] </mml:mo></mml:mrow></mml:mrow><mml:mo> / </mml:mo><mml:mrow><mml:mrow><mml:mo> ( </mml:mo><mml:mi> ϕ </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:mrow></mml:mrow></mml:math></inline-formula> , operating under a monic polynomial of degree represented as <inline-formula><mml:math><mml:mi> ϕ </mml:mi></mml:math></inline-formula> , which takes the form <inline-formula><mml:math><mml:mrow><mml:mi> ϕ </mml:mi><mml:mo> = </mml:mo><mml:msup><mml:mi> x </mml:mi><mml:mi> n </mml:mi></mml:msup><mml:mo> + </mml:mo><mml:mn> 1 </mml:mn></mml:mrow></mml:math></inline-formula> . Falcon’s structure includes three key processes: key generation, signature generation, and verification [<xref ref-type="bibr" rid="B21">21</xref>].</p>
        <p>In post-quantum cryptography, schemes such as CRYSTALS-Kyber, NTRU, and SABER address key encapsulation and secure key exchange, while Falcon and CRYSTALS-Dilithium serve as digital signature methods. NIST selected CRYSTALS-Kyber as the standard KEM for its security and efficiency. Dilithium offers effective signature creation with simple implementation, whereas Falcon yields smaller signature sizes but incurs greater complexity. NTRU is one of the earliest lattice-based systems, while SABER offers an efficient alternative based on Module-LWR that avoids the need for the NTT.</p>
        <p>3.2.2. Code-Based Cryptography Methods</p>
        <p>Code-based cryptography leverages the intractability of decoding general linear codes, a challenge that quantum computers also find insurmountable. This approach is based on the difficulty of decoding error-correcting codes known as Goppa codes, which remain unbroken and are linear codes with fast-decoding algorithms. They are used in a wide range of applications, including hard drives, satellite communication, and fault-tolerant quantum computation.</p>
        <p><bold>Definition</bold><bold>13.</bold><italic>Let</italic><inline-formula><mml:math><mml:mrow><mml:mi> g </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> z </mml:mi><mml:mo> ) </mml:mo></mml:mrow><mml:mo> = </mml:mo><mml:msub><mml:mi> g </mml:mi><mml:mn> 0 </mml:mn></mml:msub><mml:mo> + </mml:mo><mml:msub><mml:mi> g </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mi> z </mml:mi><mml:mo> + </mml:mo><mml:msub><mml:mi> g </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:msup><mml:mi> z </mml:mi><mml:mn> 2 </mml:mn></mml:msup><mml:mo> + </mml:mo><mml:mn> ... </mml:mn><mml:mo> + </mml:mo><mml:msub><mml:mi> g </mml:mi><mml:mi> t </mml:mi></mml:msub><mml:msup><mml:mi> z </mml:mi><mml:mi> t </mml:mi></mml:msup><mml:mo> ∈ </mml:mo><mml:msub><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mrow><mml:msup><mml:mi> q </mml:mi><mml:mi> m </mml:mi></mml:msup></mml:mrow></mml:msub><mml:mrow><mml:mo> [ </mml:mo><mml:mi> z </mml:mi><mml:mo> ] </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> , <italic>and</italic><italic>let</italic><inline-formula><mml:math><mml:mrow><mml:mi> L </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mo> { </mml:mo><mml:mrow><mml:msub><mml:mi> α </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> α </mml:mi><mml:mn> 2 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> α </mml:mi><mml:mi> n </mml:mi></mml:msub></mml:mrow><mml:mo> } </mml:mo></mml:mrow><mml:mo> ⊆ </mml:mo><mml:msub><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mrow><mml:msup><mml:mi> q </mml:mi><mml:mi> m </mml:mi></mml:msup></mml:mrow></mml:msub></mml:mrow></mml:math></inline-formula><italic>such</italic><italic>that</italic><inline-formula><mml:math display="inline"><mml:mrow><mml:mi> g </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:msub><mml:mi> α </mml:mi><mml:mi> i </mml:mi></mml:msub></mml:mrow><mml:mo> ) </mml:mo></mml:mrow><mml:mo> ≠ </mml:mo><mml:mn> 0 </mml:mn></mml:mrow></mml:math></inline-formula> , <italic>all</italic><inline-formula><mml:math display="inline"><mml:mrow><mml:msub><mml:mi> α </mml:mi><mml:mi> i </mml:mi></mml:msub><mml:mo> ∈ </mml:mo><mml:mi> L </mml:mi></mml:mrow></mml:math></inline-formula> . <italic>Then</italic>, <italic>the</italic><italic>code</italic><italic>def</italic><italic>ined</italic><italic>by</italic></p>
        <disp-formula id="FD15">
          <label>(15)</label>
          <mml:math>
            <mml:mrow>
              <mml:mrow>
                <mml:mo>{</mml:mo>
                <mml:mrow>
                  <mml:mi>c</mml:mi>
                  <mml:mo>=</mml:mo>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>c</mml:mi>
                        <mml:mn>1</mml:mn>
                      </mml:msub>
                      <mml:mo>,</mml:mo>
                      <mml:msub>
                        <mml:mi>c</mml:mi>
                        <mml:mn>2</mml:mn>
                      </mml:msub>
                      <mml:mo>,</mml:mo>
                      <mml:mo>⋯</mml:mo>
                      <mml:mo>,</mml:mo>
                      <mml:msub>
                        <mml:mi>c</mml:mi>
                        <mml:mi>n</mml:mi>
                      </mml:msub>
                    </mml:mrow>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                  <mml:mo>∈</mml:mo>
                  <mml:msubsup>
                    <mml:mi mathvariant="double-struck">F</mml:mi>
                    <mml:mi>q</mml:mi>
                    <mml:mi>n</mml:mi>
                  </mml:msubsup>
                  <mml:mo>:</mml:mo>
                  <mml:mstyle displaystyle="true">
                    <mml:msubsup>
                      <mml:mo>∑</mml:mo>
                      <mml:mrow>
                        <mml:mi>i</mml:mi>
                        <mml:mo>=</mml:mo>
                        <mml:mn>1</mml:mn>
                      </mml:mrow>
                      <mml:mi>n</mml:mi>
                    </mml:msubsup>
                    <mml:mrow>
                      <mml:mfrac>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>c</mml:mi>
                            <mml:mi>i</mml:mi>
                          </mml:msub>
                        </mml:mrow>
                        <mml:mrow>
                          <mml:mi>z</mml:mi>
                          <mml:mo>−</mml:mo>
                          <mml:msub>
                            <mml:mi>α</mml:mi>
                            <mml:mi>i</mml:mi>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mfrac>
                    </mml:mrow>
                  </mml:mstyle>
                  <mml:mo>≡</mml:mo>
                  <mml:mn>0</mml:mn>
                  <mml:mi>mod</mml:mi>
                  <mml:mi>g</mml:mi>
                  <mml:mrow>
                    <mml:mo>(</mml:mo>
                    <mml:mi>z</mml:mi>
                    <mml:mo>)</mml:mo>
                  </mml:mrow>
                </mml:mrow>
                <mml:mo>}</mml:mo>
              </mml:mrow>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>is called Goppa code with parameters <inline-formula><mml:math display="inline"><mml:mrow><mml:mi> g </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> z </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> and <italic>L</italic>; denoted by <inline-formula><mml:math><mml:mrow><mml:mi> Γ </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> L </mml:mi><mml:mo> , </mml:mo><mml:mi> g </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> z </mml:mi><mml:mo> ) </mml:mo></mml:mrow></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> .</p>
        <p>The general problems in coding theory that underlie the security of code-based cryptosystems are listed below.</p>
        <p><bold>Problem</bold><bold>1.</bold><italic>General</italic><italic>Decoding</italic>. <italic>Given</italic><inline-formula><mml:math><mml:mrow><mml:mi> G </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mi> q </mml:mi><mml:mrow><mml:mi> k </mml:mi><mml:mo> × </mml:mo><mml:mi> n </mml:mi></mml:mrow></mml:msubsup></mml:mrow></mml:math></inline-formula><italic>of</italic><italic>rank</italic><inline-formula><mml:math><mml:mi> k </mml:mi></mml:math></inline-formula> , <inline-formula><mml:math><mml:mrow><mml:mi> t </mml:mi><mml:mo> ∈ </mml:mo><mml:mrow><mml:mo> [ </mml:mo><mml:mrow><mml:mn> 0 </mml:mn><mml:mo> , </mml:mo><mml:mi> n </mml:mi></mml:mrow><mml:mo> ] </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> , <inline-formula><mml:math><mml:mrow><mml:mi> y </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula><italic>where</italic><inline-formula><mml:math><mml:mrow><mml:mi> y </mml:mi><mml:mo> = </mml:mo><mml:mi> c </mml:mi><mml:mo> + </mml:mo><mml:mi> e </mml:mi></mml:mrow></mml:math></inline-formula><italic>with</italic><inline-formula><mml:math><mml:mrow><mml:mi> c </mml:mi><mml:mo> = </mml:mo><mml:mi> m </mml:mi><mml:mi> G </mml:mi></mml:mrow></mml:math></inline-formula><italic>for</italic><italic>some</italic><inline-formula><mml:math><mml:mrow><mml:mi> m </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mi> q </mml:mi><mml:mi> k </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula><italic>and</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> | </mml:mo><mml:mi> e </mml:mi><mml:mo> | </mml:mo></mml:mrow><mml:mo> = </mml:mo><mml:mi> t </mml:mi></mml:mrow></mml:math></inline-formula> , <italic>find</italic><inline-formula><mml:math><mml:mi> e </mml:mi></mml:math></inline-formula> .</p>
        <p><bold>P</bold><bold>r</bold><bold>oblem</bold><bold>2.</bold><italic>Syndrome</italic><italic>Decoding</italic>. <italic>Given</italic><inline-formula><mml:math><mml:mrow><mml:mi> H </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mi> q </mml:mi><mml:mrow><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> n </mml:mi><mml:mo> − </mml:mo><mml:mi> k </mml:mi></mml:mrow><mml:mo> ) </mml:mo></mml:mrow><mml:mo> × </mml:mo><mml:mi> n </mml:mi></mml:mrow></mml:msubsup></mml:mrow></mml:math></inline-formula><italic>of</italic><italic>rank</italic><inline-formula><mml:math display="inline"><mml:mrow><mml:mi> n </mml:mi><mml:mo> − </mml:mo><mml:mi> k </mml:mi></mml:mrow></mml:math></inline-formula> , <inline-formula><mml:math><mml:mrow><mml:mi> t </mml:mi><mml:mo> ∈ </mml:mo><mml:mrow><mml:mo> [ </mml:mo><mml:mrow><mml:mn> 0 </mml:mn><mml:mo> , </mml:mo><mml:mi> n </mml:mi></mml:mrow><mml:mo> ] </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> , <inline-formula><mml:math><mml:mrow><mml:mi> s </mml:mi><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mi> q </mml:mi><mml:mrow><mml:mo></mml:mo><mml:mi> n </mml:mi><mml:mo> − </mml:mo><mml:mi> k </mml:mi></mml:mrow></mml:msubsup></mml:mrow></mml:math></inline-formula><italic>where</italic><inline-formula><mml:math><mml:mrow><mml:mi> H </mml:mi><mml:msup><mml:mi> e </mml:mi><mml:mtext> T </mml:mtext></mml:msup><mml:mo> = </mml:mo><mml:msup><mml:mi> s </mml:mi><mml:mtext> T </mml:mtext></mml:msup></mml:mrow></mml:math></inline-formula><italic>with</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> | </mml:mo><mml:mi> e </mml:mi><mml:mo> | </mml:mo></mml:mrow><mml:mo> = </mml:mo><mml:mi> t </mml:mi></mml:mrow></mml:math></inline-formula> , <italic>find</italic><inline-formula><mml:math><mml:mi> e </mml:mi></mml:math></inline-formula> .</p>
        <p>The problem remains exponentially hard in the general case, even after extensive research in coding theory, information theory, and computational complexity. This persistent difficulty supports strong confidence in the long-term security of code-based cryptography, which is underpinned by robust mathematical foundations and an extensive history of cryptanalysis. Code-based cryptography offers security guarantees established through decades of theoretical and practical analysis. Notably, the original McEliece cryptosystem has withstood attacks for nearly five decades of intensive cryptanalytic scrutiny [<xref ref-type="bibr" rid="B18">18</xref>].</p>
        <p><bold>Classic</bold><bold>McEliece</bold> is a code-based KEM that utilizes binary Goppa codes within the Niederreiter variant of the McEliece cryptosystem. These codes, combined with established cryptographic techniques, achieve IND-CCA2 security and resist chosen-ciphertext attacks. The original McEliece cryptosystem was developed to guarantee One-Wayness under Chosen-Plaintext Attacks (OW-CPA), ensuring that if an adversary randomly selects a codeword, it cannot efficiently recover it from the ciphertext and public key. McEliece’s security level has remained stable over time. The cryptosystem is based on three core algorithms: a probabilistic key-generation algorithm that outputs a public-private key pair, a probabilistic encryption algorithm, and a deterministic decryption algorithm. In a McEliece deployment, all users employ the same security parameters: <italic>n</italic>, <italic>t</italic>, <italic>and</italic><italic>k</italic>. <italic>The</italic><italic>r</italic>ecommended parameter values are <italic>n</italic> = 1024, <italic>t</italic> = 38, <italic>and</italic><italic>k</italic> = 644 [<xref ref-type="bibr" rid="B22">22</xref>].</p>
        <p><bold>HQC</bold> (Hamming Quasi-Cyclic) is a KEM that employs quasi-cyclic codes without embedding a trapdoor in the code. This approach leverages the distinctive properties of quasi-cyclic codes and provides a direct security reduction to decoding random linear codes. Unlike similar candidates, the security proof for HQC relies solely on assumptions related to the decisional Quasi-Cyclic Syndrome Decoding (QCSD) problem [<xref ref-type="bibr" rid="B23">23</xref>]. HQC’s IND-CPA security relies on the computational hardness of QCSD and the associated parity issue. Applying the Fujisaki-Okamoto (FO) transformation to a CPA-secure Public-Key Encryption (PKE) scheme enables HQC to achieve IND-CCA2 KEM security. Although the quasi-cyclic structure of HQC yields relatively small public keys and ciphertexts, they remain larger than those of structured lattice-based KEMs. NIST has determined that HQC complements ML-KEM effectively, as it is based on a distinct security foundation while maintaining sufficient performance for general applications. NIST further asserts that the HQC submission satisfies the requirements for a low Decryption Failure Rate (DFR), thereby ensuring IND-CCA2 security [<xref ref-type="bibr" rid="B14">14</xref>].</p>
        <p><bold>BIKE</bold> (Bit-Flipping Key Encapsulation) is a KEM based on binary linear Quasi-Cyclic Moderate-Density Parity-Check (QC-MDPC) codes, a class of error-correcting codes that enable efficient encryption, decryption, and key exchange. Although the BIKE cryptosystem was originally developed for ephemeral key use, it is now claimed to support static-key applications as well.</p>
        <p><bold>Definitio</bold><bold>n</bold><bold>14.</bold><italic>A</italic><italic>quasi</italic>-<italic>cyclic</italic><italic>code</italic><italic>is</italic><italic>a</italic><italic>linear</italic><italic>code</italic><italic>for</italic><italic>which</italic><italic>cyclically</italic><italic>shifting</italic><italic>a</italic><italic>codewor</italic><italic>d</italic><italic>a</italic><italic>fixed</italic><italic>number</italic><italic>n</italic><sub>0</sub> ≠ 0 <italic>of</italic><italic>positions</italic><italic>either</italic><italic>to</italic><italic>the</italic><italic>right</italic><italic>or</italic><italic>to</italic><italic>the</italic><italic>left</italic><italic>results</italic><italic>i</italic><italic>n</italic><italic>another</italic><italic>codeword</italic>. <italic>For</italic><italic>n</italic><sub>0</sub> = 1, <italic>a</italic><italic>quasi</italic>-<italic>cyclic</italic><italic>code</italic><italic>is</italic><italic>a</italic><italic>cyclic</italic><italic>code</italic>. <italic>The</italic><italic>integer</italic><italic>n</italic><sub>0</sub><italic>is</italic><italic>called</italic><italic>the</italic><italic>shifting</italic><italic>constraint</italic>.</p>
        <p>Several standard methods represent a quasi-cyclic parity-check code. For a code with a shifting constraint <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> n </mml:mi><mml:mn> 0 </mml:mn></mml:msub></mml:mrow></mml:math></inline-formula> and positive integers <inline-formula><mml:math><mml:mi> c </mml:mi></mml:math></inline-formula> and <inline-formula><mml:math><mml:mi> t </mml:mi></mml:math></inline-formula> , <italic>where</italic><inline-formula><mml:math><mml:mrow><mml:mi> c </mml:mi><mml:mo> &lt; </mml:mo><mml:mi> t </mml:mi></mml:mrow></mml:math></inline-formula> , let <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> H </mml:mi><mml:mi> i </mml:mi></mml:msub><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mn> 2 </mml:mn><mml:mrow><mml:mi> c </mml:mi><mml:mo> × </mml:mo><mml:msub><mml:mi> n </mml:mi><mml:mn> 0 </mml:mn></mml:msub></mml:mrow></mml:msubsup></mml:mrow></mml:math></inline-formula> for <inline-formula><mml:math><mml:mrow><mml:mi> i </mml:mi><mml:mo> ∈ </mml:mo><mml:mrow><mml:mo> [ </mml:mo><mml:mi> t </mml:mi><mml:mo> ] </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> . The nullspace of is then a quasi-cyclic parity-check code [<xref ref-type="bibr" rid="B24">24</xref>].</p>
        <disp-formula id="FD16">
          <label>(16)</label>
          <mml:math display="inline">
            <mml:mrow>
              <mml:mi>H</mml:mi>
              <mml:mo>=</mml:mo>
              <mml:mrow>
                <mml:mo>[</mml:mo>
                <mml:mrow>
                  <mml:mtable>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mn>1</mml:mn>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mn>2</mml:mn>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mo>⋯</mml:mo>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mi>t</mml:mi>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mi>t</mml:mi>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mn>1</mml:mn>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mo>⋯</mml:mo>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mrow>
                              <mml:mi>t</mml:mi>
                              <mml:mo>−</mml:mo>
                              <mml:mn>1</mml:mn>
                            </mml:mrow>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mo>⋮</mml:mo>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mo>⋮</mml:mo>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mo>⋱</mml:mo>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mo>⋮</mml:mo>
                      </mml:mtd>
                    </mml:mtr>
                    <mml:mtr>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mn>2</mml:mn>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mn>3</mml:mn>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mo>⋯</mml:mo>
                      </mml:mtd>
                      <mml:mtd>
                        <mml:mrow>
                          <mml:msub>
                            <mml:mi>H</mml:mi>
                            <mml:mn>1</mml:mn>
                          </mml:msub>
                        </mml:mrow>
                      </mml:mtd>
                    </mml:mtr>
                  </mml:mtable>
                </mml:mrow>
                <mml:mo>]</mml:mo>
              </mml:mrow>
              <mml:mo>∈</mml:mo>
              <mml:msubsup>
                <mml:mi mathvariant="double-struck">F</mml:mi>
                <mml:mi>q</mml:mi>
                <mml:mrow>
                  <mml:mi>t</mml:mi>
                  <mml:mi>c</mml:mi>
                  <mml:mo>×</mml:mo>
                  <mml:mi>t</mml:mi>
                  <mml:msub>
                    <mml:mi>n</mml:mi>
                    <mml:mn>0</mml:mn>
                  </mml:msub>
                </mml:mrow>
              </mml:msubsup>
            </mml:mrow>
          </mml:math>
        </disp-formula>
        <p>The secret key comprises a parity-check matrix <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> H </mml:mi><mml:mrow><mml:mi> r </mml:mi><mml:mo> × </mml:mo><mml:mn> 2 </mml:mn><mml:mi> r </mml:mi></mml:mrow></mml:msub></mml:mrow></mml:math></inline-formula> , for a Quasi-Cyclic Moderate-Density Parity-Check (QC-MDPC) code, where <italic>r</italic> denotes a prime number. Each row of matrix <italic>H</italic> possesses a specified weight. The secret key is denoted by (<italic>h</italic><sub>0</sub>, <italic>h</italic><sub>1</sub>), and the public key is derived from it. During encryption, the message is interpreted as an error vector <italic>e</italic> of weight <italic>t</italic>, and the ciphertext is computed accordingly. Decryption requires multiplying the ciphertext by <italic>h</italic><sub>0</sub> to obtain the syndrome, which is subsequently decoded using a Black-Grey-Flip (BGF) decoder to recover either the error vector or the original message [<xref ref-type="bibr" rid="B9">9</xref>]. The security of the BIKE algorithm relies on the computational intractability of decoding randomly generated error-correcting codes without knowledge of the private key, which poses significant challenges for attackers, including those equipped with quantum computers, attempting to recover the shared key.</p>
        <p>3.2.3. Hash-Based Cryptography Methods</p>
        <p>Hash functions are mathematical tools that convert input data of any size into a fixed-length output, called a hash value. A key characteristic of these functions is that they are one-way, making it nearly impossible to retrieve the original data from the hash. This feature is crucial for maintaining data integrity and identifying any alterations. Additionally, hash functions exhibit collision resistance, meaning it’s difficult to find two distinct inputs that yield the same hash, which is vital for cryptographic security [<xref ref-type="bibr" rid="B22">22</xref>].</p>
        <p>In the late 1970s, hash-based signature schemes emerged, initially as one-time signature systems developed by Lamport and later extended by Ralph Merkle. He created the MerKel signature schemes and proposed the MerKel tree structure. The security of these systems is straightforward to assess and relies on the hash function used. However, users must keep track of how many signatures have been created with a specific key. Over the past 40 years, advancements have enhanced the efficiency and theoretical foundations of hash-based signatures, culminating in XMSS, which is nearing standardization as the first signature scheme designed to withstand quantum threats. These schemes combine one-time signatures with a Merkle tree structure to sign messages effectively [<xref ref-type="bibr" rid="B25">25</xref>]. Hash-based signature schemes integrate a One-Time Signature scheme (OTS) with a Merkle tree structure. Because each OTS key securely signs only one message, multiple keys are organized into a Merkle tree to enable signing multiple messages.</p>
        <p><bold>SPHI</bold><bold>NCS</bold>, developed by a team of researchers, is a hash-based signature scheme that does not rely on stateful components, making it the first to propose parameters against quantum attacks. It builds on components of XMSS but uses larger keys and signatures, thereby removing the need for state [<xref ref-type="bibr" rid="B26">26</xref>]. The scheme incorporates elements from HORST and WOTS+<sup>+</sup> (Winternitz OTS), which traditionally require pre-generated keys to calculate the Merkle root, limiting key management. In contrast, SPHINCS can handle many more keys through two methods: a hyper-tree for authentication and a random key-path addressing scheme.</p>
        <p><bold>SPHINCS+</bold> improves this framework with better speed, security, and smaller signatures. While it retains similar principles, it differs by using FORS for signing, implementing a publicly verified leaf-index selection, and introducing tweakable hash functions, thereby streamlining the security analysis of hash-based signatures [<xref ref-type="bibr" rid="B22">22</xref>].</p>
        <p>3.2.4. Isogeny-Based Cryptography Methods</p>
        <p>Isogeny-based cryptography combines elliptic curves and isogenies, showing promise as a secure cryptographic approach. An elliptic curve consists of points that satisfy a specific equation over a finite field and form a group under operations such as point addition. Elliptic curves, which are projective curves of genus 1 with a specified base point, are fundamental in cryptography, especially in Elliptic Curve Cryptography (ECC), as shown in <xref ref-type="fig" rid="fig8">Figure 8</xref> [<xref ref-type="bibr" rid="B27">27</xref>].</p>
        <fig id="fig10">
          <label>Figure 10</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId278.jpeg?20261019032335" />
        </fig>
        <p><bold>Figure 8.</bold> Elliptic curve cryptography lines [<xref ref-type="bibr" rid="B27">27</xref>].</p>
        <p>Isogenies are algebraic maps between elliptic curves over finite fields that serve as group homomorphisms, as illustrated in <xref ref-type="fig" rid="fig9">Figure 9</xref>. These maps define relationships between curves, and their degrees quantify the size of the isogeny, a property particularly important for separable isogenies [<xref ref-type="bibr" rid="B27">27</xref>].</p>
        <fig id="fig11">
          <label>Figure 11</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId279.jpeg?20261019032335" />
        </fig>
        <p><bold>Figure 9.</bold> Isogeny [<xref ref-type="bibr" rid="B26">26</xref>].</p>
        <p>Supersingular elliptic curve isogeny cryptography leverages these properties to implement key-exchange protocols like Diffie-Hellman, offering a quantum-resistant alternative with smaller key sizes than many other post-quantum cryptographic systems. The primary schemes in this domain are Supersingular Isogeny Diffie-Hellman (SIDH) and its commutative variant (CSIDH), while Supersingular Isogeny Key Encapsulation (SIKE) has been submitted to the NIST Post-Quantum Cryptography Competition [<xref ref-type="bibr" rid="B10">10</xref>].</p>
        <p><bold>SIKE</bold> is a key encapsulation method chosen in the third round of NIST’s post-quantum standardization process. It builds on the SIDH key exchange protocol from 2011, utilizing arithmetic on elliptic curves and computing isogenies between them. The security of both SIDH and SIKE depends on the difficulty of identifying a specific isogeny between two curves, which is distinct from the discrete logarithm problem on a single curve [<xref ref-type="bibr" rid="B28">28</xref>].</p>
        <p>One key advantage of these methods is their small public keys, making them among the most compact quantum-resistant algorithms. However, their relatively slow performance has limited their effectiveness as practical post-quantum candidates.</p>
        <p>3.2.5. Multivariate Cryptography Methods</p>
        <p>Multivariate cryptography uses asymmetric encryption based on multivariate polynomials over finite fields. It’s commonly used to create digital signatures and is known for producing the shortest signatures among Post-Quantum Cryptography (PQC) methods. The security of this approach hinges on the complexity of solving nonlinear systems of equations, particularly multivariate quadratic polynomial systems [<xref ref-type="bibr" rid="B25">25</xref>]. There are primarily two categories of multivariate digital signature schemes. The first includes BigField schemes like HFEv and the NIST candidate GeMSS. The second category comprises SingleField schemes, including UOV and Rainbow [<xref ref-type="bibr" rid="B29">29</xref>]. While some multivariate encryption and authentication schemes have proven weak, a few signature schemes have withstood cryptanalysis. Notably, UOV (Unbalanced Oil and Vinegar) and SFLASH v2 are two resilient schemes that have demonstrated effective implementation and were recognized in 2002 by the European project NESSIE as viable digital signature algorithms.</p>
        <p><bold>Definition</bold><bold>15</bold><bold>.</bold> (<italic>Multivariate</italic><italic>quadratic</italic><italic>maps</italic>) The central object in Multivariate Quadratic cryptography is the multivariate quadratic map. A multivariate quadratic map </p>
        <fig id="fig12">
          <label>Figure 12</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId280.svg?20261019032336" />
        </fig>
        <p> with <inline-formula><mml:math><mml:mi> m </mml:mi></mml:math></inline-formula> components and <inline-formula><mml:math><mml:mi> n </mml:mi></mml:math></inline-formula> variables is a sequence </p>
        <fig id="fig13">
          <label>Figure 13</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId286.svg?20261019032336" />
        </fig>
        <p> of <inline-formula><mml:math><mml:mi> m </mml:mi></mml:math></inline-formula> multivariate quadratic polynomials in <inline-formula><mml:math><mml:mi> n </mml:mi></mml:math></inline-formula> variables <inline-formula><mml:math><mml:mrow><mml:mi> x </mml:mi><mml:mo> = </mml:mo><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:msub><mml:mi> x </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> x </mml:mi><mml:mi> n </mml:mi></mml:msub></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> , with coefficients in a finite field <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula> . To evaluate the map </p>
        <fig id="fig14">
          <label>Figure 14</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId296.svg?20261019032336" />
        </fig>
        <p> at a value <inline-formula><mml:math><mml:mrow><mml:mtext> a </mml:mtext><mml:mo> ∈ </mml:mo><mml:msubsup><mml:mi mathvariant="double-struck"> F </mml:mi><mml:mi> q </mml:mi><mml:mi> n </mml:mi></mml:msubsup></mml:mrow></mml:math></inline-formula> , simply evaluate each of its component polynomials in a to get a vector </p>
        <fig id="fig15">
          <label>Figure 15</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId300.svg?20261019032336" />
        </fig>
        <p> of <italic>m</italic> output elements; denote this by </p>
        <fig id="fig16">
          <label>Figure 16</label>
          <graphic xlink:href="https://html.scirp.org/file/4000521-rId302.svg?20261019032336" />
        </fig>
        <p> [<xref ref-type="bibr" rid="B30">30</xref>].</p>
        <p><bold>Rainbow</bold>, created in 2004 by Jintai Ding and Dieter Schmidt, is a digital signature scheme derived from Jacques Patarin’s Oil-Vinegar (UOV) model. It features a trapdoor function represented by a multivariate quadratic map with several layers of nested subspaces. The version presented in the NIST PQC project features a 2-layer variant with specific dimensions and equations connecting inputs and outputs. Although Rainbow offers rapid signature generation and verification, its key generation is slower [<xref ref-type="bibr" rid="B29">29</xref>].</p>
        <p>In 2022, a key-recovery attack exploited SIKE’s torsion-point information, enabling full key recovery within hours on a single core and prompting NIST to withdraw the scheme from consideration. Similarly, Ward Beullens applied a rectangular MinRank attack to Rainbow, rapidly recovering the private key and resulting in its removal from the standardization process. These incidents highlight significant risks in post-quantum cryptanalysis, demonstrating that structured algebraic problems may harbor vulnerabilities and rendering such methods unsuitable for practical deployment, despite prior assumptions of quantum resistance.</p>
      </sec>
    </sec>
    <sec id="sec4">
      <title>4. Discussion</title>
      <p>Quantum computing has advanced significantly in recent years, particularly as leading technology companies develop machines with capacities exceeding 1000 qubits. IBM, for example, plans to build a supercomputer with more than 4000 qubits by 2025, emphasizing improvements in circuit quality to support 5000 gates per circuit for large-scale workloads. Google aims to achieve an error-corrected quantum computer by 2029, building upon its 53-qubit Sycamore processor. Microsoft is pursuing utility-scale quantum computing through a three-tiered approach—Foundational, Resilient, and Scale—with a primary focus on topological qubits. In February 2025, Microsoft introduced the Majorana 1 processor, designed to scale to 1 million qubits by leveraging hardware-protected qubits [<xref ref-type="bibr" rid="B31">31</xref>].</p>
      <p>Quantum computers are advancing rapidly and will become widely adopted in the future. With quantum technology progressing swiftly, post-quantum cryptographic algorithms are also evolving. The NIST has recently announced four standardized post-quantum encryption algorithms, crucial for securing digital communications against future quantum threats. The analysis indicates that lattice-based schemes are ideal for this transition. ML-KEM is recommended for key encapsulation because of its strong security and efficiency, while ML-DSA offers balanced performance for general use. Falcon excels in bandwidth-limited settings but necessitates careful implementation, and SLH-DSA remains valuable as a high-assurance option despite its slower speed and larger signatures. While post-quantum cryptography continues to improve in efficiency, its inherently large parameter sizes remain a significant challenge. Choosing the right algorithm will depend on security levels, parameter size, execution speed, and specific application needs. <bold>Table 2</bold> presents the first standardized quantum-resistant cryptographic algorithms, highlighting these considerations and correlating security levels with the difficulty of breaking traditional encryption methods such as AES [<xref ref-type="bibr" rid="B32">32</xref>].</p>
      <p><bold>Table 2</bold><bold>.</bold> NIST PQC KEM &amp; digital signature algorithms, security levels, and parameter sizes [<xref ref-type="bibr" rid="B18">18</xref>][<xref ref-type="bibr" rid="B32">32</xref>].</p>
      <table-wrap id="tbl2">
        <label>Table 2</label>
        <table>
          <tbody>
            <tr>
              <td colspan="10">NIST PQC KEM algorithms</td>
            </tr>
            <tr>
              <td>Algorithm</td>
              <td>Scheme</td>
              <td>Parameters</td>
              <td>Security</td>
              <td>KeyGen(ms)</td>
              <td>Enc(ms)</td>
              <td>Dec(ms)</td>
              <td>Private Key(B)</td>
              <td>Public Key(B)</td>
              <td>Ciphertext(B)</td>
            </tr>
            <tr>
              <td rowspan="3">Kyber</td>
              <td rowspan="3">Lattice-Based</td>
              <td>Kyber512</td>
              <td>1</td>
              <td>0.253</td>
              <td>0.070</td>
              <td>0.084</td>
              <td>1632</td>
              <td>800</td>
              <td>768</td>
            </tr>
            <tr>
              <td>Kyber768</td>
              <td>3</td>
              <td>0.354</td>
              <td>0.095</td>
              <td>0.118</td>
              <td>2400</td>
              <td>1184</td>
              <td>1088</td>
            </tr>
            <tr>
              <td>Kyber1024</td>
              <td>5</td>
              <td>0.483</td>
              <td>0.138</td>
              <td>0.159</td>
              <td>3168</td>
              <td>1568</td>
              <td>1568</td>
            </tr>
            <tr>
              <td rowspan="3">HQC</td>
              <td rowspan="3">Code-based</td>
              <td>HQC-128</td>
              <td>1</td>
              <td>2.84</td>
              <td>4.12</td>
              <td>8.95</td>
              <td>2305</td>
              <td>2249</td>
              <td>4433</td>
            </tr>
            <tr>
              <td>HQC-192</td>
              <td>3</td>
              <td>5.67</td>
              <td>8.34</td>
              <td>18.2</td>
              <td>4586</td>
              <td>4522</td>
              <td>8978</td>
            </tr>
            <tr>
              <td>HQC-256</td>
              <td>5</td>
              <td>11.2</td>
              <td>16.8</td>
              <td>35.4</td>
              <td>7317</td>
              <td>7245</td>
              <td>14,421</td>
            </tr>
            <tr>
              <td colspan="10">NIST PQC digital signature algorithms</td>
            </tr>
            <tr>
              <td>Algorithm</td>
              <td>Scheme</td>
              <td>Parameters</td>
              <td>Security</td>
              <td>KeyGen(ms)</td>
              <td>Signing(ms)</td>
              <td>verifying(ms)</td>
              <td>Private Key(B)</td>
              <td>Public Key(B)</td>
              <td>Signature(B)</td>
            </tr>
            <tr>
              <td rowspan="3">Dilithium</td>
              <td rowspan="3">Lattice-Based</td>
              <td>Dilithium 2</td>
              <td>1</td>
              <td>0.253</td>
              <td>0.840</td>
              <td>0.267</td>
              <td>2528</td>
              <td>1312</td>
              <td>2420</td>
            </tr>
            <tr>
              <td>Dilithium 3</td>
              <td>3</td>
              <td>0.392</td>
              <td>1.205</td>
              <td>0.398</td>
              <td>4000</td>
              <td>1952</td>
              <td>3293</td>
            </tr>
            <tr>
              <td>Dilithium 5</td>
              <td>5</td>
              <td>0.652</td>
              <td>1.998</td>
              <td>0.584</td>
              <td>4864</td>
              <td>2592</td>
              <td>4595</td>
            </tr>
            <tr>
              <td rowspan="2">Falcon</td>
              <td rowspan="2">Lattice-Based</td>
              <td>Falcon 512</td>
              <td>1</td>
              <td>8.64</td>
              <td>0.168</td>
              <td>0.036</td>
              <td>1281</td>
              <td>897</td>
              <td>666</td>
            </tr>
            <tr>
              <td>Falcon 1024</td>
              <td>5</td>
              <td>27.45</td>
              <td>0.344</td>
              <td>0.073</td>
              <td>2305</td>
              <td>1793</td>
              <td>1280</td>
            </tr>
            <tr>
              <td rowspan="3">SPHINCS+</td>
              <td rowspan="3">Hash-based</td>
              <td>SPHINCS+-128s</td>
              <td>1</td>
              <td>0.032</td>
              <td>120.5</td>
              <td>1.45</td>
              <td>64</td>
              <td>32</td>
              <td>7856</td>
            </tr>
            <tr>
              <td>SPHINCS+-192s</td>
              <td>3</td>
              <td>0.048</td>
              <td>285.2</td>
              <td>2.98</td>
              <td>96</td>
              <td>48</td>
              <td>16,224</td>
            </tr>
            <tr>
              <td>SPHINCS+-256s</td>
              <td>5</td>
              <td>0.064</td>
              <td>652.8</td>
              <td>5.12</td>
              <td>128</td>
              <td>64</td>
              <td>29,792</td>
            </tr>
          </tbody>
        </table>
      </table-wrap>
      <p>All three algorithm families align with NIST security levels (1, 3, 5), showing proportional increases in key and ciphertext/signature sizes as security strengthens. Kyber stands out for its computational efficiency, operating in sub-millisecond times across all levels, highlighting the strengths of lattice-based designs for modern hardware. In contrast, HQC features significantly larger public keys, complicating its application in bandwidth-limited environments. Dilithium delivers competitive signing performance, maintaining verification times under 1.2 milliseconds at high security levels, indicating that post-quantum signatures can match or exceed traditional methods. However, SPHINCS+ signature generation takes considerably longer, ranging from 120 ms to 650 ms, due to its complex computations.</p>
      <p>Lattice-based algorithms offer an effective balance of efficiency, minimal communication overhead, and strong security foundations, making them suitable for deployment across a wide range of computing environments [<xref ref-type="bibr" rid="B18">18</xref>]. With Kyber based on the MLWE problem, it resists simple key-guessing attacks and remains secure against even powerful quantum threats. Yet, transitioning to quantum-safe standards poses significant challenges [<xref ref-type="bibr" rid="B33">33</xref>]:</p>
      <p>A lack of visibility in cryptographic use.Larger key and signature sizes affect performance.The need for hybrid systems.Limitations posed by Legacy devices.The requirement for coordinated updates across various technology layers.</p>
    </sec>
    <sec id="sec5">
      <title>5. Simulation</title>
      <p>Lattice-based methods are recognized for their strong security and computational efficiency, making them ideal for a range of cryptographic applications. Among these methods, CRYSTALS-Kyber stands out as the main KEM chosen during the PQC standardization process. It provides strong security, straightforward computation, and is suitable for resource-constrained environments. Kyber uses efficient polynomial operations enabled by the NTT, which is essential in lattice cryptography. Its predictable structure and small ciphertext sizes enhance its performance with hardware accelerators, making it a top option for fast cryptographic solutions [<xref ref-type="bibr" rid="B34">34</xref>].</p>
      <p>NTT plays a key role in post-quantum cryptography and homomorphic encryption by streamlining polynomial multiplication. Instead of multiplying polynomials directly, NTT simplifies the process to pointwise multiplication. However, this method requires modular arithmetic in <inline-formula><mml:math><mml:mrow><mml:msub><mml:mi> ℤ </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula> , which poses challenges for many platforms. Traditional modular multiplication techniques, such as trial division, can be inefficient and difficult to implement in hardware.</p>
      <p>In NTT, polynomials are converted from their standard coefficient form to the NTT domain via a forward NTT process that uses butterfly operations to combine coefficients with precomputed constants. Once transformed, polynomials can be reverted to their original form through inverse NTT, which involves a different set of butterfly operations and a final scaling step to adjust the output. Montgomery multiplication performs efficient modular arithmetic during scaling. The method leverages bit manipulation techniques to optimize performance, particularly by using parameters that streamline hardware implementation. The simulation’s operation is as follows:</p>
      <p>1) Load 256 input coefficients into coefficient memory.</p>
      <p>2) Start Forward NTT.</p>
      <p>3) Perform butterfly operations stage by stage.</p>
      <p>4) Store-and-forward NTT result.</p>
      <p>5) Run inverse NTT on the result.</p>
      <p>6) Apply final inverse scaling.</p>
      <p>7) Read output coefficients.</p>
      <p>8) Compare output with original input to ensure correctness.</p>
      <p>The forward and inverse NTT processes efficiently transform between polynomial representations, with careful attention to storage order and scaling adjustments.</p>
      <p><bold>Forward</bold><bold>NTT</bold></p>
      <p>The forward NTT transforms polynomials into the NTT domain using an in-place, iterative algorithm. The reference implementation performs the NTT as follows:</p>
      <p>1) Require polynomial <italic>a</italic><inline-formula><mml:math><mml:mrow><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:msub><mml:mi> a </mml:mi><mml:mn> 0 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:msub><mml:mi> a </mml:mi><mml:mn> 1 </mml:mn></mml:msub><mml:mo> , </mml:mo><mml:mo> ⋯ </mml:mo><mml:mo> , </mml:mo><mml:msub><mml:mi> a </mml:mi><mml:mrow><mml:mi> n </mml:mi><mml:mo> − </mml:mo><mml:mn> 1 </mml:mn></mml:mrow></mml:msub></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> as <inline-formula><mml:math><mml:mrow><mml:mi> a </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mi> x </mml:mi><mml:mo> ) </mml:mo></mml:mrow><mml:mo> ∈ </mml:mo><mml:mrow><mml:mrow><mml:msub><mml:mi> Z </mml:mi><mml:mi> q </mml:mi></mml:msub><mml:mrow><mml:mo> [ </mml:mo><mml:mi> X </mml:mi><mml:mo> ] </mml:mo></mml:mrow></mml:mrow><mml:mo> / </mml:mo><mml:mrow><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:msup><mml:mi> X </mml:mi><mml:mi> n </mml:mi></mml:msup><mml:mo> + </mml:mo><mml:mn> 1 </mml:mn></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:mrow></mml:mrow></mml:math></inline-formula> , <inline-formula><mml:math><mml:mrow><mml:mi> ψ </mml:mi><mml:mo> ∈ </mml:mo><mml:msub><mml:mi> Z </mml:mi><mml:mi> q </mml:mi></mml:msub></mml:mrow></mml:math></inline-formula> is the <italic>N</italic>-th primitive root of unity</p>
      <p>2) Precompute a vector of the first <italic>n</italic> powers of such a root stored in bit-reverse order.</p>
      <p>3) Starting with length = 128, work down to length = 2.</p>
      <p>4) For each length, apply butterfly operations on pairs of coefficients.</p>
      <p>5) The result is in bit-reversed order.</p>
      <p><bold>Inverse</bold><bold>NTT</bold></p>
      <p>The INTT transforms from the NTT domain back to coefficient representation as follows:</p>
      <p>1) Processes in the reverse order of the forward NTT.</p>
      <p>2) Uses the inverse roots of unity (stored in the same zetas array)</p>
      <p>3) Applies a final scaling factor to each coefficient (Montgomery constant).</p>
      <p>4) Returns the result in standard order.</p>
      <p><xref ref-type="fig" rid="fig10">Figure 10</xref> illustrates the NTT and INTT algorithm flowchart.</p>
      <fig id="fig17">
        <label>Figure 17</label>
        <graphic xlink:href="https://html.scirp.org/file/4000521-rId312.jpeg?20261019032336" />
      </fig>
      <p><bold>Figure 10.</bold> NTT and INTT flowchart [Generated by AI].</p>
      <p><bold>Algorithm 1</bold> shows the NTT operation using the Cooley-Tukey butterfly. <bold>Algorithm 2</bold> shows the INTT operation using the Gentleman-Sande butterfly.</p>
      <p><bold>Algorithm 1.</bold> The Cooley-Tukey NTT.</p>
      <table-wrap id="tbl3">
        <label>Table 3</label>
        <table>
          <tbody>
            <tr>
              <td>
                <bold>Input</bold>
                <bold>:</bold>
                An
                <italic>n</italic>
                -element vector
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>a</mml:mi>
                      <mml:mo>=</mml:mo>
                      <mml:msub>
                        <mml:mi>a</mml:mi>
                        <mml:mn>0</mml:mn>
                      </mml:msub>
                      <mml:mo>,</mml:mo>
                      <mml:msub>
                        <mml:mi>a</mml:mi>
                        <mml:mn>1</mml:mn>
                      </mml:msub>
                      <mml:mo>,</mml:mo>
                      <mml:mo>⋯</mml:mo>
                      <mml:mo>,</mml:mo>
                      <mml:msub>
                        <mml:mi>a</mml:mi>
                        <mml:mrow>
                          <mml:mi>n</mml:mi>
                          <mml:mo>−</mml:mo>
                          <mml:mn>1</mml:mn>
                        </mml:mrow>
                      </mml:msub>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                where
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>a</mml:mi>
                        <mml:mi>i</mml:mi>
                      </mml:msub>
                      <mml:mo>∈</mml:mo>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>q</mml:mi>
                          <mml:mo>−</mml:mo>
                          <mml:mn>1</mml:mn>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                ,
                <inline-formula>
                  <mml:math>
                    <mml:mi>n</mml:mi>
                  </mml:math>
                </inline-formula>
                (power of 2) modulus
                <inline-formula>
                  <mml:math>
                    <mml:mi>q</mml:mi>
                  </mml:math>
                </inline-formula>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>q</mml:mi>
                          <mml:mo>≡</mml:mo>
                          <mml:mn>1</mml:mn>
                          <mml:mrow>
                            <mml:mo>(</mml:mo>
                            <mml:mrow>
                              <mml:mi>mod</mml:mi>
                              <mml:mn>2</mml:mn>
                              <mml:mi>n</mml:mi>
                            </mml:mrow>
                            <mml:mo>)</mml:mo>
                          </mml:mrow>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>Input</bold>
                <bold>:</bold>
                Zeta (precomputed table of
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mn>2</mml:mn>
                      <mml:mi>n</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                -th roots of unity
                <inline-formula>
                  <mml:math>
                    <mml:mi>ψ</mml:mi>
                  </mml:math>
                </inline-formula>
                , in bit-reversed order)
              </td>
            </tr>
            <tr>
              <td>
                <bold>Output:</bold>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mover accent="true">
                        <mml:mi>f</mml:mi>
                        <mml:mo>^</mml:mo>
                      </mml:mover>
                      <mml:mo>
                      </mml:mo>
                      <mml:mo>←</mml:mo>
                      <mml:mtext>NTT</mml:mtext>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mi>a</mml:mi>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>t</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mrow>
                        <mml:mi>n</mml:mi>
                        <mml:mo>/</mml:mo>
                        <mml:mn>2</mml:mn>
                      </mml:mrow>
                      <mml:mo>;</mml:mo>
                      <mml:mi>m</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>while</bold>
                (
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>m</mml:mi>
                      <mml:mo>&lt;</mml:mo>
                      <mml:mi>n</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                )
                <bold>do</bold>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>k</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>0</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>for</bold>
                (
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>0</mml:mn>
                      <mml:mo>;</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>&lt;</mml:mo>
                      <mml:mi>m</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                )
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>S</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mtext>zeta</mml:mtext>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>m</mml:mi>
                          <mml:mo>+</mml:mo>
                          <mml:mi>i</mml:mi>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>for</bold>
                (
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>j</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>k</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>j</mml:mi>
                      <mml:mo>&lt;</mml:mo>
                      <mml:mi>k</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mi>t</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>j</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>j</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                )
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>U</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>a</mml:mi>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mi>j</mml:mi>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>V</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>a</mml:mi>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>j</mml:mi>
                          <mml:mo>+</mml:mo>
                          <mml:mi>t</mml:mi>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                      <mml:mo>⋅</mml:mo>
                      <mml:mi>S</mml:mi>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>mod</mml:mi>
                          <mml:mi>q</mml:mi>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>a</mml:mi>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mi>j</mml:mi>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                      <mml:mo>←</mml:mo>
                      <mml:mi>U</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mi>V</mml:mi>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>mod</mml:mi>
                          <mml:mi>q</mml:mi>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>a</mml:mi>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>j</mml:mi>
                          <mml:mo>+</mml:mo>
                          <mml:mi>t</mml:mi>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                      <mml:mo>←</mml:mo>
                      <mml:mi>U</mml:mi>
                      <mml:mo>−</mml:mo>
                      <mml:mi>V</mml:mi>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>mod</mml:mi>
                          <mml:mi>q</mml:mi>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>k</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>k</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mn>2</mml:mn>
                      <mml:mi>t</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>t</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mrow>
                        <mml:mi>t</mml:mi>
                        <mml:mo>/</mml:mo>
                        <mml:mn>2</mml:mn>
                      </mml:mrow>
                      <mml:mo>;</mml:mo>
                      <mml:mi>m</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>2</mml:mn>
                      <mml:mi>m</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>return</bold>
                <inline-formula>
                  <mml:math>
                    <mml:mover accent="true">
                      <mml:mi>f</mml:mi>
                      <mml:mo>^</mml:mo>
                    </mml:mover>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
          </tbody>
        </table>
      </table-wrap>
      <p><bold>Algorithm 2.</bold>The gentleman-sande INTT.</p>
      <table-wrap id="tbl4">
        <label>Table 4</label>
        <table>
          <tbody>
            <tr>
              <td>
                <bold>Input</bold>
                <bold>:</bold>
                An
                <italic>n</italic>
                -element vector
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mover accent="true">
                        <mml:mi>f</mml:mi>
                        <mml:mo>^</mml:mo>
                      </mml:mover>
                      <mml:mtext>
                      </mml:mtext>
                      <mml:mo>=</mml:mo>
                      <mml:mo>
                      </mml:mo>
                      <mml:msub>
                        <mml:mi>f</mml:mi>
                        <mml:mn>0</mml:mn>
                      </mml:msub>
                      <mml:mo>,</mml:mo>
                      <mml:msub>
                        <mml:mi>f</mml:mi>
                        <mml:mn>1</mml:mn>
                      </mml:msub>
                      <mml:mo>,</mml:mo>
                      <mml:mo>⋯</mml:mo>
                      <mml:mo>,</mml:mo>
                      <mml:msub>
                        <mml:mi>f</mml:mi>
                        <mml:mrow>
                          <mml:mi>n</mml:mi>
                          <mml:mo>−</mml:mo>
                          <mml:mn>1</mml:mn>
                        </mml:mrow>
                      </mml:msub>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                where
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:msub>
                        <mml:mi>f</mml:mi>
                        <mml:mi>i</mml:mi>
                      </mml:msub>
                      <mml:mo>∈</mml:mo>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>q</mml:mi>
                          <mml:mo>−</mml:mo>
                          <mml:mn>1</mml:mn>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                ,
                <inline-formula>
                  <mml:math>
                    <mml:mi>n</mml:mi>
                  </mml:math>
                </inline-formula>
                (power of 2) modulus
                <inline-formula>
                  <mml:math>
                    <mml:mi>q</mml:mi>
                  </mml:math>
                </inline-formula>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>q</mml:mi>
                          <mml:mo>≡</mml:mo>
                          <mml:mn>1</mml:mn>
                          <mml:mrow>
                            <mml:mo>(</mml:mo>
                            <mml:mrow>
                              <mml:mi>mod</mml:mi>
                              <mml:mn>2</mml:mn>
                              <mml:mi>n</mml:mi>
                            </mml:mrow>
                            <mml:mo>)</mml:mo>
                          </mml:mrow>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>Input</bold>
                <bold>:</bold>
                zeta_inv (precomputed table of
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mn>2</mml:mn>
                      <mml:mi>n</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                -th roots of unity
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:msup>
                        <mml:mi>ψ</mml:mi>
                        <mml:mrow>
                          <mml:mo>−</mml:mo>
                          <mml:mn>1</mml:mn>
                        </mml:mrow>
                      </mml:msup>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                , in bit-reversed order),
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:msup>
                        <mml:mi>n</mml:mi>
                        <mml:mrow>
                          <mml:mo>−</mml:mo>
                          <mml:mn>1</mml:mn>
                        </mml:mrow>
                      </mml:msup>
                      <mml:mi>mod</mml:mi>
                      <mml:mi>q</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>Output:</bold>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>f</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mtext>NTT</mml:mtext>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mover accent="true">
                          <mml:mi>f</mml:mi>
                          <mml:mo>^</mml:mo>
                        </mml:mover>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>t</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>1</mml:mn>
                      <mml:mo>;</mml:mo>
                      <mml:mi>m</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mrow>
                        <mml:mi>n</mml:mi>
                        <mml:mo>/</mml:mo>
                        <mml:mn>2</mml:mn>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>while</bold>
                (
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>m</mml:mi>
                      <mml:mo>&gt;</mml:mo>
                      <mml:mn>0</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                )
                <bold>do</bold>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>k</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>0</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>for</bold>
                (
                <inline-formula>
                  <mml:math display="inline">
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>0</mml:mn>
                      <mml:mo>;</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>&lt;</mml:mo>
                      <mml:mi>m</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                )
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>S</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mtext>zeta_inv</mml:mtext>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>m</mml:mi>
                          <mml:mo>+</mml:mo>
                          <mml:mi>i</mml:mi>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>for</bold>
                (
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>j</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>k</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>j</mml:mi>
                      <mml:mo>&lt;</mml:mo>
                      <mml:mi>k</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mi>t</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>j</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>j</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                )
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>U</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mover accent="true">
                        <mml:mi>f</mml:mi>
                        <mml:mo>^</mml:mo>
                      </mml:mover>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mi>j</mml:mi>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>V</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mover accent="true">
                        <mml:mi>f</mml:mi>
                        <mml:mo>^</mml:mo>
                      </mml:mover>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>j</mml:mi>
                          <mml:mo>+</mml:mo>
                          <mml:mi>t</mml:mi>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mover accent="true">
                        <mml:mi>f</mml:mi>
                        <mml:mo>^</mml:mo>
                      </mml:mover>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mi>j</mml:mi>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                      <mml:mo>←</mml:mo>
                      <mml:mi>U</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mi>V</mml:mi>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>mod</mml:mi>
                          <mml:mi>q</mml:mi>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>W</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>U</mml:mi>
                      <mml:mo>−</mml:mo>
                      <mml:mi>V</mml:mi>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>mod</mml:mi>
                          <mml:mi>q</mml:mi>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mover accent="true">
                        <mml:mi>f</mml:mi>
                        <mml:mo>^</mml:mo>
                      </mml:mover>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mrow>
                          <mml:mi>j</mml:mi>
                          <mml:mo>+</mml:mo>
                          <mml:mi>t</mml:mi>
                        </mml:mrow>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                      <mml:mo>←</mml:mo>
                      <mml:mi>W</mml:mi>
                      <mml:mo>⋅</mml:mo>
                      <mml:mi>S</mml:mi>
                      <mml:mrow>
                        <mml:mo>(</mml:mo>
                        <mml:mrow>
                          <mml:mi>mod</mml:mi>
                          <mml:mi>q</mml:mi>
                        </mml:mrow>
                        <mml:mo>)</mml:mo>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>k</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>k</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mn>2</mml:mn>
                      <mml:mi>t</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>t</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mn>2</mml:mn>
                      <mml:mi>t</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>m</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mrow>
                        <mml:mi>m</mml:mi>
                        <mml:mo>/</mml:mo>
                        <mml:mn>2</mml:mn>
                      </mml:mrow>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>for</bold>
                (
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>i</mml:mi>
                      <mml:mo>
                      </mml:mo>
                      <mml:mo>←</mml:mo>
                      <mml:mn>0</mml:mn>
                      <mml:mo>;</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>&lt;</mml:mo>
                      <mml:mi>m</mml:mi>
                      <mml:mo>;</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>←</mml:mo>
                      <mml:mi>i</mml:mi>
                      <mml:mo>+</mml:mo>
                      <mml:mn>1</mml:mn>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
                )
              </td>
            </tr>
            <tr>
              <td>
                <inline-formula>
                  <mml:math>
                    <mml:mrow>
                      <mml:mi>f</mml:mi>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mi>i</mml:mi>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                      <mml:mo>←</mml:mo>
                      <mml:mover accent="true">
                        <mml:mi>f</mml:mi>
                        <mml:mo>^</mml:mo>
                      </mml:mover>
                      <mml:mrow>
                        <mml:mo>[</mml:mo>
                        <mml:mi>i</mml:mi>
                        <mml:mo>]</mml:mo>
                      </mml:mrow>
                      <mml:mo>⋅</mml:mo>
                      <mml:msup>
                        <mml:mi>n</mml:mi>
                        <mml:mrow>
                          <mml:mo>−</mml:mo>
                          <mml:mn>1</mml:mn>
                        </mml:mrow>
                      </mml:msup>
                      <mml:mi>mod</mml:mi>
                      <mml:mi>q</mml:mi>
                    </mml:mrow>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
            <tr>
              <td>
                <bold>return</bold>
                <inline-formula>
                  <mml:math>
                    <mml:mi>f</mml:mi>
                  </mml:math>
                </inline-formula>
              </td>
            </tr>
          </tbody>
        </table>
      </table-wrap>
    </sec>
    <sec id="sec6">
      <title>6. Results</title>
      <p><xref ref-type="fig" rid="fig11">Figure 11</xref> shows the CPU performance benchmark for NTT and INTT, implemented on a computer with a Core (TM) i7-1360P processor at 2.20 GHz and 16GB of RAM. </p>
      <fig id="fig18">
        <label>Figure 18</label>
        <graphic xlink:href="https://html.scirp.org/file/4000521-rId402.jpeg?20261019032337" />
      </fig>
      <p><bold>Figure 11.</bold> CPU performance benchmark.</p>
      <p>The total time taken for the NTT and INTT indicates that INTT takes longer to execute on the same CPU. INTT also has lower throughput. <bold>Table 3</bold> compares CPU performance benchmarks (NTT and INV_NTT) and shows significant differences.</p>
      <p><bold>Table 3</bold><bold>.</bold> Comparison of CPU performance benchmarks.</p>
      <table-wrap id="tbl5">
        <label>Table 5</label>
        <table>
          <tbody>
            <tr>
              <td>Metric</td>
              <td>NTT</td>
              <td>INV_NTT</td>
              <td>Difference</td>
              <td>Ratio %</td>
            </tr>
            <tr>
              <td>Total Time (ms)</td>
              <td>1042.94</td>
              <td>1314.34</td>
              <td>271.4</td>
              <td>≈26.0%</td>
            </tr>
            <tr>
              <td>Average Time (ms)</td>
              <td>1.04</td>
              <td>1.31</td>
              <td>0.27</td>
              <td>≈25.96%</td>
            </tr>
            <tr>
              <td>Min Time (ms)</td>
              <td>0.68</td>
              <td>0.80</td>
              <td>0.12</td>
              <td>≈17.65%</td>
            </tr>
            <tr>
              <td>Max Time (ms)</td>
              <td>2.79</td>
              <td>3.92</td>
              <td>1.13</td>
              <td>≈40.5%</td>
            </tr>
            <tr>
              <td>Throughput</td>
              <td>968823.42</td>
              <td>760838.08</td>
              <td>207985.34</td>
              <td>≈27.34%</td>
            </tr>
          </tbody>
        </table>
      </table-wrap>
      <p>NTT clearly outperforms INV_NTT on all time scales. Productivity in NTT is about 27% higher, and INTT suffers from the worst execution time, at 40.5% higher, indicating greater performance fluctuation.</p>
      <p><xref ref-type="fig" rid="fig12">Figure 12</xref> shows the results of the GPU performance benchmark for NTT and INTT, implemented on the Server Colab T4 GPU.</p>
      <fig id="fig19">
        <label>Figure 19</label>
        <graphic xlink:href="https://html.scirp.org/file/4000521-rId403.jpeg?20261019032337" />
      </fig>
      <p><bold>Figure 12.</bold> GPU performance benchmark.</p>
      <p><bold>Table 4</bold> compares GPU performance benchmarks (NTT and INV_NTT) and shows significant differences.</p>
      <p><bold>Table 4</bold><bold>.</bold> Comparison of GPU performance benchmarks.</p>
      <table-wrap id="tbl6">
        <label>Table 6</label>
        <table>
          <tbody>
            <tr>
              <td>Metric</td>
              <td>NTT</td>
              <td>INV_NTT</td>
              <td>Difference</td>
              <td>Ratio %</td>
            </tr>
            <tr>
              <td>Total Time (ms)</td>
              <td>649.06</td>
              <td>769.35</td>
              <td>120.29</td>
              <td>≈18.53%</td>
            </tr>
            <tr>
              <td>Average Time (ms)</td>
              <td>0.65</td>
              <td>0.77</td>
              <td>0.12</td>
              <td>≈18.46%</td>
            </tr>
            <tr>
              <td>Min Time (ms)</td>
              <td>0.61</td>
              <td>0.71</td>
              <td>0.10</td>
              <td>≈16.39%</td>
            </tr>
            <tr>
              <td>Max Time (ms)</td>
              <td>1.41</td>
              <td>2.51</td>
              <td>1.10</td>
              <td>≈78.0%</td>
            </tr>
            <tr>
              <td>Throughput</td>
              <td>1540.70</td>
              <td>1299.79</td>
              <td>240.91</td>
              <td>≈18.53%</td>
            </tr>
          </tbody>
        </table>
      </table-wrap>
      <p>The results demonstrate that NTT outperforms INTT across all measured metrics:</p>
      <p>18.5% lower total execution time. 18.5% lower average execution time. 18.5% higher throughput. Much lower worst-case latency (about 78% better).More stable execution behavior (0.8 ms).</p>
      <p>NTT clearly outperforms INV_NTT in terms of execution speed, stability, and productivity. If the application requires high performance and reliability, NTT is the best choice because it delivers faster performance and less volatility. The expected reason for NTT to outperform INTT is that the INTT algorithm includes additional operations compared to NTT, such as:</p>
      <p>Employing transactions <inline-formula><mml:math><mml:mrow><mml:msup><mml:mi> ζ </mml:mi><mml:mrow><mml:mo> − </mml:mo><mml:mn> 1 </mml:mn></mml:mrow></mml:msup></mml:mrow></mml:math></inline-formula> instead of <inline-formula><mml:math><mml:mi> ζ </mml:mi></mml:math></inline-formula> .The final strike in <inline-formula><mml:math><mml:mrow><mml:msup><mml:mi> n </mml:mi><mml:mrow><mml:mo> − </mml:mo><mml:mn> 1 </mml:mn></mml:mrow></mml:msup><mml:mi> mod </mml:mi><mml:mi> q </mml:mi></mml:mrow></mml:math></inline-formula> .More Montgomery Reduction operations in some applications.</p>
      <p>Therefore, the INTT time is naturally greater, although the theoretical complexity of the two algorithms is the same: <inline-formula><mml:math><mml:mrow><mml:mi> O </mml:mi><mml:mrow><mml:mo> ( </mml:mo><mml:mrow><mml:mi> n </mml:mi><mml:mi> log </mml:mi><mml:mi> n </mml:mi></mml:mrow><mml:mo> ) </mml:mo></mml:mrow></mml:mrow></mml:math></inline-formula> .</p>
    </sec>
    <sec id="sec7">
      <title>7. Conclusions</title>
      <p>PQC is becoming the main line of defense against the threats posed by large-scale quantum computing to classical cryptographic systems. Popular public-key methods such as RSA and Elliptic-Curve Cryptography (ECC) are expected to be compromised by quantum attackers, highlighting the need for a proactive shift in cryptography. Although practical quantum computers are still in development, various stakeholders, including governments and standard-setting bodies, are already creating strategies to protect sensitive information and vital infrastructure.</p>
      <p>This paper reviews the latest innovations in quantum-resistant cryptographic algorithms, such as lattice-based, code-based, Hash-based, and multivariate polynomial methods. It also examines current standardization efforts led by organizations such as NIST, which are vital to establishing reliable quantum-safe cryptographic standards.</p>
      <p>The conclusion emphasizes that advancing post-quantum cryptography is essential for securing communication networks against the growth of quantum computing technology. Based on recent findings and NIST’s PQC standardization process, lattice-based cryptography, specifically CRYSTALS-Kyber (for encryption) and CRYSTALS-Dilithium (for digital signatures), stands out as the most suitable approach for its scalability, robustness, and hardware adaptability. </p>
      <p>However, several challenges remain. Although NIST has standardized four algorithms, comparative analysis of other methods, particularly multivariate, code-based, and isogeny-based approaches, remains limited. Additionally, many algorithms lack hardware implementations, which could slow down their adoption. Also, while post-quantum algorithms offer enhanced security, they may be more resource-intensive, creating issues for small IoT devices. Implementing PQC in IoT devices presents multiple challenges. Many IoT devices possess limited processing power and memory, which complicates the use of PQC algorithms originally designed for more capable systems. These algorithms often require increased energy, thereby reducing battery life in devices with constrained power supplies. Bandwidth limitations are also significant, as low-power networks typically offer reduced transmission speeds, and the larger key sizes of some PQC methods can extend communication times and increase the risk of transmission failures. Furthermore, many IoT devices lack robust firmware update mechanisms, making the transition to new cryptographic methods difficult. Migrating from classical to post-quantum techniques adds complexity, as it requires running both algorithms simultaneously and increases demands on processing, memory, and energy resources. Together, these factors pose substantial obstacles to implementing PQC on resource-constrained devices.</p>
      <p>Finally, transitioning to hybrid post-quantum/classical methods requires coordinated updates across systems.</p>
      <p>In the future, researchers should focus on designing lightweight post-quantum cryptographic solutions for constrained IoT devices, as well as developing hybrid schemes that effectively integrate symmetric, asymmetric, and post-quantum cryptographic approaches while ensuring energy efficiency.</p>
    </sec>
    <sec id="sec8">
      <title>Acknowledgements</title>
      <p>I sincerely thank my supervisor, Johnson Ihyeh Agbinya, for his invaluable guidance, support, and mentorship throughout this research. His insights and expertise significantly influenced the direction and outcomes of this study. During the preparation of this study, the authors used [ChatGPT, GPT-5.5] to generate two images. The authors have reviewed and edited the output and take full responsibility for the content of this publication.</p>
    </sec>
    <sec id="sec9">
      <title>Author Contributions</title>
      <p>The authors contributed to this manuscript as detailed below: Wiam Abdelrahman Elmalih, the first and corresponding author, drafted and organized all sections of the article, from the abstract to the conclusion. She also handled the practical aspects of the study, including analysis, interpretation, and visualization of the results. Johnson Ihyeh Agbinya, the second author, contributed through supervision, guidance, and by providing critical revisions and final edits to the manuscript. All authors reviewed and approved the published version of the manuscript.</p>
    </sec>
  </body>
  <back>
    <ref-list>
      <title>References</title>
      <ref id="B1">
        <label>1.</label>
        <citation-alternatives>
          <mixed-citation publication-type="journal">Bavdekar, R., Chopde, E.J., Bhatia, A., Tiwari, K., <italic>et al</italic>. (2022) Post Quantum Cryptography: Techniques, Challenges, Standardization, and Directions for Future Research. arXiv: 2202.02826. https://doi.org/10.48550/arXiv.2202.02826 <pub-id pub-id-type="doi">10.48550/arXiv.2202.02826</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48550/arXiv.2202.02826">https://doi.org/10.48550/arXiv.2202.02826</ext-link></mixed-citation>
          <element-citation publication-type="journal">
            <person-group person-group-type="author">
              <string-name>Bavdekar, R.</string-name>
              <string-name>Chopde, E.J.</string-name>
              <string-name>Bhatia, A.</string-name>
              <string-name>Tiwari, K.</string-name>
              <string-name>Techniques, C</string-name>
            </person-group>
            <year>2022</year>
            <article-title>Post Quantum Cryptography: Techniques, Challenges, Standardization, and Directions for Future Research</article-title>
            <fpage>2202</fpage>
            <pub-id pub-id-type="doi">10.48550/arXiv.2202.02826</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B2">
        <label>2.</label>
        <citation-alternatives>
          <mixed-citation publication-type="journal">Panhwar, M.A., Khuhro, S.A., Mazhar, T., Deng, Z.L., <italic>et al</italic>. (2021) Quantum Cryptography: A Way of Improving Security of Information. <italic>International Journal</italic><italic>of Mathematics &amp; Computer Science</italic>, 16, 9-12.</mixed-citation>
          <element-citation publication-type="journal">
            <person-group person-group-type="author">
              <string-name>Panhwar, M.A.</string-name>
              <string-name>Khuhro, S.A.</string-name>
              <string-name>Mazhar, T.</string-name>
              <string-name>Deng, Z.L.</string-name>
            </person-group>
            <year>2021</year>
            <article-title>Quantum Cryptography: A Way of Improving Security of Information</article-title>
            <source>International Journal of Mathematics &amp; Computer Science</source>
            <volume>16</volume>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B3">
        <label>3.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Rubia, J., Babitha, R., Nithila, E., Shibi, S. and Rosi, A. (2024) A Survey about Post Quantum Cryptography Methods. <italic>EAI</italic><italic>Endorsed</italic><italic>Transactions</italic><italic>on</italic><italic>Internet</italic><italic>of</italic><italic>Things</italic>, 10, 1-9. https://doi.org/10.4108/eetiot.5099 <pub-id pub-id-type="doi">10.4108/eetiot.5099</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.4108/eetiot.5099">https://doi.org/10.4108/eetiot.5099</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Rubia, J.</string-name>
              <string-name>Babitha, R.</string-name>
              <string-name>Nithila, E.</string-name>
              <string-name>Shibi, S.</string-name>
              <string-name>Rosi, A.</string-name>
            </person-group>
            <year>2024</year>
            <article-title>A Survey about Post Quantum Cryptography Methods</article-title>
            <source>EAI Endorsed Transactions on Internet of Things</source>
            <volume>10</volume>
            <pub-id pub-id-type="doi">10.4108/eetiot.5099</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B4">
        <label>4.</label>
        <citation-alternatives>
          <mixed-citation publication-type="confproc">Bavdekar, R., Jayant Chopde, E., Agrawal, A., Bhatia, A. and Tiwari, K. (2023) Post Quantum Cryptography: A Review of Techniques, Challenges and Standardizations. 2023 <italic>International Conference on Information Networking</italic> ( <italic>ICOIN</italic>), Bangkok, 11-14 January 2023, 146-151. https://doi.org/10.1109/icoin56518.2023.10048976 <pub-id pub-id-type="doi">10.1109/icoin56518.2023.10048976</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1109/icoin56518.2023.10048976">https://doi.org/10.1109/icoin56518.2023.10048976</ext-link></mixed-citation>
          <element-citation publication-type="confproc">
            <person-group person-group-type="author">
              <string-name>Bavdekar, R.</string-name>
              <string-name>Chopde, E.</string-name>
              <string-name>Agrawal, A.</string-name>
              <string-name>Bhatia, A.</string-name>
              <string-name>Tiwari, K.</string-name>
              <string-name>Techniques, C</string-name>
            </person-group>
            <year>2023</year>
            <article-title>Post Quantum Cryptography: A Review of Techniques, Challenges and Standardizations</article-title>
            <source>2023 International Conference on Information Networking (ICOIN)</source>
            <volume>11</volume>
            <pub-id pub-id-type="doi">10.1109/icoin56518.2023.10048976</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B5">
        <label>5.</label>
        <citation-alternatives>
          <mixed-citation publication-type="journal">Nath, A., Maity, S., Banerjee, S. and Roy, R. (2024) Quantum Key Distribution (QKD) for Symmetric Key Transfer. <italic>International Journal of Scientific Research in Comp</italic><italic>uter Science</italic>, <italic>Engineering and Information Technology</italic>, 10, 270-280. https://doi.org/10.32628/cseit24103105 <pub-id pub-id-type="doi">10.32628/cseit24103105</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.32628/cseit24103105">https://doi.org/10.32628/cseit24103105</ext-link></mixed-citation>
          <element-citation publication-type="journal">
            <person-group person-group-type="author">
              <string-name>Nath, A.</string-name>
              <string-name>Maity, S.</string-name>
              <string-name>Banerjee, S.</string-name>
              <string-name>Roy, R.</string-name>
              <string-name>Science, E</string-name>
            </person-group>
            <year>2024</year>
            <article-title>Quantum Key Distribution (QKD) for Symmetric Key Transfer</article-title>
            <source>International Journal of Scientific Research in Computer Science</source>
            <volume>10</volume>
            <pub-id pub-id-type="doi">10.32628/cseit24103105</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B6">
        <label>6.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Sabani, M.E., Savvas, I.K., Poulakis, D., Garani, G. and Makris, G.C. (2023) Evaluation and Comparison of Lattice-Based Cryptosystems for a Secure Quantum Computing Era. <italic>Electronics</italic>, 12, Article 2643. https://doi.org/10.3390/electronics12122643 <pub-id pub-id-type="doi">10.3390/electronics12122643</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.3390/electronics12122643">https://doi.org/10.3390/electronics12122643</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Sabani, M.E.</string-name>
              <string-name>Savvas, I.K.</string-name>
              <string-name>Poulakis, D.</string-name>
              <string-name>Garani, G.</string-name>
              <string-name>Makris, G.C.</string-name>
            </person-group>
            <year>2023</year>
            <article-title>Evaluation and Comparison of Lattice-Based Cryptosystems for a Secure Quantum Computing Era</article-title>
            <source>Electronics</source>
            <volume>12</volume>
            <elocation-id>2643</elocation-id>
            <pub-id pub-id-type="doi">10.3390/electronics12122643</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B7">
        <label>7.</label>
        <citation-alternatives>
          <mixed-citation publication-type="confproc">Sabani, M., Savvas, I., Poulakis, D. and Makris, G. (2022) Quantum Key Distribution: Basic Protocols and Threats. <italic>Proceedings of the</italic> 26 <italic>th Pan</italic>- <italic>Hellenic Conferenc</italic><italic>e on Informatics</italic>, Athens, 25-27 November 2022, 383-388. https://doi.org/10.1145/3575879.3576022 <pub-id pub-id-type="doi">10.1145/3575879.3576022</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1145/3575879.3576022">https://doi.org/10.1145/3575879.3576022</ext-link></mixed-citation>
          <element-citation publication-type="confproc">
            <person-group person-group-type="author">
              <string-name>Sabani, M.</string-name>
              <string-name>Savvas, I.</string-name>
              <string-name>Poulakis, D.</string-name>
              <string-name>Makris, G.</string-name>
              <string-name>Informatics, A</string-name>
            </person-group>
            <year>2022</year>
            <article-title>Quantum Key Distribution: Basic Protocols and Threats</article-title>
            <source>Proceedings of the 26th Pan-Hellenic Conference on Informatics</source>
            <volume>25</volume>
            <pub-id pub-id-type="doi">10.1145/3575879.3576022</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B8">
        <label>8.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Malpani, P., Kumar, S. and Pathak, A. (2024) Implementation of Coherent One Way Protocol for Quantum Key Distribution up to an Effective Distance of 145 km. <italic>Optical and Quantum Electronics</italic>, 56, Article No. 1369. https://doi.org/10.1007/s11082-024-06934-2 <pub-id pub-id-type="doi">10.1007/s11082-024-06934-2</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1007/s11082-024-06934-2">https://doi.org/10.1007/s11082-024-06934-2</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Malpani, P.</string-name>
              <string-name>Kumar, S.</string-name>
              <string-name>Pathak, A.</string-name>
            </person-group>
            <year>2024</year>
            <article-title>Implementation of Coherent One Way Protocol for Quantum Key Distribution up to an Effective Distance of 145 km</article-title>
            <source>Optical and Quantum Electronics</source>
            <volume>56</volume>
            <elocation-id>No</elocation-id>
            <pub-id pub-id-type="doi">10.1007/s11082-024-06934-2</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B9">
        <label>9.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Dam, D.T., Tran, T.H., Hoang, V.P., Pham, C.K. and Hoang, T.T. (2023) A Survey of Post-Quantum Cryptography: Start of a New Race. <italic>Cryptography</italic>, 7, Article 40. https://doi.org/10.3390/cryptography7030040. <pub-id pub-id-type="doi">10.3390/cryptography7030040</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.3390/cryptography7030040">https://doi.org/10.3390/cryptography7030040</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Dam, D.T.</string-name>
              <string-name>Tran, T.H.</string-name>
              <string-name>Hoang, V.P.</string-name>
              <string-name>Pham, C.K.</string-name>
              <string-name>Hoang, T.T.</string-name>
            </person-group>
            <year>2023</year>
            <article-title>A Survey of Post-Quantum Cryptography: Start of a New Race</article-title>
            <source>Cryptography</source>
            <volume>7</volume>
            <elocation-id>40</elocation-id>
            <pub-id pub-id-type="doi">10.3390/cryptography7030040</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B10">
        <label>10.</label>
        <citation-alternatives>
          <mixed-citation publication-type="report">Alagic, G., Cooper, D., Dang, Q., Dang, T., <italic>et al</italic>. (2022) Status Report on the Third Round of the NIST Post-Quantum Cryptography Standardization Process. NIST IR 8413-upd1. National Institute of Standards and Technology.</mixed-citation>
          <element-citation publication-type="report">
            <person-group person-group-type="author">
              <string-name>Alagic, G.</string-name>
              <string-name>Cooper, D.</string-name>
              <string-name>Dang, Q.</string-name>
              <string-name>Dang, T.</string-name>
            </person-group>
            <year>2022</year>
            <article-title>Status Report on the Third Round of the NIST Post-Quantum Cryptography Standardization Process</article-title>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B11">
        <label>11.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">National Institute of Standards and Technology (2024) Module-Lattice-Based Key Encapsulation Mechanism Standard. NIST FIPS 203. U.S. Department of Commerce, Federal Information Processing Standards Publication (FIPS). https://doi.org/10.6028/NIST.FIPS.203 <pub-id pub-id-type="doi">10.6028/NIST.FIPS.203</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.6028/NIST.FIPS.203">https://doi.org/10.6028/NIST.FIPS.203</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Commerce, F</string-name>
            </person-group>
            <year>2024</year>
            <article-title>Module-Lattice-Based Key Encapsulation Mechanism Standard</article-title>
            <source>NIST FIPS 203. U.S. Department of Commerce</source>
            <pub-id pub-id-type="doi">10.6028/NIST.FIPS.203</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B12">
        <label>12.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">National Institute of Standards and Technology (2024) Module-Lattice-Based Digital Signature Standard. NIST FIPS 204. U.S. Department of Commerce, Federal Information Processing Standards Publication (FIPS). https://doi.org/10.6028/NIST.FIPS.204 <pub-id pub-id-type="doi">10.6028/NIST.FIPS.204</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.6028/NIST.FIPS.204">https://doi.org/10.6028/NIST.FIPS.204</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Commerce, F</string-name>
            </person-group>
            <year>2024</year>
            <article-title>Module-Lattice-Based Digital Signature Standard</article-title>
            <source>NIST FIPS 204. U.S. Department of Commerce</source>
            <pub-id pub-id-type="doi">10.6028/NIST.FIPS.204</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B13">
        <label>13.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">National Institute of Standards and Technology (2024) Stateless Hash-Based Digital Signature Standard. NIST FIPS 205. U.S. Department of Commerce, Federal Information Processing Standards Publication (FIPS). https://doi.org/10.6028/NIST.FIPS.205 <pub-id pub-id-type="doi">10.6028/NIST.FIPS.205</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.6028/NIST.FIPS.205">https://doi.org/10.6028/NIST.FIPS.205</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Commerce, F</string-name>
            </person-group>
            <year>2024</year>
            <article-title>Stateless Hash-Based Digital Signature Standard</article-title>
            <source>NIST FIPS 205. U.S. Department of Commerce</source>
            <pub-id pub-id-type="doi">10.6028/NIST.FIPS.205</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B14">
        <label>14.</label>
        <citation-alternatives>
          <mixed-citation publication-type="report">Alagic, G., Bfros, M., Ciadoux, P., <italic>et al</italic>. (2025) Status Report on the Fourth Round of the NIST Post-Quantum Cryptography Standardization Process. NIST IR 8545. https://doi.org/10.6028/NIST.IR.8545 <pub-id pub-id-type="doi">10.6028/NIST.IR.8545</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.6028/NIST.IR.8545">https://doi.org/10.6028/NIST.IR.8545</ext-link></mixed-citation>
          <element-citation publication-type="report">
            <person-group person-group-type="author">
              <string-name>Alagic, G.</string-name>
              <string-name>Bfros, M.</string-name>
              <string-name>Ciadoux, P.</string-name>
            </person-group>
            <year>2025</year>
            <article-title>Status Report on the Fourth Round of the NIST Post-Quantum Cryptography Standardization Process</article-title>
            <pub-id pub-id-type="doi">10.6028/NIST.IR.8545</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B15">
        <label>15.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Li, S., Chen, Y., Chen, L., Liao, J., Kuang, C., Li, K., <italic>et al</italic>. (2023) Post-Quantum Security: Opportunities and Challenges. <italic>Sensors</italic>, 23, Article 8744. https://doi.org/10.3390/s23218744 <pub-id pub-id-type="doi">10.3390/s23218744</pub-id><pub-id pub-id-type="pmid">37960442</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.3390/s23218744">https://doi.org/10.3390/s23218744</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Li, S.</string-name>
              <string-name>Chen, Y.</string-name>
              <string-name>Chen, L.</string-name>
              <string-name>Liao, J.</string-name>
              <string-name>Kuang, C.</string-name>
              <string-name>Li, K.</string-name>
            </person-group>
            <year>2023</year>
            <article-title>Post-Quantum Security: Opportunities and Challenges</article-title>
            <source>Sensors</source>
            <volume>23</volume>
            <elocation-id>8744</elocation-id>
            <pub-id pub-id-type="doi">10.3390/s23218744</pub-id>
            <pub-id pub-id-type="pmid">37960442</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B16">
        <label>16.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Pouly, A., Shen, Y. (2026) Solving the Shortest Vector Problem in Time on Random Lattices. In: Daemen, J. and Thomé, E., <italic>Advances in Cryptology</italic>— <italic>EUR</italic><italic>OCRYPT</italic>2026, Springer, 92-123.</mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Pouly, A.</string-name>
              <string-name>Shen, Y.</string-name>
              <string-name>Daemen, J.</string-name>
            </person-group>
            <year>2026</year>
            <article-title>Solving the Shortest Vector Problem in Time on Random Lattices</article-title>
            <source>In: Daemen</source>
            <volume>92</volume>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B17">
        <label>17.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Sabani, M.E., Savvas, I.K. and Garani, G. (2024) Learning with Errors: A Lattice-Based Keystone of Post-Quantum Cryptography. <italic>Signals</italic>, 5, 216-243. https://doi.org/10.3390/signals5020012 <pub-id pub-id-type="doi">10.3390/signals5020012</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.3390/signals5020012">https://doi.org/10.3390/signals5020012</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Sabani, M.E.</string-name>
              <string-name>Savvas, I.K.</string-name>
              <string-name>Garani, G.</string-name>
            </person-group>
            <year>2024</year>
            <article-title>Learning with Errors: A Lattice-Based Keystone of Post-Quantum Cryptography</article-title>
            <source>Signals</source>
            <volume>5</volume>
            <pub-id pub-id-type="doi">10.3390/signals5020012</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B18">
        <label>18.</label>
        <citation-alternatives>
          <mixed-citation publication-type="journal">Chhetri, G., Somvanshi, S., Hebli, P., Brotee, S. and Das, S. (2025) Post-Quantum Cryptography and Quantum-Safe Security: A Comprehensive Survey. arXiv: 2510.10436. https://doi.org/10.48550/arXiv.2510.10436 <pub-id pub-id-type="doi">10.48550/arXiv.2510.10436</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.48550/arXiv.2510.10436">https://doi.org/10.48550/arXiv.2510.10436</ext-link></mixed-citation>
          <element-citation publication-type="journal">
            <person-group person-group-type="author">
              <string-name>Chhetri, G.</string-name>
              <string-name>Somvanshi, S.</string-name>
              <string-name>Hebli, P.</string-name>
              <string-name>Brotee, S.</string-name>
              <string-name>Das, S.</string-name>
            </person-group>
            <year>2025</year>
            <article-title>Post-Quantum Cryptography and Quantum-Safe Security: A Comprehensive Survey</article-title>
            <fpage>2510</fpage>
            <pub-id pub-id-type="doi">10.48550/arXiv.2510.10436</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B19">
        <label>19.</label>
        <citation-alternatives>
          <mixed-citation publication-type="confproc">Sinha Roy, S. (2019) SaberX4: High-Throughput Software Implementation of Saber Key Encapsulation Mechanism. 2019 <italic>IEEE</italic> 37 <italic>th International Conference on Computer Design</italic> ( <italic>ICCD</italic>), Abu Dhabi, 17-20 November 2019, 321-324. https://doi.org/10.1109/iccd46524.2019.00050 <pub-id pub-id-type="doi">10.1109/iccd46524.2019.00050</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1109/iccd46524.2019.00050">https://doi.org/10.1109/iccd46524.2019.00050</ext-link></mixed-citation>
          <element-citation publication-type="confproc">
            <person-group person-group-type="author">
              <string-name>Roy, S.</string-name>
            </person-group>
            <year>2019</year>
            <article-title>SaberX4: High-Throughput Software Implementation of Saber Key Encapsulation Mechanism</article-title>
            <source>2019 IEEE 37th International Conference on Computer Design (ICCD)</source>
            <volume>17</volume>
            <pub-id pub-id-type="doi">10.1109/iccd46524.2019.00050</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B20">
        <label>20.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Hoffstein, J., Pipher, J. and Silverman, J.H. (1998) NTRU: A Ring-Based Public Key Cryptosystem. In: <italic>Lecture Notes in Computer Science</italic>, Springer, 267-288. https://doi.org/10.1007/bfb0054868 <pub-id pub-id-type="doi">10.1007/bfb0054868</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1007/bfb0054868">https://doi.org/10.1007/bfb0054868</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Hoffstein, J.</string-name>
              <string-name>Pipher, J.</string-name>
              <string-name>Silverman, J.H.</string-name>
              <string-name>Science, S</string-name>
            </person-group>
            <year>1998</year>
            <article-title>NTRU: A Ring-Based Public Key Cryptosystem</article-title>
            <source>In: Lecture Notes in Computer Science</source>
            <volume>267</volume>
            <pub-id pub-id-type="doi">10.1007/bfb0054868</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B21">
        <label>21.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Peng, K.X. and Du, S.Y. (2024) Falcon Anti-Quantum Attack Scheme Based on 8-Qubits Channel RSP, PREPRINT (Version 1). https://doi.org/10.21203/rs.3.rs-5316539/v1 <pub-id pub-id-type="doi">10.21203/rs.3.rs-5316539/v1</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.21203/rs.3.rs-5316539/v1">https://doi.org/10.21203/rs.3.rs-5316539/v1</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Peng, K.X.</string-name>
              <string-name>Du, S.Y.</string-name>
              <string-name>RSP, P</string-name>
            </person-group>
            <year>2024</year>
            <article-title>Falcon Anti-Quantum Attack Scheme Based on 8-Qubits Channel RSP, PREPRINT (Version 1)</article-title>
            <pub-id pub-id-type="doi">10.21203/rs.3.rs-5316539/v1</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B22">
        <label>22.</label>
        <citation-alternatives>
          <mixed-citation publication-type="web">Srivastava, V., Baksi, A. and Debnath, S.K. (2023) An Overview of Hash Based Signatures. IACR Cryptology ePrint Archive. https://eprint.iacr.org/2023/411</mixed-citation>
          <element-citation publication-type="web">
            <person-group person-group-type="author">
              <string-name>Srivastava, V.</string-name>
              <string-name>Baksi, A.</string-name>
              <string-name>Debnath, S.K.</string-name>
            </person-group>
            <year>2023</year>
            <article-title>An Overview of Hash Based Signatures</article-title>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B23">
        <label>23.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Paiva, T.B. and Terada, R. (2020) A Timing Attack on the HQC Encryption Scheme. In: <italic>Lecture</italic><italic>Notes</italic><italic>in</italic><italic>Computer</italic><italic>Science</italic>, Springer, 551-573. https://doi.org/10.1007/978-3-030-38471-5_22 <pub-id pub-id-type="doi">10.1007/978-3-030-38471-5_22</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1007/978-3-030-38471-5_22">https://doi.org/10.1007/978-3-030-38471-5_22</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Paiva, T.B.</string-name>
              <string-name>Terada, R.</string-name>
              <string-name>Science, S</string-name>
            </person-group>
            <year>2020</year>
            <article-title>A Timing Attack on the HQC Encryption Scheme</article-title>
            <source>In: Lecture Notes in Computer Science</source>
            <volume>551</volume>
            <pub-id pub-id-type="doi">10.1007/978-3-030-38471-5_22</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B24">
        <label>24.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Matthews, G.L. and McMillon, E. (2025) A Combinatorial Approach to Avoiding Weak Keys in the BIKE Cryptosystem. <italic>Designs,</italic><italic>Codes</italic><italic>and</italic><italic>Cryptography</italic>, 93, 3413-3436. https://doi.org/10.1007/s10623-025-01643-7 <pub-id pub-id-type="doi">10.1007/s10623-025-01643-7</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1007/s10623-025-01643-7">https://doi.org/10.1007/s10623-025-01643-7</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Matthews, G.L.</string-name>
              <string-name>McMillon, E.</string-name>
              <string-name>Designs, C</string-name>
            </person-group>
            <year>2025</year>
            <article-title>A Combinatorial Approach to Avoiding Weak Keys in the BIKE Cryptosystem</article-title>
            <source>Designs</source>
            <volume>93</volume>
            <pub-id pub-id-type="doi">10.1007/s10623-025-01643-7</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B25">
        <label>25.</label>
        <citation-alternatives>
          <mixed-citation publication-type="web">Bernstein, D.J., Dobraunig, C., Schwabe, P., <italic>et al</italic>. (2017) SPHINCS+ Submission to the NIST Post-Quantum Cryptography Project. https://sphincs.org/data/sphincs%2B-specification.pdf</mixed-citation>
          <element-citation publication-type="web">
            <person-group person-group-type="author">
              <string-name>Bernstein, D.J.</string-name>
              <string-name>Dobraunig, C.</string-name>
              <string-name>Schwabe, P.</string-name>
            </person-group>
            <year>2017</year>
            <article-title>SPHINCS+ Submission to the NIST Post-Quantum Cryptography Project</article-title>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B26">
        <label>26.</label>
        <citation-alternatives>
          <mixed-citation publication-type="confproc">Hülsing, A. and Gazdag, S.L. (2015) Hash-Based Signatures: An Outline for a New Standard. <italic>NIST Workshop on Cybersecurity in a Post</italic>- <italic>Quantum World</italic>, Gaithersburg, 2-3 April 2015, 1-12.</mixed-citation>
          <element-citation publication-type="confproc">
            <person-group person-group-type="author">
              <string-name>Gazdag, S.L.</string-name>
              <string-name>World, G</string-name>
            </person-group>
            <year>2015</year>
            <article-title>Hash-Based Signatures: An Outline for a New Standard</article-title>
            <source>NIST Workshop on Cybersecurity in a Post-Quantum World</source>
            <volume>2</volume>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B27">
        <label>27.</label>
        <citation-alternatives>
          <mixed-citation publication-type="confproc">Varnita, L.S.M.S., Subramanyam, K., Narasimha, T.P., Bhandari, H., <italic>et al</italic>. (2024) A Study on Isogeny Based Cryptography. 2024 <italic>International Conference on Electron</italic><italic>ics</italic>, <italic>Comput</italic><italic>ing</italic>, <italic>Communication and Control Technology</italic><italic>(ICECCC</italic>), Bengaluru, 2-3 May 2024, 1-6. https://doi.org/10.1109/iceccc61767.2024.10593878 <pub-id pub-id-type="doi">10.1109/iceccc61767.2024.10593878</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1109/iceccc61767.2024.10593878">https://doi.org/10.1109/iceccc61767.2024.10593878</ext-link></mixed-citation>
          <element-citation publication-type="confproc">
            <person-group person-group-type="author">
              <string-name>Varnita, L.S.M.S.</string-name>
              <string-name>Subramanyam, K.</string-name>
              <string-name>Narasimha, T.P.</string-name>
              <string-name>Bhandari, H.</string-name>
              <string-name>Electronics, C</string-name>
            </person-group>
            <year>2024</year>
            <article-title>A Study on Isogeny Based Cryptography</article-title>
            <source>2024 International Conference on Electronics</source>
            <volume>2</volume>
            <pub-id pub-id-type="doi">10.1109/iceccc61767.2024.10593878</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B28">
        <label>28.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Seo, H., Anastasova, M., Jalali, A. and Azarderakhsh, R. (2021) Supersingular Isogeny Key Encapsulation (SIKE) Round 2 on ARM Cortex-M4. <italic>IEEE Transactions on Computers</italic>, 70, 1705-1718. https://doi.org/10.1109/tc.2020.3023045 <pub-id pub-id-type="doi">10.1109/tc.2020.3023045</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1109/tc.2020.3023045">https://doi.org/10.1109/tc.2020.3023045</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Seo, H.</string-name>
              <string-name>Anastasova, M.</string-name>
              <string-name>Jalali, A.</string-name>
              <string-name>Azarderakhsh, R.</string-name>
            </person-group>
            <year>2021</year>
            <article-title>Supersingular Isogeny Key Encapsulation (SIKE) Round 2 on ARM Cortex-M4</article-title>
            <source>IEEE Transactions on Computers</source>
            <volume>70</volume>
            <pub-id pub-id-type="doi">10.1109/tc.2020.3023045</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B29">
        <label>29.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Petzoldt, A. (2020) Efficient Key Generation for Rainbow. In: <italic>Lecture Notes in Computer Science</italic>, Springer, 92-107. https://doi.org/10.1007/978-3-030-44223-1_6 <pub-id pub-id-type="doi">10.1007/978-3-030-44223-1_6</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1007/978-3-030-44223-1_6">https://doi.org/10.1007/978-3-030-44223-1_6</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Petzoldt, A.</string-name>
              <string-name>Science, S</string-name>
            </person-group>
            <year>2020</year>
            <article-title>Efficient Key Generation for Rainbow</article-title>
            <source>In: Lecture Notes in Computer Science</source>
            <volume>92</volume>
            <pub-id pub-id-type="doi">10.1007/978-3-030-44223-1_6</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B30">
        <label>30.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Beullens, W. (2021) Improved Cryptanalysis of UOV and Rainbow. In: <italic>Lecture Notes in Computer Science</italic>, Springer, 348-373. https://doi.org/10.1007/978-3-030-77870-5_13 <pub-id pub-id-type="doi">10.1007/978-3-030-77870-5_13</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.1007/978-3-030-77870-5_13">https://doi.org/10.1007/978-3-030-77870-5_13</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Beullens, W.</string-name>
              <string-name>Science, S</string-name>
            </person-group>
            <year>2021</year>
            <article-title>Improved Cryptanalysis of UOV and Rainbow</article-title>
            <source>In: Lecture Notes in Computer Science</source>
            <volume>348</volume>
            <pub-id pub-id-type="doi">10.1007/978-3-030-77870-5_13</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B31">
        <label>31.</label>
        <citation-alternatives>
          <mixed-citation publication-type="web">Swayne, M. (2025) Quantum Computing Roadmaps: A Look at the Maps and Predictions of Major Players. The Quantum Insider. https://thequantuminsider.com/2025/05/16/quantum-computing-roadmaps-a-look-at-the-maps-and-predictions-of-major-quantum-players/</mixed-citation>
          <element-citation publication-type="web">
            <person-group person-group-type="author">
              <string-name>Swayne, M.</string-name>
            </person-group>
            <year>2025</year>
            <article-title>Quantum Computing Roadmaps: A Look at the Maps and Predictions of Major Players</article-title>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B32">
        <label>32.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Chang, S.Y. and Khan, Q. (2026) Post-quantum Cryptography in Networking Protocols: Challenges, Solutions, and Future Directions. <italic>Cryptography</italic>, 10, Article 12. https://doi.org/10.3390/cryptography10010012 <pub-id pub-id-type="doi">10.3390/cryptography10010012</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.3390/cryptography10010012">https://doi.org/10.3390/cryptography10010012</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Chang, S.Y.</string-name>
              <string-name>Khan, Q.</string-name>
              <string-name>Challenges, S</string-name>
            </person-group>
            <year>2026</year>
            <article-title>Post-quantum Cryptography in Networking Protocols: Challenges, Solutions, and Future Directions</article-title>
            <source>Cryptography</source>
            <volume>10</volume>
            <elocation-id>12</elocation-id>
            <pub-id pub-id-type="doi">10.3390/cryptography10010012</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B33">
        <label>33.</label>
        <citation-alternatives>
          <mixed-citation publication-type="web">Internet Pros Team (2026) Post-Quantum Cryptography: How PQC Is Protecting the Digital World from Quantum Threats in 2026. Internet Pros. https://internet-pros.com/blog/post-quantum-cryptography-pqc-2026/</mixed-citation>
          <element-citation publication-type="web">
            <year>2026</year>
            <article-title>Post-Quantum Cryptography: How PQC Is Protecting the Digital World from Quantum Threats in 2026</article-title>
          </element-citation>
        </citation-alternatives>
      </ref>
      <ref id="B34">
        <label>34.</label>
        <citation-alternatives>
          <mixed-citation publication-type="other">Sonbul, O.S., Rashid, M. and Jaffar, A.Y. (2025) Accelerating Crystals-Kyber: High-Speed NTT Design with Optimized Pipelining and Modular Reduction. <italic>Electronics</italic>, 14, Article 2122. https://doi.org/10.3390/electronics14112122 <pub-id pub-id-type="doi">10.3390/electronics14112122</pub-id><ext-link ext-link-type="uri" xlink:href="https://doi.org/10.3390/electronics14112122">https://doi.org/10.3390/electronics14112122</ext-link></mixed-citation>
          <element-citation publication-type="other">
            <person-group person-group-type="author">
              <string-name>Sonbul, O.S.</string-name>
              <string-name>Rashid, M.</string-name>
              <string-name>Jaffar, A.Y.</string-name>
            </person-group>
            <year>2025</year>
            <article-title>Accelerating Crystals-Kyber: High-Speed NTT Design with Optimized Pipelining and Modular Reduction</article-title>
            <source>Electronics</source>
            <volume>14</volume>
            <elocation-id>2122</elocation-id>
            <pub-id pub-id-type="doi">10.3390/electronics14112122</pub-id>
          </element-citation>
        </citation-alternatives>
      </ref>
    </ref-list>
  </back>
</article>