7.5 KiB
| title | chunk | source | category | tags | date_saved | instance |
|---|---|---|---|---|---|---|
| Aanderaa–Karp–Rosenberg conjecture | 2/4 | https://en.wikipedia.org/wiki/Aanderaa–Karp–Rosenberg_conjecture | reference | science, encyclopedia | 2026-05-05T11:01:55.807273+00:00 | kb-cron |
== Definitions == In the context of this article, all graphs will be simple and undirected, unless stated otherwise. This means that the edges of the graph form a set (and not a multiset) and each edge is a pair of distinct vertices. Graphs are assumed to have an implicit representation in which each vertex has a unique identifier or label and in which it is possible to test the adjacency of any two vertices, but for which adjacency testing is the only allowed primitive operation. Informally, a graph property is a property of a graph that is independent of labeling. More formally, a graph property is a mapping from the class of all graphs to
{
0
,
1
}
{\displaystyle \{0,1\}}
such that isomorphic graphs are mapped to the same value. For example, the property of containing at least one vertex of degree two is a graph property, but the property that the first vertex has degree two is not, because it depends on the labeling of the graph (in particular, it depends on which vertex is the "first" vertex). A graph property is called non-trivial if it does not assign the same value to all graphs. For instance, the property of being a graph is a trivial property, since all graphs possess this property. On the other hand, the property of being empty is non-trivial, because the empty graph possesses this property, but non-empty graphs do not. A graph property is said to be monotone if the addition of edges does not destroy the property. Alternately, if a graph possesses a monotone property, then every supergraph of this graph on the same vertex set also possesses it. For instance, the property of being nonplanar is monotone: a supergraph of a nonplanar graph is itself nonplanar. However, the property of being regular is not monotone. The big O notation is often used for query complexity. In short,
f
(
n
)
{\displaystyle f(n)}
is
O
(
g
(
n
)
)
{\displaystyle O(g(n))}
(read as "of the order of
g
(
n
)
{\displaystyle g(n)}
") if there exist positive constants
c
{\displaystyle c}
and
N
{\displaystyle N}
such that, for all
n
≥
N
{\displaystyle n\geq N}
,
f
(
n
)
≤
c
⋅
g
(
n
)
{\displaystyle f(n)\leq c\cdot g(n)}
. Similarly,
f
(
n
)
{\displaystyle f(n)}
is
Ω
(
g
(
n
)
)
{\displaystyle \Omega (g(n))}
if there exist positive constants
c
{\displaystyle c}
and
N
{\displaystyle N}
such that, for all
n
≥
N
{\displaystyle n\geq N}
,
f
(
n
)
≥
c
⋅
g
(
n
)
{\displaystyle f(n)\geq c\cdot g(n)}
. Finally,
f
(
n
)
{\displaystyle f(n)}
is
Θ
(
g
(
n
)
)
{\displaystyle \Theta (g(n))}
if it is both
O
(
g
(
n
)
)
{\displaystyle O(g(n))}
and
Ω
(
g
(
n
)
)
{\displaystyle \Omega (g(n))}
.
== Query complexity == The deterministic query complexity of evaluating a function on
n
{\displaystyle n}
bits (where the bits may be labeled as
x
1
,
x
2
,
…
x
n
{\displaystyle x_{1},x_{2},\dots x_{n}}
) is the number of bits
x
i
{\displaystyle x_{i}}
that have to be read in the worst case by a deterministic algorithm that computes the function. For instance, if the function takes the value 0 when all bits are 0 and takes value 1 otherwise (this is the OR function), then its deterministic query complexity is exactly
n
{\displaystyle n}
. In the worst case, regardless of the order it chooses to examine its input, the first
n
−
1
{\displaystyle n-1}
bits read could all be 0, and the value of the function now depends on the last bit. If an algorithm doesn't read this bit, it might output an incorrect answer. (Such arguments are known as adversary arguments.) The number of bits read are also called the number of queries made to the input. One can imagine that the algorithm asks (or queries) the input for a particular bit and the input responds to this query. The randomized query complexity of evaluating a function is defined similarly, except the algorithm is allowed to be randomized. In other words, it can flip coins and use the outcome of these coin flips to decide which bits to query in which order. However, the randomized algorithm must still output the correct answer for all inputs: it is not allowed to make errors. Such algorithms are called Las Vegas algorithms. (A different class of algorithms, Monte Carlo algorithms, are allowed to make some error.) Randomized query complexity can be defined for both Las Vegas and Monte Carlo algorithms, but the randomized version of the Aanderaa–Karp–Rosenberg conjecture is about the Las Vegas query complexity of graph properties. Quantum query complexity is the natural generalization of randomized query complexity, of course allowing quantum queries and responses. Quantum query complexity can also be defined with respect to Monte Carlo algorithms or Las Vegas algorithms, but it is usually taken to mean Monte Carlo quantum algorithms. In the context of this conjecture, the function to be evaluated is the graph property, and the input can be thought of as a string of size
n
(
n
−
1
)
/
2
{\displaystyle n(n-1)/2}
, describing for each pair of vertices whether there is an edge with that pair as its endpoints. The query complexity of any function on this input is at most
n
(
n
−
1
)
/
2
{\displaystyle n(n-1)/2}
, because an algorithm that makes
n
(
n
−
1
)
/
2
{\displaystyle n(n-1)/2}
queries can read the whole input and determine the input graph completely.