I’ve included three posts I particularly like in this week’s summary:

The first, ‘On semantic ambiguity in Anselm of Canterbury’s argument for God’s existence‘, asks the question ‘just how many readings of St Anselm’s ontological argument for the existence of God are there’. Based on ambiguities in the argument’s minor premise alone, I show that there are at least ten.

The second, ‘On logical fallacies employed in the philosophical use of the term ‘tautology’‘ shows that philosophical invocations of the term play on two ambiguities in the term itself. The first justifies the fallacious inference from a statement’s being true by meaning to its being uninformative. The second justifies the mistaken conclusion that claims of existence and claims of meaning are distinct in kind, and hence not inferrable from each other.

The final post, ‘Object-oriented programming objects aren’t objects‘, argues that a common analogy used to compare the objects of programming languages like C# and Java to real-world objects breaks down rather quickly. Instead, I show that programming objects are actually closer to to the philosophical account of objects found in Leibnizian monads than they are to objects as commonly understood.

Object-oriented programming is a computing paradigm implemented in widely used programming languages like Java and C#. It is often described colloquially in terms of the following intuitively plausible ideas:

• The most basic beings in the universe are particular objects
• Objects belong to kinds, mathematically represented as classes
• Objects have states and behavior, which are represented mathematically by fields and methods.

States and behavior can only belong to things, which themselves belong – in a different sense – to kinds. To enforce this, object-oriented programming requires fields and methods for kinds of objects to be attached to an associated class. This is usually achieved by placing the code for the methods and fields an object of a given class may have within brackets {} that give the code for the class as a whole. When this happens, fields and methods are said to be encapsulated in their class.

Since objects belonging to one class can belong to a second class by virtue of belonging to the first, as e.g. whatever is a chihuahua is thereby a dog, objects in one class are able to inherit the behavior of other classes – if there are any behaviors or characteristics that all dogs have in common, chihuahuas will also have them.

The principles specifying the above general ideas in ways appropriate for programming languages are called encapsulation and inheritance, and these are two of the basic principles of every object-oriented programming language.

1 Object-oriented programming objects aren’t objects

Once one gets past the analogies, however, one realizes that very little object-oriented programming actually conforms to the pre-theoretical explanation given above. To explain this, it will be useful to take a look at a very simple class from an object-oriented language, Java.

class Bicycle {

    int cadence = 0;
    int speed = 0;
    int gear = 1;

    void changeCadence(int newValue) {
         cadence = newValue;
    }

    void changeGear(int newValue) {
         gear = newValue;
    }

    void speedUp(int increment) {
         speed = speed + increment;   
    }

    void applyBrakes(int decrement) {
         speed = speed - decrement;
    }

    void printStates() {
         System.out.println("cadence:" +
             cadence + " speed:" + 
             speed + " gear:" + gear);
    }
}

The above is an example of a bicycle class taken from the Java Tutorials, a series of tutorials for learning the Java language put out by Oracle, who have held the rights to the language since their acquisition of Sun Microsystems, the language’s creator, in 2010. The class’ fields are cadence, speed, and gear. In this case, the fields do seem to fit into a (non-exhaustive) list of properties that a bicycle can have.

The class’ methods, however, don’t reflect the pre-theoretical intuition at all. Instead of representing behaviors of the object itself, these methods represent ways that the fields of an object can themselves be changed or acted on: the changeCadence() method, for instance, doesn’t reflect an action performed by the bike itself, but one that the bike’s rider could perform to it. Worse, the printStates() method, which prints the bicycle’s cadence, speed, and gear to a terminal, doesn’t reflect anything that someone could do with an actual bicycle. Instead, it represents a task that a program or user can perform on an instance of the bicycle class understood precisely as a digital object in digital space.

In short, real-world objects have states and behavior. Objects in object-oriented programming (OOP) have analogues to these called fields and methods. The fields of object-oriented objects parallel the states of real-world objects more or less faithfully. But the parallel between the methods of object-oriented objects and the behavior of real-world objects breaks down relatively quickly, for two reasons. The first is that more often than not, the methods of object oriented objects do not represent things the object can do, but things that can be done to the object. Second, objects in object-oriented languages don’t neatly distinguish between methods that act on the object in accordance with the nature of the object it is intended to represent (e.g. as pedal() method might work on a bicycle object), and methods that act on the object precisely as a bundle of code within a computer program. Instead, there is a blending together of larger reality that the object is meant to represent with that which it is, as a piece of code, actually a part of.

