Multi Valued Logic

The most general extension of ThreeValuedLogic to N-cardinality logic (potentially infinite).

A proposition, informally, is a statement that you can make about a world that possesses a truth value in that world. I.e. "Snow is white", "It is raining outside", etc. are propositions. The use of TwoValuedLogic to reason over worlds operates within the ClosedWorldAssumption; every proposition about a closed world is, by nature, either true or false (or some other duality). Under the ClosedWorldAssumption, you either know or can go measure any particular detail you need; you effectively have omniscient access to every detail about the world. If you can't prove a particular proposition is true, then that proposition must be false. The use of ThreeValuedLogic to reason over worlds operates within the OpenWorldAssumption. By definition, there are some details about an open world that you cannot know (i.e. you don't know, and aren't permitted to measure in the performance of reasoning). Thus, if a particular proposition cannot be proven true or false, it is unknown (or unknowable). (The "cannot be proven" is literal, and different from "will not be proven". You may assume you have a processor that is infinitely fast and has infinite space, so it can solve even undecidable questions, operate with impossibly large numbers, etc.) 

  --(propositions require DependentTyping in a system that carries both open and closed worlds.)
  type proposition = (closedworld -> true|false) & (openworld -> true|false|unknowable)
All worlds are either closed or open; that's a complete dual. Ultimately, any proposition asked of a world will only ever need to return true, false, or (for truly open worlds) unknowable.

