Template:Seal integer representations

Like Boolean functions in general, seals should be seen as periodic truth tables (corresponding to fractions).
For a given arity they can be seen as finite truth tables (corresponding to integers). But this approach shall be avoided here.
The integer values form the sequence A190939 = 1, 3, 5, 9, 15... An illustration can be seen here.

sequence for arities 0...4

Each row adds the entries for the new arity:
1,
3,
5, 9, 15,
17, 33, 51, 65, 85, 105, 129, 153, 165, 195, 255,
257, 513, 771, 1025, 1285, 1545, 2049, 2313, 2565, 3075, 3855, 4097, 4369, 4641, 5185, 6273, 8193, 8481, 8721, 9345, 10305, 12291, 13107, 15555, 16385, 16705, 17025, 17425, 18465, 20485, 21845, 23205, 24585, 26265, 26985, 32769, 33153, 33345, 33825, 34833, 36873, 38505, 39321, 40965, 42405, 43605, 49155, 50115, 52275, 61455, 65535

Hasse diagrams for arities 2 and 3

The gray numbers are the keys to the integer sequence.
This is a consistent numbering only for a given arity, but not across arities.

Seals with the same label are not equal. E.g. label 0 stands for $\neg A\land \neg B$ on the left, but for $\neg A\land \neg B\land \neg C$ on the right.

Equal seals do not have the same label. E.g. the tautology is labeled 4 on the left, but 15 on the right.

The depth is the layer of the Hasse diagram numbered from top to bottom. For these integers it makes more sense to number them from bottom to top: $rank=arity-depth$

Python program to calculate the integer sequence

This code uses the Python library discrete helpers.

from discretehelpers.a import make_linear_binv


arity = 4

depth_to_seals = {depth: None for depth in range(arity)}
depth_to_seals[0] = [make_linear_binv(walsh=0, parity=1, arity=arity)]  # tautology
depth_to_seals[1] = [make_linear_binv(walsh=i, parity=1, arity=arity) for i in range(1, 2 ** arity)]  # negated Walsh functions

for new_depth in range(2, arity+1):
    new_weight = 2 ** (arity - new_depth)
    old_depth = new_depth - 1
    old_seals = depth_to_seals[old_depth]
    new_seals = set()
    for key_a, seal_a in enumerate(old_seals):
        for key_b in range(key_a + 1, len(old_seals)):
            seal_b = old_seals[key_b]
            candidate = seal_a & seal_b
            if candidate.weight == new_weight:
                new_seals.add(candidate)
    depth_to_seals[new_depth] = sorted(new_seals)

lengths = []
sequence = []

for depth, seals in depth_to_seals.items():
    rank = arity - depth
    seal_integers = sorted([seal.intval for seal in seals])
    print(f'{rank}: {seal_integers},')
    lengths.append(len(seal_integers))
    sequence += seal_integers

print('\n', lengths)

print('\n', sorted(sequence))

resulting dictionary

rank_to_seals = {

    4: [65535],

    3: [255, 3855, 13107, 15555, 21845, 23205, 26265, 26985, 38505, 39321, 42405, 43605, 50115, 52275, 61455],
    
2: [15, 51, 85, 105, 153, 165, 195, 771, 1285, 1545, 2313, 2565, 3075, 4369, 4641, 5185, 6273, 8481, 8721, 9345, 10305, 12291, 16705, 17025, 17425, 18465, 20485, 24585, 33153, 33345, 33825, 34833, 36873, 40965, 49155],

    1: [3, 5, 9, 17, 33, 65, 129, 257, 513, 1025, 2049, 4097, 8193, 16385, 32769],

    0: [1]

}

A better way to represent the seals by integers is with Zhegalkin indices. They form the sequence 1, 3, 5, 7, 15...

Zhegalkin indices for arities 0...4

Each row adds the entries for the new arity:
1,
3,
5, 7, 15,
17, 19, 21, 23, 51, 63, 85, 95, 119, 127, 255,
257, 259, 261, 263, 273, 275, 277, 279, 771, 783, 819, 831, 1285, 1295, 1365, 1375, 1799, 1807, 1911, 1919, 3855, 4095, 4369, 4403, 4437, 4471, 4883, 4915, 4959, 4991, 5397, 5439, 5461, 5503, 5911, 5951, 5983, 6007, 13107, 13311, 16191, 16383, 21845, 22015, 24415, 24575, 30583, 30719, 32639, 32767, 65535