Q-Map: Quantum Circuit Implementation of Boolean Functions

TL;DR

This paper introduces Q-Map, a visual technique for implementing classical Boolean functions on quantum computers, aiming to optimize quantum gate usage and facilitate quantum algorithm development.

Contribution

The paper presents a novel visual method, Q-Map, for efficiently translating Boolean functions into quantum circuits with minimal gates.

Findings

Q-Map effectively reduces quantum gate count.

The method simplifies quantum circuit design for Boolean functions.

Q-Map enhances the practicality of quantum logic implementation.

Abstract

Quantum computing has gained attention in recent years due to the significant progress in quantum computing technology. Today many companies like IBM, Google and Microsoft have developed quantum computers and simulators for research and commercial use. The development of quantum techniques and algorithms is essential to exploit the full power of quantum computers. In this paper we propose a simple visual technique (we call Q-Map) for quantum realisation of classical Boolean logic circuits. The proposed method utilises concepts from Boolean algebra to produce a quantum circuit with minimal number of quantum gates.

Figures

Tables

Table 1. Table 1 : Toggle function to represent change of state

Present Sate $q_i$	Next State $q_i^{{}^{\prime }}$	Toggle function $T\left(q_i\right)=q_i\oplus q_i^{{}^{\prime }}$
$|0⟩$	$|0⟩$	$|0⟩$
$|0⟩$	$|1⟩$	$|1⟩$
$|1⟩$	$|0⟩$	$|1⟩$
$|1⟩$	$|1⟩$	$|0⟩$

Table 2. Table 2 : Gray code to Binary converter truth table.

Present State	Next State
${\text{q}}_3{\text{q}}_2{\text{q}}_1{\text{q}}_0$	${\text{q}}_3^{{}^{\prime }}{\text{q}}_2^{{}^{\prime }}{\text{q}}_1^{{}^{\prime }}{\text{ q}}_0^{{}^{\prime }}$
$0000$	$0000$
$0001$	$0001$
$0011$	$0010$
$0010$	$0011$
$0110$	$0100$
$0111$	$0101$
$0101$	$0110$
$0100$	$0111$
$1100$	$1000$
$1101$	$1001$
$1111$	$1010$
$1110$	$1011$
$1010$	$1100$
$1011$	$1101$
$1001$	$1110$
$1000$	$1111$

Table 3. Table 3 : Gray Code to binary converter: Q-Map functions are calculated as the XOR of the present and next states.

Present State	Next State	Toggle Functions
${\text{q}}_3{\text{q}}_2{\text{q}}_1{\text{q}}_0$	${\text{q}}_3^{{}^{\prime }}{\text{q}}_2^{{}^{\prime }}{\text{q}}_1^{{}^{\prime }}{\text{ q}}_0^{{}^{\prime }}$	$\text{T}\left({\text{q}}_3\right)$	$\text{T}\left({\text{q}}_2\right)$	$\text{T}\left({\text{q}}_1\right)$	$\text{T}\left({\text{q}}_0\right)$
$0000$	$0000$	$0$	$0$	$0$	$0$
$0001$	$0001$	$0$	$0$	$0$	$0$
$0011$	$0010$	$0$	$0$	$0$	$1$
$0010$	$0011$	$0$	$0$	$0$	$1$
$0110$	$0100$	$0$	$0$	$1$	$0$
$0111$	$0101$	$0$	$0$	$1$	$0$
$0101$	$0110$	$0$	$0$	$1$	$1$
$0100$	$0111$	$0$	$0$	$1$	$1$
$1100$	$1000$	$0$	$1$	$0$	$0$
$1101$	$1001$	$0$	$1$	$0$	$0$
$1111$	$1010$	$0$	$1$	$0$	$1$
$1110$	$1011$	$0$	$1$	$0$	$1$
$1010$	$1100$	$0$	$1$	$1$	$0$
$1011$	$1101$	$0$	$1$	$1$	$0$
$1001$	$1110$	$0$	$1$	$1$	$1$
$1000$	$1111$	$0$	$1$	$1$	$1$

Equations

$${\text{V}}_i\stackrel{{\text{U}}_{q_i}}{⟶}{\text{V}}_i^{{}^{\prime }}$$