2 What are OOP objects?

What, then, are OOP Objects? Better yet, what is it that makes such objects unified in some way, rather than random bundles of code? And accordingly, what is it that makes some OOP objects better conform to the ideal of an OOP object than others?

To answer this question, let’s look at one more example:

public class Card {
    private final int rank;
    private final int suit;

    // Kinds of suits
    public final static int DIAMONDS = 1;
    public final static int CLUBS    = 2;
    public final static int HEARTS   = 3;
    public final static int SPADES   = 4;

    // Kinds of ranks
    public final static int ACE   = 1;
    public final static int DEUCE = 2;
    public final static int THREE = 3;
    public final static int FOUR  = 4;
    public final static int FIVE  = 5;
    public final static int SIX   = 6;
    public final static int SEVEN = 7;
    public final static int EIGHT = 8;
    public final static int NINE  = 9;
    public final static int TEN   = 10;
    public final static int JACK  = 11;
    public final static int QUEEN = 12;
    public final static int KING  = 13;

    public Card(int rank, int suit) {
        assert isValidRank(rank);
        assert isValidSuit(suit);
        this.rank = rank;
        this.suit = suit;
    }

    public int getSuit() {
        return suit;
    }

    public int getRank() {
        return rank;
    }

    public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

    public static String rankToString(int rank) {
        switch (rank) {
        case ACE:
            return "Ace";
        case DEUCE:
            return "Deuce";
        case THREE:
            return "Three";
        case FOUR:
            return "Four";
        case FIVE:
            return "Five";
        case SIX:
            return "Six";
        case SEVEN:
            return "Seven";
        case EIGHT:
            return "Eight";
        case NINE:
            return "Nine";
        case TEN:
            return "Ten";
        case JACK:
            return "Jack";
        case QUEEN:
            return "Queen";
        case KING:
            return "King";
        default:
            //Handle an illegal argument.  There are generally two
            //ways to handle invalid arguments, throwing an exception
            //(see the section on Handling Exceptions) or return null
            return null;
        }    
    }
    
    public static String suitToString(int suit) {
        switch (suit) {
        case DIAMONDS:
            return "Diamonds";
        case CLUBS:
            return "Clubs";
        case HEARTS:
            return "Hearts";
        case SPADES:
            return "Spades";
        default:
            return null;
        }    
    }

    public static void main(String[] args) {
    	
    	// must run program with -ea flag (java -ea ..) to
    	// use assert statements
        assert rankToString(ACE) == "Ace";
        assert rankToString(DEUCE) == "Deuce";
        assert rankToString(THREE) == "Three";
        assert rankToString(FOUR) == "Four";
        assert rankToString(FIVE) == "Five";
        assert rankToString(SIX) == "Six";
        assert rankToString(SEVEN) == "Seven";
        assert rankToString(EIGHT) == "Eight";
        assert rankToString(NINE) == "Nine";
        assert rankToString(TEN) == "Ten";
        assert rankToString(JACK) == "Jack";
        assert rankToString(QUEEN) == "Queen";
        assert rankToString(KING) == "King";

        assert suitToString(DIAMONDS) == "Diamonds";
        assert suitToString(CLUBS) == "Clubs";
        assert suitToString(HEARTS) == "Hearts";
        assert suitToString(SPADES) == "Spades";

    }
}

The above provides an example of a Card class, again taken from Oracle’s Java tutorials. Let’s walk through it.

