{{{id=60|
#    These are the variables we will use (nothing important).
var('c,i,j,k,ii,jj,kk,pp,qq,rr,dpqr,l,t')
///
(c, i, j, k, ii, jj, kk, pp, qq, rr, dpqr, l, t)
}}}

{{{id=61|
#    Orbits are coded by sequences of 0's and 1's (instead of a and b in the article). 
#    Here are three orbits or period 5, 5 and 7.
gamma1 = [0,0,1,0,1];
gamma2 = [0,1,0,1,1];
gamma3 = [0,0,1,0,1,0,1];
///
}}}

{{{id=10|
#    The function ordrelex implements the lexicographic order on infinite words: it says 0 if the n1-th shift of l1^infty is smaller than the n2-th shift of l2^infty, 1 if it is larger, and 2 if the two words coincide (this can be determined only by looking length(l1)+length(l2) letters since u^infty = v^infty iff uv = vu).
#
def ordrelex(l1, l2, n1, n2):
    i = 0;
    while( (l1[Mod(i+n1,len(l1))] == l2[Mod(i+n2,len(l2))]) & (i <= (len(l1)+len(l2))) ):
        i = i+1;
    if l1[Mod(i+n1,len(l1))] < l2[Mod(i+n2,len(l2))]:
        return 0
    else:
        if l1[Mod(i+n1,len(l1))] > l2[Mod(i+n2,len(l2))]:
            return 1
        else: 
            return 2
///
}}}

{{{id=63|
#    One checks that gamma1 and gamma1 coincice, while gamma1 is smaller than gamma2.
print(ordrelex(gamma1,gamma1,0,0));
print(ordrelex(gamma1,gamma2,0,0));
///
2
0
}}}

{{{id=3|
#    The function cro computes the crossing number of l1 and l2 on the template. It relies on the observation that a crossing occurs when an arc coming from the left ear (the 0) goes to the right of an arc coming from the right ear (the 1).
#
def cro(l1, l2):
    c = 0;
    for i in range(len(l1)):
        for j in range(len(l2)):
            if ( (l1[i] == 0) & (l2[j] == 1) & (ordrelex(l1,l2,i+1,j+1) == 1) ):
                c = c+1;
            if ( (l1[i] == 1) & (l2[j] == 0) & (ordrelex(l1,l2,i+1,j+1) == 0) ):
                c = c+1;
    return c
///
}}}

{{{id=64|
#    One checkes that gamma1 and gamma2 have 8 crossings.
cro(gamma1, gamma2)
///
8
}}}

{{{id=58|
#    n0 and n1 are the number of 0 and 1 respectively.
def n1(l):
    return (sum(l))
def n0(l):
    return (len(l)-n1(l))
///
}}}

{{{id=23|
#    lk compute the linking number on the template Tpqr, using Lemma 2.11.
def lk(l1, l2, p, q, r):
    dpqr = p*q*r - p*q - p*r - q*r;
    return (-cro(l1,l2)/2 + ( (q*r-q-r)*n0(l1)*n0(l2) -r*n0(l1)*n1(l2) -r*n1(l1)*n0(l2) +(p*r-p-r)*n1(l1)*n1(l2) )/dpqr)
///
}}}

{{{id=59|
#    One checks that gamma2 has self-linking number -1 on T23r for any r: this is a manifestation that gamma2 bounds a Birkhoff section of Euler characteristics -1 (see the article Genus one Birkhoff sections for geodesic flows for this statement).
#
lk(gamma2, gamma2, 2, 3, 11)
///
-1
}}}

{{{id=78|
#    Now we want to check the validity of Lemmas 3.7, 3.8, 3.9 and 3.10. We begin by entering the codes of the extremal orbits.
///
}}}

{{{id=54|
#    wij is the word a^i b^j (example with i=2, j=3)
def wij(a,b):
    return list([0 for i in range(a)]) + list([1 for i in range(b)])
wij(2,3)
///
[0, 0, 1, 1, 1]
}}}

