I would keep in mind that one advantage of redundant information (such
as redundant parenthesis) is that this can let you ignore some
surrounding issues.
That is not always the best tactic - it often pays to have a deep
understanding - but the ability to focus attention where it's needed
is crucial.
Thanks,
--
Raul
On Thu, Mar 19, 2020 at 10:14 AM 'Pascal Jasmin' via Programming
<programm...@jsoftware.com> wrote:
>
> Your interesting new example is
>
> (<,'/')`(<(<,'@')`(<(<,'2'),<g`h))`:6
> /(@(g h))
>
> The explicit hook indicator (2) seems needed here because it seems hard to
> weave extra boxing levels without the hook indicator, but there is such a
> form:
>
> ((<,'/')`(<(<,'@')`(<<g`h)))`:6
>
> /(@(g h))
>
> ((;:'/@'),(g`h))@.(0 ; < 1 ; << 2 3)
>
> /(@(g h))
>
> So your D2 definition is already part of the implementation.
>
> Still, in constructing gerrunds/ARs, the advice to use the verb train
> indicators when that is the intention seems recommendable/safe, though if
> every train has a nested representation (I need more thought to evaluate)
> then there'd be no reason to use the safe approach, and perhaps no reason to
> not represent train ARs with nesting levels.
>
>
>
>
>
> On Wednesday, March 18, 2020, 11:52:16 p.m. EDT, Jose Mario Quintana
> <jose.mario.quint...@gmail.com> wrote:
>
>
>
>
>
> > You are suggesting that a list of ARs be construed as a valid AR.
>
> No, I would not dare to mess with the description of what an AR is.
> Probably the source of the confusion was my unfortunate use of the phrases
> "M represents R" when I just meant "The product of M `:6 is R." What I am
> suggesting is to extend the description of what a kosher argument (m) is in
> (m`:6). (Its valid boxed structure would be similar to the one for a
> (current) kosher argument (n) in (m@.n).)
>
> This is a more precise recursive description of the construction of a
> kosher argument (m) in (m`:6) assuming D2 holds:
>
> A <kosher argument> is,
>
> 0. An AR, or
>
> 1. A list of one or more <kosher argument>s, or
>
> 2. A boxed <kosher argument>.
>
> If (2) above is not included then it becomes the description of the
> construction of a valid argument assuming D1 holds (if I am not mistaken).
> (If one replaces (AR) above by (integer) then, I think, it becomes a
> description of the construction of a (current) kosher argument (n) in (m@
> .n).)
>
> Hopefully, answering the question (and it is a very good question) you
> posed might clarify further what I am trying to convey. Assuming (g) and
> (h) are verbs, if (f) is a verb then,
>
> f`(<g`h)
> ┌─┬─────┐
> │f│┌─┬─┐│
> │ ││g│h││
> │ │└─┴─┘│
> └─┴─────┘
> f`(<g`h) `: 6
> f (g h)
>
> This argument is not a list of ARs regardless if one is assuming D1 or D2.
> It is not kosher assuming D1 but it is assuming D2. Likewise, if (f) is a
> conjunction, say (@), then,
>
> (<,'@')`(<g`h)
> ┌─┬─────┐
> │@│┌─┬─┐│
> │ ││g│h││
> │ │└─┴─┘│
> └─┴─────┘
> (<,'@')`(<g`h) `:6
> @(g h)
>
> Again, this argument is not a list of ARs regardless if one is assuming D1
> or D2. It is not kosher assuming D1 but it is assuming D2. In addition,
> in both scenarios (if (f) is a verb or (f) is a conjunction) the product,
> assuming D2, can be thought as a train of two entities, the trailing one
> being a derived entity (g h).
>
> In contrast, the boxed form of ((<,'@')`(<g`h)),
>
> <(<,'@')`(<g`h)
> ┌─────────┐
> │┌─┬─────┐│
> ││@│┌─┬─┐││
> ││ ││g│h│││
> ││ │└─┴─┘││
> │└─┴─────┘│
> └─────────┘
> (<(<,'@')`(<g`h)) `:6
> g@h
>
> Is the AR of g@h and it is kosher assuming D1 (and, of course assuming D2
> as well). Furthermore, one can simply use,
>
> (;:'g@h')
> ┌─┬─┬─┐
> │g│@│h│
> └─┴─┴─┘
> (;:'g@h') `:6
> g@h
>
> the result is the same but it is produced as the train of three entities.
>
> A remaining question is, why the result of ((<(<,'@')`(<g`h)) `:6) is not
> (@(g h))? Apparently, the interpreter gives priority to ARs.
>
> > I don't like having to parse the ARs to figure out how to interpret them.
>
> What is the interpreter doing now? I do not know... Maybe you can let us
> know?
>
> How would one produce, for instance, (/(@g h)) then? One way is to use the
> AR of (u v),
>
> (<,'/')`(<(<,'@')`(<(<,'2'),<g`h))
> ┌─┬─────────────┐
> │/│┌─┬─────────┐│
> │ ││@│┌─┬─────┐││
> │ ││ ││2│┌─┬─┐│││
> │ ││ ││ ││g│h││││
> │ ││ ││ │└─┴─┘│││
> │ ││ │└─┴─────┘││
> │ │└─┴─────────┘│
> └─┴─────────────┘
> (<,'/')`(<(<,'@')`(<(<,'2'),<g`h)) `:6
> /(@(g h))
>
> The above is just an elaborated version of Pascal's answer given
> earlier. Thinking
> more about it, if D2 were adopted, I do not think any text in NuVoc would
> have to be changed regarding tie (`), not even the description of gerund
> unless one would like to refer to (m) in m`:6 as a gerund. The agenda (@.)
> entry of the Dictionary would have to be understood accordingly as well.
>
> I hope it helps.
>
> -----------------------------------------------------------------------------
>
>
> On Tue, Mar 17, 2020 at 10:46 AM Henry Rich <henryhr...@gmail.com> wrote:
> >
> > You are suggesting that a list of ARs be construed as a valid AR. I
> > agree with the goal. I worry that the encoding is not reversible.
> >
> > +---------+
> > |+-+-----+|
> > ||f|+-+-+||
> > || ||g|h|||
> > || |+-+-+||
> > |+-+-----+|
> > +---------+
> >
> > Is this (f (g h)) (as it must be if f is a verb)
> > or (g f h) (if f is a conjunction)?
> >
> > I don't like having to parse the ARs to figure out how to interpret them.
> >
> > Henry Rich
> >
> >
> > On 3/16/2020 10:18 PM, Jose Mario Quintana wrote:
> > >> I would say that (<,'"') is kosher and (<'"') not, already, based on
> > >> this interpretation of what Ye Dic meant. The implementation is
> > > I am adopting your suggestion henceforth.
> > >
> > >> My vote would be that 'train' refers to any sequence of ARs and that
> > >> when `:6 said 'train of individual verbs' it meant to say 'the
> (possibly
> > >> derived) words created by executing the train of the (possibly derived)
> > >> words represented by each AR'.
> > > So,
> > >
> > > D0. m `: 6 Train Result is the train of individual verbs.
> > >
> > > would become (or be understood as),
> > >
> > > D1. m `: 6 Train Result is the (possibly derived)
> > > words created by executing the train
> > > of the (possibly derived) words
> > > represented by each AR.
> > >
> > > I have thought more about this and I am not quite sure about the wisdom
> of
> > > banning, eventually (when the negligence rather than benevolence stops),
> > > the boxed arrays of ARs currently supported by the interpreter. My
> > > perspective comes from the tacit adverbial programer's viewport which
> will
> > > try to explain next assuming that D1 is the law (i.e., henceforth kosher
> > > also implies compliance with D1).
> > >
> > > If the argument of (`:6) is a list of ARs of primary parts-of-speech,
> (`:6)
> > > produces the non-parenthesized (i.e., with the parsing rules implied
> > > parenthesization) train of the corresponding primary
> parts-of-the-speech.
> > > However, when its argument is boxed the interpreter's result is the
> train
> > > which is parenthesized accordingly, and this is not kosher.
> > >
> > > How can this extra illegal flexibility be important to a tacit adverbial
> > > programmer? Consider the following slight variation of my
> general-purpose
> > > generator of tacit adverbs (hg),
> > >
> > > o=. @:
> > > c=."_
> > > ar=. 5!:1@:<
> > >
> > > d=. (a0=. `'') (a1=. (@:[) ((<,'&')`) (`:6)) (a2=. (`(<(":0);_))
> (`:6))
> > > av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6)
> > > assert 1 4 9 -: 1 2 3 *: av
> > >
> > > The only change was replacing (<'&') by (<,'&') (this does not me too
> > > much). I think its construction and operation is kosher; ye, The Wise
> of
> > > J, be the judges.
> > >
> > > The last part of (hg)'s construction is unchanged,
> > >
> > > aw=. < o ((0;1;0)&{::) NB. Fetching the atomic representation
> > > d=. (a3=. (@: (aw f.)) ('av'f.)) (a4=. "_) (a5=. `:6)
> > > a6=. ((( ar'a4') ; ] ; ( ar'a3')"_) ('av'f.)) (`:6)
> > >
> > > hg=. `((ar'a6')`(ar'a5')) (`:6)
> > >
> > > Again, if I am not mistaken, (hg)'s construction is kosher. However,
> > > whether its operation is kosher, or not, depends on its controlling
> (tacit)
> > > verb argument. This verb operates on the AR of the argument of the
> > > generated adverb and, I believe, if (and only if) it produces the AR,
> or a
> > > list of AR(s), representing the desired product, then it is kosher. Two
> > > toy examples follow, one simple and another slightly more complicated.
> > >
> > > One can use (hg) to generate an adverb (a) which is meant to take a
> > > non-parenthesized train of two or more proverbs and produce the verb
> where
> > > (@:) is inserted between the proverbs,
> > >
> > > a=. ([ , (<,'@:') , ])/ o (((3 = ]) +. (_1 = ])) o (4!:0) # ]) o
> (<S:0)
> > > f.hg
> > >
> > > This tacit fixed adverb operates in a kosher manner,
> > >
> > > (v0 v1 v2 v3 v4 v5 v6)a
> > > v0@:v1@:v2@:v3@:v4@:v5@:v6
> > >
> > > since the train produced is non-parenthesized. (If I am not mistaken.)
> > >
> > > In contrast, the following tacit fixed adverb (b) which generates an
> adverb
> > > that produces a train of adverbs by bonding accordingly its list of
> > > integers argument,
> > >
> > > an=. <@:((,'0') ,&:< ])
> > >
> > > b=. (< o ((;:'&') , <) o an"0) o x: o (('';1)&{::) f.hg
> > >
> > > does not operate in a kosher manner (and eventually it will fail),
> > >
> > > _2 3 _1 b
> > > ((&_2x)(&3x))(&_1x)
> > >
> > > +_2 3 _1 b 0 1 3 4 5 6
> > > _1 5 17 _31 65 _127
> > >
> > > and its kosher counterpart would be more complicated (because of the
> > > produced train parenthesization) when one does not need any additional
> > > complications. (If I am not mistaken.)
> > >
> > > It might be due to trickery but this current behavior of the interpreter
> > > comes across as a very useful feature from this perspective. I see a
> > > benefit if it is preserved and I cannot see a disadvantage. Thus,
> assuming
> > > I am not missing something important, I would like to offer my two
> cents,
> > >
> > > D2. m `: 6 Train Result is the (possibly derived)
> > > words created by executing the train of the
> > > (possibly derived) words represented by
> > > each AR. If m is boxed, the boxed trains
> > > are parenthesized accordingly.
> > >
> > > which is the same as D2 plus a fragment which was taken, almost
> verbatim,
> > > from the (@.) entry.
> > >
> > > Igor Zhuravlov's 3-fork, for instance, is represented by,
> > >
> > > (<v3 ` v1 ` v4) ` v0 ` (<v4 ` v2 ` v5)
> > > ┌──────────┬──┬──────────┐
> > > │┌──┬──┬──┐│v0│┌──┬──┬──┐│
> > > ││v3│v1│v4││ ││v4│v2│v5││
> > > │└──┴──┴──┘│ │└──┴──┴──┘│
> > > └──────────┴──┴──────────┘
> > >
> > > (<v3 ` v1 ` v4) ` v0 ` (<v4 ` v2 ` v5) (`:6)
> > > (v3 v1 v4) v0 v4 v2 v5
> > >
> > > whereas, assuming D1, it is represented by (ye fill the blank),
> > >
> > > ...
> > >
> > > Either way, regardless of what is ultimately decided, I think, the (@.)
> and
> > > (`) entries should be modified accordingly (I do not know about the
> concept
> > > of gerund).
> > >
> > >
> ------------------------------------------------------------------------------
> > >
> > >
> > > On Fri, Mar 13, 2020 at 11:40 AM Henry Rich <henryhr...@gmail.com>
> wrote:
> > >> I think I agree.
> > >>
> > >> My vote would be that 'train' refers to any sequence of ARs and that
> > >> when `:6 said 'train of individual verbs' it meant to say 'the
> (possibly
> > >> derived) words created by executing the train of the (possibly derived)
> > >> words represented by each AR'.
> > >>
> > >> I would say that (<,'"') is kosher and (<'"') not, already, based on
> > >> this interpretation of what Ye Dic meant. The implementation is
> > >> permissive in some cases.
> > >>
> > >> Henry Rich
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