$$\boxed{\begin{array}[]{rcl}\ket{q_{0}q_{1}q_{2}q_{3}\dots q_{n-1}}&\stackrel{{\scriptstyle\textbf{U}_{q_{0}}}}{{\longrightarrow}}&\ket{q_{0}^{{}^{\prime}}q_{1}q_{2}q_{3}\dots q_{n-1}}\\ \ket{q_{0}^{{}^{\prime}}q_{1}q_{2}q_{3}\dots q_{n-1}}&\stackrel{{\scriptstyle\textbf{U}_{q_{1}}}}{{\longrightarrow}}&\ket{q_{0}^{{}^{\prime}}q_{1}^{{}^{\prime}}q_{2}q_{3}\dots q_{n-1}}\\ \ket{q_{0}^{{}^{\prime}}q_{1}^{{}^{\prime}}q_{2}q_{3}\dots q_{n-1}}&\stackrel{{\scriptstyle\textbf{U}_{q_{2}}}}{{\longrightarrow}}&\ket{q_{0}^{{}^{\prime}}q_{1}^{{}^{\prime}}q_{2}^{{}^{\prime}}q_{3}\dots q_{n-1}}\\ \vdots&\vdots&\vdots\\ \ket{q_{0}^{{}^{\prime}}q_{1}^{{}^{\prime}}\dots q_{n-2}^{{}^{\prime}}q_{n-1}}&\stackrel{{\scriptstyle\textbf{U}_{q_{n-1}}}}{{\longrightarrow}}&\ket{q_{0}^{{}^{\prime}}q_{1}^{{}^{\prime}}\dots q_{n-2}^{{}^{\prime}}q_{n-1}^{{}^{\prime}}}\end{array}}$$

$$T(q_0)=q_0\oplus q_0^{{}^{\prime }}$$

$$T(q_1)=q_1\oplus q_1^{{}^{\prime }}$$

$$T(q_2)=q_2\oplus q_2^{{}^{\prime }}$$

$$T(q_3)=q_3\oplus q_3^{{}^{\prime }}$$

$$T(q_0)={\overline{q}}_3{\overline{q}}_2{q}_1\oplus {\overline{q}}_3{q}_2{\overline{q}}_1\oplus q_3{\overline{q}}_2{\overline{q}}_1\oplus q_3{q}_2{q}_1$$

$$T(q_1)=q_3{\overline{q}}_2\oplus {\overline{q}}_3{q}_2$$

$$T(q_2)=q_3$$

$$\boxed{\begin{array}[]{rcl}T(q_{0})&=&\overline{q}_{3}\overline{q}_{2}q_{1}+\overline{q}_{3}q_{2}\overline{q}_{1}+q_{3}\overline{q}_{2}\overline{q}_{1}+q_{3}q_{2}q_{1}\\ T(q_{1})&=&q_{3}\overline{q}_{2}+\overline{q}_{3}q_{2}\\ T(q_{2})&=&q_{3}\\ T(q_{3})&=&0\end{array}}$$

$$\boxed{\begin{array}[]{rcl}T(q_{0})&=&\overline{q}_{3}q_{1}+q_{3}\overline{q}_{1}+q_{2}\\ T(q_{1})&=&q_{3}+q_{2}\\ T(q_{2})&=&q_{3}\\ T(q_{3})&=&0\end{array}}$$

Full text

Introduction

The advancement of quantum computing hardware and software intrigues researchers to develop quantum algorithms in areas such as cryptography, image processing, algorithms, finance [10, 15, 13, 6] and many other areas. One main advantage of quantum computers compared to classical computers is the processing power. The quantum computer can process computationally expensive tasks exponentially faster than the classical computer. While classical algorithms are limited in complexity to $O(n)$, a quantum search algorithm proposed by Grover [8] uses $O(\sqrt{n})$ for unsorted list of $n$ items. Shor [23] proposed a quantum algorithm to factor an integer $n$ in polynomial of log $n$ time complexity. At this point, there is no classical algorithm that can solve number factorisation in polynomial time.The RSA cryptographic system [20] is based on prime number factorisation, and thus with quantum computers an RSA encrypted message can be decrypted in polynomial time complexity. Hallgen [9] presented a polynomial-time quantum algorithm to solve the Pell-Fermat equation [3] ( also known as the Pells equation 111Pell-Fermat equation is: $x^{2}-dy^{2}=1$ and the goal is to find pairs of integers $(x,y)$ to satisfy the equation). In classical algorithm there is no know polynomial time solution and the problem is know to be NP complete [4]. Recently, a group of scientists at Google AI Quantum [2] used $53$ qubit quantum computer to sample the output of a pseudo-random quantum circuit [18]. The results were compared with the sate-of-the art super computer that needs 10,000 years while the 53 qubit quantum computer needs $200$ seconds.

