Search problem

Search problemMain

Community hub

Search problem

7 pages, 0 posts

0 subscribers

Recent from talks

Be the first to start a discussion here.

Recent from talks

Be the first to start a discussion here.

Contribute something

About hubMembersContent overviewUpdatesRules

Main reference articles

Search problem

View on Wikipedia

from Wikipedia

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages)

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed.
Find sources: "Search problem" – news · newspapers · books · scholar · JSTOR (May 2025) (Learn how and when to remove this message)

This article includes a list of general references, but it lacks sufficient corresponding inline citations. Please help to improve this article by introducing more precise citations. (May 2025) (Learn how and when to remove this message)

(Learn how and when to remove this message)

In computational complexity theory and computability theory, a search problem is a computational problem of finding an admissible answer for a given input value, provided that such an answer exists. In fact, a search problem is specified by a binary relation $R$ where $xRy$ if and only if " $y$ is an admissible answer given $x$ ".^{[note 1]} Search problems frequently occur in graph theory and combinatorial optimization, e.g. searching for matchings, optional cliques, and stable sets in a given undirected graph.

An algorithm is said to solve a search problem if, for every input value $x$ , it returns an admissible answer $y$ for $x$ when such an answer exists; otherwise, it returns any appropriate output, e.g. "not found" for $x$ with no such answer.

Definition

[edit]

PlanetMath defines the problem as follows:^[1]

If $R$ is a binary relation such that $\operatorname {field} (R)\subseteq \Gamma ^{+}$ and $T$ is a Turing machine, then $T$ calculates $f$ if:^{[note 2]}

If $x$ is such that there is some $y$ such that $R(x,y)$ then $T$ accepts $x$ with output $z$ such that $R(x,z)$ . (there may be multiple $y$ , and $T$ need only find one of them)
If $x$ is such that there is no $y$ such that $R(x,y)$ then $T$ rejects $x$ .

Note that the graph of a partial function is a binary relation, and if

T

calculates a partial function then there is at most one possible output.

R

can be viewed as a search problem, and a Turing machine which calculates

R

is also said to solve it. Every search problem has a corresponding decision problem, namely

L(R)=\{x\mid \exists yR(x,y)\}.

This definition can be generalized to n-ary relations by any suitable encoding which allows multiple strings to be compressed into one string (for instance by listing them consecutively with a delimiter).

Notes

[edit]

^ Luca Trevisan (2010), Stanford University - CS254: Computational Complexity, Handout 2 , p. 1.
^ Henry, PlanetMath.org - search problem.

References

[edit]

^ "PlanetMath". planetmath.org. Retrieved 15 May 2025. This article incorporates text from this source, which is available under the CC BY 2.5 license.

This article incorporates material from search problem on PlanetMath, which is licensed under the Creative Commons Attribution/Share-Alike License.

Revisions and contributors Edit on Wikipedia Read on Wikipedia

View on Grokipedia

from Grokipedia

In computer science, particularly artificial intelligence and algorithms, a search problem is a computational problem that requires finding a sequence of actions to reach a goal state from an initial state within a defined state space. It formalizes tasks such as pathfinding, planning, and puzzle solving by specifying key components: an initial state, a set of possible actions applicable to states, a transition model that determines the resulting state after an action, a goal test to identify goal states, and optionally a path cost function to evaluate solution quality.^[1] Search problems serve as the foundation for various search algorithms, which explore the state space systematically or heuristically to find optimal or feasible solutions. They are central to applications in navigation, game AI, and optimization, where the structure enables analysis of efficiency and completeness.^[1]

Definition and Formalism

Core Definition

In computational complexity theory, a search problem is a type of computational problem where, given an input instance

x \in \{0,1\}^*

, the task is to find a corresponding solution

y \in \{0,1\}^*

(typically of length polynomial in

|x|

) that satisfies a specified relation, or determine that no such solution exists. This contrasts with decision problems, which only require determining existence via a yes/no answer, by demanding the explicit output of the solution itself. Search problems are fundamental to understanding the practical limits of computation, particularly in contexts where verification is easy but discovery is hard.^[2] The formulation emphasizes efficient verifiability: for problems in the class FNP, there exists a polynomial-time algorithm that, given

x

and a candidate

y

, checks whether

(x, y)

satisfies the relation. This structure underpins many NP-hard challenges, where solving the search version efficiently would imply P = NP. The concept developed in the 1970s alongside the study of NP-completeness, with early examples drawn from combinatorial optimization.^[3] Search problems can be partial (solutions may not exist for all inputs) or total (solutions always exist), influencing subclasses like TFNP for total functions in FNP. Unlike optimization problems that seek the best solution among many, basic search problems focus on finding any valid witness, though extensions often incorporate quality measures.^[2]

