The Many and the One, Ch. 3/ii

In Chapter 3, recall, Florio and Linnebo are discussing various familiar arguments against singularism, aiming to show that “the prospects for regimentation singularism are not nearly as bleak as many philosophers make them out to be”.

Now, it has always struck me that the most pressing challenge to singularism is actually that the story seems to fall apart when it moves from programmatic generalities and gets down to particulars. If the plan is, for example, to substitute a plural term referring to some Xs by a singular term referring to the set of those Xs, then how does work out in practice? How do we substitute for the associated predicate to preserve truth-values (without burying a plural in the new predicate)? Is the same treatment to apply to a plural term when it takes a distributive and collective predicate? The anti-singularist’s contention is that trying to substitute for plural terms ends up with (at best) ad hoc, piecemeal, treatments, and the resulting mess smacks of a degenerating programme (as Oliver and Smiley remark, having noted that e.g. Gerald Massey ends up giving four different treatments for four kinds of collective predicate, “where will it end?”). Now, this line of anti-singularist criticism might be more or less compelling: but in the nature of the case, that can’t be settled by a single counter-jab at one example. The devil will be in all the details — which is why I found F&L’s very brief treatment of what they call substitution arguments quite unsatisfactory.

But now let’s move on to consider another familiar anti-singularist line of argument that goes back to Boolos in his justly famous paper ‘To Be is to Be a Value of a Variable’. Here’s an edited version:

There are certain sentences that cannot be analyzed as expressing statements about sets in the manner suggested [i.e. replacing plural forms by talk about sets], e.g., “There are some sets that are self-identical, and every set that is not a member of itself is one of them.” That sentence says something trivially true; but the sentence “There is a set of sets that are self-identical, and every set that is not a member of itself is a member of this set,” which is supposed to make its meaning explicit, says something false.

F&L consider this sort of challenge to singularism in their §3.4.

One point to make (as F&L note) is that the argument here generalizes. Suppose we replace plural talk about some Xs with singular talk (not about the set of those objects) but by singular reference to some other kind of proxy object; and we correspondingly replace talk about some object o being one of the Xs by talk of o standing in the relation R to that proxy. Then it is easy to see that R can’t be universally reflexive if it is to do the intended work. So there will be some proxy objects such that any of the proxies which are not R to themselves is one of them. But this truth supposedly goes over to the claim that there is a proxy which is R to just those proxies which are not R to themselves. And it is a simple logical theorem that there can be no such thing.

But a second point worth making (which F&L don’t note) is that the quantificational structure of the Boolos sentence isn’t essential to the argument. Revert for ease of exposition to taking a singular term which refers to a set as the preferred substitution for a plural term, with membership as the R relation. Then consider the simple truth ‘{Jack, Jill} is one of the sets which are not members of themselves’. Supposedly, this is to be singularized as ‘{Jack, Jill} is a member of the set of sets which are not members of themselves’. Trouble!

OK. So how do F&L propose to blunt the force of this line of argument? They have two shots. First,

The paradox of plurality relies on the assumption that talk of proxies is available in [the language we are trying to regiment]. The lesson is that, if [the language to be regimented] can talk not only about pluralities but also about their proxies, then the regimentation validates unintended interactions of the sort just seen. To block the paradox, we would therefore have to prevent such problematic interactions. One possibility … is to refrain from making a fixed choice of proxies to be used in the analysis of all object languages. Instead, the singularist can let her choice of proxies depend on the particular object language she is asked to regiment. All she needs to do is to choose new proxies, not talked about by the given object language. In this way, the problematic interactions are avoided.

But hold on. I thought the the singularist was trying to give a regimented story about our language, using some suitably disciplined fragment of our language with enough singular terms but without the contended plurals? The proposal now seems to be that we escape paradox by introducing proxy terms new to our language, which we don’t already understand. Really? Usually singularists talk of sets, or mereological wholes, or aggregates, or whatever — but now, to avoid paradox, the idea is that we mustn’t talk of them but some new proxies, as yet undreamt of. It is difficult to see this as rescuing singularism as opposed to mystifying it.

