Count Your Chickens – Pattern generation as a matter of counting

Introduction

Historical Foundation

The pattern generation method that we present is grounded on the works of Sebastien Truchet² and Dominique Doüat³ dated 1704 and 1722 respectively.

The bright intuition of Sebastien Truchet was really simple: to apply a combinatorial study to a tiling module, in order to make its aesthetic potential emerge before starting to compose (fig. 1,2).

We can sum up his approach in four passages: 1. Define the initial modules (fig. 1, Table I). 2. Combine the modules in all possible permutations (Table I). 3. Create an ordered index of the permutations based on their visual appearance (fig. 2 Tables II and III). 4. Generate compositions by selecting permutations from the ordered index (fig. 2, Planches des desseins).

Dominique Doüat improved on Truchet’s approach introducing a new notation and calculation method for pattern generation, this made the manual work faster and more accurate.

First, he associates a letter to every spatial configuration of the square module: A, B, C, D (fig. 3). Then, he combines elements 4 by 4 rather than in groups of 2, allowing the system to scale up better and let the aesthetic potential emerge.

In Doüat words:

II. Observation The same tile A, when placed in different positions and viewed from the same side, can be considered as four different tiles: this is clear. We will call tile A the one with the colored corner at the bottom left; tile B, the one with the colored corner at the top left; tile C, the one with the colored corner at the top right; and tile D, the one with the colored corner at the bottom right. See (Figure 3, first row)

III. Observation The tiles A, B, C, D, when compared with one another, are opposed in three different ways: diagonally, horizontally, and perpendicularly. The tiles A & C, or C & A, B & D, or D & B, are opposed diagonally, that is, from white to black, or from black to white. The tiles A & D, or D & A, B & C, or C & B, are opposed horizontally, that is, from right to left, or from left to right. The tiles A & B, or B & A, C & D, or D & C, are opposed perpendicularly, that is, from top to bottom, or from bottom to top. It is clear, from the mere aspect of the four tiles figured hereafter. See (Figure 3, second row). Dominique Doüat, Methode pour faire un’infinité des Desseins […], Paris, 1722. Freely translated by the authors, see original⁴

Since the appearance and the reciprocal geometric properties of the modules has already been defined, Doüat’s notation made the method more efficient and created a “virtual” environment, where one could calculate combinations or notate pleasing visual compositions simply by writing (fig. 4), without even looking at the actual representation.

(Doüat also defined the rules for the catalogation of the obtained permutations, and some generative rules to compose with his notation.)

The main merit of Dominique Doüat is in understanding the power of notation for pattern generation.

Doüat furthermore calculates the total possible compositions in a given space (fig. 5) and defines some generative rules for the composition of drawings⁵.

\(TotalCount = n^k\)

\(n\) : number of modules

\(k\) : class of the permutation

To conclude, the main difference between the work of Truchet and Douat is the notation: while the first was permutating tiles with a graphical notation, Douat was doing it tipographically, playing with strings.

Modern and contemporary background

The modular approach has already been recognized as a central strategy in contemporary design practice. As Martin Lorenz has demonstrated, modular composition provides a flexible framework for developing and applying visual systems in today’s context.⁶

La Scuola Open Source has demonstrated that Douat’s notation is particularly effective for modular font design.⁷ In several workshops, participants used GTL - Generatore Tipografico di Libertà — an open-source software developed by the work cooperative in 2018 — to experiment with the notation and explore how it can support the creation of modular type systems.

In the paper Tiling through Typography⁸, it is demonstrated that Douat’s textual notation can be easily implemented in digital environments. When the modules are encoded as glyphs in a unicase monospaced font, the compositions can be rendered easily. Historically, such typefaces were engraved for letterpress printing, where they served to construct frames and typographic ornaments. These modular systems found renewed applications in the 20th century, such as letter compositions (fig. 6).

To provide clarity, the same paper introduced a lexicon that we also adopt in this work:

1. we refer to the initial tiles, along with their possible isometric transformations, as modules.
2. The permutations of these modules within any n-class are called nodes.
3. Finally, we call compositions the resulting tilings obtained by assembling multiple nodes together.

