# Subspace projection method for unstructured searches with noisy quantum oracles using a signal-based quantum emulation device

- 598 Downloads
- 1 Citations

## Abstract

This paper describes a novel approach to solving unstructured search problems using a classical, signal-based emulation of a quantum computer. The classical nature of the representation allows one to perform subspace projections in addition to the usual unitary gate operations. Although bandwidth requirements will limit the scale of problems that can be solved by this method, it can nevertheless provide a significant computational advantage for problems of limited size. In particular, we find that, for the same number of noisy oracle calls, the proposed subspace projection method provides a higher probability of success for finding a solution than does an single application of Grover’s algorithm on the same device.

### Keywords

Quantum computing Quantum search Grover’s algorithm Analog electronics## 1 Introduction

A great many problems can be described in terms of a general Boolean function \(f:\{0, \ldots , 2^n-1\} \mapsto \{0,1\}\) mapping an *n*-bit integer to a single bit and for which \(f(x) = 1\) indicates a solution [9]. The general problem is, then, to determine the number of solutions, if any, and their respective values. In the absence of any structural information regarding *f*, the general solution requires the evaluation of *f* for all \(2^n\) possible inputs. Clearly, the complexity of this problem grows exponentially in the number of input bits.

Suppose that *f* can be evaluated in a number of steps that scale only polynomially in *n*. The problem of determining whether a solution exists falls within the complexity class NP (Nondeterministic Polynomial), while finding the total number of solutions falls within the complexity class #P [2, 10]. In this paper, we shall be concerned with the most general problem of determining the number and values of all solutions.

A quantum computer implementing Grover’s search algorithm would be capable of a quadratic speedup in unstructured searches, but for problems that fall outside the complexity class P this approach is still inefficient [13, 22]. In the absence of quantum error correction, decoherence and noise may further degrade performance [19, 25, 26, 27]. Abrams and Lloyd have noted that a nonlinear quantum computer could solve such problems efficiently [3], but no such nonlinearity in quantum phenomena has been observed experimentally [6, 20, 29, 30]. Along similar lines, Ohya and Volovich have suggested that a *chaotic* quantum computer would allow a solution in polynomial time [23, 24], but no practical implementation of this scheme is yet known. Nuclear magnetic resonance (NMR) bulk-ensemble computing offers an alternative approach to solving unstructured search problems that is practically implementable for a few dozen qubits and capable of an exponential speedup [7, 31] Quantum annealing has also been used to solve certain NP-complete problems that can be represented as quadratic binary optimization (QUBO) problems [11, 12, 15], but it is not known whether this approach is intrinsically more efficient than Grover’s search algorithm or even standard classical methods [14]. Finally, Khatri and coworkers have developed a novel noise-based logic scheme to solve Boolean satisfiability problems using an orthogonal basis of independent classical noise processes [18].

Recently, a classical, signal-based scheme was proposed for emulating a gate-based quantum computer. Using a set of sinusoidal signals to represent individual qubits, a quadrature-modulated tonal (QMT) representation of the quantum state may be constructed that reproduces the Hilbert space structure of a multi-qubit quantum computer [17]. For a signal represented as a time-varying electronic voltage, standard analog electronic devices may be used to construct the quantum state, manipulate it through a sequence of gates, and perform a measurement resulting in a digital output. An analog emulation of this sort differs significantly from a traditional digital simulation in that it provides an explicit physical representation of states within the Hilbert space, and the operations upon them, thereby giving rise to a fundamentally different computational model. Since the information is encoded in the frequency domain and the signal may be of bounded amplitude, the required power will be independent of the number of qubits represented. By contrast, although sophisticated digital simulations of up to 40 qubits have been performed on large, high-performance computers, they are bulky and require several megawatts of power to operate [28].

The ability to emulate a quantum computer classically comes with certain additional freedoms and restrictions. Aaronson has shown, for example, that a quantum computer with access to a history of hidden-variables is capable of performing an unstructured search faster than Grover’s algorithm [1]. However, a classical emulation is not necessarily restricted to unitary operations on the state. In particular, projections and inner products may be performed explicitly, allowing one to extract components of the quantum state that would otherwise be inaccessible via unitary evolution and measurement alone. This confers a significant computational advantage in terms of the number of operations needed to perform a search. Since, in our QMT representation, the Hilbert space is embedded in the frequency domain of the signal, bandwidth becomes the primary limitation. Nevertheless, quite large problems (on the order of 40 qubits) could be represented by this scheme, and hybrid schemes may be used to solve larger problems while still taking advantage of the inherent features of quantum parallelism and superposition [8].

