I have encountered the following problem a couple of times. This problem is this: When formalizing something in predicate logic, the predicate uses propositions as variables.^{1} We may refer to this as the predicate acting upon the variable. The predicate is a function similar to functions in mathematics like “F(x) = x4”. Predicates were also written like this (with parentheses) to begin with. Variables are written in the english lower-case letters beginning from x and i.e. {x, y, z, etc.}. For variables that have to do with time ‘t’ is often used. Propositions are written in upper-case english letters beginning with P i.e. {P, Q, R, S, etc.}. What ought one to write, then, when a predicate acts upon propositions? Ought one to switch to lower-case but keep the same letters i.e. {p, q, r, s, t}? We ought to use the way which is the least confusing and which is powerful enough to express whatever meaning clearly we might want to express. Here are some possible ways to formalize it:

- Upper case beginning from P.
- Lower case beginning from p.
- Upper case beginning from X.
- Lower case beginning from x.
- Upper case beginning from P in parentheses.
- Upper case beginning from P in square brackets.
- Upper case beginning from P in curly brackets.
- Upper case beginning from P in sub-script.
- Upper case beginning from P in sup-script.

## Some possible causes of confusion

### Upper case beginning from P

Example: s knows that P is formalized as KsP.

Normally only the predicate is written in upper case e.g. “Fx” and all variables are written in lower case e.g. Rxyz.

### Lower case beginning from p

Example: s knows that P is formalized as Ksp.

Normally propositions are written in the upper case. The confusion may be enhanced when the proposition used in some predicate is also used elsewhere in the analysis without being acted upon by a predicate e.g. Kxp⇒P where “Kxp” means x knows p.

### Upper case beginning from X

Example: s knows that P is formalized as KsX.

Normally propositions are not referred to as “X”. “X” is usually reserved for variables in predicates. So this may cause confusion.

### Lower case beginning from x

Example: s knows that P is formalized as Ksx.

For the same reason as above and that propositions are normally written in the upper case.

### Upper case beginning from P in parentheses.

Example: s knows that P is formalized as Ks(P).

This is sometimes used. Parentheses are normally used for other purposes, so that may cause confusion. The good thing about using some sort of surrounding formalization is that it makes it much less confusing to have the propositional variable be complex e.g. an agent might know that someone knows a proposition logically implies that that proposition is true. Formalized as Ka(Kx(P)⇒P).

### Upper case beginning from P in square brackets

Example: s knows that P is formalized as Ks[P].

I have used this from time to time. I have not seen anyone else use it. It suffers from the same problem as above although to a lesser degree since square brackets are not as commonly used as parentheses. When square brackets are used, then they are usually used as alternate parenthesis. When some wff becomes so complicated that multiple sets of parentheses are needed, then one alternates between regular parentheses and square brackets e.g. (P→[Q→(R↔T)]). It makes it easier to keep track of the parenthesis sets. I sometimes use square brackets to mean that some wff is a formalization of something that was written in normal language. One might combine square brackets with parentheses so one can alternate surrounding characters even within some predicate e.g. an agent might know that someone knows a proposition logically implies that that proposition is true. Formalized as Kx[Kx(P)⇒P].

### Upper case beginning from P in curly brackets

Example: s knows that P is formalized as Ks{P}.

I have never seen this used and I don’t know of any other uses of curly brackets that may be confused with this.

### Upper case beginning from P in sub-script

Example: s knows that P is formalized as Ks_{P}.

Sub-script is sometimes used to number propositions e.g. (P_{1}, P_{2}, P_{3} … P_{n}.) to mean all P propositions. I suppose one could formalize this in second order predicate logic as (∀P)(P). It is usually employed for infinite sets or ‘changing’ sets e.g. a set of premises of an argument.^{2} It is also sometimes used to symbolize an alternate meaning of a word e.g. atheist_{2} but words are not used in wff’s, so that should not be a source of confusion. Another thing is that it may be hard to read since the letters are so small. It’s hard to even see that the “P” is in upper case.

### Upper case beginning from P in sup-script

Example: s knows that P is formalized as Ks^{P}.

I don’t know of any usage of sup-scripts in formalization at all. So I don’t know of any potential sources of confusion. The problem with readability also applies here.

## Summary and conclusion

Given the 9 suggestions above I think one should go with the method of surrounding the acted upon proposition with alternatingly parentheses and square brackets. The reason for choosing this method is that it introduces no new characters, so it is characteristic parsimonious which is important. The less different characters used the better all other things being equal. This is a general fact of language. The curly bracket solution introduces two new characters, “{“ and “}”, but doesn’t have any large advantages as far as I can see over the chosen method. The other methods are either confusing or too hard to read. To make it very simple: The chosen method is both parsimonious and powerful.

1Predicates with more than one variable are sometimes called relations. I shall just refer to them all as predicates in this essay.

2That set is ‘changing’ in the sense that the number of premises vary from argument to argument.