Our counting approach

While Truchet combines modules into nodes through a graphic method, Douat does so through a string-based method. In other words: both approaches rely on the same principle of combining modules, but whereas Truchet draws nodes (fig. 7), Douat writes nodes (fig. 8).

AABB

Figure 8: Dominique Doüat “writes” Tilings, he notates the four possible configurations of the modules with A, B, C or D.

5

Figure 9: our notation for the same node.

In this paper, we introduce a third approach: we represent modules as digits and combine them into numbers, then produce combinations by enumeration: by counting nodes (fig. 9). This shift offers a different mode of representation and reveals new affordances for analysis and application.

Note that in our work we favor the graphical representation of compositions over the textual one. We do so to make these affordances explicit, by adopting a square matrix representation rather than a linear string. This square representation allows for systematic nodes catalogaing according to their geometric and chromatic transformations, resulting in a clear classification grounded in visual appearance.

Math foundation

Contextualizing the historical works of Dominique Doüat in the setting of math has the obvious reasons of approachability and elegance. Moreover, math has the great advantage of digital portability. Mathematical language and operators are widely implemented in many programming languages.

By viewing Doüat strings as numeric literals we facilitate generation and handling of permutations and can exploit the power of efficient math implementation. High generation speed is not only desirable for time saving, it also opens up new affordances to the system, opening the possibility for complete generation of permutation sets: handling all the permutations of a given length at once. We can easilly operate with billion of number-only nodes, abstracting away from their string and graphical form. Costly rendering, being it typographic, graphic or musical is performed only as a last, lazy, step.

From Permutations to Counting

We have seen how Doüat improves the Truchet approach to pattern generation by implementing a textual notation and operating with patterns as strings.

Once this correspondence is set one can start to think of modules as letters.

a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z.

Figure 10: The latin alphabet letters, “modules” of the English language

and enumerate all the possible compositions allowed by the generation system:

aa, ab, ac, ad, ae, ...
aaa, aab, aac, aad, ...

Figure 11: All possible compositions of a fixed length from the English alphabet

This realization shifts the generation process from manual enumeration to automatic iteration, a far more efficient approach for generating and exploring all possible combinations.

After that, one can see that while all the compositions in a given set are technically valid, only some of them are useful for a given case. This is evident for our language, where many “valid” words are discarded as not useful for many reasons.

an, by, on, up, it, ...
cat, dog, sun, run, hat, ...
book, star, moon, frog, gold, ...
apple, table, chair, house, plant, ...
circle, orange, animal, yellow, summer, ...

Figure 12: Some useful words in the English language

This new generate-all-then-filter approach poses new problems of scale for pattern generation, but you will see that we present ways to navigate the newfound complexity by cataloging, ordering and filtering nodes.

Positional notation

While the idea of counting in different bases is second nature to mathematicians, it can seem abstract to the less versed. To ensure clarity for all readers, let’s briefly review how numeric systems generalize Doüat’s combinatorial notation.

In our everyday decimal system (base 10), we use ten digits (0–9). A number with a single digit counts up to 9:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

two digits count up to 99:

 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 
50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 
70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 
90, 91, 92, 93, 94, 95, 96, 97, 98, 99.

three digits up to 999, and so on — the number of unique representable numbers increases exponentially (to the power of 10) with each additional digit.

Now, if we switch to base 4 and represent using only digits 0–3, a single digit-number counts up to 3;

0, 1, 2, 3.

two digits up to decimal 15:

00, 01, 02, 03, 
10, 11, 12, 13, 
20, 21, 22, 23, 
30, 31, 32, 33. 

three digits up to decimal 63:

000, 001, 002, 003, 010, 011, 012, 013, 
020, 021, 022, 023, 030, 031, 032, 033, 
100, 101, 102, 103, 110, 111, 112, 113, 
120, 121, 122, 123, 130, 131, 132, 133, 
200, 201, 202, 203, 210, 211, 212, 213, 
220, 221, 222, 223, 230, 231, 232, 233, 
300, 301, 302, 303, 310, 311, 312, 313, 
320, 321, 322, 323, 330, 331, 332, 333.

