Note that there are other possible interpretations of “primeprime”. For example, since one can multiply integer matrices, there might be a useful concept of “prime matrices”.

For example: Consider only the numbers F=15913… F 1 5 9 13 … — that is, F=k4⁢k+1 k∈N F k k 4 k 1 . It's easy to verify that multiplying two of these numbers still results in a number of the form 4⁢k+1 4 k 1 . Thus it makes sense to talk of factoring such numbers: We'd say that 45 factors into 5⁢95 9, but 9 is considered prime since it doesn't factor into smaller elements of FF.

Interestingly, within FF, we lose unique factorization: 441=9×49=21×21 441 9 49 21 21 , where each of 9, 21, and 49 are prime, relative to FF! (Mathematicians will then go and look for exactly what property of a multiplication function are needed, to guarantee unique factorization.)

The point is, that all relations in logical formula need to be interpreted. Usually, for numbers, we use a standard interpretation, but one can consider those formulas in different, non-standard interpretations!

A long outstanding problem was that of Euclid's parallel postulate: Given a line and a point not on the line, how many lines parallel to the first go through that point? Euclid took this as an axiom (unable to prove that it followed from his other axioms). Non-Euclidean geometries of Lobachevsky and Riemann took different postulates, and got different geometries. However, it was not clear whether these geometries were sound — whether one could derive two different results that were inconsistent with each other.

Henri Poincaré developed an ingenious method for showing that certain non-Euclidean geometries are consistent — or at least, as consistent as Euclidean geometry. Remember that in Euclidean geometry, the concepts “point” and “line” are left undefined, and axioms are built on top of them (e.g., “two different lines have at most one point in common”). While it's usually left to common sense to interpret “point”, “line”, and “a point is on a line”, any interpretation which satisfies the axioms means that all theorems of geometry will hold.

The Poincaré disc is one such interpretation: “point” is taken to mean “a point in the interior of the unit disc”, and “line” is taken to mean “a circular arc which meets the unit disc at right angles”. So a statement like “two points determine a line” can be interpreted as [*] For any two points inside the disc, there is exactly one circular arc which meets the disc at right angles. Indeed, this interpretation preserves all of Euclid's postulates except for the parallel postulate. You can see that for a given line and a point not on it, there are an infinite number of parallel (that is, non-intersecting) lines.

Figure 1: Some lines in the Poincaré disc, including several lines parallel to a line L through a point p.

(Note that the distance function is very different within the Poincaré disc; in fact the perimeter of the disc is off at infinity. Angles, however, do happen to be preserved.)

The critical point of his interpretation of a non-Euclidean geometry is this: it is embedded in Euclidean geometry! So we are able to prove (within the embedding Euclidean geometry) that the disc-postulates hold (e.g., we can prove the statement [*] above as a theorem about circular arcs in Euclidean geometry). Therefore, if there is any inconsistency in non-Euclidean geometry, then that could be parlayed into some inconsistency of Euclidean geometry. Thus, his interpretation gives a proof that the strange non-Euclidean geometry is as sound as our familiar Euclidean geometry.

A well-known problem in computer science — “P vs. NP” — asks whether (for a given problem) it is truly more difficult to find a short solution (when one exists) (“NP”), than it is to verify a short purported solution handed to you (“P”). For example, “Given a set of people and how strong person is, can you partition them into two tug-of-war teams which are exactly evenly matched?” Certainly it seems easier to check that a pair of proposed rosters has equal strength (and, verify that everybody really is on one team or the other) than to have to come up with two perfectly-matched teams. But conceivably, the two tasks might be equally-difficult up to some acceptable (polynomial time) overhead. While every assumes that P is easier than NP, nobody has been able to prove it.

An interesting variant of the problem lets both the problem-solver and the purported-answer-verifier each have access to a particular oracle — a program that will gives instant yes/no answers to some other problem (say, “given any set of numbers, yes or no: is there an even-sized subset whose total is exactly the same as some odd sized subset?”).

It has been shown that there is some oracle which makes the problem-solver's job provably tougher than the proof-verifier's job, and also there is some other oracle problem-solver's job provably no-tougher than the proof-verifier's job.

This means that any proof of P being different from NP has to be subtle enough so that when P and NP are re-interpreted as “P and NP with respect to a particular oracle”, the proof will no longer go through. Unfortunately, this eliminates all the routine methods of proof; we know that solving this problem will take some new attack.

The Löwenheim-Skolem theorem of logic states that if a set of (countable) domain axioms has a model at all, then it has a countable model. This is a bit surprising when applied to the axioms of arithmetic for the real numbers: even though the real numbers are uncountable, there is some countable model which meets all our (finite) axioms of the real numbers!

Note that object-oriented programming is founded on the possibility for nonstandard interpretations: perhaps you have some code which is given a list of Objects, and you proceed to call the method toString on each of them. Certainly there is a standard interpretation for the function Object.toString, but your code is built to work even when you call this function and some nonstandard, custom, overridden method is called instead.

It can become very difficult to reason about programs when the run-time method invoked might be different from the one being called. We're used to specifying type constratins which any interpretation must satisfy; wouldn't it be nice to specify more complicated constraints, e.g. “this function returns an int which is a valid index into [some array]”? And if we can describe the constraint formally (rather than in English comments, which is how most code works), then we could have the computer enforce that contract! (for every interpretation which gets executed, including non-static ones).

An obvious formal specification language is code itself — have code which verifies pre-conditions before calling a function, and then runs code verifying the post-condition before leaving the function. Indeed, there are several such tools about (Java, Scheme). In the presence of inheritance, it's harder than you might initially think to do this correctly.

It is still a research goal to be able to (sometimes) optimize away such run-time verifications; this requires proving that some code is correct (at least, with respect to its post-condition). The fact that the code might call a function which will be later overridden (our “non-standard interpretations”) exacerbates this difficulty. (And proving correctness in the presence of concurrency is even tougher!)

Even if not proving programs correct, being able to specify contracts in a formal language (code or logic) is a valuable skill.

Finally, it is worth noting that many rebuttles of real world arguments (see also some exercises) amount to showing that the argument's form can't be valid since it doesn't hold under other interpretations, and thus there must be some unstated assumptions in the original.