{{{id=55|
#    wijk is the word (a^(p-1)b)^k a^i b^j (example with p=4, i=2, j=3, k=2)
def wijk(a,b,c,p):
    l = [];
    for i in range(c):
        l = l + wij(p-1,1);
    l = l + wij(a,b);
    return l
wijk(2,3,2,4)
///
[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1]
}}}

{{{id=65|
#    wijkk is the word (ab^(q-1))^k a^i b^j (example with q=4, i=2, j=3, k=2)
def wijkk(a,b,c,q):
    l = [];
    for i in range(c):
        l = l + wij(1,q-1);
    l = l + wij(a,b);
    return l
wijkk(2,3,2,4)
///
[0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1]
}}}

{{{id=57|
#    wkl is the word (a^(p-1)b)^k (ab^(q-1))^l (example with p=4, q=5, i=2, k=2, l=3)
def wkl(a,b,p,q):
    l = [];
    for i in range(a):
        l = l + wij(p-1,1);
    for i in range(b):
        l = l + wij(1,q-1);
    return l
wkl(2,3,4,5)
///
[0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]
}}}

{{{id=67|
#    An example of linking number (lk may be rational in a Q-HS)
lk(wijk(1,1,1,3),wijkk(2,2,2,3),3,4,4)
///
-3/2
}}}

{{{id=34|
#    lemma37 returns 0 if Lemma 3.7 is true for these values of p,q,r (example with 3, 3, 4)
def lemma37(p,q,r):
    t = 0;
    for k in range (r/2):
        for kk in range (r/2):
            for i in range (1,p):
                for j in range (1,q):
                    if ( ((i,j)!=(1,q-1)) & ((i,j)!=(p-1,1)) ):
                        for ii in range (1,p):
                            for jj in range (1,q):
                                if ( ((ii,jj)!=(1,q-1)) & ((ii,jj)!=(p-1,1)) ):
                                    if lk( wijk(i,j,k,p), wijk(ii,jj,kk,p), p, q, r ) >= 0:
                                        t = 1;
    return t
lemma37(3,3,4)
///
0
}}}

{{{id=41|
#    lemma38 returns 0 if Lemma 3.8 is true for these values of p,q,r (example with 3, 3, 4)
def lemma38(p,q,r):
    t = 0;
    for k in range (r/2):
        for kk in range (r/2):
            for i in range (1,p):
                for j in range (1,q):
                    if ( ((i,j)!=(1,q-1)) & ((i,j)!=(p-1,1)) ):
                        for ii in range (1,p):
                            for jj in range (1,q):
                                if ( ((ii,jj)!=(1,q-1)) & ((ii,jj)!=(p-1,1)) ):
                                    if lk( wijk(i,j,k,p), wijkk(ii,jj,kk,q), p, q, r ) >= 0:
                                        print(i,j,k,ii,jj,kk);
                                        t = 1;
    return t
lemma38(3,3,4)
///
0
}}}

{{{id=45|
#    lemma39 returns 0 if Lemma 3.9 is true for these values of p,q,r (example with 3, 3, 4)
def lemma39(p,q,r):
    t = 0;
    for k in range (1,r/2):
        for kk in range (1,r/2):
            for l in range (1,r/2):
                for ll in range (1,r/2):
                    if lk( wkl(k,l,p,q), wkl(kk,ll,p,q), p, q, r ) >= 0:
                         print(k,l,kk,ll,p,q,r);
                         t = 1;
    return t
lemma39(3,3,4)
///
0
}}}

{{{id=50|
#    lemma310 returns 0 if Lemma 3.10 is true for these values of p,q,r (example with 3, 3, 4)
def lemma310(p,q,r):
    t = 0;
    for k in range (r/2):
        for i in range (1,p):
            for j in range (1,q):
                if ( ((i,j)!=(1,q-1)) & ((i,j)!=(p-1,1)) ):
                    for kk in range (1,r/2):
                        for ll in range (1,r/2):
                            if lk( wijk(i,j,k,p), wkl(kk,ll,p,q), p, q, r ) >= 0:
                                  print(i,j,k,kk,ll,p,q,r);
                                  t = 1;
    return t
lemma310(3,3,4)
///
0
}}}