In an effort to demonstrate the feasibility of this approach, we have developed a fully programmable hardware prototype device capable of emulating a two-qubit quantum computer implementing a universal set of gate operations with over 99% fidelity [16]. Scaling to larger numbers of qubits would require bandwidths and physical components that scale exponentially by roughly a factor of 1000 for every 10 additional qubits. Exisiting semiconductor manufacturing technologies can place over a billion transistors on a single integrated circuit chip, which is sufficient to emulate about 30 qubits using our approach. Future manufacturing capabilities are expected to extend this to perhaps 40 qubits within the next decade. Unlike traditional analog computers, a quantum emulation device would also be capable, if need be, of implementing standard quantum error correction protocols, albeit at the cost of additional qubits and, hence, bandwidth, so that fault-tolerant operation may, in principle, be possible.

This paper will examine the relative advantages and trade-offs for such an approach as compared to either classical brute-force searches or applications of Grover’s algorithm. Since gate fidelity will be important in determining the efficacy of each approach, we consider the inclusion of additive white complex Gaussian noise to the emulating signal, which reproduces the effect of a depolarizing channel. Performance is then assessed as a function of the overall fidelity or, equivalently, the signal-to-noise ratio (SNR).

The organization of the paper is as follows. In Sect. 2, we introduce the general subspace projection method used to solve the Boolean function problem for one solution and multiple solutions. Section 3 defines a general noisy quantum oracle that may be used to represent any given Boolean function in terms of its solutions. An assessment of relative performance is described and analyzed in Sect. 4, and our conclusions are summarized in Sect. 5.

## 2 Subspace projection method

### 2.1 QMT representation

*x*. Thus, a given quantum state \(|\psi \rangle \) with components \(\alpha _{x,y} \in {\mathbb {C}}\) is represented by

In addition to the usual unitary gate operations, the QMT representation also allows for the construction of projections onto signal subspaces through the use of specialized bandpass filters. This provides a unique capability to “disentangle” entangled (i.e., nonseparable) states and is the primary mechanism upon which the subspace method of solution is based. In the following sections, we describe how this method may be used to solve Boolean problems of one or more solutions.

### 2.2 Problems with one solution

*f*and such that, for a given basis state \(|x,y\rangle \), where \(x \in \{0, \ldots , N-1\}\) and \(y \in \{0,1\}\), we have

*N*. Using our classical signal-based representation, one may perform a projection onto the subspace of qubit 0 corresponding to the output register value of \(|1\rangle \), denoted \(|\psi \rangle = \varPi _1^{(0)} |\psi ^{\prime }\rangle \), to obtain

*a*is thereupon read off from the value of the input register using

*n*single-qubit measurement gates.

Of course, even in a classical QMT representation, the solution component of the signal has an amplitude that is \(N-1\) times smaller than that of the nonsolution component, so discrimination between the two remains a similar challenge. The question we ask is whether, in a practical setting, a classical subspace projection approach may provide computational gain over other classical or quantum alternatives. Before examining this question, however, we turn to a generalization of the single-solution problem.

### 2.3 Problems with multiple solutions

Consider an *n*-bit Boolean function *f* such that, for \(x \in \{0, \ldots , N-1\}\) and \(M \in \{0, \ldots , N\}\), we have \(f(x) = 1\) if \(x \in \{a_1, \ldots , a_M\} = {\mathcal {S}}\) and \(f(x) = 0\) otherwise. Each element of \({\mathcal {S}}\) is assumed unique, so \(a_j = a_{j^{\prime }}\) only if \(j=j^{\prime }\). We also consider the possibility that \(M = 0\), in which case \(f(x) = 0\) for all *x*. As before, let \(U_f\) denote the corresponding unitary transformation.

*M*solutions. If the number of solutions is known, the procedure of preparation, projection, and measurement may be repeated \({\mathcal {O}}(M)\) times to obtain all

*M*solutions.

### 2.4 Finding the number of solutions

