Can second order logic express each (computable) infinitary logic sentence?

Question

In chapter 9 of Ebbinghaus et. al, the logical systems $\mathcal{L}_\text{II}$ ("full" second order logic with standard semantics) and $\mathcal{L}_{\omega_1\omega}$ (countable infinitary logic with finite quantificaton) are introduced. The chapter gives some examples which should indicate why second order logic is rather too expressive. This is taken as motivation for introducing infinitary logic as a slightly less expressive logic system.

Here comes my question. Because second order logic is considered more expressive than infinitary logic, it should be possible to express each (computable) infinitary logic sentence as a (countable?) set of second order formulas, such that both have exactly the same models. One non-constructive way to do this would be to take the class of all models of the infinitary logic sentence, and then take the set of all second order formulas which are valid for all models from that class. Then one would only have to prove that this set of formulas has no other models than the ones used to construct it.

However, I ask myself whether there is also a more constructive way to express a given (computable) inifinitary logic sentence in second order logic by a set of formulas. Some way to implicitly reference some set of formulas in another formula, something like converting some set of formulas $\varphi_i$ to $\forall x (\varphi_i \rightarrow Xx$) and then using $X$ in a clever way in the other formula. Or perhaps it is possible to implicitly write programs in second order logic which both compute the subexpressions and somehow apply the infinite "or" operation to these terms.

Answer 1

I will describe a translation that takes a computable sentence $\phi$ of $L_{\omega_1\omega}$, in some first-order signature, and turns it into a sentence $\phi^*$ in second-order logic with the same signature, so that for any first-order structure $M$, $M$ satisfies $\phi$ if and only if $M$ satisfies $\phi^*$. This can be done under two extra hypotheses: I need the signature to be finite and I only get a translation that works when $M$ is infinite. I don't see yet how to do the general case, which might use a very different method. But this method is interesting (to me at least), even though it gives a stronger conclusion with stronger hypotheses.

When we have infinite models, second-order logic is able to quantify over isomorphic copies of the standard model of Peano arithmetic. Using these (anonymous) copies, it is able to do the coding of syntax that can be done in Peano arithmetic. It only needs the signature to contain equality for this to work, but it needs the model to be infinite in order to get started.

In any of these copies, second-order logic can define the set $T_1$ of numbers $n$ such that $n$ is the code for a first-order formula $\psi$ in the signature of $M$ and $\psi$ holds in $M$. $T_1$ is the smallest set that contains the code of every true atomic formula and is closed under the $T$-schema. The former property of a set can be expressed as a formula because the signature is finite; the latter can be expressed because there are only finitely many logical connectives. Thus the property "$X$ contains the code of every true atomic formula and is closed under the $T$-schema" can be expressed as a formula of second-order logic. Then for any $n$, $n$ is in $T_1$ if and only if $n$ is in every set $X$ that has the property quoted in the previous sentence. Thus in general, if $\phi$ is first order, we could let $\phi^*$ say "$k \in T_1$", where $k$ is the code for $\phi$. Written more explicitly, $\phi^*$ would say "for every model of PA, the term $k$ in this model is in the set $T_1$ defined in this model".

The argument in the last paragraph extends immediately to the computable fragment of $L_{\omega_1\omega}$. The only change is that we have infinite computable conjunctions; they can be handled as another line in the $T$-schema that is used to define $T_1$. Here we assume that an infinite computable conjunction is syntactically represented by the index of the computable function that enumerates the conjuncts.