Key insight: If 'a' is followed by 'b' anywhere, the string is rejected. So once we see any 'a', we can never see a 'b' afterward. This means: all the b's come before all the a's.

Answer: b*a*

Test: "ba" ✓, "bba" ✓, "aaa" ✓, "bbb" ✓, "ε" ✓, "ab" ✗ (correct!), "bab" ✗ (correct!)

Note: "bab" fails because after the middle 'a', there's a 'b'.

Key insight: An odd-length string can be written as: one character, then any number of pairs of characters.

Answer: (a+b)((a+b)(a+b))*

Or equivalently: ((a+b)(a+b))*(a+b)

The pattern picks any single symbol, then zero or more pairs. Total: 1 + 2k = odd ✓

Test: "a" (length 1 ✓), "abc"... actually "aba" (length 3 ✓), "ab" (length 2 ✗ correct).

Key insight: Every 'a' must be immediately followed by a 'b' (or end the string). So a's can only appear as "ab" blocks, except possibly a final 'a'.

Answer: b*(ab*)*(ε+a) or equivalently (b+ab)*(ε+a)

Reading: any number of b's, then any number of (a followed by b's), optionally ending in a single a.

Test: "aba" ✓, "abab" ✓, "b" ✓, "ε" ✓, "aa" ✗ (correct!), "bab" ✓, "baa" ✗ (correct!)

Key insight: The string must contain "aa" exactly once, and no other consecutive a's. This means: before and after the "aa", we can have anything EXCEPT another "aa". Use the "no consecutive a's" pattern around the "aa".

Let NO_AA = (b+ab)*(ε+a) = strings with no consecutive a's.

Answer: (b+ab)* aa (b+ab)*(ε+a)

But wait — we also need to make sure there's no 'a' immediately before or after the "aa" that would create a run of 3+ a's. Adjust:

Refined: (b+ab)* b aa b (ab+b)* (ε+a) (if the "aa" is in the middle)

This is tricky — full solution requires careful case analysis based on whether "aa" appears at start/end/middle.

Key insight: The number of b's is 1, 2, 4, 5, 7, 8, ... (not 0, 3, 6, 9...). Split into two cases: #b ≡ 1 (mod 3) or #b ≡ 2 (mod 3).

Let A = a* (any number of a's, used between b's)

Let GRP = a*ba*ba*ba* = exactly 3 b's with any a's

For #b ≡ 1 (mod 3): a*(ba*ba*ba*)* b a* — groups of 3 b's, plus 1 extra

For #b ≡ 2 (mod 3): a*(ba*ba*ba*)* b a* b a* — groups of 3 b's, plus 2 extra

Answer: union of both cases with +.

Tip: on the exam, these counting patterns are often better designed as a DFA first, then described in English.

Key insight: Either "00" comes before "11" or "11" comes before "00".

Let ANY = (0+1)*

Answer: (0+1)* 00 (0+1)* 11 (0+1)* + (0+1)* 11 (0+1)* 00 (0+1)*

Or more concisely since the parts can overlap: you need any string that has at least one "00" AND at least one "11" somewhere. The two cases cover whether "00" or "11" appears first.

Key insight: Length ≡ 1 (mod 3) OR length ≡ 2 (mod 3).

Let Σ = (0+1).

Answer: Σ(ΣΣΣ)* + ΣΣ(ΣΣΣ)*

First part: lengths 1, 4, 7, ... (≡ 1 mod 3)

Second part: lengths 2, 5, 8, ... (≡ 2 mod 3)

Strategy — State Elimination Method:

1. If multiple accepting states, add a new single accepting state with ε-transitions from each.
2. Add a new start state with ε-transition to the original start.
3. Eliminate states one by one: for each state q being eliminated, for each pair (p, r) of predecessor and successor, add a direct transition labeled p_to_q · q_loop* · q_to_r.
4. When only start and accept remain, the label on the remaining transition is your regex.

This is algebraic and mechanical — practice it on the 2024 Q4d and 2025 Q4c diagrams.

TRUE. This is the NFA→DFA equivalence theorem. Subset construction converts any NFA to an equivalent DFA. No explanation needed — just write "True."

FALSE. L = {ε, ab, aabb} is a finite language. All finite languages are regular. Since regular languages are closed under complement, Σ*−L is also regular.

TRUE. This is the literal definition of DFA acceptance. No explanation needed.

FALSE. The regex requires the string to start with 'b' (the first symbol is a literal 'b'). But "aaba" starts with 'a'. No string starting with 'a' can match this regex.

FALSE. State equivalence means δ(p,a) and δ(q,a) are equivalent states, not necessarily the same state. Counterexample: Take a minimal DFA; duplicate any accepting state. The two copies are equivalent but δ goes to different (yet equivalent) copies.

TRUE. Take any DFA M. Add redundant states to get NFA N that recognizes the same language. M has fewer states. Alternatively, there are languages where the minimal DFA is smaller than any NFA for that language.

TRUE. Every finite language is regular. The Pumping Lemma holds for all regular languages. Set k = (length of longest string + 1). No string in L satisfies |s| ≥ k, so the condition is vacuously true.

