If we try to represent tossing a coin or a die, or picking a card out of a deck at random, in logic, how should we do it?

Tossing a coin might look like:

Toss(coin) → (Heads or Tails)

Tossing a die might be:

Toss(die) → (1 or 2 or 3 or 4 or 5 or 6)

Picking a card:

Pick(52 card deck) → (1♣ or 2♣ or … or k♥)

This begs asking, do these statements make sense? For instance look what happens if we try to abstract:

∀x Toss(x)

such that ‘Toss’ represents a random selection of the given object.

But this is weird because Toss is a randomized function and x is not selected randomly in this formula. Perhaps if we added another variable, we could generate the right sort of function:

∀y ∃x Toss(yx)

Then x would be a function of y: we would select x with respect to y. The problem is still that a Toss involves randomness. So this setup is incorrect because treating x as a function of y is not randomized, because y is not random.

How can we represent randomness in logic?

As noted, functions alone will not work. Variables and interpreted objects cannot invoke randomness. Perhaps we can modify some part of our logic to accommodate randomness. The connectives for negation and conjunction haven’t anything to do with randomness either.

But, if we use the game theoretic interpretation of logic, then we can conceive of each quantifier as representing a player in a game. Players can be thought of as acting irrationally or randomly.

Therefore, let’s introduce a new quantifier: Я. Я is like the other quantifiers in that it instantiates a variable.

- Яx T(x)
- Tb

However, Я is out of our (or anyone’s) control. It does instantiate variables when it is it’s turn (just like other quantifiers) but it instantiates randomly. So we have three players, Abelard, Eloise and Random (or the Verifier, Falsifier and Randomizer).

But more is still needed. We need a random selection between specific options, be it between heads and tails, 1-6, cards, numbers, or anything else. One way of doing this would be to create a special domain just for the random choices. Я would only instantiate from this domain, and if there are multiple random selections, we will require multiple indexed domains.

Hence, given D_{i}(Heads, Tails),

Я_{i}x

represents a coin flip since Я randomly instantiates out of the domain containing only Heads and Tails.

(aside:

I prefer to use an artifact of Independence Friendly logic, the dependence indicator: a forward slash, /. The dependence indicator means that the quantifier only depends on those objects, variables, quantifiers or formulas specified. Hence

Яx/(Heads, Tails)

means that the variable x is randomly instantiated to Heads or Tails, since the only things that Яx is logically aware of are Heads and Tails. Therefore this too represents a coin flip, without having multiple domains.)

Now that we have an instantiation rule for Я we also need a negation rule for it. If some object is not selected at random, then it must have been individually selected. In this case the only other players that could have selected the object are ∀ and ∃. Hence the negation rule for Я is just like the negation rule for the other quantifiers: negating a quantifier means that a different player is responsible for instantiation of the variable. If neither player is responsible, it can be considered random: ¬Яx ↔ (∀x or ∃x). We can leave the basic negation rule for ∀ and ∃ the way it is.

Therefore, given the additions of the new quantifier and domain (or slash notation), we can represent randomness within logic.

———

See “Propositional Logics for Three” by Tulenheimo and Venema in *Dialogues, Logics And Other Strange Things* by Cedric Degremont (Editor) College Publications 2008, for a generalized framework for logics with 3 quantifiers. Since the above logic requires either indexed domains or dependence operators, Яandom Logic is a bit different, but it is a good discussion.