W3C home > Mailing lists > Public > www-rdf-logic@w3.org > June 2001

Re: Nests and abstract syntax: Quads vs. nests as sets of Triples

From: Jonathan Borden <jborden@mediaone.net>
Date: Fri, 8 Jun 2001 15:42:00 -0400
Message-ID: <0af001c0f053$16180a80$0a2e249b@nemc.org>
To: "Drew McDermott" <drew.mcdermott@yale.edu>
Cc: <www-rdf-logic@w3.org>
Drew McDermott wrote:

>
>    [Jonathan Borden]
>    This is getting much better. Can we do this all with 4-tuples:
>
>    <predicate,subject,object,nest> where each are atoms.
>
> Yes.  The "boundaries" I was talking about are then determined as
> follows:
>
>    -- Every "nest" atom in a 4-tuple corresponds to a nesting
> boundary.
>    -- A 4-tuple <p, s, o. n> is inside a boundary N if either n=N, or n
> is the subject or object of a 4-tuple inside N.
>
>
>    So the top level statements are those who are not pointed to by other
>    statements in the same nest. Assuming the subgraph described by a nest
is
>    acyclic, this works. correct?
>
> I'm not sure I understand this.  I would say "The top-level statements
> in a nest are those that are not members of any subnest."  Then to
> assert a nest is to assert its top-level statements; stronger
> conclusions require knowledge of the content and inferences of the
> nest.

It seems to me that there are two ways to accomplish the same thing:

1) use "{" and "}" to delimit nest:

{
    (a b c d)
    (or e f g)
    (and h i (or j k l m))
}

It this case we have a nest, and 'inside' the nest are 3 top level lists.
Suppose the lists are constructed each of multiple triples (or quads) using
some mechanism. The top level tuples are the 'first' tuple in each list.

My assumption is that this is the same as:

and

    (a b c d)
    (or e f g)
    (and h i (or j k l m))
}

2) Use a nest for each expression e.g.

{
    {a b c d}
    {or e f g}
    {and h i {or j k l m}}
}
>
> The nesting graph should be acyclic, in the sense that two nests may
> not be subnests of each other.  We need some stronger constraints as
> well.  There are some technical holes that need to be filled in.  For
> instance, we've all been assuming that a nest can be pointed to from
> multiple places.  That means its contents would be inside multiple,
> nonoverlapping nests.  Is that okay?  And then there's this: Can a
> nest have free variables?  Presumably the answer is Yes, given Pat's
> analysis of quantification.  But then if it's pointed to from multiple
> places, it seems to me they must all bind all the free variables.
> Could the same variable occurrence end up universally quantified when
> reached from one direction and existentially quantified when reached
> from another?  Blech.

Are any of these problems at all unique to nests? Aren't they the exact
sorts of problems that occur with lists (e.g. setcdr)?

>
> I'm not sure we're all talking about the same proposal at this point.
> Pat wanted tuples to be arguments of tuples, but I seem to have
> wandered off into assuming that *nests* would be arguments of
> tuples.  Have I grossly missed the point, or is this consistent with
> what Pat suggested?  (Pat?)  Obviously nests correspond to
> *conjunctions* of tuples, so perhaps I'm okay.

yes I think that this point is the key point.

-Jonathan
Received on Friday, 8 June 2001 15:59:01 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:52:40 GMT