Multi-Solution Ternary Grover’s Algorithm for Logic-Based Quantum Machine Learning with Pseudo-Kronecker Reed–Muller Form Minimization

Abstract

Optimization problems in machine-learning (ML) applications can be computationally challenging for classical methods, particularly when they involve large, unstructured search spaces. Quantum computing offers a promising approach to combinatorial optimization by utilizing quantum superposition and amplitude amplification. This paper presents a new methodology using logic-based quantum machine learning (QML) as a complete framework for employing a multi-solution ternary Grover’s algorithm to minimize incomplete binary functions represented by Pseudo-Kronecker Reed–Muller (PKRO) expansions, consistent with Occam’s razor principle. Unlike previous quantum approaches based on Kronecker Reed–Muller (KRO) or fixed-polarity Reed–Muller (FPRM) representations, our work introduces the first Grover-based optimization framework for PKRO forms. This framework formulates logic minimization as a quantum search problem to identify minimum-cost AND-XOR representations with the fewest nonzero coefficients. A hybrid binary–ternary quantum architecture is developed to explore the enlarged PKRO search space, enabling optimization of both completely and incompletely specified binary functions. Owing to the greater flexibility of PKRO expansions, our framework produces more compact AND–XOR representations than KRO- and FPRM-based approaches. Across all 256 3-variable binary functions, PKRO provides less nonzero coefficients for 4.688% of functions compared with KRO and for 37.5% compared with FPRM, with average reductions of 0.047 and 0.484 nonzero coefficients, respectively. Our multi-solution ternary Grover search reduces the number of Grover iterations by more than 91% compared with the single-solution approach.

1. Introduction

Quantum machine learning (QML) integrates quantum computing principles with machine learning (ML) to address computationally challenging learning and optimization problems [1]. Classical logic-based machine learning has evolved through interpretable representations, including decision rules, decision trees, Boolean expressions, and symbolic models. Early inductive learning approaches [2] established rule-based learning from examples, followed by the Classification Induction (CN2) algorithm [3], Iterative Dichotomiser 3 (ID3) and its successor, C4.5 decision tree algorithms [4,5], First Order Inductive Learner (FOIL) [6], and Repeated Incremental Pruning to Produce Error Reduction (RIPPER) [7] for symbolic classification and rule extraction. In parallel, Binary Decision Diagrams (BDDs) [8] and logic synthesis techniques based on Sum-of-Products (SOP), Exclusive-Sum-of-Products (ESOP) [9], and Boolean function minimization [10] provided efficient representations and optimization methods for binary functions. Functional decomposition approaches, including Ashenhurst–Curtis decomposition [11], and spectral techniques based on Reed–Muller (RM) representations [12], further enhanced the analysis and optimization of binary functions. These classical methods establish the foundation for interpretable machine learning, symbolic reasoning, and logic optimization.

Recent advances have explored the reformulation of Boolean optimization and symbolic learning problems as quantum search and optimization problems. Quantum logic synthesis and binary function optimization approaches have demonstrated the feasibility of mapping classical logic-minimization problems into reversible quantum circuits [13,14]. Grover’s quantum search algorithm [15,16] provides a quadratic reduction in oracle query complexity for unstructured search by amplifying the probability amplitudes of target states [17,18]. In Grover-based optimization, a quantum oracle is implemented as a reversible operator that evaluates candidate solutions and marks target states (solutions) through phase inversion. Multi-solution extensions of Grover’s algorithm further reduce the required amplitude amplification iterations when multiple valid solutions exist [19,20]. In addition, the Quantum Approximate Optimization Algorithm (QAOA) [21] and its variants [22] have been widely applied to approximately solve combinatorial optimization problems by optimizing parameterized quantum circuits. These developments motivate the application of quantum search techniques to logic-minimization and symbolic machine-learning optimization problems.

Efficient representation of machine-learning classifier functions is critical for reducing computational complexity during training and inference. Many logic-based learning problems can be formulated as identifying compact Boolean expressions in AND–XOR form, consistent with Occam’s razor [23,24,25], which favors simpler models while maintaining classification accuracy. In an AND–XOR representation, binary functions are expressed as XOR combinations of product terms associated with nonzero coefficients, providing a spectral-domain alternative to conventional truth-table and logic-expression representations. The complexity of these representations is commonly evaluated by the number of nonzero product terms and the resulting circuit implementation cost [18]. Their regular structures also enable efficient logic synthesis and hardware implementation [19]. The most general AND–XOR representation is the Exclusive-or Sum-of-Products (ESOP) form. However, unlike canonical spectral representations such as fixed-polarity Reed–Muller (FPRM), Kronecker Reed–Muller (KRO), and Pseudo-Kronecker Reed–Muller (PKRO) [26,27,28,29], ESOP does not provide a unique spectral representation, making exact minimization computationally challenging. Since exact ESOP minimization is NP-hard and becomes impractical for large binary functions, heuristic methods, including simulated annealing, genetic algorithms, and evolutionary optimization, are commonly employed to obtain near-optimal ESOP and RM representations [30,31,32,33,34,35]. To balance representation flexibility and optimization complexity, structured AND–XOR forms such as FPRM, KRO, and PKRO have been developed. These spectral representations provide regular decomposition structures that can be efficiently implemented using transform-based butterfly networks. In RM spectral logic, the polarity specifies the expansion type applied at each step of the recursive decomposition. Among these canonical approaches, PKRO provides the greatest flexibility by allowing different polarities at individual decomposition nodes, enabling more compact AND–XOR expressions with fewer nonzero coefficients than more restricted forms such as FPRM and KRO. However, this flexibility significantly enlarges the optimization space, making exhaustive minimization increasingly challenging as the number of variables grows. To overcome this challenge, we propose a quantum-assisted search framework. In addition, it extends PKRO minimization to incompletely specified binary functions, enabling its application to logic-based quantum machine learning.

Machine-learning methods learn input–output relationships from observed training data and generalize these relationships to unseen instances. In logic-based machine learning, incomplete knowledge about unobserved input combinations can be represented similarly to unspecified conditions in logic synthesis, where “don’t-care” assignments provide flexibility for function optimization. From this perspective, learning can be formulated as the selection of a binary function that satisfies observed input–output constraints while minimizing representation complexity according to Occam’s razor. Therefore, the learning objective can be mapped to finding compact AND–XOR representations with a minimum number of nonzero coefficients (product terms). Recent studies have investigated the application of quantum computing to machine learning by implementing existing algorithms on quantum platforms or reformulating learning and optimization problems as quantum search and optimization tasks. Representative developments in quantum machine-learning algorithms include [17,26,27,36]. These studies demonstrate the feasibility of formulating logic-based learning problems as quantum optimization problems, providing a foundation for our proposed PKRO-based quantum machine-learning framework.

Our work proposes a quantum machine-learning approach using spectral transformations to search for minimum-term PKRO representations. An optimal PKRO solution is defined as the representation with the minimum number of product terms (nonzero coefficients). An n-variable binary function is represented by a minterm vector, where each variable appears once in complemented or uncomplemented form within each minterm. For incompletely specified training data, undefined entries (“−”) are treated as don’t-care conditions and assigned binary values (0 and 1) to generate completely specified functions. PKRO expansions transform these functions into spectral-domain AND–XOR representations, and the spectral coefficient vector with the minimum number of nonzero coefficients is selected. The proposed Grover-based quantum search explores the enlarged PKRO solution space through amplitude amplification, achieving a quadratic reduction in oracle evaluations and providing an efficient optimization framework for logic-based quantum machine-learning applications.

A major task in our research is the construction of a hybrid binary–ternary quantum oracle for Grover’s algorithm. The reversible PKRO processor transforms a minterm vector into an AND–XOR spectral coefficient vector based on the selected variable ordering and PKRO polarity assignment. The oracle evaluates the cost function, defined as the number of nonzero spectral coefficients, and determines whether the candidate PKRO representation satisfies a given threshold T. Since Grover’s algorithm performs search rather than direct optimization, PKRO minimization is formulated as a sequence of threshold-based decision problems. A classical controller updates T according to the oracle results until the minimum-cost representation is identified. The oracle is implemented as a reversible hybrid quantum circuit using both qubit and qutrit registers. Qubit registers store minterm data, intermediate states, and AND-XOR coefficient information, while qutrit registers encode the three PKRO polarity choices. After a successful Grover search, measurement of the qutrit registers reveals the optimal ternary expansion configuration. This hybrid architecture enables quantum exploration of the PKRO solution space while retaining classical control for threshold optimization.

Applications of our above-proposed quantum machine-learning framework based on incomplete binary functions can be extended to recommender systems [37], knowledge graph completion [38], multi-label learning [39], crowdsourcing [40], drug–target prediction [41], and other machine-learning tasks.

The main contributions of this research are summarized as follows:

• A hybrid quantum–classical framework for logic minimization and logic-based quantum machine learning. The proposed framework supports both completely specified and incompletely specified binary functions with “don’t-care” conditions. For machine-learning problems with unspecified input combinations, the corresponding output assignments can be treated as flexible, analogous to logic-synthesis “don’t-care” conditions.
• A unified butterfly-based representation for PKRO expansions. A general butterfly transformation framework is developed to represent all PKRO expansion structures. By leveraging quantum superposition, the proposed approach enables parallel exploration of PKRO configurations and demonstrates the greater flexibility of PKRO compared with FPRM and KRO representations [23].
• A hybrid binary–ternary Grover’s algorithm for PKRO optimization. Our proposed algorithm identifies the minimum-cost PKRO representation, where the cost is defined by the number of nonzero coefficients (product terms). The corresponding butterfly structure is implemented as a reversible binary–ternary quantum circuit.
• A quantum-assisted optimization method for incomplete binary learning problems. Our method addresses incomplete input–output specifications and introduces post-processing and post-selection methods to improve Grover search success probability.
• Simulation-based analysis and robotic demonstration of our proposed quantum optimization framework. The results evaluate the effectiveness of our multi-solution ternary Grover algorithm by reducing the required number of Grover iterations compared with single-solution approaches, which is consistent with multi-solution amplitude amplification theory.

2. Related Work

2.1. Comparison of Different Reed–Muller Forms for Binary Functions

This paper presents a spectral-logic framework for logic minimization and logic-based quantum machine learning. AND–XOR minimization has been widely studied in classical logic synthesis to reduce circuit complexity and is well suited for quantum circuit design because reversible gates, such as CNOT and Toffoli gates, naturally implement XOR operations. Compact AND–XOR representations can, therefore, enable more efficient reversible and quantum circuits. Both logic synthesis and logic-based machine learning can be formulated as binary function optimization problems: logic synthesis derives compact Boolean representations from specifications, while machine learning infers simple binary functions from input–output data according to Occam’s razor.

A binary function can be represented as an OR combination of minterms, where each minterm is an AND combination of literals [32]. An n-variable binary function can be expressed as follows (1):

$$f={\sum }_{i=0}^{2^n-1}{m}_i{p}_i\left(x_1,x_2,\dots ,x_n\right),$$

(1)

where $m_i\in \left\{0,1\right\}$ is the binary coefficient indicating whether the ith minterm is present or not, and $p_i(x_1,x_2,\dots ,x_n)$ is the ith minterm product term formulated in (2):

$$p_i(x_1,x_2,\dots ,x_n)={\prod }_{j=1}^n{x}_j^{b_j}{\overline{x}}_j^{1-b_j},$$

(2)

where $b_j \in \left\{0,1\right\}$ is the jth bit of the binary representation of the minterm index $i$.

For example, a 3-variable binary function $f$ is expressed in (3)

$$f=m_0\overline{x_1} \overline{x_2} \overline{x_3}+m_1\overline{x_1} \overline{x_2} x_3+m_2\overline{x_1} x_2 \overline{x_3}+m_3\overline{x_1}{x}_2{x}_3+m_4{x}_1\overline{x_2} \overline{x_3}+{ m}_5{x}_1\overline{x_2} x_3+m_6{x}_1{x}_2 \overline{x_3}+m_7{x}_1{x}_2{x}_3.$$

(3)

Because all base functions in (1) are disjoint, OR operators can be transformed into XOR operators using RM expansions. Let $f_i^0$ denote the negative cofactor of $x_i$, where $x_i$ is replaced by 0 in $f$; let $f_i^1$ denote the positive cofactor of $x_i$, where $x_i$ is replaced by 1 in $f$; and let $f_i^2=f_i^0\oplus f_i^1$. Based on these definitions, three fundamental expansions shown in (4)–(6) generalize the RM expansion framework [42].

$$f={\overline{x}}_i{f}_i^0\oplus x_i{f}_i^1,\text{\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}Shannon (Sh)},$$

(4)

$$f=f_i^0\oplus x_i{f}_i^2,\text{\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}Positive Davio (pD)},$$

(5)

$$f=f_i^1\oplus {\overline{x}}_i{f}_i^2,\text{\hspace{1em}\hspace{1em}\hspace{1em}Negative Davio (nD)}.$$

(6)

For an n-variable binary function in AND–XOR representation, the general formular is expressed in (7):

$$f(x_1,x_2,\dots ,x_n)={⨁}_{i=0}^{2^n-1}{a}_i{h}_i(x_1,x_2,\dots ,x_n),$$

(7)

where $\oplus$ = XOR (mod-2 addition), $a_i\in \{0,1\}$ is the binary coefficient indicating whether the product term is included or not, and $h_i\left(x_1,x_2,\dots ,x_n\right)$ is the AND product term. The product term is formulated in (8):

$$h_i\left(x_1,x_2,\dots ,x_n\right)={\prod }_{k=1}^n{l}_{ik},$$

(8)

where $l_{ik}\in \left\{1,x_k,{\overline{x}}_k\right\}$ representation generalizes to allow each literal to appear as uncomplemented: $x_k$, complemented: ${\overline{x}}_k$, and absent: 1.

For example, RM forms of three variables can be expressed in AND–XOR representations in (9).

$$f={a_{0}1\oplus a_1\widehat{x}}_1{\oplus a_2\widehat{x}}_2{\oplus a_3\widehat{x}}_3{\oplus a_4 \widehat{x}}_1{\widehat{x}}_2{\oplus a_5\widehat{x}}_1{\widehat{x}}_3{\oplus a_6 \widehat{x}}_2{\widehat{x}}_3{\oplus a_7\widehat{x}}_1{\widehat{x}}_2{\widehat{x}}_{3,}$$

(9)

where ${\widehat{x}}_i$ denotes a literal that may appear in either complemented or uncomplemented form for all $i$.

Throughout this paper, ternary polarity values 0, 1, and 2 are used to represent the positive Davio (pD), negative Davio (nD), and Shannon (Sh) expansions, respectively. Each polarity assignment produces different AND–XOR expressions, and the resulting spectral coefficient distribution determines the number of product terms and the implementation complexity. Our approach is based on the theory of canonical AND-XOR forms as well as spectral methods [10,25,26,31,43]. For an n-variable binary function (n ≥ 2), FPRM form allows each variable to use either pD or nD expansion, resulting in $2^n$ possible polarity assignments. KRO form further allows each variable level to use one of three expansion types (pD, nD, or Sh), producing $3^n$ possible assignments. However, the expansion type of a variable remains fixed throughout the decomposition tree for KRO. PKRO further relaxes this restriction by permitting different expansion types at individual decomposition nodes, resulting in more compact logic representations and improved optimization opportunities. Since exact minimization of ESOP and RM expressions is NP-hard, practical synthesis relies on restricted representations such as PKRO, together with efficient optimization algorithms that balance logic quality and computational complexity. Figure 1a illustrates the three RM expansion rules used in our work. Figure 1b shows an example of the 4-variable PKRO decomposition tree.