*n*cosines, with frequencies \(\omega _1, \ldots , \omega _n\) and a complex exponential of the form \(\mathrm {e}^{-\mathrm {i}\omega _0t}\). The inner product of the state \(|\phi \rangle \) with the projection state \(|\psi \rangle \) gives the number of solutions, since

*M*solutions have been extracted.

## 3 General quantum oracles

In order to realize the algorithm for a particular instance of the Boolean function *f*, we must construct a corresponding quantum oracle. The details of how such an oracle may be constructed from more elementary gate operations are problem specific and typically based on a reversible-logic formulation of the Boolean function itself. Here we will abstract the details of any particular oracle and consider instead a template construction for an arbitrary oracle given a set of solutions as defining parameters. We note that the use of quantum oracles with planted solutions is done solely for purposes of analysis; no knowledge of the solutions is used by the algorithms themselves.

### 3.1 Ideal quantum oracles

*n*-bit integer \(a \in \{0, \ldots , N-1\}\) with a little-endian binary representation such that \(a = [a]_{n-1} 2^{n-1} + \cdots + [a]_0 2^{0}\). The corresponding Boolean function is implemented by the unitary operator

*n*-fold Toffoli gate with control qubits 1 through

*n*and target qubit 0. The operator \(\varvec{\mathsf {A}}\) is defined by the parameter

*a*such that

*n*-fold Toffoli gate to be decomposed into \(48n^2 + {\mathcal {O}}(n)\) one- and two-qubit gate operations, although the inclusion of at least one ancilla qubit can reduce this size to \({\mathcal {O}}(n)\) [4]. A QMT representation of the

*n*-fold Toffoli gate may be realized more simply by applying narrowband filters to the frequencies \(\varOmega _{N-1,0}\) and \(\varOmega _{N-1,1}\) and then physically swapping the coefficients \(\alpha _{N-1,0}\) and \(\alpha _{N-1,1}\), represented by the DC filter outputs, to obtain

### 3.2 Noisy oracles

*w*denote an additive white noise complex Gaussian process with power spectral density \(\sigma ^2\) such that \(E[w(t)] = 0\) and \(E[w(t^{\prime })^*w(t)] = \sigma ^2 \delta (t^{\prime }-t)\). Filtering onto the 2

*N*component frequencies forms a projected state \(|\nu \rangle \) of the form

*N*-dimensional identity operator [17]. The fidelity

*F*is therefore given by

*F*depends only on

*N*and the SNR value \(S^2 = s^2T/\sigma ^2\). Equivalently, we may specify the value of \(\sigma ^2\) needed for a given

*F*to be

### 3.3 Noisy solution estimates

*M*and variance \(N^2 \sigma ^2/(s^2 T)\). Thus, \(|{\tilde{M}}|\) has a Rician distribution with mean

*m*from this estimate is therefore

## 4 Comparison of methods

Ideally, the subspace projection method always gives a correct answer with a single application of the oracle. This is in contrast to a brute-force search, which requires \({\mathcal {O}}(N)\) oracle calls, or Grover’s search algorithm, which gives the correct answer with an error of \({\mathcal {O}}(1/N)\) using \({\mathcal {O}}(\sqrt{N})\) oracle calls. Imperfect gate operators will, however, degrade search performance. In this section, we will use the noisy oracle model to compare the performance of the subspace projection method to that of both Grover’s algorithm and a simple, brute-force search when the number of solutions is known.

### 4.1 Brute-Force approach

*x*,

*y*). What is the probability that \((x,y) = (a,1)\)? If we use \(|\tilde{\psi }\rangle \) to determine probabilities according to the Born rule and use, say, an independent, uniformly distributed random variable \(u \in [0,1]\) to determine the outcome, then the probability of success for a particular realization is

*N*) for \(s^2T/(N\sigma ^2) \ll 1\).

*N*times to yield a total probability for at least one success of

*N*, and keeping all other parameters fixed, \(P_B\) tends to the value \(1-\mathrm {e}^{-1/2} \approx 0.3935\).

### 4.2 Subspace projection method

*N*. The latter result indicates that the probability of success falls off twice as slowly as that of the brute-force approach as a consequence of the fact that the output register has been projected onto the \(|1\rangle \) state.

