Studies of Euler diagrams/transformations

dummy

These are pairs of functions in the same clan (NP equivalence class), so they can be expressed in terms of each other.
The clan numbers refer to the rational ordering. (Which will at some point be replaced by a better one.)

The transformation from one to the other is a signed permutation, which means that arguments are negated and permuted.
As a special case it can be just a set of negated places or just a permutation. (These cases are marked with N, P or NP respecitively.)

clan 84: dakota and tinora   (NP)

This Euler diagram has no symmetry. Therefore the transformation of one into the other is unique. The one from left to right is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {Blue}\neg 2}&{\color {Red}~0}&{\color {ForestGreen}\neg 1}&{\color {Orange}~3}\end{pmatrix}}$.   It means the following: The old red border becomes the new blue border, and the orientation changes. (The spikes pointed upward, now they point downward.) The old green border becomes the new red border. (The orientation stays the same.) The old blue border becomes the new green border, and the orientation changes. (The spikes pointed left, now they point right.) The yellow border remains unchanged. dakota tinora The transformation from right to left is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {ForestGreen}~1}&{\color {Blue}\neg 2}&{\color {Red}\neg 0}&{\color {Orange}~3}\end{pmatrix}}$, the inverse of the one shown above. This code is part of a Python library called discrete helpers, which is not yet published. from discretehelpers.sig_perm import SigPerm from discretehelpers.boolf.examples import dakota, tinora dakota_clan = dakota.ec_clan() dakota_clan.get_block_from_label(tinora) == [(6, 3)] sigperm = SigPerm(pair=(6, 3)) assert sigperm.sequence_string(4) == '(~2, 0, ~1, 3)' assert sigperm.inverse.sequence_string(4) == '(1, ~2, ~0, 3)' assert dakota.apply_sigperm([~2, 0, ~1, 3]) == dakota.apply(~2, 0, ~1, 3) == tinora assert tinora.apply_sigperm([1, ~2, ~0, 3]) == tinora.apply(1, ~2, ~0, 3) == dakota map of spots fullspots_map = dict() for fs in dakota.fullspots: fullspots_map[fs] = sigperm.apply_on_natural_number(fs) assert fullspots_map == { 0: 6, 1: 2, 2: 7, 3: 3, 4: 4, 6: 5, 7: 1, 8: 14, 9: 10 }

clan 157: dagoro and darimi   (NP)

Dagoro is a gap variant of tinora (shown above on the right). These two functions do not have the same set of (relevant) arguments. But that is not a problem. One can see dagoro as a 5-ary function with an irrelevant input E, and darimi has an irrelevant input A. The transformation from left to right is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}&{\color {Brown}~4}\\{\color {Orange}\neg 3}&{\color {Blue}~2}&{\color {ForestGreen}~1}&{\color {Brown}~4}&{\color {Red}~0}\end{pmatrix}}$. It means the following: The old red border becomes the new yellow border, and the orientation changes. (The spikes pointed left, now they point right.) The old green border becomes the new blue border. The old blue border becomes the new green border. The old yellow border becomes the new brown border. The inexistent old brown border "becomes" the inexistent new red border. (There could also be a negator in this place.) dagoro darimi The transformation from right to left is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}&{\color {Brown}~4}\\{\color {Brown}~4}&{\color {Blue}~2}&{\color {ForestGreen}~1}&{\color {Red}\neg 0}&{\color {Orange}~3}\end{pmatrix}}$, the inverse of the one shown above. This code is part of a Python library called discrete helpers, which is not yet published. Darimi is spread to arity 5, and thus not among the 4-ary functions in dagoro.ec_clan(). dagoro.ec_clan(5) is created without duplicates by default. from discretehelpers.a import logic_str_vector from discretehelpers.sig_perm import SigPerm from discretehelpers.boolf.examples import dagoro, darimi dagoro_clan_triples = dagoro.ec_clan(5) triples = dagoro_clan_triples.get_block_from_label(darimi) # [(1, 5, 4)] m, n, c = triples[0] sigperm = SigPerm(pair=(m, n)) # <SigPerm (2, 1, ~0)> atomvals = dagoro_clan_triples.glove_compartment[c] # (1, 2, 3, 4) sigvar = sigperm.apply_on_vector(atomvals) # signed variation assert sigvar == [-4, 2, 1, 4] assert logic_str_vector(sigvar) == '[~3, 2, 1, 4]' assert dagoro.apply(*sigvar) == darimi ########################################################################################### dagoro_clan_pairs = dagoro.ec_clan(5, suppress_abbreviation=True) dagoro_clan_pairs.get_block_from_label(darimi) == [(8, 101), (9, 101)] a = SigPerm(pair=(8, 101)) b = SigPerm(pair=(9, 101)) assert a.sequence_string() == '(~3, 2, 1, 4, 0)' assert b.sequence_string() == '(~3, 2, 1, 4, ~0)' assert dagoro.apply_sigperm(a) == dagoro.apply_sigperm(b) == darimi