Figure 1. (a) Illustration of three expansion types: positive Davio (pD), negative Davio (nD) and Shannon (Sh); and (b) an example of a 4-variable PKRO expansion tree structure.

Theorem 1.

For an $n$-variable binary function, the total number R of PKRO expansion forms is expressed in (10),

$$R=n!3^{2^n-1}$$

(10)

where the factor $n!$ represents the number of possible variable expansion sequences, and $3^{2^n-1}$ represents the number of possible node-level assignments of positive Davio (pD), negative Davio (nD) and Shannon (Sh) expansions in the PKRO decomposition tree, where n ≥ 2.

Proof of Theorem 1.

A PKRO representation is uniquely determined by three components: (i) the binary function $\mathrm{f}$; (ii) the variable expansion sequence $\mathsf{\sigma }=({\mathrm{x}}_{{\mathrm{i}}_1},{\mathrm{x}}_{{\mathrm{i}}_2},\dots ,{\mathrm{x}}_{{\mathrm{i}}_{\mathrm{n}}})$, which specifies the order of variable decomposition; and (iii) the expansion-type assignment $\mathrm{B}$, which specifies the expansion type selected at a node of the decomposition tree. Therefore, a PKRO construction can be represented in (11),

$$R=R(f,\sigma , B),$$

(11)

where $R\left(\cdot \right)$ denotes the recursive construction of the PKRO expansion from the function, the variable ordering, and the expansion-type assignment.

For each fixed variable expansion sequence, as shown in Figure 1b, the number of expansion nodes $w_i$ at each level forms a geometric series $w_1,w_2,\dots ,w_i,\dots ,w_n$ with a ratio of 2. Therefore, a complete binary decomposition tree of an n-variable binary function contains ${W=2}^n-1$ nodes. $B$ is the set of expansion choices assigned to PKRO expansion tree nodes, as stated in (12):

$$B=\{b_1,b_2,\dots ,b_{2^n-1}\},b_j\in \{Sh,pD,nD\},$$

(12)

For ${W=2}^n-1$ nodes in a fixed variable expansion sequence, the number of PKRO expansion assignments R₁ is expressed in (13):

$$R_1=3^{2^n-1}.$$

(13)

We need to prove that the recursive decomposition depends on the selected expansion variable at each level. Suppose ${\sigma }_1=(x_i,{\sigma }^{\prime })$ and ${\sigma }_2=\left(x_j,{\sigma }^{″}\right)$, where $i\ne j.$ The first decomposition under ${\sigma }_1$ is $\mathcal{R}\left(f,{\sigma }_1,B\right)=D_{d_1}(x_i,f_i^0,f_i^1),$ where $D_{d_1}$ denotes the selected Sh, pD or nD decomposition. Similarly, $\mathcal{R}\left(f,{\sigma }_2,B\right)=D_{d_1}(x_j,f_j^0,f_j^1).$ Since $x_i\ne x_j,$ the variable sequences ${\sigma }_1$ and ${\sigma }_2$ are distinct. For a general binary function, cofactors with respect to different expansion variables are generally different, resulting in different intermediate subfunctions and recursive decomposition trees. Consequently, $\mathcal{R}\left(f,{\sigma }_1,B\right)\ne \mathcal{R}\left(f,{\sigma }_2,B\right)$, even when the same expansion-type assignment is used. Please note that although certain symmetric or degenerate binary functions may yield equivalent decompositions under different variable orderings, the complete PKRO search space must consider all n! variable orderings for general cases. Therefore, when the variable ordering is included, the complete PKRO search space contains $n!R_1$ candidate representations, as given in (14), which is equivalent to (10).

$$R=n!R_1=n!3^{2^n-1}$$

(14)

□

For an n-variable binary function, the PKRO search space is substantially larger than those of KRO and FPRM, providing greater flexibility for logic optimization. This expanded search space increases the likelihood of finding representations with fewer product terms [44,45] while also motivating the use of quantum search to identify minimum-cost PKRO forms efficiently.

A PKRO expansion can be formulated as a spectral transformation that maps a binary function between the input domain and the spectral domain. This transformation is recursively constructed through tensor products of a fundamental transformation matrix, referred to as the “kernel”. The kernel represents the elementary expansion operators that are selected at each node of the decomposition tree, as illustrated in Figure 2a–c. Effective implementation of this transformation can be achieved using constructive transform schemes represented by butterfly signal-flow graphs [26,27,46], which are analogous to the fast transform structures widely used in spectral analysis [47]. Figure 2d presents a butterfly structure for a 3-variable binary function. In this structure, ${\mathrm{P}}_{\mathrm{a}0}$, ${\mathrm{P}}_{\mathrm{b}0}$, ${\mathrm{P}}_{\mathrm{b}1}$, ${\mathrm{P}}_{\mathrm{c}0}$, ${\mathrm{P}}_{\mathrm{c}1}$, ${\mathrm{P}}_{\mathrm{c}2}$, and ${\mathrm{P}}_{\mathrm{c}3}$ denote polarity-selection variables associated with variables $x_1$, $x_2$, and $x_3$, where ${\mathrm{P}}_{\mathrm{a}0}$ corresponds to $x_1$, ${\mathrm{P}}_{\mathrm{b}0}$ and ${\mathrm{P}}_{\mathrm{b}1}$ correspond to $x_2$, and ${\mathrm{P}}_{\mathrm{c}0}$–${\mathrm{P}}_{\mathrm{c}3}$ correspond to $x_3$. These polarity variables determine the expansion configuration of each decomposition node, and their interactions with the corresponding coefficients generate the final AND–XOR representation through recursive logical operations.

Figure 2. (a) Butterfly diagrams: (a) a kernel for nD expansion; (b) a kernel for pD expansion; (c) a kernel for Sh expansion; and (d) PKRO butterfly diagram for an example with the minterm vector 0100101.

The PKRO transformation process is conceptually related to classical spectral transforms, such as the Walsh transform and the Fast Fourier Transform (FFT), in that different transformation configurations produce different spectral representations. In classical implementations, every combination of variable ordering and polarity assignment must be evaluated individually, resulting in sequential exploration of the complete PKRO search space. In contrast, the proposed quantum framework represents multiple PKRO configurations simultaneously through quantum superposition. Based on this principle, a unified hybrid binary–ternary quantum circuit is developed to implement butterfly transformations for all PKRO configurations within a single computational framework. This approach eliminates the need for explicit sequential evaluation of individual PKRO candidates and enables efficient exploration of the exponentially large PKRO search space. Consequently, our proposed framework identifies the globally optimal PKRO representation with the minimum number of product terms (spectral nonzero coefficients).

Classical optimization of Reed–Muller (RM) representations has been extensively studied using exact algorithms, heuristic methods, and evolutionary optimization techniques [8,35,48,49,50]. Conventional optimization of FPRM and KRO representations determines polarity configurations and expansion structures using exhaustive search, branch-and-bound, dynamic programming, or heuristic methods, depending on the problem size [8,16,17]. Due to its much larger search space, PKRO optimization has primarily relied on genetic algorithms and other metaheuristic techniques to optimize variable ordering and local expansion assignments [35,49]. In parallel, exact and heuristic ESOP minimization algorithms, together with logic synthesis methods based on BDDs, And-Inverter Graphs (AIGs), Boolean rewriting, and related optimization techniques have achieved effective optimization of XOR-intensive logic circuits [9,10,50]. However, these methods either target different logic representations or rely on heuristic search and, therefore, do not perform exact optimization over the complete PKRO search space.

Our proposed framework formulates PKRO minimization as a quantum search problem over the complete PKRO solution space. Compared with classical ESOP and PKRO optimization methods based on exact, heuristic, or evolutionary search [8,31,33,35], as well as the previously reported quantum ESOP minimization algorithm [36], our proposed method guarantees the globally optimal PKRO form with respect to the optimization criterion adopted in our work, namely the minimum number of nonzero spectral coefficients. Since ESOP is more general than PKRO, a heuristically optimized ESOP expression may still contain fewer product terms than an optimal PKRO representation. To the best of our knowledge, our work is the first quantum algorithm capable of obtaining exact minimum PKRO representations for all 3-variable binary functions, whereas the quantum ESOP method in [36] was demonstrated primarily for 2-variable functions.

For an n-variable binary function, considering both variable ordering and node-level expansion assignments produces R candidate PKRO representations (see (10)). The proposed multi-solution ternary Grover search explores this space using quantum amplitude amplification. Unlike classical exhaustive search, which evaluates candidates sequentially, the proposed framework achieves Grover’s quadratic reduction in search iterations while preserving exact optimization. Although current quantum hardware limits exact optimization to relatively small problem instances, the framework provides a hybrid quantum–classical approach with potential scalability as quantum hardware advances.

2.2. Multi-Solution Ternary Grover’s Algorithm for Quantum Machine Learning

Most variants of Grover’s algorithm are formulated for binary computational spaces using qubits, while ternary quantum search has been less explored. In this work, qutrits (three-level quantum systems) are employed because they naturally represent the three PKRO expansion types: pD, nD, and Sh. Each qutrit, therefore, encodes the expansion type (polarity) at one node of the PKRO decomposition tree. The Dirac notation of a qutrit state is given by (15):

$$|\Psi ⟩= \alpha |0⟩+\beta |1⟩+\mathsf{\gamma }|2⟩= \alpha \left[\begin{array}{c}1\\ 0\\ 0\end{array}\right]+\beta \left[\begin{array}{c}0\\ 1\\ 0\end{array}\right]+ \mathsf{\gamma }\left[\begin{array}{c}0\\ 0\\ 1\end{array}\right].$$

(15)

The $\alpha$, $\beta$, and $\gamma$ coefficients satisfy the normalization condition stated in (16):

$${\mid \alpha \mid }^2+\mid \beta {\mid }^2+\mid \gamma {\mid }^2=1.$$

(16)

The complex values $\alpha$, $\beta$, and $\gamma$ are probability amplitudes, and their squared magnitudes $\mid \alpha {\mid }^2$, $\mid \beta {\mid }^2$, and $\mid \gamma {\mid }^2$ represent the likelihood of observing each corresponding basis state upon measurement. For a search-based system composed of m qutrits, the overall state is typically a superposition of basis states formed from the fundamental qutrit vectors $|0⟩$, $|1⟩$, and $|2⟩$, resulting in a composite quantum state spanning the $3^m$-dimensional Hilbert space, where m ≥ 2. Since quantum computation produces probabilistic measurement outcomes, quantum search algorithms are designed to increase the probability of observing the desired solutions. Grover’s algorithm achieves this through amplitude amplification, increasing the probability of measuring target states and enabling efficient identification of optimal PKRO representations [15,16].

When the multi-solution ternary Grover’s algorithm is applied to PKRO forms of an n-variable binary function, the total number of candidate states for a specific PKRO expansion variable sequence (e.g., x₁ → x₂ → x₃) is $N=3^{(2^n-1)}$. The simulation in our research evaluates all n! permutations of expansion variable sequences separately. For each expansion variable sequence, the candidate states are encoded using $(2^n-1)$ qutrits. Among these N states, let M states satisfy a specified condition C, where C requires that the number of AND–XOR nonzero coefficients does not exceed a predefined threshold T.

For Grover’s algorithm, the binary–ternary oracle must be a unitary operator $O_f$ acting on a binary–ternary Hilbert space. Let the polarity assignment be encoded in the quantum register $\mid \mathrm{P}⟩=\mid {\mathrm{q}}_1,{\mathrm{q}}_2,\dots ,{\mathrm{q}}_{2^n-1}⟩,$ where each $\mid {\mathrm{q}}_i⟩\in \{\mid 0⟩,\mid 1⟩,\mid 2⟩\}$ represents one expansion choice at node $i$. Let $Q\left(\mathrm{P}\right)$ denote the number of AND–XOR nonzero coefficients for polarity assignment $\mid \mathrm{P}⟩$. This $O_f$ requires us to mark all polarity assignments whose cost $Q\left(\mathrm{P}\right)$ does not exceed the current threshold $T$. According to the phase kickback principle, the desired output of this oracle $O_f$ is expressed in (17) for the polarity assignment vector $\mid \mathrm{P}⟩$.