and four digits up to 255: 0000, ...., 3333.

In general, with \(n\) possible symbols and \(k\) digits, we can represent \(n^k\) unique combinations.

Doüat’s notation follows this logic exactly: each module is assigned a symbol, and combinations are formed just as numbers are written in a positional numeral system. If we substitute symbols we recover the systematic pattern enumeration found in Doüat’s 1722 book. We adopt the natural mapping from digits to letters in alphabetical order, starting from zero (fig. 13).

A ⟷ 0
B ⟷ 1
C ⟷ 2
D ⟷ 3

Figure 13: Mapping from modules to digits

You can find all the nodes presented by Doüat and rewritten in our notation in Appendix C.

Now that we have a clear correspondance, whether we think of modules as letters (where each four-letter “word” is a unique arrangement) or as digits in a number system, the result is the same: we are, at heart, simply counting.

Counting to create a generative system

Following this new theory we can tell that if we imagine a sequence of numbers, we are virtually creating a generative environment. In the following paragraphs we will demonstrate how a simple sequence of increasing numbers can be used to create patterns.

For the sake of simplicity and to streamline our discussion, we will now shift to using a binary (base-2) system in our demonstration.

First of all we will define the parameters of our system, such as the number of modules \(n\) and the number of digits \(k\).

Definition of modules

To reduce the complexity of our demonstration we are not going to use the “Truchet tile” modules (fig.14), but a white square and a black square as modules, shifting from a four-modules-system to a two-module-system (fig. 15).

Combination of modules in nodes

Defining the number of digits k

Now that the number of modules \(n=2\) is fixed, we have to choose the class for our permutation space. With a fast calculation \(tot=2^k\) we can get an idea of how many nodes will be included in our system:

with two digits \(k=2\) we can obtain four nodes \(tot=2^2=4\),

00, 01, 10, 11.

with three digits \(k=3\) we can obtain eight nodes \(tot=2^3=8\),

000, 001, 010, 011, 100, 101, 110, 111.

with four digits \(k=4\) we can obtain eight nodes \(tot=2^4=16\),

0000, 0001, 0010, 0011, 0100, 0101, 0110, 0111, 
1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111.

It is clear that some values for k are more useful to us than others: the approrpiately-named perfect squares. Integers that can be actually arranged to form a square matrix. In order to obtain a decorative system complex enough we will use sixteen digits \(k=16\), obtaining a total of \(tot= 2^{16}=65.536\) nodes. This class allows as to format the strings of length 16 as 4x4 square matrices.

e.g. number 31828 is binary string 0111110001010100, which can be folded into the following square matrix (using conventional top-down left-right folding):

31828  →  0111 1100 0101 0100  →  0 1 1 1
                                  1 1 0 0
                                  0 1 0 1
                                  0 1 0 0

Figure 16: Folding of a binary string into a square matrix.

Generating all the nodes

After we have fixed our generation space to two modules \(n=2\) and sixteen digits \(k=16\) we can tell that we will obtain \(65.536\) nodes. In order to generate them, all we have to do is to count from 0 to 65.535 and convert the base of the numbers from 10 to 2.

We have now obtained 65.536 nodes (binary strings) of 16 digits, composed of 0 and 1.

0000000000000000, 0000000000000001, 
0000000000000010, 0000000000000011, 
0000000000000100, 0000000000000101 
              ... 1111111111111111.

These can be folded to square matrices accordingly:

0 0 0 0   0 0 0 0   0 0 0 0   ...   1 1 1 1
0 0 0 0   0 0 0 0   0 0 0 0         1 1 1 1
0 0 0 0   0 0 0 0   0 0 0 0         1 1 1 1
0 0 0 0   0 0 0 1   0 0 1 0         1 1 1 1

This set includes all the possible nodes that can be created with these two modules with sixteen digits. Every resulting pattern is different from the other by at least one element.

Example

The number 2025

1. is converted to the string 0000111111001001,
2. formatted as a square matrix:
3. then represented with modules in a node:

