CMPS 260 Spring 2022
Preview of Final Exam

Generally speaking, you should expect the final exam to include problems similar to those that appeared in the homework assignments, or the quiz, or the midterm exam.

More specifically, you should be prepared to solve problems of the following types:

• Given a binary relation on a set S, identify which properties it possesses among reflexivity, symmetry, and transitivity.
• Given a set S and a list of properties (such as those mentioned in the previous item), devise a binary relation on S (illustrated by a directed graph whose vertices correspond to members of S) that possesses those properties.
• Given a relatively simple assertion regarding numbers, sets, relations, graphs, context-free grammars, derivation trees, or finite automata, demonstrate its truth using one or more proof techniques among mathematical induction, proof by contradiction, and the pigeonhole principle.
• Given an informal, but precise, description of a regular language, devise either a finite automaton (possibly restricted to being deterministic) that accepts the language or a regular expression that denotes the language.
• Given a (possibly nondeterministic) finite automaton, or a regular expression, provide a precise (even if not necessarily formal) description of the language that it accepts/denotes.
• Given a finite automaton M, devise a regular expression r such that they represent the same language (i.e., L(M) = L(r)). Or vice versa. (You will not be expected to carry out the NFA-to-regular expression algorithm in Linz's Section 3.2, however.)
• Given a nondeterministic finite automaton (NFA), convert it to an equivalent deterministic finite automaton (DFA) using the "subset construction" algorithm (what Linz refers to as the nfa-to-dfa procedure in Section 2.3).
• Given the description of some language operator (e.g., as in Problems 16-18 at end of Section 2.3 or Problems 1-5 in HW #5), justify the claim that regular languages are closed under that operator.

  For a unary operator, typically this is done by showing that an FA that accepts L can be (algorithmically) modified to become an FA that accepts op(L). For a binary operator, typically this is done by showing that an FA accepting L₁ op L₂ can be built using FA's that accept L₁ and L₂.

  For some operators, a construction based upon regular expressions (or right-linear grammars) could work better.

• Given a DFA M, identify the equivalence classes of the state-indistinguishability relation and, based upon those, construct the equivalent minimal DFA M'.
• Given an informal, but precise, description of a context-free language (CFL), devise a context-free grammar (CFG) that generates that language, or perhaps a PDA (possibly restricted to be a DPDA) that accepts it.
• Given a CFG G, provide a precise (even if not necessarily formal) description of the language that it generates (L(G)).
• Given a non-regular language, prove it to be so using results in Linz, the Regular Language Pumping Lemma, and/or closure properties of regular languages.
• Given an ambiguous CFG, show that it is ambiguous.
• Given a Chomsky Normal Form CFG G and a (short) string x, apply the CYK algorithm (Section 6.3) to determine whether x ∈ L(G).
• Given the description of some non-standard Turing Machine model, show that its computations can be simulated by a standard TM.
• Given the description of a set that is countable, but perhaps not obviously so, demonstrate that it is by describing a one-to-one correspondence between it and the set of positive integers, or a procedure by which to enumerate its elements.
• Show that a given problem/language is undecidable by describing a reduction to it from a known-to-be undeciable problem (e.g. the Halting Problem).
• Given the description of an enumeration procedure for some recursively enumerable (RE) set, argue that the nature of that procedure can be exploited in such a way as to show that the set is actually recursive.
• Given a set-theoretic operator (e.g., union, intersection), argue in favor of, or against, the proposition that the class of recursive (or perhaps RE) languages is closed under that operation.
• Given a pair of similar decision-problems/languages L₁ and L₂, show that L₁ is polynomial-time reducible to L₂. (This entails describing an algorithm that, given a string w₁, produces (in polynomial time) a string w₂ such that w₁ ∈ L₁ if and only if w₂ ∈ L₂.)