clan 109: tamino and niliko   (NP)

The diagrams in this EC are mirror symmetric. That means that there are two transformations between each pair of functions. The one used here to get from left to right is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {Blue}\neg 2}&{\color {Orange}~3}&{\color {ForestGreen}~1}&{\color {Red}~0}\end{pmatrix}}$. The one from right to left is the inverse ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {Orange}~3}&{\color {Blue}~2}&{\color {Red}\neg 0}&{\color {ForestGreen}~1}\end{pmatrix}}$. tamino niliko

clan 203: dukeli and netuno   (NP)

Each function can be represented by two mirror symmetric Euler diagrams. Here both are shown for netuno. The transformation from the chosen diagram of dukeli to the one of netuno above is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {Red}~0}&{\color {Orange}~3}&{\color {Blue}\neg 2}&{\color {ForestGreen}\neg 1}\end{pmatrix}}$. Its inverse is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {Red}~0}&{\color {Orange}\neg 3}&{\color {Blue}\neg 2}&{\color {ForestGreen}~1}\end{pmatrix}}$. dukeli netuno netuno The transformation from the chosen diagram of dukeli to the one of netuno below is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {ForestGreen}\neg 1}&{\color {Blue}\neg 2}&{\color {Orange}~3}&{\color {Red}~0}\end{pmatrix}}$. Its inverse is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}\\{\color {Orange}~3}&{\color {Red}\neg 0}&{\color {ForestGreen}\neg 1}&{\color {Blue}~2}\end{pmatrix}}$. This whole NP equivalence class with 192 functions (represented by 384 diagrams) can be found in dukeli NP. This code is part of a Python library called discrete helpers, which is not yet published. from discretehelpers.sig_perm import SigPerm from discretehelpers.boolf.examples import dukeli, netuno dukeli_clan = dukeli.ec_clan() assert dukeli_clan.get_block_from_label(netuno) == [(6, 14), (6, 18)] a = SigPerm(pair=(6, 14)) b = SigPerm(pair=(6, 18)) # above assert a.sequence_string() == '(0, 3, ~2, ~1)' assert a.inverse.sequence_string() == '(0, ~3, ~2, 1)' # below assert b.sequence_string() == '(~1, ~2, 3, 0)' assert b.inverse.sequence_string() == '(3, ~0, ~1, 2)' assert dukeli.apply_sigperm(a) == dukeli.apply_sigperm(b) == netuno netuno_clan = netuno.ec_clan() assert netuno_clan.get_block_from_label(dukeli) == [(3, 9), (12, 14)] == [b.inverse.pair, a.inverse.pair]

clan 349: nagini and medusa   (P)

These diagrams have the symmetry of a rectangle, which can be flipped in four ways. This means that there are four transformations between each pair of functions in it. The one used here to get from left to right is ${\begin{pmatrix}{\color {Red}0}&{\color {ForestGreen}1}&{\color {Blue}2}&{\color {Orange}3}\\{\color {ForestGreen}1}&{\color {Blue}2}&{\color {Orange}3}&{\color {Red}0}\end{pmatrix}}$. The one from right to left is the inverse ${\begin{pmatrix}{\color {Red}0}&{\color {ForestGreen}1}&{\color {Blue}2}&{\color {Orange}3}\\{\color {Orange}3}&{\color {Red}0}&{\color {ForestGreen}1}&{\color {Blue}2}\end{pmatrix}}$. The arguments are only permuted, but not negated. So only the colors change, but not the direction of the spikes. nagini medusa

clan 15: potero and makoto   (NP)

