Algebraically we look for elements that remain unchanged under some mapping that is consistent with the system's assumptions. Group theory calls these mappings homomorphisms, and when they are 1:1 and cover all the elements under consideration, they are isomorphisms or permutations.
Take, for instance, the set { ø, A, B, α, β } under addition defined by:
ø + (any element) = the same element
A + A = B
A + B = α
B + B = β
A + α = β
B + β = A
α + α = A
α + β = B
β + β = α
A + β = ø
B + α = ø
The first rule gives the identity element. The last two give inverses. This set of elements is isomorphic to Z5, the set of integers mod 5. We can show this by a bijective function that preserves identity and inverses (an isomorphism):
{ (ø, 5), (A, 1), (B, 2), (α, 3), (β, 4) }
We can see the symmetry about 0 and the inverses more directly by restating the domain set and the isomorphism as:
{ (ø, 0), (A, 1), (B, 2), (α, -1), (β, -2) }
Addition also remains well-defined: inverses and the 'order' of each element (in effect, the way skip-counting works) must be preserved:
{ (ø, 0), (A, -2), (B, 1), (α, 2), (β, -1) }
The structure of the group is maintained across the transformation:
- ø goes to 0, identity to identity. 0 is its own inverse, and 0 has order 1 (one element results from skip counting 0+0).
- A goes to -2 and its inverse α goes to 2, the inverse of -2. Similarly for B and β.
- By skip counting 2, 2+2=4, +2=6=1 mod 5, +2=3 mod 5, +2=5=0 mod 5 we get that the order of 2 (and -2) is 5. Similarly for B and β.
And here is the point: when we grow software, like it or not, we are implicitly defining a kind of broken algebra. Usually it is a messy affair, both incomplete and inconsistent, replete with exceptions. Yet despite the incongruities identifiable structure exists.
Fixed points in software give rise to symmetries analogous to those found in algebras - similarity and congruence in subordinate structures, inverses and zero divisors. If we fix two diagonally opposing corners of a square figure, we define an axis of symmetry. By fixing points we constrain the set of morphisms on the space defined by the square, leaving just one valid movement: a flip about the diagonal.
In a software code base, fixed points act to constrain, inhibit or completely proscribe adaptations. Like local fault inclusions formed in a crystal lattice by too-fast growth or foreign particles, fixed points introduce cleavage planes into the structure. If the system is well-formed the structure may be minimally complex.
But fixed points in software are often incidental and accidental, leading to anomalous structuring. In a software system, every random fixed point injected renders it more prone weird structuring. Whether we get a well-structured system with clean cleavage planes, a quizzical Rube Goldberg contraption, or an amorphous mass largely depends upon the environment in which the software is grown and the rate at which decisions crystalize.
