On the distributivity of arithmetic and boolean operations in 2ⁿ

#!/usr/bin/env python3

import itertools
import collections


# convenience utilities
bit = lambda bits, i: (bits >> i) & 1

def op_per_bit(op, n):
    """Apply a binary operation to the i-th bits ∀i in i-bits vectors"""
    def per_bit(a, b):
        acc = 0
        for i in range(n):
            acc |= op(bit(a, i), bit(b, i))
        return acc
    return per_bit

# definition of operations
OP = collections.namedtuple('OP', 'name func')
OPS = lambda n: [
    OP('ADD ', lambda a, b: (a + b) % 2**n),
    OP('SUB ', lambda a, b: (a - b) % 2**n),
    OP('MUL ', lambda a, b: (a * b) % 2**n),
    OP('DIV ', lambda a, b: (a // b) % 2**n if b != 0 else 0),
    OP('XOR ', lambda a, b: a ^ b),
    OP('AND ', lambda a, b: a & b),
    OP('OR  ', lambda a, b: a | b),
    OP('IF  ', op_per_bit(lambda bit1, bit2: int(not bit1 or bit2), n)),
    OP('XNOR', op_per_bit(lambda bit1, bit2: int(not (bit1 ^ bit2)), n)),
    OP('NAND', op_per_bit(lambda bit1, bit2: int(not (bit1 & bit2)), n))
]


def result_repr(left, right):
    if left and right:
        return "l,r  "
    elif left:
        return "l    "
    elif right:
        return "r    "
    return "     "

def print_human_readable_table(tbl_left, tbl_right, n):
    ops = OPS(n)

    print(" " * 5 + "│", end='')
    for op in ops:
        print(op[0] + "│", end='')
    print()
    print("–" * 56)

    for op_1 in ops:
        print(op_1[0] + " │", end='')
        for op_2 in ops:
            print(result_repr(tbl_left[op_1[0] + op_2[0]], tbl_right[op_1[0] + op_2[0]]), end='')
        print()

if __name__ == "__main__":
    for n in range(1, 6):
        print("\n## n == {}\n".format(n))

        # evaluation data
        left_distributivity = {}
        right_distributivity = {}

        # evaluation
        for op1, op2 in itertools.product(OPS(n), repeat=2):
            left_dist, right_dist = True, True

            for arg1, arg2, arg3 in itertools.product(range(2**n), repeat=3):
                lhs = op1.func(arg1, op2.func(arg2, arg3))
                rhs = op2.func(op1.func(arg1, arg2), op1.func(arg1, arg3))
                left_dist = left_dist and (lhs == rhs)

                lhs = op1.func(op2.func(arg2, arg3), arg1)
                rhs = op2.func(op1.func(arg2, arg1), op1.func(arg3, arg1))
                right_dist = right_dist and (lhs == rhs)

            left_distributivity[op1.name + op2.name] = left_dist
            right_distributivity[op1.name + op2.name] = right_dist

        print_human_readable_table(left_distributivity, right_distributivity, n)