Example #1
0
def glue_mori(DtoJmat, mori_rows_group):
    "Compute Mori and Kahler cones for glued geometries."
    g_mori = Cone(mori_rows_group[0])
    for x in mori_rows_group[1:]:
        g_mori = g_mori.intersection(Cone(x))
    g_mori_rows = [list(x) for x in g_mori.rays().column_matrix().columns()]
    g_mori_cols = mongojoin.transpose_list(g_mori_rows)
    g_kahler_cols = [
        sum([
            DtoJmat[k][j] * vector(g_mori_cols[j])
            for j in range(len(g_mori_cols))
        ]) for k in range(len(DtoJmat))
    ]
    g_kahler_rows = mongojoin.transpose_list(g_kahler_cols)
    return [g_mori_rows, g_kahler_rows]
def ToricSwissCheese(h11,NL,dresverts,fgp,fav,JtoDmat,mori_rows,itensXD):
    "Solves for the rotation matrices of a Toric Swiss Cheese solution."
    if fav:
        mori_cols=mongojoin.transpose_list(mori_rows);
        ndivsD=len(JtoDmat);
        RaLbssetpairs=[];
        #Small Cycle
        for i in range(ndivsD):
            for j in range(ndivsD):
                if (all([x==0 for x in itensXD[i][j]])):
                    RaLbssetpairs+=[[{i},{j}]];
        #Take (NL,h11-NL) subsets that satisfy the small cycle condition
        RaLbsgroups=groupabsetpairs(RaLbssetpairs,NL,h11);
        #Check for orthogonality (required for a basis) and basis change conditions
        #Rabgroups=[];
        #Tab=[];
        result=[];
        homresult=[];
        #rind=0;
        #ind=0;
        #int_basis_a=False;
        #int_basis_b=False;
        doneflag=False;
        for group in RaLbsgroups:
            aspossset=Set([z for z in range(ndivsD) if z not in group[0]]).subsets(h11-NL).list();
            bLpossset=Set([z for z in range(ndivsD) if z not in group[1]]).subsets(NL).list();
            for asposs in aspossset:
                afullrank=(matrix(ZZ,[JtoDmat[j] for j in group[0]+list(asposs)]).rank()==h11);
                if afullrank:
                    for bLposs in bLpossset:
                        bfullrank=(matrix(ZZ,[JtoDmat[j] for j in list(bLposs)+group[1]]).rank()==h11);
                        if bfullrank:
                            r=[[group[0],list(asposs)],[list(bLposs),group[1]]];
                            ra=r[0][0]+r[0][1];
                            #Volume
                            volflag=False;
                            lkconeflag=False;
                            skconeflag=False;
                            lcflag=False;
                            homflag=False;
                            i=0;
                            while (i<len(r[0][0]) and not volflag):
                                j=0;
                                while (j<len(ra) and not volflag):
                                    k=0;
                                    while (k<len(ra) and not volflag):
                                        if (itensXD[r[0][0][i]][ra[j]][ra[k]]!=0):
                                            volflag=True;
                                        k+=1;
                                    j+=1;
                                i+=1;
                            if volflag:
                                #Kahler Cone (Large part)
                                lkconeflag=all([(all([y>=0 for y in mori_cols[z]]) or all([y<=0 for y in mori_cols[z]])) for z in r[0][0]]);
                                if lkconeflag:
                                    #Kahler Cone (Small part)
                                    #skconeflag=False;
                                    #all_solcones=[Cone([[mori_rows[i][r[0][1][j]] for j in range(len(r[0][1]))]]).dual() for i in range(len(mori_rows)) if all([mori_rows[i][k]==0 for k in r[0][0]])];
                                    #solcone=Cone([[0 for j in range(len(r[0][1]))]]).dual();
                                    #for newsolcone in all_solcones:
                                    #    solcone=solcone.intersection(newsolcone);
                                    #if solcone.dim()==len(r[0][1]):
                                    #    skconeflag=True;
                                    #else:
                                    #    in_interior=(not any([solcone.intersection(z).is_equivalent(solcone) for y in all_solcones for z in y.facets()]));
                                    #    if in_interior:
                                    #        skconeflag=True;
                                    skconeflag=Cone([[mori_rows[i][r[0][1][j]] for j in range(len(r[0][1]))] for i in range(len(mori_rows)) if all([mori_rows[i][k]==0 for k in r[0][0]])]).is_strictly_convex();
                                    if skconeflag:
                                        #Large Cycle
                                        #lcflag=False;
                                        for j in r[0][0]:
                                            for k in ra:
                                                if (not any([itensXD[i][j][k]==0 for i in r[1][0]])):
                                                    lcflag=True;
                                                    break;
                                            if lcflag:
                                                break;
                                        if lcflag:
                                            #Homogeneity
                                            #if homogeneity_on:
                                                #homflag=False;
                                            for j in r[0][1]:
                                                if(not any([itensXD[i][i][j]==0 for i in r[1][1]])):
                                                    homflag=True;
                                                    break;
                                            #else:
                                            #    homflag=True;
                            if (volflag and lkconeflag and skconeflag and lcflag):# and homflag):
                                #Convert to rotation matrices
                                Ta=[JtoDmat[j] for j in r[0][0]+r[0][1]];
                                Tb=[JtoDmat[j] for j in r[1][0]+r[1][1]];
                                #Rabgroups+=[r];
                                #Tab+=[[Ta,Tb]];
                                #Check for integer bases
                                a_integer=simpvol([dresverts[m] for m in range(ndivsD) if m not in r[0][0]+r[0][1]])==fgp;
                                b_integer=simpvol([dresverts[m] for m in range(ndivsD) if m not in r[1][0]+r[1][1]])==fgp;
                                result+=[[NL,[Ta,Tb],a_integer,b_integer,homflag]];
                                if homflag:
                                    homresult+=[[NL,[Ta,Tb],a_integer,b_integer,homflag]];
                                    if a_integer and b_integer:
                                        #int_basis_a=True;
                                        #int_basis_b=True;
                                        #ind=rind;
                                        doneflag=True;
                                        break;
                                #elif a_integer and (not b_integer) and not (int_basis_a or int_basis_b):
                                #    int_basis_a=True;
                                #    int_basis_b=False;
                                #    ind=rind;
                                #elif (not a_integer) and b_integer and not (int_basis_a or int_basis_b):
                                #    int_basis_a=False;
                                #    int_basis_b=True;
                                #    ind=rind;
                                #rind+=1;
                if doneflag:
                    break;
            if doneflag:
                break;                        
        #if len(Tab)==0:
        #    return [NL,[],int_basis_a,int_basis_b];
        #else:
        #    return [NL,Tab[ind],int_basis_a,int_basis_b];
        if doneflag:
            return [NL,[Ta,Tb],a_integer,b_integer,homflag];
        elif len(homresult)>0:
            return homresult[0];
        elif len(result)>0:
            return result[0];
        else:
            return [NL,[],False,False,False];
    else:
        return [NL,"unfav",False,False,False];