2025 → 0000 1111 1100 1001  →  0 0 0 0  →  □ □ □ □
                               1 1 1 1     ■ ■ ■ ■ 
                               1 1 0 0     ■ ■ □ □ 
                               1 0 0 1     ■ □ □ ■

Figure 17: Converting a decimal number to a 4x4 matrix.

Definition of an ordered index of nodes

Identifying binary visual patterns

Following the Truchet approach we now need to index the strings following some criterias. The indexing strictly depends on the purposes of our generative system. If we are going to produce visual patterns, we would want to catalogue nodes based on their visual appearance. In our case 0 and 1 represent a white or black square.

If for instance we consider the nodes obtained as rhythms (0 as silence and 1 as a specific sound), we should index them with different criterias that have more to do with music, rather than visual arts.

In order to demonstrate the improvement of Doüat’s notation we keep working on visual patterns, but this time we work with 4x4 square nodes, rather than 16x1 string nodes like Doüat. This will allow us to introduce a new kind of criteria for indexing, based on the symmetries of a square.

Identifying nodes through decimal literals

Doüat performs combinatorial calculation and enumerates the results obtained from \(1\) to \(n^k\). We want to keep naming nodes in decimal notation as it is the most common way to refer to integer numbers. We have also seen that expressing nodes in the natural base, the one that has the selected number of different digits presents many advantages: in the natural base the node Identifier coincides with the node description itself. To uniquely relate decimal representations to base-n strings one can use the base-change transformation, which maintains a one-to-one corispondence without error.

In the case of two modules: - we select 𝑛=2 modules and pick a perfect square class, say \(k=16\) - we count the total possible nodes as \(2^{16}\), from \(0\) to \(65,535\), this decimal number is the node identifier. - we convert to the natural binary base, this is the descriptive string for the node. - we can use this string for visually represent the node in a \(4×4\) grid.

Limits of using enumeration as an identifier

Using decimal literals as identifiers for compositions poses a problem of long non-descriptive identifier: if we are navigating in a generative system with a large class, it may have so many elements that they have a long name, even if the modules of the system are only two. :::info I.e.

n = 2 
k = 36

The node’s decimal ID number is:

18.345.642.073.719.551.315

Even if it is shorter than its description in binary notation:

1111111010011000110100000100010001000100100000111011010101010011

it results distant from day-to-day numbers. :::

Another limit consists in having a number of modules bigger than 10 (\(n>10\)). In this case the default base-10 identifier of a node would be longer than its “description”. It would be paradoxically easier to call a node by its description rather than its identifier.

n = 16
k = 8

10.268.320

FAB10

Grouping by node Properties

From the total set of nodes we can select a few with analogue visual properties.

Grouping by Symbol Count

Compositions can be indexed, for example, according to the count of total 0 and 1 digits. If 0 is white and 1 is black, this type of indexing corresponds to the average gray value of the composition. #### Indexing based on chromatic opposition This type of indexing leads to a further subdivision: for each composition there exists another in which the 0s and 1s are inverted (fig. 18). This allows us to divide the set into two symmetric parts: for any node with \(ID = t\) (where \(t\) is a decimal number), there exists its chromatic complement \(invID = n^k–t-1\) (where the \(n\) is the number of modules, and \(k\) is the class of the permutation).

Indexing based on the redundancy of square symmetries

Each square node possesses 7 geometric symmetries (fig. 19): three rotations (90°, 180°, 270°) and four axial symmetries, corresponding to reflections along the vertical axis, the horizontal axis, and the two diagonals. In addition to these geometric symmetries, in a binary system we consider the inversion of 0 and 1 as a chromatic (or complementary) symmetry. This chromatic inversion is analogous to swapping black and white in the node’s configuration, resulting in what we call the complementary node.

As a consequence, each node is associated with a total of 16 related nodes: 8 obtained by applying the 7 geometric symmetries and the original configuration, 8 more by applying the same symmetries to its chromatic complement. This is why nodes are grouped in sets of 16: each set contains a node, all its geometric symmetries, its chromatic complement, and all the symmetries of the complement (fig. 20).

Interestingly, not all nodes are unique under these transformations. Some nodes are invariant under certain symmetries; for example, a node that is symmetric with respect to the vertical axis remains unchanged when reflected along that axis (fig. 21).