Formal Components

A search problem is formally defined by a binary relation

R \subseteq \{0,1\}^* \times \{0,1\}^*

that is efficiently computable (decidable in polynomial time), along with a polynomial

p

bounding the solution length. For input

x

, a solution is any

y

with

|y| \leq p(|x|)

such that

(x, y) \in R

; if no such

y

exists, the problem may require outputting an indicator of non-existence.^[2] The input

x

represents the problem instance, encoded as a binary string, while the solution

y

is the output witness, also binary, encoding the required information (e.g., a satisfying assignment). The relation

R

encodes the validity condition, often via a verifier function

V(x, y)

that runs in polynomial time and accepts if

(x, y) \in R

. For FNP problems, this verifier is deterministic and polynomial-time.^[3] The polynomial bound

p

ensures solutions remain feasible in size, preventing trivial inflation. In cases where solutions always exist (total search problems), the output is guaranteed; otherwise, algorithms must handle non-solution cases, often via the decision version in NP. Reductions between search and decision problems, such as self-reducibility, allow leveraging oracles for solution construction. For example, in the search version of SAT,

x

is a Boolean formula,

y

is a variable assignment, and

R

checks satisfiability under that assignment.^[2] This framework avoids assumptions of determinism or full observability inherent in other models, focusing instead on worst-case computational resources for solution finding and verification.^[3]

Representation and Modeling

Search problems in computational complexity theory are formally represented by a binary relation

R \subseteq \{0,1\}^* \times \{0,1\}^*

that is computable in polynomial time by a deterministic Turing machine. For an input instance

x \in \{0,1\}^n

, a solution

y

satisfies

(x, y) \in R

and has length

|y| \leq p(n)

for some polynomial

p

. The relation

R

encodes the problem's structure, such as verifying a satisfying assignment for a Boolean formula in SAT or a valid coloring for a graph in the graph coloring problem.^[2]^[3]

State Space

The state space for a search problem refers to the domain of possible instances

x

and the corresponding solution space for each

x

, which is the set of strings

y \in \{0,1\}^{p(n)}

such that

(x, y) \in R

. This solution space has exponential size

2^{p(n)}

, reflecting the inherent computational challenge of exhaustive search. In practice, for concrete problems, the state space is modeled more compactly; for example, in SAT, states can represent partial assignments to variables, with the full space being

2^m

for

m

variables, but only satisfying ones are valid solutions. The effective exploration of this space relies on the problem's structure, such as sparsity of solutions or self-reducibility, to avoid enumerating the entire exponential domain.^[2] A key aspect is the solution density or the expected number of valid

y

per

x

, analogous to a branching factor in search trees derived from self-reducibility. For NP-hard search problems, the state space's size underscores why polynomial-time solutions are unlikely unless P = NP. Challenges like the "search explosion" arise when attempting to enumerate or sample from large state spaces, similar to but distinct from AI contexts, emphasizing theoretical limits over practical enumeration. For instance, in the search version of 3-SAT, the state space of assignments grows as

2^n

for

n

variables, with verification ensuring only valid ones are accepted.^[3]

Actions and Transition Model

Modeling the solution process for search problems often uses self-reducibility, where the search version reduces to polynomially many queries to the decision version. Here, the "state space" is partial solutions, and "actions" correspond to extending the partial solution by setting the next bit or variable. For a state

s

(a partial assignment), the actions are assigning 0 or 1 to the next unset variable, leading to successor states

s'

via a deterministic transition:

T(s, a) = s'

, where

a \in \{0,1\}

appends the value to

s

. The process continues until a full assignment

y

is obtained or inconsistency is detected via decision oracle calls.^[2] In self-reducible problems like SAT, the transition model is total for applicable actions but may prune branches if a partial assignment renders the formula unsatisfiable, as checked by the NP oracle. The successor function generates at most two children per state (branching factor 2), forming a binary search tree of depth equal to the number of variables. This model is reversible, as unsetting a variable returns to the parent state, enabling techniques like recursive querying. For graph coloring, actions might assign colors to vertices sequentially, with transitions enforcing adjacency constraints via verification. Such modeling highlights how decision oracles facilitate search without explicit enumeration, central to classes like FNP.^[3]

Types and Variations

Deterministic vs. Nondeterministic

