This is the manifestation of the bug, (<'&')` &`
On Sat, Oct 21, 2017 at 7:55 AM, Jose Mario Quintana < [email protected]> wrote: > Hi Erling, > > The issue arises because my original post shows a session as opposed to a > clean script and I used a trick to define three adverbs in one line, see my > last response, to Raul. That should not have caused any harm except that > J's response is affected by a linear representation bug. > > In retrospect, to avoid any confusion, I should have edited the session > and deleted J's response; that is, > > 9!:14'' > o=. @: > ar=. 5!:1 @:< > (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6)) > av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6) > ... > > What you did is equivalent, thanks. > > The first part runs fine using the latest "stable" official interpreter > (it also runs in Jx, of course). The last part (the "thought experiment" > was run using Jx). > > > > > On Sat, Oct 21, 2017 at 7:30 AM, Jose Mario Quintana < > [email protected]> wrote: > >> Look carefully at my first post [0] as I suggested (using a browser), the >> line, >> >> (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6)) >> >> defines a0, a1 and a2, the next line is J's response >> ((`'')(((@:[)(&`))(`:6)))((`_)(`:6)) and the next line, >> >> av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6) >> >> is where ar'a2' is used. >> >> >> [0] [Jprogramming] Trains: past, present and ... Jose Mario Quintana >> http://www.jsoftware.com/pipermail/programming/2017-October/ >> 049263.html >> >> >> On Fri, Oct 20, 2017 at 6:18 PM, Raul Miller <[email protected]> >> wrote: >> >>> Please re-read my message? >>> >>> Yes, the line quoted in my error message got wrapped. However, I have >>> no reason [yet] to believe that it was incomplete. >>> >>> But... your quoting of that error message wrapped it further for me. I >>> do not know if that wrapping happened before you got my message or >>> after. But I would hope at the very least that you would recognize >>> that the error message contained [even if wrapped] what I believed was >>> the line that's throwing the error. >>> >>> Anyways... I do not see how "beware of line wrapping" solves anything >>> here. Not yet, anyways. >>> >>> That said, if you really want to avoid line wrap issues, I would >>> recommend using pastebin. >>> >>> (But, my reading of the code suggests that a2 would still be undefined >>> if it's run in a fresh session. And, I suspect you could see this for >>> yourself if you take that erase line from your message and include it >>> at the top of your script. Be sure, of course, to be running J and not >>> Jx...) >>> >>> Anyways, I'm willing to believe that I have made a mistake. And I >>> might even be convinced that I missed some sort of line wrap issue. >>> But, right now, I'm definitely not seeing it. (And, as verification: >>> every line in my copy of the code is indented - but line-wrap leaves >>> unindented lines.) >>> >>> Thanks, >>> >>> -- >>> Raul >>> >>> >>> On Fri, Oct 20, 2017 at 5:53 PM, Jose Mario Quintana >>> <[email protected]> wrote: >>> > No, a2 is defined previously; recall "beware of line-wrapping." >>> > >>> > In addition, what I showed was a session output, not a clean script. >>> If >>> > your email formatting is giving you a hard time, try to look at the >>> version >>> > of my post in the forum archive. >>> > >>> > I hope it helps >>> > >>> > >>> > On Thu, Oct 19, 2017 at 8:31 PM, Raul Miller <[email protected]> >>> wrote: >>> > >>> >> When I try to execute your script, I get: >>> >> >>> >> |value error: a2 >>> >> | (a0=.`'')(a1=.(@:[)((<'&')`)(`:6))(a2=.(`(<(":0);_))(`:6))( >>> >> (`'')(((@:[)(&`))(`:6)))((`_)(`:6))av=.((ar'a0')`)(`(ar'a1'))(`( >>> >> ar'a2'))(`:6) >>> >> |[-3] /users/rauldmiller/j64-805-user/temp/2.ijs >>> >> 9!:14'' >>> >> j805/j64/darwin/beta-9/commercial/www.jsoftware.com/2016-07- >>> 05T17:11:06 >>> >> >>> >> And, indeed, it does look like you are referring to ar'a2' before >>> >> you define a2. >>> >> >>> >> Thanks, >>> >> >>> >> -- >>> >> Raul >>> >> >>> >> >>> >> On Thu, Oct 19, 2017 at 8:21 PM, Jose Mario Quintana >>> >> <[email protected]> wrote: >>> >> > There were many adverb and conjunction producing trains during a >>> period >>> >> > which Henry has referred as the Golden Age. Some were available as >>> early >>> >> > as 1993 [0] and several more afterward [1]. A few of those adverb >>> >> > producing trains (all of them bidents) survived [2] (using nv to >>> denote >>> >> > noun or verb), >>> >> > >>> >> > " >>> >> > x (a1 a2) is x a1 a2 >>> >> > x (c nv) is x c nv >>> >> > x (nv c) is nv c x >>> >> > " >>> >> > >>> >> > but none of the conjunction producing trains did. Nevertheless, I >>> >> learned >>> >> > to appreciate very much two of them (a trident and a bident), >>> together >>> >> with >>> >> > the survivors, many years after they were decommissioned, >>> >> > >>> >> > " >>> >> > x (a1 c2 a3) y is (x a1) c2 (y a3) >>> >> > ... >>> >> > x (c a) y is (x c y) a >>> >> > " >>> >> > >>> >> > I hope mentioning old versions of J does not provoke a wild-goose >>> chase >>> >> ;) >>> >> > >>> >> > Remarkably, the adverb producing train survivors are sufficient to >>> allow >>> >> > for complete adverbial programming in the following sense: if the >>> desired >>> >> > entity (a noun, verb, adverb or conjunction), to be produced, can be >>> >> > computed from the adverb's argument then there is a (pure) tacit >>> adverb >>> >> > able to do so (even compliantly; that is, the hard way, without >>> using any >>> >> > black magic). >>> >> > >>> >> > How come? There are several ways to show how this can be done; the >>> J >>> >> > sentences further down define a (Curried) adverb hg which can >>> define an >>> >> > arbitrary adverb t as follows, >>> >> > >>> >> > t=. v hg >>> >> > >>> >> > hg acts on a (presumably pure tacit) workhorse verb v and produces >>> the >>> >> > required adverb (t). The workhorse verb acts on the atomic >>> >> representation >>> >> > of t's argument and should produce the atomic representation (or >>> similar) >>> >> > of the desired entity; finally, hg evokes (`:6) it. Since (at >>> least, in >>> >> > principle) one can go back and forth between the atomic >>> representations >>> >> and >>> >> > the entities they represent, tacit adverbial programming is reduced >>> to >>> >> > tacit verbal programming and the latter is Turing complete [3, 4]. >>> >> > >>> >> > The adverb hg can be defined as follows (no agendas are used, which >>> some >>> >> > members might find too cryptic), beware of line-wrapping, >>> >> > >>> >> > 9!:14'' >>> >> > j805/j64/windows/release/commercial/www.jsoftware.com/2016- >>> >> 12-11T08:02:16 >>> >> > >>> >> > o=. @: >>> >> > ar=. 5!:1@:< >>> >> > >>> >> > (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) >>> (`:6)) >>> >> > ((`'')(((@:[)(&`))(`:6)))((`_)(`:6)) >>> >> > av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6) >>> >> > NB. Adverbing a monadic verb (adv) >>> >> > assert 1 4 9 -: 1 2 3 *: av >>> >> > >>> >> > aw=. < o ((0;1;0)&{::) NB. Fetching the atomic representation >>> >> > a3=. (@: (aw f.)) ('av'f.) >>> >> > a4=. "_ >>> >> > a5=. `:6 >>> >> > a6=. ((( ar'a4') ; ] ; ( ar'a3')"_) ('av'f.)) (`:6) >>> >> > >>> >> > hg=. `((ar'a6')`(ar'a5')) (`:6) >>> >> > assert 1 4 9 -: 1 2 3 ((<'*:') ; ]) hg >>> >> > >>> >> > erase'a0 a1 a2 a3 a4 a5 a6 ar av aw' >>> >> > 1 1 1 1 1 1 1 1 1 1 >>> >> > >>> >> > The adverb hg is tacit and it is fixed. Once it is defined one >>> does not >>> >> > have to know or remember how it works to use it (that was the main >>> point >>> >> > for defining it in the first place). >>> >> > >>> >> > The verb an is convenient to use together with hg for development >>> >> (because >>> >> > it neutralizes the hg ending adverb evoke (`:6)) >>> >> > >>> >> > an=. <@:((,'0') (,&<) ]) NB. Atomizing words (monadic verb) >>> >> > >>> >> > For example, assume one wants an adverb t to act on a gerund, >>> >> representing >>> >> > two verbs (say, u and v) u`v, and produce the verb v@u; thus one >>> needs a >>> >> > workhorse verb to produce, >>> >> > >>> >> > v@:u an hg >>> >> > ┌──────────┐ >>> >> > │┌──┬─────┐│ >>> >> > ││@:│┌─┬─┐││ >>> >> > ││ ││v│u│││ >>> >> > ││ │└─┴─┘││ >>> >> > │└──┴─────┘│ >>> >> > └──────────┘ >>> >> > >>> >> > acting on, >>> >> > >>> >> > (u`v) an hg >>> >> > ┌─────────┐ >>> >> > │┌─┬─────┐│ >>> >> > ││0│┌─┬─┐││ >>> >> > ││ ││u│v│││ >>> >> > ││ │└─┴─┘││ >>> >> > │└─┴─────┘│ >>> >> > └─────────┘ >>> >> > >>> >> > Therefore, given that, >>> >> > >>> >> > (u`v) an o (< o ((('@:') ; < o |.)) o (('';1)&{::)) hg >>> >> > ┌──────────┐ >>> >> > │┌──┬─────┐│ >>> >> > ││@:│┌─┬─┐││ >>> >> > ││ ││v│u│││ >>> >> > ││ │└─┴─┘││ >>> >> > │└──┴─────┘│ >>> >> > └──────────┘ >>> >> > >>> >> > the adverb t can be defined as, >>> >> > >>> >> > t=. < o ((('@:') ; < o |.)) o (('';1)&{::) hg >>> >> > >>> >> > (u`v)t >>> >> > v@:u >>> >> > >>> >> > Let us entertain a more general version of t taking a gerund >>> >> representing a >>> >> > (variable) number of verbs, the atomic representation of a sample >>> >> argument >>> >> > u0`u1`u2`u3`u4 (extra parentheses used again for clarity) is, >>> >> > >>> >> > (u0`u1`u2`u3`u4) an hg >>> >> > ┌────────────────────┐ >>> >> > │┌─┬────────────────┐│ >>> >> > ││0│┌──┬──┬──┬──┬──┐││ >>> >> > ││ ││u0│u1│u2│u3│u4│││ >>> >> > ││ │└──┴──┴──┴──┴──┘││ >>> >> > │└─┴────────────────┘│ >>> >> > └────────────────────┘ >>> >> > >>> >> > and the atomic representation of the product u0@:u1@:u2@:u3@:u4 is, >>> >> > >>> >> > (u0@:u1@:u2@:u3@:u4) an hg >>> >> > ┌──────────────────────────────────────────┐ >>> >> > │┌──┬─────────────────────────────────────┐│ >>> >> > ││@:│┌────────────────────────────────┬──┐││ >>> >> > ││ ││┌──┬───────────────────────────┐│u4│││ >>> >> > ││ │││@:│┌──────────────────────┬──┐││ │││ >>> >> > ││ │││ ││┌──┬─────────────────┐│u3│││ │││ >>> >> > ││ │││ │││@:│┌────────────┬──┐││ │││ │││ >>> >> > ││ │││ │││ ││┌──┬───────┐│u2│││ │││ │││ >>> >> > ││ │││ │││ │││@:│┌──┬──┐││ │││ │││ │││ >>> >> > ││ │││ │││ │││ ││u0│u1│││ │││ │││ │││ >>> >> > ││ │││ │││ │││ │└──┴──┘││ │││ │││ │││ >>> >> > ││ │││ │││ ││└──┴───────┘│ │││ │││ │││ >>> >> > ││ │││ │││ │└────────────┴──┘││ │││ │││ >>> >> > ││ │││ ││└──┴─────────────────┘│ │││ │││ >>> >> > ││ │││ │└──────────────────────┴──┘││ │││ >>> >> > ││ ││└──┴───────────────────────────┘│ │││ >>> >> > ││ │└────────────────────────────────┴──┘││ >>> >> > │└──┴─────────────────────────────────────┘│ >>> >> > └──────────────────────────────────────────┘ >>> >> > >>> >> > Now, that seems to be messy but it does not have to be (hint: >>> producing >>> >> the >>> >> > atomic representation is not necessary, as long as the entity can be >>> >> evoked >>> >> > correctly). A solution of this type is shown near the end of this >>> post. >>> >> > >>> >> > While currently, tacit adverbial programming is complete, tacit >>> >> > conjunctional programming is, alas, virtually zip. Nevertheless, >>> let us >>> >> > have a thought experiment: what would happen if the two conjunction >>> >> > producing trains I mentioned above had survived? Would >>> conjunctional >>> >> > programming be complete in the same sense in which tacit adverbial >>> >> > programming is? The answer is yes. >>> >> > >>> >> > How come? Because then tacit conjunctional programming could be >>> reduced >>> >> to >>> >> > tacit adverbial programming. Assume, for example, that a >>> conjunction >>> >> acts >>> >> > on a noun and a verb, say 1 2 3 4 and +/, then >>> >> > >>> >> > 1 2 3 4 ((an f.hg) (` (an o ((('';1)&{::))hg))(an f.hg)) (+/) >>> >> > ┌───────────┬───────┐ >>> >> > │┌─┬───────┐│┌─┬───┐│ >>> >> > ││0│1 2 3 4│││/│┌─┐││ >>> >> > │└─┴───────┘││ ││+│││ >>> >> > │ ││ │└─┘││ >>> >> > │ │└─┴───┘│ >>> >> > └───────────┴───────┘ >>> >> > >>> >> > Therefore, one can replace the verb an by a workhorse verb v acting >>> on >>> >> the >>> >> > above gerund to produce whatever is desired, for example, if one >>> wants >>> >> the >>> >> > right-hand verb argument to act on the left-hand side argument we >>> could >>> >> > simply define the conjunction as follows, >>> >> > >>> >> > t=. ((an f.hg) (` (|. o ((('';1)&{::))hg)) (an f.hg)) >>> >> > >>> >> > 1 2 3 4 t (+/) >>> >> > 10 >>> >> > >>> >> > 'boxed' t < >>> >> > ┌─────┐ >>> >> > │boxed│ >>> >> > └─────┘ >>> >> > >>> >> > type't' >>> >> > ┌───────────┐ >>> >> > │conjunction│ >>> >> > └───────────┘ >>> >> > >>> >> > In general, an arbitrary conjunction could be defined as, >>> >> > >>> >> > >>> >> > t=. (an f.hg) (` (v o ((('';1)&{::))hg)) (an f.hg) >>> >> > >>> >> > where v is the workhorse verb. For the common case where the two >>> >> arguments >>> >> > are verbs, >>> >> > >>> >> > t=. ` (v o ((('';1)&{::))hg) >>> >> > >>> >> > would be sufficient. >>> >> > >>> >> > The 1993 version J is unable to successfully define hg because, >>> although >>> >> > evoke (`:6) supported gerunds representing lists of verbs, it did >>> not >>> >> have >>> >> > the extended functionality for hg to be able to work; that was added >>> >> > later. I am not sure if the late versions of the interpreters of >>> the >>> >> > Golden Age can reproduce all the above. >>> >> > >>> >> > However, the above is not quite a pure thought experiment. It >>> reflects a >>> >> > Jx session (Jx is a fork of J that provides some extensions [5]). >>> (Jx >>> >> does >>> >> > not require the conjunction producing trains to make tacit >>> conjunctional >>> >> > programming complete because it provides an alternative way to >>> produce >>> >> > arbitrary conjunctions; there are there because they are useful and >>> I >>> >> > personally consider any tiny performance penalty, due to restoring a >>> >> > trident entry in the parse table, as a well-deserved tribute to >>> them.) >>> >> > >>> >> > Could they find their way back to official interpreters? I do not >>> think >>> >> > so. Yet, complete conjunctional tacit programming could be provided >>> >> without >>> >> > having to restore any trident (apart from the fork trident which is >>> >> > special). How come? I could give an outline on how this could be >>> >> > implemented but this post is already way too long and I wonder how >>> many >>> >> > members could still be reading it at this point. >>> >> > >>> >> > However, before I forget, just in case someone wants to see it... >>> >> > >>> >> > The more general adverb t can be obtained easily: since, >>> >> > >>> >> > (u0`u1`u2`u3`u4) an o (([ , (<'@:') , ])/o |. o (('';1)&{::))hg >>> >> > ┌──┬──┬──┬──┬──┬──┬──┬──┬──┐ >>> >> > │u4│@:│u3│@:│u2│@:│u1│@:│u0│ >>> >> > └──┴──┴──┴──┴──┴──┴──┴──┴──┘ >>> >> > >>> >> > then t can be defined as, >>> >> > >>> >> > t=. ([ , (<'@:') , ])/o |. o (('';1)&{::)hg >>> >> > >>> >> > u0`u1`u2`u3`u4`u5`u6 t >>> >> > u6@:u5@:u4@:u3@:u2@:u1@:u0 >>> >> > >>> >> > *:`(+/)`-`j.`(^ %:)t 1 2 3 >>> >> > 2.40034j16.7123 >>> >> > >>> >> > PS. My plans for sending a version of this post during the weekend >>> were >>> >> > crushed because I was too busy (oversleeping, watching dance >>> >> performances, >>> >> > eating out, swimming, watching boxing, football, etc. :) >>> >> > >>> >> > >>> >> > References >>> >> > >>> >> > [0] [Jprogramming] Tacit Expressions with Explicit J Syntax roger >>> stokes >>> >> > >>> >> > http://www.jsoftware.com/pipermail/programming/2017-Septembe >>> >> r/048917.html >>> >> > >>> >> > [1] [Jprogramming] Jx 1.1 Release neitzel >>> >> > http://www.jsoftware.com/pipermail/programming/2017-October >>> >> /049177.html >>> >> > >>> >> > [2] [Jprogramming] Jx 1.1 Release neitzel >>> >> > http://www.jsoftware.com/pipermail/programming/2017-October >>> >> /049179.html >>> >> > >>> >> > [3] Universal Turing machine (J) >>> >> > https://rosettacode.org/wiki/Universal_Turing_machine#J >>> >> > >>> >> > [4] Jforum: A Tacit Implementation of a Turing Machine >>> >> > http://www.jsoftware.com/pipermail/general/1999-December/002 >>> 736.html >>> >> > >>> >> > [5] [Jprogramming] Jx 1.1 Release Jose Mario Quintana >>> >> > >>> >> > http://www.jsoftware.com/pipermail/programming/2017-Septembe >>> >> r/048957.html >>> >> > ------------------------------------------------------------ >>> ---------- >>> >> > For information about J forums see http://www.jsoftware.com/forum >>> s.htm >>> >> ------------------------------------------------------------ >>> ---------- >>> >> For information about J forums see http://www.jsoftware.com/forum >>> s.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 >>> >> >> > ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
