LMSetTheory

import numpy

class LM:
    def countMin(arr):
        small = min(arr);
        tot = 0;
        for x in range(len(arr)):
            if (arr[x] == small):
                tot+=1;
        return tot;

    def ignoreZeros(arr):   #Not used in LM/SetTheory
        final = 0;
        for x in range(len(arr)):
            final+=arr[x];
            if final > 0:
                break;
            elif x == len(arr) and final == 0:
                final = 1;
        return final;

    def nestedIndex(arr,srch):  #Returns the index of sub-array srch within arr if included.
        result = [];
        for a in range(len(arr)):
            result.append(arr[a][srch]);
        return result;
    def checkIndexes(arr):
        result = [];
        for x in range(1,len(arr)):
            if arr[x] == arr[x-1]:
                result.append(True);
        return len(result) == len(arr)-1;
    
    def mindex(arr):
        small = min(arr);
        for x in range(len(arr)):
            if arr[x] == small:
                return x;
    
    def arrSame(arr):
        collect = [];
        trueMatrix = [];
        total = 0;
        for a in range(len(arr)):
            for b in range(len(arr[a])):
                collect.append(LM.nestedIndex(arr,b));
                total+=1;
        for c in range(len(collect)):
            temp = [];
            for d in range(1,len(collect[c])):
                if (collect[c][d] == collect[c][d-1]):
                    temp.append(True);
            trueMatrix.append(temp);
        final = [];
        for x in range(len(trueMatrix)):
            if len(trueMatrix[x]) == len(arr)-1:
                final.append(True);
        return len(final) == total;
    
    def progSum(arr,mod):
        winner = [];
        option1 = arr;
        semi = SetTheory.retro(option1);
        option2 = SetTheory.invert(semi,0,mod)
        for x in range(1,len(option1)):
            if SetTheory.modulus(option1[x]-option1[x-1],mod) < SetTheory.modulus(option2[x]-option2[x-1],mod):
                winner.append(1);
            elif SetTheory.modulus(option1[x]-option1[x-1],mod) > SetTheory.modulus(option2[x]-option2[x-1],mod):
                winner.append(2);
            else:
                winner.append(0);
        semi = LM.ignoreZeros(winner);
        if semi == 1:
            return option1;
        else:
            return option2;

    def rotate(arr):    
        result = [];
        big = arr+arr;
        for x in range(len(arr)):
            result.append(big[x:x+len(arr)]);
        return result;

    def duplicateSubArr(arr):      #Works on its own, fails in context of abstractSubsets
        dups = [];
        for x in range(len(arr)):
            for y in range(len(arr)):
                if x < y:
                    temp = [];
                    for a in range(len(arr[x])):
                        for b in range(len(arr[y])):
                            if arr[x][a] == arr[y][b]:
                                temp.append(True);
                    if len(temp) == (len(arr[y])):
                        dups.append(y);
        dups = sorted(numpy.unique(dups),reverse=True);
        for z in dups:
            del(arr[z]);
        return arr;

    def subCount(srch,arr):      
        res = []
        fin = [srch,0]
        start = list(filter(lambda a: len(a) == len(srch),arr));
        for x in range(len(start)):
            tru = [];
            for y in range(len(start[x])):
                for z in range(len(srch)):
                    if srch[z] == start[x][y]:
                        tru.append(True);
            res.append(tru);
        for a in range(len(res)):
            if len(res[a]) == len(srch):
                fin[1]+=1;
        return fin;