{{{id=75|
#    Finally test check the four Lemmas for these maximal values of p,q,r.
def test(pmax,qmax,rmax):
    t=0;
    for pp in range(3,pmax+1):
        for qq in range(3,qmax+1):
            for rr in range(4,rmax+1):
                print(pp,qq,rr);
                if lemma37(pp,qq,rr)==1:
                    print(37,pp,qq,rr);
                    t=rr;
                if lemma38(pp,qq,rr)==1:
                    print(38,pp,qq,rr);
                    t=rr;
                if lemma39(pp,qq,rr)==1:
                    print(39,pp,qq,rr);
                    t=rr;
                if lemma310(pp,qq,rr)==1:
                    print(310,pp,qq,rr);
                    t=rr;
    if t==0:
        print('no counter-example: all flows are left-handed')
    else:
        print('We found and counter-example!');
        print(t);
///
}}}

{{{id=79|
#    Here we use test for (pmax,qmax,rmax) = (3,3,4) (time 0.04s), then (4,5,6) (time 15.70s), then (6,8,10) (time 8016s)
///
}}}

{{{id=73|
time test(3,3,4)
///
(3, 3, 4)
no counter-example: all flows are left-handed
Time: CPU 0.04 s, Wall: 0.04 s
}}}

{{{id=76|
time test (4,5,6)
///
(3, 3, 4)
(3, 3, 5)
(3, 3, 6)
(3, 4, 4)
(3, 4, 5)
(3, 4, 6)
(3, 5, 4)
(3, 5, 5)
(3, 5, 6)
(4, 3, 4)
(4, 3, 5)
(4, 3, 6)
(4, 4, 4)
(4, 4, 5)
(4, 4, 6)
(4, 5, 4)
(4, 5, 5)
(4, 5, 6)
no counter-example: all flows are left-handed
Time: CPU 15.70 s, Wall: 15.77 s
}}}

{{{id=103|
time test (6,8,10)
///
WARNING: Output truncated!  
<html><a target='_new' href='/home/admin/17/cells/103/full_output.txt' class='file_link'>full_output.txt</a></html>



(3, 3, 4)
(3, 3, 5)
(3, 3, 6)
(3, 3, 7)
(3, 3, 8)
(3, 3, 9)
(3, 3, 10)
(3, 4, 4)
(3, 4, 5)
(3, 4, 6)
(3, 4, 7)
(3, 4, 8)
(3, 4, 9)
(3, 4, 10)
(3, 5, 4)
(3, 5, 5)
(3, 5, 6)
(3, 5, 7)
(3, 5, 8)
(3, 5, 9)
(3, 5, 10)
(3, 6, 4)
(3, 6, 5)
(3, 6, 6)
(3, 6, 7)
(3, 6, 8)
(3, 6, 9)
(3, 6, 10)
(3, 7, 4)
(3, 7, 5)
(3, 7, 6)
(3, 7, 7)
(3, 7, 8)
(3, 7, 9)
(3, 7, 10)
(3, 8, 4)
(3, 8, 5)
(3, 8, 6)
(3, 8, 7)
(3, 8, 8)
(3, 8, 9)
(3, 8, 10)
(4, 3, 4)
(4, 3, 5)
(4, 3, 6)
(4, 3, 7)
(4, 3, 8)
(4, 3, 9)
(4, 3, 10)
(4, 4, 4)
(4, 4, 5)
(4, 4, 6)
(4, 4, 7)
(4, 4, 8)
(4, 4, 9)
(4, 4, 10)
(4, 5, 4)
(4, 5, 5)
(4, 5, 6)

...

(5, 6, 9)
(5, 6, 10)
(5, 7, 4)
(5, 7, 5)
(5, 7, 6)
(5, 7, 7)
(5, 7, 8)
(5, 7, 9)
(5, 7, 10)
(5, 8, 4)
(5, 8, 5)
(5, 8, 6)
(5, 8, 7)
(5, 8, 8)
(5, 8, 9)
(5, 8, 10)
(6, 3, 4)
(6, 3, 5)
(6, 3, 6)
(6, 3, 7)
(6, 3, 8)
(6, 3, 9)
(6, 3, 10)
(6, 4, 4)
(6, 4, 5)
(6, 4, 6)
(6, 4, 7)
(6, 4, 8)
(6, 4, 9)
(6, 4, 10)
(6, 5, 4)
(6, 5, 5)
(6, 5, 6)
(6, 5, 7)
(6, 5, 8)
(6, 5, 9)
(6, 5, 10)
(6, 6, 4)
(6, 6, 5)
(6, 6, 6)
(6, 6, 7)
(6, 6, 8)
(6, 6, 9)
(6, 6, 10)
(6, 7, 4)
(6, 7, 5)
(6, 7, 6)
(6, 7, 7)
(6, 7, 8)
(6, 7, 9)
(6, 7, 10)
(6, 8, 4)
(6, 8, 5)
(6, 8, 6)
(6, 8, 7)
(6, 8, 8)
(6, 8, 9)
(6, 8, 10)
no counter-example: all flows are left-handed
Time: CPU 8015.94 s, Wall: 8032.32 s
}}}

