---+-------+ +-------+-------+-------+-------+
| | [d]_x | | | | | 1 | | |
+-------+-------+-------+-------+ +-------+-------+-------+-------+
| | | | [d]_x | | | | | 1 |
+-------+-------+-------+-------+ +-------+-------+-------+-------+
| | | [d]_x | | | | | 1 | |
+-------+-------+-------+-------+ +-------+-------+-------+-------+
| [d]_x | | | | | 1 | | | |
+-------+-------+-------+-------+ +-------+-------+-------+-------+
([d] = [delta])

the number in each row of cempartments denoting an operation of
[delta]_x. Hence the permutation problem is equivalent to that of
placing n units in the compartments of a square lattice of order n in
such manner that each row and each column contains a single unit.
Observe that the method not only enumerates, but also gives a process
by which each solution is actually formed. The same problem is that of
placing n rooks upon a chess-board of n^2 compartments, so that no rook
can be captured by any other rook.

Regarding these elementary remarks as introductory, we proceed to give
some typical examples of the method. Take a lattice of m columns and n
rows, and consider the problem of placing units in the compartments in
such wise that the sth column shall contain [lambda]_s units (s = 1,
2, 3, ... m), and the tth row p1 units (t = l, 2, 3, ... n).

Writing

1 + a1x + a2x^2 + ... + ... = (1 + a1x)(1 + a2x)(1 + a3x) ...

1
and D_p = --([d]_[a]1 + [a]1[d]_[a]2 + [a]2[d]_[a]3 + ...)^p,
p!
([d] = [delta], [a] = [alpha])

the multiplication being symbolic, so that D_p is an operator of order
p, the function is

a_[lambda]1.a_[lambda]2.a_[lambda]3...a_[lambda]m,

and the operator D_p1.D_p2.D_p3...D_pn. The number
D_p1.D_p2...D_pn.a_[lambda]1.a_[lambda]2.a_[lambda]3...a_[lambda]m
enumerates the solutions. For the mode of operation of D_p upon a
product reference must be made to the section on "Differential
Operators" in the article ALGEBRAIC FORMS. Writing

a_[l]1.a_[l]2...a_[l]m =
... + [Delta][Sigma][a]1^p1.[a]2^p2...[a]n^pn + ...,

or, in partition notation,

(1^[l]1)(1^[l]2)...(1^[l]m) = ... + A(p1p2...pn) ... +
D_p1.D_p2