nihil architecture blogs

This is probably extremely useless info for most people and trivial for others but I just realized this and it’s too elegant to not bother the few that both don’t know of it and care about it with it. Basically, in mathematics there is a principle called ‘from a contradiction follows all’, or when you’ve stumbled on a contradiction, any proposition that can be expressed in your language is automatically true. Or rather, you may infer from that any so called ’sentence’ from your language, as sentences negated are also sentences… well… contradictions lead to contradictions. Often a contradiction is defined as for any sentence S, if we can derive:

S ∧ ¬S

We have a contradiction, the ¬ symbol takes a sentence, and negates it, which basically says that its falsity is true (note that that is different from saying that it’s not true or that it ’s false, but we’ll ignore that henceon for convenience sake.) and ∧ just means ‘and’.

So, how can we prove from that every other sentence? Well, it’s really quite simple:

1. S ∧ ¬S
2. S ∨ T (since S is true, then surely only S is true, or only T, or both for any random T)
3. T (but we just said that the falsity of S is true, and since S or T are true, if S is false, then T must be true right?)

Well, there you have it, any random sentence T with a truth value can be easily demonstrated to be true, which is… unhandy, it’s not that inconsistent mathematics is ‘wrong’, it’s just not very practical and above all not very interesting.

Logical systems may have another property, that’s called functional completeness, functional completeness basically means that we can compose from our functions all possible functions that take any number of arguments from {0,1} (true and false) and return a member of {0,1}. So what we want is basically a system in which we can construct any permutation of truth values. Now truth operations are in principle functions, when we say S ∧ T we can also express that concept as ∧(S,T) = 1.

Most often, the canonical example given for a system that is functionally complete is a system that contains the operations ∧,∨,→,¬ or AND, OR, IMPLIES, and NOT respectively, which may be defined as:

• AND: (1,1) » 1; else: 0
• OR: (0,0) » 0; else: 1
• NOT: (0) » 1; (1) » 0
• IMPLIES: (1,0) » 0; else: 1

It should become apparent that NOT is quite special as it’s the only function to take one argument. But this definition is extremely redundant because we may construct IMPLIES as follows:

S → T := ¬S ∨ T

Just do the maths, they return the same value each on the same inputs, so we can scrap IMPLIES from the list and still retain functional completeness, after all, we can construct it from the other functions. But it doesn’t end there, we can also scrap OR from the list by:

S ∨ T := ¬(¬S ∧ ¬T)

Quite intuitive, at least one of them is true if it’s not true, that both of them are not true, right? If both of them are not true, then surely not one of them can be true? So, we have a functionally complete system with only NOT and AND as we can construct the rest from it. But it goes on, we could have also opted to scrap AND by:

S ∧ T := ¬(¬S ∨ ¬T)

Both of them are true if and only if it isn’t true that at least one of them is not true, right? So, NOT and OR alone is also functionally complete. Lastly, the least intuitive one is this:

S ∨ T := (S → T) → T

Or, at least one of S,T is true if that S implies T is true implies T. Walk with me on this one, say that S is true here, then T is true, if T is true follows from that then as T implies itself of course, T is also true, thus the whole picture is true if S is true regardless of the other situation. If T is true, then S doesn’t matter any more and the fact that S implies T is irrelevant to the truth of T, so if T is true this picture also implies T, thus we have established that this returns true at least if either S or T are true. Now we want it to return false if both aren’t true. Well, we already established that IMPLIES returns true in any case that it’s first argument is not true. Thus it collapses, by that to TRUE → FALSE, which by the definition above is the only possible combination of arguments that results into FALSE.

So we’ve established that AND can be constructed using only OR and NOT, that OR can be constructed using only IMPLIES and NOT, and that OR can be constructed using only AND and NOT and that IMPLIES can be constructed using only AND and NOT, so, for a functionally complete system all we need is NOT, and one of the others. People just love redundancy don’t they?

This is all fine and nice, but back to that contradiction, how do we define it, well, we stated S ∧ ¬S, that’s the most common, but not the only way, another is: S → ¬S, for surely if a sentence implies its own negation, that automatically leads to the former definition? And lastly, you guessed it ¬(S ∨ ¬S) . So, it all falls into place, if a system can state a contradiction, it is functionally complete, if it is functionally complete it can state a contradiction, another one of those fine things which show why God hates us and why all systems that have some useful and cool property automatically also have a major downside that comes with it.

And no—you zealots of rigour, this is not intended as a proof, this is an illustration, I’m not going to Hilbert-style this on a blog that’s mainly for a relative take on holocaust denial.