Theory of Computation MCQ

Explanation

A finite automaton (DFA or NFA) has a finite set of states, reads input one symbol at a time, and accepts if it ends in an accepting state. It recognizes regular languages.

Explanation

Regular languages are the simplest class in the Chomsky hierarchy. They are closed under union, concatenation, and Kleene star, and can be represented by DFA, NFA, or regex.

Explanation

A Deterministic Finite Automaton (DFA) has exactly one transition for each state-symbol pair, making its behavior fully deterministic.

Explanation

NFAs allow nondeterminism (multiple transitions, ε-moves). Every NFA can be converted to an equivalent DFA via the subset construction, though the DFA may have exponentially more states.

Explanation

Regular expressions use ∪ (union), · (concatenation), and * (Kleene star) as basic operators. They describe exactly the class of regular languages.

Explanation

In a CFG, each production rule has a single non-terminal on the left side (A → α). CFGs generate context-free languages, recognized by pushdown automata.

Explanation

A Pushdown Automaton (PDA) extends a finite automaton with a stack, giving it the power to recognize context-free languages (e.g., balanced parentheses).

Explanation

A Turing machine can read/write symbols on an infinite tape and move left or right. It is the most powerful computational model, equivalent to any real computer.

Explanation

The Church-Turing thesis is an informal hypothesis: anything intuitively computable can be computed by a Turing machine. It is not formally provable but is universally accepted.

Explanation

Turing proved that no Turing machine can decide for all programs whether they halt. The proof uses diagonalization and is a cornerstone of computability theory.

Explanation

A decidable (recursive) language has a Turing machine that halts on all inputs — returning "accept" or "reject." Undecidable problems (like the Halting Problem) have no such TM.

Explanation

Chomsky Type 3 (regular) ⊂ Type 2 (context-free) ⊂ Type 1 (context-sensitive) ⊂ Type 0 (recursively enumerable). Each type is recognized by a progressively more powerful automaton.

Explanation

ε represents the empty string. ε-transitions in NFAs allow state changes without consuming input. The set {ε} is not the empty language; the empty language is {}.

Explanation

L* (Kleene closure) includes ε and all finite concatenations of strings from L. It is a fundamental operation for defining regular languages.

Explanation

ε-NFAs allow state changes on ε (no input consumed). Every ε-NFA can be converted to an equivalent DFA by computing ε-closures.

Explanation

L(G) is the set of all terminal strings derivable from the start symbol S. Every grammar defines a language.

Explanation

Terminals are the actual symbols of the language (letters, digits). Non-terminals are intermediate symbols that get replaced. Only terminals appear in final derived strings.

Explanation

A grammar is ambiguous if there exists a string that can be parsed in two different ways (two distinct parse trees or leftmost derivations). Ambiguity in programming language grammars causes operator precedence problems.

Explanation

Regular languages are closed under union, concatenation, Kleene star, intersection, and complement. The union of two regular languages is always regular.

Explanation

The complement of L is all strings over the same alphabet that are NOT in L. Regular languages are closed under complement; context-free languages are not.

Explanation

Parse trees (derivation trees) represent how a string is derived from a grammar. They visualize the hierarchical structure and are used in compiler syntax analysis.

Explanation

{aⁿbⁿ} is the classic example of a CFL that is not regular. A DFA cannot count arbitrarily, but a PDA can use its stack to count matching a's and b's.

Explanation

RE languages are recognized (accepted) by Turing machines that always halt on accepted strings but may loop forever on rejected strings. Decidable languages always halt on both.

Explanation

In a leftmost derivation, the leftmost non-terminal is always expanded first. A rightmost derivation expands the rightmost. Both strategies are used in parser construction.

Explanation

A dead (trap) state is a non-accepting state from which the machine can never reach an accepting state. Once entered, the string will be rejected.

Explanation

The minimized DFA (Myhill-Nerode theorem) is unique and has the fewest states. States are merged if they are indistinguishable (same behavior on all input suffixes).

Explanation

Subset (powerset) construction: each DFA state is a set of NFA states reachable on the same input. An n-state NFA may produce up to 2ⁿ DFA states.

Explanation

GNF: every production is A → aB₁B₂...Bk where a is terminal and Bi are non-terminals. Any CFG can be converted to GNF. Useful for PDA construction.

Explanation

CNF productions are A → BC (two non-terminals) or A → a (one terminal). Every CFG can be converted to CNF. CNF is used by the CYK parsing algorithm.

Explanation

An LBA is a nondeterministic Turing machine restricted to the tape length of the input. It recognizes exactly the context-sensitive languages (Type 1).