$$O_f\mid \mathrm{P}⟩=(-1{)}^{f\left(\mathrm{P}\right)}\mid \mathrm{P}⟩,f(\mathrm{P})=\{\begin{array}{cc}1,& Q\left(\mathrm{P}\right)\le T,\\ 0,& Q\left(\mathrm{P}\right)>T.\end{array}$$

(17)

The qutrit register $\mid \mathrm{P}⟩$ serves as the control variable for the ternary-controlled reversible gates to decide PKRO polarity assignments. After the butterfly-based PKRO transformation generates the AND–XOR spectral coefficients, a reversible comparator evaluates the threshold condition and stores the result in a binary flag qubit: $f\left(\mathrm{P}\right)=\{\begin{array}{cc}1,& Q\left(\mathrm{P}\right)\le T,\\ 0,& Q\left(\mathrm{P}\right)>T.\end{array}$. The phase inversion required by Grover’s oracle $O_f$ is not applied directly to the qutrit polarity register. Instead, the flag qubit is converted into a phase marker through phase kickback. By preparing an ancilla qubit in the state $\mid -⟩={\displaystyle \frac{\mid 0⟩-\mid 1⟩}{\sqrt{2}}}$ and applying a controlled-NOT operation from the flag qubit to the ancilla, the states satisfying f(P) = 1 acquire a negative phase. The qutrit polarity states $\mid \mathrm{P}⟩$ remain unchanged; only their amplitudes ${\alpha }_P$ are modified, i.e., ${\alpha }_{\mathrm{P}}\mid \mathrm{P}⟩\to -{\alpha }_{\mathrm{P}}\mid \mathrm{P}⟩.$ Thus, the computed value of f(P) is transferred from the ancilla flag qubit into the local phase, producing the required Boolean-decision oracle while preserving the polarity register. After phase marking, all ancilla registers are uncomputed (mirrored) by applying the inverse reversible computation, $O_f^{†}{O}_f=I,$ which restores ancilla registers to their initial states $\mid 0⟩$. This reversible binary–ternary oracle construction preserves quantum properties and satisfies the requirements of Grover’s amplitude amplification. The oracle $O_f$ outputs phase-marked target states (solutions) for candidate PKRO representations satisfying the optimization constraint and leaves non-satisfying states (nonsolution) unchanged.

For satisfying PKRO expansion polarity assignments, the binary–ternary oracle is stated in (18):

$$O_f({\displaystyle {\sum }_{\mathrm{P}}}{\alpha }_{\mathrm{P}}\mid \mathrm{P}⟩)={\sum }_{\mathrm{P}}{(-1)}^{f\left(\mathrm{P}\right)}{\alpha }_{\mathrm{P}}\mid \mathrm{P}⟩.$$

(18)

For a multi-solution Grover’s search algorithm including the diffusion operator D, the resulting binary–ternary oracle can also be expressed in (19) [51], and (20) states the diffusion operator D.

$$O_f=\mathrm{I}-2{\displaystyle \sum _{k=1}^M}\mid {\mathrm{P}}_k⟩⟨{\mathrm{P}}_k\mid ,$$

(19)

$$D=2|\mathrm{P}⟩⟨\mathrm{P}|-\mathrm{I},$$

(20)

where $⟨\mathrm{P}|$ is the Hermitian conjugate of $|\mathrm{P}⟩$, ${\left\{\mid {\mathrm{P}}_k⟩\right\}}_{k=1}^M$ denotes the set of target basis states satisfying the PKRO optimization constraint, and I represents the identity matrix. The summation term represents the projector onto the marked subspace, causing the amplitudes of all target states to be multiplied by −1 while leaving non-solution states unchanged. This operator form is mathematically equivalent to the phase oracle defined by the binary decision function f(P) and provides a convenient representation for the multi-solution ternary Grover framework proposed in our work.

As illustrated in Figure 3a–c, the operation of Grover’s algorithm can be interpreted geometrically as a rotation by an angle θ within a two-dimensional subspace spanned by the equal-superposition state $|\mathrm{P}⟩$ and the target state subspace represented by $|P_{\omega }⟩$. If we denote the orthogonal non-solution component as $|{\mathrm{P}}^{\prime }⟩$, then the superposition state $|\mathrm{P}⟩$ can be expressed in (21):

$$|\mathrm{P}⟩=\sqrt{{\displaystyle \frac{M}{N}}}|{\mathrm{P}}_{\mathsf{\omega }}⟩+\sqrt{{\displaystyle \frac{N-M}{N}}}|{\mathrm{P}}^{\prime }⟩.$$

(21)

Figure 3. Grover’s algorithm illustration: (a) amplitudes of the superposed input qutrit states $|\mathrm{P}⟩$; (b) inversion of the amplitudes of the selected target states by the oracle ($O_f|\mathrm{P}⟩$); and (c) inversion about the new mean performed by a Grover diffusion operator (D$O_f|\mathrm{P}⟩$). Note that (b,c) together constitute one Grover iteration (Grover loop).

Please observe that each Grover iteration rotates the quantum state vector toward the target solution subspace $|P_{\omega }⟩$ by an angle θ, thereby increasing the probability amplitude of the target solution states [36]. The rotation angle θ depends on the number of target solution states M and the total number of superimposed states N, as given in (22) [51].

$$\sin ({\displaystyle \frac{\mathsf{\theta }}{2}})=\sqrt{{\displaystyle \frac{M}{N}}}.$$

(22)

When ${\displaystyle \frac{M}{N}}$ is relatively small, the θ can be estimated in (23).

$$\mathsf{\theta }\approx 2\sqrt{{\displaystyle \frac{M}{N}}}.$$

(23)

As shown in Figure 3 and (23), each Grover iteration increases the amplitude of the target solution states by approximately $~2\sqrt{{\displaystyle \frac{M}{N}}}$. Consequently, repeated applications of Grover iterations progressively rotate the quantum state vector toward the target solution subspace. After r iterations, the state vector approaches an angle of $~{\displaystyle \frac{\pi }{2}}$ relative to its initial position, maximizing the probability of measuring a target solution state. The required number of iterations r is given by (24):

$$\mathrm{r}\approx {\displaystyle \frac{\pi }{4}}\sqrt{{\displaystyle \frac{N}{M}}}.$$

(24)

The parameter r denotes the number of Grover iterations for a fixed variable ordering and threshold T. Since an n-variable function has n! possible variable orderings, the search is repeated for each ordering. The computational advantage is based on the conventional Grover oracle, which reduces the oracle query complexity from O($N$) for exhaustive classical search to approximately O($\sqrt{{\displaystyle \frac{N}{M}}}$) in our proposed framework.

The main contribution of our work is the formulation of PKRO optimization as a multi-solution quantum search problem using a threshold-based oracle and a hybrid binary–ternary reversible architecture, rather than the development of a new amplitude amplification algorithm. Practical implementation on quantum hardware depends on circuit synthesis, oracle construction, qudit fidelity, and error correction, which will be investigated in our future work [52,53,54,55,56,57,58].

3. Materials and Methods

3.1. PKRO Processor Design for Quantum Oracle Construction

The three PKRO expansion expressions are canonical forms connected via linear transformations. The corresponding PKRO transformation matrix is constructed using tensor product operations, where each expansion is represented by a kernel matrix associated with a selected polarity, as given in (25)–(27):

$$M_{P_i}=\left[\begin{array}{cc}1& 0\\ 1& 1\end{array}\right],{TM}_{P_m}=\begin{array}{c}m\\ \otimes \\ i=1\end{array}{M}_{P_i},$$

(25)

$$M_{N_i}=\left[\begin{array}{cc}1& 1\\ 0& 1\end{array}\right],{TM}_{N_m}=\begin{array}{c}m\\ \otimes \\ i=1\end{array}{M}_{N_i},$$

(26)

$$M_{S_i}=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right],{TM}_{S_m}=\begin{array}{c}m\\ \otimes \\ i=1\end{array}{M}_{S_i},$$

(27)

where $\otimes$ denotes the tensor product; $M_{P_i}$, $M_{N_i}$ and $M_{S_i}$ represent the kernel matrices corresponding to pD, nD, and Sh expansions at the ith expansion node; and ${TM}_{P_m}, {TM}_{N_m},$ and ${TM}_{S_m}$ denote the resulting pD, nD, and Sh transformation matrices obtained after applying m expansions in parallel.

We use qutrits as the control units to encode the three PKRO expansion types, represented by polarity values 0, 1, and 2 (see Figure 4). The symbols above the gates indicate the activating value of the control qutrit $\mathrm{P}$. When $\mathrm{P}=1$, the first controlled-XOR gate is activated for nD expansion; when $\mathrm{P}=0$, the second controlled-XOR gate is activated for pD expansion; and when $\mathrm{P}=2$, neither gate is activated, corresponding to the Sh expansion. We refer to this hybrid ternary-controlled binary XOR operation as the binary–ternary Toffoli gate C₂C₃X, where C₂ denotes one binary control qubit, C₃ denotes one ternary control qutrit, and X denotes the target XOR operation. In future work, this gate will be generalized to ${\mathrm{C}}_2^n{\mathrm{C}}_3^m\mathrm{T}$, where n and m are the numbers of binary control qubits and ternary control qutrits, respectively, and T represents an arbitrary binary or ternary target operation. Table 1 summarizes C2C3X gate outputs for each value of the control qutrit P.

Figure 4. C₂C₃X gate using a qutrit as the control input $\mathrm{P},$ where $\mathrm{P}\in \{0,1,2\}$.

Table 1. C₂C₃X gate outputs $e_0$ and $e_1$ based on P control values (Inputs $m_0$ and $m_1$).

P	Type	${\mathit{e}}_{\mathbf{0}}$	${\mathit{e}}_{\mathbf{1}}$
0	pD	$m_0$	$m_0\oplus m_1$
1	nD	$m_0\oplus m_1$	$m_1$
2	Sh	$m_0$	$m_1$

A butterfly diagram can be constructed for any numbers of ternary polarity assignments; however, the primary challenge is determining the optimum polarity configuration that yields the minimum number of AND–XOR nonzero coefficients within a single reconfigurable butterfly structure. Figure 5 illustrates a 3-variable example of the proposed PKRO processor, derived from the butterfly flow diagrams in Figure 2a–c and the PKRO Toffoli control gates C₂C₃X shown in Figure 4.

Figure 5. Architecture of a 3-variable PKRO processor for AND–XOR expression minimization, where P_a0P_b0P_b1P_c0P_c1P_c2P_c3 are ternary control inputs, $m_0$–$m_7$ are binary minterm vector, and $e_0$–$e_7$ are binary AND-XOR spectrum coefficients.

The PKRO processor in Figure 5 is implemented as a hybrid ternary–binary quantum circuit, where the polarity variables P_a0, P_b0, P_b1, P_c0, P_c1, P_c2, and P_c3 are represented using ternary encoding, while the minterm vector $m_0$–$m_7$ and the AND–XOR coefficients $e_0$–$e_7$ are represented in binary form. This hybrid representation enables compact, flexible, and reconfigurable PKRO processor implementation. Please note that our proposed algorithm is quantum technology independent. The oracle is described using generalized ternary-controlled C₂C₃X gates as a high-level logical model. In a future physical implementation, each C₂C₃X gate may be decomposed into elementary operations supported by the target hardware, such as single-qutrit gates together with hybrid qutrit–qubit controlled interactions. Consequently, the physical quantum cost depends on the available gate library and hardware technology.

In this work, a PKRO-based quantum machine-learning simulator employing Grover’s algorithm is implemented to generate optimal PKRO polarity assignments for a given incompletely specified binary function. Based on Figure 4 and Table 1, the matrix representations $M_{{\mathrm{P}\mathrm{D}}_1}$, $M_{{\mathrm{N}\mathrm{D}}_1}$, and $M_{{\mathrm{S}\mathrm{H}}_1}$ are derived from (25)–(27) and presented in (28) for the pD, nD, and Sh expansions, respectively. These matrices serve as the fundamental building blocks of the PKRO processor, where the input vector $m_0{m}_1$ and the output coefficient vector $e_0{e}_1$ are represented in state-vector form: $\left[\begin{array}{c}1\\ \begin{array}{c}0\\ \begin{array}{c}0\\ 0\end{array}\end{array}\end{array}\right]$, $\left[\begin{array}{c}0\\ \begin{array}{c}1\\ \begin{array}{c}0\\ 0\end{array}\end{array}\end{array}\right]$, $\left[\begin{array}{c}0\\ \begin{array}{c}0\\ \begin{array}{c}1\\ 0\end{array}\end{array}\end{array}\right]$, and $\left[\begin{array}{c}0\\ \begin{array}{c}0\\ \begin{array}{c}0\\ 1\end{array}\end{array}\end{array}\right]$ corresponding to $|00⟩$, $|01⟩$, $|10⟩$ and $|11⟩$ states, respectively.

$$M_{{pD}_1}=\left[\begin{array}{cc}\begin{array}{cc}1& 0\\ 0& 1\end{array}& \begin{array}{cc}0& 0\\ 0& 0\end{array}\\ \begin{array}{cc}0& 0\\ 0& 0\end{array}& \begin{array}{cc}0& 1\\ 1& 0\end{array}\end{array}\right],M_{{nD}_1}=\left[\begin{array}{cc}\begin{array}{cc}1& 0\\ 0& 0\end{array}& \begin{array}{cc}0& 0\\ 0& 1\end{array}\\ \begin{array}{cc}0& 0\\ 0& 1\end{array}& \begin{array}{cc}1& 0\\ 0& 0\end{array}\end{array}\right],M_{{Sh}_1} =\left[\begin{array}{cc}\begin{array}{cc}1& 0\\ 0& 1\end{array}& \begin{array}{cc}0& 0\\ 0& 0\end{array}\\ \begin{array}{cc}0& 0\\ 0& 0\end{array}& \begin{array}{cc}1& 0\\ 0& 1\end{array}\end{array}\right]$$

(28)

For an $n$-variable function, the simulator recursively applies tensor product operations to construct the PKRO transformation matrix corresponding to a given polarity assignment according to the PKRO butterfly diagram and expansion tree structure. For each variable, the polarity assignment determines one of three expansion types (i.e., pD, nD, or Sh) at each node of the expansion tree. The corresponding kernel matrices are recursively combined through tensor product operations to form the complete PKRO transformation matrix. The resulting transformation matrix is then multiplied by the input minterm vector to obtain the corresponding AND–XOR spectral coefficients. By evaluating the number of nonzero spectral coefficients associated with different polarity assignments, the simulator constructs the complete PKRO ternary search space that would be explored by Grover’s algorithm. This search space forms the basis for identifying an optimal PKRO representation during the search process.

3.2. Cost Counter and Comparator for Quantum Oracle Construction

The cost counter and comparator module is designed and implemented in this research following the design methodology in [26]. The reversible Hamming-weight counter is implemented using hierarchical compressor-tree architecture. The first stage employs reversible 8:4 compressors to generate partial population counts, which are then combined by a reversible adder tree to obtain the final Hamming weight. This organization follows the general compressor-tree methodology widely used in multi-operand addition and reversible arithmetic [59,60]. Each 8:4 compressor computes the population count of eight PKRO coefficients. The 8:4 compressor is implemented using a tree of half adders (HA) and full adders (FA). The quantum implementation of the half adder and full adder is shown in Figure 6a,b. The 8-input population counter based on a tree of full adders and half adders is shown in Figure 6c [26]. Please note this counter design has two levels with the first level consisting of two full adders and one half-adder, which add two 3-bit values and one 2-bit value parallel that form three 2-bit numbers. The second level is an adder tree that compresses the 6-bit values from the first level into a 4-bit number, denoted as $Q={\mathrm{S}}_3{\mathrm{S}}_2{\mathrm{S}}_1{\mathrm{S}}_0$. Please note that, in Figure 6c, $\mathrm{S}{\mathrm{S}}_0-\mathrm{S}{\mathrm{S}}_2$ and $\mathrm{S}\mathrm{S}{\mathrm{S}}_1$ are intermediate sum outputs, and $\mathrm{C}{\mathrm{C}}_0-\mathrm{C}{\mathrm{C}}_2 , \mathrm{C}\mathrm{C}{\mathrm{C}}_1$, $\mathrm{C}\mathrm{C}{\mathrm{C}}_2$, and $\mathrm{C}\mathrm{C}{\mathrm{C}\mathrm{C}}_1$ are intermediate carry outputs.

Figure 6. Schematic diagram of (a) half adder (HA); (b) full adder (FA); and (c) 8:4 compressor.

When $n>3$, reversible 8:4 compressors first partially compute the population counts of groups of eight AND–XOR coefficients, and a reversible adder tree then combines these partial counts to obtain the total Hamming weight of the AND–XOR coefficient vector $\mathrm{Z}=(e_0,e_1,\dots ,e_{2^n-1}),$ which represents the total number of PKRO nonzero coefficients, as defined in (29),

$$H={\displaystyle \sum _{i=0}^{2^n-1}}{e}_i.$$

(29)

For the comparator, the binary function is designed to compare two unsigned 4-bit numbers: $Q={\mathrm{S}}_3{\mathrm{S}}_2{\mathrm{S}}_1{\mathrm{S}}_0$ and the threshold $T={\mathrm{T}}_3{\mathrm{T}}_2{\mathrm{T}}_1{\mathrm{T}}_0$. The comparison begins with the Most Significant Bit (MSB). When ${\mathrm{S}}_3$ and ${\mathrm{T}}_3$ differ, i.e., ${\mathrm{S}}_3\oplus {\mathrm{T}}_3=1$, the comparison result can be determined immediately: if ${\mathrm{T}}_3=1$, then $T>Q$; otherwise, $T<Q$. If ${\mathrm{S}}_3$ and ${\mathrm{T}}_3$ are equal $\left({\mathrm{S}}_3\oplus {\mathrm{T}}_3=0\right)$, then the comparison proceeds to ${\mathrm{S}}_2$. The same procedure continues sequentially until the Least Significant Bit (LSB) ${\mathrm{S}}_0$ is evaluated. The comparator condition $Q\le T$ is expressed in (30). This is a highly optimized hierarchical AND–XOR comparator form because each stage only activates if all higher bits are equal, redundant product terms are eliminated, and the structure scales naturally to an $n$-bit comparator.

$$C=\overline{{\mathrm{S}}_3}{\mathrm{T}}_3\oplus {\mathrm{E}}_3\overline{{\mathrm{S}}_2}{\mathrm{T}}_2\oplus {\mathrm{E}}_3{\mathrm{E}}_2\overline{{\mathrm{S}}_1}{\mathrm{T}}_1\oplus {\mathrm{E}}_3{\mathrm{E}}_2{\mathrm{E}}_1\overline{{\mathrm{S}}_0}{\mathrm{T}}_0\oplus {\mathrm{E}}_3{\mathrm{E}}_2{\mathrm{E}}_1{\mathrm{E}}_0,$$

(30)

where ${\mathrm{E}}_3=\overline{{\mathrm{S}}_3\oplus {\mathrm{T}}_3}$, ${\mathrm{E}}_2=\overline{{\mathrm{S}}_2\oplus {\mathrm{T}}_2}$, ${\mathrm{E}}_1=\overline{{\mathrm{S}}_1\oplus {\mathrm{T}}_1}$, and ${\mathrm{E}}_0=\overline{{\mathrm{S}}_0\oplus {\mathrm{T}}_0}.$ Please note that ${\mathrm{E}}_i=1$ means the two bits are equal where i $\in \left\{0,1,2,3\right\}$.

Figure 7 shows the reversible quantum circuit for the cost counter and comparator. The circuit is constructed by replacing each irreversible Boolean gate with its reversible counterpart. XOR operations are implemented using CNOT gates, AND operations using Toffoli gates, and multi-input binary functions are synthesized as reversible Toffoli networks. The counter accumulates the coefficient bits into $\lceil {\mathrm{l}\mathrm{o}\mathrm{g}}_2(2^n+1)\rceil =n+1$ bit registers that store the Hamming weight (i.e., the number of AND-XOR nonzero coefficients).

Figure 7. Three-variable PKRO quantum circuit for AND–XOR coefficient cost counter and comparator.

3.3. Quantum Oracle Circuit Architecture

Figure 8 illustrates the proposed binary–ternary oracle architecture for identifying the minimum PKRO representation of a 3-variable binary function using Grover’s algorithm. The oracle consists of four main blocks: the PKRO processor, cost counter and comparator, and their corresponding inverse circuits, which uncompute and restore all ancilla registers after evaluation. As shown in Figure 8 and Table 2, four registers are used in the oracle architecture. The PKRO oracle requires ancilla/work registers for PKRO evaluation, counting, comparison, and phase marking. The estimated ancilla and working register requirements in Table 2 depend on the specific circuit implementation.

Figure 8. Our proposed binary–ternary oracle architecture that searches for the minimum 3-variable binary PKRO form.

Table 2. Binary and ternary registers used in the binary–ternary oracle architecture.

Register	Symbol	Dimension
Ternary polarity register	P	$2^n-1$ qutrits
Binary minterm register	M	$2^n$ qubits
PKRO coefficient register	Z	$2^n$ qubits
Ancilla/work register	A	≈($2^n+\mathrm{n}+2)$ qubits

As shown in Figure 8, the PKRO processor takes the minterm vector $m_0$–$m_7$ and a polarity vector for P_a0P_b0P_b1P_c0P_c1P_c2P_c3 as inputs and produces the corresponding AND–XOR spectral coefficients for PKRO forms. Before entering the PKRO processor, the polarity qutrit register is transformed into an equal superposition of all polarity assignments using ternary superposition $S_3$ gates. This is equivalent to using Hadamard gates in binary quantum computing domain. $S_3$ gate is a special case of Muthukrishnan–Stroud (MS) gate [51] that prepares ternary superposition, as given in (31).

$$S_3=\left[\begin{array}{ccc}{\displaystyle \frac{1}{\sqrt{3}}}& {\displaystyle \frac{1}{\sqrt{6}}}& {\displaystyle \frac{1}{\sqrt{2}}}\\ {\displaystyle \frac{1}{\sqrt{3}}}& {\displaystyle \frac{-2}{\sqrt{6}}}& 0\\ {\displaystyle \frac{1}{\sqrt{3}}}& {\displaystyle \frac{1}{\sqrt{6}}}& {\displaystyle \frac{-1}{\sqrt{2}}}\end{array}\right].$$

(31)

Accordingly, the oracle acts on the composite Hilbert space given in (32):

$$\mathcal{H}={\mathcal{H}}_P\otimes {\mathcal{H}}_{\mathrm{M}}\otimes {\mathcal{H}}_{\mathrm{Z}}\otimes {\mathcal{H}}_{\mathrm{A}},$$

(32)

where ${\mathcal{H}}_{\mathrm{P}},{\mathcal{H}}_{\mathrm{M}},{\mathcal{H}}_{\mathrm{Z}}$, and ${\mathcal{H}}_{\mathrm{A}}$ are Hilbert space for polarity register, minterm register, AND-XOR coefficient register, and ancilla/work register, respectively. Their dimensions are given by $\dim \left({\mathcal{H}}_{\mathrm{P}}\right)=3^{2^n-1},\dim \left({\mathcal{H}}_{\mathrm{M}}\right)=2^{2^n},$ $\dim \left({\mathcal{H}}_{\mathrm{Z}}\right)=2^{2^n},$ and $\dim \left({\mathcal{H}}_{\mathrm{A}}\right)=2^{2^n+\mathrm{n}+2}$. The polarity register participates in Grover’s algorithm by identifying the optimal ternary polarity assignment $\mathrm{P}$ for the minimum PKRO form. Once the optimal polarity assignment is obtained, a classical computer computes the corresponding PKRO spectral coefficients and directly synthesizes the optimal PKRO logic equation, which is then converted to a classical circuit or reversible quantum circuit. Therefore, our proposed hybrid quantum–classical framework uses Grover’s algorithm to optimize the PKRO representation, while the resulting logic circuit serves as an interpretable binary classifier for logic-based machine learning. Accordingly, our entire method converts “don’t-care” conditions (–) to “care” (0 or 1) conditions, as standard logic-based classifiers. The PKRO circuit is a completely specified function-based hardware that can be synthesized into any technology.

After the phase inversion has been applied to the target polarity states $|{\mathrm{P}}_{\mathsf{\omega }}⟩$ shown in Figure 3, all reversible computations are uncomputed by executing parts of the oracle circuit in reverse order. Specifically, the comparator, Hamming-weight counter, and PKRO processor are each inversed to restore the intermediate computation states. As a result, all ancilla qubits return to their initial $\mid 0⟩$ state, all intermediate spectral coefficients are lost, and only the amplitudes applied to $|{\mathrm{P}}_{\mathsf{\omega }}⟩$ (solutions) remain. This uncomputation is required before applying the Grover diffusion operator, by preserving quantum properties across successive Grover iterations. The inverse circuits ensure that the oracle is a valid unitary transformation by restoring all ancilla registers while leaving the desired decision information encoded for the ternary polarity register P.

To the best of our knowledge, contemporary Grover oracle designs are based primarily on either binary quantum systems (qubits) or d-valued quantum systems (qudits, d ≥ 3) [51,61]. Our work introduces the first hybrid binary–ternary PKRO oracle architecture, in which qutrit registers encode PKRO polarities, while binary registers perform reversible spectral coefficient generation, counting, and cost comparison.

3.4. Grover Diffusion Operator Design

The quantum gate-level representation of diffusion operator, which operates on $(2^n-1)$ qutrits to manage PKRO forms of an $n$-variable function, is expressed in (33) [51,62,63,64,65].

$$\mathrm{D}=S_3^{\otimes {(2}^n-1)}{\mathrm{Z}}_{3,\mid 0⟩}{\left(S_3^{†}\right)}^{\otimes {(2}^n-1)},$$

(33)

where n ≥ 2, $S_3^{\otimes {(2}^n-1)}$ represents the tensor product of the single-qutrit $S_3$ gate applied ($2^n-1$) times, $S_3^{†}$ denotes the conjugate transpose of $S_3$, and ${\mathrm{Z}}_{3,\mid 0⟩}$ represents multi-controlled ternary ${\mathrm{Z}}_3$ gate to invert the phase around $|0⟩.$ ${\mathrm{Z}}_{3,\mid 0⟩}$ is expressed in (34). For simplicity, zero-valued matrix elements for ${\mathrm{Z}}_{3,\mid 0⟩}$ are omitted. Please observe that the Z gate is a binary phase gate, while the ${\mathrm{Z}}_3$ gate is a ternary phase gate.

$${\mathrm{Z}}_{3,\mid 0⟩}=\left[\begin{array}{cc}1& \\ & \begin{array}{ccc}-1& & \\ & -1& \\ & & \begin{array}{cc}\ddots & \\ & -1\end{array}\end{array}\end{array}\right].$$

(34)

Please note that ${\mathrm{Z}}_{3,\mid 0⟩}$ is a $3^{\left(2^n\right|1)}\times 3^{\left(2^n\right|1)}$ matrix corresponding to $\left(2^n\right|1)$ qutrits for PKRO expansions of an $n$-variable binary function. The direct implementation of the ${\mathrm{Z}}_{3,\mid 0⟩}$ gate requires sign inversion across multiple states due to multiple −1 entries in the matrix representation shown in (34). To reduce circuit complexity, the multi-controlled ${\mathrm{Z}}_3$ gate design is optimized by implementing $-{\mathrm{Z}}_{3,\mid 0⟩}$, as defined in (35). The additional global negative sign does not affect quantum measurement outcomes as measurements depend on probabilities derived from squared magnitudes of probability amplitudes rather than their signs. The $-{\mathrm{Z}}_{3,\mid 0⟩}$ gate only flips the phase of the $|0⟩$ state, thereby simplifying circuit implementation, reducing the number of required controlled operations, and improving overall computational efficiency and scalability.

$${-\mathrm{Z}}_{3,\mid 0⟩}=\left[\begin{array}{cc}-1& \\ & \begin{array}{ccc}1& & \\ & 1& \\ & & \begin{array}{cc}\ddots & \\ & 1\end{array}\end{array}\end{array}\right].$$

(35)

The three types of ternary ${\mathrm{Z}}_3$ gates shown in Figure 9 and used in our proposed multi-controlled ${\mathrm{Z}}_3$ gate circuit design are given by (36).

$${\mathrm{Z}}_{3,+1}=+1=\left[\begin{array}{ccc}0& 0& 1\\ 1& 0& 0\\ 0& 1& 0\end{array}\right], Z_{3,+2}=+2=\left[\begin{array}{ccc}0& 1& 0\\ 0& 0& 1\\ 1& 0& 0\end{array}\right], Z_{3,|2⟩}=\left[\begin{array}{ccc}1& 0& 0\\ 0& 1& 0\\ 0& 0& -1\end{array}\right],$$

(36)

where the ${\mathrm{Z}}_{3,+1}$ gate shifts basis states by $+1$, the ${\mathrm{Z}}_{3,+2}$ gate shifts basis states by $+2$, and the $Z_{3,|2⟩}$ gate applies a phase inversion to $|2⟩$ [51]. The ${\mathrm{Z}}_{3,+1}$ and ${\mathrm{Z}}_{3,+2}$ are well-known shift ternary successor (increment, −2) and predecessor (decrement, −1) gates, respectively, from the literature, which are used in many different notations. Our proposed multi-controlled ${\mathrm{Z}}_3$ gate quantum circuit is shown in Figure 9. First, the circuit applies the $Z_{3,+2}$ gate to each qutrit, transforming $|0⟩$ to $|2⟩$. Consequently, the target phase inversion is applied to $|22\cdots 2⟩$. Next, the $Z_{3,|2⟩}$ gate is used to invert the phase of $|22\cdots 2⟩$. Finally, the ${\mathrm{Z}}_{3,+1}$ gate is applied to each qutrit, shifting $|22\cdots 2⟩$ back to $|00\cdots 0⟩$ before the next Grover iteration or the final measurement. Please note that the phase inversion is implemented in $\mid 2⟩$, following the ternary phase-gate convention in [51], where the phase gate applies a −1 phase specifically to $\mid 2⟩$. Our proposed multi-controlled ternary phase gate, therefore, naturally targets $\mid 2⟩$. The $Z_{3,+2}$ and ${\mathrm{Z}}_{3,+1}$ cyclic shifts map the desired $\mid 0⟩$ state to and from $\mid 2⟩$, allowing the same phase-inversion construction to be used. In this work, $(2^n-3)$ ancilla/work registers are required for $Z_{3,|0⟩}$ implementation.

Figure 9. Multi-controlled ${\mathrm{Z}}_{3 }$ gate quantum circuit design for ternary Grover diffusion operator.

To provide the required input for Grover’s algorithm, an initial cost threshold is first determined. Random PKRO polarities are assigned to all decomposition nodes in Figure 1, and the resulting number of AND-XOR nonzero coefficients, denoted by $Q$, is used as the initial threshold, $T=Q$. Because this random polarity assignment produces a valid PKRO representation of the binary function, $Q$ provides a feasible upper bound on the minimum cost. The threshold is then reduced to $T=Q-1$, and Grover’s algorithm is executed to search for a solution satisfying $Q\le T$. If a valid solution is found, the threshold is reduced by one and the search is repeated. This process continues until no solution satisfies the current threshold, indicating that the previous threshold is the minimum PKRO cost. An adaptive threshold initialization based on measurement histograms is also possible. Similar to histogram analysis in Qiskit [66], the measured probability distribution can also identify promising threshold values, which are then verified using the PKRO cost function. In this work, the random-polarity initialization method is adopted because of its simplicity and compatibility with the proposed quantum circuit implementation.

Our simulation flowchart for determining the minimum-cost PKRO form is shown in Figure 10. The flowchart begins with search-space initialization, threshold selection, and oracle construction, followed by iterative Grover’s algorithm consisting of repeated oracle and diffusion operations. After the required number of Grover iterations, PKRO ternary polarity register P is measured. The simulation is repeated for n! variable expansion orderings to explore entire PKRO search space to get the exact minimum-cost PKRO form.

Figure 10. Our simulation software flowchart of the multi-solution ternary Grover’s algorithm.

The schematic of our proposed Grover’s algorithm for fixed variable expansion ordering is illustrated in Figure 11. The circuit begins with a sequence of S₃ gates that prepares the ternary polarity register in an equal superposition of all possible ternary polarity assignments. Repeated Grover iterations amplify the amplitudes of polarity assignments satisfying the minimization criterion. After the required number of iterations, the ternary polarity register is measured, collapsing the superposition to a single ternary basis state and yielding a candidate minimum-cost PKRO polarity assignment.

Figure 11. Our proposed schematic of multi-solution ternary Grover’s algorithm.

3.5. Post-Processing and Post-Selection to Increase Grover’s Algorithm Success Probability

Several studies have proposed post-processing and post-selection techniques to improve the success probability of Grover’s algorithm by combining repeated quantum measurements with classical analysis [67]. In our work, Grover’s algorithm is executed multiple times, and the resulting candidate solutions are evaluated on a standard classical computer. Let $Q_k$ denote the cost of the PKRO polarity assignment ${\mathrm{P}}_k$ obtained from the kth execution of Grover’s algorithm. The minimum cost among all k executions, denoted by $Q_{\mathrm{m}\mathrm{i}\mathrm{n}}$, is defined by (37):

$$Q_{\mathrm{m}\mathrm{i}\mathrm{n}}=\min \left(Q_1,Q_2,\dots ,Q_k\right).$$

(37)

The minimum-cost polarity assignment, ${\mathrm{P}}_{\mathrm{m}\mathrm{i}\mathrm{n}}$, is selected from the candidate set $\left({\mathrm{P}}_1,{\mathrm{P}}_2,\dots ,{\mathrm{P}}_k\right)$ corresponding to $Q_{\mathrm{m}\mathrm{i}\mathrm{n}}$. The proposed post-processing is entirely classical. Each execution of Grover’s algorithm ends with a measurement that produces a classical polarity vector. The candidates measured from multiple independent executions are then evaluated classically, and the one with the minimum PKRO cost is selected. Our proposed post-processing procedure is illustrated in Figure 12.

Figure 12. Illustration of our proposed post-processing and post-selection method to increase the success probability of Grover’s algorithm by selecting the minimum-cost solution $P_{\mathrm{m}\mathrm{i}\mathrm{n}}$ from multiple executions of Grover’s algorithm.

Let $p_{\mathrm{success}}$ denote the probability of obtaining a target solution in a single independent execution of Grover’s algorithm. Assuming that each execution is statistically independent and identically distributed, the probability of failure in one execution is $1-p_{\mathrm{success}}$. Therefore, the probability that all $k$ independent executions fail to produce a correct solution is ${\left(1-p_{\mathrm{success}}\right)}^k$. Consequently, the overall success probability $p_{\mathrm{total}}$, defined as the probability of obtaining at least one successful outcome in $k$ executions, is given by (38):

$$p_{\mathrm{total}}=1-(1-p_{\mathrm{success}}{)}^k.$$

(38)

Repeated executions increase the probability of obtaining the correct solution. In our work, each execution uses the same threshold schedule and stopping criterion, with differences arising only from the probabilistic measurement outcomes. A possible improvement is to use the best solution from one execution to initialize the threshold for subsequent executions, which can reduce the total number of Grover iterations. The adaptive threshold updating across k executions is our promising future optimization approach.

Since the number of target solutions depends on the threshold T, it can be expressed as $M=M\left(T\right)$. As the threshold changes, the number of target solutions changes accordingly. In our simulation, the number of target solutions $M$ corresponding to the current threshold is computed classically for the PKRO search space. In a practical quantum implementation, $M$ can be estimated using quantum counting or adaptive Grover’s algorithm [68,69]. For a desired overall success probability $p_{\mathrm{target}}$, the required number of repeated Grover’s algorithm executions is denoted by k. The minimum k is given by (39), where $\lceil .\rceil$ denotes the ceiling operation, and $p_{success}{=p}_{success}\left(M\left(T\right),N\right)$ is the success probability of a single Grover execution for a search space of N with M(T) target solutions:

$$k=\lceil {\displaystyle \frac{\mathrm{l}\mathrm{o}\mathrm{g}(1-p_{\mathrm{target}})}{\mathrm{l}\mathrm{o}\mathrm{g}(1-p_{success}(M\left(T\right),N\left)\right)}}\rceil .$$

(39)

Overall, repeated executions of Grover’s algorithm produce a set of candidate polarity assignments and their associated cost values. These candidates are subsequently evaluated during a classical post-processing stage, and the polarity assignment corresponding to the minimum cost is selected through post-selection as the final logic-optimization and machine-learning solution. The post-selection is entirely classical computation, operating on measurement outcomes after each independent Grover’s algorithm execution. By aggregating the outcomes of multiple independent executions, the overall success probability is increased to reach a specified target probability $p_{\mathrm{target}}$.

3.6. Quantum Computation Cost Analysis for the Proposed System Design

The total quantum computation cost equals the per-iteration oracle cost multiplied by the total number of Grover iterations. This cost is compared with the computation cost of classical exhaustive search, where the oracle cost is multiplied by the total number of classical function evaluations. To estimate the quantum computation cost, we first determine the per-iteration oracle gate count, which is the total number of reversible quantum operations required by one Grover oracle execution. The circuit depth, which represents the critical execution path, is evaluated separately. Following the standard practice in quantum algorithm evaluation, our work reports quantum computation cost, gate count and circuit depth separately.

Theorem 2.

The per-iteration oracle gate count of a reversible PKRO is given in (40):

$$\begin{gathered} G_{oracle}=G_{PKRO processor}+G_{counter}+G_{compare}+G_{phase mark }+G_{uncompute} \\ =2\left(G_{PKRO processor}+G_{counter}+G_{compare}\right)+G_{phase mark}, \end{gathered}$$

(40)

where $G_{\mathit{oracle}}$ denotes the total gate count of the Grover oracle, $G_{PKRO processor}$ is the gate count of computing the PKRO spectral coefficients using the reversible butterfly network, $and$ $G_{\mathit{counter}}$ denotes the gate count of the reversible circuit that counts the number of PKRO nonzero coefficients; $G_{\mathit{compare}}$ is the gate count of the reversible comparator that checks whether the coefficient count satisfies the threshold criterion; $G_{phase mark}$ represents the gate count of the phase-marking operation that marks candidate solutions satisfying the oracle condition; and $G_{\mathit{uncompute}}$ is the gate count of reversing the PKRO processor, counter, and comparator to restore all ancillae to their initial |$0⟩$ states.

Likewise, the oracle circuit depth is expressed in (41):

$$\begin{gathered} D_{oracle}=D_{PKRO processor}+D_{counter}+D_{compare}+D_{phase mark}+D_{uncompute} \\ =2(D_{PKRO processor}+D_{counter}+D_{compare})+D_{phase mark}. \end{gathered}$$

(41)

where each $D_i$ denotes the critical-path depth after maximal parallelization for each key component. They follow the same definition of each critical component from (40).

Proof of Theorem 2.

The reversible PKRO oracle consists of five stages: (i) the butterfly-based PKRO processor, (ii) the Hamming-weight counter, (iii) the threshold comparator, (iv) the phase-marking operation, and (v) the inverse computation (uncomputation).

• PKRO processor:

The butterfly processor computes all $2^n$ PKRO spectral coefficients through $n$ recursive expansion stages. Assuming each butterfly coefficient update is implemented by reversible Toffoli ternary control and binary input gate C₂C₃X, each stage processes all $2^n$ coefficients once. Therefore, $G_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O}\mathrm{p}\mathrm{r}\mathrm{o}\mathrm{c}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{o}\mathrm{r}}=O\left(n{2}^n\right)$ where the Big-$O$ notation $O\left(.\right)$ ignores constant factors and lower-order terms, focusing only on the dominant term. $O\left(n{2}^n\right)$ describes the asymptotic upper bound on the growth rate of the gate counts as the input size increases.