FALSE. For every NFA, subset construction produces an equivalent DFA. No NFA can recognize a language that no DFA can recognize.

FALSE. Regular languages are closed under complement. The complement of any regular language is also regular. (To build a DFA for the complement: flip all accepting states.)

FALSE. Non-equivalence means there exists a string x distinguishing p and q. But the immediate transitions δ(p,a) and δ(q,a) can be the same state. Example: p∈F, q∉F, but δ(p,a)=δ(q,a)=r for all a. Still p≢q (ε witnesses it), but transitions are identical.

FALSE. L has only 101 strings (finite). All finite languages are regular. Complement of a regular language is regular.

TRUE. The first alternative (a+ba)* includes (a)* which contains "aa" (take "a" twice). So aa ∈ L((a+ba)*) ⊆ L((a+ba)* + (ab+ba)*).

TRUE. Classic result: the language of strings where the n-th-from-last bit is 1. An NFA needs n+1 states; every equivalent DFA needs 2ⁿ states. So there exists an NFA that is smaller than every equivalent DFA.

FALSE. This universal claim is false. For many simple languages, a DFA can have fewer or equal states to the NFA. Also, you can always add useless states to an NFA to make it larger than any equivalent DFA. The claim "ALL NFAs have fewer states than ALL equivalent DFAs" is clearly wrong.

TRUE. Use ε as the witness. δ̂(p,ε) = p ∈ F (p accepts ε). δ̂(q,ε) = q ∉ F (q rejects ε). Since the string ε is accepted from p but rejected from q, p and q are not equivalent by definition.

For each claim, state True or False. If False, explain why.

(a) If L₁ and L₂ are both non-regular, then L₁ ∪ L₂ is non-regular.

(b) There exists a DFA with 2 states that recognizes L = {w | w has odd length}.

(c) For all DFAs M: L(M) ≠ ∅.

(d) If L is infinite, then L is non-regular.

(e) For all NFAs N, the subset construction produces a DFA with exactly 2|Q| states.

Solutions:

(a) FALSE. L₁ = {aⁿbⁿ | n≥0} and L₂ = complement of L₁ are both non-regular, but L₁ ∪ L₂ = Σ* which IS regular.

(b) TRUE. States: "even length" (ACCEPT) and "odd length". Start at "even." Every symbol swaps between them.

(c) FALSE. A DFA with no accepting states (F = ∅) recognizes the empty language ∅.

(d) FALSE. L = {a}* = {ε, a, aa, ...} is infinite and regular.

(e) FALSE. The subset construction can produce up to 2|Q| states, but typically far fewer are reachable.

(a) [3 marks] Build a DFA for L = {w ∈ {a,b}* | w contains an even number of a's}.

(b) [2 marks] Build a DFA for L = {w ∈ {0,1}* | the binary number w is divisible by 4}.

Solutions:

(a) Track #a's mod 2. Two states: q_even (ACCEPT, start), q_odd.

Accepting: q_even (ε has 0 a's = even ✓).

(b) Divisible by 4 = last two bits are 00. States track the last two bits read. Start state = "seen nothing" (or ε, which has value 0 → divisible by 4).

NFA over Σ = {a, b}: Q = {0, 1, 2}, s = 0, F = {2}.

Transitions: δ(0,a) = {0,1}, δ(0,b) = {0}, δ(1,a) = ∅, δ(1,b) = {2}, δ(2,a) = ∅, δ(2,b) = ∅.

(a) Describe the language in plain English.

(b) Convert to a DFA via subset construction. Show all work.

Solutions:

(a) The language is: all strings that contain "ab" as a substring. (State 1 = "just saw 'a'", state 2 = "saw 'ab'")

(b) Subset Construction Table:

3 DFA states. Start: {0}. Accept: {0,2}.

Σ = {a, b}. Write regular expressions for:

(a) All strings where every 'a' is immediately followed by 'b'.

(b) All strings of even length that start and end with the same symbol.

(c) All strings where the number of a's is divisible by 3.

(d) All strings that contain neither "aa" nor "bb".

Solutions:

(a) Every 'a' must be followed by 'b'. The only 'a' that doesn't need to be followed by 'b' is... none. So: b*(abb*)* (ε + "nothing") — wait, 'a' must always be followed by 'b'. Answer: (b + ab)*

(b) Even length, start=end=a: a(a+b)*a, even length (total). And start=end=b: b(a+b)*b. But we need even total length. a(a+b)^(2k)a doesn't work directly... Answer: a(a+b)(a+b)*a + b(a+b)(a+b)*b + aa + bb (length 2 base cases plus length 4+).

More cleanly: (a(a+b)*a) + (b(a+b)*b) where the inner part has even length. Constrain inner: a((a+b)(a+b))*a + b((a+b)(a+b))*b

(c) Groups of 3 a's: b*(ab*ab*ab*)* b* — any b's interspersed, a's come in groups of 3.

(d) No "aa" and no "bb" — strings must alternate: ab, ba, aba, bab, abab, ... Answer: (ab)*(ε+a) + (ba)*(ε+b)