APPENDIX

Description of the LYaP AS Language*

A. D. Zakrevskii

§ 1. General Principles of the LYaPAS Language

Purpose of the LYaPAS Language In many cases, the complexity of contemporary devices for the automatic processing of discrete information becomes so great that the actual building ofthese devices, performed on the intuitive level, leads to enormous expenditures of resources, materials, and time in the design phase, and to obtaining unnecessarily large, and hardly complete, constructive solutions. It is therefore necessary to replace the intuitive methods of construction by a rigorous theory of discrete automaton design. Today, the theory of discrete automaton design has been intensively developed, but the re• duction of its results to the level of engineering practice has come up against two serious ob• stacles. The first is that the practical methods of synthesis developed within the framework of the present theory are too complicated for a large number of engineer-designers. The second obstacle is the arduousness of many of the well-known algorithms for solving practical prob• lems of synthesis: in many cases, the realization of these algorithms entails the performance of millions, and even billions, of elementary computational steps. There thus arises the necessity of automating the synthesis processes, where the effec• tiveness of such automation can be judged by the degree to which the following criteria are met: a) the practical utilization of the developed system for automating synthesis must be suf- ficiently simple: b) the number of problems susceptible of handling by the system must be quite large; c) the system must provide high productivity; d) use of the system must be conducive to the further development of the theory of syn• thesis; e) the system must be sufficiently flexible that it will not be rendered obsolete by further development of synthesis theory but, rather, will be able to be improved on the basis of this development;

• Translated from Logical Language for the Representation of Algorithms for the Synthesis of Relay Devices (editor M. A. Gavrilov), Nauka, Moscow (1966), pp. 7-38. 141 142 A. D. ZAKREVSKII

f) the system must be actually developed over a short period of time, and at relatively low cost. Taking the level of development of modern technology of information-processing into ac• count, we can assert that the best way to satisfy the aforementioned requirements if to base ourselves on the use of general-purpose digital computers (GPDC). To be sure, we should realize that modern GPDC are specialized, in the sense that they are basically designed to operate on numbers. Programming problems of a logical character, to which synthesis problems belong, are accompanied by significantly greater difficulties, and require special knowledge and resourcefulness. It is possible to alleviate this problem by de• veloping a special language for the representation of the algorithms for solving logical prob• lems, such as those involved in synthesizing discrete automata, and by developing, on the basis of this language, a system for the automation of the programming of the problems of interest to us. In this paper, we expound the results of the development of such a language, called the LYaPAS language.* LYaPAS was developed in parallel with the programming program corres• ponding to it. t In its construction, we assumed the following quite explicit goals, although the formulation avowedly lacks precision: a) the algorithms of interest to us must be expressed in LYaPAS compactly and compre• hensibly, in order that these expressions may be published as they stand; b) LYaPAS must make maximum use of the capabilities of modern computational tech• niques; at the same time, it must be independent of the details of programming technique and of the idiosyncracies of specific computers, Le., it must be maximally machine-independent; c) the corresponding software for the specific computers must be quite compact: it must fit completely in the machine's operational memory, providing high-speed interpretation and compilation; d) the capability must be provided of having all programmer and user interfaces with the computer on the level of the LYaPAS language; in particular, program debugging must be re• duced to debugging algorithms, with the debugging results output in LYaPAS.

Types of Words LYaPAS expreSSions are sequences of elements, called words. Each word is a symbol of some well-defined concept: variable, constant, certain actions on variables (represented by neighboring words in the sequence of words), etc. It is precisely this meaningful content in the elements of the language which justifies the use, in this case, of the term "word." Depending on their meaning, words are divided into types: the greater part of the words serve as symbols of operands and operators, while some words play ancillary roles, expressing relative connections of words in LYa PAS sentences, or defining the mode of interpretation of the succeeding symbols. The basic LYaPAS operands are variables, the values of which are represented by 32-bit codes, interpreted, in general, not as numbers, but as subsets of some abstract set of 32 ele• ments. Such variables are the standard ones, and operations with them on modern GPDC are performed quite simply.

·Translator's note: acronyms are not particularly amenable to translation. This one means: logical language for the rep• resentation of synthesis algorithms, the English acronym for which, LOLAFOTROSA, has obviously no future. tTranslator's note: by "programming program," the Russians can mean a compiler, an assembler, an operating system, or any combination of these. The English word "software" is an adequate equivalent in most cases. DESCRIPTION OF THE LYaPAS LANGUAGE 143

The capability is also provided of operating with compound variables, the values of which are given by 32w-bit codes, where w is some integer greater than unity, and also with arrays, which also play the role of operands in the language, an array being a set whose elements are analogous to variables. A special system of subscripting array elements allows one to operate both with arrays as a whole, and with their individual elements. In particular, the subscripts of array elements can be specified by the values of standard variables of a special designation, called indices. In addition to variables, constants, representable by 32-bit codes, can be LYaPAS operands. A special type of constant can be specified directly by LYaPAS words which, in the given case, do not simply play the role of symbols of some 32-bit constant, but provide, in their right part (seven bits), the constant itself, the remaining bits being filled with zeros. Such a method of giving constants (i.e., literals) is particularly convenient if these con• stants are interpreted as integers and are used, in particular, for the serial numeration of program statements.

We shall consider only those ~equences of LYaPAS words which represent algorithms for the solution of certain problems, and we shall call them the L-programs, or simply the prb• grams, for solving these problems.

Two Levels of LYaPAS LYaPAS has two levels. The first level, closer to machine language, is simpler, and is designed for the representation of algorithms which are not too complex; the more compact software corresponds to this level. On this level, ~ can operate directly on those variables whose values are 32-bit codes, Le., on simple variables, subscripts, and individual elements of arrays. For the representation of operations on this level, there is a special collection of standard first-level operators, or l-operators, many of which are close to the elementary operations of general-purpose computers: bitwise disjunction, complementation, shifting, counting the num• ber of ones in a code, etc. Particular roles are played by the operators of assigning to one var• iable the value of another, of incrementing the value of a variable, etc. A small group of opera• tors is used for controlling the order of execution of program steps on the basis of current in• formation. Provision is made for procedures to input initial values of operands and to output results in indexed form, Le., the value of a variable is accompanied in the printout by the sym• bol of the variable. Provision is also made for automatic program debugging (in the LYaPAS language), this facility consisting of the printout of the corresponding process of program execu• tion via the sequence of values of those variables and indices, the set of which is specified by a special code, as well as a printout of a trace of the program's trajectory. A special mechanism built in to the debugging block provides for practical uniformity of output of monitoring informa• tion in all cycles of programs being debugged, independently of the mutual configurations of these cycles. On the second level of LYaPAS, the L-operators are generalized to the cases when they can be used with compound variables (in programming practice, this generalization corresponds to the unification of several memory cells, i.e., to the usual method of handling multiple-preci• sion arithmetic). Many of the first-level operations are also generalized to operate with arrays. New operations are introduced. In the first instance, these new operations include the operations of union, intersection, and subtraction of sets representable by given arrays, the operations of finding the upper and the lower bounds of sets, the operations of identifying, in a given set, the subset of elements possessing some given property, the operation of finding a minimal interval of a set which includes some given set, etc. On the second level, there is also provided a special 144 A. D. ZAKREVSKII mode for realizing operations of the first level. For example, if these operations are two-place operations, operating on arrays, they are performed on all pairs made up of one element from each of the two arrays in question; the resultant array is formed from the set of results after similar pairs have been identified. A particular place among the second-level operators is held by the sorting operators, which are optimal with respect to various concrete situations. As additional examples, we have: an operator for testing a graph for connectivity, an oper• ator for the optimal covering of a given set, an operator for minimizing Boolean functions, and an operator for simplifying systems of logical equations. Second-level operators, called L-operators, are realized by the corresponding subpro• grams, expressed in LYaPAS. These subprograms can contain symbols of other L-operators, constituting a certain hierarchy of operators, expressed, in the final analysis, in first-level LYaPAS. One can include a virtually unlimited number of L-operators in LYaPAS, thus enrich• ing the language during its use.

Automatic Programming System The core of the automatic programming system provided by LYaPAS is the translator, transforming expressions in first-level LYaPAS into machine language. Since first-level LYaPAS is quite simple, the translator fits completely into the computer's operational memory, occupying about 1000 cells, and providing the translator with a speed of about 100 elementary computer operations per symbol of expression to be translated. For each type of computer, the translator assumes a different concrete form, but it can also by well described in more abstract form, by means of the LYaPAS language itself. To a certain extent, the methods of inputting information to the computer, and of outputting the results, are tied to the concrete computer. However, a basic principle adopted for the system for automating programming is its uni• versality, amounting to the following, that all the blocks of the system, apart from the translator (the compiler, the debugging program, the block for building compound variables, the block for optimizing memory utilization, etc.), are expressed in first-level LYaPAS, and can be transferred to machine language at any time by simply being put through the translator. The use of this prin• ciple can significantly reduce the time to create programming programs and to comprehensibly describe these latter. Indeed, any programming program is a program for solving typical non• trivial logical problems, and thus serves as a good test-bed for a language for programming logical problems. For the realization of complicated programs, we have combined interpretation and com• pilation modes. The latter mode is entered, for example, for translating inner program loops into machine language. Combining this with the interpretative mode allows us to avoid over• loading the computer's operational memory. In theory, LYaPAS can be implemented on any computer whose operational memory is not too small. The LYaPAS symbols are coded by 9-bit codes (or three octal digits) and are densely packed in machine memory, thus providing a highly compact representation of the program. LYaPAS is implemented somewhat more conveniently and naturally on single-address computers (which, in general, are more appropriate for programming automation) and on fixed-point com• puters. In fact, any deviation from the normal order of bits is difficult to familiarize oneself with in trying to program logical problems. Outlook and Some Comparisons