Since all butterflies within the same stage operate on independent data, they can be executed concurrently. Consequently, only the $n$ sequential stages determine the critical path, giving $D_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O}\mathrm{p}\mathrm{r}\mathrm{o}\mathrm{c}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{o}\mathrm{r}}=O\left(n\right).$

2.

Hamming-weight counter:

The counter scans the $2^n$-bit coefficient vector once to compute the number of nonzero coefficients. Hence, $G_{\mathrm{c}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}\mathrm{e}\mathrm{r}}=O\left(2^n\right).$

Using a balanced reversible adder tree, the additions are performed in parallel, resulting in $D_{\mathrm{c}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}\mathrm{e}\mathrm{r}}=O\left(n\right).$

3.

Threshold comparator:

The reversible comparator evaluates whether the computed Hamming weight satisfies $Q\le T$. Since the counter output contains $n+1$ bits, $G_{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{e}}=O\left(n\right),$ and $D_{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{e}}=O\left(n\right).$

4.

Phase marking:

After comparison, a controlled phase gate marks the valid target solutions. This requires constant gate cost and constant depth, $G_{\mathrm{p}\mathrm{h}\mathrm{a}\mathrm{s}\mathrm{e} \mathrm{m}\mathrm{a}\mathrm{r}\mathrm{k}}=O\left(1\right),D_{\mathrm{p}\mathrm{h}\mathrm{a}\mathrm{s}\mathrm{e} \mathrm{m}\mathrm{a}\mathrm{r}\mathrm{k}}=O\left(1\right).$

