Statement Forms and Truth Tables

TL;DR

You'll learn how to break down complex sentences into their basic logical structure, called a statement form. Then, you'll use truth tables to systematically figure out all possible truth values for these forms. This helps you understand when a complex statement is true or false under different conditions.

1. The Mental Model

Think of statement forms as the blueprints for sentences, showing how simple ideas are connected. Truth tables are like testing those blueprints under every possible scenario to see if the overall structure holds true or falls apart.

2. The Core Material

When we analyze compound statements in logic, we're not always interested in what they mean in everyday language, but rather their logical structure and how their truth value depends on the truth values of their parts.

What's a Statement Form?

Photo by RDNE Stock project on Pexels

A statement form is the underlying logical structure of a compound statement, represented by statement variables (like p, q, r) and logical connectives (like 'and', 'or', 'not', 'if...then'). It's like an algebraic expression, but for logic.

For example, the statement "It is raining and I am happy" has the form p AND q, where p is "It is raining" and q is "I am happy".

Here are the basic logical connectives and their symbols:

• NOT (Negation): ~ or ¬ (e.g., ~p means "It is not raining")
• AND (Conjunction): ∧ (e.g., p ∧ q means "It is raining AND I am happy")
• OR (Disjunction): ∨ (e.g., p ∨ q means "It is raining OR I am happy")
• IF...THEN (Conditional): → (e.g., p → q means "IF it is raining THEN I am happy")
• IF AND ONLY IF (Biconditional): ↔ (e.g., p ↔ q means "It is raining IF AND ONLY IF I am happy")

Building Truth Tables

Photo by Magda Ehlers on Pexels

A truth table systematically lists all possible combinations of truth values (True/T or False/F) for the simple statements in a statement form, and then shows the resulting truth value for the entire compound statement.

The number of rows in a truth table is 2^n, where n is the number of unique simple statements (variables). So, for p and q, you'll have 2^2 = 4 rows. For p, q, and r, you'll have 2^3 = 8 rows.

Let's look at the truth tables for the basic connectives:

graph TD
    subgraph Negation (~p)
        p1["T"] --> p_not1["F"]
        p2["F"] --> p_not2["T"]
    end

    subgraph Conjunction (p ∧ q)
        pq1["T, T"] --> pq_and1["T"]
        pq2["T, F"] --> pq_and2["F"]
        pq3["F, T"] --> pq_and3["F"]
        pq4["F, F"] --> pq_and4["F"]
    end

    subgraph Disjunction (p ∨ q)
        pq5["T, T"] --> pq_or1["T"]
        pq6["T, F"] --> pq_or2["T"]
        pq7["F, T"] --> pq_or3["T"]
        pq8["F, F"] --> pq_or4["F"]
    end

    subgraph Conditional (p → q)
        pq9["T, T"] --> pq_cond1["T"]
        pq10["T, F"] --> pq_cond2["F"]
        pq11["F, T"] --> pq_cond3["T"]
        pq12["F, F"] --> pq_cond4["T"]
    end

    subgraph Biconditional (p ↔ q)
        pq13["T, T"] --> pq_bi1["T"]
        pq14["T, F"] --> pq_bi2["F"]
        pq15["F, T"] --> pq_bi3["F"]
        pq16["F, F"] --> pq_bi4["T"]
    end

To build a truth table for a complex statement form, you work from the innermost operations outwards, just like in algebra.

1. List all simple statement variables.
2. List all possible combinations of truth values for these variables (2^n rows).
3. Add columns for each logical operation, following the order of operations (parentheses first, then negations, then conjunctions/disjunctions, then conditionals/biconditionals).
4. Fill in each column based on the truth tables of the basic connectives.

3. Worked Example

Let's build a truth table for the statement form (p ∧ q) → (~p ∨ q).

1. Identify simple statements: p, q.
2. Number of rows: 2^2 = 4 rows.
3. Columns for basic parts: p, q, p ∧ q, ~p, ~p ∨ q, (p ∧ q) → (~p ∨ q).

Notice that the final column is all Ts. This means this particular statement form is a tautology—it's always true, regardless of the truth values of p and q.

4. Key Takeaways

• A statement form is the abstract logical structure of a compound statement using variables and connectives.
• Truth tables systematically show every possible truth value for a compound statement given its simple parts.
• The number of rows in a truth table is determined by 2^n, where n is the number of unique simple statements.
• You build truth tables step-by-step, evaluating innermost operations first, similar to algebraic order of operations.
• Understanding basic connective truth tables (AND, OR, NOT, IF...THEN, IF AND ONLY IF) is crucial for building complex ones.
• A statement form that is always true is called a tautology.
• A statement form that is always false is called a contradiction.

Common Mistakes to Avoid:
- Miscounting the number of rows needed for a truth table (always 2^n).
- Incorrectly applying the truth values for conditional statements (p → q is only false when p is true and q is false).
- Forgetting to negate a statement (~p) correctly in a column.
- Not working through the operations in the correct order (e.g., doing an OR before a NOT within parentheses).

5. Now Try It

Construct a truth table for the statement form ~(p ∨ q) ↔ (~p ∧ ~q). Your success will be a truth table with 4 rows and 7 columns (p, q, p ∨ q, ~(p ∨ q), ~p, ~q, ~p ∧ ~q, and the final ~(p ∨ q) ↔ (~p ∧ ~q)), where the final column shows all Ts (meaning it's a tautology, illustrating De Morgan's Law).