The distinction begins with meaning. L says which relationships hold and what counts as a solution. C decides such matters as whether reasoning proceeds from data towards consequences or from a goal towards subgoals, which pending call is handled next, whether alternatives are explored sequentially or together, and how relational data are stored and retrieved. On Kowalski’s first approximation, admissible changes to C alter behaviour and efficiency but do not alter the problems solved or the answers returned.

That qualification matters. The paper does not say control is irrelevant, nor that logic alone is an executable algorithm. A correct declarative relation can be paired with control that repeats work explosively, consumes unnecessary memory or never reaches an existing answer. Conversely, good control cannot turn a poor representation into an efficient method in every case. Both sides affect performance, but they affect it in different ways.

The motivating promise is replaceability. If A₁ = L + C₁ and A₂ = L + C₂, then, under meaning-preserving control, A₁ and A₂ are equivalent in result while possibly very different in cost. That creates a clean target for optimisation: improve C while holding L fixed. It also creates a clean target for reasoning: establish what L means without first committing to every scheduling choice.

Kowalski is careful not to reify the boundary. The same behaviour can often be analysed as L₁ + C₁ or L₂ + C₂. Work embedded in a more elaborate logical representation can be shifted into a more capable interpreter, and work performed by control can instead be compiled into the clauses. The equation is therefore a disciplined decomposition chosen for explanatory and engineering value.

This inventory blocks a common misreading. “Logic” does not mean a pile of facts with no structure. It includes recursively defined relations, abstractions such as sorting, and representations of data. Nor does “control” mean a single program counter. It includes forward versus backward reasoning, sequential versus parallel calls, depth-first versus breadth-first exploration, indexing and retrieval. An interpreter can own some of these choices; an advanced programmer can provide additional control information in a separate language.

The distinction also locates responsibility. Domain-specific knowledge belongs primarily in L. General and problem-specific problem-solving strategies belong in C, provided they preserve meaning. At a high level of programming, the system should assume more responsibility for control. Kowalski uses database query systems as evidence: the user states a relational query, while the system chooses storage and retrieval schemes.

Control may still use domain knowledge. A programmer can state that y is functionally determined by x in F(x,y), allowing a backtracking engine to avoid seeking a second F answer after a later goal fails. A diagnosis system can state that procedure Q is more likely than R to explain symptom P, changing search order. These facts guide effort without becoming new object-level solutions: if they are correct and the interpreter honours them soundly.

The resulting architecture is asymmetric. L must be specified before C in Kowalski’s programme of successive refinement. Control is subordinate to meaning: it may choose how the relation is realised, but it is not entitled to rewrite the relation silently. That asymmetry is the reason the split can support both correctness arguments and performance work.

An assertion has a conclusion and no conditions. A procedure declaration has one conclusion B and zero or more conditions A₁…Aₙ. A denial has conditions but no conclusion and represents a problem to be refuted. The empty clause is contradiction. Variables are implicitly universal within each clause; variables in different clauses remain distinct even if printed with the same letter.

The logical reading of “Parent(x,y) if Father(x,y)” states a relation. The recursive pair for Ancestor states that a parent is an ancestor and that ancestry composes through an intermediate individual. None of this commits the system to left-to-right calls, depth-first search or a particular index. Those are additions made by control.

Problems are expressed as denials. To ask whether Zeus is a grandparent of Harmonia, deny that relation and seek a refutation. If the denial contains variables, a successful refutation returns substitutions that witness answers. Thus a query for descendants of Zeus can produce Ares, Harmonia and Dionisius rather than merely a Boolean.

Horn form is expressive enough for the paper’s procedural argument, but Kowalski does not pretend it is always the most natural surface form. His subset example shows that converting a compact quantified definition into clauses can obscure its meaning. The restriction is methodological: study the part of logic whose declarative and procedural structures line up most clearly.