After the name of the class and an initial curly brace, two fields are declared: rank and suit. After this follow all the kinds of suits, then the kinds of ranks. This is followed by a special kind of method, called a constructor, which may be used by other objects to generate an instance of the Card class, then a pair of methods getSuit() and getRank(), which respectively provide, or return, the value of the suit and rank of a card object to whatever object makes use of, or calls, these methods. This pair of functions belongs to a larger class of methods called getters, whose naming and functionality follow a longstanding coding convention. This is followed by two Boolean methods isValidRank() and isValidSuit(), the methods suitToString() and rankToString(), and the main() method. The Boolean methods, named after the logician George Boole, are so-called because the values they return are ‘true’ and ‘false’, which are represented by the numbers 1 and 0 in the two-valued Boolean number system all computers use. The ToString() methods convert an integer data type to a corresponding string of letters. For instance, when provided the number 2, the rankToString() method returns the string ‘Two’. Common best practice for real-world Java applications places the main method in its own, separate Main class, so we’ll leave that method aside for now.

In short, the Card class above consists of two fields, representing common properties of a card object, a makeshift identification of the card ranks and suits with integers that makes them easier to functionally manipulate, and a set of methods that perform various operations on the card’s fields. Related classes are bundled together into a package, which are to Classes what a file folder is to files.

3 Objects as monads

Thus, object-oriented programming classes are integrated into a larger whole, and have methods that act reflexively on their states, where these methods may treat the things they act on either in accordance with the nature of what they represent or in accordance with their nature as objects in an program. Because of the first condition, classes themselves serve as abstract parts in an abstract whole. When a program using these classes is run, objects which are instances of these classes are created and their methods are used in accordance with user input and the instructions in the code itself.  Because of this, objects can, in turn, exist in other objects.

Philosophy has a name for an object which may exist in another object, has behavior which is reflexive upon its own state, and responds to the behavior of other objects through its own spontaneous behavior, such that all these beings exist as part of a harmoniously working whole: a monad. The term goes back to Gottfried Leibniz, who introduced the concept to provide a unified solution  to the problems involved in explaining both interactions between different bodies and the relation of the body to the soul. On Leibniz’s account, objects don’t genuinely change each other’s states. Instead, God so closely harmonized these various objects in their nature at the beginning of creation that a change in one object would automatically result in a corresponding, albeit spontaneous, change in others. Object-oriented objects act on their own states, exist as parts in a harmonious whole and are all ordered by one dominant method called the main method, just as Leibniz’s monads act reflexively on themselves in a harmonious world ordered perfectly by God from creation.

4 Conclusion

Though object-oriented programming objects are often presented as being strictly analogous to real-world objects, this analogy breaks down fairly quickly. While OOP fields are similar to the static properties of real-world objects, the dynamic behavior of OOP objects is fundamentally different from that of real-world objects: OOP methods don’t explicitly distinguish instances of classes as representations from those same objects as instances of code, and the methods bundled together in a class are bundled with that class (rather than another) because of the manner in which they reflect on, utilize, or otherwise manipulate the object’s more basic states. OOP classes are parts in a whole package, and the methods listed for a given class will depend on the role it plays in that whole (or a similar one). When a program is run, the exact order in which various objects act is given by a master method called the main method, usually set off in its own class. In these ways, objects which instantiate classes in packages are closer to the philosophical account of objects found in Leibniz’s account of monads as parts of a harmonious world which act reflexively on their own states in a manner God coordinates, than they are to objects as commonly understood.

The term ‘tautology’ is ambiguous between two closely related meanings.

In the stricter sense, it refers to a statement that is both true by definition and grasped immediately — similar to how the term ‘axiom’ was understood in Euclidean mathematics.

In the broader sense, it refers to a statement that is true by definition, regardless of whether it is grasped immediately. In this latter sense, nearly the whole of mathematics is tautologous.

When something is called a tautology, the above ambiguity is played on by implying that something is tautological in the stricter sense, i.e. that it states something obvious and uninformative, when it is merely tautological in the broader sense. But the fact that something is contained in the meaning of a term implicitly does not imply that it is contained in the meaning of the term explicitly.

The notion of a tautology further suffers from being part of a longstanding, albeit false dichotomy between claims that are true by meaning, or analytic, and those that are statements of empirical facts. Particularly, claims of existence are thought to belong to the latter category, while claims that bear on the meanings of things are thought to be irrelevant to questions of whether something exists.

