From Lojban
(Redirected from Bunches)
Jump to: navigation, search


“Bunch” is a cover term for formally treated pluralities. There are several realizations of this formalism: plural reference and quantification, L(esniewski)-sets, applied C(antor)-sets (with atoms but without the null set), mereological sums. All of these can be ways for dealing with plurals within the language of logic. They all share the following theses, which are just listed here, without any attempt to divide them into axioms, theorems and definitions (though some are probably obvious). No claim is made that this list is complete, even as a basis, but it does seem to be consistent (relative to standard set theory – not that that is altogether reassuring). The notions treated here are “in” – the relation between pluralities and what make them up, “+” – the device for creating new pluralities by combining existing ones, “I” – “is an individual” (a bunch with no further components), “-F” (and “F-“) – distributive predication (“collective predication,” including personal predication for individuals, is the norm), “F*” – “participates in Fing.”

a in a (reflexive)

a in b and b in a => a=b (asymmetric)

a in b and b in c => a in c (transitive)

AaEb b in a

a in b or b in a or Ec(a in c and b in c)

The one that surely exists is a+b

a+a = a

a+b = b+a

a+(b+c) = (a+b)+c

a in a+b

b in a+b

c in a+b => c = a+b or Ed a+b = c+d

c in a+b => c = a+b or c in a or c in b or Ed a+b = c+d

a+b = a => b in a

a in b => a+c in b+c

xI <=> Aa: a in x x in a

xI <=>Aa: a in x x = a

AaEx: x in a(a = x or Eb a = x+b)

(Here we use the convention of taking quantifiers involving x, y , z as being short for quantifiers restricted to individuals, so here Ex: xI and x in a.)

(Every bunch breaks down completely into individuals and there are is no empty bunch.)

Ex x in a

(This follows from the above but says more explicitly that no bunch is empty)

The above foundation thesis does not quite say that every bunch breaks down into individuals without remainder, or at best says it for finite bunches only. The following does a bit better:

Ax: x in a x in b => a in b


Ax: x in a x in b & Ay: y in b y in a => a = b

this is essentially the foundation principle for sets and is taken as meaning that a set breaks down completely into its elements, even though we could work up a model in which there were a lot more things in there than the elements. The point is that if there are such other things, they never affect any claim to be made -- even about the size of the bunch .

x in a+b => x in a or x in b

a-F <=> Ax: x in a xF

(the “-“ is always on the predicate side, so for a following term, it would be “F-a.” Note: different terms may have F as predicate in different ways: aF-b, a-Fb, a-F-b, and aFb are all possible, even if b = a.)

a-F and b in a => b-F

Ea a=x+y

aF => a-*F

(ever member of a collective particpates in what the collective does)

(like -, * goes between argument and predicate -- pending a better notation)

a<1> <=> Ex a = x (is a monad)

a<n+1> <=> Eb: b in aEx: x in a (b<n> & ~ x in b & a = b + x)

aInf <=>An Eb: b in a b<n>