Another advantage of quantum computers is low energy consumption. In computation, energy consumption is correlated with reversibility of the computation. Irreversibly is equivalent to information erasure. For the case of an AND gate of output 0, we may say that we cannot uniquely identify the input, the AND operation resulted in erasure of information and thus consumed energy [14]. As demonstrated by Landauer [14], classical binary computers mainly dissipate energy during information erasure at the rate of $KT\ln 2$ per bit erased, where $K$ is the Boltzmann constant and $T$ is the temperature in Kelvins. At room temperature (300 Kelvin), each bit erasure will cost around $3\times 10^{-21}Jouls$. This number appears to be too small, however the digital binary computer is composed of huge number of Boolean logic gate operations at the hardware level which results in significant consumption of energy. On the other hand, quantum computers utilise quantum gates which are all reversible gates and thus quantum computation do not result in energy consumption.

In this paper we propose a simple visual technique (we call Q-Map) for quantum realisation of classical Boolean logic circuits. Classical boolean computation can be described in terms of classical boolean functions. To perform classical computations using a quantum computer, the classical boolean function need to be synthesised using reversible functions.

Overview of classical and Quantum gates

A Boolean function with $n$ inputs and $m$ outputs is defined as:

$\mathcal{B}_{n,m}\stackrel{{\scriptstyle\text{def}}}{{=}}\{f|f:\mathbb{B}^{n}\rightarrow\mathbb{B}^{m}\}$, where the Boolean values are denoted by $\mathbb{B}\stackrel{{\scriptstyle\text{def}}}{{=}}\{0,1\}$.

A function $f\in\mathcal{B}_{n,n}$ is reversible if it is bijective [21], each input map exactly to one output and the number of inputs is equal to the number of outputs.

Classical Binary computers are, in essence, composed of irreversible logic gates. Other than the NOT gate, the binary logic gates are irreversible gates ( see Figure 1 ). For example the classic AND gate is irreversible, for an output of 0 the input could be 00, 01 or 10 and cannot be uniquely identified.

On the other hand, a quantum bit (or qubit) x represents a unit of information and can be described in a two dimensional quantum system as follows:

\ket{x}=\left[\begin{array}[]{c}c_{0}\\ c_{1}\end{array}\right] where $\sqrt{{\left|c_{0}\right|}^{2}+{\left|c_{1}\right|}^{2}}=1$

The quantum states of $\ket{0}$ and $\ket{1}$ are represented by the vectors \ket{0}=\left[\begin{array}[]{c}1\\ 0\end{array}\right] and \ket{1}=\left[\begin{array}[]{c}0\\ 1\end{array}\right]

The qubit can be in an ”on” or ”off” states as in the classical Boolean computers or in any combination of the ”on-off” states : $\textbf{x}=\alpha\ket{0}+\beta\ket{1}$ , where $\sqrt{\alpha^{2}+\beta^{2}}=1$. To represent a classical digital system the qubit $\ket{0}$ and $\ket{1}$ are sufficient. Figure 2 shows the commonly used quantum gates, all quantum gates are reversible and the input can be reconstructed from the output by applying the gate twice. Figure 3 shows an example using the Toffoli gate, the input can be reconstructed by applying the Toffolli gate twice.

In this paper we propose a technique to implement a binary logic circuit using a quantum gates, and thus only the $\ket{0}$ and $\ket{1}$ states of the qubit are utilised. In classical Boolean circuits, the NAND gate is a universal gate and all other Boolean gates could be constructed using one or more NAND gates[27]. Any Boolean logic circuit can be designed using reversible quantum gates, the logic gates presented in Figure 1 can be constructed using a combination of the NOT, CNOT and Toffoli gates, thus the NOT-CNOT-Tofolli gates form a universal basis for quantum circuit implementation [19, 31, 5]. Figure 4 shows quantum reconstruction of the NAND gate using a Toffoli gate, the quantum equivalent requires an extra bit ( i.e ancillary bit ).The rest of the boolean gates can be synthesised using the NOT-CNOT-Tofolli bases.