But every relevant proof of any conclusion relies on predicating meaningful descriptive claims of objects mentioned in those arguments. When those things exist, meaningful truths about those existing things are deduced from non-empirical claims. Furthermore, not all existence proofs are themselves empirical. Proofs of the existence of fixed points in mathematics, for instance, are non-empirical. Likewise, the existence of the planet Neptune was first implied by a proof from irregularities in the orbit of the planet Uranus, and then confirmed by observation.

1 An 11th century benedictine monk’s argument for the existence of God

In the second half of the 11th century, St. Anselm of Canterbury, then a benedictine monk at Bec abbey in northern France, formulated what would become perhaps the most famous argument in all of medieval philosophy. It goes like this.

1. God is that than which nothing greater can be thought.
2. That than which nothing greater can be thought really exists.
3. Therefore, God really exists.

The first premise listed is called the minor premise: it provides the term that will be the subject term in the conclusion, namely ‘God’. The second premise is called the major premise: it provides the term that will be the predicate in the conclusion, namely ‘exists’. Both terms are linked to each other by a common middle term, namely ‘that than which nothing greater can be thought’. The major premise itself is supported by an argument moving from an elucidation of what is implied in this middle term to the conclusion that anything that truly answers to that description must, in fact, exist. That argument, stated informally, is as follows:

Suppose, for the sake of argument, that that than which nothing greater can be thought does not exist. Call this non-existent entity than which nothing greater can be thought a. Now an entity, call it b, can be thought, which is in every way like a except that it really exists. But really existing is better than not really existing. Therefore if two entities are alike with respect to all qualities except existing, that which exists is greater. Therefore, b is greater than a. Therefore, there is something greater than a that can be thought. Therefore, there is something greater than that than which nothing greater can be thought that can be thought. Therefore, since b is greater than it, that than which nothing greater can be thought is not that than which nothing greater can be thought. Thus, the assumption that that than which nothing greater can be thought doesn’t really exist leads to a contradiction, and thus must be denied. Therefore, that than which nothing greater can be thought really exists. Therefore, God really exists.

In what follows, I only intend to point out the various ambiguities in the key term of the argument. There are thus multiple different readings of the main premise.

2 Ambiguities in the argument

2.1. Predicative and attributive readings of the argument’s middle term

The first ambiguity is that between what modern linguistics calls predicative and attributive readings of the minor premise.

In a statement of the form ‘A is BC’, where A is the subject term and B and C are adjectives, ‘A is BC’ is predicative if it implies both ‘A is B’ and ‘A is C’. Thus, since ‘Clifford is a red dog’ implies both that Clifford is red and that Clifford is a dog, ‘red’ and ‘dog’ are both predicated predicatively of Clifford. If such an inference cannot be made, then the reading of the predication is attributive. Thus, ‘Rashad is a good quarterback’, is read attributively, since it doesn’t imply anything about him being good as an individual.

In the ontological argument, the predicative reading takes the attributions of God’s thinkability and nothing being greater than him as separate: God is thinkable, and nothing is greater than him. In the attributive reading, these are not separated: this reading states that nothing can be thought to be greater than God – leaving aside whether anything, in fact, is.

2.2 Ambiguities in the domain of the term ‘nothing’

The second ambiguity is in what the term ‘thing’ in the compound word ‘nothing’ ranges over. On the weaker reading, the term ranges over existing things: nothing that exists can be thought to be greater than god – this reading leaves aside whether something that merely could exist can be thought to be so. On the stronger reading, the term encompasses not merely things that do exist, but also things that can exist, used to exist, will exist, or even can be thought to exist: no possible or conceivable thing greater than god can be thought.

2.3 Ambiguities in how the term ‘God’ is taken

The third ambiguity arises for the attributive reading, in whether the term ‘God’ is taken for the thing it refers to, or for the thing it refers to in the manner it refers to it. In the DC comic, Lois Lane believes that Superman is Superman. Since Superman is Clark Kent, she thus believes that the thing that answers to the name ‘Clark Kent’ is Superman. But since glasses are such a great disguise, she doesn’t believe the term ‘Clark Kent’ actually refers to Superman, and thus, doesn’t directly believe that Clark Kent is Superman. In like manner, someone may hold that nothing can be thought to be greater than x, where x is the thing that we call ‘God’, described in some fashion. For instance, one can believe that nothing can be thought to be greater than the creator of the universe. But one can also hold that nothing can be greater than God, taking the term ‘God’ to carry the full weight of its proper meaning – e.g. that if the proper meaning of the term is ‘an all-knowing, all-good, all-powerful being’, than nothing can be greater than that. For short, I will say that when a sentence is assessed by taking a term for what it refers to, but not under the description that the term gives, that term is read objectively; when a sentence is read by taking the object referred to by a term as the term describes it, that term is read descriptively.