It may be hoped that the development and utilization of LYa PAS will open up perspectives of effective solution, not only of practical problems in the theory of discrete automata, but also DESCRIPTION OF THE LYaPAS LANGUAGE 145

of a wide circle of problems, representable in set-theoretical terms, constituting the base of LYaPAS. The application and development of LYaPAS could stimulate the development of syn• thesis theory in a direction which takes account of the possibilities inherent in modern computer technology, while an experimental basis for synthesis theory, built on the basis of LYaPAS, might provide for the application of new approaches in the theory (e.g., experimental-statistical, or comparative-analytic). The reader might have his doubts as to the efficacity of developing this new language at the same time as sufficiently universal languages are already well-known, for example, ALGOL- 60 [1, 2], and are provided with the corresponding systems of automatic programming. We note that more specialized languages, similar to that discussed here, might be significantly more effective just because they are specialized. Thue, the compactness and speed of the first-level L YaP AS programming program are tens of times better than the corresponding characteristics of well-known translators of ALGOL-60. Of those languages known to the author, the closest to LYaPAS in its purpose is that pro• posed by Iverson [3], the experiment with which was studied in the development of LYaPAS. The first variant of LYaPAS was described in [4]. After the introduction of a host of cor• rections plus essential additions, LYaPAS assumed the following form.

§2. Operands

Basic Set

It is legitimate to assume that the language of set theory is, in the final analysis, the most universal language of mathematics, while the language of the theory of finite sets is of great con• venience in handling problems of a logical character and in orienting oneself in the technology of discrete computation. In conjunction with this, it is advantageous to represent all the informa• tion concerning problems to be solved in the form of certain sets, their subsets, etc., while the solution processes themselves for these problems should be interpreted in the language of set theory, these processes being expressed by some sequences of well-defined operations on finite sets which play the role of operands. Turning now to the consideration of certain methods of representing operands, we introduce the bas i c set A of certain abstract elements. the set A of all subsets of set A,

A == {Ao. Alo ...• Ap -1}, where p = 21'-. and the set X of all subsets of set A,