5.

Uncomputation:

To restore all ancillae to their initial |$0⟩$ states, the oracle applies its inverse circuit $U^{†}$. Since the inverse executes the butterfly processor, counter, and comparator in reverse order, $G_{\mathrm{u}\mathrm{n}\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{u}\mathrm{t}\mathrm{e}}=G_{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{e}}+G_{\mathrm{c}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}\mathrm{e}\mathrm{r}}+G_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O} \mathrm{p}\mathrm{r}\mathrm{o}\mathrm{c}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{o}\mathrm{r}},$ and $D_{\mathrm{u}\mathrm{n}\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{u}\mathrm{t}\mathrm{e}}=D_{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{e}}+D_{\mathrm{c}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}\mathrm{e}\mathrm{r}}+D_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O} \mathrm{p}\mathrm{r}\mathrm{o}\mathrm{c}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{o}\mathrm{r}}$.

Substituting these expressions into (40) and (41) yields

$$G_{\mathrm{o}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{l}\mathrm{e}}=2(G_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O} \mathrm{p}\mathrm{r}\mathrm{o}\mathrm{c}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{o}\mathrm{r}}+G_{\mathrm{c}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}\mathrm{e}\mathrm{r}}+G_{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{e}})+G_{\mathrm{p}\mathrm{h}\mathrm{a}\mathrm{s}\mathrm{e} \mathrm{m}\mathrm{a}\mathrm{r}\mathrm{k}},$$

and

$$D_{\mathrm{o}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{l}\mathrm{e}}=2(D_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O} \mathrm{p}\mathrm{r}\mathrm{o}\mathrm{c}\mathrm{e}\mathrm{s}\mathrm{s}\mathrm{o}\mathrm{r}}+D_{\mathrm{c}\mathrm{o}\mathrm{u}\mathrm{n}\mathrm{t}\mathrm{e}\mathrm{r}}+D_{\mathrm{c}\mathrm{o}\mathrm{m}\mathrm{p}\mathrm{a}\mathrm{r}\mathrm{e}})+D_{\mathrm{p}\mathrm{h}\mathrm{a}\mathrm{s}\mathrm{e} \mathrm{m}\mathrm{a}\mathrm{r}\mathrm{k}}$$

□

After applying Theorem 2 and substituting each item in (40) with their $\mathit{O}(.)$ values, we can get the following (42) because $O\left(n{2}^n\right)$ dominates the remaining terms:

$$\begin{array}{cc}{G}_{\mathrm{o}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{l}\mathrm{e}}& =2\left(O\left(n{2}^n\right)+O\left(2^n\right)+O\left(n\right)\right)+O\left(1\right)=O\left(n{2}^n\right).\\ & \end{array}$$

(42)

Similarly, we get the $D_{\mathrm{o}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{l}\mathrm{e}}$ stated in (43):

$$D_{\mathrm{o}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{l}\mathrm{e}}=2\left(O\left(n\right)+O\left(n\right)+O\left(n\right)\right)+O\left(1\right)=O\left(n\right).$$

(43)

Because qubit and qutrit systems have different computational dimensions and native gate libraries, their quantum computation costs cannot be compared directly without a hardware-specific gate decomposition. Therefore, this work reports computation costs separately for binary and ternary logical operations. In the proposed circuit model, the binary–ternary Toffoli gate C₂C₃X used in the butterfly network is treated as a high-level elementary operation. When implemented using native qubit and qutrit gates, C₂C₃X must be decomposed into hardware-supported operations, making its cost technology dependent. For illustrative cost estimation, we assume that one C₂C₃X gate is equivalent to approximately 5–6 elementary qubit gates and 5–10 elementary qutrit gates, consistent with reported decompositions of multi-controlled and ternary quantum gates [65,70,71,72,73]. The exact cost depends on the target hardware and native gate set. Resource overheads associated with qubit–qutrit interactions are not considered in this work and will be investigated in our future research.

The quantum gate libraries and their cost estimates are summarized in Table 3. Ternary gates use a native qutrit gate library, whereas binary gates use the standard qubit gate library.

Table 3. Quantum Gate Library used in PKRO oracle and Grover diffusion operator ($\lfloor .\rfloor$ denotes the floor function).

Gate Type	Gate Name	Ternary Quantum Cost Estimate	Binary Quantum Cost Estimate
Ternary Gates	C2C3X	≈5–10	≈5–6
	Superposition S3	1	0
	Phase $Z_3$	1	0
	Shift $Z_{3,+1},Z_{3,+2}$	1	0
	Multi-controlled $(m \mathrm{controls}){ Z}_3$	$\approx 12\lfloor {\displaystyle \frac{m}{3}}\rfloor +4(m \mathrm{mod}3)$	0
Binary Gates	NOT	0	1
	CNOT	0	1
	Toffoli	0	≈5
	Phase Z	0	1
	Hadamard	0	≈3

Table 4 lists quantum binary and ternary gate count for n-variable PKRO oracle and Grover diffusion operator. These gate counts are provided as reference values to indicate how the number of elementary binary and ternary gates varies with the number of variables. The actual quantum gate count requirements and physical implementation costs will depend on the specific circuit decomposition, hardware architecture, gate set, and optimization techniques used for implementation [72]. Therefore, the gate counts in Table 4 should be regarded as analytical estimates rather than definitive physical resource costs.

Table 4. Quantum binary and ternary gate count for PKRO oracle and Grover diffusion operator.

Component	Gate Type	Gate Name	Gate Count
PKRO Process	Binary–Ternary	C2C3X	$n{2}^n$
Counter	Binary	Toffoli	$11\times 2^{n-3}$
	Binary	CNOT	$11\times 2^{n-3}$
Comparator	Binary	Toffoli	${(\mathrm{n}+1)}^2$
		CNOT	$n+1$
Diffusion Operator	Ternary	Shift $Z_{3,+1},Z_{3,+2}$	$2(2^n$ −1)
	Ternary	Multi-controlled $Z_3$	1
	Ternary	Superposition S3	$2(2^n$ −1)

The quantum gate count of the Grover diffusion operator is estimated as $O\left(2^n\right)$, based the gate count in Table 4. From (42), the PKRO oracle has a quantum gate count estimation of $O\left(n{2}^n\right)$, which grows faster with the number of input variables compared with the diffusion operator. Consequently, the oracle dominates the overall quantum gate count in Grover’s algorithm circuit design. Therefore, following the standard resource analysis of Grover’s algorithm [74], only the oracle quantum computation cost is reported in this research. If $L_j$ threshold values are evaluated during PKRO minimization for a specific input minterm vector under the jth variable expansion ordering, C₂C₃X gate quantum computation cost estimation is denoted as $C_{\mathrm{CCX}}$, then its oracle quantum computation cost ${QC}_{\mathrm{oracle}\_\mathrm{one}}$ is given by (44), derived from (42):

$${QC}_{\mathrm{oracle}\_\mathrm{one} }\approx C_{\mathrm{CCX} }n{2}^n{\displaystyle {\sum }_{i=1}^{L_j}}\sqrt{{\displaystyle \frac{N}{M_i}}}.$$

(44)

Since an n-variable binary function has n! possible variable expansion orderings and Grover’s algorithm is repeated k times for post-processing and post-selection, the total quantum computation cost ${QC}_{\mathrm{total}}$ is given by (45). Please note, O(k) classical post-processing and post-selection computation cost is not included in (45):

$${QC}_{\mathrm{total}}\approx C_{\mathrm{CCX} }n{2}^{n}k{\displaystyle \sum _{\mathrm{j}=1}^{n!}}\left({\displaystyle \sum _{i=1}^{L_j}}\sqrt{{\displaystyle \frac{3^{2^n-1}}{M_i}}}\right).$$