2.4 Ambiguities in how the term related to god by the ‘greater than’ relation is taken

The same ambiguity arises for the second related term in the attributive reading. On one reading, nothing x can be thought to be greater than God under its proper description. On another, nothing can be thought to be greater than God, regardless of its description.

3 Summary and conclusion

There are thus, minimally, 10 readings of the claim ‘God is that than which nothing greater can be thought’.

1. The predicative reading with narrow domain for the term ‘thing’: No existing thing is both thinkable and greater than God.
2. The predicative reading with a wide domain for the term ‘thing’. No possible or conceivable thing is both thinkable and greater than God.
3. The attributive reading with narrow domain for the term ‘thing’, with both terms taken objectively: there is no existing thing x such that it can be thought to be greater than the being y, where x happens to answer to some description a and y to the description ‘God’. In particular, no existing thing can be thought to be greater than that than which nothing greater can be thought – which is a description of God.
4. The attributive reading with narrow domain for the term ‘thing’, with the term ‘God’ taken descriptively and ‘thing’ taken objectively. There is no existing thing x which can be thought to be greater than god, understood as god, irrespective of any description a.
5. The attributive reading with narrow domain for the term ‘thing’, with the term ‘God’ taken objectively and the term ‘thing’ referring descriptively: No existing thing a can be thought, as a, to be greater than y, where y is God under some description b.
6. The attributive reading with narrow domain for the term ‘thing’, with both terms taken descriptively. There is no existing thing a which can be thought, as a, to be greater than God, as God.
7. The attributive reading with wide domain for the term ‘thing’, with both terms taken objectively: there is no possible or conceivable thing x such that it can be thought to be greater than the being y, where x happens to answer to some description a and y to the description ‘God’. In particular, no conceivable thing can be thought to be greater than that than which nothing greater can be thought – which is a description of God.
8. The attributive reading with wide domain for the term ‘thing’, with the term ‘God’ taken descriptively and ‘thing’ taken objectively. There is no possible or conceivable thing x which can be thought to be greater than god, understood as god, irrespective of any description a of x.
9. The attributive reading with wide domain for the term ‘thing’, with the term ‘God’ taken objectively and the term ‘thing’ referring descriptively: No conceivable or possible thing a can be thought, as a, to be greater than y, where y is God under some description b. For instance, nothing can be thought, as what it is, to be greater than the God worshipped by Abraham.
10. The attributive reading with wide domain for the term ‘thing’, with both terms taken descriptively. There is no conceivable or possible thing a which can be thought, as a, to be greater than God, as God.

In his argument, Anselm uses several of these different readings. He clearly makes use of reading 2, which implies reading 1, when he says an existing that-than-which-nothing-greater-can-be-thought is better than a non-existing one. He also makes use of an objective reading of ‘God’ in the attributive reading of the predicate ‘can be thought greater than’ when he substitutes the description ‘that than which nothing greater than be thought’ itself for the term in the greater than relation. Anselm doesn’t, however, clearly distinguish these different interpretations from each other. Anselm’s argument thus relies on several closely linked, but different, interpretations for its force. The strength of the argument as a whole is dependent on the independent plausibility of the various interpretations of its key phrase which it invokes.

In previous posts, we established the following:

• Real-world objects have states and behavior. Objects in object-oriented programming (OOP) have analogues to these called fields and methods.
• The fields of object-oriented objects parallel the states of real-world objects more or less faithfully. But the parallel between the methods of object-oriented objects and the behavior of real-world objects breaks down relatively quickly, for two reasons:
  • The first is that more often than not, the methods of object oriented objects do not represent things the object can do, but things that can be done to the object.
  • Second, objects in object-oriented languages don’t neatly distinguish between methods that act on the object in accordance with the nature of the object it is intended to represent (e.g. as a ‘pedal’ method might work on a bicycle object), and methods that act on the object precisely as a bundle of code within a computer program. Colloquially, one might say there is a blending together of larger reality that the object is meant to represent with that which it is, as a piece of code, actually a part of.