Explanation

Transducers (Mealy and Moore machines) are FA with outputs. Mealy machines produce output on transitions; Moore machines produce output on states. Used in digital circuit design.

Explanation

The Halting Problem is RE (a TM can accept by simulating M on w until it halts) but undecidable (no TM always halts on both instances). Its complement is not even RE.

Explanation

CYK checks membership in a CFG (in CNF) using DP on all substrings. It fills a triangular table bottom-up in O(n³) time, determining if a string is generated by the grammar.

Explanation

A TM recognizer (enumerator) accepts members of the language but may loop forever on non-members. A TM decider (solver) always halts with yes/no for all inputs.

Explanation

An undecidable problem has no algorithm that always terminates with the correct answer. This is a fundamental limitation of computation, not just current hardware.

Explanation

An NTM explores multiple paths of computation simultaneously. While not physically realizable, it is theoretically equivalent to deterministic TMs in terms of language recognition (though potentially exponentially faster).

Explanation

∅ (empty set) is the language containing no strings at all, not even ε. The language {ε} contains exactly one string: the empty string. Both are regular languages.

Explanation

Production rules define how strings are derived. In CFGs, the left-hand side is a single non-terminal. In unrestricted grammars (Type 0), both sides can be any string.

Explanation

A Moore machine produces output that depends only on the current state. A Mealy machine produces output based on the current state AND input symbol.

Explanation

L₁·L₂ = {xy | x ∈ L₁, y ∈ L₂} — strings formed by concatenating any string from L₁ with any string from L₂.

Explanation

The Pumping Lemma states that every regular language has a pumping length p such that any string w with |w|≥p can be split as xyz with xy^i z in the language. Violating this proves non-regularity.

Explanation

{aⁿbⁿcⁿ} is not context-free (proved by the CFL Pumping Lemma) but is context-sensitive. It requires counting three quantities simultaneously, which is beyond the power of a PDA's single stack.

Explanation

Regular languages are closed under union, concatenation, star, intersection, and complement. Context-free languages are closed under union, concatenation, and star but not intersection or complement.

Explanation

Myhill-Nerode: a language is regular iff it has finitely many right-congruence classes (≡_L). The number of classes equals the number of states in the minimal DFA.

Explanation

Rice's theorem: for any non-trivial property P of RE languages (neither all TMs nor no TMs have it), the problem of deciding whether TM M has property P is undecidable.

Explanation

Earley parsing handles any CFG without requiring transformations. It builds items (dotted rules) in a chart, making it versatile but O(n³) for ambiguous grammars.

Explanation

LL parsers (predictive, recursive descent) are top-down and handle a subset of CFGs. LR parsers (shift-reduce) are bottom-up and handle a larger class of CFGs without ambiguity.

Explanation

The emptiness problem for CFGs is decidable: mark productive non-terminals (those deriving terminal strings), and check if S is marked. Equivalence is undecidable for CFGs.

Explanation

If A reduces to B (A ≤ B), then B is at least as hard as A. If A is undecidable and A reduces to B, then B is also undecidable. Reductions are the primary tool for undecidability proofs.

Explanation

PCP: given pairs of strings (aᵢ, bᵢ), find a sequence i₁, i₂,..., iₖ such that a_{i₁}a_{i₂}...a_{iₖ} = b_{i₁}b_{i₂}...b_{iₖ}. Undecidable, useful for showing other problems undecidable.

Explanation

P contains problems solvable in O(nᵏ) time for some constant k. Examples: sorting, shortest paths, linear programming. P is believed to be a strict subset of NP.

Explanation

NP is the class of problems with polynomial-time verifiable solutions (witnesses/certificates). Equivalently, solvable by a nondeterministic TM in polynomial time.

Explanation

NP-complete problems are the hardest in NP. If any NP-complete problem is in P, then P = NP. Examples: SAT, 3-SAT, Vertex Cover, Hamiltonian Path.

Explanation

Cook's theorem (1971) proved that SAT is NP-complete. Karp then showed 21 other problems (including 3-SAT, Clique, Vertex Cover) are NP-complete by reduction from SAT.

Explanation

The CFL Pumping Lemma splits strings into 5 parts: uvxyz with two "pumpable" segments v and y. Violating it proves a language is not context-free (e.g., {aⁿbⁿcⁿ}).

Explanation

PSPACE contains all problems solvable in O(nᵏ) space. P ⊆ NP ⊆ PSPACE ⊆ EXP. PSPACE-complete examples: QBF (Quantified Boolean Formula), TQBF.

Explanation