Bottom-up begins from Father(Zeus,Ares) and Father(Ares,Harmonia). Parent rules derive Parent(Zeus,Ares) and Parent(Ares,Harmonia). The grandparent rule then derives Grandparent(Zeus,Harmonia). Processing moves from available data towards the requested consequence. It may also derive facts irrelevant to the particular request, such as Male(Zeus), because forward closure is not automatically goal-directed.

Top-down begins from Grandparent(Zeus,Harmonia). The grandparent rule replaces that goal with Parent(Zeus,z) and Parent(z,Harmonia). The parent rules reduce those subgoals to father or mother alternatives; compatible facts bind z to Ares and close the proof. Processing moves from the requested consequence towards supporting data. It can still make irrelevant choices: for example, trying Mother(Zeus,z) before Father(Zeus,z).

Direction is control because the clauses do not nominate a starting end. Top-down proof procedures include model-elimination and linear-resolution families; bottom-up procedures include hyper-resolution. Kowalski also points to connection graphs and natural-deduction systems that can mix directions. This is not a choice between logic and something non-logical. Both are deduction, organised differently.

Direction has characteristic failure modes. Forward reasoning can materialise a broad closure that a narrow query never needs. Backward reasoning can revisit the same subproblem or follow an unproductive branch. Neither direction is universally superior. The purpose of separation is to permit the choice to respond to query shape, data distribution and available execution machinery.

The substitution transmits information in both directions. Matching Grandparent(Zeus,Harmonia) with Grandparent(x,y) binds x and y, sending input to new parent calls. Matching Father(Zeus,z) with the fact Father(Zeus,Ares) binds z, sending output back to the remaining goal. A single invocation can transmit both input and output.

This differs from conventional procedure calls in three ways emphasised by Kowalski. First, a clause body is logically a set or conjunction, not a compulsory sequence; calls may run in any order or in parallel. Secondly, several clauses may have conclusions matching the same call, so choosing a clause is a search problem. Thirdly, argument modes are not fixed once and for all. The same relation can test a pair, find an output from an input, or search for inputs consistent with an output.

Those freedoms are precisely the control surface. A concrete language such as Prolog usually commits to a more particular regime: textual clause order, left-to-right subgoals and depth-first backtracking. Such a regime is one C, not the procedural meaning of Horn clauses in full. Treating it as inevitable collapses the analytical separation.

Flexibility does not remove operational preconditions. A relation can be mathematically symmetric while a chosen implementation expects one argument to be sufficiently instantiated. A reorder can move an expensive generator before a selective test. Parallel calls can require synchronisation on shared variables. The logic tells us which joint assignments satisfy the clause; control must realise them without losing or inventing answers.

The direct definition says that sorting x gives y when y is a permutation of x and y is ordered. It is transparent as a specification. Yet ordinary ways of controlling those two relations generate permutations and test them, or interleave generation with orderedness checks. Better scheduling prunes some work, but the representation still exposes an enormous search space.

A quicksort-style logical definition introduces partitioning around the first element, recursively sorting the two partitions and appending the results. Even simple top-down sequential control now behaves efficiently compared with permutation generation. The improvement came from L: the relation was decomposed using stronger problem knowledge. The result relation: ordered permutations: remains the intended one, but the logical route is more informative.

This supports a two-stage discipline. Specify and refine a logic component that says clearly what is to be done and captures useful domain structure. Then improve its control. Some programme transformations can derive a new, more efficient L by deduction; other optimisations leave L fixed and change C. Calling both “optimisation” should not hide the distinction.

The boundary remains movable. A sophisticated interpreter might recover useful partitioning or constraints from a more abstract specification, shifting work back into C. A simple interpreter may require the programmer to encode more of that knowledge in L. Kowalski’s long-term preference is for clear logic paired with powerful problem-solving machinery, not for deliberate representational weakness.

