User:Marcz1001/sandbox

Quantum Query Complexity
One major advantage of using a quantum computational system instead of a classical one, is that a quantum computer may be able to give a polynomial time algorithm for some problem for which no classical polynomial time algorithm exists, but more importantly, a quantum computer may significantly decrease the calculation time for a problem that a classical computer can already solve. Essentially, a quantum computer may be able to both determine how long it will take to solve a problem, while a classical computer may be unable to do so, and can also greatly improve the computational efficiency associated with the solution to a particular problem. Quantum query complexity refers to how complex, or how many queries to the graph associated with the solution of a particular problem, are required to solve the problem. Before we delve further into query complexity, let us consider some background regarding graphing solutions to particular problems, and the queries associated with these solutions.

Query Models of Directed Graphs
One type of problem that quantum computing can make easier to solve are graph problems. If we are to consider the amount of queries to a graph that are required to solve a given problem, let us first consider the most common types of graphs, called directed graphs, that are associated with this type of computational modelling. In brief, directed graphs are graphs where all edges between vertices are unidirectional. Directed graphs are formally defined as the graph $$G=(N,E)$$, where N is the set of vertices, or nodes, and E is the set of edges.

ADD MORE BACKGROUND HERE, EVEN THOUGH THE PAGE IS LINKED.

Adjacency Matrix Model
When considering quantum computation of the solution to directed directed graph problems, there are two important query models to understand. First, there is the adjacency matrix model, where the graph of the solution is given by the adjacency matrix: $$M \in \{0,1\}a^{n\Chi n} $$, with $$M_{ij}=1 $$, if and only if $$(v_{i},v_{j})\in E $$.

Adjacency Array Model
Next, there is the slightly more complicated adjacency array model built on the idea of adjacency lists, where every vertex, $$u $$, is associated with an array of neighboring vertices such that $$f_i:[d_i^+]\rightarrow[n] $$, for the out-degrees of vertices $$d_i^+,...,d_n^+ $$, where $$n $$ is the minimum value of the upper bound of this model, and $$f_i(j) $$ returns the "$$j^{th} $$" vertex adjacent to $$i $$. Additionally, the adjacency array model satisfies the simple graph condition, $$\forall i\in[n],j,j^{'}\in[k],j\neq j^{'}: f_i(j)\neq f_i(j^{'}) $$, meaning that there is only one edge between any pair of vertices, and the number of edges is minimized throughout the entire model (see Spanning tree model for more background).

Quantum Query Complexity of Certain Types of Graph Problems
Both of the above models can be used to determine the query complexity of particular types of graphing problems, including the connectivity, strong connectivity (a directed graph version of the connectivity model), minimum spanning tree, and single source shortest path models of graphs. An important caveat to consider is that the quantum complexity of a particular type of graphing problem can change based on the query model (namely either matrix or array) used to determine the solution. The following table showing the quantum query complexities of these types of graphing problems illustrates this point well.

Notice the discrepancy between the quantum query complexities associated with a particular type of problem, depending on which query model was used to determine the complexity. For example, when the matrix model is used, the quantum complexity of the single source shortest path model is $$\Omega(n^{3/2})$$, but when the array model is used, the complexity is $$\Omega(\sqrt{nm})$$, where $$m=\Theta(n^2)$$. The important implication here is that the efficiency of the algorithm used to solve a graphing problem is dependent on the type of query model used to model the graph.

Grover's Algorithm
There is already stuff about Grover's algorithm, just add here...

Optimization of a query algorithm refers to how the algorithm compares to the most efficient theoretical algorithm that solves the same problem. An algorithm is said to be asymptotically optimized if at worst, it performs at a constant factor worse than the most efficient possible algorithm. Note that an algorithm is still considered to be optimized if it performs worse than the most efficient possible algorithm, as long as the algorithm doesn't get exponentially worse than the most efficient possible algorithm, as the number of inputs increases.