What are OOP objects?

What, then, are OOP Objects? Better yet, what is it that makes such objects unified in some way, rather than random bundles of code? And accordingly, what is it that makes some OOP objects better conform to the ideal of an OOP object than others?

To answer this question, let’s look at one more example:

public class Card {
    private final int rank;
    private final int suit;

    // Kinds of suits
    public final static int DIAMONDS = 1;
    public final static int CLUBS    = 2;
    public final static int HEARTS   = 3;
    public final static int SPADES   = 4;

    // Kinds of ranks
    public final static int ACE   = 1;
    public final static int DEUCE = 2;
    public final static int THREE = 3;
    public final static int FOUR  = 4;
    public final static int FIVE  = 5;
    public final static int SIX   = 6;
    public final static int SEVEN = 7;
    public final static int EIGHT = 8;
    public final static int NINE  = 9;
    public final static int TEN   = 10;
    public final static int JACK  = 11;
    public final static int QUEEN = 12;
    public final static int KING  = 13;

    public Card(int rank, int suit) {
        assert isValidRank(rank);
        assert isValidSuit(suit);
        this.rank = rank;
        this.suit = suit;
    }

    public int getSuit() {
        return suit;
    }

    public int getRank() {
        return rank;
    }

    public static boolean isValidRank(int rank) {
        return ACE <= rank && rank <= KING;
    }

    public static boolean isValidSuit(int suit) {
        return DIAMONDS <= suit && suit <= SPADES;
    }

    public static String rankToString(int rank) {
        switch (rank) {
        case ACE:
            return "Ace";
        case DEUCE:
            return "Deuce";
        case THREE:
            return "Three";
        case FOUR:
            return "Four";
        case FIVE:
            return "Five";
        case SIX:
            return "Six";
        case SEVEN:
            return "Seven";
        case EIGHT:
            return "Eight";
        case NINE:
            return "Nine";
        case TEN:
            return "Ten";
        case JACK:
            return "Jack";
        case QUEEN:
            return "Queen";
        case KING:
            return "King";
        default:
            //Handle an illegal argument.  There are generally two
            //ways to handle invalid arguments, throwing an exception
            //(see the section on Handling Exceptions) or return null
            return null;
        }    
    }
    
    public static String suitToString(int suit) {
        switch (suit) {
        case DIAMONDS:
            return "Diamonds";
        case CLUBS:
            return "Clubs";
        case HEARTS:
            return "Hearts";
        case SPADES:
            return "Spades";
        default:
            return null;
        }    
    }

    public static void main(String[] args) {
    	
    	// must run program with -ea flag (java -ea ..) to
    	// use assert statements
        assert rankToString(ACE) == "Ace";
        assert rankToString(DEUCE) == "Deuce";
        assert rankToString(THREE) == "Three";
        assert rankToString(FOUR) == "Four";
        assert rankToString(FIVE) == "Five";
        assert rankToString(SIX) == "Six";
        assert rankToString(SEVEN) == "Seven";
        assert rankToString(EIGHT) == "Eight";
        assert rankToString(NINE) == "Nine";
        assert rankToString(TEN) == "Ten";
        assert rankToString(JACK) == "Jack";
        assert rankToString(QUEEN) == "Queen";
        assert rankToString(KING) == "King";

        assert suitToString(DIAMONDS) == "Diamonds";
        assert suitToString(CLUBS) == "Clubs";
        assert suitToString(HEARTS) == "Hearts";
        assert suitToString(SPADES) == "Spades";

    }
}

The above provides an example of a Card class, again taken from Oracle’s Java tutorials. Let’s walk through it.