class SetTheory:                #Collection of methods used for set class analysis.
    def modulus(num,mod):
        if num >=0 and num < mod:
            return num;
        elif num < 0:
            return SetTheory.modulus(num+mod,mod);
        elif num >= mod:
            return SetTheory.modulus(num-mod,mod);

    def cycleLen(ints,mod):
        tot = 0;
        for x in ints:
            tot+=x;
        z = 1;
        while tot*z%mod != 0:
            z+=1;
        return z*len(ints);

    def cycle(start,int,terms):
        res = [start];
        for x in range(terms-1):
            res.append(res[x]+int);
        return res;

    def combCycle(start,ints,mod):          
        bigInts = [];
        result = [start];
        for x in range(SetTheory.cycleLen(ints,mod)//len(ints)):
            for y in range(len(ints)):
                bigInts.append(ints[y]);
        for z in range(len(bigInts)):
            result.append(SetTheory.modulus(result[z]+bigInts[z],mod));
        return result;

    def transpose(set,index,mod):
        res =[];
        for x in set:
            res.append(SetTheory.modulus(x+index,mod));
        return res;

    def complement(num,length):
        return length-num;

    def retro(arr):
        result = [];
        for x in range(len(arr)):
            result.append(arr[SetTheory.complement(x,len(arr)-1)]);
        return result;

    def AIS(arr,mod):       #This runs just fine on its own and within normalOrder and primeForm, but fails in ultimateSubs only in cardinalities above 7??
        ais = [];
        for x in range(1,len(arr)):
            ais.append(SetTheory.modulus(arr[x]-arr[x-1],mod));
        return ais;

    def bounds(arr,mod):
        res = [];
        for x in range(len(arr)):
            if (SetTheory.modulus(arr[x]-arr[0],mod)) != 0:
                res.append(SetTheory.modulus(arr[x]-arr[0],mod));
        return SetTheory.retro(res);

    def intervalClass(val,mod):
        if val <= mod*.5:
            return val;
        else:
            return mod-val;

    def rotBound(arr,mod):
        res = [];
        for x in arr:
            res.append(SetTheory.bounds(x,mod));
        return res;

    def invert(arr,index,mod):
        result = [];
        for x in arr:
            temp = mod-x;
            result.append(SetTheory.modulus(temp+index,mod));
        return result;
    
    def normalOrder(arr,mod):          #Gets the normal order of a set modulo n;
        step1 = sorted(arr);
        step2 = LM.rotate(step1);
        step3 = SetTheory.rotBound(step2,mod);
        if LM.arrSame(step3) == True:
            return sorted(arr);
        else:
            for x in range(len(step3)-1):
                step4 = LM.nestedIndex(step3,x);  
                if LM.countMin(step4) > 1:
                    for y in range(1,len(arr)):
                        step4 = LM.nestedIndex(step3,(x-y));       
                elif LM.countMin(step4) == 1:
                    no = step2[LM.mindex(step4)];
                    return no;                                                  
            
    def primeForm(arr,mod):
        pf = [];
        start = SetTheory.normalOrder(arr,mod);
        ints = SetTheory.AIS(start,mod);
        if LM.checkIndexes(ints) == True:
            for x in range(len(start)):
                pf.append(SetTheory.modulus(start[x]-start[0],mod));
        else:
            next = LM.progSum(start,mod);
            for z in next:
                pf.append(SetTheory.modulus(z-next[0],mod));
        return pf;

    def intervalVector(arr,mod,out):    
        ints = [];
        vector = []
        for a in range(len(arr)):
            for b in range(len(arr)):
                if b>a:
                    ints.append(SetTheory.modulus(arr[b]-arr[a],mod));
        for i in range(1,(mod//2)+1):
            vector.append([[i,SetTheory.modulus(mod-i,mod)],[0]]);
        for j in range(len(ints)):
            for k in range(len(vector)):
                if ints[j] == vector[k][0][0] or ints[j] == mod-vector[k][0][0]:
                    vector[k][1][0]+=1;
        if out == 0:
            return vector;
        elif out == 1:
            woot = [];
            for l in range(len(vector)):
                woot.append(vector[l][1][0]);
        return woot;

    def indexVector(arr,mod,out):
        ints = [];
        vect = [];
        for a in range(len(arr)):
            for b in range(len(arr)):
                ints.append(SetTheory.modulus(arr[a]+arr[b],mod));
        for i in range(mod):
            vect.append([i,0]);
        for j in range(len(vect)):
            for k in range(len(ints)):
                if ints[k] == vect[j][0]:
                    vect[j][1]+=1;
        if out == 0:
            return vect;
        elif out == 1:
            wowz = [];
            for l in range(len(vect)):
                wowz.append(vect[l][1]);
            return wowz;

    def powerSet(arr):
        results = [];
        arrLen = 2**(len(arr));
        for a in range(arrLen):
            temp = [];
            for b in range(len(arr)):
                if a & 2**b:
                    temp.append(arr[b]);
            if len(temp) != 0:
                results.append(temp);
        return results;

    def filtPowerSet(arr,filt):  #Prints the subsets of cardinality filt from powerset of a collection. (Does not include the empty set).
        start = SetTheory.powerSet(arr);
        fin = list(filter(lambda x: len(x) == filt,start));
        return fin;

    def literalSubsets(arr):        #Literal collections contained within a superset.
        start = SetTheory.powerSet(arr);
        return start;

    def setClass(set,mod):  #Generates the collection of all sets transpositionally and inversionally equivalent to the input set.
        t_s = [];
        i_s = [];
        for x in range(mod):
            t_s.append(["T"+str(x),SetTheory.transpose(set,x,mod)]);
            i_s.append(["I"+str(x),SetTheory.retro(SetTheory.invert(set,x,mod))]);
        return [t_s,i_s];

    def srchSet(set,super):             #Searches a superset for the primeform specified.
        tot = SetTheory.powerSet(super);
        primes = [];
        for x in tot:
            primes.append(SetTheory.primeForm(x,12));
        return LM.subCount(set,primes);

    def abstractSubsets(arr):   
        res = [];
        start = SetTheory.literalSubsets(arr);
        for x in start:
            res.append(SetTheory.primeForm(x,12))
        return LM.duplicateSubArr(res);
    
    def ultimateSubs(set):  #Counts the number of instances of each abstract subset within a collection, fails in cards over 7?
        ps = [];
        res = [];
        start = SetTheory.abstractSubsets(set);
        tot = SetTheory.powerSet(set);
        for x in tot:
            ps.append(SetTheory.primeForm(x,12));
        for y in start:
            res.append(LM.subCount(y,ps));
        return res;

mySet = [0,2,4,5,7,9,11]

print(SetTheory.ultimateSubs(mySet))
print(SetTheory.abstractSubsets(mySet));