In computational complexity theory, search problems are classified as deterministic or nondeterministic based on the computational resources required to find a solution

y

for an input

x

such that

(x, y) \in R

, where

R

is the defining relation. Deterministic search problems belong to the complexity class FP (function P), consisting of those solvable by a deterministic Turing machine in polynomial time. These problems allow efficient computation of solutions without nondeterministic choices, assuming the relation

R

permits direct polynomial-time resolution. A classic example is the uniform cost search analogue in graphs, such as computing the shortest path in an unweighted graph using breadth-first search, which runs in polynomial time

O(|V| + |E|)

for sparse graphs.^[2] Such problems are in P for their decision versions and extend naturally to search via deterministic algorithms. Nondeterministic search problems, in contrast, fall into the class FNP, the function analogue of NP, where a solution

y

(of polynomial length) can be verified in polynomial time given

x

, but finding

y

may require nondeterministic computation if the problem is hard. Membership in FNP means there exists a polynomial-time verifier for

R

, but solving the search version might not be feasible deterministically unless P = NP. The search version of the satisfiability problem (SAT), requiring a satisfying assignment for a Boolean formula if one exists, exemplifies an FNP-complete problem; its decision version is NP-complete, and self-reducibility allows solving the search problem via polynomially many oracle calls to the decision problem.^[3] This distinction underscores that while verification is efficient, generation often relies on nondeterminism or exponential search in the worst case, highlighting the core challenges in complexity theory. The boundary between FP and FNP captures the essence of efficient solvability: problems in FP yield practical algorithms for exact solutions, whereas FNP problems drive research into approximations and heuristics when exact solutions are intractable. Reductions between search and decision problems facilitate studying these classes, with implications for whether NP search problems can be derandomized or approximated.^[2]

Total vs. Partial Search Problems

Search problems in FNP can be further varied as partial or total based on whether solutions are guaranteed to exist for every instance. Partial search problems, the general case in FNP, may have instances with no solution

y

such that

(x, y) \in R

; the task is to find

y

if it exists or report none. Factoring large integers—finding non-trivial factors of a composite number—is a partial FNP problem, as some numbers (primes) have no such factors, and its hardness underpins cryptography like RSA.^[3] These problems correspond closely to NP decision versions, where "no" instances are possible. Total search problems, captured by the class TFNP, are a subclass of FNP where a solution is guaranteed for every input

x

, eliminating the need to check for existence and focusing purely on computation. TFNP includes problems with combinatorial guarantees, such as parity arguments ensuring solutions in certain structures. A prominent subclass is PPAD (polynomial parity arguments), which addresses fixed-point problems in directed graphs with indegree/outdegree at most 1, where a source-sink pair is known, and another must exist by parity. Finding a Nash equilibrium in a two-player game is PPAD-complete, as shown by reductions from Brouwer's fixed-point theorem; solutions can be verified in polynomial time, but no polynomial-time algorithm is known as of 2025.^[3] Other TFNP subclasses include PPA (polynomial parity arguments for undirected graphs) and PLS (polynomial local search) for optimization landscapes with local minima. This total/partial distinction emphasizes structural promises: partial problems allow "no" answers and relate to NP-hardness, while total problems like those in TFNP avoid existence checks but remain hard due to the need to locate solutions efficiently. Research into TFNP subclasses explores whether they contain P-complete problems or require exponential time, informing fields like game theory and economics.^[2]

Solution Methods

Search Algorithms Overview

In computational complexity theory, algorithms for search problems aim to compute a solution

y

such that

(x, y) \in R

for a given input

x

, where

R

is the defining relation. For general FNP search problems, exact solutions are not known to be computable in polynomial time unless P = NP. A basic approach is brute-force enumeration: generate all possible

y

of length polynomial in

|x|

and verify each against

R

, which requires exponential time in the worst case due to the size of the search space.^[2] Many natural NP search problems are self-reducible, allowing the search version to be solved via polynomially many queries to a decision oracle for the corresponding NP problem. In self-reducibility, the solution is constructed incrementally: for problems like the search-SAT (finding a satisfying assignment), fix bits of the assignment one by one by querying the decision oracle on whether a solution exists for the current prefix with the next bit set to 0; if affirmative, set it to 0, else to 1. This requires

O(|x|)