(45)

(45) represents the estimated total computation cost of our proposed hybrid quantum–classical optimization framework. In our experimental simulation, $M$ is determined exactly by classical evaluation of the PKRO search space and used to set the Grover iteration count. For $M >1$, (44) and (45) quantify the quantum search cost conditional on known $M$, excluding this classical preprocessing cost. In contrast, the conservative assumption $M =1$ can be used to allow (44) and (45) to be evaluated without knowing the exact $M$. For a fairer quantum–classical comparison, we evaluate both the exact $M$ and conservative $M =1$ cases to determine the iteration count, although $M =1 \mathrm{c}\mathrm{a}\mathrm{s}\mathrm{e}$ generally requires more Grover iterations than using the exact $M$. Under the assumption of M = 1, the oracle needs to be modified to consistently amplify the same target solution state in each Grover iteration (e.g., by always amplifying the target solution with the maximum index of the minterm vectors). This $M =1$ assumption also allows the search to proceed when $M =0$; if no feasible solution is observed after repeated Grover executions, the likelihood that $T$ is infeasible increases with the number of Grover executions. Conversely, observing a feasible solution establishes that $T$ is feasible. Thus, repeated Grover executions can identify the minimum feasible threshold with high confidence. Our future work will investigate quantum counting and adaptive Grover strategies for handling unknown $M$ and incorporate their additional oracle-query costs into a more comprehensive framework resource comparison.

The exhaustive classical search evaluates all N candidate PKRO representations for each of the n! possible variable orderings. Assuming the same PKRO evaluation circuit is used, its computation cost estimation $C_{\mathrm{classical}\mathrm{total}}$ is given by (46).

$$C_{\mathrm{classical}\mathrm{total}}\approx n{2}^n{C}_{\mathrm{CCX} }n!N=n{2}^n{C}_{\mathrm{CCX} }n!3^{2^n-1}.$$

(46)

Grover’s algorithm reduces the search query complexity from $O\left(N\right)$ to $O\left(\sqrt{{\displaystyle \frac{N}{M}}}\right)$. Note that Grover’s algorithm reduces the exponent by taking a square root $\sqrt{3^{2^n-1}}=3^{(2^n-1)/2}$ that is still double exponential. Therefore, Grover’s algorithm does not change the asymptotic class of the search space. The only thing changed is the number of Grover iterations $O\left(\sqrt{{\displaystyle \frac{N}{M}}}\right)$ relative to the number of classical exhaustive search evaluations $O\left(N\right).$

The primary objective of this work is to develop a quantum search framework for exact PKRO optimization. Accordingly, the evaluation focuses on (i) the improvement of PKRO over KRO and FPRM representations and (ii) the reduction in Grover iterations achieved by the proposed multi-solution search strategy. Classical exhaustive search (46) serves as the optimal baseline for verifying the correctness of the proposed framework. Although the proposed framework guarantees globally optimal PKRO solutions, its search space still grows rapidly with the number of variables $n!3^{\left(2^n\right|1)}$. Classical heuristic ESOP and Reed–Muller optimization methods [30,31,32,33,34,35] improve scalability but generally do not guarantee global optimality, while the quantum ESOP optimization method in [36] was demonstrated primarily for 2-variable functions. By exploring the complete PKRO search space, our proposed framework preserves exact optimality while achieving Grover’s quadratic reduction in oracle queries compared with classical exhaustive search.

3.7. Software-Simulation Validation and Robotic Demonstration

Logic-based machine learning represents predictive models using explicit logical rules rather than numerical parameters, enabling compact and interpretable classifiers suitable for hardware implementation. Classical approaches include ESOP minimization for machine learning and knowledge discovery [75], as well as rule-learning systems such as the Attributional Calculus (AQ) algorithm, which constructs discriminative rules from training examples while optimizing criteria such as rule complexity and classification accuracy [76,77]. The CN2 algorithm is another well-known classical rule-induction method for learning classification rules from data [3]. In parallel, classical logic synthesis and circuit design have employed heuristic optimization, functional decomposition, and evolutionary synthesis to optimize logic implementations [78,79]. However, these classical approaches rely on heuristic search and do not provide quantum search over the complete PKRO representation space.

In our proposed framework, logic-based quantum machine learning is formulated as an exact PKRO minimization problem for incompletely specified binary data. As a subcategory of ESOP representations, PKRO provides greater expansion flexibility, while the proposed hybrid quantum–classical Grover-based framework enables exact minimum-cost synthesis through quantum search rather than relying solely on classical heuristic ESOP optimization.

Let $X=\{0,1{\}}^n$ denote the input space of an $n$-variable binary function. Each training sample is $x_i=(x_{i1},\dots ,x_{in})\in X,$ with binary label $y_i\in \{0,1\}.$ The training dataset is $D_{\mathrm{t}\mathrm{r}\mathrm{a}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}}=\left\{\right(x_i,y_i){\}}_{i=1}^U,$ where $U\le 2^n$. Input combinations not included are treated as “don’t-care” conditions and may be assigned either binary value during PKRO optimization. Thus, the optimization preserves the labels of all training samples while selecting assignments for the unspecified inputs that minimize the PKRO representation. Assuming h is any PKRO representation for mapping all minterm cares $x_i$ to their outputs $y_i$ and also converting all “don’t-care” to their corresponding mapped outputs 0 and 1, $C_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O}}\left(h\right)$ is the number of AND-XOR nonzero coefficients of h. We also assume the labels $y_i$ are preserved for all $x_i$. The hypothesis class $\mathcal{H}$ is defined independently of T and consists of all $h$ that preserve the labels $y_i$ of the training samples. The learning objective is formulated in (47):

$$\begin{array}{c}\mathrm{f}\mathrm{i}\mathrm{n}\mathrm{d} h\in \mathcal{H}\hfill \\ \mathrm{subject}\mathrm{to}\hfill \\ C_{\mathrm{P}\mathrm{K}\mathrm{R}\mathrm{O}}\left(h\right)\le T,\hfill \\ h\left(x_i\right)=y_i,\forall (x_i,y_i)\in D_{\mathrm{t}\mathrm{r}\mathrm{a}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}}.\hfill \end{array}$$

(47)

Here, T is a prescribed coefficient threshold rather than a bound incorporated into the hypothesis class $\mathcal{H}$. The initial threshold $T_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{a}\mathrm{l}}$ is progressively decreased until its smallest feasible value $T_{\mathrm{M}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{m}\mathrm{a}\mathrm{l}}$ is identified. Our proposed method learns the optimal PKRO classifier that is consistent with the training data, following the principle of selecting the simplest consistent hypothesis.

In conventional logic synthesis, unspecified truth-table entries are treated as “don’t-care” conditions and may be assigned either logic value (0 or 1) to simplify the circuit. In our proposed framework, these unspecified entries are treated as “don’t-care” conditions and may be assigned either logic value to facilitate PKRO minimization. The objective goal is to learn a compact PKRO logic function consistent with the observed training data while assigning outputs to unseen inputs, following Occam’s razor principle. This framework focuses on symbolic logic learning and compact Boolean hypothesis synthesis rather than statistical generalization approach.

For the robotic case study, the training accuracy is 100% because the synthesized PKRO classifier is exactly consistent with all specified training samples. Since the primary goal of this work is to develop and confirm the proposed quantum-assisted learning algorithm, no independent test dataset is used. Accordingly, the reported 100% classification accuracy should be interpreted as a measure of consistency with the training specifications rather than as an indication of generalization performance metric [78]. Evaluating predictive performance on benchmark symbolic learning datasets and comparing with classical symbolic learning methods, such as decision trees and rule-learning algorithms, will be investigated in our future work. The proposed logic-based quantum machine-learning framework learns Boolean hypotheses by searching the PKRO hypothesis space using a hybrid binary–ternary Grover’s algorithm. By combining symbolic logic learning with quantum search, the framework effectively synthesizes compact and interpretable logic classifiers for robotic decision-making using the multi-solution Grover-based technique.

In [80], a quantum-controlled Braitenberg vehicle uses two front sensors and two rear motors, with its behavior being determined by the sensor readings. Following this concept, we use a vehicle with three binary sensor readings ($x_1$, $x_2$, and $x_3$), and train it using five sensor patterns represented as 3-variable minterms. For illustration, these training examples are shown in a Karnaugh map [81] in Figure 13, where 0 represents turning left and 1 represents moving forward. The remaining three unspecified cases are treated as “don’t-care” conditions and assigned binary values to minimize the number of nonzero PKRO AND–XOR coefficients. Our proposed framework then learns a compact PKRO-based AND–XOR classifier consistent with the training data. The resulting assignments preserve the specified sensor–action mappings while using unspecified inputs to minimize the PKRO representation. This demonstrates how the framework handles incomplete training data to obtain simpler Boolean logic representations.

Figure 13. Illustration of our quantum machine-learning process based on PKRO minimization as applied to a 3-variable robotic demonstration.

The experimental setup (see Figure 14) consists of a Hiwonder intelligent-vision robot equipped with a Raspberry Pi 5 (4 GB memory) running Python 3, and an Intel Core i7 laptop with a 13th Gen Intel^® Core™ i7 processor and 16 GB memory for classically simulating our proposed quantum machine-learning framework. The robot is equipped with a high-definition (HD) camera and an ultrasonic distance sensor, providing complementary visual and distance information for robotic perception. This multi-sensor platform supports real-time data acquisition and robotic decision-making [82,83,84].

Figure 14. Experimental setup to demonstrate our proposed quantum machine-learning framework.

The HD camera captures real-time images, which are processed to extract features such as object presence and navigation cues. The images are preprocessed using normalization and feature extraction before being converted into binary variables [85]. In this case study, blue and green blocks in the images are used as target objects for detection.

The ultrasonic sensor simultaneously measures the distance to nearby obstacles. Its readings are converted into binary values, where 1 indicates no obstacle within 30 cm and 0 indicates that an obstacle is detected. Ultrasonic sensing complements the camera by providing reliable distance measurements under varying lighting conditions [86].

Sensor fusion is performed on the Raspberry Pi 5 by combining the camera and ultrasonic features into a unified Boolean representation [87]. The variable $x_1$ represents obstacle detection from the ultrasonic sensor, while $x_2$ and $x_3$ indicate the presence of blue and green blocks, respectively. This quantum machine-learning framework is simulated on the laptop to learn the PKRO-based decision function for robotic navigation. The input variables and output labels of the classifier are summarized in Table 5.

Table 5. Input/output concepts of our quantum machine-learning experiment.

	Inputs		Outputs
$x_1$	$x_2$	$x_3$	$f$
(Ultrasonic Sensor)	(Camera)	(Camera)	(2 motors)
No Object within 30cm.	Blue Block	Green Block	Forward or Left Turn
0: Detected	0: Not Detected	0: Not Detected	0: Left Turn
1: Not Detected	1: Detected	1: Detected	1: Forward

The proposed framework is evaluated using our Python 3-based quantum simulator and a Hiwonder robotic platform. The simulator verifies the oracle, diffusion operator, and multi-solution search, while the robotic experiment demonstrates the real-time navigation using the optimized PKRO decision function. The robot executes the synthesized logic function (Figure 14), with quantum computations performed in software simulation. The proposed quantum approach is compared with a classical exhaustive PKRO search over the complete representation space, with both methods identifying the minimum-cost PKRO representation. The comparison focuses on the computational cost.

The pseudocode of the software simulation is outlined in Algorithm 1.

Algorithm 1: Software simulation of logic-based PKRO minimization

Inputs: Training dataset Dtraining and target success probability ptarget Outputs: Optimal PKRO representation Pmin and minimized AND–XOR classifier 1: Construct the minterm vector from the labeled training dataset Dtraining 2: BestSolution ← NULL 3: For each variable expansion order V (all n! permutations) do //---------- Classical Preprocessing ---------- 4:          Generate an initial feasible PKRO expansion by randomly assigning one polarity to each expansion tree node 5:          Compute the corresponding PKRO spectral coefficients 6:          Count the number of nonzero spectral coefficients Tinitial 7:          CandidateSet ← initial feasible candidate for Tinitial 8:          Set the initial threshold: T ← Tinitial −1 9:          While (better solution exists) do //---------- First Grover Execution ---------- 10:                Prepare a uniform superposition of all PKRO expansion assignments 11:                Determine the number of target solutions M (If M is unknown, M = 1) 12:                Compute the Grover iteration number: r = round (${\displaystyle \frac{\mathsf{\pi }}{4}}\sqrt{{\displaystyle \frac{N}{M}}}$) 13:                Execute Grover search once using r iterations 14:                Measure the quantum registers 15:                Estimate the single-execution success probability psuccess //---------- Determine Repeated Executions ---------- 16:                Calculate required number of Grover executions k using ptarget and psuccess 17:                Add the candidate from this Grover execution to CandidateSet //---------- Additional Grover Executions ---------- 18:                For (execution = 2 to k) do 19:                         Initialize the quantum registers 20:                         Execute Grover search using r iterations 21:                         Measure and decode the candidate PKRO form 22:                         Add the candidate to CandidateSet 23:                End For //---------- Classical Post-Processing and Post-Selection ---------- 24:                Classically verify all candidates in CandidateSet 25:                Select candidate with minimum number of nonzero spectral coefficients 26:                If Count (BestCandidate) ≤ T then 27:                         BestSolution ← BestCandidate 28:                         T ← Count (BestCandidate) − 1 29:                Else 30:                         Terminate threshold search 31:                End If 32:        End While 33: End For 34: Select overall best PKRO representation Pmin among all variable expansion orders 35: Construct the minimized AND–XOR classifier 36: Validate the classifier using Dtraining 37: Return Pmin and the minimized AND–XOR classifier

Figure 15 illustrates our complete system workflow, in which the training data are processed by our framework simulator to synthesize the minimum PKRO decision function, which is then communicated to Raspberry Pi 5 controller for robotic decision-making.

Figure 15. Flow diagram of the proposed quantum machine-learning framework.

4. Results and Discussion

4.1. Comparison of PKRO, KRO, and FPRM Form Minimization Results

PKRO, KRO, and FPRM minimizations are evaluated using the number of nonzero AND–XOR coefficients as the cost function. Table 6 summarizes the results for all 3-variable binary functions. PKRO reduces the number of nonzero coefficients by 0 or 1 compared with KRO, and by 0, 1, or 2 compared with FPRM. Overall, PKRO improves upon KRO for 4.688% of the functions, and upon FPRM for 37.5%, with average reductions of 0.047 and 0.484 nonzero coefficients, respectively. This improvement results from PKRO’s flexibility to independently select Sh, pD, and nD expansions at each node, providing a larger search space and more compact AND–XOR representations. As shown in Table 7, PKRO can generate up to 20% fewer nonzero coefficients than KRO for certain minterm vectors. Previous heuristic studies have also reported PKRO improvements over KRO, including an average 12.3% reduction in decision-diagram node ratio for larger input/output benchmarks and up to 25% improvement for some benchmark circuits [45].

Table 6. PKRO, KRO, and FPRM minimization—comparing results for all 3-variable binary functions.

AND-XOR Coefficients	PKRO Versus KRO	PKRO Versus FPRM
Minimum reduction	0	0
Maximum reduction	1	2
Average reduction	0.047	0.484
Medium reduction	0	0
Standard deviation	0.211	0.684
Functions improved	4.688%	37.500%
Functions unchanged	95.312%	62.500%
Functions worsened	0	0