Multi-valued logics, thus, are not necessary for reasoning over worlds. Or, at least they are not necessary for reasoning over worlds directly. Instead, these logics are generally utilized for indirectly reasoning about other worlds within systems that often contain incomplete, fuzzy, and potentially incorrect information. In a sense, these systems are epistemic worlds, where the objects consist of knowledge and facts held with varying degrees of confidence. This epistemic world may, itself, be closed or open... e.g. it might be considered closed while reasoning within one's own mind (since you supposedly know what you believe), and open while reasoning about someone else's (since you don't usually know everything someone else knows). Thus, questions of the epistemic world return that some proposition is true, false, or unknown. However, those propositions themselves are generally asking: is <some fact> accepted/known/believed/necessary/possible/etc. in <some other world>. All propositions are indirect.

The most common of such systems is the brain. As such, MultiValuedLogic has a very important place in to ArtificialIntelligence.

The following are in common use across various domains: 

      type truth_primitive = true         --(boolean logic)
                           | false        --(boolean logic)
                           | believed with <confidence> to be <truth_primitive> --(epistemic logic)
                           | necessary    --(modal logic)
                           | possible     --(modal logic)  (... see many other modal logics)
                           | <probability> likely  --(bayesian logic)
                           | <percent> true        --(fuzzy logic)
                           | unknown      --(open-world inherent logic value)
                           | unknowable   --(open-world theoretic logic)
                           | undecided    --(computation-limited logic)
                           | undecidable  --(computation-theoretic logic)

The original three-valued logic was invented (by Łucasiewicz around 1920) to accommodate the idea that some assertions are neither true nor false. Not that their truth or falsehood is unknown (to someone or something); that they literally, objectively *are* neither true nor false. Several three-valued logics are based on this idea; some are based on the notion that assertions can be *both* true and false. Some four-valued logics assume that assertions can be true, false, neither xor both. (Why make such apparently strange assumptions? Usually to try to avoid (or to embrace!) some of the paradoxes that afflict ClassicalLogic?, or to capture the idea that statements about future events can be neither true nor false.) Conversely, the logics that philosophers *do* generally use to reason about things like knowledge and provability are things like IntuitionisticLogic? and flavours of ModalLogic?. These are by and large two-valued logics which are provably not equivalent to any finitely-many-valued logic. (Equivalence to infinitely-many-valued logic(s) is a messier story.) Source: An Introduction to Non-Classical Logic by GrahamPriest?.

BooleanLogic operates within a ClosedWorldAssumption (if you can't prove it's true, then it's false).

BooleanLogic does no such thing. Adding that assumption to BooleanLogic would make incomplete systems inconsistant.

Your objection is unfounded. Incomplete systems are inconsistent with BooleanLogic. For example, proposition 'p', all by itself, has no boolean logic value. Period. It's fundamentally inconsistent with boolean logic. However, by representing 'p' in a ClosedWorldContext?, then you can assume either: "if 'p' is not provable as true, then 'p' is false", or "if 'p' is not provable as false, then 'p' is true". Now 'p' can be given a BooleanLogic value (either true or false). To do this, however, you had to "operate within the ClosedWorldAssumption".

According to what you've just said here, arithmatic on natural numbers is inconsistant. It uses BooleanLogic, and it's provably incomplete. I'm not talking about the set of natural numbers, I'm talking about arithmatic on natural numbers. It is provably incomplete (See GoedelsTheorem.) You need multi-place predicates (and identity) to model arithmetic. BooleanLogic is ZeroOrderLogic?. If it has predicates (with more than zero places) it's at least FirstOrderLogic. Call it FregeanLogic? if you have to.

In representation of Incomplete Systems, where you wish to have consistency, you must use ThreeValuedLogic... which allows proposition 'p' to return the value 'unknown'. In this case, however, there is no excluded middle; BooleanLogic no longer applies.

Now you've switched from the system itself to representing that system. I agree that unless you are dealing only with complete information, you will need some method of handling the incompleteness.

This causes less inconsistency than you might believe. If you can't prove p, then p is false. Thus, Not(p) is true, because p is false. Etc.

It's not that simple. For example, lets define (over the natural number)

Odd(x) ::= There exists a natural number, n, such that 2*n + 1 = x. Even(x) ::= There exists a natural number, n, such that 2*n = x.

Let's y be some unknown value. Which of Odd(y) and Even(y) is true? According to the closed world assumption, both are false. However, we also know that at least one is true.

You need to UnaskTheQuestion, here. You've made a conceptual error in assuming you have a closed world after you say "let y be some unknown value." You don't. 'y' isn't a proposition asked of the world; it is, instead, an object within the world. In a closed world, all such things are known a'priori. By saying you do not know what 'y' is, you've clearly violated your ClosedWorldAssumption. You may no longer use BooleanLogic to answer questions about that world; to do so would be fallacy.

If you wish, you may wrap an open world within a closed world; to do this, you simply reason about what you know about the openworld. The set of things you know is, after all, a closed set objects -- a closed world. (In particular, it is a closed set of data objects.) For example: 

    knowledge :: data = { NaturalNumber(y) is True in theExampleWorld }
Now you may form propositions to ask of your knowledge regarding theExampleWorld. Known(Even(y) or Odd(y)) would be true, and you may ask Known(Even(y)) and receive false, and Not(Known(Even(y))) will properly return True. All of these are correct. All may be calculated with Boolean logic within the ClosedWorldAssumption, given the proper inferencing rules. Everything about the world of reason is in that simple, closed set of data.

Asking Odd(y) within this epistemic world isn't even a valid question, because 'y' is not an object of the world. However, when reasoning -within- the associated open world (theExampleWorld, above), a question such as Odd(y) may be asked directly... it's just that the answer is 'Unknown'.

I thought we were discussing situations where we had incomplete information, so I don't think I'll UnaskTheQuestion. The closed world assumption doesn't even come into play when you have complete information.

The ClosedWorldAssumption IS the assumption that you have complete information regarding the world, even if you don't. It is the assumption that everything that is true is either represented directly or can be derived from the set of things that are in the world. The ClosedWorldAssumption comes into play when you ask a proposition of the world that cannot be proven. The ClosedWorldAssumption insists that it is false. And such a proposition is provably false under this assumption. The ClosedWorldAssumption is violated when you introduce to the world something that you don't have represented. The world you presented ('y' is unknown) is NOT a closed world. This makes your claims that the ClosedWorldAssumption fails to handle this situation rather meaningless. If the assumption is violated, then of course it shouldn't hold.

Which is pretty much the point. Including the ClosedWorldAssumption in BooleanLogic, breaks just about every theory we use BooleanLogic in. BooleanLogic (without that assumption) doesn't have a problem with the situation in question, it simply doesn't prove any of these statements, Even(y), Not(Even(y)), Odd(y), and Not(Odd(y)). But if we include the closed world assumption, we have to prove two of those, and I don't see any obvious way of picking which ones. (The only consistant choices are Even(y) and Not(Odd(y)), or Not(Even(y)) and Odd(y), but how do you pick which one of those two?).

In any case, I know what 'y' is. 'y' is a variable that ranges over objects in the world. y is an object in the world. (To be clear, y is an object, not a variable.) Even(y) and Odd(y) are statements about the world. We cannot prove Even(y). We cannot prove Odd(y). According to the closed world assumption, both Even(y) and Odd(y) are false, but we can prove that Even(y) v Odd(y). This is a problem, and it's caused adding the closed world assumption to BooleanLogic.

Your proposed Even(y) and Odd(y) are not statements about a closed world. I've explained this well enough above. Their use does not provide a relevant argument, and I'll let you be the one to scroll upwards and study why. Here's a short mental challenge to you: What is the correct value of Even(y), given only BooleanLogic (true/false)?

Whatever the model says it is. It's the model that assigns the truth values, not BooleanLogic.

It is BooleanLogic that carries the truth values. When you ask a proposition of a world, you receive an answer in the form of a truth primitive. For a closed world, this truth primitive must be from BooleanLogic. No other answer is legal. For other models, you don't need to answer with BooleanLogic... but, in those cases, you are simply no longer using BooleanLogic (well... no more than ThreeValuedLogic "isn't using BooleanLogic"; BooleanLogic may be subsumed by a wider logic). Anyhow, you're the one claiming you have a closed world, and you're the one asking a proposition of it. You can't dodge this question and claim you have a closed world. So, what. is. your. answer?

(See also BooleanLogic, ThreeValuedLogic, TwoValuedLogic, BooleanAlgebra, DataBase, WhatIsData)

CategoryLogic

EditText of this page (last edited November 15, 2006) or FindPage with title or text search