Symbolic Logic

**11.4.3**

> AxAy[ (Cube(x) & Cube(y) &x #y ) ->
SameCol(x, y)]

You don't need the x#y clause. The English says
*all* the cubes are in the same column, i.e. every cube is in the same
column as every cube including itself. The English contains nothing like "else"
or "different" that would indicate a need for x#y.**11.4.6**

> ExEy((Tet(x) & Tet(y) &
x#y) -> SameRow(x, y))

The first thing to notice about this is that it
is an existentially quantified conditional, which is pretty much guaranteed to
be bad news! It needed to say something
weaker, namely that it's not the case that every tetrahedron is in a different
row from every other tetrahedron. The easiest approach is to start with a
sentence that says that every tetrahedron is in a different row from every other
tetrahedron, and then negate it.

> ~Ax Ay (Tet(x) & Tet(y) ->
SameRow(x, y))

this is close. Couple of issues.

(1) not well
formed: as written, the sentence is ambiguous between Tet(x) & (Tet(y) ->
SameRow(x,y)) and (Tet(x) & Tet(y)) -> SameRow(x,y). You need to use
parentheses to disambiguate it.

(2) The sentence is supposed to say that
it is not the case that every tetrahedron is in a *different* row from every other
tetrahedron. Yours (almost) says that it is not the case that every tetrahedron
is in the *same* row as every other tetrahedron.

(3) Also, the word
"other" is important here! You need x#y to specify that the second tetrahedron is different from the first.

**11.4.8**

> Ax (Cube(x)
->Ay( Cube(y) & ~SameSize(x, y)))

Your sentence says: for all x,
if x is a cube then for all y, y is a cube and x is not the same size as y. More
colloquially: every cube is such that *everything* is a cube that is not the
same size as it.

Changing '&' to '->' would get you closer, except
that then it would imply that no cube is the same size as any cube (including
itself)!

So you need to change '&' to '->' *and* make it explicit
that you only mean every *other* cube is not the same size as the
first.**11.16.6**

> Ax ((Cube(x) & Ay(Tet(y) &
FrontOf(x, y))) -> Large(x))

"every cube in front of every tetrahedron
is large": your translation is fine except for the "x is in front of every
tetrahedron part". Ay(Tet(y) & FrontOf(x,y)) says that everything is a
tetrahedron and has x in front of it. You need a conditional, not a conjunction.
(Remember, you very seldom want to translate an English sentence with a
universally quantified conjunction.)**11.16.8**

> Ax
Ey((Cube(y) & BackOf(x, y) & FrontOf(x, y)) ->
~Large(x))

"nothing in back of a cube and in front of a cube is large" --
your translation says that nothing in back of and in front of the same cube is
large. Since nothing could possibly be both in back of and in front of the same
cube, this is an unlikely interpretation of the English sentence. You need to use two existential quantifiers,
so that x could be in front of one cube and in back of a different cube, to get
the right translation.

> Ax (( Ey(Cube(y) & (BackOf(x, y) v
FrontOf(x, y))) ) -> ~Large(x))

"Nothing in back of a cube and in
front of a cube is large": you have "or" instead of "and" (and you also need two
existential quantifiers, since the cubes that x is in back of an in front of
can't be the same)**11.16.9**

> Ax (( Ey ~BackOf(y, x)) ->
Cube(x))

The English is: "Anything with nothing in back of it is a cube."
Your sentence says that anything with something that is not in back of it is a
cube -- not quite the same thing. (Yours is true if there is a non-cube with
something in back of it, as long as there's also something else that's not in
back of it.)

**11.17.10**

As of June 6, 2008, the solution in the "Hints and Solutions" document on the
web site for our text is incorrect because it is not a well-formed formula.
However, if you fix the parentheses it's OK. (I've just emailed them about this,
so probably they will have fixed it by the time you see it, though.)

**11.18.3**

Donkey sentence!**11.19.2**

On this
problem, it is important to keep in mind the "hint" included in the problem
about how to translate "as large as" -- the authors don't mean "same size as"
but rather "at least as large," i.e. "same size as or larger than."

Also: the sentence is basically a donkey sentence.**11.19.3**

"no cube with nothing to its left is between two cubes"

Note that this is a universal negative. So the overall form should be: Ax ((x
is a cube with nothing to its left) -> ~(x is between two cubes)).**11.19.4-5**

Note carefully
the hint in the text on problem 5. As the hint suggests, the only difference in
meaning between 4 and 5 is that 4 implies that b and c are large cubes, while 5
does not.

So we could paraphrase 4 as: b and c are large cubes, but nothing else is.

And we could paraphrase 5 as: nothing other than b and c is a large cube (leaving it open whether b or c is a large cube). Equivalently: any large cube has to be b or c.

One final hint: both translations will need to use '='.**11.20.1**

> ~Ax (LeftOf(x, a) & Ay(LeftOf(y, b) -> Larger(x,y)))

Couple of things to notice about this. First,

"Nothing to the left of a is larger than everything to the left of b" is a universal negative sentence, so the translation should start either with Ax(Leftof(x,a) -> ~ . . . or, since a univ. neg. is equivalent to the negation of a particular affirmative, with ~Ex(LeftOf(x,a) & . . .

> Ax ((LeftOf(x, b) -> ~Ey (Larger(y, x) & LeftOf(y, a))))

Hmm, this is kind of backward. Your sentence says that nothing to the left of b is larger than anything to the left of a. It needs to say that nothing to the left of a is larger than *everything* to the left of b. So a and b should be switched, and the Ey should be changed to an Ay.

> Ax Ay ((LeftOf(x, a) & LeftOf(y, b)) -> ~Larger(x, y))

This one isn't right -- it implies that nothing to the left of a is larger than

> AxAy ((LeftOf(x, a) & LeftOf(y, b)) -> ~Larger(x, y))

Best to take these in stages. "Nothing to the left of a is larger than everything to the left of b" -- looks like a universal negative, giving us:

Ax (LeftOf(x,a) -> ~(x is larger than everything to the left of b))

Now all that's left is translating the consequent and plugging it in . . .

> Ax (LeftOf(x, a) -> Ay ~(LeftOf(y, b) & Larger(x, y)))

If you think about these in terms of the aristotelean forms, both are universal negatives, so the overall form should be Ax (S(x) -> ~P(x)). #1: "nothing to the left of a is larger than everything to the left of b." subject property: being to the left of a. predicate property: being larger than everything to the left of b.

so at the first stage we'll get

Ax (LeftOf(x,a) -> ~ [x is larger than everything to the left of b])

11.20.2

Hint: if the "same things" are to the left of a and b, then all the objects to the left of a are to the left of b

Incidentally, you shouldn't take the sentence to imply that there are
multiple things (or even one thing, necessarily) to the left of a and b. The
intended meaning is that the same things, *if any*, are left of a as are
left of b.**11.20.4**

> Ey (Ax
(LeftOf(x, a) -> Smaller(x, y)) & Az ((Cube(z) & RightOf(z, b)) ->
BackOf(y, z)) )

your sentence implies that there's a particular thing
that anything to the left of a is smaller than. On the most natural reading, the
English sentence doesn't imply this -- it says that anything to the left of a is
smaller than something (that . . .), but doesn't imply that it's the same
something every time. (There may be a slightly forced reading of the English
sentence that's compatible with your translation, though.)

> Ax Az
((LeftOf(x, a) & Cube(z) & RightOf(z, b)) -> Ey (Smaller(x, y) &
BackOf(y, z)))

This is an interesting case. I think your translation is
OK. But the GG is right that it's not equivalent to the expected (more natural,
to my eye) translations. This is because the correctness of your version depends
on the fact that if every cube to the right of b has something smaller than x
behind it, then there has to be something smaller than x that is behind *all*
the cubes to the right of b. (The former is what your translation guarantees;
the latter is what the English says.) But this depends on the meaning of "back
of": "BackOf" is transitive, so whatever is behind the furthest-back cube is
automatically behind all the others also. For a non-transitive 2-place
predicate, your translation wouldn't work -- e.g. if cubes could love each other
and the original sentence were "Anything to the left of a is smaller than
something that loves every cube to the right of b." It would probably be better
to stay closer to the English so that your translation would be correct for any
English sentence with the same syntax.

> Ax EyAz((LeftOf(x, a)
& BackOf(y, z) & Cube(z) & RightOf(z, b) )-> Smaller(x,
y))

with a sentence this complex, you are almost never going to get it
right if you try to pile all the quantifiers up at the beginning (especially
when the sentence includes one or more conditionals). The step-by-step method is
the way to go here.

> Ax (LeftOf(x, a) -> Az ((Cube(z) &
RightOf(z, b)) -> Ey (BackOf(y, z) -> Smaller(x, y))))

"anything to
the left of a is smaller than something that is in back of every cube that is to
the right of b"

your first step is fine:

Ax (LeftOf(x,a) -> x
is smaller than something that's in back of every cube to the right of
b)

paraphrase a little:

Ax (LeftOf(x,a) -> there is something
in back of every cube to the right of b that x is smaller than)

translate
the existential quantifier:

Ax (LeftOf(x,a) -> Ey (y is in back of
every cube to the right of b & Smaller(x,y))

Now all that's left is
"y is in back of every cube to the right of b", i.e. "every cube to the right of
b is something y is in back of", which looks like a universal
affirmative.

> Ax (LeftOf(x, a) -> Ey (Az ((Cube(z) &
RightOf(z, b)) & BackOf(y, z))))

"anything to the left of a is
smaller than something that's in back of every cube to the right of b" -- an
initial warning sign is that the predicate Smaller() never occurs in your
sentence! Also Az binds a conjunction; usually one expects to see universal
quantifiers paired with conditionals. The GG is right, it's best to take this
one a step at a time.

You have a good start:

Ax (LeftOf(x,a) ->
x is smaller than something that's in back of every cube to the right of
b)

i.e.

Ax (LeftOf(x,a) -> there is something that's in back of
every cube to the right of b and x is smaller than that
thing)

i.e.

Ax (LeftOf(x,a) -> Ey (y is in back of every cube
to the right of b & Smaller(x,y)))

Now all that remains is to
translate "y is in back of every cube to the right of b", which shouldn't be too
bad (looks like a universal affirmative: "every cube to the right of b is
something y is in back of").

11.20.5

> Ax (Cube(x) ->
(Ey (Dodec(y) & Smaller(x, y)) & ~Az (Dodec(z) & Smaller(x,
z))))

Close . . . note that most sentences have one of the Aristotelean
forms, so *usually* it's a danger sign to have either "Ex(S(x) -> P(x))" or
"Ax(S(x) & P(x))". But you do have something like the latter after Az:
danger sign! If there's something that's not a dodec, it'll make this part of
your sentence true regardless of whether x is smaller than it or not. Your last
& should be a ->.

> *** Your fifth sentence, "Ax (Cube(x) ->
Ey (Dodec(y) &

> Smaller(x, y))) &

> Ez (Cube(z) ->
Au (Dodec(u) & ~Smaller(z, u)))", is

> not equivalent to

>
any of the expected translations.

First conjunct is OK. Second conjunct:
when you see anything that has an existential quantifier whose scope is a
conditional, it's usually a sign that you've got trouble. You want to say that
no cube has a certain property: universal negative, so the form will need to be
either "Az(Cube(z) -> ~ . . ." or "~Ex(Cube(x) & . . .".

> Ax
(Cube(x) -> Ey (Dodec(y) & Smaller(x, y))) & Ax (Cube(x) -> ~Ay
(Dodec(y) & Smaller(x, y)))

> [GG timed out]

OK, guess I have
to earn my keep now. This is close but actually not quite correct. The first
conjunct is fine. The second is supposed to say "no cube is smaller than every
dodecahedron." Notice that even if this English sentence is false, i.e. if there
*is* a cube smaller than every dodec, your sentence will come out true if there
is something that's not a dodec. (This is related to my earlier comment about
sentences of the form "Ax(F(x) & G(x) . . .".)

What you need for the
second conjunct is "Ax(Cube(x) -> ~Ay(Dodec(y) -> Smaller(x,y)))" or,
equivalently, ~Ex(Cube(x) & Ay(Dodec(y) ->Smaller(x,y))

>
??? Ax (Cube(x) -> Ey (Dodec(y))) & ~Ex (Cube(x) & Ay (Smaller(x, y)
& Dodec(y) ))

Hmm, this is sort of an odd translation! English:
"Every cube is smaller than some dodec but no cube is smaller than every dodec."
Your translation doesn't quite work, for a couple of reasons. (1) the first
conjunct says that for every cube there is a dodec. It needs to say that for
every cube, there is a dodec that the cube is smaller than. (2) The right-hand
conjunct says that it's not the case that there is a cube such that it is
smaller than everything and everything is a dodec -- not quite what you mean.
Make the last '&' a '->' instead and it should work.

> Ax
Ey((Cube(x) & Dodec(y) & Smaller(x, y)) -> Az(Dodec(z) ->
~Smaller(x, z)))

Easiest way to think of this English sentence is to
treat it as a conjunction of two quantifier sentences (rather than as a big long
quantifier sentence). And then do it in stages -- watch out for the temptation
to lump all the quantifiers out to the left!

11.20.6

> Ex
((Cube(x) & Smaller(a, x)) -> Ay (Tet(y) & Smaller(a,
y)))

Two problems: (1) The first "Smaller" should be a "Larger"; (2) the
consequent should be a universal affirmative. (In general a universally
quantified conjunction is usually a danger sign. Notice that the consequent of
this conditional implies that everything is a tetrahedron and that a is smaller
than everything.)

> Ex (Cube(x) & Larger(a, x)) -> Ey(Tet(y) &
Smaller(a, y))

English: "if a is larger than some cube, it's smaller than
every tetrahedron." Your translation: "if a is larger than some cube, it's
smaller than *a* tetrahedron."

> Ex ((Cube(x) & Larger(a, x))
-> (Ay ((Tet(y) & a#y)->Smaller(a, y))))

to get a correct
translation, you would either need to change the first quantifier from an
existential to a universal, or move the first left parenthesis to the left of
the existential quantifier. (Strange but true: AxF(x)->P <==>
Ex(F(x)->P) if there are no free occurrences of x in P. Also ExF(x)->P
<==> Ax(F(x)->P), again, if there are no free occurrences of x in P.
We've spend some time discussing this in class in relation to these
translations.

(To see the latter equivalence intuitively, think about the
equivalence of "If someone steps on the grass, it will die": the grass is
extremely fragile, ExS(x)->D, which says the same thing as Ax(S(x)->D), if
anyone steps on the grass it will die. I'm still trying to figure out a way to
make the other equivalence I mentioned seem intuitively natural, though. It's
weird because it involves a conditional bound by an existential quantifier, and
as the text has stressed from the outset, these sentences are hard to get your
mind around; they don't mean what it can seem they should.)

> Ex
((Cube(x) & Larger(a, x)) -> (Ay (Tet(y) -> Smaller(a,
y))))

Danger sign: this is an existentially quantified conditional, and
those are almost always bad news! You should have the Ex bind only the
antecedent of the conditional (or you could leave the location the same and
change it to Ax, but the easiest way to do the translation is to think of the
English sentence as a conditional with an existential as its antecedent and a
universal as its consequent).

11.20.7

> Sentences 11.20
(Student file: "Sentences 11.20.sen")

> We found problems in your
sentences:

> *** Your seventh sentence, " Ex Ay (Larger(x, y)
->

> Dodec(x))", is not

> equivalent to any of the expected
translations. We

> are interpreting

> the English sentence to
mean that if an object is

> larger than all other

> objects,
then it is a dodecahedron.

Usually an existential quantifier whose scope
includes a whole conditional is a sign that something's gone wrong! Also need to
specify x # y ("all *other* objects").

> ??? Ax Ay(Larger(x, y)
-> Dodec(x))

> [GG timed out]

Two problems here. One is the
now-infamous scope-of-quantifier-in-relation-to-conditional problem: this
translation says that only dodecahedra are larger than *anything* else, whereas
the English says that only dodecahedra are larger than *everything* else. You
could either change Ay to Ey or else leave it alone and move the first left
paren to its left, to get "Ax (Ay(Larger(x,y) . . ." etc. Once this change is
made, we run into the "else" problem: nothing is larger than *everything*, since
nothing is larger than itself; need to specify that x # y.

> The
grade grinder is being particularly inadequate of

> late. It keeps
timing out and insisting that sentences that

> seem correct are not,
since they do not match any of the

> "expected" answers. For
instance, 11.20, #7. I would

> challange someone to submit an answer
that the grade grinder

> neither marks as wrong nor times out in
grading.

OK -- the translation I sent you last night works fine!
Just to remind you, it was:

Ax (Ay (x # y -> Larger(x,y)) ->
Dodec(x))

The GG also accepted the prenex version:

AxEy ((x = y v
Larger(x,y)) -> Dodec(x))

> ??? We could not determine
whether your seventh sentence, "Ax Ay ((x # y &

> Larger(x, y))
-> Dodec(x))", was correct: The Grade Grinder timed out

> while
checking your answer. Your instructor will have to verify this

>
answer.

it looks to me as though you're running into the rather
subtle problem

we discussed in class earlier today. 11.20.7 is supposed
to say: "only

dodecahedra are larger than everything else." Your
translation below will

actually have the consequence that every object
that's larger than

*anything* else is a dodecahedron. (See why?) Not
what you want!

The most natural translation (to my eye anyway)
is:

Ax ( Ay(x # y -> Larger(x,y)) ->
Dodec(x))

(somewhat colloquially, "everything is such that, if it
is larger than

everything else, it is a dodecahedron"). Notice that the
second

quantifier's scope includes only the antecedent of the outer
conditional.

Putting this into prenex form is a little tricky. One
prenex form would be

this:

AxEy ((x = y v Larger(x,y))
-> Dodec(x))

-- one of those cases where the form with all the
quantifiers at the left is

not what you'd expect!

>
~Ex (~Dodec(x) & Ay (Larger(x, y)))

your sentence is too easy to make
true: nothing can be larger than itself, so your sentence is true in every
world. You need Ay(y # x -> Larger(x,y)).

> ??? Ax Ay ((Larger(x,
y) & (x #y) & ~Dodec(y)) -> Dodec(x))

> [GG timed
out]

Again, not quite. Your sentence says that for any two objects, if
one is larger than the other and the other isn't a dodec, then the first one
(the larger one) is a dodec. It should say that any object that is larger than
*everything* else is a dodec. Something like this:

Ax (Ay (y # x ->
Larger(x,y)) -> Dodec(x)).

(If you changed your 'Ay' to 'Ey' and
deleted '~Dodec(y)' you'd have something equivalent to the right answer, but
hard to read because of the weird existentially quantified
conditional.)

> Ex (Dodec(x) & Ay(~Dodec(y) -> Larger(x,
y)))

This is the donkey sentence problem. Notice that your sentence is an
existentially quantified conditional, almost always a bad sign. "If *an object*
is larger" sounds like an existential, but this is misleading; really means for
any object, if it's larger, . . .

but also, notice that your conditional
looks like it's sort of the converse of what you need: if larger than everything
else, then dodec. (Your sentence says that there is a dodecahedron that is
larger than every non-dodecahedron.)

> Ax (Ay Larger(x, y) ->
Dodec(x))

Close, but the antecedent of your sentence can never be true
because an object can't be larger than itself: you need to specify that x is
larger than all *other* objects.

> Ax (~Ey ((~Larger(y, x) &
~SameSize(y, x)) -> Dodec(x)))

danger sign: there's an existentially
quantified conditional here! You probably want Ey to bind only the antecedent,
not the whole conditional. There also seems to be an extra negation sign in
there. And you don't really need SameSize for anything . . . Here's a
translation similar to yours that should be OK:

Ax (~Ey Larger(y,x) ->
Dodec(x))

> ??? Ax Ay (Larger(x, y) -> Dodec(x))

> [GG timed
out]

Close, but this says that only dodecahedra are larger than
*anything* else, not that only they are larger than *everything* else. You
want:

Ax (x is larger than everything else -> Dodec(x))

When
you translate the antecedent and plug it in, the y-quantifier will end up inside
the left parenthesis instead of outside, and this makes an important difference
here.

11.26.3

> Ax (Cube(x) & Ey ((Dodec(y) &
RightOf(x, y)) -> Smaller(x, y)))

Ah, this is the "donkey" problem!
The scope of the Ey *should* end at the end of the antecedent, but then it
doesn't bind the last occurrence of y, so you moved a parenthesis. But then the
sentence doesn't quite mean what you want it to. (For one thing, this version
implies that everything is a cube!) Need to do the usual solution to the donkey
problem, namely change Ey to Ay and give it the whole conditional as its scope.
(Either "AxAy((Cube(x) & Dodec(y) & RightOf(x,y)) -> Smaller(x,y))"
or "Ax(Cube(x) -> Ay((Dodec(y) & RightOf(x,y)) ->
Smaller(x,y))".

> Ax (Dodec(x) & Ay ((Cube(y) & RightOf(y, x))
-> Smaller(y, x)))

Hmm, close, but this implies that everything is a
Dodec! You want the dodec part to be part of the antecedent of your conditional,
not a separate conjunct.

11.26.4

> Ax (Dodec(x) -> Ey
(Cube(y) & LeftOf(x, y) & Larger(x, y)))

why the move from "right
of" and "smaller" to LeftOf() and Larger()? Better to stick with the predicates
in the English sentence! Also note that the English says something about every
cube, so you probably need a universal quantifier instead of an existential . .
.

11.26.5

> Ex (Dodec(x) & Cube(a) & ~Larger(x,
a))

One problem here is that the sentence says x is not larger than a,
but it should say a is not larger than x.

11.26.6

> Ax ~((Dodec(x) & Cube(a)) ->
Larger(a, x))

Interesting! This actually implies that everything is a
dodec. (Although seeing this is a little tricky! The negation says the whole
conditional is false. The only way a conditional can be false is for its
antecedent to be true and its consequent false. So your sentence implies that
the antecedent is true for every value of x, i.e. everything is a dodec.) If you
change -> to & you should get one of the readings of the English
sentence.

> Ax ((Cube(a) & Dodec(x)) -> Smaller(x,
a))

main problem is that "smaller" doesn't mean the same thing as "not
larger" since smaller rules out same size but not larger doesn't. (Also the
sentence seems to imply that a is a cube, so probably want "Cube(a) &
Ax(Dodec(x) . . ." instead of putting Cube(a) in the antecedent.)

> Ax
~((Dodec(x) & Cube(a)) -> Larger(a, x))

English: "cube a is not
larger than every dodec". Depending on how you interpret the scope of the
negation, this could mean that it is not the case that a is larger than every
dodec:

~Ax((Dodec(x) & Cube(a))-> Larger(a,x))

(i.e. there is some
dodec that a is not larger than), or it could mean that every dodec is such that
a is not larger than it, i.e. that a is not larger than any
dodec:

Ax((Cube(a) & Dodec(x)) ->
~Larger(a,x))

11.26.7

> ~Ex Ay (Cube(x) & Dodec(y)
& LeftOf(x, y))

This says it's not the case that there's a cube such
that everything (!) is a dodec it's to the left of. You want the dodec part to
say the cube is to the left of anything that's a dodec, but you don't want it to
say that everything is a dodec. This would work:

~Ex(Cube(x) &
Ay(Dodec(y)-> LeftOf(x,y))).

> Ax (Cube(x) -> Ey (Dodec(y) &
~LeftOf(x, y)))

Hmm, this says that every cube has some dodec that it's
not to the left of. If you move the negation to in front of Ey you'll get one
reading of the English sentence (namely that every cube is such that it's not to
the left of any dodecahedron). The other reading would say that there is a
particular dodec such that no cube is to the left of it, i.e. Ex(Dodec(x) &
Ay(Cube(y) -> ~LeftOf(y,x))).

11.26.8

> Ax (Cube(x)
-> ~Ay (Dodec(y) & LeftOf(x, y)))

This
should say "no cube is to the left of all the dodecahedra." The sentence above
has the right overall form, namely universal negative. But the negated
predicate, "x is to the left of all the dodecahedra," i.e. "every dodecahedron
is such that x is to its left," should be a universal affirmative, not a
universally quantified conjunction. Translations of the form Ax(F(x) & G(x))
usually indicate trouble.

11.26.9

> Ex Ey (Cube(x) &
Cube(y) & x # y & Ez Eu (Dodec(z) & Dodec(u) & z # u &
Between(x, z, u) & Between(y, z, u)))

Yeah, this is OK as one reading
of the English sentence. (I think I tried this version too and also got timed
out on; the GG likes it better if you put the EzEu part at the front. But your
translation should be equivalent to the expected one.)

Curtis Brown | Symbolic Logic | Philosophy Department | Trinity University

cbrown@trinity.edu