Non procedural language for parallel programs

Probably building non procedural languages is the most prospective way for parallel programming just because non procedural means no fixed way for execution. The article consists of 3 parts. In first part we consider formal systems for definition a named datasets and studying an expression power of different subclasses. In the second part we consider a complexity of algorithms of building sets by the definitions. In third part we consider a fullness and flexibility of the class of program based data set definitions.

💡 Research Summary

The paper proposes a formal framework for a non‑procedural language aimed at parallel programming. It begins by arguing that non‑procedural specifications, which describe what a data set should contain rather than how to compute it, are inherently suited to parallel execution because they leave the choice of evaluation strategy open. The authors illustrate the limitations of traditional relational database languages with examples that require named data sets and self‑referential definitions, motivating a richer formalism.

The core of the work is a taxonomy of four elementary forms of set definition:

• α (enumeration) – explicit listing of elements.
• β (property‑based selection) – defining a set by a quantified predicate over other sets.
• γ (inductive definition) – a base set together with an induction rule that adds elements satisfying a predicate.
• δ (functional image) – constructing a new set by applying a term (function) to arguments drawn from other sets.

Each form is associated with a schema S_j t (a name parameterized by a term) and a selector hierarchy U that specifies the domains of the variables appearing in the term. Selectors are organized into closed hierarchies to guarantee that every variable is bound and that there are no circular dependencies. The paper distinguishes closed definition systems (which use only internally defined names) from open ones (which may refer to external names), and defines the notion of a system of forms as a finite collection of definitions satisfying syntactic constraints.

To compare expressive power, the authors treat each system of forms as an operator that maps a data universe to a family of named sets. They introduce a partial order ≥ on subclasses of definitions: a subclass Φ₁ is at least as expressive as Φ₂ if for every system in Φ₁ there exists an equivalent system in Φ₂ (possibly with an extended signature) that yields the same named sets under any interpretation. Using this framework they prove that none of the four basic forms can be eliminated without strictly reducing expressive power. Moreover, extending the signature with a predicate p(x, S) that tests membership of x in a named set S yields a strictly stronger subclass.

The complexity analysis is built on the concept of a standard interpretation: a finite set of bearer elements Q, a set of terms Q^λ built from the functional symbols, and a diagram D that records which ground predicate atoms are true or false. A minimal standard interpretation for a given named set S_a is one where removing any atom from D would change the resulting set. Lemma 1 shows that if two systems differ in minimality for the same name, they cannot be equivalent, establishing a tool for separating expressive classes.

Finally, the paper addresses the functional completeness of the proposed language class. By showing that any computable function can be expressed as a composition of the four basic forms together with appropriate selectors, the authors argue that programs written in this non‑procedural style are functionally complete. The selector hierarchy also serves as a static data‑dependency analysis, enabling safe parallel execution: because the dependencies are explicitly encoded, a runtime system can schedule independent selectors concurrently without risking data races.

In conclusion, the work provides a rigorous foundation for non‑procedural parallel programming languages, demonstrating that a modest set of declarative constructs suffices for full computational expressiveness while offering a clear path to parallel execution through explicit dependency specifications. The authors suggest that future research should focus on concrete language design, compiler support for selector analysis, and empirical evaluation on real parallel architectures.