Mathematical Foundations for Computing

  1. Induction and Recursion
    1. Mathematical Induction
      1. The Principle of Mathematical Induction
        1. First Principle of Induction
          1. Structure of Inductive Proofs
          2. The Basis Step
            1. Establishing the Base Case
              1. Multiple Base Cases
              2. The Inductive Step
                1. Inductive Hypothesis
                  1. Proving the Implication
                  2. Writing Inductive Proofs
                    1. Proof Templates
                      1. Common Techniques
                      2. Common Pitfalls in Induction
                        1. Incorrect Base Cases
                          1. Faulty Inductive Steps
                            1. Assuming What You Want to Prove
                            2. Strong Induction
                              1. Principle of Strong Induction
                                1. When to Use Strong Induction
                                  1. Examples of Strong Induction
                                    1. Relationship to Weak Induction
                                  2. Recursive Definitions
                                    1. Recursively Defined Functions
                                      1. Base Cases and Recursive Cases
                                        1. Examples and Construction
                                          1. Well-Defined Recursive Functions
                                          2. Recursively Defined Sets and Structures
                                            1. Sequences
                                              1. Trees
                                                1. Strings
                                                  1. Natural Numbers
                                                2. Structural Induction
                                                  1. Principle of Structural Induction
                                                    1. Applications to Data Structures
                                                      1. Induction on Trees
                                                        1. Induction on Lists
                                                        2. Recursive Algorithms
                                                          1. Design Principles
                                                            1. Divide and Conquer
                                                              1. Base Cases and Recursive Cases
                                                                1. Ensuring Termination
                                                                2. Classic Recursive Algorithms
                                                                  1. Factorial Computation
                                                                    1. Fibonacci Numbers
                                                                      1. Tower of Hanoi
                                                                      2. The Merge Sort Algorithm
                                                                        1. Recursive Structure
                                                                          1. Merging Process
                                                                            1. Time Complexity Analysis
                                                                            2. The Binary Search Algorithm
                                                                              1. Recursive Implementation
                                                                                1. Iterative Implementation
                                                                                  1. Correctness Analysis
                                                                                  2. Proving Correctness of Recursive Algorithms
                                                                                    1. Base Case Verification
                                                                                      1. Inductive Step
                                                                                        1. Termination Arguments
                                                                                      2. Recurrence Relations
                                                                                        1. Modeling with Recurrence Relations
                                                                                          1. Examples from Algorithms
                                                                                            1. Setting Up Recurrences
                                                                                              1. Initial Conditions
                                                                                              2. Solving Linear Recurrence Relations
                                                                                                1. Homogeneous Recurrence Relations
                                                                                                  1. Characteristic Equations
                                                                                                    1. Distinct Roots
                                                                                                      1. Repeated Roots
                                                                                                        1. Nonhomogeneous Recurrence Relations
                                                                                                          1. Particular Solutions
                                                                                                          2. The Master Theorem
                                                                                                            1. Statement of the Master Theorem
                                                                                                              1. Application to Divide-and-Conquer Algorithms
                                                                                                                1. Cases and Examples
                                                                                                                  1. Limitations of the Master Theorem

                                                                                                              Previous

                                                                                                              4. Integers and Number Theory

                                                                                                              Go to top

                                                                                                              Next

                                                                                                              6. Counting and Combinatorics