Previously, I talked about my original idea called *propositional stability* - roughly, when a truth-value for a proposition or sentence remains bound by the same range of truth-values after being *transacted* between two logics regardless of the range of truth-values available within the second logic

So, no proposition or sentence assigned *true* or *false* under a classical logic can be assigned say *both true and false* within say a Kleene 3-valued so-called *logic of contradiction* (Priest's *logic of paradox* where a third-truth value is understood as standing for *both true and false* rather than as *indeterminate* which was proposed as a solution to Alethic paradox)

I'd like to take some time to elaborate that concept, discuss two related concepts, and then talk briefly about combined modal logics which have just begun to be studied

Again, importantly, a lot of this discussion fits within the larger logical pluralism debate which regards the feasibility of at least one of the following three theses:

(1) There is no one, sole and universal, logic that structures, limits, defines, or describes all of reality.

(2) There are either multiple truth-predicates/operators, conceptions of truth, and/or alethic inferences underpinning truth-predicates/operators.

(3) There are multiple truth-properties.

That thesis is not as radical as it might at first seem - *abductive* reasoning is common in law, medicine, and science and requires something like a non-monotonic logical framework to truly represent and understand the types of valid inference patterns allowed. Classical logic (Boolean Algebra), however, is *monotonic*.

Definitions

Meta-language: (following Tarski) a language L sufficient for First-Order Logic within which object languages are constructed

Object-language: a language O constructed within a meta-language L - the target language to be specified or built

Cross Logics: two object languages O*1 and O*2 so-constructed in a meta-language L such that they comprise a *transactional logic* are each referred to as the *cross logic* of the other

Logical Transaction: a time-based mechanism or procedure by which a proposition P in a meta-language L also residing in an object language O in L is assigned a new truth-value within the *cross logic* of L

Transactional Logic: a meta-language L implements a *transactional logic* if-and-only-if L contains languages O1, ... that are *cross logics* of each other supporting *logical transactions* between them

Java Overview

This is fairly straightforward and while it works well enough right now I don't want to opensource the entire demonstration quite yet. It's actually pretty simple to put together. In any event, I'd like to begin sharing some of the lower level pieces.

The basic sketch of the implementation is this - we need to fully abstract the concept of a proposition, a logic, truth-values, and any other requisite concept within logic.

Our meta-language is Java, our two object languages will be a Boolean and a P3 logic. We have to reinvent the wheel a bit since we need to be able to translate truth-values from our custom Boolean over into the truth-values of our P3 implementation.

Java Implementation

Here's the top level propositional abstraction:

```
public abstract class SyntacticProposition {
private FregeanSyntacticTruthValue truthValue;
private ArrayList
``` allowed;
private boolean isTruthValueAllowed(FregeanSyntacticTruthValue truthValue) {
return getAllowed().contains(truthValue);
}
public boolean isTruthValueClassAllowed(Class c) {
for (FregeanSyntacticTruthValue syntacticTruthValue : getAllowed()) {
if (c.equals(syntacticTruthValue.getClass())) { return true; }
}
return false;
}
public FregeanSyntacticTruthValue getTruthValue() { return truthValue; }
public void setTruthValue(FregeanSyntacticTruthValue truthValue) {
if (isTruthValueAllowed(truthValue)) { this.truthValue = truthValue;
} else { this.truthValue = FirstTruthValueFregean.getFirstTruthValue(); }
}
public void setAllowed(FregeanSyntacticTruthValue... truthValues) {
for (FregeanSyntacticTruthValue truthValue : truthValues) {
this.allowed.add(truthValue);
}
}
public ArrayList getAllowed() { return this.allowed; }
public boolean check(FregeanSyntacticTruthValue d) { return getTruthValue().equals(d);}

Abstraction of a super classed truth-value in accordance with Frege's truth-value monism - association with Java's native Boolean wrapper of primitive boolean allowed:

```
public abstract class FregeanSyntacticTruthValue {
private HashMap
``` booleanKey;
public void booleanRelate(Boolean b) {
this.booleanKey.put(FregeanSyntacticTruthValue.this, b);
}
public Boolean getBoolean() {
return this.booleanKey.get(FregeanSyntacticTruthValue.this);
}
}

A singleton (here's where we satisfy Frege's view) child of that super class:

```
public class FirstTruthValueFregean extends FregeanSyntacticTruthValue {
private static final FirstTruthValueFregean firstTruthValue = new FirstTruthValueFregean();
protected FirstTruthValueFregean() {}
public static FirstTruthValueFregean getFirstTruthValue() {
return firstTruthValue;
}
}
```

