Note

 import sys                                                                                                                                                   import bisect

import math

def Lcm(a, b):

    return abs(a*b) // math.gcd(a, b)

def find_lt(a, x):

    'Find rightmost value less than x'

    i = bisect.bisect_left(a, x)

    if i:

        return a[i - 1]

    return 0

def find_gt(a, x):

    'Find leftmost value greater than x'

    i = bisect.bisect_right(a, x)

    if i != len(a):

        return a[i]

    return a[len(a) - 1]

if __name__ == "__main__":

    llp = int(sys.argv[1])

    ulp = int(sys.argv[2])

    llt = [i*llp for i in range(Lcm(llp, ulp) // llp + 1)]

    ult = [i*ulp for i in range(Lcm(llp, ulp) // ulp + 1)]

    via_size = int(sys.argv[3])

    prl = int(sys.argv[4])

    print(llt)

    print(ult)

    res = []

    space_list = []

    vios = 0

    vios_list = []

    for t in ult[:-1]:

        left_bnd = find_lt(llt, t)

        right_bnd = find_gt(llt, t)

        left_dis = t - left_bnd - via_size

        right_dis = right_bnd - t - via_size

        space_list.append((left_dis, right_dis))

        res.append((left_bnd, right_bnd))

        if left_dis < prl:

            vios = vios + 1

            vios_list.append(left_dis)

        if right_dis < prl:

            vios = vios + 1

            vios_list.append(right_dis)

    vios_list.sort()

    print(res)

    print(space_list)

    print("upper tracks: ", len(ult) - 1)

    print("vios: ", vios)

    print("vios_list: ", vios_list)   

Script Note

import sys

import re

from itertools import combinations_with_replacement as rcb

from itertools import combinations as cb

if __name__ == '__main__':

    all_vt = set()

    group_list = {}

    i = 0

    with open('vt.txt') as f:

        lines = f.readlines()

    for line in lines:

        group_list[i] = {}

        p_list = []

        n_list = []

        for l in str(line).split():

            if re.search('P', l):

                p_list.append(l)

            else:

                n_list.append(l)

            all_vt.add(l)

        group_list[i]['P'] = p_list

        group_list[i]['N'] = n_list

        i = i + 1

    print(group_list)

    for vt in all_vt:

        vt_type = 'P'

        adj_type = 'N'

        if re.search('N', vt):

            vt_type = 'N'

            adj_type = 'P'

        adj_vt = re.sub(vt_type, adj_type, vt)

        for key in group_list:

            print(group_list[key])

            group = group_list[key]

            if adj_vt not in group[adj_type]:

                continue

            if vt in group[vt_type]:

                continue

            risk_types = list(rcb(group[vt_type], 2))

            for risk_type in risk_types:

                if vt in risk_type:

                    continue

                if re.sub(vt_type, adj_type, risk_type[0]) in group[adj_type] and re.sub(vt_type, adj_type, risk_type[1]) in group[adj_type]:

                    continue

                print("Violate Group: ", adj_vt, risk_type)