Table 7. Comparison of PKRO and KRO results for 3-variable minterm examples.

Minterms (${\mathit{m}}_{\mathbf{0}}–{\mathit{m}}_{\mathbf{7}}$)	PKRO			KRO			Ones Count Reduction % ($\frac{\mathit{K}\mathit{R}\mathit{O}-\mathit{P}\mathit{K}\mathit{R}\mathit{O}}{\mathit{K}\mathit{R}\mathit{O}}$%)
	Polarity (${\mathit{x}}_1:{\mathbf{P}}_{\mathbf{a}0}$; ${\mathit{x}}_2:$ ${\mathbf{P}}_{\mathbf{b}0}{\mathbf{P}}_{\mathbf{b}1}$; ${\mathit{x}}_3: {\mathbf{P}}_{\mathbf{c}0}{\mathbf{P}}_{\mathbf{c}1}{\mathbf{P}}_{\mathbf{c}2}{\mathbf{P}}_{\mathbf{c}3}$.)	AND-XOR Coefficients ${(\mathit{e}}_{\mathbf{0}}–{\mathit{e}}_{\mathbf{7}}$) & Functions	Ones Count	Polarity (${\mathit{x}}_1:{\mathbf{P}}_{\mathbf{a}}$; ${\mathit{x}}_2:{\mathbf{P}}_{\mathbf{b}}$; ${\mathit{x}}_3:$ ${\mathbf{P}}_{\mathbf{c}}$.)	AND-XOR Coefficients $({\mathit{e}}_{\mathbf{0}}–{\mathit{e}}_{\mathbf{7}})$ & Functions	Ones Count
01101101	$x_1:1;$ $x_2$: 00; $x_3$: 2001	10011010 $f=\overline{x_1} \overline{x_3}\oplus \overline{x_1} x_2 x_3$ $\oplus x_2 \overline{x_3} \oplus 1$	4	$x_1:0;$ $x_2$: 0; $x_3$: 2	01111001 $f=x_3\oplus x_2\overline{x_3}\oplus x_2 x_3$ $\oplus x_1 \overline{x_3}\oplus x_1 x_2 x_3$	5	20%
01111001	$x_1:0;$ $x_2$: 10; $x_3$: 2000	10101001 $f=\overline{x_2} \overline{x_3}\oplus x_1 x_2 x_3$ $\oplus x_1\oplus 1$	4	$x_1:0;$ $x_2$: 0; $x_3$: 2	01101101 $f= x_2\overline{x_3}\oplus x_3\oplus x_1\overline{x_3}$ $\oplus x_1{x}_3\oplus x_1 x_2 x_3$	5	20%
10010111	$x_1:0;$ $x_2$: 00; $x_3$: 2000	10101001 $f=\overline{x_3}\oplus x_2$ $\oplus x_1\oplus x_1 x_2 x_3$	4	$x_1:0;$ $x_2$: 1; $x_3$: 2	11010110 $f=\overline{x_2} \overline{x_3}\oplus \overline{x_2} x_3$ $\oplus x_3\oplus x_1 \overline{x_2} x_3\oplus x_1 \overline{x_3}$	5	20%
11100111	$x_1:1;$ $x_2$: 00; $x_3$: 2001	10100110 $f=\overline{x_1} \overline{x_3}\oplus \overline{x_1}{x}_2$ $\oplus x_3\oplus x_2\overline{x_3}$	4	$x_1:0;$ $x_2$: 1; $x_3$: 2	01101101 $f=\overline{x_2}{x}_3\oplus x_1 \overline{x_2} \overline{x_3}$ $\oplus \overline{x_3}\oplus x_1 \overline{x_2} x_3\oplus x_1 x_3$	5	20%
11101001	$x_1:0;$ $x_2$: 00; $x_3$: 0002	10010110 $f=1\oplus x_2 x_3$ $\oplus x_1{x}_3\oplus x_1 x_2 \overline{x_3}$	4	$x_1:0;$ $x_2$: 0; $x_3$: 2	11010110 $f=\overline{x_3}\oplus x_3$ $\oplus x_1{x}_3\oplus x_2{x}_3\oplus x_1{x}_2\overline{x_3}$	5	20%

4.2. Simulation Analysis of Single-Solution Grover’s Algorithm

This research simulates the single-solution case for Grover’s algorithm with (M = 1). Figure 16 shows the measurement probability versus the number of Grover iterations for 3-variable PKRO minimization. According to (24), the optimal number of iterations is approximately ${\displaystyle \frac{\pi }{4}}\sqrt{N}={\displaystyle \frac{\pi }{4}}\sqrt{3^{2^3-1}}$ ≈ 37 times. The probability of measuring the optimal solution increases with the number of iterations and approaches 100% at approximately 37 iterations. Further iterations reduce the success probability, which then oscillates periodically. This behavior results from the amplitude-amplification process, in which each Grover iteration rotates the quantum state toward the target state. After the optimal point, further rotations move the state away from the target $|P_{\omega }⟩$, reducing the success probability. The single-solution case ($M=1$) is a special case of the multi-solution Grover’s search algorithm and exhibits the same amplitude-amplification behavior. Therefore, selecting an appropriate number of Grover iterations is essential for finding the optimal PKRO representation.

Figure 16. Probability of measuring the target state versus the number of Grover iterations, illustrating the periodic behavior of Grover’s algorithm.

Moreover, Grover’s algorithm provides a quadratic reduction in the number of Grover iterations. As shown in Table 8, the proposed approach reduces the required number of iterations by more than 98% compared with classical exhaustive search. This reduction quantifies the decrease in Grover iterations for the problem sizes evaluated in this study and should not be interpreted as direct experimental evidence of scalability to larger values of n. Because the PKRO search space grows exponentially with the number of variables n, the reduction in the required number of Grover iterations is expected to become increasingly significant as the search space grows. However, a reduction in the number of Grover iterations does not, by itself, imply a corresponding reduction in the total execution time. Practical scalability also depends on the resource requirements of the oracle design and implementation, including gate count, circuit depth, ancilla qubits or qutrits, and the overheads associated with implementing multi-controlled gates, just to name a few. The scalability of our proposed framework is further examined later in the paper using n-variable analytical resource estimates.

Table 8. Quadratic number of Grover iteration reduction for the single-solution case ($M=1$).

n	Tree Nodes ($2^{\mathit{n}}-1$)	Candidate Solutions $\mathit{n}!$3(2n−1)	Classical Search Iterations $\mathit{C}\mathit{L}=\mathit{n}!$3(2n−1)	Grover Iterations $\mathit{G}=\mathit{n}!\frac{\mathit{\pi }}{4}\sqrt{3^{2^{\mathit{n}}-1}}$	Grover Iteration Reduction ($\frac{\mathit{C}\mathit{L}-\mathit{G}}{\mathit{C}\mathit{L}}$%)
3	7	13,122	13,122	222	98.32%
4	15	344,373,768	344,373,768	71,366	99.98%

4.3. Multi-Solution Grover’s Algorithm Simulation Analysis

Figure 17 shows a multi-solution Grover’s search for the minterm vector 01001011. The measured state $|0212221⟩$ represents one of 144 optimal PKRO polarity assignments. This ternary state corresponds to decimal index 646. Each target state has a measurement probability of approximately 0.653%, giving a total success probability of 94.032% across all 144 target states in one Grover execution. Because the 144 optimal polarity assignments are equivalent solutions, measuring any one of these target states constitutes a successful outcome. Thus, the high aggregate success probability results from the combined probability of all 144 optimal states rather than from the probability of measuring a particular state. This multi-solution behavior is a key advantage of the proposed multi-solution Grover-based search, as it allows any optimal PKRO polarity assignment to be accepted as a valid solution.

Figure 17. Multi-solution Grover’s algorithm measurement-probability distribution for the minterm vector 01001011.

Table 9 shows simulation results demonstrating that the proposed multi-solution Grover’s algorithm reduces the required number of iterations by more than 91% compared with the single-solution Grover’s algorithm. As the number of target solutions M increases, fewer iterations are needed, consistent with the O $\left(\sqrt{{\displaystyle \frac{\mathit{N}}{\mathit{M}}}}\right)$ complexity of the multi-solution Grover search. These results demonstrate that our proposed binary–ternary multi-solution Grover’s algorithm can efficiently amplify multiple optimal PKRO polarity assignments while reducing the overall search cost.

Table 9. Multi-solution Grover’s algorithm for 3-variable PKRO form minimization. For comparison, the single-solution case requires $r_s=37$ Grover iterations for all 3-variable PKRO forms.

Minterms (${\mathit{m}}_{\mathbf{0}}–{\mathit{m}}_{\mathbf{7}})$	Multi-Solutions (M)	Multi-Solution Iterations (r = $\frac{\mathit{\pi }}{4}\sqrt{\frac{\mathit{N}}{\mathit{M}}}$)	Grover Iteration Reduction ($\frac{{\mathit{r}}_{\mathit{s}}-\mathit{r}}{{\mathit{r}}_{\mathit{s}}}$%)
01001011	144	3	91.9%
10010011	144	3	91.9%
10011010	144	3	91.9%
01011011	288	2	94.6%
10010010	288	2	94.6%
11011010	288	2	94.6%
01011010	432	2	94.6%
10000010	432	2	94.6%
11110011	432	2	94.6%
00001110	648	1	97.3%
10001000	648	1	97.3%
11101110	648	1	97.3%

The quantum simulator analyzes all 256 possible minterm vectors for 3-variable PKRO minimization and classifies them into four categories—Category-144, Category-288, Category-432, and Category-648—according to the number of target solutions. Figure 18 shows the percentage distribution of these categories across all 3-variable minterm vectors.

Figure 18. Percentage distribution of target solution count-based categories for multi-solution Grover’s algorithm in 3-variable PKRO minimization across all minterms.

In addition, the proposed post-processing method is evaluated through simulation to improve the success probability of Grover’s algorithm. For example, if the target success probability $p_{\mathrm{t}\mathrm{a}\mathrm{r}\mathrm{g}\mathrm{e}\mathrm{t}}$ is set to 99.9% for the minterm vector 01001011, the required number of Grover executions is $k=3$, according to (39). After three executions, the post-processing method selects the PKRO polarity assignment with the fewest nonzero coefficients, achieving a success probability of 99.979%, as calculated by (38) and shown in Table 10.

Table 10. Example of multiple executions of Grover’s algorithm to achieve a target success probability of 99.9% for the minterm vector 01001011.

Minterms (m0–m7)	Required Grover Executions (k)	Success % for 1 Execution	Success % for 2 Executions	Success % for 3 Executions
01001011	3	94.032%	99.644%	99.979%

Table 11 shows that, for the minterm vector 01001011, the proposed strategy achieves target success probabilities $p_{\mathrm{t}\mathrm{a}\mathrm{r}\mathrm{g}\mathrm{e}\mathrm{t}}$ with only a small number of repeated Grover executions. Consequently, the method provides a practical balance between computational efficiency and solution quality while significantly increasing the probability of identifying optimal PKRO representations for logic-minimization and machine-learning tasks.

Table 11. Example of required Grover executions k to achieve different target success probability $p_{\mathrm{target}}$ for the minterm vector 01001011.

Target Success % ${\mathit{p}}_{\mathbf{target}}$	Success % for 1 Execution	Required Grover Executions (k)	Success % for k Executions
99.9%	94.032%	3	99.979%
99.99%	94.032%	4	99.9987%
99.999%	94.032%	5	99.9999%

Table 12 lists the number of Grover executions required to achieve the target success probability $p_{\mathrm{t}\mathrm{a}\mathrm{r}\mathrm{g}\mathrm{e}\mathrm{t}}=99.9\%$ using the proposed post-processing and post-selection method for different multi-solution count M categories. For all M categories in Table 12, only 2–3 executions are required, demonstrating the rapid increase in overall success probability achieved by our proposed method.

Table 12. Required number of multi-solution Grover’s algorithm executions to achieve an overall success probability of $p_{\mathrm{target}}=99.9\%$ for 3-variable PKRO optimizations.

Multi-Solutions (M)	Individual Target Solution Measurement Probability	1 Execution Success % ${\mathit{p}}_{\mathbf{success}}$	Number of Executions Needed (k)
144	0.653%	94.032%	3
288	0.320%	92.160%	3
432	0.223%	96.336%	3
648	0.151%	97.848%	2

Figure 19 shows that the proposed method exponentially increases the success probability toward 100% across different multi-solution categories—Count-144, Count-288, Count-432, and Count-648—by combining multiple independent executions of Grover’s algorithm, thereby enhancing the reliability and robustness of our proposed quantum machine-learning framework. Please note that the success probability does not necessarily increase monotonically with the number of solutions M. For example, the Count-144 category achieves a higher success probability than the Count-288 category because the required number of Grover iterations $r$ is rounded to the nearest integer, and this rounding can result in different success probabilities for different solution counts M. Therefore, there is no exact monotonic trend in which a higher M count always leads to a higher success probability.

Figure 19. PKRO Grover’s post-processing and post-selection success probability trend as a function of multiple executions for 3-variable minterm vectors to handle different Grover’s algorithm multi-solution count categories. The Figure illustrates the improvement in overall success probability through repeated Grover executions combined with post-processing and post-selection.

4.4. Quantum Computation-Cost-Simulation-Result Analysis

Table 13 presents the estimated quantum computation cost for one Grover iteration based on (42), assuming each ${\mathrm{C}}_2{\mathrm{C}}_3\mathrm{X}$ gate has binary and ternary quantum costs of approximately 6 and 10, respectively. Please note the exact cost number depends on the actual target hardware and the chosen gate decomposition.

Table 13. Estimated quantum computation cost for one iteration of PKRO-processor evaluation for an n-variable binary function PKRO minimization, assuming binary and ternary quantum cost of approximately 6 and 10, respectively, for ${\mathrm{C}}_2{\mathrm{C}}_3\mathrm{X}$ gate.

N	Grover Iteration Gate Counts Estimation (O(n2n))	Quantum Cost Estimation (Binary)	Quantum Cost Estimation (Ternary)
2	8	48	80
3	24	144	240
4	64	384	640
5	160	960	1600
6	384	2304	3840
7	896	5376	8960
8	2048	12,288	20,480

Figure 20 shows an example of PKRO form minimization execution initial-to-minimal threshold-difference distribution for all 3-variable binary function minterm vectors. In this example, each PKRO decomposition is assigned with pD expansion at every decomposition node to determine the initial threshold T_initial. In Figure 20, larger threshold differences indicate a greater PKRO AND-XOR nonzero coefficient reduction being achieved by the PKRO optimization process while a higher number of Grover iterations needs to be executed to achieve that.

Figure 20. Threshold reduction from PKRO minimization for all 256 3-variable binary functions. Each decomposition uses pD expansion to determine the initial threshold $T_{\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{a}\mathrm{l}}$. The horizontal axis shows the function index (0–255) and the vertical axis shows the reduction in $T$.

Figure 21 shows an example of the total number of oracle evaluations required to reduce the AND–XOR nonzero coefficient threshold from its initial value obtained using pD expansions to the minimum in 3-variable PKRO minimization. The calculation includes all Grover iterations used to minimize the threshold across n! variable expansion orderings, as well as k repeated Grover executions for post-processing to increase the success probability to the target level $p_{\mathrm{target}}=99.9\%$.

