Computing Theory Tutorial: Context-Free Grammars & Undecidability

Introduction: Why Computing Theory Matters in 2026

In May 2026, as AI chatbots like ChatGPT-7 and Gemini Pro handle complex language tasks, understanding the theoretical foundations of computation is more relevant than ever. Computing theory—especially context-free grammars (CFGs) and undecidability—underpins how we design programming languages, parse natural language, and understand the limits of algorithms. This tutorial will guide you through key concepts from COSC 1107/1105, using examples inspired by viral apps and game design.

Context-Free Grammars: Building Blocks of Language

A context-free grammar consists of rules that generate strings in a language. Consider the grammar derivations from your assignment. For instance, the derivation S ⇒ aSb ⇒ aaSbb ⇒ aacSdbb ⇒ aacdbb suggests rules like S → aSb, S → cSd, and S → λ. Similarly, derivations involving A and B introduce rules for counting and balancing symbols. Think of this like a viral TikTok filter that generates symmetric patterns: each a must be matched with a b, and each c with a d.

Constructing Rules from Derivations

From the given derivations, we can extract the following rules:

S → aSb | cSd | A | λ
A → xAy | B@ | @C
B → xB | x
C → Cy | y

These rules define a language where strings have a structure similar to nested parentheses, but with multiple symbol types. This is analogous to how a chatbot like ChatGPT-7 ensures that opening and closing tags in a markup language are balanced.

Set Notation for Languages

Expressing the language in set notation helps describe all possible strings. For the grammar above, the language is: L(G) = { w x^i @ y^j (bd(w))^R or w (bd(w))^R | i ≠ j, i,j ≥ 0, w ∈ {a,c}* } where bd(w) replaces a with b and c with d, and R denotes reversal. This is like a game level where you must match the number of keys (x and y) but with different counts, while also mirroring the path.

Regular vs. Context-Free Languages

Is there a regular grammar for L(G)? No, because the language requires comparing counts of x and y (they must differ) and ensuring balanced a/c with b/d. Regular languages cannot perform such counting; they lack memory. This is similar to why a simple regex cannot parse nested HTML tags—you need a CFG.

Constructing a CFG for a Complex Language

Now, let's construct a CFG for L = { x^i w1 @ w2 y^j | i ≠ 2j, i,j ≥ 0, |w1| = |w2|, w1 ∈ {a,c}*, w2 ∈ {b,d}* }. We split into two cases: i < 2j and i > 2j. For i < 2j, we generate extra ys. For i > 2j, extra xs. The grammars are:

G1: S → xxSy | XA; A → Ay | By; X → x | λ; B → aBb | aBd | cBb | cBd | @
G2: S → xxSy | C; C → xC | xD; D → aDb | aDd | cDb | cDd | @

Combine with S → T | U. This is like designing a game where the number of power-ups (x) must be less than twice the number of enemies (y), or vice versa, while the map is symmetric.

Undecidability and NP-Completeness in 2026

In the second part of the assignment, we identify incorrect statements about NP-completeness. For example, factorization is not known to be NP-complete (it's in NP but not proven NP-complete). Also, NP-complete problems are not certainly intractable; they are only believed to be so. The claim that the Traveling Salesperson Problem has an O(n^10) algorithm is false—it's exponential. And the Hamiltonian Circuit problem is NP-complete, not simpler than TSP.

Reduction and the Halting Problem

The halting problem for the Generalized Platypus Game with Gandalf the White is undecidable. We can reduce the standard halting problem to it, similar to how you can reduce the problem of whether a program terminates to a game scenario. This is like proving that no AI chatbot can always determine if a user's request will lead to an infinite loop.

Conclusion: Theory Meets Practice

Whether you're parsing code in a new programming language or analyzing the limits of AI, computing theory provides the tools. By understanding CFGs and undecidability, you gain insight into what computers can and cannot do—a crucial skill in an era of rapid technological change.