This redundancy creates a simplification: some of the 16 transformations may yield the same node, reducing the actual number of distinct nodes in the resulting set (fig. 22).

Indexing nodes according to the type and number of redundant symmetries provides a powerful way to classify them. Nodes with the same redundancy profile share common geometric or chromatic properties, which can be useful for analyzing, selecting specific nodes, or generating patterns within the larger system. An example of this classification can be found in the appendix B.

Higher order compositions

Dominique Doüat described and used some generative rules for creating tilings (“desseins”) by selecting specific permutations from a comprehensive table of all possible combinations of tiles. These rules determine which permutations to choose, how to arrange them, and how to repeat these arrangements. By carefully choosing, positioning, and combining these permutations according to set procedures, Doüat’s approach enables the creation of a wide variety of increasingly complex designs through clear, repeatable steps.

Canons

We refer to this kind of rules with the word “canon”, as a “set of transformations”, a list of operations to execute on the node to produce a larger composition. By working on a square grid we know that combining four adjacent modules in a 2x2 format produces a larger square composition (fig. 23).

//Rotations
r90   //90 degree rotation
r180  //180 degree rotation
r270  //270 degree rotation

//Reflections
mX  //reflection on the X axis
mY  //reflection on the Y axis
d1  //reflection on the first diagonal
d2  //reflection on the second diagonal

//Chromatic inversion
ne  //inversion of "0" and "1"

Figure 24: Complete list of transformations with their short name.

In terms of canon notation the order of the sequence always starts from the upper left corner, and follows to the right, then repeats on the new line. This is done to stay coherent to the typographic approach and ensure the same flow of information between nodes, canons, and compositions.

notation = [n1,n2,n3,n4] = ⎡n1,n2⎤
                           ⎣n3,n4⎦
                           
                           
                          
rep = [n,n,n,n] // Repetition

nRep = [ne,ne,ne,ne] // Negative repetition
altRep = [n,ne,ne,n] // Alternated repetition

refX = [n,n,mX,mX] // Horizontal mirror
refY = [n,mY,n,mY] // Vertical mirror
refD = [n,d2,d2,n] // Diagonal mirror

altRefX = [ne,ne,mX,mX] // Alt. horizontal mirror
altRefY = [n,ne(mY),n,ne(mY)] // Alt. vertical mirror
altRefD = [n,ne(d2),ne(d2),n] // Alt. diagonal mirror

ortho = [n,mY,mX,r180] // Orthogonal
altOrtho = [n,ne(mY),ne(mX),r180] // Alternate orthogonal

rotC = [n,r90,r270,r180] // Concentric rotation
altRotC = [ne,ne(r90),ne(r270),ne(r180)] // Neg. conc. rotation

Figure 26: A complete list of the syntax of the canons

Canon nesting

Founding the system on a power of four principle opens up to many possibilities. By applying a canon to a node, we obtain a composition that is still a perfect square (fig. 28). Therefore, treating the result composition as an input node, we can pass it through a second canon (fig. 29) and repeat the process to get another perfect square. The canon operation exhibits the inherent property of nesting: we can travel through “layers” of canons, increasing the complexity of the resulting composition and its resolution. (fig. 30)

It is important to note that commutative property does not apply to canon nesting: the same canons applied to the node in different order can produce a different composition.

We invite the reader to explore canon nesting in the Chicken Counter tool that we present in Appendix A. It is focused on intuitive exploration of the node symmetries and composition of 3 layers of canons, applied to a manually designed 4x4 node.

Conclusion

This paper has demonstrated how Dominique Doüat’s combinatorial notation can be adapted for computational pattern generation by reframing visual compositions as numeric literals in a positional counting system. By treating Doüat’s combinatorial strings as base-n numbers, we have transformed the manual enumeration process into efficient computational counting, enabling the systematic generation and analysis of all possible pattern combinations within parameter spaces defined by number of different modules and class.

Our approach centers on grouping enumerated elements into coherent sets based on structural properties — particularly symmetry redundancies — which provides a powerful framework for pattern classification and selection. This mathematical foundation honors Doüat’s 18th-century innovations and extends them into contemporary computational practice, revealing new affordances for pattern exploration and generation.