Savitch's theorem shows nondeterministic and deterministic space classes are close: NPSPACE(f) ⊆ DSPACE(f²). This implies PSPACE = NPSPACE.

Explanation

co-NP = {L̄ | L ∈ NP}: languages whose complement is in NP. If P = NP, then P = NP = co-NP. It is unknown if NP = co-NP. TAUTOLOGY is co-NP-complete.

Explanation

PH = ∪ Σₖᴾ where Σ₀ᴾ = P, Σ₁ᴾ = NP, Π₁ᴾ = co-NP, Σ₂ᴾ = NP^NP, etc. If any level collapses (Σₖ = Πₖ), the entire hierarchy collapses.

Explanation

Mealy machines produce output λ(q,a) for each transition. Moore machines produce output only based on state. Both are equivalent in expressive power.

Explanation

A PDA with two stacks is equivalent to a Turing machine. One stack simulates the left part of the tape and one the right part. This shows the power jump from one to two stacks.

Explanation

Time-constructible functions are needed in the Time Hierarchy Theorem: DTIME(o(f(n)/log f(n))) ⊊ DTIME(f(n)) for time-constructible f, proving there are problems requiring more time.

Explanation

If L and L̄ are both RE, then L is decidable. For a recognizer of L: run it and a recognizer of L̄ in parallel; whichever halts first decides. This is Turing's decidability characterization.

Explanation

3-SAT is NP-complete (reduced from SAT). Every clause has exactly 3 literals. Many NP-completeness proofs reduce from 3-SAT, making it a fundamental problem in complexity theory.

Explanation

L = DSPACE(log n): problems solvable with O(log n) extra workspace. L ⊆ P. Graph reachability (STCON) is NL-complete (nondeterministic logspace). L vs NL is open.

Explanation

Kleene's Recursion Theorem: for any TM T, there exists a TM R that, when run, behaves as T does when T receives R's description as input. Used to construct quines and prove results in computability.

Explanation

Oracle TMs are used to define relative complexity: Pᴬ means P with access to oracle A. Baker-Gill-Solovay showed there exist oracles A where Pᴬ = NPᴬ and oracles B where Pᴮ ≠ NPᴮ.

Explanation

IP = PSPACE (Shamir 1992). The prover convinces a verifier of a true statement through multiple rounds of interaction with randomized queries, with completeness and soundness properties.

Explanation

ZK proofs satisfy completeness (honest prover convinces verifier), soundness (dishonest prover fails), and zero-knowledge (verifier learns nothing except the statement is true). Used in cryptography.

Explanation

EXPTIME = DTIME(2^(n^k)) for constant k. P ⊆ NP ⊆ PSPACE ⊆ EXPTIME. It is known P ⊊ EXPTIME (Time Hierarchy). Go (game) is EXPTIME-complete.

Explanation

Thompson's construction recursively builds NFA fragments for each regex sub-expression and joins them with ε-transitions, guaranteeing the resulting NFA has at most twice as many states as regex symbols.

Explanation

The standard pumping argument picks w = 0ᵖ1ᵖ. Since |xy| ≤ p, the substring y consists only of 0s, so pumping (xy²z) creates more 0s than 1s, contradicting membership in L and proving L is not regular.

Explanation

Regular languages form a Boolean algebra — closed under union, intersection, and complement. Context-free languages are closed under union, concatenation, and star, but generally not under intersection or complement (e.g., the intersection of two CFLs can be non-context-free).

Explanation

Because {aⁱbʲ | i ≠ j} is the union of "more a's than b's" and "more b's than a's," a CFG generates a balanced aⁿbⁿ core and then prepends extra a's or appends extra b's, illustrating how CFLs are built from simpler component languages.

Explanation

A predictive parser expanding A → Aα would call itself again before reading input, looping forever. The standard fix rewrites left recursion into right recursion using a fresh non-terminal, preserving the language while making top-down parsing feasible.

Explanation

The product construction simulates two DFAs simultaneously: each state is a pair (q, r), transitions move both components on the same symbol, and a pair is accepting only if both q and r are accepting — directly proving regular languages are closed under intersection.

Explanation

CNF conversion proceeds in stages — removing ε- and unit-productions, eliminating unreachable/non-generating symbols, then restructuring rules into A → BC or A → a form. This uniform binary structure is exactly what the CYK parsing algorithm requires.

Explanation

DFA equivalence is decidable: minimize both DFAs (or build a product DFA checking the symmetric difference) and compare; if no string is accepted by exactly one, they are equivalent. This contrasts sharply with the undecidable equivalence problem for Turing machines.

Explanation