{{{id=77|
#    Now we want to deal with the case p=2.
///
}}}

{{{id=80|
#    xi is the word ab^i (example with i=3)
def xi(a):
    return wij(1,a)
xi(3)
///
[0, 1, 1, 1]
}}}

{{{id=81|
#    xik is the word (ab)^ka b^i (example with q=4, i=1, k=2)
def xik(a,b,q):
    l = [];
    for i in range(b):
        l = l + wij(1,1);
    l = l + xi(a);
    return l
xik(1,2,4)
///
[0, 1, 0, 1, 0, 1]
}}}

{{{id=83|
#    yik is the word (ab^(q-1))^ka b^i (example with q=4, i=1, k=2)
def yik(a,b,q):
    l = [];
    for i in range(b):
        l = l + wij(1,q-1);
    l = l + xi(a);
    return l
yik(1,2,4)
///
[0, 1, 1, 1, 0, 1, 1, 1, 0, 1]
}}}

{{{id=84|
#    zkl is the word (ab)^k(ab^(q-1))^l (example with q=4, k=2, l=3)
def zkl(a,b,q):
    l = [];
    for i in range(a):
        l = l + wij(1,1);
    for i in range(b):
        l = l + wij(1,q-1);
    return l
zkl(2,3,4)
///
[0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1]
}}}

{{{id=87|
#    lemma312 returns 0 if Lemma 3.12 is true for these q,r (q>3 for the statement to be non-empty, example with 4,5)
def lemma312(q,r):
    t = 0;
    for k in range ((r-1)/2):
        for kk in range ((r-1)/2):
            for i in range (2,q-1):
                for ii in range (2,q-1):
                    if lk( xik(i,k,q), xik(ii,kk,q), 2, q, r ) >= 0:
                         print(i,k,ii,kk,q,r);
                         t = 1;
    return t
lemma312(4,5)
///
0
}}}

{{{id=91|
#    lemma313 returns 0 if Lemma 3.13 is true for these q,r (q>3 for the statement to be non-empty, example with 4,5)
def lemma313(q,r):
    t = 0;
    for k in range ((r-1)/2):
        for kk in range ((r-1)/2):
            for i in range (2,q-1):
                for ii in range (2,q-1):
                    if lk( xik(i,k,q), yik(ii,kk,q), 2, q, r ) >= 0:
                         print(i,k,ii,kk,q,r);
                         t = 1;
    return t
lemma313(4,5)
///
0
}}}

{{{id=89|
#    lemma314 returns 0 if Lemma 3.14 is true for these q,r (example with 4,5)
def lemma314(q,r):
    t = 0;
    for k in range ((r-1)/2):
        for kk in range (1,(r-1)/2):
            for i in range (2,q-1):
                for ll in range (1,(r-1)/2):
                    if lk( xik(i,k,q), zkl(kk,ll,q), 2, q, r ) >= 0:
                         print(i,k,kk,ll,q,r);
                         t = 1;
    return t
lemma314(8,8)
///
0
}}}