Example #3
0
 Iprechow = C.ideal(Ilin + Ibasechange)
 ######################## Begin parallel MPI scatter/gather of geometrical information ###############################
 scatt = [[C, DD, JJ, dresverts, DtoJmat, Iprechow, x]
          for x in mongojoin.distribcores(triangs, size)]
 #If fewer cores are required than are available, pass extraneous cores no information
 if len(scatt) < size:
     scatt += [-2 for x in range(len(scatt), size)]
 #Scatter and define rank-independent input variables
 prechow = comm.scatter(scatt, root=0)
 C_chunk, DD_chunk, JJ_chunk, dresverts_chunk, DtoJmat_chunk, Iprechow_chunk, triangs_chunk = prechow
 #For each chunk of information assigned to this rank, do the following
 gath = []
 for t in triangs_chunk:
     #Obtain Mori and Kahler matrices
     mori_rows = mori(dresverts_chunk, t['TRIANG'])
     mori_cols = mongojoin.transpose_list(mori_rows)
     kahler_cols = [
         sum([
             DtoJmat_chunk[k][j] * vector(mori_cols[j])
             for j in range(len(mori_cols))
         ]) for k in range(len(DtoJmat_chunk))
     ]
     kahler_rows = mongojoin.transpose_list(kahler_cols)
     #Obtain Stanley-Reisner ideal and Chow ideal
     SR = SR_ideal(dresverts_chunk, t['TRIANG'])
     SRid = [prod([DD_chunk[j] for j in x]) for x in SR]
     ISR = C_chunk.ideal(SRid)
     Ichow = Iprechow_chunk + ISR
     #Obtain information about the Chow ring
     ipolyAD, itensAD, ipolyXD, itensXD, invbasis, JtoDmat, cnAD, cnAJ = chowAmb(
         C_chunk, DD_chunk, JJ_chunk, dresverts_chunk, t['TRIANG'],