The efficiency gains from treating patterns as numeric literals rather than character strings prove substantial. Operating directly on numbers allows for rapid generation, comparison, and manipulation of entire pattern spaces—transformations that would be computationally expensive when performed on string representations. This numeric approach enables real-time exploration of pattern sets containing tens of thousands of elements, making previously impractical systematic analysis feasible.

Critically, our method reconciles two seemingly conflicting creative approaches. The bottom-up approach begins with mathematical enumeration, building pattern understanding through systematic analysis of all possible combinations and their structural properties, then filtering based on them. Conversely, the top-down approach starts with intuitive exploration, allowing designers to navigate the pattern space guided by aesthetic preference and creative intention. Rather than opposing each other, these approaches prove complementary: systematic enumeration provides the comprehensive foundation that makes intuitive exploration meaningful, while creative navigation reveals which mathematical structures hold visual or functional significance. The filtering and grouping mechanisms serve as the bridge between these approaches, transforming exhaustive mathematical coverage into selective creative discovery.

Further Developments

Free exploration has revealed symmetries emerging from computational analysis rather than traditional geometric classification. Visual analysis of contiguous shapes within patterns and mathematical characterization of node filters require further work. The approach may find application in musical composition and typography, though domain –specific constraints would need consideration.

The companion web application and playground “The Chicken Counter” provides a foundation for further exploration. Taken as a framework, it also opens the possibility of new curated functions to be implemented, leveraging simple interactions for a cascade of effects. Notably, the translation function within the nodes has revealed the potential to generate “organic” animations, evoking patterns reminiscent of Conway’s Game of Life.⁹.

Appendix A: Pattern playground

With 65,536 chickens scratching in a coop, how can one properly distinguish and move them around?

This paper comes with a companion web app allowing for free exploration of patterns: The Chicken Counter 1.0 is a browser-based interface to navigate the nodes (chickens) and arrange them into more advanced compositions.

It has been designed pursuing the smoothness of interaction. It is meant to be explored intuitively. It works as a playground, we invite you to explore it freely or to start from the selected nodes you encountered in the paper.

The primary parameters of our proposed method have been intentionally fixed for ease of use, and to reduce the complexity of the process to the lowest terms.

The core system of the counter is the decimal number, the unique identifier of each node-chicken (from 0 to 65,535). In this generator we display all the forms a node can take in our system: as a number, as binary strings (graphical or numerical), as binary matrices (graphical or numerical).

Since the number and the strings evade our human ability to graphically evaluate the corresponding node, we arranged the matrices representations at the top of the page. There they serve as the first interactive entry point. Each digit can be clicked and swapped to the opposed binary one, for an extremely intuitive and fast optical-based navigation of the nodes, while live-adjusting the underlying decimal indexing to always point to the correct value.

Whichever node selection route is taken, number or click based, the system responsively updates the others to always be in sync and display the correct decimal and binary representations.

The process so far has established a system to encode, identify and distinguish a precise amount of binary nodes. These nodes, strings of 16 characters, can be represented graphically, by employing a custom typeface that converts 1s to black squares and 0s to white ones.

Our wish is to explore the graphical applications of the modules in a controlled environment, one that can enable us to navigate smoothly through the entire set of possibilities. All of this while maintaining a formal description of each resulting output.

Lastly, any users wishing to make concrete use of their exploration are welcome to copy the output, and incorporate it into whichever medium of interest they may have. Given the simple binary nature of the output, it may find applications from typography to punchcard for textiles, classic decoration or more advanced computational elaboration.

How to use the Chicken Counter 1.0

When we open the Chicken Counter and at every refresh we visualise a 32x32 composition, obtained through the nesting of three random canons, applied to a random node (chicken).

As a general rule, any red element is interactive, with the addition of the two matrices on the top right - in binary squares and digits.

The controls

The controls are set to the right side of the window, here we can edit the nodes and the canons of the output composition.

Node Editing

The core system of the counter is the number, the unique identifier of each node-chicken. This univocal value is represented five times (fig. A2):