A list can be represented by terms: nil names the empty list and cons(x,y) names a list whose first element is x and whose rest is y. Higher-level sorting can interact with this representation through relations such as empty, first and rest. Those interface predicates state what the structure provides without forcing every sorting clause to expose cons cells.

A preliminary deduction can eliminate the interface predicates and specialise the abstract quicksort definition into clauses that pattern-match directly on nil and cons. The specialised form avoids interface calls at runtime but mixes procedure and representation. Kowalski connects this to macro expansion: flatten the abstraction before execution, much as a theorem prover or programme transformer can derive a lower-level logic component.

Separation brings two benefits. The list representation can be replaced without rewriting higher-level sorting, and well-named interface relations make the programme largely self-documenting. Mixing representation into every procedure may gain speed, but it transfers documentation outside the programme and increases the cost of change.

This is why Kowalski’s terminology deliberately conflicts with Wirth’s “program = algorithm + data structure”. In A = L + C, data-structure definitions belong to L. The control side manages the scheme by which relational data are stored and retrieved. A relation such as Parent can be presented independently of whether tuples live in an array, hash table, tree or semantic network.

For “y is a permutation of x, and y is ordered”, sequential execution can generate a complete permutation before checking order. Coroutining can suspend generation after each new element and ask whether the partial sequence remains ordered. Invalid prefixes are abandoned early. The two calls still define the same acceptable y values; their communication schedule changes.

Quicksort exposes pipeline parallelism. Partitioning can begin as input elements arrive. Recursive sorts can begin on emerging partitions, and append can begin as sorted output becomes available. The clause lists the joint relations. Control can realise them as a staged sequence, coroutines or communicating processes.

The tree example makes memory visible. To test whether two trees have the same leaf list, a sequential strategy constructs both complete lists and compares them. A communicating strategy lets each traversal emit one leaf, compares the pair immediately and stops at the first mismatch. When the trees disagree early, it avoids most traversal; even when they agree, it need not retain the consumed prefixes.

Kowalski’s claim that parallel top-down subproblems “seems never” to decrease efficiency belongs to the paper’s 1979 framing, not a universal modern cost theorem. Real parallel systems pay scheduling, communication and synchronisation costs. The durable insight is analytical: the conjunction defines compatibility, while the execution regime determines materialisation, latency and resource use.

With two base assertions and the relation Fib(u+2)=Fib(u+1)+Fib(u), a naïve top-down request for Fib(n) expands into requests for Fib(n−1) and Fib(n−2). Those subtrees overlap: Fib(n−2) is solved independently inside both branches, and the duplication compounds. The number of calls grows exponentially with n, while the stack grows with n.

Bottom-up execution begins with the two base values and generates each later value once. It performs linear work. With an appropriate deletion policy it needs to retain only the previous two assertions, using constant working storage. Here the supposedly “declarative” direction looks like the familiar iterative algorithm.

The comparison is not a timeless verdict against top-down reasoning. Kowalski notes that its disadvantage disappears when repeated calls are solved only once: a strategy related in the paper to Warren’s generalisation of Earley parsing. Today one might call the idea memoisation or tabling. That is another C over the same recursive L: demand-driven like top-down evaluation, but sharing answers rather than rebuilding subtrees.

The lesson is causal. The recursive definition does not force exponential work. A particular control regime causes repeated evaluation. Replacing the definition with an imperative loop can fix the symptom, but it also hides that the useful transformation was a change in direction or sharing.

A grandchild query may try parent facts one at a time, nesting one loop of alternatives inside another and leaving as soon as it finds a witness. In a conventional programme that looks like iteration over an array. In a relational account it is depth-first backtracking over matching assertions. Breadth-first, parallel and indexed searches are other controls over the same facts.

In the first path representation, Go(x) means that x is reachable from a fixed initial node. Arcs are clauses such as Go(B) if Go(A). Bottom-up reasoning from Go(A) is forward search. Top-down reasoning from the goal Go(Z) is backward search. Combining them yields bidirectional search; depth-first versus breadth-first is the strategy for investigating alternatives.

