frag, w.r.t. mid80

frozen@mid80 is with the frag programming-language. That is compatible with the prior art from 1980. As most programmers know, coding algorithms in Basic, Pascal, C, or COBOL, does not change what that is telling. The predicates of Nutt, and PL/I of SARA, were that way, too. To map this to that, is trivial.

With frag, a statement may be stated in a few ways. I prefer the calculator syntax, for familiarity that most people have with calculators. The programming syntax of NN73 is mostly supported, too. For example,

the next four, are equivalent
1 =@ b5
b5 @= 1
b5 := 1
1 =: b5

for a rezproc that is bound to r1,
the next two, are equivalent
   b2 ? 1. 0
   b2==1 -> r1:=1.  r1:=0

the next, are equivalent, too
r1 ? 1 =@ b5
r1 -> b5 := 1
r1 == 1 -> b5:=1

frag is resembling NN73 predicates. To translate code to/from these, is trivial. I do not know the rest of the programming system that NN73 were working with, but frag is good enough, for so far. A calculator, resembling Prolog, and with the self-relative operators of C/Pascal (*=, =*, /=, =/, :=, =:, etc).

A calculator is with what, people/children are so accustomed/cozy that, they forget arithmetic -- as reports cry. Prolog is reported as preferrable to iterative languages, for newbies. The C operators for less typing. The Pascal :=, or frag @=, for less-confusability.) All are cozy, familiar, I think. A uniform, succinct language, to assemble the mid80 programming examples.

NN73,p.726,  the transition a1
    activity  is   [ T->M(b3):=M(b1); M(b3(2)):=1 ]
    freezing  is   M(b1(7))

with frag,
    activity is    1 =@ b3[2]  or  b3[2]:=1  or  M(b3(2)):=1
    freezing is    b1[7]       or  M(b1(7))

The transition procedures of NN73 (Noe & Nutt) may seem "more explicit," but that is not exactly true. If you would examine all of that formal-listing, you would see that, although in some cases, the procedure is explicitly telling the obvious token-transfer, in other transitions, telling short. Therefore, I infer that, those more verbose examples were redundant, presumably for exemplifying how to modify the default behavior of a transition, although in that specific application no such special-case existed. As a result of what Iinfer, frozen@mid80 is inferring what is affine. For example, if one of the two afferent (input) locations has the width (amount of attributes in the token) as the forward (output) location, that is the path for token-transfer. That default is modifiable, though, through the transition-procedure. No different than NN73.

Freezing is a type of waiting that is with no activity. The term freezing is, therefore, more fitting than "dwell time" (Nutt, Merlin, & Danthine term) or "delay" (SARA term). With a farmaze/food metaphor, first rezolving for what you want. Right next, that fresh fruit/greenery is frozen, until the time of edibility (activity is actually what firing is for, freezing is no work, as far as your metabolism would tell). That is, there is the count-down, of firing

The time-Petri-net type of freezing (as Merlin, & Danthine used), is setting the minimum and maximum allowable freezing period. The minimum is certainly expiring. The maximum is resembling the expiry-date on food labels. Firable until that, or otherwise, not firable.

For monitoring, frozen@mid80 is using Nutt & SARA type of freezing. The time-Petri-net type is sounding more fitting for representing-for-verifying. But if a random-timing function is used, that is well for monitoring, too -- [almost] equivalent to Nutt type of freezing. (For randomizing, frozen@mid80 has the ran3 that Knuth had published, as I got that from NumericalRecipes.)

NN73,p.726,  the transition a16
   activity  is   [ T->M(b24(2)):=2 ]
   freezing  is   0 &  0 for both
   rezolving is   r4 : [ M(b23(5))>=M(b23(4)) -> M(r4):=1  : T->M(r4):=0 ]

with frag,
   activity is    2 =@ b24[2]
   freezing is    0   &  0
   rezolving is   b23[5]>=b23[4] ? 1. 0.

Short-circuiting is the Prolog attitude to fail a predicate. The frag fail-testing is with '?' (equivalent to the ',' (comma/and) of Prolog, '->' of NN78, and "if then" of Pascal or PL/I). After a predicate has failed, Prolog would backtrack. Prolog is grouping by name-similarities, while frag is keeping all the row-list of a frag, together, and testing all, until a row finishes, or all have failed.

Referring to the rezloc with explicit-naming, is fitting frag, too. But that is not a good strategy for a function repository, for re-usable frag'ging. In cases, if the frag is not referring to a local data (token-state, or token-attribute value), the repository is convenient. For modifier-relative fragging, the token is referrable as a[1] (or, I[1]) if afferent/input location, and f[1] (or, O[2]) for a forward/output location. For example, Peterson would list all the places input to a transition t5 as I(t5) = {p8, p9, p10}. With frag, to refer p10 through t5, I(t5)[3] is the format.

For a function that is bound to a transition any way, the transition-naming is unnecessary. Thus, fruitfully, for a function-repository, I[3] is pointing at p10, when run in a frag/function that is bound to t5. (A rezproc is bound to a rezloc. Any rezloc (in Nutt formalism) is determining for a single modifier/transition. Thus, transitively, a rezproc may refer those through a[] & f[], too.) The Q of Valette is similar (if referring to data-only, no control-peeking, and also when used for rezolving from a specific transition). The strategies for a function-repository are no different than macros.

Fragging is a formal-netting [with hierarchies], irrespective of how to organize the graph-or-graphs laterally. NN73 and VD78 both design with hierarchies. Representing the single-graph of NN73, as two-(laterally-)related-graphs of LOGOS (as VD78 and SARA prefer), does not differ, though. The operator that is running when a VD78 transition is firing, is no different than the transition-procedure of Nutt -- except that Nutt tokens may have token-attributes, but that is simply a type of data (message, or local-data), that is, not quite different than VD78/LOGOS. (Danthine (1980) had pointed out that, too, about Nutt & Keller.) They are Petri net derivatives, with small notational differences, and all adding a few into that literature. Trivial to see the link.

For fragging with frozen@mid80, the syntax of referring to mid80 literature may confuse, too, in cases. For example, Peterson/Petri notation for listing the output-places of a transition is O(t5), while VD78 is using that letter "O" for 'o'perator, that is that what activity() of Nutt does. With frag, keep in mind that O(t5) and O5() are different, rather, O5() and a5() (the transition/activity) are [mostly] equivalent, and O(t5) and f5[] (the forward-location list) are equivalent. Happily, that kind of resembling/interfering is rare, thus, justifying the support for all of the mid80 formal letters.

Forum: . . (Fair Menu . . . . . Fault Report? . . . . . Remedy for your case . . . . . Noticed Plagiarism?)

Referring#: 0.0.1
Last-Revised (text) on Feb. 23, 2007 . . . published as
Written by: Ahmed Ferzen/Ferzan R Midyat-Zila (or, Earth)
Copyright (c) [2002,] 2007, 2009 Ferzan Midyat. All rights reserved.
frozen@mid80, frag, form@fix, & are trademarks of Ferzan Midyat.