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.
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 uses the Python library discrete helpers.

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 uses the Python library discrete helpers.

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 uses the Python library discrete helpers.

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 uses the Python library discrete helpers.

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.)