*N*solutions will have the output qubit flipped. Nevertheless, the subspace with \(y = 1\) onto which we project constitutes about half of the valid solutions.

The case of no solutions (i.e., \(M = 0\)) is special. If \(\sigma > 0\), then the subspace for which \(y = 1\) will not be entirely empty, due to noise, and so there is a nonzero probability of obtaining a solution, albeit an erroneous one. Thus, the probability of obtaining a correct solution is zero, as predicted by Eq. (39). If there is no noise (i.e., \(\sigma = 0\)), then \(\varPi _1^{(0)} \rho \varPi _1^{(0)}\) is the zero operator and no longer constitutes a normalizable mixed state. For this special case (\(M = 0\), \(\sigma = 0\)), we simply *define*\(p_S\) to be zero, as this is the limiting value of \(p_S\) as \(\sigma \rightarrow 0\).

*N*times, we will have a total probability of at least one success of

*N*, provided \(p_S > 0\) and all other parameters are held fixed.

### 4.3 Grover’s search algorithm

*R*iterations of the (ideal) Grover operator \(\varvec{\mathsf {G}}\) and a final \(\varvec{\mathsf {H}}_0\) to obtain, for a single solution, the final state

*f*(

*x*) is replaced by \(1-f(x)\), in which case \(R = \lfloor \pi \sqrt{(N-M)/M}/4\rfloor \) is optimal. Otherwise, the procedure is the same, and the final state after

*R*iterations of a noisy Grover operator is

Unlike that of \(p_B\) and \(p_S\), we note that there is no simple relationship between \(p_G\) and \(p_S\). For some parameter values \(p_G > p_S\), for others \(p_G < p_S\), and in certain special cases (e.g., \(M=0\) or \(M=N\)) the two are identical. As the SNR tends to zero (\(S^2 \rightarrow 0\)), \(p_S\) tends to *M* / *N*, whereas \(p_G\) tends to half this value. As the SNR becomes large (\(S^2 \gg 1\)), we find that \(p_S\) tends to unity, as expected, whereas \(p_G\) tends to a possibly smaller limiting value of \(\sin ^2(R\theta +\theta /2)\). Thus, \(p_S \ge p_G\) in these two limits. For intermediate SNR values, it is possible that \(p_S < p_G\).

*S*.

*R*. Suppose, though, the subspace method is repeated \(R+1\) times. In this case, the overall probability of success (i.e., of obtaining at least one valid solution) is

*n*,

*M*, and

*S*. Thus, for the same computational effort, the subspace method appears to provide equal or better performance to Grover’s algorithm. This result does not, however, conflict with the well-established optimality of Grover’s algorithm, as the latter is based on a constraint of unitary gate operations, one to which the proposed classical representation is not bound [5].

While a comparison of the subspace projection method to Grover’s algorithm is relatively straightforward, a similar comparison to a digital solver proves somewhat more challenging. We may imagine that a digital device performs an ideal brute-force search with near-infinite SNR, giving a probability of success of \(p_B = M/N\) for any particular instance. To place this approach on the same footing as that of the other two methods, we may restrict the number of oracle calls to \(R+1\) so that the probability of obtaining at least one valid solution is \(1-(1-M/N)^{R+1}\). Since \(p_S \ge M/N\), this is still no better than the subspace projection method and will be better than Grover’s algorithm only for low-SNR oracles.

More challenging still is a comparison in terms of absolute solution time. Current digital processors operate at near GHz clock speeds, giving each fundamental logic operation an execution time on the order of a nanosecond. Memory access times can extend this time to tens of nanoseconds. A quantum emulation device implementing the subspace projection algorithm with, say, 10 qubits in the frequency range of 1 MHz to 1 GHz would have a gate operation time on the order of a microsecond but would evaluate a thousand digital inputs at once, giving it an effective speed at least equivalent to that of the digital processor. Thus, it is reasonable to suppose that the algorithmic advantage observed in terms of the number of required oracle calls would indeed translate into an actual speed advantage for computation.

## 5 Conclusion

This paper has introduced a novel approach to performing unstructured searches using a classical emulation of a gate-based quantum computer. In this approach, the classical, signal-based representation of quantum states allows for a direct computation of subspace projection operations, thereby allowing additional computational capability beyond the application of unitary gate operations. The price paid for this capability is a limitation in scale, due to bandwidth constraints, but this by no means nullifies the utility of the approach.