F&L’s second shot is more interesting, and suggests instead that we discern “a variation in the range of the quantifiers involved in the paradoxical reasoning.” Thus, in the Boolos sentence “There is a set of sets that are self-identical, and every set that is not a member of itself is a member of this set” the proposal is that we take the ‘there is’ quantifier to range wider than the embedded ‘every set’ quantifier, and this will get us off the hook. On the face of it, however, this seems entirely ad hoc. Still, this sort of domain expansion is often put on the table when considering puzzles about absolute generality, and F&L announce they are going to return to discuss such issues in their Chapter 11. Fine. But so far, we have no hint about how the story is going to go.

And, more immediately, how do considerations about domain expansion engage with the not-overtly-quantified version of the Boolosian challenge that involves only a plural definite description. F&L just don’t say. They are, indeed, so far remarkably silent about plural terms and plural reference which, you might have supposed, would need to be a central topic in any discussion of plural logic.

We’ll have to wait to see what, if anything, F&L have to say later about e.g. plural descriptions. But for the moment, I think most readers will judge that the singularist’s prospects of escaping Boolos’s type of Russell-style paradox still look pretty bleak!

To be continued.

7 thoughts on “The Many and the One, Ch. 3/ii”

  1. I thought the the singularist was trying to give a regimented story about our language, using some suitably disciplined fragment of our language with enough singular terms but without the contended plurals?

    What makes that the goal? It doesn’t seem to be what F&L are doing. I don’t think they say that the regimenting language is meant to be a fragment of our language, or of the object language. (The closest I can find to that is when they say ‘Even when LR is a formal language, we may follow Quine in treating it as a “special part [ . . . ] of ordinary or semi-ordinary language.”‘ However, they don’t seem to treat that as meaning that even a formal regimenting language would (somehow) be a fragment of our ordinary language.)

    I think what F&L say about proxy objects is very reasonable. It doesn’t seem so reasonable if we go straight to the point where they talk of refraining

    from making a fixed choice of proxies to be used in the analysis of all object languages. Instead, the singularist can let her choice of proxies depend on the particular object language she is asked to regiment. All she needs to do is to choose new proxies, not talked about by the given object language.

    So let’s restore some context.

    First (initially when discussing the substitution argument, but reiterated in the next section), F&L note that problems come from ‘unintended interaction between these plural resources [of the object language] and talk about the objects that are used to represent pluralities [in the regimenting language].’ They decided to call such objects proxies and say ‘if LO was precluded from talking about the proxies, the [problematic] argument could not get off the ground.’

    How can they do that? They have to take the object language as given, but (they note) the regimenting language ‘can freely be chosen to serve our needs.’

    A solution appears: use proxies that can’t be referred to in the object language.

    That seems an excellent solution to me. Defining a new type of element-containing object is a completely ordinary thing to do when programming; I don’t think there’s any good reason why philosophers can’t do it too. And if I’m implementing a programming language and define a new type of object in the implementing language, nothing says I have to let programs in the implemented language refer to those objects.

    However, it’s game over for the pluralists if they accept this solution, so of course they don’t.

    Instead, they might reply: Oh no, we won’t let you get away with that. Whatever proxies you use in the regimenting language, we’ll add them to the object language too.

    Then a ‘singularist’ can say: It’s going to be like that, is it? Well, two can play that game. Whenever you do that, we’ll pick a new type of proxy object. If you ever stop changing the object language, in order to say something in it, we’ll be able to translate what you say without you being able to use that same object language to create problems for our translation.

    And that in effect is how we arrive at the not-so-reasonable-sounding idea described earlier.

    I think it’s better to reject that game and stick with the original idea that the object language can’t refer to the proxy objects used in the regimenting language. I think that separation of levels is reasonable and does not mystify anything.

    1. The “That seems an excellent solution to me. …” paragraph was supposed to begin

      That seems an excellent solution to me, and not one that’s mystifying.

      (Without the part about not being mystifying, the shift to what happens with programming and language implementation can seem an unmotivated leap.)

  2. Interesting, but two quick comments:

    1. Do programmers really define into existence new objects as opposed to new ways of packaging old objects (listing them, putting them into arrays, or whatever)? I guess I’d need to hear more their seemingly magical ontological powers!

    2. Suppose we are told that e.g. the plural referring term ‘Whitehead and Russell’ is to be replaced by a singular term referring to a single thing, the widget of Whitehead and Russell. And supposed we are told that the truism that Whitehead is one of Whitehead and Russell is to be recast as the claim that Whitehead partakes in the widget of Whitehead and Russell. What more is to be said about widgets/partaking? If the answer is (more or less) nothing, then yes, do talk about widgets if you like; but thus far they can be understood as merely virtual objects, with widget talk, in so far as we understand it, to be cashed out in terms of plural talk (not vice versa). If the story is elaborated, e.g. it is further said that two widgets are identical if and only if just the same objects partake in them, etc., etc., then the danger is that widgets/partaking just ends up as e.g. rebadged sets/members and we are back with eliminating plurals for sets. If the story is that widgets are genuine objects (not virtual) but also not sets, not multisets, not mereological sums, … well, say I, until we are told more this is just arm-waving mystery-mongering. The ur-singularist project was, after all, surely to eliminate plural talk in terms of familiar singular apparatus that was already available to us (so showing that we had no need to add plurals to our logical apparatus in a competent regimented language which we already understood).

    1. 1. That isn’t how I would describe it. I’m not sure what you have in mind when saying “define into existence”, or why you see packaging old objects as opposed to creating new objects. Packaging old (already existing) objects in a list or array creates a new object: the list or array. And defining a new way of packaging objects can be done in the way I said, by defining a new object type.

      (A programming language might not have lists ‘built-in’, for example, but still be able to let programmers define a list type. That’s pretty much what happened with Java. Although it didn’t initially have lists — apart from a sort of ‘stretchy vector’ — they’re now provided by a library written in Java.)

      Anyway, I don’t think that ‘packaging’ is a problem for what I was saying. A ‘proxy’ for a plural will package those objects (unless ‘package’ means something unusual that I’m missing).

      Now suppose I write a program in language L1 that implements language L2. The L1 program might be an interpreter for L2 programs, for example. I could create data types in L1 (and even use them in the interpreter) without letting L2 programs refer to instances of those types. I see this as analogous to using a proxy in a regimenting language for plurals in an object language. It needn’t let expressions in the object language refer to the proxies.

      For a somewhat closer analogy, suppose I’m implementing L2 by translating L2 programs into L1 programs, that L2 has a form of plural reference, but L1 doesn’t, and that I translate L2 plural references into L1 references to ‘proxy’ objects. Now the translated L2 program (which is an L1 program) can refer to proxy objects. However, that doesn’t mean it can do everything related to proxies that an ordinary L1 program can do. It can do only things that correspond (via the translation) to things that can be done with plurals in L2. In effect, the translated program is in a restricted sublanguage of L1.

      If L1 has sets as one of its data types, the translator might even use such sets as the proxies for L2 plurals. That doesn’t mean that talk of sets in L2 (if that’s even possible) must be about those sets. The translator could translate L2 set-talk in some other way.

      (Of course, when thinking in such ways we have to idealise considerably from actual programming languages as actually implemented. I don’t think that creates a fundamental problem, though.)

      2. I find that sort of argument hard to understand. If plural-talk can be avoided in the regimented language by using singular widget-talk, why would it matter if the widgets were ‘virtual’? How would widget-talk be cashed out in terms of plural-talk if the regimented language didn’t include plural-talk?

      What do ‘virtual’ and ‘genuine’ mean here anyway? Ordinarily, I’d think that mathematical objects — not just sets but mathematical objects generally, including numbers — were real / genuine objects only to Platonists. Is the singularist project meant to require Platonism? That doesn’t seem right. Or is there some different way to be a ‘genuine object’, without being ‘virtual’, and without needing Platonism, that covers numbers, sets, and so on, even though they aren’t ordinary (physical) objects?

      1. (1) is outside my comfort zone. Though I guess there is more to be said about — if I can put it this way — introducing listings (new bits of language doing helpful new work) vs introducing lists (thought of as some supposedly new objects being denoted by the listings).

        (2) I was talking of virtual objects as Quine talks of virtual classes.

        (3) It isn’t that the singularist project requires Platonism (or was that a slip?); rather the emerging worry is the other way about — it seems that the singularist (on the proposal under now consideration) introduces his objects for plural-replacements to refer to with a kind of ontological insouciance which (not only a) Platonist would be unhappy with. At the outset, as I said before, the singularist was at least proposing that objects already available to us (sets or whatever) could serve as the reference of singular terms replacing plurals.

        Obviously there’s more to be said. But F&L don’t say it. (Increasingly, my sense, reading the book, is that their arguments too often stop too soon …)

        1. I’m having trouble posting this comment. The same sort of problem used to happen with the site’s previous setup. Basically, if there was some problem in the markup I’d typed, and I edited to try to fix it, it would say I was no longer allowed to edit (as if the time allowed for editing had been exceeded), and the post would vanish. If I tried to post it again, it would say it was a duplicate. Anyway, perhaps putting this much text in front will stop the software from thinking it’s a duplicate.
          – – – – –

          (1) I’d say instead that a list is a new object and that it’s primarily lists, rather than any notation in the language that denotes lists, that does helpful new work. Indeed, lists can do that work even if the language lacks any list-denoting notation.

          I’m not entirely sure what you mean by a ‘listing’, though. Since you say listings are ‘new bits of language’, I’m guessing that in programming language terms they’re something you can write in a program (in the source code) such as ‘1, 2, 3’ listing (representations of) the numbers 1, 2, and 3. When calling a function, f, on those numbers, for example, I could write f(1,2,3), and if making a list of them, I might write [1,2,3] in a language like Python, or List.of(1,2,3) in Java. When such code is evaluated, it creates a new list. The list can even be made the value of a variable:

          a = [1,2,3] # Python
          var a = List.of(1,2,3) // Java

          However, most lists aren’t created by explicitly listing their elements.

          (Of course, what’s in the source code is a textual representation, rather than numbers, and what the language implementation creates is still a representation, though typically a different one, such as twos-complement binary in the machine’s memory. I don’t think that creates any fundamental problem for what I’m saying, though.)

          (2) I couldn’t find a good online source for Quine’s account of virtual classes, so I looked at Levy’s Basic Set Theory. There, at least, the idea seems to be that references to classes can all be removed by translating to a ‘base language’ that does not include classes or class variables, etc.

          Saying the proxy objects are ‘virtual’ in that sense seems a strange argument to make against the singularist, though.

          Sing: I can translate all the plural-talk in your language (the object language) into proxy-talk in my regimented language, so there’s no need for plurals in the regimented language.

          Plur: Ah! But I can translate all your proxy-talk back into plural-talk in my preferred language, so your proxy-talk has to be cashed out in terms of plural talk (not vice versa).

          Sing: Why not vice-versa? Or why not say that having translations both ways shows an equivalence?

          Plur: I’ll accuse you of mystification. (And if you’re not careful, I’ll accuse you of set theory.)

          Sing: Accuse away! (shrugs) I’ll still have shown there’s no need for plural-talk in a regimented language.

          (3) I’m trying to understand what the objection to the ‘ontological insouciance’ is, when the proxy objects are ‘genuine objects’, rather than virtual. If the proxies were genuine objects in a Platonist sense, I could understand the objection. I might not agree with it, but I could understand what it was about and why someone might care. So (quoting my previous comment, so that the above might explain it):

          Is the singularist project meant to require Platonism? That doesn’t seem right. Or is there some different way to be a ‘genuine object’ …?

          And if there is a different way, what is the problem with the proxy objects being ‘genuine’ in that way? Especially if we’re happy to accept the likes of sets as genuine objects. What could the objection to the proxies be, apart from them not being familiar?

          BTW, Much of what I said in my previous post about using one language to implement another also applies if the ‘two’ languages are the same. It used to be fairly common to write a Lisp interpreter in Lisp to help explain the language. Suppose I write a Lisp-in-Lisp and run it in implementation I1. When creating the objects that interpreted programs will see as lists, functions, etc, the interpreter doesn’t have to use the same data structures provided for such things by I1.

          1. On the issue about comments editing, drat! — that sounds a glitch in the recommended plugin (but I guess it would be even worse to delete the plugin that at least allows users a window of opportunity to edit their comments, and seems unproblematic for shorter comments). I think it is probably best to compose long posts/comments offline in an html-friendly text editor, and then cut’n’paste when you are happy with the result: at least, that’s what I do, and it seems to reduce the number of petty (or not so petty) annoyances!

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top