In the subset (powerset) construction, each DFA state is the set of NFA states reachable on a given input prefix. Since an n-element set has 2ⁿ subsets, certain NFAs (carefully designed) force all of them to be distinguishable, giving a tight exponential blow-up.

Explanation

For concatenation, you build a new grammar S → S₁S₂ combining the two start symbols. No such simple construction exists for intersection — and the classic counterexample intersects two context-free languages to obtain {aⁿbⁿcⁿ}, which the CFL Pumping Lemma shows is not context-free.

Explanation

The Time Hierarchy Theorem proves that more time gives strictly more computational power. It implies P ⊊ EXPTIME and rules out collapsing of the complexity hierarchy.

Explanation

Immerman and Szelepcsényi independently proved NL = co-NL (1987/1988) using inductive counting: the complement of graph reachability is in NL.

Explanation

Proving a language violates the CFL Pumping Lemma shows it cannot be context-free. It must be context-sensitive, recursively enumerable, or non-RE, depending on what TM variant can recognize it.

Explanation

Ladner's theorem (1975) proves: if P ≠ NP, the NP class is not just P and NP-complete — there are problems "in between." Graph Isomorphism is suspected to be NP-intermediate.

Explanation

Oblivious TMs can be simulated by circuits and are used in proofs relating time complexity to circuit complexity (e.g., NC, P/poly). Any TM can be made oblivious with O(T log T) slowdown.

Explanation

Descriptive complexity (Fagin, Immerman) connects logic and complexity: NP = ∃SO (existential second-order logic), P = FO+LFP on ordered structures, L = FO+DTC. This gives machine-independent characterizations.

Explanation

Karp-Lipton (1980): NP ⊆ P/poly → PH collapses. This is evidence against NP ⊆ P/poly, since most believe PH doesn't collapse. It connects circuit complexity to the P vs NP question.

Explanation

AM protocols use public randomness (Arthur's coins visible to Merlin). AM = IP[O(1)] = NP^RP. Goldwasser-Sipser showed AM ⊆ IP. AM is believed to equal NP.

Explanation

A language is in P/poly iff it has polynomial-size circuit families (non-uniform). Uniformity (logspace-uniform) restricts to P. NC ⊆ P corresponds to shallow, parallel circuits.

Explanation

Razborov showed MOD-2 is not in AC⁰[3]; Smolensky extended this to all primes. This is one of the deepest circuit lower bounds, proving strict separations in the circuit complexity hierarchy.

Explanation

Toda's theorem (1991): PH ⊆ P^#P. This means any level of the polynomial hierarchy can be solved with one query to a counting oracle, showing counting is surprisingly powerful.

Explanation

#P counts the number of accepting paths of a polynomial-time NTM. Counting the number of satisfying assignments of a Boolean formula is #P-complete (#SAT). #P is at least as hard as NP.

Explanation

Immerman and Szelepcsényi (1987-88) proved independently that nondeterministic logspace is closed under complement: NL = co-NL. This was surprising given analogous questions at higher levels remain open.

Explanation

BGS (1975) showed P vs NP is immune to relativization: some oracles collapse P = NP, others separate them. This rules out many standard proof techniques for resolving P vs NP.

Explanation

The PCP Theorem (1992) states NP = PCP(log n, 1). Its main consequence: approximating many NP-hard optimization problems is itself NP-hard, establishing approximation hardness results.

Explanation

Nisan-Wigderson (1994): if there exist functions hard for exponential-size circuits, then P = BPP (all randomized polynomial algorithms can be derandomized). Strong lower bounds → BPP = P.

Explanation

BPP allows at most 1/3 error probability on any input. P ⊆ BPP ⊆ PSPACE. It is widely believed BPP = P (derandomization conjecture), though unproven.

Explanation

The UTM (Universal Turing Machine) is a single machine that simulates any other TM given its description. It formalizes the concept of a stored-program computer and is central to undecidability proofs.

Explanation

PCP theorem implies: MAX-3-SAT is NP-hard to approximate within 7/8+ε; Clique within n^(1-ε); Vertex Cover within some constant. Some NP-hard problems do have PTAS (e.g., Euclidean TSP).

Explanation

The Space Hierarchy Theorem gives DSPACE(o(f(n))) ⊊ DSPACE(f(n)) for space-constructible f, a cleaner separation than the Time Hierarchy Theorem's DTIME(o(f(n)/log f(n))) ⊊ DTIME(f(n)). The gap is tighter because a diagonalizing machine can reuse space when simulating other machines, avoiding the bookkeeping overhead that costs a log factor in the time-based argument.