Theory of Computation

  1. Automata Theory and Regular Languages
    1. Finite Automata
      1. Deterministic Finite Automata
        1. Formal Definition
          1. State Set
            1. Input Alphabet
              1. Transition Function
                1. Initial State
                  1. Final States
                  2. State Diagrams
                    1. Graphical Representation
                      1. State Transitions
                        1. Accepting Paths
                        2. Language Recognition
                          1. String Acceptance
                            1. Computation Traces
                              1. Language of a DFA
                              2. DFA Construction Examples
                                1. Simple Pattern Recognition
                                  1. Modular Arithmetic
                                    1. String Properties
                                  2. Nondeterministic Finite Automata
                                    1. NFA Definition
                                      1. Nondeterministic Transitions
                                        1. Multiple Next States
                                          1. Epsilon Transitions
                                          2. NFA Computation
                                            1. Parallel Computation Paths
                                              1. Acceptance Criteria
                                                1. Tree of Computations
                                                2. NFA vs DFA Power
                                                  1. Expressive Equivalence
                                                    1. Computational Differences
                                                  2. NFA to DFA Conversion
                                                    1. Subset Construction Algorithm
                                                      1. State Set Construction
                                                        1. Transition Function Definition
                                                          1. Complexity Analysis
                                                          2. Epsilon-NFA Handling
                                                            1. Epsilon Closure
                                                              1. Modified Subset Construction
                                                          3. Regular Expressions
                                                            1. Regular Expression Syntax
                                                              1. Basic Symbols
                                                                1. Union Operator
                                                                  1. Concatenation
                                                                    1. Kleene Star
                                                                      1. Precedence Rules
                                                                      2. Regular Expression Semantics
                                                                        1. Language Denoted by RE
                                                                          1. Recursive Definition
                                                                            1. Examples and Interpretations
                                                                            2. Extended Regular Expressions
                                                                              1. Plus Operator
                                                                                1. Question Mark Operator
                                                                                  1. Character Classes
                                                                                    1. Complement and Intersection
                                                                                  2. Equivalence of Models
                                                                                    1. Regular Expressions to NFA
                                                                                      1. Thompson Construction
                                                                                        1. Base Cases
                                                                                          1. Inductive Cases
                                                                                            1. Union Construction
                                                                                              1. Concatenation Construction
                                                                                                1. Star Construction
                                                                                              2. DFA to Regular Expression
                                                                                                1. State Elimination Method
                                                                                                  1. Elimination Order
                                                                                                    1. Regular Expression Updates
                                                                                                      1. Final Expression
                                                                                                      2. Matrix Method
                                                                                                      3. Closure Under Regular Operations
                                                                                                        1. Union Closure
                                                                                                          1. Concatenation Closure
                                                                                                            1. Star Closure
                                                                                                          2. Properties of Regular Languages
                                                                                                            1. Decision Problems
                                                                                                              1. Membership Problem
                                                                                                                1. Emptiness Problem
                                                                                                                  1. Equivalence Problem
                                                                                                                    1. Finiteness Problem
                                                                                                                    2. Pumping Lemma for Regular Languages
                                                                                                                      1. Statement and Proof
                                                                                                                        1. Pumping Length
                                                                                                                          1. Application Techniques
                                                                                                                            1. Non-regularity Proofs
                                                                                                                            2. Myhill-Nerode Theorem
                                                                                                                              1. Distinguishability Relation
                                                                                                                                1. Equivalence Classes
                                                                                                                                  1. Minimal Automata
                                                                                                                                  2. Closure Properties
                                                                                                                                    1. Union
                                                                                                                                      1. Intersection
                                                                                                                                        1. Complement
                                                                                                                                          1. Concatenation
                                                                                                                                            1. Kleene Star
                                                                                                                                              1. Reversal
                                                                                                                                                1. Homomorphism
                                                                                                                                              2. DFA Minimization
                                                                                                                                                1. Equivalent States
                                                                                                                                                  1. State Distinguishability
                                                                                                                                                    1. Equivalence Testing
                                                                                                                                                    2. Minimization Algorithms
                                                                                                                                                      1. Table-Filling Algorithm
                                                                                                                                                        1. Partition Refinement
                                                                                                                                                          1. Hopcroft's Algorithm
                                                                                                                                                          2. Uniqueness of Minimal DFA
                                                                                                                                                            1. Canonical Form
                                                                                                                                                              1. Isomorphism of Minimal DFAs

                                                                                                                                                          Previous

                                                                                                                                                          1. Introduction to Theory of Computation

                                                                                                                                                          Go to top

                                                                                                                                                          Next

                                                                                                                                                          3. Context-Free Languages