Each function can be represented by two mirror symmetric Euler diagrams. Here both are shown for makoto. The transformation between the chosen diagram of potero and the one of makoto above is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}\\{\color {ForestGreen}\neg 1}&{\color {Red}\neg 0}&{\color {Blue}~2}\end{pmatrix}}$. (It is self-inverse, so it works left to right, and back.) potero makoto makoto The transformation from the chosen diagram of potero to the one of makoto below is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}\\{\color {Blue}\neg 2}&{\color {Red}~0}&{\color {ForestGreen}~1}\end{pmatrix}}$. Its inverse is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}\\{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Red}\neg 0}\end{pmatrix}}$.

potero and potula   (N)

These two diagrams differ only in the orientation of border A. The self-inverse transformation between them is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}\\{\color {Red}\neg 0}&{\color {ForestGreen}~1}&{\color {Blue}~2}\\\end{pmatrix}}$. potero potula

potula and basori   (P)

The transformation between the two diagrams is ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}&{\color {Orange}~3}&{\color {Brown}~4}\\{\color {Red}~0}&{\color {Orange}~3}&{\color {Brown}~4}&{\color {ForestGreen}~1}&{\color {Blue}~2}\end{pmatrix}}$, which is self-inverse. From left to right the columns 3 and 4 are irrelevant, and from right to left the columns 1 and 2. The entries in these columns could be negated and permuted. Counting these leads to 8 possible transformations. (That is between the two diagrams. Between the two functions it would be 16.) potula basori This code is part of a Python library called discrete helpers, which is not yet published. from discretehelpers.a import logic_str_vector from discretehelpers.sig_perm import SigPerm from discretehelpers.boolf.examples import potula, basori potula_clan_triples = potula.ec_clan(5) assert potula_clan_triples.get_block_from_label(basori) == [(0, 0, 5), (2, 5, 5)] # signed permutations based on first two entries in triples sigperm_a = SigPerm(pair=(0, 0)) sigperm_b = SigPerm(pair=(2, 5)) assert sigperm_a.sequence_string(5) == '(0, 1, 2, 3, 4)' assert sigperm_b.sequence_string(5) == '(2, ~1, 0, 3, 4)' # the possible combinations (3-subsets of a 5-set) assert potula_clan_triples.glove_compartment == [ (0, 1, 2), # 0 (0, 1, 3), # 1 (0, 1, 4), # 2 (0, 2, 3), # 3 (0, 2, 4), # 4 (0, 3, 4), # 5 (this one) (1, 2, 3), # 6 (1, 2, 4), # 7 (1, 3, 4), # 8 (2, 3, 4) # 9 ] # combination based on last entry in triples atomvals = potula_clan_triples.glove_compartment[5] assert atomvals == (0, 3, 4) # signed variations (signed permutations applied on combination) sigvar_a = sigperm_a.apply_on_vector(atomvals) sigvar_b = sigperm_b.apply_on_vector(atomvals) assert logic_str_vector(sigvar_a) == '[0, 3, 4]' assert logic_str_vector(sigvar_b) == '[4, ~3, 0]' assert potula.apply(*sigvar_a) == basori assert potula.apply(*sigvar_b) == basori ########################################################################################## potula_clan_pairs = potula.ec_clan(5, suppress_abbreviation=True) assert potula_clan_pairs.get_block_from_label(basori) == [ (0, 60), (0, 84), (2, 60), (2, 84), (4, 60), (4, 84), (6, 60), (6, 84), (8, 65), (8, 89), (10, 65), (10, 89), (12, 65), (12, 89), (14, 65), (14, 89) ] example_sigperm = SigPerm(pair=(0, 60)) assert example_sigperm.sequence_string() == '(0, 3, 4, 1, 2)' assert example_sigperm.inverse == example_sigperm assert potula.apply_sigperm(example_sigperm) == basori assert basori.apply_sigperm(example_sigperm) == potula

clan 19: dobare and dobipi   (N)

Euler diagrams in this EC have 3-fold dihedral symmetry. (This is obfuscated by the conventional representation on the right.) Thus there are six transformations from one function to another. The simplest one between these two is to change the orientation of border A, i.e. ${\begin{pmatrix}{\color {Red}~0}&{\color {ForestGreen}~1}&{\color {Blue}~2}\\{\color {Red}\neg 0}&{\color {ForestGreen}~1}&{\color {Blue}~2}\\\end{pmatrix}}$.   (Compare potero and potula.) dobare dobipi

barita filtrates   (P)

miniri and sediri gepofu and sedofu putuki and seduki

bloatless alternatives   (N)

demole futare