{{{id=92|
#    lemma315 returns 0 if Lemma 3.15 is true for these q,r (example with 3,7)
def lemma315(q,r):
    t = 0;
    for k in range (1,(r-1)/2):
        for kk in range (1,(r-1)/2):
            for l in range (1,(r-1)/2):
                for ll in range (1,(r-1)/2):
                    if lk( zkl(k,l,q), zkl(kk,ll,q), 2, q, r ) >= 0:
                         print(k,l,kk,ll,q,r);
                         t = 1;
    return t
lemma315(4,8)
///
0
}}}

{{{id=93|
#    Now test23r check the four Lemmas for these maximal values of p=2,q=3,r<=rmax.
def test23r(rmax):
    t=0;
    for rr in range(7,rmax+1):
        print (2,3,rr);
        if lemma315(3,rr)==1:
            t=rr;
            print('We found a counter-example!');
    if t==0:
        print('no counter-example: all flows are left-handed')
///
}}}

{{{id=94|
time test23r(12)
///
(2, 3, 7)
(2, 3, 8)
(2, 3, 9)
(2, 3, 10)
(2, 3, 11)
(2, 3, 12)
no counter-example: all flows are left-handed
Time: CPU 4.47 s, Wall: 4.47 s
}}}

{{{id=95|
#    Finally test2qr check the four Lemmas for these maximal values of p=2,q<=qmax,r<=rmax.
def test2qr(qmax,rmax):
    t=0;
    for qq in range(4,qmax+1):
        for rr in range(5,rmax+1):
            print (2,qq,rr);
            if lemma312(qq,rr)==1:
                t=qq;
                print('We found a counter-example!');
            if lemma313(qq,rr)==1:
                t=qq;
                print('We found a counter-example!');
            if lemma314(qq,rr)==1:
                t=qq;
                print('We found a counter-example!');
            if lemma315(qq,rr)==1:
                t=qq;
                print('We found a counter-example!');
    if t==0:
        print('no counter-example: all flows are left-handed')
    else:
        print(t);
///
}}}

{{{id=96|
time test2qr(4,10)
///
(2, 4, 5)
(2, 4, 6)
(2, 4, 7)
(2, 4, 8)
(2, 4, 9)
(2, 4, 10)
no counter-example: all flows are left-handed
Time: CPU 1.58 s, Wall: 1.58 s
}}}

{{{id=116|
time test2qr(10,14)
///
(2, 4, 5)
(2, 4, 6)
(2, 4, 7)
(2, 4, 8)
(2, 4, 9)
(2, 4, 10)
(2, 4, 11)
(2, 4, 12)
(2, 4, 13)
(2, 4, 14)
(2, 5, 5)
(2, 5, 6)
(2, 5, 7)
(2, 5, 8)
(2, 5, 9)
(2, 5, 10)
(2, 5, 11)
(2, 5, 12)
(2, 5, 13)
(2, 5, 14)
(2, 6, 5)
(2, 6, 6)
(2, 6, 7)
(2, 6, 8)
(2, 6, 9)
(2, 6, 10)
(2, 6, 11)
(2, 6, 12)
(2, 6, 13)
(2, 6, 14)
(2, 7, 5)
(2, 7, 6)
(2, 7, 7)
(2, 7, 8)
(2, 7, 9)
(2, 7, 10)
(2, 7, 11)
(2, 7, 12)
(2, 7, 13)
(2, 7, 14)
(2, 8, 5)
(2, 8, 6)
(2, 8, 7)
(2, 8, 8)
(2, 8, 9)
(2, 8, 10)
(2, 8, 11)
(2, 8, 12)
(2, 8, 13)
(2, 8, 14)
(2, 9, 5)
(2, 9, 6)
(2, 9, 7)
(2, 9, 8)
(2, 9, 9)
(2, 9, 10)
(2, 9, 11)
(2, 9, 12)
(2, 9, 13)
(2, 9, 14)
(2, 10, 5)
(2, 10, 6)
(2, 10, 7)
(2, 10, 8)
(2, 10, 9)
(2, 10, 10)
(2, 10, 11)
(2, 10, 12)
(2, 10, 13)
(2, 10, 14)
no counter-example: all flows are left-handed
Time: CPU 951.95 s, Wall: 956.38 s
}}}

{{{id=117|

///
}}}