oracle calls and polynomial time otherwise, reducing search to decision. Similar techniques apply to graph coloring and other NP-complete search problems. If the decision problem is in P, the search is solvable in FP.^[4]^[2] For total search problems in TFNP, where a solution is guaranteed to exist, subclasses have specialized methods. In PPAD, encompassing fixed-point problems like computing Nash equilibria in games, algorithms such as the Lemke-Howson method can find solutions for two-player games, though general PPAD-complete problems resist efficient solving. When exact solutions are intractable, approximation algorithms provide near-solutions, such as approximate Nash equilibria within a small epsilon, computable in polynomial time for certain parameters. Heuristics and practical solvers, like DPLL-based SAT solvers (e.g., MiniSat), are used for real-world instances despite worst-case hardness.^[3]

Evaluation Metrics

Algorithms for search problems are evaluated based on computational complexity measures, solution guarantees, and practical performance. Time complexity classifies solvability, with FP for polynomial-time search functions and EXP for brute-force methods. For oracle reductions, query complexity counts decision calls, polynomial in self-reducible cases. Space complexity evaluates memory, crucial for bounded-resource models like LOGSPACE analogs for search.^[2] For approximation and optimization-oriented search problems, the approximation ratio quantifies how close the output is to optimal (e.g., within factor

\rho

), defining classes like PTAS (polynomial-time approximation schemes). Randomized algorithms are assessed by success probability (e.g., Monte Carlo vs. Las Vegas) and expected runtime, relevant for classes like BPP^NP. Hardness results, such as inapproximability from PCP theorems, set limits on achievable ratios without P=NP implications. Solution quality metrics, like the value of the objective function relative to the optimum

C^*

, inform utility in applications. These evaluations drive research into efficient solvers and theoretical barriers.^[3]

Applications and Examples

Search problems in computational complexity often arise in graph-theoretic settings, where the input is a graph and the goal is to find a structure satisfying a relation, such as a path or tour. A prominent example is the search version of the traveling salesman problem (TSP), where given a complete weighted graph

G = (V, E)

with edge weights representing distances, the task is to find a Hamiltonian cycle (tour visiting each vertex exactly once and returning to the start) of minimum total weight, if one exists with weight below a threshold.^[3] This is an FNP search problem, as solutions (tours) can be verified in polynomial time, but finding the optimal is NP-hard. TSP underpins applications in logistics and route optimization, where exact solutions are intractable for large instances (e.g., thousands of cities), leading to approximation algorithms or heuristics in practice.^[3] Another key example is the Hamiltonian path problem: given a directed graph

G