In the second representation, Go*(x,y) means that y is reachable from x, and transitivity is a clause connecting x to z and z to y. A query Go*(A,Z) can still move forward by solving the first subgoal first, backward by solving the second first, or bidirectionally by coroutining them. What counted as inference direction in the one-place representation partly becomes subgoal scheduling in the two-place representation. The same behaviour has different L/C analyses.

The paper closes its technical development with arrows attached to atoms. Arrows state where processing activity can flow: conditions-to-conclusion for top-down use, conclusion-to-conditions for bottom-up use, with numeric annotations for sequencing. The notation can drive a connection-graph prover, but Kowalski marks its limit. Efficient grandparent query order depends on which argument is bound, and a static arrow cannot express that input-sensitive choice. A useful decomposition must admit that its control language is incomplete.

The graph is L. Its directed edges determine which paths exist. The start and goal form the problem. The frontier policy is C. Depth-first commits to the earliest open branch, breadth-first expands by distance from the start, and best-first ranks open nodes by their geometric distance to the displayed goal. Duplicate suppression is shared so every strategy terminates on this finite graph.

The three exact checks separate semantics from behaviour. First, the reported reachability must match a control-independent exhaustive closure. Secondly, any returned witness must begin at the start, end at the goal and traverse only declared edges; an unreachable result must return no witness. Thirdly, the reported expansion count must equal a duplicate-free visited trace. These checks do not assert that the controls have equal cost. They assert that cost differences occur inside a preserved relation.

Search order can interact with termination. A depth-first path may descend indefinitely while another branch contains a finite proof. A fair breadth-first procedure may find the proof. Both operate over the same clauses, yet the first may produce no observable answer. For partial computations, “same meaning” requires a semantic account broader than immediate runtime behaviour and an explicit completeness or fairness premise.

Pruning can change the answer set. A functional-dependency annotation, a cut, a beam width or an early stopping rule may discard alternatives. If the discarded branches cannot contribute new valid answers, the pruning is meaning-preserving; otherwise C has reduced completeness. Later logic-programming work makes this obligation explicit by proving correctness and completeness separately and checking that pruning preserves both for the chosen specification.

Modes and floundering complicate the boundary. A relation may support several logical directions, but a concrete implementation can delay calls until arguments are instantiated. Some schedules terminate, others suspend forever. Control still explains the difference, but the engineering claim needs a declared query class and operational preconditions.

Cost itself can leak into meaning when resources are bounded. A system killed after one second does not return the relation’s full answer set. Parallelism can add races or non-deterministic side effects that are absent from pure Horn clauses. Kowalski’s clean separation is most exact for logical, side-effect-free definitions paired with sound problem-solving strategies. Extending it to real systems requires naming resource limits and effects.

The paper also says the L/C division is not wholly unambiguous. A heuristic can be represented as meta-level control or compiled into object-level predicates. An index may look like storage control or a materialised logical relation. The test is not whether every feature has one metaphysical home. It is whether the chosen boundary makes invariants, transformations and obligations easier to see.

The 1979 article is not the first appearance of every ingredient. Kowalski’s earlier work on predicate logic as a programming language and connection-graph proof procedures supplied foundations; Colmerauer, Roussel, Warren, Clark, van Emden and others shaped the operational and semantic programme. The article’s contribution is synthetic: it turns those strands into an engineering equation and walks through the dimensions that can move independently.

The database analogy is especially durable. A query states a relation; an optimiser chooses join order, access paths and materialisation. Two physical plans can be extensionally equivalent while having radically different costs. Kowalski’s supplier/part examples anticipate input-sensitive ordering: begin with the relation constrained by the known constant, not with a static leftmost call.