Figure 21. Example of the total number of oracle evaluations to reduce AND–XOR threshold from its initial value to the minimum and perform post-processing for all 3-variable PKRO minimizations.

Table 14 presents the estimated PKRO processor quantum computation cost distribution for the complete 3-variable binary function PKRO minimization process using the proposed framework, including the $M=1$ statistic in addition to $M>1$ case. The initial threshold is determined by assuming pD expansions at all PKRO decomposition nodes. The gate cost is estimated separately for binary and ternary gates. These values are intended for cost estimation only; the actual implementation cost depends on the underlying hardware technology and gate-decomposition method. The results, therefore, provide a hardware-independent basis for analyzing the relative cost of our proposed quantum machine-learning framework.

Table 14. Estimated PKRO processor evaluation quantum computation gate cost distribution including threshold decreasing from the initial value to the minimal value, and post-processing k executions for all 3-variable function PKRO minimization executions, assuming binary and ternary quantum cost of approximately 6 and 10, respectively, for ${\mathrm{C}}_2{\mathrm{C}}_3\mathrm{X}$ gate.

Category	Quantum Computation Cost Estimation (Binary)		Quantum Computation Cost Estimation (Ternary)
	M > 1	M = 1	M > 1	M = 1
Minimum	31,968	31,968	53,280	53,280
Maximum	43,200	255,744	72,000	426,240
Average	38,778	90,012	64,631	150,020
Medium	39,744	95,904	66,240	159,840
Standard	4062	39,247	6770	65,411

Table 15 compares the proposed Grover-based PKRO processor with classical exhaustive search using the same PKRO processor under a uniform per-iteration cost assumption. Assuming that the ${\mathrm{C}}_2{\mathrm{C}}_3\mathrm{X}$ gate has the same estimated quantum computation cost, Grover’s algorithm reduces the computation cost, compared with classical exhaustive search, by an average of 97.95% and up to 98.31% for M > 1, and by an average of 95.24% and up to 98.31% for M = 1.

Table 15. Comparison of Grover oracle query PKRO processor computation cost between Grover’s algorithm (GA) and classical exhaustive (CE) search for PKRO minimization of all 3-variable binary functions (CE total cost: 1,889,568 for binary gate cost and 3,149,280 for ternary gate cost).

Computation Cost	GA Versus CE ($\frac{\mathit{C}\mathit{E}-\mathit{G}\mathit{A}}{\mathit{C}\mathit{E}}$%) M > 1	GA Versus CE ($\frac{\mathit{C}\mathit{E}-\mathit{G}\mathit{A}}{\mathit{C}\mathit{E}}$%) M = 1
Minimum reduction	97.71%	86.47%
Maximum reduction	98.31%	98.31%
Average reduction	97.95%	95.24%
Medium reduction	97.90%	94.92%
Standard deviation	0.21%	2.08%

4.5. Software Simulation and Robotic Demonstration of the Proposed Quantum Machine-Learning Framework

Table 16 shows that our proposed Grover-based quantum machine-learning framework can handle multiple “don’t-care” conditions. During learning, “don’t-care” entries are treated as variables within the PKRO search space. These variables are assigned with 0 and 1 binary values. The multi-solution binary–ternary Grover’s algorithm searches these assignments to identify optimal PKRO solutions with the minimum number of AND–XOR nonzero coefficients. The results demonstrate that our logic-based quantum machine-learning framework can handle different training datasets while maintaining compact solutions and computational efficiency.

Table 16. Examples of logic-based quantum machine-learning solutions when handling multiple “don’t-care” conditions.

Minterms (${\mathit{m}}_{\mathbf{0}}–{\mathit{m}}_{\mathbf{7}}$) with “Don’t-Care” Conditions (−)	Minterms (${\mathit{m}}_{\mathbf{0}}–{\mathit{m}}_{\mathbf{7}}$) Replace “−” with 0/1	Polarity (${\mathit{x}}_{\mathbf{1}}:{\mathbf{P}}_{\mathbf{a}\mathbf{0}}$; ${\mathit{x}}_{\mathbf{2}}:$ ${\mathbf{P}}_{\mathbf{b}\mathbf{0}}{\mathbf{P}}_{\mathbf{b}\mathbf{1}}$; ${\mathit{x}}_{\mathbf{3}}:{\mathbf{P}}_{\mathbf{c}\mathbf{0}}{\mathbf{P}}_{\mathbf{c}\mathbf{1}}{\mathbf{P}}_{\mathbf{c}\mathbf{2}}{\mathbf{P}}_{\mathbf{c}\mathbf{3}}$.)	AND-XOR Coefficients (${\mathit{e}}_{\mathbf{0}}–{\mathit{e}}_{\mathbf{7}}$)	QML Prediction Function
101101$-$ $-$	10110100	$x_1:1; x_2$: 11${;x}_3$: 2000	00100100	Selected 00100100 with two AND–XOR nonzero coefficients: $f\left(x_1,x_2,x_3\right)=\overline{x_1}\oplus \overline{x_2}{x}_3$
	10110101	$x_1:2; x_2$: 00${;x}_3$: 1000	10010100
	10110110	$x_1:1; x_2$: 10${;x}_3$: 2000	10010110
	10110111	$x_1:1; x_2$: 20${;x}_3$: 0001	10000110
011$-$0$-$01	01100001	$x_1:1; x_2$: 10${;x}_3$: 2000	10100001	Selected 00100100 with two AND–XOR nonzero coefficients: $f\left(x_1,x_2,x_3\right)=x_3\oplus \overline{x_1}{x}_2$
	01100101	$x_1:1; x_2$: 00${;x}_3$: 2000	00100100
	01110001	$x_1:1; x_2$: 00${;x}_3$: 2000	01100001
	01110101	$x_1:1; x_2$: 00${;x}_3$: 2100	00100100

Furthermore, our quantum machine-learning framework is evaluated using a robotic motion-control case study. As shown in Table 17 and Figure 22, the PKRO-based learning process identifies an optimal prediction function, $f\left(x_1,x_2,x_3\right)=\overline{x_2}{x}_3\oplus x_1$, which provides a compact representation consistent with Occam’s razor (see Figure 22b). Figure 22c illustrates an alternative prediction function that is not selected because it contains a larger number of AND–XOR nonzero coefficients. When multiple solutions have the same minimum cost, the simulator randomly selects one of the optimal solutions and transmits it to the robot via Wi-Fi. The robot then uses the selected function to make motion decisions based on real-time sensor inputs. Experimental results show correct behavior for all tested sensor readings, demonstrating that the proposed framework can generate compact logic-based prediction functions for robotic decision-making. This case study illustrates the practical use of the learned minimum-cost logic representation for hardware-based robotic decision-making.

Table 17. Example of PKRO-based quantum-assisted machine learning for robotic motion control with multiple “don’t-care” conditions.

Minterms (${\mathit{m}}_{\mathbf{0}}–{\mathit{m}}_{\mathbf{7}}$) with “Don’t-Care” Conditions (−)	Minterms (${\mathit{m}}_{\mathbf{0}}–{\mathit{m}}_{\mathbf{7}}$) Replace “−” with 0/1	Polarity (${\mathit{x}}_{\mathbf{1}}:{\mathbf{P}}_{\mathbf{a}\mathbf{0}}$; ${\mathit{x}}_{\mathbf{2}}:$ ${\mathbf{P}}_{\mathbf{b}\mathbf{0}}{\mathbf{P}}_{\mathbf{b}\mathbf{1}}$; ${\mathit{x}}_{\mathbf{3}}:{\mathbf{P}}_{\mathbf{c}\mathbf{0}}{\mathbf{P}}_{\mathbf{c}\mathbf{1}}{\mathbf{P}}_{\mathbf{c}\mathbf{2}}{\mathbf{P}}_{\mathbf{c}\mathbf{3}}$.)	AND-XOR Coefficients (${\mathit{e}}_{\mathbf{0}}–{\mathit{e}}_{\mathbf{7}}$)	QML Prediction Function
$-$10$-$101$-$	01001010	$x_1:2; x_2$: 21${;x}_3$: 2222	01000010	Selected 01000001 with 2 AND–XOR nonzero coefficients: $f\left(x_1,x_2,x_3\right)$ $= \overline{x_2} x_3\oplus x_1$
	01001011	$x_1:0; x_2$: 21${;x}_3$: 2221	01000001
	01011010	$x_1:2; x_2$: 11${;x}_3$: 2222	00010010
	01011011	$x_1:2; x_2$: 12${;x}_3$: 2221	00011001
	11001010	$x_1:2; x_2$: 21${;x}_3$: 1222	01000010
	11001011	$x_1:2; x_2$: 22${;x}_3$: 1221	01001001
	11011010	$x_1:2; x_2$: 21${;x}_3$: 1222	01010010
	11011011	$x_1:0; x_2$: 22${;x}_3$: 1222	01010110

Figure 22. Robot-motion case-study illustration: (a) Karnaugh map shows input minterms with “don’t-care” conditions; (b) the minterm vector 01001011 is selected due to minimum number of ones for AND–XOR coefficients: $f\left(x_1,x_2,x_3\right)=\overline{x_2}{x}_3\oplus x_1$; and (c) the minterm vector 11011010 is not selected due to more ones for AND–XOR coefficients: $f\left(x_1,x_2,x_3\right)=\overline{x_1}\overline{x_2}\oplus \overline{x_1}{x_{2}x}_3\oplus x_1\overline{x_3}$.

The framework simulator uses approximately 6.4 GB of memory due to large matrix operations, with each Grover iteration taking about 5 milliseconds on our laptop. This memory requirement limits simulation scalability for larger numbers of variables. Future work will investigate implementation of the proposed framework on real quantum hardware. To further assess scalability, we evaluate classical PKRO enumeration for $n=4$. Each completely specified 4-variable binary function has approximately $3^{15}\approx 1.43\times {10}^7$ candidate polarity assignments from Table 8, resulting in approximately $2.25\times {10}^{13}$ PKRO expansion combinations across all $2^{16}=\mathrm{65,536}$ binary functions. At the measured rate of 0.4659 milliseconds per PKRO polarity combination, exhaustive enumeration would require approximately 333 years of sequential computation. Thus, computational time becomes the primary scalability limitation for $n=4$, requiring further software optimization, parallel computing, and more powerful hardware to feasibly explore larger PKRO expansion spaces classically. This computational limitation further motivates the proposed quantum-based framework as a potential approach for PKRO expansion minimization in the hybrid quantum–classical domain.

5. Directions of Future Work

Several directions remain for future research. First, the current work is primarily simulation-based. Future studies will focus on implementing the proposed approach on real quantum hardware. Current quantum computers remain constrained in the numbers of available qubits and qutrits because of noise, connectivity, decoherence, and error-correction constraints. As quantum hardware advances, larger-scale binary–ternary Grover-based machine-learning systems may become feasible.

Second, future research will investigate error-tolerant machine learning, where slightly less accurate but simpler AND–XOR representations may improve generalization while reducing circuit complexity. Noise-based quantum simulation [88] can also be used to evaluate the robustness of the proposed hybrid binary–ternary quantum–classical framework. Systematic studies of noise and decoherence will assess their effects on solution quality and circuit performance.

Third, reducing the number of qutrits required to represent PKRO polarity configurations is an important research direction. Ternary Decision Diagrams (TDD) and RM expansions may provide opportunities to reduce the number of active qutrits and gate counts in quantum oracle synthesis [89]. In general, reducing the size and complexity of the quantum oracle remains a key challenge. Future work will also examine scalability to larger numbers of variables and the associated qubit/qutrit, gate, and circuit-depth requirements. Beyond the exact optimization studied in this paper, future research will investigate classical exhaustive and heuristic methods using common benchmarks to quantify representation cost, computational effort, and scalability, while accounting for differences in optimization objectives and optimality guarantees. These comparisons will help identify the practical trade-offs and application regimes of the respective approaches. Approximate optimization strategies will also be investigated to potentially trade representation quality for lower computational and quantum resource requirements.

Finally, more compact solutions may theoretically be obtained using generalized Reed–Muller (GRM) forms [35,44]. GRM provides greater representation flexibility because the polarity of each variable can vary across individual product terms, but this also results in a substantially larger search space. Since GRM forms are canonical, exact minimization can be formulated by evaluating a finite set of transformation matrices, providing a possible basis for quantum oracle construction. However, existing approaches are generally limited to a fixed number of variables and do not provide a recursive structure that can be extended to arbitrary n. Developing a recursive GRM butterfly structure for arbitrary n, therefore, remains an open theoretical problem. Recent work on classical GRM and generalized pseudo-mixed-polarity Reed–Muller (GPMPRM) methods [90,91,92] provides a potential starting point for developing future quantum search algorithms for more general AND–XOR representations and logic-based classifiers.

6. Conclusions

This paper presents a quantum-assisted framework for logic-based machine learning based on logic minimization using a multi-solution binary–ternary Grover’s algorithm and Pseudo-Kronecker Reed–Muller (PKRO) minimization. The proposed approach formulates logic-based machine learning as a search for minimum-cost AND–XOR representations that are consistent with the training data and guided by Occam’s razor. To the best of our knowledge, based on our review of the recent literature, this work is the first to apply a binary–ternary Grover’s algorithm to the minimization of AND–XOR representations within a quantum machine-learning framework. Our framework employs ternary controls and binary targets, providing general architecture with potential applications beyond the specific minimization problem considered here. Furthermore, the use of multiple butterfly structures in quantum superposition provides a potential pathway for extending classical butterfly-based algorithms to the quantum domain and, ultimately, to arbitrary multi-valued logic with both multi-valued controls and targets.

To explore the expanded PKRO solution space, our proposed method uses hybrid ternary–binary reversible circuits, where qutrits encode the three PKRO expansion types using values 0, 1, and 2, while binary registers perform PKRO computation and cost evaluation. The framework also supports incomplete training data containing “don’t-care” conditions for logic minimization. Simulation results demonstrate the proposed quantum circuit operations and the ability to identify minimum-cost PKRO forms. Across all 256 three-variable binary functions, PKRO provides fewer AND-XOR nonzero coefficients than KRO for 4.688% of functions and fewer than FPRM for 37.5% of functions, with average reductions of 0.047 and 0.484 nonzero coefficients, respectively. The multi-solution Grover’s algorithm reduces the number of iterations by more than 91% compared with the corresponding single-solution search, consistent with the standard complexity of multi-solution Grover’s algorithm.

The threshold-based post-processing and post-selection procedure is introduced to promote convergence toward the desired solution. A robotic navigation case study demonstrates how the resulting PKRO function can be synthesized as a hardware classifier for decision-making. Although the demonstration uses classical simulation, it illustrates the application of the proposed minimum-cost logical model-selection framework to hardware-implementable machine learning. No held-out evaluation or quantitative comparison with classical rule-learning methods is performed. Beyond the three-variable evaluation, the n-variable resource and scalability analysis characterizes the growth of the PKRO search space, oracle resources, and Grover search requirements. Practical evaluation of larger instances remains limited by classical simulation resources and quantum hardware constraints, including available qubits and qutrits, connectivity, gate fidelity, and error correction. When native (supported) ternary gates are not available, qutrit operations can be encoded using multiple qubits, at the cost of additional resources. IBM’s projected systems, targeting over 10,000 qubits by the early 2030s [93], provide one indication of the potential long-term hardware-scaling direction.