, find a path visiting each vertex exactly once, or determine none exists. This search problem is NP-complete in its decision version and belongs to FNP, with applications in scheduling (e.g., ordering tasks with precedence constraints) and network design (e.g., sequencing routes in communication networks). Unlike polynomial-time solvable shortest-path problems (e.g., via Dijkstra's algorithm in P), Hamiltonian path highlights the hardness of exact "navigation" in complex graphs, motivating reductions from other NP problems.^[5] In navigation-like scenarios, such as vehicle routing, the search problem generalizes to the vehicle routing problem (VRP), where multiple vehicles must serve customers from a depot while minimizing total distance. The relation R defines valid routes satisfying capacity and time constraints; finding such routes is FNP-hard, with real-world use in fleet management and supply chain optimization, where combinatorial explosion limits exact solutions to small instances (e.g., <50 customers).^[3]

Puzzle and Game Solving

Combinatorial puzzles often formalize as search problems in FNP, requiring a configuration (solution y) satisfying constraints for input puzzle x. The Boolean satisfiability (SAT) problem exemplifies this: given a Boolean formula φ in conjunctive normal form, find an assignment to variables making φ true, if possible. Here, R(φ, a) holds if a is a satisfying assignment, verifiable in polynomial time. SAT search is complete for FNP under parsimonious reductions and models puzzle-solving like logic grid puzzles or Sudoku (reducible to SAT), with applications in verification (e.g., checking hardware designs for bugs) and AI planning. As of 2025, SAT solvers handle industrial instances with millions of clauses using heuristics, but worst-case exponential time underscores P vs. NP implications.^[5]^[3] Graph coloring extends this to puzzles like map coloring: given graph G and integer k, find a k-coloring c: V → {1,...,k} such that no adjacent vertices share colors. The 3-coloring search problem is FNP-complete, used in scheduling (assigning resources without conflicts) and register allocation in compilers. Solutions exist for bipartite graphs (k=2, in P), but general k=3 is hard, illustrating how puzzle solvability ties to complexity classes.^[5] In game theory, search problems capture strategic reasoning. The Nash equilibrium problem, in PPAD ⊆ TFNP, requires finding a mixed-strategy profile (probabilities over actions) for a finite game where no player benefits from unilateral deviation. For input game matrix x, output y such that R(x,y) (equilibrium condition) holds; solutions always exist by Nash's theorem, but computing approximate equilibria is PPAD-complete. Applications include auction design, market analysis, and algorithmic game theory, where finding equilibria aids in predicting outcomes in economic models or network formation. As of 2025, no polynomial-time algorithm exists, with quantum approaches explored but unproven.^[6]^[3] Another TFNP example is integer factorization: given composite N, find nontrivial factors p,q such that N = p·q. Verifiable in polynomial time, it's total (always solvable) and believed hard, forming the basis of RSA cryptography for secure communication (e.g., HTTPS). Quantum algorithms like Shor's (1994) solve it in polynomial time on quantum computers, but as of 2025, no large-scale quantum threat exists, preserving classical hardness assumptions.^[5]^[3]

Complexity Analysis

Computational Complexity

Search problems in computational complexity theory are analyzed through function complexity classes that extend decision classes like NP. The class FNP includes search problems where, given an input

x

and proposed solution

y

, there exists a polynomial-time verifier confirming

(x, y) \in R

. This mirrors NP but requires constructing

y

rather than deciding existence. If the corresponding decision problem (existence of

y

) is in P, the search problem is in FP, solvable in polynomial time by a deterministic Turing machine.^[2] A key subclass is TFNP, comprising total search problems in FNP where a solution is guaranteed for every input, based on combinatorial principles ensuring existence (e.g., via fixed-point theorems). TFNP has natural subclasses capturing specific totality arguments: PPAD for polynomial-time problems related to directed graphs with unequal in/out-degrees (e.g., finding Brouwer fixed points or approximate Nash equilibria in games); PPA for parity arguments in undirected graphs; and others like PPP and PLS for potential maximization. These classes are believed incomparable, with no known complete problems under standard assumptions, highlighting the nuanced hardness within TFNP.^[3] Hardness for search problems often follows from decision versions via reductions. A search problem is NP-hard if every NP decision problem reduces to it in polynomial time, implying P = NP if solvable in polynomial time. For instance, the search-SAT problem (finding a satisfying assignment) is NP-hard by parsimonious reductions from decision-SAT. Many NP search problems are self-reducible, allowing solution via polynomially many queries to the decision oracle: for SAT, fix variables one by one, checking satisfiability after each. This technique extends to problems like graph coloring. Search problems can also be complete for higher classes, such as PSPACE, where the Quantified Boolean Formulas (QBF) search variant requires finding satisfying assignments to alternating quantifier formulas, hard even with polynomial space.^[2]^[7]

Practical Challenges

The intractability of NP-hard and TFNP-complete search problems poses challenges in applications requiring exact solutions, such as cryptography (e.g., integer factorization as a search problem) and optimization (e.g., TSP tour finding). To address this, approximation algorithms seek solutions within a guaranteed factor of optimality; for example, Christofides' 1.5-approximation for metric TSP, though the general case resists constant-factor approximation unless P = NP. Parameterized complexity fixes parameters beyond input size (e.g., treewidth in graph problems), yielding fixed-parameter tractable (FPT) algorithms like O(2^w n) for vertex cover on graphs of treewidth w, where n is input size. These mitigate hardness for restricted instances common in practice, such as logistics routing or protein folding.^[3] Proving hardness for search problems often requires novel reductions, as totality in TFNP complicates standard NP techniques; for PPAD, reductions from End-of-the-Line preserve approximate solutions. Recent results (as of 2023) show fine-grained hardness, linking PPAD to algebraic problems like finding short vector lattices, impacting post-quantum cryptography. Challenges include distinguishing average-case from worst-case hardness, with random self-reducibility enabling derandomization for some problems. In real-world deployment, hybrid approaches combine exact solvers for small instances with heuristics, but verifying approximation ratios remains computationally intensive.^[3]^[8]

History

Search problem

Recent from talks

Recent from talks

Contribute something

Contribute something

Media Pages

Timelines

Articles

Notes collections

Notes

Notes

Days in Chronicle

Search problem

Definition

See also

Notes

References

Search problem

Definition and Formalism

Core Definition

Formal Components

Representation and Modeling

State Space

Actions and Transition Model

Types and Variations

Deterministic vs. Nondeterministic

Total vs. Partial Search Problems

Solution Methods

Search Algorithms Overview

Evaluation Metrics

Applications and Examples

Pathfinding and Navigation

Puzzle and Game Solving

Complexity Analysis

Computational Complexity

Practical Challenges

References

Add your contribution

Related Hubs

Contribute something