Under ideal conditions, the proposed subspace projection method is capable of finding a solution in an unstructured search using a single oracle call, independent of the size of the problem. Under more realistic conditions, however, the approach will be hampered by noise and other imperfections such that a solution may be found only with a certain probability of success. The computation may then be repeated to improve the overall success probability. The number of solutions may also be estimated by this method, and, unlike Grover’s algorithm, the probability of success will not be sensitive to this estimate.

To understand the efficacy of this approach in a realistic setting, we have compared the probability of success of the proposed subspace projection method to that of a simple, brute-force search or application of Grover’s search algorithm, modeling the imperfections as a noisy oracle. In order to facilitate comparison across the three methods, we have ignored errors in both the projection and Grover diffusion operations under the simplifying assumption that the oracle is the dominant source of error. For an unstructured search, a single instance of the subspace projection method always provides a better probability of success, not surprisingly, than the brute-force approach using a single oracle call. A single instance of Grover’s algorithm tends to provide a higher probability of success for intermediate values of the noisy oracle’s signal-to-noise ratio, albeit with many more oracle calls. Interestingly, when repeated instances of the subspace projection method are considered, it was found that for the same total number of oracle calls the subspace projection method provides a higher probability of success than does Grover’s algorithm.

## Notes

### Acknowledgements

This work was support by the Office of Naval Research under Grant No. N00014-14-1-0323.

### References

