Loading ...
Sorry, an error occurred while loading the content.

Re: A new direction in loglangs?

Expand Messages
  • Alex Fink
    ... The first way I would think to handle these classes (in fact, what we do in UNLWS) is as predicates whose argument is the Davidsonian event argument for
    Message 1 of 9 , Aug 1, 2012
    • 0 Attachment
      On Thu, 26 Jul 2012 15:58:56 -0600, Logan Kearsley <chronosurfer@...> wrote:

      >One of the things that has always bugged me about Palno being based on
      >predicate calculus is the awkwardity of adverb constructions. But just
      >today I was reading an old article on classifying adverbs for
      >machine-readable dictionaries, and they had predicate-calculus forms
      >for describing the semantics of subject-focused, verb-modifying, and
      >clause-modifying adverbs, and the listings for verb-modifying senses
      >was extremely weird:
      >
      >[ VERB / ADVERB ](arg1,arg2,...)
      >
      >That does not look like proper predicate calculus to me, and then it
      >suddenly dawned on me: the correct way to write it is
      >
      >ADVERB(VERB)(arg1,arg2,...)
      >
      >I.e., verb- (and some clause-) modifying adverbs are actually
      >semantically equivalent to higher-order functions!

      The first way I would think to handle these classes (in fact, what we do in UNLWS) is as predicates whose argument is the Davidsonian event argument for the verb (there's a word I've learned from And).

      Perhaps I am ignorant of some important distinction between verb- and clause-modifying adverbs. For instance, in your leading example

      >E.g., given the sequence
      >
      >"Bob ball kick hard"
      >
      >How do you know if "hard" is a higher order function operating on
      >"kick" before binding the arguments "Bob" and "ball", or if it's a
      >first-order function operating on the result of "Bob ball kick"?

      the binding of "Bob" and "kick" seems to me to commute semantically with the whatevering of "hard". What semantic difference do you take to be present between the two?

      Alex
    • Logan Kearsley
      ... That s effectively what Palno so far has always done. Rather than explicitly stating a Davidsonian event argument, though (which would seem to me rather
      Message 2 of 9 , Aug 1, 2012
      • 0 Attachment
        On 1 August 2012 06:33, Alex Fink <000024@...> wrote:
        > On Thu, 26 Jul 2012 15:58:56 -0600, Logan Kearsley <chronosurfer@...> wrote:
        >
        >>One of the things that has always bugged me about Palno being based on
        >>predicate calculus is the awkwardity of adverb constructions. But just
        >>today I was reading an old article on classifying adverbs for
        >>machine-readable dictionaries, and they had predicate-calculus forms
        >>for describing the semantics of subject-focused, verb-modifying, and
        >>clause-modifying adverbs, and the listings for verb-modifying senses
        >>was extremely weird:
        >>
        >>[ VERB / ADVERB ](arg1,arg2,...)
        >>
        >>That does not look like proper predicate calculus to me, and then it
        >>suddenly dawned on me: the correct way to write it is
        >>
        >>ADVERB(VERB)(arg1,arg2,...)
        >>
        >>I.e., verb- (and some clause-) modifying adverbs are actually
        >>semantically equivalent to higher-order functions!
        >
        > The first way I would think to handle these classes (in fact, what we do in UNLWS) is as predicates whose argument is the Davidsonian event argument for the verb (there's a word I've learned from And).

        That's effectively what Palno so far has always done. Rather than
        explicitly stating a Davidsonian event argument, though (which would
        seem to me rather Lojbanish), the event argument is equivalent to the
        implicit return value of a non-top-level predicate. That's what allows
        nesting such that the result of one predicate can be the argument of
        another.

        Many of the existing problems with Palno (like correctly handling
        relative clauses) stem from manipulating that return value so that
        it's something *other* than the Davidsonian. E.g., top-level
        predicates have to actually be logical predicates that assert a truth
        value, like "there exists e such that e satisfies this predicate",
        rather than the bare argument value itself, "some e such that e
        satisfies this predicate".

        > Perhaps I am ignorant of some important distinction between verb- and clause-modifying adverbs. For instance, in your leading example
        >
        >>E.g., given the sequence
        >>
        >>"Bob ball kick hard"
        >>
        >>How do you know if "hard" is a higher order function operating on
        >>"kick" before binding the arguments "Bob" and "ball", or if it's a
        >>first-order function operating on the result of "Bob ball kick"?
        >
        > the binding of "Bob" and "kick" seems to me to commute semantically with the whatevering of "hard". What semantic difference do you take to be present between the two?

        That's not a very good example for demonstrating the difference,
        'cause that probably is semantically commutative. A better simple
        example might be a truth-intensifier, like "really". "Bob really
        kicked the ball", e.g., we assume that some event happened without
        question, but the event was *definitely* a kick, not something else;
        as opposed to "Really, Bob kicked the ball", e.g. there is no question
        over the type of event under discussion, but it definitely happened,
        as opposed to not.

        Incidentally, I found one paper on verbal semantics that represents
        predicates in fully curried form. Of course, when writing out
        semantics in predicate calculus, they're allowed to use parentheses,
        so it didn't really help my cogitation here.

        -l.
      • And Rosta
        ... Why Lojbanish? The Lojban method is clunkier than the Palno--Liva or the Livagico-UNLWS systems: it uses a dyadic predicate, _nu_, x1 is the event of x2 ,
        Message 3 of 9 , Aug 2, 2012
        • 0 Attachment
          Logan Kearsley, On 01/08/2012 21:17:
          > On 1 August 2012 06:33, Alex Fink<000024@...> wrote:
          >> On Thu, 26 Jul 2012 15:58:56 -0600, Logan Kearsley<chronosurfer@...> wrote:
          >>> One of the things that has always bugged me about Palno being based on
          >>> predicate calculus is the awkwardity of adverb constructions.
          >> The first way I would think to handle these classes (in fact, what
          >> we do in UNLWS) is as predicates whose argument is the Davidsonian
          >> event argument for the verb (there's a word I've learned from
          >> And).
          >
          > That's effectively what Palno so far has always done. Rather than
          > explicitly stating a Davidsonian event argument, though (which would
          > seem to me rather Lojbanish),

          Why Lojbanish? The Lojban method is clunkier than the Palno--Liva or the Livagico-UNLWS systems: it uses a dyadic predicate, _nu_, "x1 is the event of x2", where x2 is syntactically and semantically a predication.

          > the event argument is equivalent to the
          > implicit return value of a non-top-level predicate. That's what allows
          > nesting such that the result of one predicate can be the argument of
          > another.
          >
          > Many of the existing problems with Palno (like correctly handling
          > relative clauses) stem from manipulating that return value so that
          > it's something *other* than the Davidsonian. E.g., top-level
          > predicates have to actually be logical predicates that assert a truth
          > value, like "there exists e such that e satisfies this predicate",
          > rather than the bare argument value itself, "some e such that e
          > satisfies this predicate".

          I don't see why the top-level case is a problem: you could say that the syntactic predication returns an event argument, as usual, and that there is an implicit quantifier binding it. (In the case of Livagian, implicit narrow-scope existential quantification is the default for all arguments; I expect UNLWS is the same.)

          --And.
        • Logan Kearsley
          ... Well, yes, that s precisely what I meant. Palno does not explicitly state the Davidsonian, while Lojban does (or at least, can). Thus, if Palno did so, I
          Message 4 of 9 , Aug 2, 2012
          • 0 Attachment
            On 2 August 2012 09:24, And Rosta <and.rosta@...> wrote:
            > Logan Kearsley, On 01/08/2012 21:17:
            >>
            >> On 1 August 2012 06:33, Alex Fink<000024@...> wrote:
            >>>
            >>> On Thu, 26 Jul 2012 15:58:56 -0600, Logan
            >>> Kearsley<chronosurfer@...> wrote:
            >>>>
            >>>> One of the things that has always bugged me about Palno being based on
            >>>> predicate calculus is the awkwardity of adverb constructions.
            >>>
            >>> The first way I would think to handle these classes (in fact, what
            >>>
            >>> we do in UNLWS) is as predicates whose argument is the Davidsonian
            >>> event argument for the verb (there's a word I've learned from
            >>> And).
            >>
            >> That's effectively what Palno so far has always done. Rather than
            >> explicitly stating a Davidsonian event argument, though (which would
            >> seem to me rather Lojbanish),
            >
            > Why Lojbanish? The Lojban method is clunkier than the Palno--Liva or the
            > Livagico-UNLWS systems: it uses a dyadic predicate, _nu_, "x1 is the event
            > of x2", where x2 is syntactically and semantically a predication.

            Well, yes, that's precisely what I meant. Palno does not explicitly
            state the Davidsonian, while Lojban does (or at least, can). Thus, if
            Palno did so, I would find it to be rather Lojbanish.

            >> the event argument is equivalent to the
            >> implicit return value of a non-top-level predicate. That's what allows
            >> nesting such that the result of one predicate can be the argument of
            >> another.
            >>
            >> Many of the existing problems with Palno (like correctly handling
            >> relative clauses) stem from manipulating that return value so that
            >> it's something *other* than the Davidsonian. E.g., top-level
            >> predicates have to actually be logical predicates that assert a truth
            >> value, like "there exists e such that e satisfies this predicate",
            >> rather than the bare argument value itself, "some e such that e
            >> satisfies this predicate".
            >
            > I don't see why the top-level case is a problem: you could say that the
            > syntactic predication returns an event argument, as usual, and that there is
            > an implicit quantifier binding it. (In the case of Livagian, implicit
            > narrow-scope existential quantification is the default for all arguments; I
            > expect UNLWS is the same.)

            That is essentially the interpretation that I do use, most of the
            time. The trouble with it is that it results in an asymmetry in the
            interpretation of top-level vs. embedded clauses, which means that the
            interpretation of a clause can change if an additional clause is built
            around it (e.g., if adverbials are added), and structures are then
            needed to specify when an embedded clause actually is intended to
            return a truth value rather than an event. I would much prefer
            context-independence.

            -l.
          • Jim Henry
            ... Why not use derivational morphology to turn one type of predicate into another, or to derive several types of predicates from more general roots? I think
            Message 5 of 9 , Aug 2, 2012
            • 0 Attachment
              On Tue, Jul 31, 2012 at 12:22 AM, Logan Kearsley <chronosurfer@...> wrote:
              > one which binds looser and so would attach to the clause). But while
              > this works well for math, with a limited number of operators, it
              > wouldn't work so well for a language with an open class of predicates.
              > It would be like the animacy hierarchy from hell, having to memorize
              > the relative positions of every possible pair of predicates in the
              > entire language, and you could never define enough different synonyms
              > for every predicate to cover ever possible binding order you might
              > ever want.

              Why not use derivational morphology to turn one type of predicate into
              another, or to derive several types of predicates from more general
              roots?

              I think one of the versions of Larry Sulky's Konya used different
              derivational operation to turn roots into noun-oriented prepositions
              or verb-oriented prepositions.

              --
              Jim Henry
              http://www.pobox.com/~jimhenry/
            • Logan Kearsley
              ... That is one of the options, but first I have to know what kinds of predicates to create the morphology for! Just having noun/value-oriented vs.
              Message 6 of 9 , Aug 2, 2012
              • 0 Attachment
                On 2 August 2012 19:41, Jim Henry <jimhenry1973@...> wrote:
                > On Tue, Jul 31, 2012 at 12:22 AM, Logan Kearsley <chronosurfer@...> wrote:
                >> one which binds looser and so would attach to the clause). But while
                >> this works well for math, with a limited number of operators, it
                >> wouldn't work so well for a language with an open class of predicates.
                >> It would be like the animacy hierarchy from hell, having to memorize
                >> the relative positions of every possible pair of predicates in the
                >> entire language, and you could never define enough different synonyms
                >> for every predicate to cover ever possible binding order you might
                >> ever want.
                >
                > Why not use derivational morphology to turn one type of predicate into
                > another, or to derive several types of predicates from more general
                > roots?
                >
                > I think one of the versions of Larry Sulky's Konya used different
                > derivational operation to turn roots into noun-oriented prepositions
                > or verb-oriented prepositions.

                That is one of the options, but first I have to know what kinds of
                predicates to create the morphology for! Just having
                noun/value-oriented vs. verb/function-oriented predicates, e.g.,
                doesn't solve the binding problem with more than 1 adverbial
                predicate, because binding the first still results in a verb/predicate
                phrase, leaving it ambiguous as to whether the second adverbial
                predicate was supposed to bind before or after the first.

                -l.
              • MorphemeAddict
                Try several different kinds. stevo
                Message 7 of 9 , Aug 2, 2012
                • 0 Attachment
                  Try several different kinds.

                  stevo

                  On Thu, Aug 2, 2012 at 10:33 PM, Logan Kearsley <chronosurfer@...>wrote:

                  > On 2 August 2012 19:41, Jim Henry <jimhenry1973@...> wrote:
                  > > On Tue, Jul 31, 2012 at 12:22 AM, Logan Kearsley <chronosurfer@...>
                  > wrote:
                  > >> one which binds looser and so would attach to the clause). But while
                  > >> this works well for math, with a limited number of operators, it
                  > >> wouldn't work so well for a language with an open class of predicates.
                  > >> It would be like the animacy hierarchy from hell, having to memorize
                  > >> the relative positions of every possible pair of predicates in the
                  > >> entire language, and you could never define enough different synonyms
                  > >> for every predicate to cover ever possible binding order you might
                  > >> ever want.
                  > >
                  > > Why not use derivational morphology to turn one type of predicate into
                  > > another, or to derive several types of predicates from more general
                  > > roots?
                  > >
                  > > I think one of the versions of Larry Sulky's Konya used different
                  > > derivational operation to turn roots into noun-oriented prepositions
                  > > or verb-oriented prepositions.
                  >
                  > That is one of the options, but first I have to know what kinds of
                  > predicates to create the morphology for! Just having
                  > noun/value-oriented vs. verb/function-oriented predicates, e.g.,
                  > doesn't solve the binding problem with more than 1 adverbial
                  > predicate, because binding the first still results in a verb/predicate
                  > phrase, leaving it ambiguous as to whether the second adverbial
                  > predicate was supposed to bind before or after the first.
                  >
                  > -l.
                  >
                Your message has been successfully submitted and would be delivered to recipients shortly.