::; -- - p A == {Ao. Alo ...• Aq-d. where q = 2 . Consider the variables ~i' whose values are subsets of set A or elements of set X. It is convenient to interpret these variables as p-dimensional vectors with double indices

0r more simply, and to represent their values by p-bit codes, with the convention that 146 A. D. ZAKREVSKII if the value of variable ~i is just the set Aj c X(eE{O,1, ... ,p-1}). Thus, the notation ~i = 101101 ... 01 is equivalent to the assertion that the value of variable ~i is the ~et {Ao, A2, A3, Afj, ... , A p_ 1} . This method of specifying the values of variables is of obvious convenience when digital computers are used which operate on multi-bit codes, ordinarly interpreted as number codes. By changing the interpretation, one can represent the most diverse objects by these binary codes: numbers, Boolean functions, graphs, etc.

The cardinality, J.1-, of set A can, in general, be chosen quite arbitrarily but, in attempting to make maximally effective use of modern computer technology, one does well to take the quid• dities of computers into account when choosing J.1-. It is thus advantageous to set

21'-

Bearing in mind what we have just said, we choose 5 as the standard value of J.1-; in this case, the values of variables ~i will be the 32-bit codes which fit conveniently into the majority of modern computer memory cells. At the same time, in order to avoid cumbersome illustrations, we shall adopt the conven• tion in this discussion that, from now on, we shall use the value J.1- = 3 (p"" 8). Provision has also been made for using other, nonstandard, values of p, denoting the cor• responding variables by ~t, and assuming that p = 32w, where w is a special dimensionality para• meter, assuming positive integers as its values. If 2 5 ::s k < 26 then, for a convenient representation of the values of a variable ~r, w memory cells are required.

It is also useful to introduce the variables ~ **, equivalent to some set of variables oftypes ~i or 1 ~7; the values of variables ~r* are the corresponding sets of 32-bit codes which can be inter- preted as subsets of X.

Simple and Compound Variables, Arrays, Indices We introduce into the LYaPAS language the symbols for the following concrete types of operands. Simple variables (or, simply, variables) a, b, c, d, e, t, g, h, i, j, k, l, m, n, p, g, 1', 8, t, u, v, w, x, y, ;::, JIf, ,1/" rjJ, m, a, 10, II, playing the role of the basic operands in LYaPAS, belonging to standard type ~i' with their values being represented by 32-bit codes. The dimensionalities of variables can be increased by preceding their symbols by primes, " .. " - meaning that the value of a "primed" variable is represented by a 32w-valued code in some collection of w cells. We agree to call such variables compound variables. Arrays (sets whose elements are represented by the analogous variables) are denoted by A, B, C, D, E, P, G, H,I,J, K,L, M, N,P,Q,R, S, T, U, V, W, X, Y, Z, nt, .'I, W, III, 9, ID, H. Their cardinalities equal Cf.t, CTb , CTc ' ... , respectively ar..d, in general, are variables. Arrays are specified by enumerations of their elements (for example, A ~ {ao, aI, ... , a Oa _ 1), each of which is represented as a simple or compound variable (the dimensionalities of all the elements of one array must coincide). The capability is prOVided of operating both with arrays as a whole, and with their individual elements. The selection of a particular element of an array is made by DESCRITPION OF THE LYaPAS LANGUAGE 147

means of the indices (subscripts) a, b, c, d, e, j, g, h, i, j, k, I, m, n, p, q, r. s, t, U, v, w, x, y, Z, :JIC, Jt, '.P, IU, 3, 10, Jr., whose values are interpreted as ordinal numbers of elements. We adopt the convention of denoting by ab the [bj-th element of array A, where [bJ is an integer whose binary representation coincides with the code of the value of index b (the positional binary code used in modern computers is presupposed here). Also admissible is the notation Ab, i.e., ab'" Ab. The codes of these expressions coincide. Indices can serve as LYaPAS operands on a par with simple variables, but the former cannot have their symbols preceded by primes, and the latter cannot be used for indexing (subscripting) elements of arrays.

Of the variables we have introduced, one is singled out for a special purpose, namely, If, this being used for a random number generator, in the sense that no value can be assigned by programming means to this variable. It is assumed that when variable If, is called, its value will be represented by a random collection of zeros and ones in which the probabilities of 0 and 1 are identical, and in which there is no inter-bit correlation. In addition to the collections of variables and indices already mentioned, there is an ana• logous supplementary collection for use in subprograms, corresponding to L-operators. For the denotation of elements of the supplementary collections, we use the same symbols, a, b, ..• , a, b, ... , but code them differently.

The variables and indices represented by the letters :JIC, Jt, '.P, IU, 3, 10, .11., will have special purposes (basically, in the automatic programming system), so that their use in programming on a par with other variables and indices is not authorized.

Constants As LYaPAS operands, one can also use standard and natural constants. The collection of standard constants consists of the following 32-bit C'odes, each of which has the corresponding 9-bit code as its denotation. Moreover, this collection is set up in the form of four arrays, permitting operations with standard constants as with array elements.

Co -1000 0000 0000 0000 0000 0000 0000 0000 Ci- 0100 0000 0000 0000 0000 0000 0000 0000 C2- 0010 0000 0000 0000 0000 0000 0000 0000

C37- 0000 0000 0000 0000 0000 0000 0000 0001 do-l0to 1010 tol0 1010 1010 1010 10to 1010 di-HOO 1100 HOD 1100 1100 1100 1100 HOO d2 -1111 0000 1111 0000 1111 0000 1111 0000 d3 -1111 H11 0000 0000 1111 1111 0000 0000 d, - 1111 1111 1111 1111 0000 0000 0000 0000 e o - 0101 0101 0101 0101 0101 0101 0101 0101 ei- 0011 0011 0011 0011 0011 0011 0011 0011 e,_ aooo 1111 0000 1111 0000 1111 0000 1111 e3- 0000 0000 1111 11t1 0000 0000 1111 1111 e4- 0000 0000 0000 0000 11H 1111 1111 1111 /0 - 0000 00000 0000 0000 0000 0001 1000 0000 /1- 0000 0000 0000 0000 0000 0001 1100 0000 /2- 0000 0000 0000 0000 0000 0001 1110 0000 /3- 0000 0000 0000 0000 0000 0001 1111 0000 /4-0000 0000 0000 0000 0000 0001 1111 1000 /s - 0000 0000 0000 0000 0000 0001 1111 1100 /6-0000 OOljO 0000 0000 0000 0001 1111 1110 /7- 0000 0000 0000 0000 0000 0001 1111 1111 /10 -1111 1111 1111 1111 1111 1111 1111 1111 /11-1111 1111 1111 1111 1111 1111 1111 1111 148 A. D. ZAKREVSKII

There is a special meaning to the last of the constants, it I' It is represented in any com• puter by ones in all bits of the memory cell, independently of the number of these bits, while all the other constants can have ones only in 32 bits, selected in a very definite way. The con• stants are intended primarily for the system of automatic programming. We also introduce 128 natural constants, specified directly by the program codes (i.e., literals). The symbols for these constants are the corresponding octal digits. Thus,

0-0000 0000 0000 0000 0000 0000 0000 0000 1 - 00000 0000 0000 0000 0000 0000 0000 0001 2 -0000 0000 0000 0000 0000 0000 0000 0010

7 -0000 {l000 0000 0000 0000 0000 0000 0111 10-0000 UOOO 0000 0000 0000 0000 0000 1000

176 - 0000 0000 0000 0000 0000 0000 0111 1110 177 - 0000 0000 0000 0000 0000 0000 0111 1111 Special Arrays As was shown in the enumeration of the standard constants, they are divided into four arrays, C, D, E, and F, belonging to the special arrays A, B, C, D, E, F, G, H, I, J, K, L, M, N, P, Q. The special arrays possess fixed values, certain of which will be discussed in this sec• tion, the rest in the discussion of the automatic programming system. The cardinality of the special arrays is fixed. We define operational array K as that array whose i-th element has its value represented in the i-th cell of the computer's operational memory. With such a definition, the problem of locating information in computer memory reduces to the problem of establishing a definite cor• respondence between the operational array and other arrays and isolated variables representing the information to be processed.

Array A is taken to be the array of the origins of all the arrays, A, B, ... , JI in the opera• tional array, i.e., we adopt the rule that element ao will represent the ordinal number of that ele• ment of the operational array which is identified with element ao, element al is put into the ana• logous correspondence with element b o, etc. Array B is called the array of cardinalities of arrays .4., B, ... , H: the value of bo will be aa, the cardinality of set A, [btl = ab' [b21 = ac, etc. We denote by G the array of variables, set• ting go = a, gl = b, g2 = c, etc. We give analogous definitions to H, the array of indices, to I, the array of supplementary variables, and to J, the array of supplementary indices.

§ 3. First-Level Operators of the LYaPAS Language As has already been mentioned, first-level LYaPAS is basically intended for direct opera• tion only with those variables ~i whose values are given by 32-bit codes, i.e., with simple var• iables, indices, individual elements of arrays, and constants of different types. We now present the standard first-level operators.

Basic Computational Operators V - the disjunction operator,*

~i V ~ j = £Ic -~: V £} = ~~, where t E {O, 1, .... p -1 }. "Translator's note: to read this. and the su bsequent definitions of operations, it helps to realize that the major operation in the definition is symbolized by ~, meaning that the expression on the left (all of it) is defined to be the expression on the right (all of it). Hence, the preceding definition is to be understood as saying that the disjunction of two variables produces a variable each of whose bits is the logical disjunction of the corresponding bits from the original variables. Bit 0 is the leftm ost bit in the word. DESCIUPTION OF THE LYaPAS LANGUAGE 149

Example: 01000110 V 10001100 = 11001110. 1\ - the conjunction operator,

~i 1\ ~j = £k - ~; 1\ £; = ~~.

Example: 010001101\ 10001100 = 00000100. E9 - the exclusive disjunction operator,

~i EB ~j = ~k ~ ~: EB ~} = ~~.

Example: 01000110 E9 10001100 = 11001010.

+ - the operator of addition mod 2 P,

~i + ~j = ~k - [~d + [£j] = [£kl mod 2p. Example: 01000110 + 10001100 = 11010010.

the operator of subtraction mod 2 P,

£i - ~j = ~k ~ [~il - [~j] = [£k] mod 2p Example: 01000110 - 10001100 = 10111010.

x - the operator of multiplication mod 2P,

~i X ~j = £k - [£il· [£jl = [£kl mod 2p. Example: 01000110 x 10001100 = 010010000. X - the operator of multiplication with rounding,

£i X £j = Gk - I£kl = md· [£j] - [Gil· [£j] mod 2p ):2 p . Example: 01000110 X 10001100 = 00100110. : - the division operator.

The expression ;i: ;j = ;k means that the value of variable;k is the remainder upon div• ision of [;d by [; j]. At the same time, when the division operation is performed, the integral part of the quotient is always represented by the value of index S/,. For example, 00001101 :

00000101 = 00000011, while S/, receives the value 000010. In both preceding operations, the value; = 00 ... 0 is not permitted. This must be taken into account in programming. 1 - the componentwise complementation operator,

£il = £k -1: = £~. Example: 01000110 1 = 10111001. I - the order-inversion operator,

Example: 01000110 I. = 01100010. f-- - the operator of finding the ordinal number of the leftmost one,

~if-- = £k- [£kl = tmin for ~: = 1. Example: 00010110 f-- = 00000011. 150 A.D. ZAKREVSKII

In using this operator, it should be borne in mind that 00000000 f- = 10000000 f-- 00000000.* 1<0-- - the normalization operator,

t tt {£:+q, if t+qp, where q = l£; f- J. The action of this operator amounts to a shift of the operand to the left until a one appears in the leftmost bit, if there is a one in the operand to begin with. Example: 00010110 1<0-- = 10110000, 00000000 1<0-- = 00000000. < - the left shift operator,

1 { £: + q, if t + q < p, £i < £j = £k - £k 0, if t + q '> p, where q = [~j J. Example: 01101010 < 00000100 = 101000000

> - the right shift operator,

t l - q Of t '-0 £0 "- £. = £k _ £1 = { 'oi ,1 - q ~ , ./ J k 0, if t-q

Example: 01101010 > 00000101 => 00000011. - the cyclic shift operator,

whereq= [~J. Example: 01101010 -- 00100100 = 10100110. 'V - the weighing operator,

~i 'V = ~k ~ [~kJ is the number of ones in the code of ~i' Example: 0110101 'V = 00000100. V - the mapping operator,

£1 + 2n n { if t = 0, £i £j = £k - = £: _ V £~ 2n: iftn =1, where n = [~j 1 = 0, 1, 2, 3, 4, and t n is the n-th bit from the right of the binary positional code for the number t (if the count begins with 0).

If we consider the 32-bit code, the value of variable ~i, as the unfolding of a five-dimen• sional cube, the action of the mapping operator can then be pictured as the reflection (mirror exchange) of the four-dimensional faces corresponding to the different values of one of the five binary variables specified by operand ~ j 0 Examples: 01001101 Y.. oOOOOOUO = 10001110, 01001101¥ 00000001 = 00010111,

• Translator's note: It might not hurt to recall that ordinal numbers are calculated from the Ie f t of the word, the ordinal number of the leftmost bit being 0, not 1. In the example, for instance, the leftmost one is fourth from the left and, hence, has ordinal number three or, in binary, 00000011. DESCRIPTION OF THE LYaPAS LANGUAGE 151

01001 tol Y 00000010 = 11010100.

When [~.] > log2P, the result of mapping must be 00000000. J

Value-Assignment Operators While the operators already enumerated admit a "static" interpretation, i.e., we can say that they specify some functional relationship subsisting between certain variables, the operators to be discussed now can be interpreted only dynamically, since they rest on the representation of changes of variables in time.

~ - the assignment operator.

~i ~ £j means that the value of variable ~i is assigned to (Le., becomes the new value of) var• iable ~j ; as an example, ~i V £j ~ £k means that the result of the operation £i V £j is ascribed to the variable ~k' etc.

We now introduce the following generalization of operator ~ to the case of exchange of information between groups of variables of type ~ and arrays. By definition,

where the ~i can be symbols of simple variables, indices, or constants, and where the cardinal• ity, aa' of array A at the given moment equals n, is realized (Le., executed) by increasing the value of aa to n + k with the concomitant addition to array A of the elements of ordinal numbers n, n + 1, ... , n + k - 1, these elements assuming the values of variables ~ 10 £2' ... , h, respec• tively. The expression

where the ~i can be symbols only of simple variables or indices, has a meaning just the converse of the former expression: if, at the given moment, the cardinality of array A, aa' equals n, then the variables £ l' £2, ... , ~n assume the values of the elements of array A with ordinal numbers n - k, n - k + 1, ... , n - 1, respectively, while the cardinality of array A is reduced to n - k.

# - the exchange operator.

The expression Si # Si means that the variables £i and ~j exchange their values.

~ - the natural assignment operator.

The expression £i ~'ljJl'IjJ2'IjJ3'IjJ4' where the ~j are arbitrary sumbols of the language (vector constants with nine-bit components), is realized by assigning to variable ~i the value determined by vectors ~j in the following manner:

'IjJ~+4 for 0..;;;;:t<5, £'_ 'IjJ~-5 for 5";;;;:t<14, \ • - 'IjJ~ -14 for 14 < t < 23, 'IjJ~ - 23 for 23";;;;: t < 32 We shall denote by heavy (bold-face) characters those LYaPAS symbols which coincide with their own codes (for example, code 065 is put into correspondence with the symbol 065). Then, for the assignment to variable a of the value 1011 0011 0011 0111 1001 0011 0101 0101, it suffices to execute the operation a ~ 026 315 711 525. *

• Translator's note: this last exam pIe is easier to accept if one realizes that: 1) all the digits are to base 8; and 2) only the five rightmost bits of the first triplet are converted. In the example, the triplet 026 '" 000010110 provides the first five bits of the result, i.e., 10110. 152 A. D. ZAKREVSKII

6. - the operator of positive elementary incrementation,

6. ~; ~ ~j + 1 ... ~;.

Example: If ~j == 10011011, the result of the action of operator 6. on variable ~j is the assump• tion by variable ~j of the value 10011100. 6. - the operator of negative elementary incrementation,

6. ~j~~j-1"'~j.

Example: if ~j == 10011011, the result of the action of operator 6. on variable ~j is the assump• by variable ~j of the value 10011010. o - the operator of assigning value zero.

The result of the action of operator 0 on variable ~j is always to ascribe the value 00000000 to ~j • o - the operator of assigning the maximal value,

O~j~OI"'~j· The result of the action of operator 0 on variable ~j is always to ascribe the value 11111111 to variable ~j.

Dummy Variable T We now turn to a dynamic interpretation of all the operators, since precisely this occurs in using the LYaPAS language. A sequence of symbols of this language, representing an L-pro• gram, reflects some computational process over a period of time during which the operators entering into the program are executed successively. With a standard execution of a program, the operators are executed in the order in which their symbols occur in the program, reading from left to right. The result of the execution of the current operator is represented by the current value of dummy variable T, a symbol which i'S never included in a program. This var• iable plays the role of a left operand (for which, in introducing the operators:we used the sym• bol ~ i), allowing us to increase the compactness of the programs by showing the connectedness of the computational processes. Thus, represents the following sequence of actions:

;i ~ 1:" 00110100 1:"1 ~ 1:" 11001011 T + 1 ~ T 11001100 T I\;j ~ 1:" 00000100 T ~ ; j 00000100.

If the initial value of ~j is 00110100, the series of eight bits on the right show the changes in dummy variable T after each step in the "microprogram" representing the original expression.

A program consists of statements, each labeled by the symbol § accompanied by the or• dinal number of the statement itself, which follows immediately, the ordinal number being rep• resented by the appropriate natural constant. Each statement can contain an arbitrary number of words, and must include just one symbol §, constituting its leftmost symbol. In writing a program on paper, the convention has been adopted of beginning each new statement on a new line. DESCRIPTION OF THE LYaPAS LANGUAGE 153

We have provided for a standard order of execution of operators in time where, after the current operator has been realized, that operator is realized whose symbol follows immediately after the symbol of the current operator. The standard order of operator execution can be vio• lated only by the occurrence of the following operators for controlling the flow of program exe• cution.

Transfer Operators -- the unconditional transfer operator.

The pair of symbols -~j means that immediately after execution of the previous portion of the program, statement number [~j 1 begins.

~ - the operator of conditional transfer on zero. This operator is equivalent to the action of operator - under the following conditions:

a) if operator ~ immediately precedes operators + or - upon whose execution it turns out that [~il + [~jl ~ [~ ± ~ 1, i.e., either [~d + [~jl ~ 2P (for operator +), or [~il < [~jl (for op• erator -), where ~i and ~j are, respectively, the left and the right operands of the operator + or -;

b) if operator ~ does not precede operator + or operator -, and if the last value of var• iable T is 00000000. In all other cases, the standard order of program execution is not disturbed. 1--+ - the operator of conditional transfer on one.

The action of this operator is the opposite of that of operator ~. The following two operators are introduced principally to simplify work with subprograms. We first introduce the concept of the de p t h of program execution, letting the beginning of pro• gram execution correspond to depth zero, and allowing the depth to change only upon occurrences of operators +> and !...... - the exit operator.

The expression +> ~ia, where a is some arbitrary expression in LYaPAS language, means that the depth of the execution must be increased by one, the "coordinates" of expression a must be placed into correspondence with the new value of depth, and stored, after which the program transfers to the execution of statement number [~jl. ! - the return operator. When operator ! occurs at a nonzero depth, there is executed a transfer to the execution of that expreSSion whose "coordinates" had been stored at the current depth. The depth of ex• ecution is then reduced by one. The execution of any program begins at depth zero. The preceding transfer operators are meaningful only when the value of the variable whose symbol follows the operator's symbol coincides with the ordinal number of one of the statements in the L-program. We adopt the convention that this symbol can only be a symbol of a natural constant.

~ - the operator for transfer to machine language.

The pair of symbols ~ ~i signals the transfer to the execution of some program in machine language, the first command of this program being represented by the [~d -th element of the op• erational array. In order to provide for return to the execution of the L-program, starting with the symbol following the symbols ~ ~h the machine language program at issue here should end 154 A. D. ZAKREVSKII

with a command of unconditional transfer of control to the cell of the operational memory re• served for the storage of the value of variable '10.

The symbol ~i can be the symbol either of a variable or of an index. This operator can be useful in those cases when it is efficient to express some computa• tional process directly in machine language. Its use requires familiarity with certain charac• teristics of the automatic programming system (the placement of information in the operational memory, etc.). We adopt the convention that, upon execution of any of the foregoing operators, the value of dummy variable T does not change. The following two operators possess a hybrid character. * the operator of orderly unit extraction,

6; * 6i 6k - 6; 0+- 6j 61f--- ~ 6k C Sk EB Sf ~ Si' Operand ~k can only be an index. Execution of operator * is accompanied by the assign• ment to dummy variable T of the new value of this index. Example: let the initial value of ~i = 01011010, with the value of index ~ k being arbitrary. Then, after execution of the operation 6i*Si6k variable ~i assumes the value 00011010, while index ~k assumes the value 00000001. If the initial value of variable ~i were 00000000, execution of statement [~jl immediately begins.* .l€ - the operator of random unit extraction. This operator differs from the p receding one only in that the selection of the next one-bit in the code of variable ~i is made "at random," with each one-bit having equal probability of being chosen.

For both operators, '* and ~,the left operand must be given by the symbol immediately before the operator's symbol (for example, it is impossible to use an expression of the type a + b*5c, if one wishes to have the value of the sum a + b) operated upon). Immediately after the operators '* and *, as after the previously considered operators -+, 1-+,0+- and ..... , there can be only the symbol of a natural constant.

• Translator's note: The author's discussion of the opera tor of orderly unit extraction probably. could stand elaboration. The gist of the operation is that the leftmost one in the operand preceding the operator is changed to a zero, but not before its ordinal number is made the value of the index whose symbol is second on the right of the operator symbol. If the operand preceding the operator were initially all zeros, control is transferred to the statement whose ordinal number is given by the contents of the variable whose symbol is on the right of the operator *. As for the strict definition of the operator in LYaPAS symbols. as given above, a few words of explanation might not be amiss. Recall that the expression to the right of the ~ is the "meaning" of the operator. Recall further that the LY aPAS expression is scanned from left to right with the conventions usual for Polish strings. Following this scan, we see:

l. {iO+-{j (if {i is all zeros go to [{ j], else continue)

2. {jf--- (find the ordinal number of the leftmost one in {i' This becomes the value of dummy variable T .)

(The value of dummy variable T is ascribed to index {k)

(Index {k is used to access mas k C {k' i.e., the proper single-one word is fetched from array C, the first of the fout standard arrays shown earlier. As the left operand of the "exclusive or" operator, this mask strips the proper one-bit from variable g i' leaving the result in dummy variable T.)

(Variable {i is assigned the value of dummy variable T, i.e., the new g i is the 'Jriginal g i minus its leftmost one.)

In following the examples of LY aPAS programming later in this paper, a consoling thought to keep in mind is that this type of pare11lhesis-free notation is easy for a compiler or interpreter to read. DESCRIPTION OF THE LYaPAS LANGUAGE 155

The operators and symbols next to be introduced are supplementary ones, designed prin• cipally for use in the automatic programming system, all of whose blocks, aside from the trans• lator, must be expressed in terms of LYaPAS itself.

Operators for Exchanging Information with External Media The following operators play an ancillary role, providing chiefly for the exchange of in• formation between the memory of the computer realizing the algorithm and external media. * - the operator for printing an element. Execution of operator * amounts to outputting the current value of dummy variable T on the printer. Taking into account the idiosyncrasies of modern computers, we require that the value of T be given in octaLt : - the operator for punching an element.

This operator causes the current value of T to be punched out. It is of some convenience, for example, in those cases when the information put out during execution of some algorithm is destined for subsequent input into the computer again. In the one case when operator * or operator ~ immediately follows the symbol of an array (for example, a case such as A *), the printer or punch successively receives the values of all the elements of the array. t - the input operator. The information to be processed by the computer is prepared in the form of a sequence of constants, partitioned into records. At the head of each record is a statement of its size, as well as the ordinal number of some element of the computer's operational ~.rray. When opera• tor t is executed, the next record is input to the computer, meaning that the constants in it are entered in the order of their appearance, becoming the values of that portion of the operational array which begins with the element noted in the recodrd header and which has the cardinality specified in that same header. In addition to the operational array, corresponding to the computer's operational memory, we bring in an external array, corresponding to a supplementary, external, computer memory. Exchange of information between these two arrays can be performed by the use of the following two operators. /' - operator of block transfer to external array.

The expression /' 6i6j6k means that [~.J bits of successive elements of the operational ar• ray, starting with the element whose ordinal number is [~d, are transmitted to the [~jJ bits of the external array starting with the element whose ordinal number is [~kJ. II' - the operator of block transfer from external array.

This operator transfers information in the direction the reverse of the previous one: [~j] elements of the external array, starting with element number [~k]' are transmitted to the cor• responding series of elements of the operational array, starting with element number [~d.

Other Operators . - operator for algorithm termination.

tTranslator's note: perhaps no rem inder is needed that the author is referring to modern R us s ian computers here. as everywhere else in this paper. 156 A. D. ZAKREVSKII

The symbol" . " plays a dual role: on the one hand, it serves as a signal that the algor• ithm is ended (the execution of the algorithm is halted when this symbol is encountered) and, on the other hand, the symbol" ". " is a signal to the reader (or writer) that the expression for the algorithm is at an end. The following operator is, to a certain extent, beyond the scope of our original construct, and is introduced to make possible a more complete utilization of computer memory, specifically, of computer memories in which the cells have more than 32 bits, as well as complete utilization of the computer's input and output channel capacities.

~ - the unbounded shift operator.

The expression ~! t= 6i can be interpreted as follows: the contents of the cell in which the value of variable gi is stored are shifted by q = [gjJ mod 26 - 2 5 bits, with a positive value of q corresponding to a shift to the left, a negative value to a right shift, bits shifted out being re• placed by zeros.

Syntax of First-Level LYaPAS A program expressed in first-level LYaPAS consists of a string composed of the symbols considered up to this point. However, not every string of these symbols is an L-program, but only those which satisfy the set of conditions which constitute the syntax of first-level LYaPAS. To be sure, not everyone of these admissible strings can be considered as a reasonable program. For example, a string may clearly contain redundancy, allowing some part of the string to be deleted without changing the sense of the program. Nonetheless, any string satisfy• ing the syntax rules to be introduced now is called an L-program, and must be univocally con• verted by the translator from first-level LYaPAS to the language of the computer in Etuestion. We can therefore say that the given syntax specifies the domain of definition of the translator function. We specify

;tl E \a, b, •.. , n}, ;t2E {a, b, ... , Ji}, naE{O,1, .•. , 177},

n, E {co' c" ... , Ca7' do, db ...• d4 , eo' e" ..• , e" /0' It, ... , /ll}, noE {A, B, ... , a. A, B • ...• Q}, neE {A, B, ... , a, A, B, G, H, ... , Q}, n7E {A, B • ... , a}, PI E {f-, 1<-. I, I, 'V}, P2E {+, -, V, 1\, EB,~, X, x. >, <, <-, V, :}, Pa E { ~, (», I~, -- }, p,E {O, 0, l:::" l:::,}.

We shall assume that, if fJ E {fJ" fJ2' ... , fJm} and ~ E gl' ~2' ...• ~n} , then t]~ E {fJI~" fJI~2 •... , fJI~n' fJ2~" fJ2~2' ... , fJ2~n, ... , fJm~I' fJm~2' ... , fJm~n}. We further specify that

;tl E {;t1l ;t2 }, n 2 E {:rt2' :rta}, ;taE {:rtl! :rt2, :rta, :rt,}, ;t'E {;tl' :rt2, :rt6;t2}, nE{:rta,:rt.;t2}. DESCIUPTION OF THE LYaPAS LANGUAGE 157

We give the name "a-string" to any finite sequence of elements in set 0':

atE {n, PI' P2n, Pana, p,n', *,:, ~n', ~ n I, n5., n5: ' t, I' nlnInt, ~ nlnlnl, n 7 ~ (n lnl ... nI), (n8n8... n3) ~ n7, n 4 * nan2' n' }€ nSn2' n' ~ 'iJ'iJ"'", n 4 # n' , !, § ns}, assuming that \)i is an arbitrary simple symbol (i.e., a symbol which is coded by one 9-bit byte).

The symbols §7T 3 partition an 0'-string into statements whose ordinal numbers are the values of symbol 1T3' the ordinal number of a statement being given at the very beginning of the state• ment, immediately after the initial symbol §. An a-string which is terminated by a " . " and which satisfies the following conditions is called an L-program. The statement numbers must not repeat, and must constitute such a set, N, of numbers that the condition nsE N must be met for all substrings P31T3' 1\:nanz and ~nsnz occurring in the given a-string. Suppose we construct a directed graph whose vertices are the statements of a program, and whose arcs are the possible transfers due to operators P3' 1\:, and * , or transfers due to the normal order of statement succession (in case the previous statement was not terminated by a symbol- 1T3 or I). Arcs corresponding to transfers by operator""" , and vertices corres• ponding to the matching statements, are marked by terminal symbol!. In the graph thus obtained, there must not exist any loops containing marked arcs (i.e., recursion is not permitted). In a graph obtained from an initial one by discarding marked arcs, there must not be paths leading from the vertex corresponding to the initial statement (this ver• tex must not be marked) to any of the marked vertices.

Let us now render precise the order of determining current values of dummy variable T. We stipulate that T retains its previous value upon execution of the operations *, *,* as well as upon entry to a new statement marked by the flag §1T3' Upon execution of operation n4#n4 T receives the value of the right operand while, upon execution of operation n4~1jJ1jJ'iJ'iJ T receives the new value of 1T4. Upon execution of the operations n5 *, n5:, t, I'nInl1[X, ~ 1[11[11[1, n7 ~ (nl1[I ... 1[l),

Symbol?

In order to make it possible to keep track of utilization of the operational array during program execution, we have introduced the special symbol "?". When it occurs after the com• bination 1T77r2' where n7 E {A, B, ... , H} and .1t2 E {a, b, ... , JI.}, this serves as the signal for array 1T7 to be checked for possible "overlap" on other operands in the operational array and, if such there be, they are expunged. The combination B1Ts ??, where n8 E {O, 1, ... , 37},is a signal to find space in the operational array for the array whose ordinal number is given by the value of 1T S. Execution of these two operations is assigned to the corresponding block of the program• ming system. In clarifying our description of first-level LYaPAS syntax, we note that symbol strings satisfying it could be braodened by replacing 1T71T2 by 1T71T2 ?, and B1Ts by B1Ts ?? However, re• peated replacements of this type, leading, for example to a combination of the form 1T71T2 ??, is inadmissible. 158 A. D. ZAKREVSKII

§ 4. Examples of First-Level L-Programs

Use of the Matrix of Binary Relationships for Algorithm Description To describe the formulation of some problem, as well as the algorithm for its solution, we have decided to use the Latin alphabet, as well as some of the other symbols used in LYaPAS, but with other meanings. To align this description with the corresponding L-program, we have arranged to use the C matrices of binary relationships between elements of two sets, A == {a 0, ai' ... , an-I} and B == {bo, bl , •.• , bm _. I }, defining these C matrices as follows: C = II A -< BII means that c{ = 1 if a. -< bit where -< is the symbol of some binary relationship, and c{ = 0 otherwise. In many cases, it is more convenient to begin the numberation of elements of the sets in questinn with unity, i.e., to set A == {a I' a2' ... , an} and B == {bl , b2, ••• , bm }. We shall denote by II {A} -< B II the one-row matrix of the binary relationship -< between the sole element, A, of set {A} and the elements of set B. By definition, the expression A::IIA-

Obtaining the Coordinates of the Ones in Code a

§Oa1Hb*~O § 1 ... * The result of executing this program is a sequence of codes specifying the positions of ones in code a. For example, if the initial value of variable a were 00110101, the resulting sequence would have the form:

00000010, 00000011, 00000101, 00000111.

Finding the Lower Bound of a Set

Let B C A, where A is some set. The lower bound of set B is what we call its subset consisting of those elements bi E B. for which it is impossible to find bj E B, such that bj C bi' Here is one possible variant of the program to obtain the lower bound of set B, assuming that B: : ii B =:3 A II.

§ 0 0 b § 1 6bEBb,c»4ca § 2 6, a EB b1 c» 3aS b c» 2b b 1/\ ba c» 1 ~ 2 § 3 bb * -> 1 § 4 . DESCRIPTION OF THE LYaPAS LANGUAGE 159

For example, as the result of applying this program to the array

10110010, 01000010, 01101101, 01100001, 10111011 , 1O()01100, 11110101, O()OOlOoo we get the array

10110010, 0100001 lJ , 01100001, 0(;001000

The Quine Simplification By the Quine simplification, we mean the algorithm, due to Quine, for determining a re• duced set B C A this being one of the steps in minimizing a Boolean function in the class of disjunctive normal forms. The Quine simplification amounts to obtaining a subset of set B such that its elements are not absorbed by the core, C, of set B, i.e., the set of essential elements of set B, or else elements which are themselves in the core. With this, an element hi E B is said to be an essential element of set B if it contains some element, aj' of set A which is not contained in any other element of set B. It is also presumed that an element bi E B is absorbed by set B j C B, if bi C B~, where Bj is the union of all the elements of set Bj. We now adduce the program for the Quine simplification, in which

B:: II B:3A II, and the values of variables b, c, d, and e are defined during process realization in the following way: b : : Ii{ B* } :3 A II, e : : II { B** } 3 A II, where B** is the set of those elements of A each of which enters into no more than two elements of B,

d:: II {B* '" B** } :3 A II , e :: II {c*}:3 A II . § 0 oaObOe § 1 /::.. a EJj b, 0+- 2b /\ ba V e =? eba Vb=? b -> 1 § 2 ci!\b=?doaoe § 3 /::.. a E8 b, 0+- 4 ba !\ do+- 3ba V e =? e ~ 3 § 4 di!\e=?/oa § 5 /::..aEJjb,0+-6/i!\ba 0+-5ba *-.,.5 § 6 .

§ 5. Operations in Compound Variables

We now introduce four independent dimensionality parameters, w1' w2' W3. and W4' the values of which. specified by the indices :He, A, rfi. and Ut , can be natural numbers. The variables and elements of arrays whose dimensionality will be defined by these parameters will be marked by the (prefixed) symbols P, '"". N"'. "'''''''. respectively. We stipulate that the dimensions of ele• ments belonging to one and the same array must coincide. We permit changes in the values of the indices :He, A, rfi and UJ, within reasonable limits during execution of L-programs. 160 A.D. ZAKREVSKII

We define the operations on variable s with extended dimensionality, or compound variables, as generalizations of the operations already considered on variables of the type ~i' with the re• placement of p = 32 by p = 32w, where 00 E {WI' 002, 003, W4}' Among the operators to which this generalization applies are the one-place operators I, \7) 1-, f--, 6" 6" 0, 0, I and the two-place operators +, -, V, 1\, EB, <, >, -, y. We insist that the right operand of operators <, >, _ and y can only be an operand of type ~i (for which p = 32), and that the left operand of operator y can be a compound variable only in case the dimensionality parameter w has the value 2 n, where n is a natural number. The interpretation of the right operand of operator y is extended: [~j] = 0, 1, 2, 3, 4, 5, 6, .... We permit the operators +. -, V, 1\ and ffi to act on operands of different dimensionalities, i.e., we permit, for example, the operation

a + 'b, 'Ci EB' d etc. Prior to the execution of such operations, the dimensionalities of the operands are equal• ized by adding zeros to the right of the operand with the lower dimensionality. In trying to simplify the automatic programming system, we have proscribed extending operators x, x: and t: to compound variables.

The convention has been established that the dimensionality of dummy variable T is de• fined by the dimensionality of the operands processed during execution of the L-program. How• ever, in order not to complicate unduly the programming program, we have to insist that values of T passed along via transfer operators, and in changes of program statements, can only be of standard dimensions.

Upon execution of an operation 'a=,;>b b our convention is that b assumes the value specified by the leftmost components of compound variable 'a.

We allow the use of expressions of the type (a" b' C if) =';> C, during the execution of which there is performed "packing" (or "unpacking") of the operands of different dimensions in array C.

A compound variable can be the left operand of the operators 1\: and '€ (but never one of their right operands).

Conditional transfers via operators 0+, 1->-, 1\: and * , with action on compound variables, are defined analogously to the case of variables of type ~i . A formal extension of the array C of constants is made by saying that, in the case

32

Finally, we adopt the convention that expression of the type 'a* or II~ represent the out• putting of the values of the corresponding compound variables on the printer or the punch. Recall that the symbols", .... , ...... , and ...... can be placed only before symbols of variables a, b, ... or symbols of array elements, but never before indices, which can not be "compounded. II

§ 6. Hierarchical Programming

The General Idea Complicated computational processes can ordinarily be partitioned into "blocks" which are independently meaningful, and which can be put into correspondence with certain operators. The DESCRIPTION OF THE LYaPAS LANGUAGE 161

introduction of these operators into the language, together with the corresponding programs, allows the effectiveness of the language thus enriched to be increased, since an ever greater portion of the programming work is performed automatically. The representation of the com• putational processes themselves is improved, with the compactness of the programs being in• creased, as well as their comprehensibility, while their writing is accelerated and their de• bugging is facilitated. This general idea can be, and is,realized in the LYaPAS language.

Problem of Seeking a Quine Covering Let us consider the concrete example of finding a covering of a Quine table. In its general form, this problem can be formulated as follows. We are given a Boolean matrix U, with the ui E {D, 1},. and we have singled out some subset, b, of its rows uj and some subset, c, of its columns u J, and we are required to find a subset d C b of its rows such that it will, in its total• ity, cover all the columns occurring in c, i.e., such that, for each ui E c we can find such Ui E d, that u! = 1. With this, it is desirable that the covering be "cheap," that, for example, it 1 contain as few elements as possible. Let us consider here a very simple approximate algorithm for solving this problem, in order to use it as an illustration of the method of partitioning algorithms. We denote by Uxy the minor of matrix U formed by the elements at the intersections of the rows comprising set x and the columns comprising set y. We shall call a minimal row (or column) of the minor a row (or column) which contains the minimal number of ones. We define analogously maximal row and column. If there are several such rows or columns, we choose anyone of them, the first for example. The algorithm amounts to choosi.ng a minimal column, ej. of minor Ubc, and in finding a maximal row, 11> in minor Ub'c, where b' is the set of rows having unit elements at the intersection with column el' After this, minor Ubc is replaced by minor Ubjcj, where bt = b " {It} and Ct = c" c' where c' is the set of columns having unit ele• ments at the intersections with row fj' We then take the minimal column, e2, in Ub jc1> etc., until the set of columns, ci> at some i-th step turns out to be vacuous. The set of rows thus found constitutes the solution

L-Operators

It is obvious that the basic portions of the algorithm just described can be represented in the form of two operators, each independently meaningful. We shall call such operators L• ope rat 0 r s (in contradistinction to first-level operators, called 1- 0 per at 0 r s ), while we call the programs in which they occur ext ern alp r 0 g ram s (in contradistinction to in t ern a 1 pro g ram s, or sub pro g ram s, necessary for the realization of the L-operators them• selves). The L-operators we introduce will each be assigned its own name, and the arbitrary contractions of these names, written in italics, will serve as the symbols of these operators when they are utilized in external programs. After the symbol of an L-operator there must follow, in a prescribed order, the symbols of its operands, terminated by the symbol#'. For example, we can represent the foregoing operation of finding a minimal column of a minor by the expression

minsto Ubcd II. where min s t 0* is the operator for finding a minimal column of minor Ubc, and U,h,c, and d are the operands subject to its action.

-Translator's note: The contractions for the L-operators in this article are, of course, the contractions of the corresponding Russian names. Where the English user would have presumably entitled the present operator mincol, the Russian uses the first three letters of the corresponding two words, "minimal' nyi stobets." 162 A. D. ZAKREVSKII

The array U represents matrix U (Le., the rows of the matrix are the elements of the array), while band c are the variables defining sets band c of the rows and columns of matrix U form• ing the minor Ubc: b:: II {b};3B II ,c:: II {c}03C II. where Band C are the complete sets of rows and columns of matrix U. The minimal column of the minor, once found, is represented by the value of variable d:

d :: II {b'} 3 B II • where b' is the set of rows of the minor having unit elements at the intersections with the column found.

We define analogously the operator m a k s t r 0 for finding the maximal row of the minor, while the expression

• makstro Ubcd /1 denotes the operation of applying the given operator to minor Ubc, represented the same way as in the example in question. In the given case, the value of index d will represent the ordinal number of the maximal row found for minor Ubc. By using both these operators, we can compactly express the algorithm described for ob• taining a covering of a Quine table. sOon § 1 millsto Ubcdll makstro Udcbll Cb V n =? n 1/\ b =? bUb 1/\ c =? c 1--> 1.

The result of using this algorithm is an enumeration of the rows of the minor forming the desired covering, represented by the final value of variable n.

Subprograms and Their Formation

In their turn, the L-operators min s to and m a k s t r 0 must be represented by certain SUbprograms. Let us consider how these are formed. We say that the variables and indices used in subprograms are divided into internal and external. As a rule, the external operands of a subprogram are the operands of the L-operator corresponding to the subprogram. The remaining variables and indices necessary for the exec• ution of the computational process are internal for the program in question.

For example, the operation m a k s t r 0 Udcb II may be realized by the following sub• program:

§ 0 Ob 0 C § 1 d * 2a U" /\ c v - C od -+- C =? ca =? b --> 1 § 2 .

In this program, the external operands are U, d, c, and b, while the internal operands are a and c. For the formation of subprograms, the following conventions apply:

a) the statements are numbered in order, starting with 1. The initial statement, if there are no transfers to it within the given program, is not numbered; DESCRIPTION OF THE LYaPAS LANGUAGE 163

b) the symbols of the external operands are replaced everywhere in the subprogram by the symbols a,~, y, 6, £, ~, 1], 'fr, x, A, ft, v, S, :t, p, a in strict correspondence with the loci of the operands in the list accompanying the symbol of the given L-operator (for example, in the sub• program the symbol 'Y replaces the symbol for the external operand occupying the third place in the list); c) the arrays used in a subprogram (except the special ones) are, for convenience, con• sidered to be external operands (this convention allows the automatic programming system to be simplified). In our present example, the subprogram will have the following form:

ObOc § 1 ~ 1\: 2a eta 1\ r V - c 0+ 1 + c =? ca =? 6 -'> 1 § 2.

Supplementary Set of Variables and Indices In order to facilitate second-level programming, we introduce a supplementary set of var• iables and indices, using the same symbols as before for their notation. It is necessary with this to remember that the meaning of symbols will be determined by their position, with identical symbols being interpreted or coded differently depending on whether they occur in a subprogram or in an external program. We adopt the convention that all the variables and indices which are internal operands of subprograms will be chosen only from these sets (with the exception of the variable R). Thus, we avoid the danger of conflicts of variables and indices in subprograms and external programs. The programmer, in writing an external program, need pay attention only to the external operands of those subprograms corresponding to the L-operators used by him, without giving any heed to the makeup of their internal operands.

Extended Concept of External Operand Taking into account the idiosyncracies of the compiling method used by us, we allow, as elements of an L-operator's operand list, the symbols, in particular, of variables, indices, con• stants, arrays, and individual elements of arrays. We permit priming of variables and arrays, i.e., the placing of a prime ( , ) before the corresponding symbol. The formal substitution at compile time of the elements of the list in place of the symbols a, {3, ..• permits the concept of a subprogram's external operands to be broadened. For ex• ample, as external operands of subprograms one may use l-operators, and even entire expres• sions in the LYaPAS language. If a list element consists of more than one symbol, it is called composite, and included within parentheses. Only primed variables and arrays are excluded from this. For example, we admit an expression of the type

operator 5'A+(bq )"a'm(a+b=9c)//.

In using composite list elements, it should be remembered that, upon their being substituted in place of the symbols a, {3, ••• , the parentheses enclosing them are discarded. More detailed information on the possibilities of formal substitution of list elements can be obtained in the compiler description in [5].

"Priming" of Variables

It is necessary to return to the question of "priming" variables. Obviously, the dimension• ality of internal operands depends on the dimenSionality of the external ones, so that "priming" of the latter must be accompanied by "priming" of definite internal variables. Our convention is to represent the information necessary for implementing such priming by listing the con- 164 A. D. ZAKREVSKII nections subsisting between the external and internal operands. For example, (ab d m) means that, if external operand a is primed, then priming of the same type must be applied to inter• nal variables b, d, and m, the dimensions of which, consequently, must all coincide.

Subprogram Headers The translation of a second-level LYaPAS expression into first-level language must be performed by a special program, called a compiler. To facilitate compiler operation, sub• programs for L-operators are given headers containing certain characteristics of the subpro• grams. The first symbol of a header gives the number (code) of the L-operator; the second gives the size of the subprogram, expressed by the total number of symbols in the subprogram, while the third header element is the number of numbered statements in the subprogram. These three numbers are printed in semiheavy digits. This means that they coincide with their own codes. After these digits follows the information, in the prescribed form, necessary for implementing priming, then the subprogram itself. For example, the header

53 116 5 (~a) (y cd) belongs to the subprogram for the operator with ordinal number 53. This subprogram contains 116 symbols, and has five numbered statements, with ordinal numbers 1, 2, 3, 4, and 5. When or if external operand f3 is primed, the compiler must provide the analogous priming of variable a and, for priming of y, analogous priming of c and d. For example, if "m occupies the third place in the operand list of the L-operator in question, the compiler must then precede the sym• boIs cand d in the compiled subprogram by " everywhere these symbols occur.

Multiterminal L-operators

The L-operator m a k s t r 0, considered earlier, belongs to the type of two-terminal oper• ators, possessing one input and one output terminal. It is advantageous to consider the more general case of multiterminal L-operators. We adopt the following conventions. We agree that the basic output terminal of an L-operator corresponds to the end of the sub• program. As for additional output terminals, we agree to represent them in the corresponding subprogram by symbols of transfers *, *. --' ...... , ~, 1---"' after which we place symbols of ex• ternal operands (a, f3, ... ) having, in this case, a doubly special meaning. In writing the external program, it suffices to substitute, in the place of such a symbol, accompanying an L-operator symbol, the ordinal number of one of the statements of the external program, in order to make the corresponding terminal of the L-operator occur at this statement. The basic input terminal corresponds to the beginning of the subprogram. If an L-operator has supplementary input terminals, they must necessarily correspond to the beginnings of some statements of the subprogram, and the connections with them are repesented in the external pro• gram by means of the same transfer operators where, following the symbols of these transfer operators, there should be the L-operator symbol and the ordinal number of the corresponding subprogram statement, represented by a natural constant.

Subprogram Characteristics A complicated program may have a many-layered hierarchical structure, composed of L• operators, many of which may again be expressed in terms of L-operators. The order of form• ation of the subprograms of such L-operators has its own idiosyncratic features. DESCRIPTION OF THE LYaPAS LANGUAGE 165

Since the internal variables and indices of these subprograms are chosen from the same collection as the variables and indices of the subprograms of the subordinate L-operators, it is necessary that the relevant information be carefully matched. In connection with this, we estab• lish the following rules. In forming each subprogram, it is necessary to make economical use of its internal var• iables and indices, employing them in alphabetic order and noting the last one of them. In set• ting up subprograms containing L-operators, it is necessary to take into account which variables and indices have already been used in the subprograms corresponding to these L-operators. The information necessary for the programmer is contained in the subprogram character• istics in the following order: a) the symbol of the L-operator realized by the given subprogram; b) the list of the ordinal numbers of the L-operators used in the subprogram, in the order of their appearance in the subprogram; c) a list of the external operands, with an indication of the type of each operand n is a variable, II is an index, }{ is an array, q is a number, 0 is an operator, and B is an expres• sion),* with those operands marked by a + whose values do not change during execution of the subprogram, and those operand-arrays marked by ? or ?? whose symbols occur in the subpro• gram accompanied by? or ?? ; d) the last (alphabetically) of the variables and indices used in the subprogram; e) a list of the subsets of external operands whose elements can be identified (for example, tlle presence in this list of the expression af3 means that, in the places occupied in the subpro• gram by the symbols a and (3, one can substitute one and the same symbol of some concrete operand); f) a list of subsets of external operands including operands whose dimensions in the given subprogram must coincide everywhere. These lists are blocked off by the symbol/fore and aft, the list elements are separated by commas, and the elements of the list in b) and f) are included within parentheses. For example, the characteristics of the subprogram realizing some arbitrary L-operator, oper,

oper (5, 7,3,) /0( q, ~o, y}{ + , {) II, e \,?, ~II/d,e/{)~ / (ye) ({)~) indicates, in particular, that in the subprogram the L-operators with ordinal numbers 5, 7, and 3, in that order, are used, that for operand a some natural number, given by a natural constant, is used, that the value of the array denoted by operand 'Y does not change during execution of the subprogram, that the symbols of the array denoted by operand £- occur in the subprogram accompanied by symbol? , indicating monitoring of the increase of this array during program execution, that the symbol of one and the same operand can be used in the place of symbols 0 and ~, that the dimensionalities of operands 'Y and £- must coincide, etc. If some operand of the external ones had been marked by a + and, simultaneously, an in• dication had been given that this operand can be identified with some operand, it should then be taken into account that, with this identification, the + sign loses its meaning.

"Translator's note: as with the contractions for the L-operators, Russian-language notations is used to deSignate the various operand types except that here we retain the original Cyrillic letters. Each of these letters is the initial letter of the cor• responding Russian word. 166 A.D. ZAKREVSKII

Some Recommendations Re garding Second-Level Programming We now turn to certain facets of automatic compilation which should be borne in mind when doing second-level programming. As we saw, two ways of referencing L-operators are possible. The first of these, called the direct form, corresponds to a call of the subprogram's basic input terminal, including an enumeration of the operands. The second, the indirect form, corresponds to a call to a supple• mentary input terminal of the subprogram, and contains only the code of this program and the ordinal number of the terminal in question. The gist of the compilation, accompanying a left-to-right scan of the external program, is as follows. Each time a direct reference to an L-operator occurs, the subprogram of this L• operator is inserted in the first-level program being synthesized, subsequent to the necessary "adjustment" of the given operand list. When an indirect reference occurs, the actions of the compiler are limited to incorporating the programmer-planned transfer in the external program to one of the subprogram's supplementary terminals, the set of operands for which is not changed in the process. If several direct references to one and the same L-operator are made in the external pro• gram, the compiled first-level program will contain the same number of copies of the subpro• gram for this operator, the copies differing from one another by at most the different sets of external operands to which they are "adjusted." Therefore, if the size of the subprogram of some L-operator is quite large, it is recom• mended to use a direct reference to this operator only once, doing the "adjusting" of the operands in the external program, and writing a supplementary statement at whose beginning the direct reference is placed. This route should also be taken in the case when an L-operator has several input termin• als. As a matter of fact, after analyzing an indirect reference to some L-operator, the compiler will program a transfer to the input terminal of the first (in the compiled program) subprogram of the L-operator cited in the indirect reference. Therefore, if some subprogram with several input terminals (entry points) occurs several times in the external program, all the transfers to the supplementary entry points of this subprogram will be locked up by the first occurrence of this subprogram.

Increasing the Efficiency of Using Specific Computers Certain computers are endowed with special devices (parameter registers, cycle counters, etc.) permitting the implementation of complex computational processes on the level of the machine's elementary operations. Taking account of these concrete features permits one to in• crease the effiCiency of computer usage. On the other hand, the inclusion in a developing higher• level language of a set of operators allowing these individual features to be taken into account is undesirable, since this leads, in the first instance, to greater complexity of the language and requires, in the second place, a knowledge of the particular computer and, in the final analysis, its programming. Therefore, the LYaPAS language is given an abstract form so that it can be used for prac• tically any general-purpose computer. The problem of increasing efficiency of usage with spe• cific computers is solved in the following way. The direct connection with machine language is made exclusively by the translator, which must also take into account the idiosyncracies of the given computer in putting the operational program together. In order to facilitate the translator's solution of this problem, we have pro• vided the facility of a certain extension of LYaPAS by introducing additional operators specific DESCRIPTION OF THE LYaPAS LANGUAGE 167

to the given computer and the given translator. The system of "computer plus translator" can be characterized as a whole by the set of costs of the operators of the extended language, where the cost of an operator might, for example, be the number of machine cycles necessary for its execution. The problem then arises of equivalent transformations of an L-program directed towards lowering the total cost of its execution. This problem can be solved by a special opti• mizer, transforming L-programs, expressed in the abstract language described here, to forms which are optimal for the various specific computers. It would seem particularly effective to optimize subprograms, described in abstract form but then optimized upon their inclusion in the set of subprograms stored in the memory of some specific computer. Since subprogram optimization has a one-shot character, it can be performed quite care• fully, while the subsequent use of already optimized subprograms does not require any additional expenditure of time. The optimizer is expressed in abstract LYaPAS and, therefore, can work on any computer, as can all the blocks of the automatic programming system apart from the translator. If some program or subprogram has not gone through the optimization step, it must be un• conditionally accepted by the other blocks of the automatic programming system. The differ• ence will only be that the program execution will (in general) take more machine time. The programmer can perform some of the optimizer functions if he wishes to increase the speed of program execution and if automatic optimization is not available. For example, if some computer has a unique register for automatic address-modification of commands then, in putting the working program together, the translators associate this register with index "a." Therefore, one can recommend using index" a" for the inner loops of the program.

§ 7. Simplest Operations on Arrays As has been mentioned, the further development of the LYaPAS language is along the line of broadening the collection of second-level operators, or L-operators. We now consider a series of quite simple L-operators, together with their associated subprograms, allowing us to extend, in definite ways, various first-level operators to arrays. The subprograms presented here can serve as the simplest examples of programming concrete problems.

Elimination of Duplicates Suppose a represents an array in which certain elements may be equal to one another. Operator pripodob eliminates duplicates, i.e., leaves just one element of each type (different types, in this case, will then differ by their elements), and forms from these different elements array [3.

1 pripodob em +, ~K/-, ellX~/ (IX~) 40 65 4 oboe § 1 6. b tB b~ 0> 4 6 a § 2 ~ a E8 e 0> 3~a EP ::J.b 0> 1 -'> 2 § 3 IXb =? ~c 6. e -'> 1 § 4 e=?b~.

Obtaining a Lower Bound

We say that variable a absorbs variable b if, for any iE{0,1, ... ,p-1}ai~biis valid where+• is the implication symbol, and if a ,c b. We give the name of lower bound of an array to the 168 A. D. ZAKREVSKII collection of those of its elements which do not absorb any other elements of this same array. The obtaining of the lower bound of array 0', if it does not contain equal elements, is realized by operator n i g r a, providing a representation of this bound by array {S.

nigra +, ~I\ / -, C I IX~/ (IX~) 41 74 4 o b 0 C § 1 6, b EB b", 0+ 4 0 a § 2 6, a EB b", 0+ 3IXb I A IX" I----'? 2a EEl b 0+ 2 ----'? 1 § 3 IXb =} ~c Do C -4 1 § 4 c=}b{1'

Obtaining an Upper Bound

The operator v e g r a obtains the upper bound of array 0' if this array does not contain equal elements, with the upper bound being defined as the set of those array elements which are not absorbed by any other elements of the same array. The result is represented by array f3.

vegra +, ~J\ / -, c / IX~ / (IX~) 42 74 4 o b 0 C § 1 Do b ffi b", 0+ 4 0 a § 2 Do a EB b", 0+ 3IXa I A IXb 1----'> 2a EEl b 0+ 2 ----'> 1 § 3 IXb =} ~c 6, C -4 1 § 4 c='?bp,.

Array Compression Execution of the operation s z hat i e AbC II results in the formation of array C from those elements of array A which correspond to one-bits in the code of variable b.

szhatie +,~II,rK/-,b/IXr/(IXr) 43 33 2 o b § 1 ~ 1\' 2a IXa =} Yb 6, b ----'? 1 § 2 b=}b y •

Unification Operator

This operator adds to array 0' those elements of array f3 which were lacking from array 0'.

ob"edin IXI{, ~J\ + / -, c! (::t~) 44 70 4 o b b~ =} C § 1 /':, b EB b{1 0-- 4 0 a § 2 6, a EB I)~ 0+ 3 ::to. EB ~b 0+ 1 ----'? 2 § 3 ~b =?: IXc 6, C-'> 1 § 4 c='?b",. Intersection Operator

This operator forms array 'Y from the elements common to arrays 0' and f3 (more exactly, DESCRIPTION OF THE LYaPAS LANGUAGE 169 from those elements of array a which also occur in array {3).

peresech IXK +, ~" +, yIt / - ,e/ lXyl (IX~Y) 45 62 3 oboe § 1 6, b EB b" 0+ 3 (5 a § 2 6, a EB b(lO+ 1lXb EB ~a I~ 2~b ~ Ye 6, e-1 § 3 e=} by.

Difference Operator The difference operator forms array 'Y from those elements of array a which are lacking in array {3.

raznast IXI( + , ~K +, y" I -, e I lXy I (IX~Y) 46 66 4 (5 b 0 e § 1 6,bEBb:x0+4(5a § 2 6, a EB bp 0+ 3 IXb EB ~a 0+ 1 - 2 § 3 IXb =} y~ 6, e -'> 1 § 4 e=}by •

Array Convolution

The expression s v e r t ka 0 Ab II is equivalent to the expre.ssion ao 0 alO ... <:) aOa-l =} b, where 0 is a two-place operator.

svertka IX 0, ~K +, i II / -, a / (~r) 47 35~ o a ~a =}y § 1 6, a EEl b(l 0+ 2 PPa =} Y - 1. § 2 .

Convolution with Compression The operation s z has v e r <:) Acb II differs from the operation s v e r t k a <:) Abl/ in that, in the formation of the value of variable b, only those elements of array A participate which are marked by ones in the code of the value of variable 'Y.

szhasver IX 0, ~K +, y II, 6 II I -, a I (~~) 50 34 2 y*2a~a~6 § 1 y * 2a 6 ~ ~a =} 6 -,>1 § 2.

Obtaining the Scalar Product We define the scalar product of arrays A and B with respect to the two-place operator 0 as the array, C, for which Uc = min (ua, Ub) and for iE {O, 1, .... O'c - 1} Ci = ai 0 b;. The opera• tion of obtaining such an array is realized by the operator pro s k a I for which, in the given case, 0 = IX, A = ~, B = y and C = 6. 170 A. D. ZAKREVSKII

proskal a 0, ~H +, YH +, OK / -, a / ~O, yO / (~yO) 51 60 3 Q,abl> - by 0> 1 by ~ us -'> 2 § 1 bV-l>bs * 2 /::; a EEl bs 0> 3 ~aara ~ oa -'> 2 § 3 .

Obtaining the Cartesian Product By the Cartesian product of arrays A and B with respect to the two-place operator 0 we mean the array C for which Ci = ajOb, where i= j,ub + k and iE{O,l, ... , (Je -l}, j E {O,l, ... , (Ja -l}, kE {O,l, ... , (J~ -l}. The operation of obtaining array C with these properties is realized by the operator ka r te z, where 0 = a, A = ~, B = Y and C = o.

kartez aD, ~K + , YK + , OH?? / -, e / (~yO) 52 64 3 bl> X by ~ bs?? oboe § 1 6 b EB by 0> 30a § 2 6aEBbI>0>1~aaYb~oc6c->2 § 3 .

Obtaining the Cartesian Product with Elimination of Duplicates

Operator k art e p r i unites the functions of the operators k art e z and p rip 0 d 0 b, and is of interest because the elimination of duplicates is performed during the process of computing the Cartesian product and, therefore, the operational array is utilized quite economically. For operator k art e p r i, a represents the two-place operator with respect to which Cartesian multiplication of arrays {3 and 'Y is performed, with assignment of the result to array O.

kartepri ao, ~K + , YH +, OK? la, d I (~rO) 53 106 5 (~a) oboe § 1 6 b EB by 0> 50a § 2 6 a EB bl> 0> l~aaYb ~ aCSd § 3 6 dEBe 0> 4a EEl Od 0> 2 ---+ 3 § 4 a ~ oe? 6 e ---+ 2 § 5 c~bs.

Obtaining the Lower Bound of a Cartesian Product Operator k a r n i g r a is equivalent in its action to the successive use of operators k art ez and n i g r a and, similarly to operator k art e p r i, provides economical utilization of the opera• tional array. The operands a, {3, 'Y, and 0 are defined as for the case of operator k art e p r i .

karnigra ao, ~I' + , YR + , OR? / a, d! ([3yO) 54 133 5 (~a) ObOe

§ 1 6 b EB b l 0> ;-)3a

§ 2 6 a EEl b~ 0> lpa :XYb =}aod § 3 L, dEBe 0> 4a 11\ Od 0> 20d 11\ a 1---+ 3 6 cO c =? Od ~d -> 3 § 4 a =? oe? 6 C -> 2 § 5 C =? bs. DESCRIPTION OF THE LYaPAS LANGUAGE 171

Obtaining the Upper Bound of a Cartesian Product Operator k a r v e g r a is defined analogously to operator k a r n i g r a, with the difference being that here we find the upper, rather than the lower, bound of the Cartesian product of two arrays.

karvegra 0:0, ~1\ + , 11\ + . b1\? / a, d / (~yb) 55 133 5 (~a) oboe § 1 6, b EB b.( 0+ 5(5a § 2 6,aEBb~o+l~aO:Yb=9aod § 3 6, dEBe 0+ 4b d 1/\ a 0+ 2a 1/\ bd I~ 3 6. cbc =9 bd 6 d --'; 3 § 4 a =9 be? 6,c --> 2 § 5 c =9 bs.

Cartesian Multiplication of an Array by a Variable

Operator k ark 0 p e differs from operator k art e z only in that the second of the two arrays being multiplied together contains only one element, represented by variable 'Y.

karkope 0:0, ~K + . yn, bK / - • a / ~/l / (~y/l) 56 37 2 oab~ =9 bs § 1 6, a EB b~ 0> 2~aO:Y =9/la ~ 1 § 2 .

Cartesian Multiplication of a Variable by an Array

Operator k a r p e k 0 differs from operator k art e z only in that the first of the two ar• rays being multiplied together contains only one element, represented by variable {3.

karpeko 0:0, ~n. y1\ + . /lK / - , a / r~ / (~rb) 57 37 2

oaby =9b& § 1 6, a EB by 0+ 2~o:y a =9 ba ~ 1 § 2.

Exchange of Information The following very simple operators can turn out to be useful in the programming of ex• change of information between arrays. Operator per e s y I k a transmits (Le., assigns) to array {3 the value of array a.

peresylka 0:1\ + . ~K/ - • a/ (o:~) 60 35 2 oa § 16,aEBb,,0+2cxa=9~a-'>1 § 2 bot =9bp..

If there is no necessity of retaining the previous value of array a, it is possible to limit oneself to transmitting to array {3 the characteristic of array a (a ex and bex ) by using the expres• sion 172 A. D. ZAKREVSKII

which is so simple that its replacement by a special L-operator is hardly justifiable. In some situations, one can require the interchange of information between two arrays, programmed equally simply:

Operator ochistka sets all the elements of array a equal to zero.

ochistka

LITERATURE CITED 1. H. Bottenbruch, Structure and Use of ALGOL 60 [Russian translation from the English], Moscow, ILl (1963). 2. Languages for aiding compiler writing. Symbol. Languages Data Process., New York, London (1962), pp. 184-204. 3. K. E. Iverson, A Programming Language, New York, London (1963). 4. A. D. Zakrevskii, "LYaPAS, a logical language for the representation of synthesis algorithms," in: Materials of the Scientific Seminar on Theoretical and Applied Questions of Cybernetics, Kiev (1964). 5. A. D. Zakrevskii, "The LYaPAS compiler," in: Logical Language for the Represen- tation of Algorithms for the Synthesis of Relay Devices, Nauka, Moscow (1966), pp. 70-74.