• as 4x4 matrix of binary squares,
• as 4x4 matrix of binary digits,
• as decimal number 2025,
• as string of binary squares □□□□□■■■■■■□■□□■,
• as string of binary digits 0000011111101001.

Both the matrices can have each individual digit clicked to swap it to the other binary value. Additionally, a transformation bar is located under the first matrix (fig. A3). Its different buttons apply the corresponding transformation to the module. From left to right, these are: 1. clockwise rotation, 2. first diagonal symmetry, 3. reflection on the horizontal axis, 4. complementary (negative), 5. reflection across vertical axis, 6. second diagonal symmetry, 7. and counterclockwise rotation.

An ulterior tool appears when hovering the square matrix (fig. A4). Four arrows pointing to its different sides, that upon being clicked shift the pattern a column or row up or down, depending on the direction clicked.

Under the node matrices is the Chicken Number, a decimal number input ranging from 0 to 65535, covering all the possible permutations of the class-16 binary module (fig. A5). Once clicked, a new number can be typed in or scrolled to using the up and down arrow keys. By clicking on the round button below, the chicken-number is randomized. On the right the node is represented both as a visual and numeric binary string.

Canon Editing

The canons define the arrangement of the node in the larger compositions, they are randomly selected at page loading or by clicking on the title (fig. A6). A maximum nesting of three canons is allowed on the generator. On the right of each canon a black box displays the list of the transformations applied to the node. Canons are activated by default, and can be deactivated by clicking on their letter identifier (the red ❶, ❷ and ❸). By hovering the mouse over the red rectangular buttons, small arrows appears, they can be used to edit the applied canons. Furthermore, clicking on the round red button the canons are randomised.

The output

The pattern preview is visible on the left side of the window. The output is read-only, and its content can be copied to the clipboard by clicking the red dot under the bottom-right corner (fig. A7).

It is a string of 1s and 0s separated into lines by carriage returns. You can render this text on any text editor whit this simple font, that displays 1s as black squares ■, and 0s as white ones □. Make sure to give the same value of body size and baseline, so that the squares align exactly.

00001010010100000000101001010000
01110110011011100111011001101110
11100110011001111110011001100111
10011100001110011001110000111001
10100000000001011010000000000101
01100111111001100110011111100110
01101110011101100110111001110110
11001001100100111100100110010011
11001001100100111100100110010011
01101110011101100110111001110110
01100111111001100110011111100110
10100000000001011010000000000101
10011100001110011001110000111001
11100110011001111110011001100111
01110110011011100111011001101110
00001010010100000000101001010000
00001010010100000000101001010000
01110110011011100111011001101110
11100110011001111110011001100111
10011100001110011001110000111001
10100000000001011010000000000101
01100111111001100110011111100110
01101110011101100110111001110110
11001001100100111100100110010011
11001001100100111100100110010011
01101110011101100110111001110110
01100111111001100110011111100110
10100000000001011010000000000101
10011100001110011001110000111001
11100110011001111110011001100111
01110110011011100111011001101110
00001010010100000000101001010000

Appendix B: 100 Pixel nodes with dichromatic symmetry in a square matrix of class 16

Our favourite Chickens - Dichromatic Symmetric nodes

Once all possible nodes have been indexed, it becomes easy to isolate those with specific structural properties by applying filtering rules.

Dichromatic symmetry identifies the graphical elements made of only two colors in which the shape of one color and the shape of the chromatic opposite are complementary and identical in shape;

A famous example is the Yin and Yang symbol.

Nodes for which at least one of the fundamental square transformations produces the chromatic inverse are of this kind.

One can reproduce this process as follows: 1. select nodes that are half black, those with the same number of zeroes and ones; 2. apply the 7 square transformations and mark the results; 3. compare each result with the inverse of the original: if one or more matches you got one.

All possible permutations can be filtered to extract compositions with particularly distinctive properties, enabling the abstraction and study of modules that exhibit notable formal or perceptual characteristics.

We further group them in closed sets by the number of unique results after symmetries.

Appendix C: Doüat permutations rewritten with our notation