4421.sagews

Nombre minimal d'oreillers pour $Q(7, -1^{11}):

def N_min(p0, p1, p2, p3):    # donner les pi dans l'ordre décroissant.
       l=0                       #il faudrait rajouter un test pour vérifier que les pi sont comme on veut
       if p2+p3 == 4 :
           l=2
       elif p2+p3 == 6 :
           if p3 == 1 :
               l=4
           else :
               l=2
       return 2*p0+p1+2*l

Programme : $d$ : degré du revêment, $d=2,4,6,12$. Le nombre $k$ détermine le nombre d'oreillers dans $Q(7, -1^{11})$ : il y en a $N_{min}+2k$. Retourne $[r, u]$ sous forme de liste. Remarque sur les conventions : Sur la base on numérote les carreaux de 1 à $2N$. Le carreau $k$ de la base s'indentifie au carreau $2iN+k$ dans la feuille $i$, où $i$ va de $0$ à $d-1$.

def ru(k,d, p0, p1, p2, p3):          # Donner les p_i dans le bon ordre !!! (ou rajouter un test)
    Nmin=N_min(p0, p1, p2, p3)           #nombre minimal d'oreillers pour la base
    N=Nmin+2*k                           #nombre d'oreillers pour la base
    nbr_cyl=(p2+p3)/2                    #nombre minimal de cylindres pour la base
    n=1+2*k                              #nombre de carreaux avant le premier pôle
    s=2*n                                #nombre d'oreillers entourant le premier pôle
    t=s+2*(p1-1)                         #nombre d'oreillers consacrés aux pôles numéro 1 (correspondant à p1)
    ########################################################## cas d'un cylindre :
    if nbr_cyl == 1:
        ############################### degré 0 :
        R0=range(1, 2*N+1)                       
        U0=range(1, 2*N+1)
        for j in range(2*N-1):
            R0[j]=j+2 
        R0[2*N-1]=1                      
        for j in range(N):
            U0[1+2*j]=2*N-2*j-1
        for j in range(n):
            U0[2*j]=2*n-2*j
        for j in range(n, n+p1-1):
            U0[2*j]=2*j+2
        for j in range(n+p1-1, N):
            if (j-(n+p1-1)) % 2 == 0:
                U0[2*j]=2*j+4
            else:
                U0[2*j]=2*j
        r0=Permutation(R0)
        u0=Permutation(U0) 
        invu0=u0.inverse()       
        rr0=Permutation(R0).cycle_string(singletons=True)       #pour vérif
        uu0=Permutation(U0).cycle_string(singletons=True)
        print 'r0=', rr0
        print 'u0=', uu0
        ################################### degré 2 :
        if d==2:
            R=range(1, N+1)
            U=range(1, N+1)
            for j in range(N-1):
                R[j]=j+2
            R[N-1]=1
            for j in range(1, n+1):
                U[j-1]=N-n+j
            for j in range(n+1, n+p1):
                U[j-1]=N-j+1
            for j in range(n+p1, N+1):
                if (j-n-p1) % 2 == 0:
                    U[j-1]=N-j
                else:
                    U[j-1]=N-j+2
        ################################## degré 4, 6, ou 12 :
        if (d ==4) or (d==6) or (d==12):
            R=range(1, 2*d*N+1)
            U=range(1, 2*d*N+1)
            for i in range(d):                                #remplissage de R
                if i%2==1:
                    for j in range(i*2*N+1, (i+1)*2*N):
                        R[j]=j
                    R[2*i*N-1]=((2*(i-3)*N)%(d*2*N))+1
                    R[2*i*N]= (2*(i+3)*N-1)%(d*2*N)+1
                else:
                    for j in range(i*2*N, (i+1)*2*N-1):
                        R[j]=j+2   
            for j in range(2*d*N):                              #remplissage de U
                r=j//(2*N)
                k= j % (2*N) 
                mod=u0[k]                                     #mod : numéro du carreau modulo 2N (numéroté de 1 à 2N)
                if ((k %2==1) and (r%2==0)) or ((k%2==0) and (r%2==1)):
                    mod=invu0[k]
                num=1                                         #num=1 si on va à la feuille supérieure, -1 si inférieure
                if r%2==0:
                    if (k<n) or (((k+1)>s) and (k<t) and ((k-s)%2==0)) or (((k+1)>t) and (((k-t)%4)<2)):
                        num=-1
                else:
                    if k>N-1:
                        num=-1
                U[j]=mod+ ((r+num)%d)*2*N
    r=Permutation(R)
    u=Permutation(U)
    rr=Permutation(R).cycle_string(singletons=True)       #pour vérif
    uu=Permutation(U).cycle_string(singletons=True)
    print 'r=', rr
    print 'u=', uu
    return [r,u]

Test :

v=ru(0,6, 0,9,1,1)

r0= (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18) u0= (1,2,17,18)(3,4,15,16)(5,6,13,14)(7,8,11,12)(9,10) r= (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54)(19,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,108,107,106,105,104,103,102,101,100,99,98,97,96,95,94,93,92,91,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20) u= (1,92,17,108,73,56,89,72,37,20,53,36)(2,19,54,71,38,55,90,107,74,91,18,35)(3,94,15,106,75,58,87,70,39,22,51,34)(4,21,52,69,40,57,88,105,76,93,16,33)(5,96,13,104,77,60,85,68,41,24,49,32)(6,23,50,67,42,59,86,103,78,95,14,31)(7,98,11,102,79,62,83,66,43,26,47,30)(8,25,48,65,44,61,84,101,80,97,12,29)(9,100,81,64,45,28)(10,27,46,63,82,99)