Thus any Boolean function can be synthesised by simply replacing each Boolean gate by its quantum counterpart. However this approach is hardly efficient and leads to a significant number of ancillary bits [17, 30]. In literature several approaches have been proposed [12, 7, 25, 24, 29, 28] to synthesise a given Boolean function with minimal number of ancillary bits. Most of the approaches rely on heuristic methods to minimise the costs of the resulting circuits using complex function manipulation [11]. In this paper we present an exact method to realise the quantum implementation of any classical binary system. The technique (we call Q-Map) is analogous to the Karnaugh Map [27] for classical logic gate minimisation technique. The main contribution of this paper is as follows:

• •

We propose a visual method to synthesise any Boolean functions without having to resort to complex function decomposition and manipulation.

• •

We demonstrate the algorithm by implementing the 4-bit Gray Code Encoder using QISKIT.

Quantum-Map technique

In our proposed approach, the problem is modelled as a quantum circuit with $n$ input quantum bits ($\ket{q_{0},q_{1},...,q_{n-1}}$) that represents the initial state of every qubit and $n$ output quantum bits ($\ket{q_{0}^{{}^{\prime}},q_{1}^{{}^{\prime}},...,q_{n-1}^{{}^{\prime}}}$) that represent the final state of each bit (see Fig. 5 (a)). The quantum circuit is further decomposed into a series of $n$ cascaded stages . Each stage is a quantum circuit with $n$ input qubits represented by the vector $\textbf{V}_{i}$ and $n$ output qubits represented by the vector $\textbf{V}_{i}^{{}^{\prime}}$ where qubit $\ket{q_{i}}$ is altered and the rest of the qubits are unaltered, the stages are presented in Fig. 5 (b).

The relationship between the input vector and the output qubit at stage $i$ is defined by a control function $\textbf{U}_{q_{i}}:\mathbb{B}^{n}\longrightarrow\mathbb{B}^{n}$ as follows:

[TABLE]

Where $\textbf{U}_{q_{i}}$ is a control function that computes a new value at the target output $q_{i}$ and leaves all other variables unaltered. Equation 1 can be expanded as:

[TABLE]

As presented in Equation 2, the input vector $\textbf{V}_{0}=\ket{q_{0}q_{1}q_{2}q_{3}\dots q_{n-1}}$ includes all qubits, thus the quantum circuit $\textbf{U}_{q_{0}}$ will calculate $q_{0}^{{}^{\prime}}$ (i.e the next state of $q_{0}$) as a function of $n$ qubits. The output vector $\textbf{V}_{0}^{{}^{\prime}}=\ket{q_{0}^{{}^{\prime}}q_{1}q_{2}q_{3}\dots q_{n-1}}$ is an $n$ qubit vector where only qubit $q_{0}$ is changed to $q_{0}^{{}^{\prime}}$ based on value of the control function $\textbf{U}_{q_{0}}$ and the rest of the qubits are unchanged. To calculate $q_{1}^{{}^{\prime}}$, the output qubit from the previous stage will be used. In general, the input vector for any stage $k$ is the vector $\textbf{V}_{k}=\ket{q_{0}^{{}^{\prime}}q_{1}^{{}^{\prime}}\dots q_{k-1}^{{}^{\prime}}q_{k}\dots q_{n-1}}$ and the output is the vector $\textbf{V}^{{}^{\prime}}_{k}=\ket{q_{0}^{{}^{\prime}}q_{1}^{{}^{\prime}}\dots q_{k-1}^{{}^{\prime}}q_{k}^{{}^{\prime}}\dots q_{n-1}}$.

To calculate $\textbf{U}_{q_{i}}$ for each stage, we follow a function minimisation approach inspired by the Karnaugh Map technique [27] for Boolean function minimisation. Our proposed approach starts by building a logic map for the function to be minimised we call it the Quantum Map (Q-Map). The Q-Map is a two-dimensional array of cells used to represent a switching function. The switching function $T(q_{i})$, presented in Table 1, represents the toggle state of a qubit from the present state $q_{i}$ to the next state $q^{{}^{\prime}}_{i}$ (i.e toggle from $\ket{0}$ to $\ket{1}$ or from $\ket{1}$ to $\ket{0}$). The function $T(q_{i})$ can be represented as the logical XOR of the current state $q_{i}$ with the next state $q_{i}^{{}^{\prime}}$ as presented in Table 1.

