Philosophy 2340 |
11.4.3
> AxAy[ (Cube(x) & Cube(y) &x #y ) ->
SameCol(x, y)]
I think the only issue here is the x # y: the English says
all the cubes are in the same column, which presumably implies that every cube
is in the same column as every cube including itself. (In practice the sentences
will always evaluate the same anyway, since every block must be in the same
column as itself.)
11.4.6
> ExEy((Tet(x) & Tet(y) &
x#y) -> SameRow(x, y))
Note that the sentence above says that every
tetrahedron is in the same row as every other. It needed to say something
weaker, namely that it's not the case that none of them are in the same row as
any of the others. (If some were and some weren't the original sentence would be
true but yours would be false.)
> ~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! need to stick in an ~(x=y) to specify that the second
tet 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" --
the English doesn't imply that the second cube has to be the same cube as the
first one (the object could be in back of one cube and in front of another). But
your sentence does imply this. Need to use two existential quantifiers 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.18.3
> Ax ((Cube(x) & Ey(Dodec(y) &
BackOf(y, x ))) -> & Smaller(x, y)))
It's close, though. Need to
make sure what you're writing is actually a sentence! If you change "->
&" to "->" and make sure the parentheses match up properly you should be
OK.
11.19.2
> Ax ((Cube(x) & Ey (Dodec(y) &
RightOf(x, y) & ~BackOf(x, y) -> (SameSize(x, y) v Larger(x,
y)))))
This is one of those "donkey sentences." You could do
"AxAy((Cube(x) & Dodec(y) & RightOf(x,y) & ~BackOf(x,y)) ->
(SameSize(x,y) v Larger(x,y)))".
> Ax ((Cube(x)) -> Ey ((Dodec(y)
& RightOf(x, y) & ~BackOf(x, y)) -> SameSize( x, y)))
Close!
The first -> should be an & and then the parentheses will need to be
moved around a little. (Try using the "step by step method, starting with one of
the Aristotelian forms.) And take a look at the "hint" included in the problem
about how to translate "as large as" -- they don't mean "same size as" but
rather "as large or larger".
> Ex Ey ((Cube(x) & Dodec(y) &
RightOf(x, y) & ~BackOf(x, y)) -> ~Larger(x, y))
the sentence
refers to "a cube" and "a dodec" but it's implicitly universal (doesn't matter
what cube or dodec), so you need universal quantifiers. This is like the donkey
sentences. (Notice that your sentence is an existentially quantified
conditional, which is almost always bad news.)
also, "x is as large as y
" can't be translated by "~Larger(x,y)". Remember, we are interpreting "as large
as" to mean "at least as large as," i.e. same size or larger: ("SameSize(x,y) v
Larger(x,y)") would do.
11.19.3
> ??? ~Ex (Cube(x) &
~Ey ( LeftOf(y, x)) & Ez Eu (Cube(z) & Cube(u) & Between(x, z,
u)))
> [GG timed out]
Yeah, this one should be OK. Maybe the GG
doesn't like it because it's expecting to see x # y (since the English says "two
cubes"), but in this case it's OK not to have it since x can't be between z and
u if they're the same cube.
> ??? Ax Ay (((x = b) & (y = c ))
-> (Large(x) & Cube(x) & Large(y) & Cube(y)))
> [GG timed
out]
Doesn't quite work. Your sentence is equivalent to just saying b and
c are both large cubes. But you need to say that they are the only large cubes,
so need to add that anything that is a large cube is either b or c. (Make your
conditional a biconditional and it would work.)
> Ax ~((Cube(x) &
(~Ey (LeftOf(y, x)))) & (Ez Eu (Cube(z) & Cube(u) & Between(x, z,
u))))
"no cube with nothing to its left is between two cubes" -- probably
best to regard this as a universal negative; doing the easy parts gives
us:
Ax ((Cube(x) & x has nothing to its left) -> ~(x is between two
cubes))
Now you can just translate the two remaining phrases and plug them
in. The trouble with your translation is that it is too easy to make it true.
For example, it is true in any world in which there is something that is not a
cube, regardless of how many cubes are between two other cubes!
> Ax
Ey ((Cube(x) & Cube(y) & Between(x, y, y)) -> Ez (~LeftOf(z,
x)))
"no cube with nothing to its left is between two cubes" -- I think
we talked about this in the office today? It can be regarded as a universal
negative: Ax (x is a cube with nothing to its left -> ~(x is between two
cubes)). Now we just do the pieces and plug them in.
x is a cube with
nothing to its left: Cube(x) & Ay~LeftOf(y,x)
x is between two cubes:
there are two cubes that x is between: EzEu (Cube(z) & Cube(u) & z # u
& Between(x,z,u)
Put the pieces together and there you
go!
(There are some trouble signs in your sentence. For one thing, you
have an existential quantifier with a conditional as its scope, which is almost
always bad news. In one place you have this: "Between(x,y,y)", which also looks
potentially like trouble, since x can't be between y and y! Also notice that
Ez(~LeftOf(z,x)) -- which could also be written Ez~LeftOf(z,x) -- does not mean
that x has nothing to its left; rather, it means that there is something that is
not to the left of x.)
> ??? Ax ~((Cube(x) & (~Ey (LeftOf(y, x))))
& (Ez Eu (Cube(z) & Cube(u) & Between(x, z, u))))
> [GG timed
out]
Not quite . . . this one is too easy to make true: it will be true
in any world in which there is something that's not a cube, for instance,
regardless of how many cubes are between two other cubes!
You want a
universal negative, Ax (x is a cube with nothing to its left -> ~ (x is
between two other cubes)). You have the right pieces but need to put them
together a little differently.
11.19.4
> Large(b) &
Large(c) & ~Ex (Cube(x) & Larger(x, b) & Larger(x, c))
the
english doesn't say anything about some objects being larger than others, just
that b and c are the only large cubes (so if anything is a large cube, it must
be b or c).
also, you've specified that b and c are large, but haven't
specified that they are cubes -- need to add
this.
11.20.1
> ~Ax (LeftOf(x, a) & Ay(LeftOf(y, b)
-> Larger(x,y)))
Couple of things to notice about this. First,
usually after a universal quantifier you won't find a conjunction unless it's
part of the antecedent of a conditional. (Most sentences have one of those
Aristotelian forms; your sentence above doesn't fit any of them.) In this case,
if there is something that's not to the left of a that's enough to make your
sentence come out true but not enough to make the English come out
true.
"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 anything to
the left of b. But all the English requires is that nothing to the left of a be
larger than everything to the left of b. A world in which something to the
left of a is larger than some but not all of the objects to the left of b will
make the English sentence true but your sentence false.
> 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])
now all we need to do is
translate "x is larger than everything to the left of b"! If x is larger than
everything to the left of b, then everything to the left of b is something x is
larger than. That looks like a universal affirmative, so should have the
form
Ax (S(x) -> P(x))
subject property: being to the left of
b. predicate property: being something x is larger than. So we have
Ax
(LeftOf(x,b) -> Larger(x,b))
plug this into the brackets in our
first-stage translation and we get
Ax (LeftOf(x,a) -> ~Ax (LeftOf(x,b)
-> Larger(x,b)))
11.20.2
> ~Ex (LeftOf(x, a) & ~Ey
(LeftOf(y, b) -> Smaller(x, y)))
Hmm, another existential quantifier
governing a conditional; again, a bad sign! You could drop the second negation
sign and change -> to &.
11.20.3
> Ax (LeftOf(x, a)
-> LeftOf(x, b))
Close. If the "same things" are to the left of each,
then all the objects to the left of a are to the left of b and vice versa! So
you need <-> instead of ->.
> Ax Ay ((LeftOf(x, a) ->
LeftOf(x, b)))
Close. You don't need "Ay" (notice it's not binding any
variables!) and you should have <-> instead of -> : if the same objects
are left of a as b, then all the objects to the left of a are to the left of b
and vice versa.
> AxAyAzAu((LeftOf(x, a) & LeftOf(y, a) &
LeftOf(z, b) & LeftOf(u, b) &x #y &z #u) -> ((x =z v x = u )
& (y =u v y =z )))
Oh, those piled-up quantifiers! They're pretty
clear in this case though. The reason this isn't equivalent to what the GG was
looking for is just that you took the plurals seriously and they didn't --
they're not taking the sentence to imply that there's more than one thing to the
left of a (and b). Your sentence is fine if you do take the plurals literally.
(If not, the translation is extremely simple: Ax (LeftOf(x,a) <->
LeftOf(a,x))! )
11.20.4
> Ax (LeftOf(x, a) -> Ey (Az
(Cube(z) & RightOf(z, b)) -> BackOf(y, z) & Smaller(x,
y))))
I'm getting a little bleary here, but it may be that the only
problem with this is the extra right parenthesis at the end.
> 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 "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 pull the EzEu part out the front. But your
translation should be equivalent to the expected one.)
|
Last update: October 19, 2005. |