Later work sharpens the premises. Drabent’s construction of a practical Prolog SAT solver treats a logic programme as a declarative object, proves correctness and completeness, then adds delay and pruning controls and separately proves that the required properties survive. Brand and Yap generalise the form to “Propagation = Logic + Control”, distinguishing the truth conditions of complex constraints from information about which propagation is relevant.

Other descendants move the boundary again. Knowledge-base systems such as IDP treat logic as a model of a domain and provide several inference services rather than one procedural reading. Tabled logic programming changes top-down control by retaining answers. Deductive databases compile declarative rules into physical plans. None of these developments makes the 1979 equation a complete architecture; together they show why its separation of concerns remained productive.

Review one: scholarly fidelity and teaching. The reconstruction was checked across the complete author-hosted scan: abstract, A=L+C qualification, component diagram, clause notation, top-down and bottom-up grandparent derivations, procedural interpretation, permutation/quicksort contrast, data-structure separation, coroutining, Fibonacci, alternative-clause search, both path analyses, arrow notation, its input-sensitive limitation and the conclusion.

The largest fidelity risk was turning the equation into an absolute partition. The paper explicitly calls the boundary not wholly unambiguous and shows A=L₁+C₁=L₂+C₂. A second risk was claiming that all control preserves behaviour. The page keeps Kowalski’s first-approximation restriction and adds explicit soundness, completeness, termination and resource caveats from later work.

Review two: evidence fairness, language and accessibility. Historical credit remains distributed across Hayes, Codd, Hewitt, Bibel and the logic-programming collaborators cited by Kowalski. Later developments are labelled as context, not read backwards into 1979. The prose avoids treating Prolog’s particular left-to-right depth-first regime as the whole procedural interpretation.

All ten figures carry titles, descriptions, captions and source scopes. Animation is redundant, subtle and disabled under reduced-motion preference. The laboratory writes every state as text, verifies three independent invariants, distinguishes unreachable from unfinished search and exposes work rather than declaring one strategy universally best. Desktop, tablet and phone layouts are part of the release test.

Clark’s finite-failure condition already showed that operational details have semantic consequences. A loop cannot license negation, and a selection rule can determine whether failure becomes visible. Kowalski supplies the organising vocabulary: the completed or relational content belongs to L; selection, direction and alternative search belong to C.

The connection is not that meaning and control are independent in every observable sense. It is that separating them makes their interaction testable. One can ask whether a proposed C terminates, remains complete and respects L. Without that split, a missed answer is merely “programme behaviour”; with it, the miss can be diagnosed as representation, search, pruning or scheduling.

Canon 0093 moves to Raymond Reiter’s “A Logic for Default Reasoning”. Clark and Kowalski have established two pressures that default logic answers in a different register: knowledge bases need principled defeasible conclusions, and reasoning systems need to distinguish object-level rules from the conditions that govern their use.

That promise is L: the relation between legitimate inputs and answers, expressed with enough domain structure to be intelligible and useful. The methods are C: which direction to reason, which subproblem to attend to, which alternative to explore, what to retain and how to retrieve it. Improvement becomes a controlled comparison only when the promise is held fixed.

The paper also resists a naïve celebration of abstraction. Permutation plus orderedness is beautifully direct but computationally weak under ordinary controls. A quicksort relation moves problem knowledge into L. Data abstraction improves clarity, yet specialisation may be required for speed. The useful boundary must serve both proof and execution.

Modern systems repeat this pattern. Database users state relations while optimisers select plans. Constraint modellers state conditions while propagators schedule inference. A graph query has a meaning while engines choose indexes and traversal orders. A machine-learning pipeline has a metric contract while schedulers choose batching and placement. In every case, performance work becomes safer when the invariant is executable.

The hard part is the verb “preserve”. A fast search that misses an answer, a parallel schedule that races, or an index that serves stale data has changed the effective programme. Kowalski’s equation is therefore not permission to ignore control. It is a demand to make control replaceable and then prove, test or monitor the boundary.