$T(q_{i})$ is a function of $n$ qubits denoted by $\ket{q_{0}q_{1}\dots q_{n-1}}$, the Q-Map of the stage $\textbf{U}_{q_{i}}$ is composed of two vectors $\textbf{S}_{1}=\ket{q_{n-1}\dots q_{k}}$ and $\textbf{S}_{2}=\ket{q_{k-1}\dots q_{0}}$ with a row for each assignment of $\textbf{S}_{1}$ for a total of $2^{n-k-1}$ and with a column for each assignment of $\textbf{S}_{2}$ for a total of $2^{k}$ columns. Similar to the Karnaugh Map, the adjacency condition is established by labelling the rows and the columns such that for any $2^{r}$ adjacent rows ( or columns) differ only in $r$ variables. Fig. 6 shows the Q-Map to find the quantum circuit with four variables. In each cell the corresponding value of the switching function $T(q_{i})$ is inscribed. Using the Q-Map, a minimal expression $T(q_{i})$ is calculated for each qubit. And finally the quantum circuit is implemented using the $\bf{NOT-CNOT-Toffoli}$ quantum gate basis.

To demonstrate our proposed approach, we present a quantum circuit implementation of the Gray Code to Binary converter. The details of proposed algorithm with the reversible circuit implementation are presented in the next section.

Implementation of the Gray Code Encoder

In this section we demonstrate the technique by implementing the Gray Code to Binary converter. The Gray Code is used in many applications such as position control systems, communications and many other areas [16]. The Gray code provides a binary code that changes by one bit only when it changes from one state to the next. The Gray code and the corresponding decimal unsigned binary equivalent is shown in Table 2.

The first step starts by building the switching function $T(q_{i})$ for each quantum bit as described in Table 1. The function $T(q_{i})$ for each qubit is calculated as:

[TABLE]

The result is presented in Table 3

The second step is to establish the Q-Map for each qubit. Figure 7 (a) shows the Q-Map to evaluate ${q_{0}}$ given the values of the input ${q_{1}}$, ${q_{2}}$ and $q_{3}$. A value of $1$ in the Q-Map represents the state of ${q_{1}}$, $q_{2}$ and ${q_{3}}$ when ${q_{0}}$ toggles its state. Thus ${q_{0}}$ will toggle its state when the following expression is true:

[TABLE]

Figure 7 (b) shows the Q-Map to find $T(q_{1})$. The expression is calculated based on inputs $q_{3}$, $q_{2}$ and $q_{0}^{{}^{\prime}}$ as follows:

[TABLE]

Figure 7 (c) shows the Q-Map to find $T(q_{2})$. The expression is calculated based on inputs $q_{3}$, $q_{1}^{{}^{\prime}}$ and $q_{0}^{{}^{\prime}}$ as follows:

[TABLE]

Finally, figure 7 (d) shows the Q-Map to find $T(q_{3})$. The expression is calculated based on the inputs $q_{2}^{{}^{\prime}}$, $q_{1}^{{}^{\prime}}$ and $q_{0}^{{}^{\prime}}$ as follows:

Notice here we use the XOR ($\oplus$) operation and the function $T(q_{i})$ is represented in Exclusive-OR Sum-of-Product form (ESOP) form since the qubit will toggle only if we have an odd number of true terms. For even number of true terms the qubit will retain its initial state. In classical Boolean function minimisation using Karnaugh Map the logic OR ($+$) operation is used and the function is expressed in Sum of Product (SOP) form since the Boolean function will be true if any of the terms is true and so group overlap is allowed.

In our proposed Q-Map approach group overlap is not allowed, this makes all terms in every function $T(q_{i})$ mutually exclusive and only one term can be true at one instant of time. Thus the XOR ($\oplus$) operation can be replaced by the OR ($+$) operation and the function $T(q_{i})$ can be represented in the Sum of Product (SOP) form. Since each Q-Map in Figure 7 contains no overlapping groups, the functions can be represented in Sum of Product (SOP) form as follows:

[TABLE]

The functions presented in Equation 10 can be realised by a reversible circuit with only four lines (i.e. $O(n)$ lines) using the NOT-CNOT-Toffoli bases with Multi-Control Toffolli gates [22]. This means that the implementation is efficient and no temporary lines (also referred as ancilla) are needed. The quantum circuit can be implemented using CNOT and two and three input Toffoli gates as shown in Figure 8.

