f.py

import functions as f
import numpy as np


# c) demonstrating that conv(ld(rd(R))) is the same as conv(rd(ld(R))) for all 11 relationships

def prt2_c_disjoin():
    disjoin = np.array([[0, 0, 1], [0, 0, 1], [1, 1, 1]])

    print("conv(ld(rd(R)))")
    print("For: DISJOIN")
    print(disjoin)
    x = f.rt_dual(disjoin)
    print("-> to inside with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to embrace with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to EMBRACE with the converse.")
    print(z)

    print("conv(rd(ld(R)))")
    disjoin = np.array([[0, 0, 1], [0, 0, 1], [1, 1, 1]])
    print('For: DISJOIN')
    print(disjoin)
    y = f.lft_dual(disjoin)
    print('-> to contains with a left dual.')
    print(y)
    y = f.rt_dual(y)
    print('-> to embrace with a right dual.')
    print(y)
    z = f.converse(y)
    print("-> to EMBRACE with the converse.")
    print(z)
    print("\n")


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

    print("conv(ld(rd(R)))")
    print("For: EMBRACE")
    print(embrace)
    x = f.rt_dual(embrace)
    print("-> to contains with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to disjoin with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to DISJOIN with the converse.")
    print(z)

    print("conv(rd(ld(R)))")
    embrace = np.array([[1, 1, 1], [1, 0, 0], [1, 0, 0]])
    print('For: EMBRACE')
    print(embrace)
    y = f.lft_dual(embrace)
    print('-> to inside with a left dual.')
    print(y)
    y = f.rt_dual(y)
    print('-> to disjoin with a right dual.')
    print(y)
    z = f.converse(y)
    print("-> to DISJOIN with the converse.")
    print(z)
    print("\n")


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

    print("conv(ld(rd(R)))")
    print("For: ATTACH")
    print(attach)
    x = f.rt_dual(attach)
    print("-> to equal with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to attach with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to ATTACH with the converse.")
    print(z)

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


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

    print("conv(ld(rd(R)))")
    print("For: ENTWINED")
    print(entwined)
    x = f.rt_dual(entwined)
    print("-> to covers with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to meet with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to MEET with the converse.")
    print(z)

    print("conv(rd(ld(R)))")
    entwined = np.array([[1, 1, 1], [1, 1, 0], [1, 0, 0]])
    print('For: ENTWINED')
    print(entwined)
    y = f.lft_dual(entwined)
    print('-> to coveredBy with a left dual.')
    print(y)
    y = f.rt_dual(y)
    print('-> to meet with a right dual.')
    print(y)
    z = f.converse(y)
    print("-> to MEET with the converse.")
    print(z)
    print("\n")


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

    print("conv(ld(rd(R)))")
    print("For: MEET")
    print(meet)
    x = f.rt_dual(meet)
    print("-> to coveredBy with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to entwined with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to ENTWINED with the converse.")
    print(z)

    print("conv(rd(ld(R)))")
    meet = np.array([[0, 0, 1], [0, 1, 1], [1, 1, 1]])
    print('For: MEET')
    print(meet)
    y = f.lft_dual(meet)
    print('-> to covers with a left dual.')
    print(y)
    y = f.rt_dual(y)
    print('-> to entwined with a right dual.')
    print(y)
    z = f.converse(y)
    print("-> to ENTWINED with the converse.")
    print(z)
    print("\n")


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

    print("conv(ld(rd(R)))")
    print("For: OVERLAP")
    print(overlap)
    x = f.rt_dual(overlap)
    print("-> to overlap with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to overlap with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to OVERLAP with the converse.")
    print(z)

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


def prt2_c_coveredBy():
    coveredBy = np.array([[1, 0, 0], [1, 1, 0], [1, 1, 1]])
    print("conv(ld(rd(R)))")
    print("For: COVEREDBY")
    print(coveredBy)
    x = f.rt_dual(coveredBy)
    print("-> to meet with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to covers with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to COVEREDBY with the converse.")
    print(z)

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


def prt2_c_covers():
    covers = np.array([[1, 1, 1], [0, 1, 1], [0, 0, 1]])
    print("conv(ld(rd(R)))")
    print("For: COVERS")
    print(covers)
    x = f.rt_dual(covers)
    print("-> to entwined with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to coveredBy with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to COVERS with the converse.")
    print(z)

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


def prt2_c_inside():
    inside = np.array([[1, 0, 0], [1, 0, 0], [1, 1, 1]])
    print("conv(ld(rd(R)))")
    print("For: INSIDE")
    print(inside)
    x = f.rt_dual(inside)
    print("-> to disjoin with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to contains with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to INSIDE with the converse.")
    print(z)

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


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

    print("conv(ld(rd(R)))")
    print("For: EQUALS")
    print(equals)
    x = f.rt_dual(equals)
    print("-> to attach with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to equals with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to EQUALS with the converse.")
    print(z)

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


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

    print("conv(ld(rd(R)))")
    print("For: CONTAINS")
    print(contains)
    x = f.rt_dual(contains)
    print("-> to embrace with a right dual.")
    print(x)
    y = f.lft_dual(x)
    print("-> to inside with a left dual.")
    print(x)
    z = f.converse(y)
    print("-> to CONTAINS with the converse.")
    print(z)

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