"Propositional logic can represent a lot of things, but it turns out to be too limiting to be practically useful. Every proposition is its own opaque chunk of truthhood or falsity, with no way to break it down into constituent parts. Suppose I wanted to claim that every state in the union had a governor. To state this in propositional logic, I’d have to create a brand new proposition for each state: Let G1 be the proposition that Alabama has a governor. Let G2 be the proposition that Alaska has a governor. Let G3 be the proposition that Arizona has a governor. … and then, finally, I could assert: G1 ∧ G2 ∧ G3 ∧ · · · ∧ G50. What we need is some kind of proposition template, with which we can “mint” new propositions of a similar form by plugging in new values. This is exactly what a predicate is, which forms the basis for predicate logic, or “first-order predicate logic,” to be more exact. A predicate is a formula that yields a proposition for each value of its inputs. For instance, I can define a predicate called “HasGovernor” as follows: Let HasGovernor(x) be the proposition that x is a state that has a governor. Then I can assert: HasGovernor(Virginia) to state that Virginia has a governor. This mechanism alleviates the need to define fifty nearly-identical propositions. Instead, we define one predicate. You can think of a predicate as a function mapping objects to propositions: HasGovernor : Ω → P, where P is the set of all propositions. Note that the domain of this function is Ω, the entire domain of discourse. This means that you can give any individual element from the domain of discourse to the predicate. For instance, we can assert: ¬HasGovernor(mayonnaise), which is perfectly true."