The quantum circuit is also simulated using QISKIT open-source framework simulator for quantum circuit [1, 26]. In QISKIT, the Toffoli gate is composed of two control inputs and one output. To implement the circuit in Figure 8, we redesigned the quantum circuit to include 2-input Toffoli gates; however an additional ancillary qubit is needed to store the intermediate values. The design with 2-input Toffoli gates is presented in Figure 9. The code to simulate the qunatum gray to binary converter is presented in Figure 11.

The Q-Map algorithm can be summarised as follows:

• Step 1: For each qubit $q_{i}$ build the toggle function $T(q_{i})=q_{i}\oplus q_{i}^{{}^{\prime}}$ as the logical Exclusive-OR of the present state $q_{i}$ and the final state $q_{i}^{{}^{\prime}}$.
• **Step **2 :Establish the Q-Map of the switching function $T(q_{i})$ as a function of the $n$ qubits $(q_{0}^{{}^{\prime}},q_{1}^{{}^{\prime}},\dots,q_{i-1}^{{}^{\prime}},q_{i}\dots,q_{n-1})$ .
• Step 3: In each cell inscribe the value of $T(q_{i})$ in the Q-Map.
• Step 4: Find the expression of $T(q_{i})$ in Sum-Of-Product form using the Q-Map such that:

1. Groups should be as large as possible

2. Group Overlapping is not allowed

• Step 5: For each expression $T(q_{i})$ use the CNOT-NOT-Toffoli bases to implement the corresponding quantum circuit.

Q-Map optimisation

In classical boolean function minimsation using the Karnaugh map, the entry inscribed in every cell indicates the value of the boolean function at the corresponding state. However in our proposed approach, the entry inscribed in each cell in the Q-map indicates change of state of the function. An entry of $1$ in th Q-map indicates that the function must change state (i.e toggle) and a value of [math] indicates the function must remain in the same state. Thus including the $1^{\prime}s$ in the Q-map in an odd number of groups will result in one change of state and including the $0^{\prime}s$ in even number of groups will result in no change of state. This property of the Q-map could be used in our advantage to maximise the number of Q-map cells in each group and produce a more simplified expression that minimises the quantum cost of the design.

The optimised Q-Map algorithm can be summarised as follows:

• Step 1: For each qubit $q_{i}$ build the toggle function $T(q_{i})=q_{i}\oplus q_{i}^{{}^{\prime}}$ as the logical Exclusive-OR of the present state $q_{i}$ and the final state $q_{i}^{{}^{\prime}}$.
• **Step **2 :Establish the Q-Map of the switching function $T(q_{i})$ as a function of the $n$ qubits $(q_{0}^{{}^{\prime}},q_{1}^{{}^{\prime}},\dots,q_{i-1}^{{}^{\prime}},q_{i}\dots,q_{n-1})$ .
• Step 3: In each cell inscribe the value of $T(q_{i})$ in the Q-Map.
• Step 4: Find the expression of $T(q_{i})$ in Sum-Of-Product form using the Q-Map such that:

Groups should be as large as possible and may include $1^{\prime}s$ and $0^{\prime}s$. 2. 2.

Every $1$ must be included in an odd number of groups 3. 3.

If a [math] is included, it must be included in an even number of groups

• Step 5: For each expression $T(q_{i})$ use the CNOT-NOT-Toffoli bases to implement the corresponding quantum circuit.

To demonstrate the idea, we re-evaluate the functions produces in the Q-map of Figure 7 as shown in Figure 12 and the functions presented in Eq. 10 can be replaced by :

[TABLE]

Other alternative designs are possible, for example, $T(q_{1})$ can be also written as $\bar{q_{2}}+\bar{q_{3}}$.

Based on the functions in Eq.11, the quantum circuit can be designed as presented in Figure 13 and the corresponding QISKIT code is shown in Figure 14. The optimised approach re-designed the quantum circuit with no ancillary bits and significantly reduced the number of quantum gates.

Conclusion

In this paper we propose a visual method for quantum realisation of classical Boolean logic functions. The proposed method utilise concepts from Boolean algebra to produce a quantum circuit with minimal number of quantum gates. The proposed technique is composed of three steps: (1) for each quantum bit $q_{i}$ build a switching function $T(q_{i})$, (2) establish the Q-Map for $T(q_{i})$ and (3) using the Q-Map find the quantum expression to implement the switching function using the NOT-CNOT-Toffoli quantum gate basis.The proposed method is demonstrated by implementing the Gray-Code Encoder.