- 1.Aaronson, S.: Quantum computing and hidden variables. Phys. Rev. A
**71**, 032,325 (2005)MathSciNetCrossRefMATHGoogle Scholar - 2.Aaronson, S.: Quantum Computing Since Democritus. Cambridge University Press, Cambridge (2013)CrossRefMATHGoogle Scholar
- 3.Abrams, D.S., Lloyd, S.: Nonlinear quantum mechanics implies polynomial-time solution for NP-Complete and #P problems. Phys. Rev. Lett.
**81**, 3992 (1998)ADSCrossRefGoogle Scholar - 4.Barenco, A., Bennett, C.H., Cleve, R., DiVincenzo, D., Margolus, N., Shor, P., Sleator, T., Smolin, J.A., Weinfurter, H.: Elementary gates for quantum computation. Phys. Rev. A
**52**, 3457 (1995)ADSCrossRefGoogle Scholar - 5.Bennett, C.H., Bernstein, E., Brassard, G., Vazirani, U.: The strengths and weaknesses of quantum computation. SIAM J. Comput.
**26**, 1510 (1997)CrossRefMATHGoogle Scholar - 6.Bollinger, J.J., Heinzen, D.J., Itano, W.M., Gilbert, S.L., Wineland, D.J.: Test of the linearity of quantum mechanics by RF spectroscopy of the 9Be+ ground state. Phys. Rev. Lett.
**63**, 1031 (1989)ADSCrossRefGoogle Scholar - 7.Brüschweiller, R.: Novel strategy for database searching in spin Liouville space by NMR ensemble computing. Phys. Rev. Lett.
**85**, 4815 (2000)ADSCrossRefGoogle Scholar - 8.Cheng, S.T., Tao, M.H.: Quantum cooperative search algorithm for 3-SAT. J. Comput. Syst. Sci.
**73**, 123–136 (2007)MathSciNetCrossRefMATHGoogle Scholar - 9.Crama, Y., Hammer, P.L.: Boolean Functions: Theory, Algorithms, and Applications. Cambridge University Press, Cambridge (2011)CrossRefMATHGoogle Scholar
- 10.Du, D.Z., Ko, K.I.: Theory of Computational Complexity. Wiley, Hoboken (2014)CrossRefMATHGoogle Scholar
- 11.Farhi, E., Goldstone, J., Gutmann, S., Lapan, J., Ludgren, A., Preda, D.: Quantum adiabatic evolution algorithm applied to random instances of an NP-complete problem. Science
**292**, 472 (2001)ADSMathSciNetCrossRefMATHGoogle Scholar - 12.Finilla, A.B., Gomez, M.A., Doll, D.J.: Quantum annealing: a new method for minimizing multidimensional functions. Chem. Phys. Lett.
**219**, 343 (1994)ADSCrossRefGoogle Scholar - 13.Grover, L.K.: A fast quantum mechanical algorithm for database search. In: Proceedings of the 28th Annual ACM Symposium on the Theory of Computing, p. 212. (1996)Google Scholar
- 14.Heim, B., Rønnow, T.F., Isakov, S.V., Troyer, M.: Quantum versus classical annealing of Ising spin glasses. Science
**348**, 215 (2015)ADSMathSciNetCrossRefGoogle Scholar - 15.Kadowaki, T., Nishimori, H.: Quantum annealing in the transverse Ising model. Phys. Rev. E
**58**, 5355 (1998)ADSCrossRefGoogle Scholar - 16.La Cour, B.R., Ostrove, C.I., Ott, G.E., Starkey, M.J., Wilson, G.R.: Classical emulation of a quantum computer. Int. J. Quantum Inf.
**14**, 1640,004 (2016)MathSciNetCrossRefMATHGoogle Scholar - 17.La Cour, B.R., Ott, G.E.: Signal-based classical emulation of a universal quantum computer. New J. Phys.
**17**, 053,017 (2015)MathSciNetCrossRefGoogle Scholar - 18.Lin, P.C.K., Mandal, A., Khatri, S.P.: Boolean satisfiability using noise based logic. In: Proceedings of the 49th Annual Design Automation Conference, p. 1260. (2012)Google Scholar
- 19.Long, G.L., Li, Y.S., Zhang, W.L., Tu, C.C.: Dominant gate imperfections in Grover’s quantum search algorithm. Phys. Rev. A
**61**, 042,305 (2000)CrossRefGoogle Scholar - 20.Majumder, P.K., Venema, B.J., Lamoreaux, S.K., Heckel, B.R., Fortson, E.N.: Test of the linearity of quantum mechanics in optically pumped 201 hg. Phys. Rev. Lett.
**65**, 2931 (1990)ADSCrossRefGoogle Scholar - 21.Marcum, J.I.: Table of Q Functions. Technical Report, RAND Corporation, Santa Monica, CA. U.S. AirForce RAND Research Memorandum M-339 (1950)Google Scholar
- 22.Nielsen, M.A., Chuang, I.L.: Quantum Computation and Quantum Information. Cambridge University Press, Cambridge (2000)MATHGoogle Scholar
- 23.Ohya, M., Volovich, I.V.: New quantum algorithm for studying NP-complete problems. Rep. Math. Phys.
**52**, 25–33 (2003)ADSMathSciNetCrossRefMATHGoogle Scholar - 24.Ohya, M., Volovich, I.V.: Quantum computing and the chaotic amplifier. J. Opt. B
**5**, S639 (2003)ADSMathSciNetCrossRefGoogle Scholar - 25.Pablo-Norman, B., Ruiz-Altaba, M.: Noise in Grover’s quantum search algorithm. Phys. Rev. A
**61**, 012,301 (1999)CrossRefGoogle Scholar - 26.Salas, P.J.: Noise effect on Grover algorithm. Eur. Phys. J. D
**46**, 365 (2008)ADSCrossRefGoogle Scholar - 27.Shenvi, N., Brown, K.R., Whaley, K.B.: Effects of a random noisy oracle on search algorithm complexity. Phys. Rev. A
**68**, 052,313 (2003)CrossRefGoogle Scholar - 28.Smelyanskiy, M., Sawaya, N.P.D., Aspuru-Guzik, A.: qHiPSTER: the quantum high performance software testing environment. arXiv:1601.07195
- 29.Walsworth, R.L., Silvera, I.F., Mattison, E.M., Vessot, R.F.C.: Test of the linearity of quantum mechanics in an atomic system with a hydrogen maser. Phys. Rev. Lett
**64**, 2599 (1990)ADSCrossRefGoogle Scholar - 30.Weinberg, S.: Precision tests of quantum mechanics. Phys. Rev. Lett.
**62**, 485 (1989)ADSCrossRefGoogle Scholar - 31.Xiao, L., Long, G.L.: Fetching marked items from an unsorted database in NMR ensemble computing. Phys. Rev. A
**66**, 052,320 (2002)CrossRefGoogle Scholar

## Copyright information

**Open Access**This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.