a.py

import functions as f
import numpy as np


# a) demonstrating that  conv(ld(R)) is the same as ld(conv(R)) for all 11 relationships
def prt1_a_disjoin():
    disjoin = np.array([[0, 0, 1], [0, 0, 1], [1, 1, 1]])

    print("conv(ld(R))")
    print("For: DISJOIN")
    print(disjoin)
    x = f.lft_dual(disjoin)
    print("-> to contains with left dual.")
    print(x)
    f.converse(x)
    print("-> to INSIDE with converse.")
    print(x)

    print("ld(conv(R))")
    disjoin = np.array([[0, 0, 1], [0, 0, 1], [1, 1, 1]])
    print('For: DISJOIN')
    print(disjoin)
    y = f.converse(disjoin)
    print('-> to disjoin with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to CONTAINS with left dual.')
    print(y)
    print("\n")


def prt1_a_embrace():
    embrace = np.array([[1, 1, 1], [1, 0, 0], [1, 0, 0]])

    print("conv(ld(R))")
    print("For: EMBRACE")
    print(embrace)
    x = f.lft_dual(embrace)
    print("-> to inside with left dual.")
    print(x)
    f.converse(x)
    print("-> to CONTAINS with converse.")
    print(x)

    print("ld(conv(R))")
    embrace = np.array([[1, 1, 1], [1, 0, 0], [1, 0, 0]])
    print('For: EMBRACE')
    print(embrace)
    y = f.converse(embrace)
    print('-> to embrace with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to INSIDE with left dual.')
    print(y)
    print("\n")


def prt1_a_attach():
    attach = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]])

    print("conv(ld(R))")
    print("For: ATTACH")
    print(attach)
    x = f.lft_dual(attach)
    print("-> to equals with left dual.")
    print(x)
    f.converse(x)
    print("-> to EQUALS with converse.")
    print(x)

    print("ld(conv(R))")
    attach = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]])
    print('For: ATTACH')
    print(attach)
    y = f.converse(attach)
    print('-> to attach with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to EQUALS with left dual.')
    print(y)
    print("\n")


def prt1_a_entwined():
    entwined = np.array([[1, 1, 1], [1, 1, 0], [1, 0, 0]])

    print("conv(ld(R))")
    print("For: ENTWINED")
    print(entwined)
    x = f.lft_dual(entwined)
    print("-> to coveredBy with left dual.")
    print(x)
    f.converse(x)
    print("-> to COVERS with converse.")
    print(x)

    print("ld(conv(R))")
    entwined = np.array([[1, 1, 1], [1, 1, 0], [1, 0, 0]])
    print('For: ENTWINED')
    print(entwined)
    y = f.converse(entwined)
    print('-> to entwined with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to COVEREDBY with left dual.')
    print(y)
    print("\n")


def prt1_a_meet():
    meet = np.array([[0, 0, 1], [0, 1, 1], [1, 1, 1]])

    print("conv(ld(R))")
    print("For: MEET")
    print(meet)
    x = f.lft_dual(meet)
    print("-> to covers with left dual.")
    print(x)
    f.converse(x)
    print("-> to COVEREDBY with converse.")
    print(x)

    print("ld(conv(R))")
    meet = np.array([[0, 0, 1], [0, 1, 1], [1, 1, 1]])
    print('For: MEET')
    print(meet)
    y = f.converse(meet)
    print('-> to meet with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to COVERS with left dual.')
    print(y)
    print("\n")


def prt1_a_overlap():
    overlap = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])

    print("conv(ld(R))")
    print("For: OVERLAP")
    print(overlap)
    x = f.lft_dual(overlap)
    print("-> to OVERLAP with left dual.")
    print(x)
    f.converse(x)
    print("-> to OVERLAP with converse.")
    print(x)

    print("ld(conv(R))")
    overlap = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
    print('For: OVERLAP')
    print(overlap)
    y = f.converse(overlap)
    print('-> to OVERLAP with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to OVERLAP with left dual.')
    print(y)
    print("\n")


def prt1_a_coveredBy():
    coveredBy = np.array([[1, 0, 0], [1, 1, 0], [1, 1, 1]])
    print("conv(ld(R))")
    print("For: COVEREDBY")
    print(coveredBy)
    x = f.lft_dual(coveredBy)
    print("-> to entwined with left dual.")
    print(x)
    f.converse(x)
    print("-> to ENTWINED with converse.")
    print(x)

    print("ld(conv(R))")
    coveredBy = np.array([[1, 0, 0], [1, 1, 0], [1, 1, 1]])
    print('For: COVEREDBY')
    print(coveredBy)
    y = f.converse(coveredBy)
    print('-> to covers with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to MEET with left dual.')
    print(y)
    print("\n")


def prt1_a_covers():
    covers = np.array([[1, 1, 1], [0, 1, 1], [0, 0, 1]])
    print("conv(ld(R))")
    print("For: COVERS")
    print(covers)
    x = f.lft_dual(covers)
    print("-> to meet with left dual.")
    print(x)
    f.converse(x)
    print("-> to MEET with converse.")
    print(x)

    print("ld(conv(R))")
    covers = np.array([[1, 1, 1], [0, 1, 1], [0, 0, 1]])
    print('For: COVERS')
    print(covers)
    y = f.converse(covers)
    print('-> to coveredBy with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to ENTWINED with left dual.')
    print(y)
    print("\n")


def prt1_a_inside():
    inside = np.array([[1, 0, 0], [1, 0, 0], [1, 1, 1]])
    print("conv(ld(R))")
    print("For: INSIDE")
    print(inside)
    x = f.lft_dual(inside)
    print("-> to embrace with left dual.")
    print(x)
    f.converse(x)
    print("-> to EMBRACE with converse.")
    print(x)

    print("ld(conv(R))")
    inside = np.array([[1, 0, 0], [1, 0, 0], [1, 1, 1]])
    print('For: INSIDE')
    print(inside)
    y = f.converse(inside)
    print('-> to contains with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to DISJOIN with left dual.')
    print(y)
    print("\n")


def prt1_a_equals():
    equals = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])

    print("conv(ld(R))")
    print("For: EQUALS")
    print(equals)
    x = f.lft_dual(equals)
    print("-> to attach with left dual.")
    print(x)
    f.converse(x)
    print("-> to ATTACH with converse.")
    print(x)

    print("ld(conv(R))")
    equals = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
    print('For: EQUALS')
    print(equals)
    y = f.converse(equals)
    print('-> to equals with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to ATTACH with left dual.')
    print(y)
    print("\n")


def prt1_a_contains():
    contains = np.array([[1, 1, 1], [0, 0, 1], [0, 0, 1]])

    print("conv(ld(R))")
    print("For: CONTAINS")
    print(contains)
    x = f.lft_dual(contains)
    print("-> to disjoint with left dual.")
    print(x)
    f.converse(x)
    print("-> to DISJOIN with converse.")
    print(x)

    print("ld(conv(R))")
    contains = np.array([[1, 1, 1], [0, 0, 1], [0, 0, 1]])
    print('For: CONTAINS')
    print(contains)
    y = f.converse(contains)
    print('-> to inside with converse.')
    print(y)
    y = f.lft_dual(y)
    print('-> to EMBRACE with left dual.')
    print(y)
    print("\n")