I'll skip over the other two needed for a three-value abstract class:

```
public abstract class ThreeValued implements SyntaticStandardLogic {
public static final FregeanSyntacticTruthValue First = FirstTruthValueFregean.getFirstTruthValue();
public static final FregeanSyntacticTruthValue Second = SecondTruthValueFregean.getSecondTruthValue();
public static final FregeanSyntacticTruthValue Third = ThirdTruthValueFregean.getThirdTruthValue();
public FregeanSyntacticTruthValue implication(Ternary antecedent, Ternary consequent) {
// Only false implication is true ant. + false cons.
if (consequent.check(First) && antecedent.check(Second)) {
return Second;
}
// Overrides subsequent
if (consequent.check(First) || antecedent.check(Second)) {
return First;
}
// Either ant. or cons. is indeterminate/unknown.
return Third;
}
public FregeanSyntacticTruthValue negation(Ternary prop) {
if (prop.check(First)) {
return Second;
}
if (prop.check(Second)) {
return First;
}
return Third;
}
public FregeanSyntacticTruthValue conjunction(Ternary left, Ternary right) {
// False conjunct entails falsity overrides all subsequent
if (left.check(Second) || right.check(Second)) {
return Second;
}
// indeterminate/unknown conjunct entails falsity overrides all subsequent
if (left.check(Third) || right.check(Third)) {
return Third;
}
// Otherwise true.
return First;
}
public FregeanSyntacticTruthValue disjunction(Ternary left, Ternary right) {
// Check if true disjunct first - overrides all others.
if (left.check(First) || right.check(First)) {
return First;
}
// Then check if indeterminate/unknown disjunct second - overrides all subsequent.
if (left.check(Third) || right.check(Third)) {
return Third;
}
// Then check if false disjunct.
if (left.check(Second) || right.check(Second)) {
return Second;
}
return Third;
}
public FregeanSyntacticTruthValue biconditional(Ternary left, Ternary right) {
return conjunction(new Ternary(implication(left, right)), new Ternary(implication(right, left)));
}
public String toString(Ternary prop) {
if (prop.getClass().equals(First)) {
return "First";
}
if (prop.getClass().equals(Second)) {
return "Second";
}
return "Third";
}
public String name() {
return "Three Valued";
}
}
```

Here's the P3 abstract sub class:

```
public abstract class P3 extends ThreeValued {
@Override
public String name() {
return "Priest 3 Valued Propositional Logic of Paradox";
}
@Override
public String toString(Ternary prop) {
if (prop.check(First)) {
return "True";
}
if (prop.check(Second)) {
return "False";
}
return "TrueFalse";
}
}
```

Here, we'll tease out the ability to associate boolean values with our abstracted truth values. To that end, we'll build a simple two-value logic - the two logics share a common abstracted proposition parent class enabling *logical transactions*:

```
public abstract class TwoValued implements SyntaticStandardLogic {
public static final FregeanSyntacticTruthValue First = FirstTruthValueFregean.getFirstTruthValue();
public static final FregeanSyntacticTruthValue Second = SecondTruthValueFregean.getSecondTruthValue();
public FregeanSyntacticTruthValue implication(Binary antecedent, Binary consequent) {
if (antecedent.check(First) && consequent.check(Second)) {
return Second;
} else { return First; }
}
public FregeanSyntacticTruthValue negation(Binary prop) {
if (prop.check(First)) { return Second; }
return First;
}
public FregeanSyntacticTruthValue conjunction(Binary left, Binary right) {
if (left.check(First) && right.check(First)) { return First; }
return Second;
}
public FregeanSyntacticTruthValue disjunction(Binary left, Binary right) {
if (left.check(First) || right.check(First)) { return First; }
return Second;
}
public FregeanSyntacticTruthValue biconditional(Binary left, Binary right) {
return conjunction(new Binary(implication(left, right)), new Binary(implication(right, left)));
}
public String toString(Binary prop) {
if (prop.check(First)) { return "First"; }
return "Second";
}
public String name() { return "Two Valued"; }
}
```

And the specific implementation of that below:

```
public abstract class Boolean extends TwoValued {
@Override
public String name() {
return "Boolean";
}
@Override
public String toString(Binary prop) {
if (prop.check(First)) {
return "1";
}
return "0";
}
}
```

Comments and Interlude

Using the basic pieces specified above, we can now begin to assemble a *transactional logic*