After the name of the class and an initial curly brace, two fields are declared: rank and suit. After this follow all the kinds of suits, then the kinds of ranks. This is followed by a special kind of method, called a constructor, which may be used by other objects to generate an instance of the Card class, then a pair of methods getSuit() and getRank(), which respectively provide, or return, the value of the suit and rank of a card object to whatever object makes use of, or calls, these methods. This pair of functions belongs to a larger class of methods called getters, whose naming and functionality follow a longstanding coding convention. This is followed by two boolean methods, isValidRank() and isValidSuit(), the methods suitToString() and rankToString(), and the main method.

Tomorrow, I’ll continue to explain how to understand objects and classes in object-oriented programming.

Some statements describe states of affairs that can never occur. An example is the statement ‘2+2=5’, assuming the terms ‘2’, ‘+’, ‘=’, and ‘5’ retain their standard meaning. Another example would ‘John owns three dogs, but no canines’.

Other statements describe states of affairs that can occur, but can never be stated truly. The medieval logician John Buridan gives ‘no statement is negative’ as an example. Other examples include ‘I am not here’ and ‘I am not speaking’.

In other words, there is a difference between something being impossible on account of what it is and its being impossible because its existence or obtaining would entail a contradiction.

Therefore, there is a difference between essence and existence.

This week’s recommendations include two posts.

The first, On passionate disagreement and self-identity, argues that the proximate passionate disagreement over a topic arises from the way an opinion on it challenges one to break with a certain understanding of the self, itself ultimately grounded in how the matter in question demands adherence to a certain way of life.

The second, A dilemma for a constitutionally protected, publicly funded right to abortion, argues from a distinction between private and public goods that abortion is  constitutionally protected if and only if it is not publicly fundable.

Whatever permits being publicly funded by the state is deemed a public good by the polity that funds it.

Nothing deemed to be a private good can also be deemed to be a public good by the same polity.

Therefore, nothing which permits being publicly funded by the state is a private good

Whatever is deemed constitutionally protected under the justification of privacy is a private good. Since private and public are mutually exclusive categories, no such goods are public goods.

Public funding for abortion is required by law in multiple U. S. jurisdictions, and hence would be deemed a public good by those same jurisdictions.

By the same criterion, it cannot constitute a private good in contradistinction to a public one, and thus cannot be legally protected under grounds of privacy.

But the grounds on which abortion is legally protected are exactly those of privacy.

Thus, if abortion is constitutionally protected on the grounds of its being a private good, then it is not permissible to publicly fund it. Likewise, if abortion is publicly funded, and hence treated as a public good, it is not constitutionally protected.

Therefore, abortion may be publicly funded in U. S. jurisdictions if and only if it is not constitutionally protected.

I recently had a disagreement with a friend over what, to me, seemed to be a minor issue of academic interest, namely whether deliberately structuring a work of fiction so as to illustrate a moral message would degrade the character of the work. The other party to the conversation, an aspiring author, passionately disagreed with me on the matter, to the point of being offended by my view.

In what follows, I intend to focus not on the topic we disagreed over but on what the instance can tell us about how passionate disagreement itself arises and operates.

It’s clear that the fact that my discussion partner was aspiring to be a novelist is not irrelevant to the matter. More generally, a disagreement that brings into question a person’s understanding of self is more likely to be passionate than one that doesn’t. For example, moral disagreement generates more passion than disagreements in mathematics (except, perhaps, among some professional mathematicians, which only proves the general rule).

Passionate disagreement is thus likely to arise when the matter of disagreement is one affecting the self-understanding of one or more parties to the disagreement. When it affects only one party, the disagreement is likely to be one-sided, with anger on one side and bewilderment on the part of others. When it affects the self-understanding of multiple parties, the disagreement is likely to arise to the level of argument.

In this way, understanding how disagreement becomes passionate thus requires an understanding of how self-identification occurs.

Self-identification is a contingent act of understanding oneself in the light of a non-present, non-necessary goal or end. The act need not be one of explicitly modeling oneself after another – as a Christian, for instance, may model his life on that of Jesus, but may be more generally one of comporting oneself in accordance with what an end demands – as a writer, for instance, comes to have a given understanding of self according with his or her idea of a good work. The end sought is not a present, achieved one, but one that serves as a regulatory ideal of the nature of a certain good, which brings with it a corresponding concept of the self. The goal is non-necessary, not in that it is avoidable, but only in that the act of fully accepting and living in accord with it is. A king, for instance, may be born into his position, and societal pressures may be such that he lacks the choice of being anything other than a king. But such a king could still fail to seize the end of ruling a people rightly as his own end.

Because self-identification is consequent upon the acceptance of a given goal or end, it can never be understood as arising from something that lacks the nature of a goal. Thus, for instance, examples like being black, being female, etc. can only have the nature of identities inasmuch as they refer not to material qualities like gender or skin color, but rather to the implications those qualities have for a way of living. Hence, for any thing, there can only be a self-identification as that thing if there is a corresponding way of being that thing.

Inasmuch as passionate disagreement is disagreement about ends, which bring with them a corresponding conception of self, such disagreements are never merely factual, in the sense that they may be adjudicated by appeal to some present, objective state of affairs. Rather, passionate disagreement, inasmuch as it concerns a non-present goal, involves a concept of being that ‘stretches’ through time: a person who disagrees passionately is one whose vision not of a given moment, but of a lasting movement, is interrupted. Part of what makes this disagreement passionate is that ceding one’s vision involves the abandonment of plans, hence the abandonment of a possible future, of one’s self through time, of a way of life.

A matter of passionate disagreement thus confronts the individual with the task of breaking with their current understanding of self by confronting them to abandon a given end. The passion it invokes will be proportionate with the depth of the matter itself and the breadth of the self-conception of the person thus challenged. A person who is ‘full of himself’, as the phrase goes, to the degree that this person is able to be confronted, will have more frequent occasion to be angered. Absent the task of emptying out his self-conception, such a person’s only alternative will be that of hardening the self to outside influence. Hence, a person with a wide conception of core self-identity is likely to become either irascible or impenetrable. Correspondingly, societies which encourage a wide concept of core identity are more likely to generate such individuals.

Traditional religions provide a name for the break with the past which a matter of passionate disagreement demands: conversion. It is thus understandable that disagreement arises with the greatest frequency and intensity in matters that, in a broad sense, should be described as religious (from the Latin religare, ‘to bind back, to bind in response’). Passion arises when the task of binding oneself to a goal, and with it, the unification of one’s life through time, is interrupted by a call to break with one’s past and rupture one’s conception of self, a call to conversion. If we see this phenomenon arising with greater frequency in secular society and less in traditional religious settings, this would seem to suggest that the principal loci of modern religious sentiment may have navigated away from the dominant loci of traditional religious content, and hence are not what they once were.

As stated in the previous post on this topic, a refutation of a thesis consists in a proof that the thesis is not the case. This can happen in two ways. The first is by proving that the thesis is false. The second is by proving that it is ill-formed or non-sensical.

In a simple statement, the proof that a statement is false is a proof that what it attributes to the subject is not attributable to it. Such a proof may occur either solely by way of explication of the being of what is named by the subject and predicate, or it may occur by way of the addition of information about other beings. In the first case, a proof will concludes to a necessary conclusion about the nature of the things in question. In the second case, the conclusion may be merely factual. In every refutation of a thesis, an explication of the nature of what is named in its terms must play at least a partial role.

For instance, utilitarianism is a view that contains, as one of its constitutive elements, the thesis that what it is for something to be good is for it to be useful. But the nature of utility is such that something is only ever called useful with respect to a given end. Hence, whenever someone calls some thing a useful, this must be read as saying that thing is useful for some end b, i.e. a is useful for achieving b. But goodness is not only said with respect to some end. Some things are good without respect to ends, viz. those ends themselves. Therefore, utility is not goodness. Therefore, utilitarianism is false.

When a constitutive part of a view is refuted, such a refutation is ipso facto a refutation of any view or thesis that implies the original view, including any subspecies of that view.

A consequence of this is that no refuted view can become unrefuted by the addition of further nuance to that view, provided it remains a species of the originally refuted view. Hence, attempts to avoid refutation by the imposition of nuance constitute a failure to understand how refutation works. Given that this is the de facto means by which views are modified over time in academic literature on philosophical questions, the implication is that this failure of understanding is widespread.