Gedichte Musik Bilder Quellcodebibliothek Diashow Normaldarstellung
Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/tst/testinstall/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 18.9.2025 mit Größe 123 kB image not shown  

Quelle  pperm.tst   Sprache: unbekannt

 
#@local display,e,f,g,h,i,notationpp,notationt,p,x,PPerm4,Perm4,im,coll,p1,p2
##
## takes around 4 seconds to run

#
gap> START_TEST("pperm.tst");
gap> display:=UserPreference("PartialPermDisplayLimit");;
gap> notationpp:=UserPreference("NotationForPartialPerms");;
gap> notationt:=UserPreference("NotationForTransformations");;
gap> SetUserPreference("PartialPermDisplayLimit", 100);;
gap> SetUserPreference("NotationForPartialPerms", "component");;
gap> SetUserPreference("NotationForTransformations", "fr");;

# Some helper functions
gap> PPerm4 := function(arg)
>   local out, e;
>   if Length(arg) = 1 then 
>     e := LeftOne(PartialPerm(arg[1]));
>     Add(arg[1], 65536);
>     return e * PartialPerm(arg[1]);
>   else 
>     Add(arg[2], 65536 + Length(arg[1]));
>     out := PartialPerm(arg[1], [65536 .. 65536 + Length(arg[1]) - 1]) * 
>            PartialPerm([65536 .. 65536 + Length(arg[1])], arg[2]);
>     DomainOfPartialPerm(out);
>     return out;
>   fi;
> end;;
gap> Perm4 := function(p)
> return p * ((1, 65537) * (1, 65537));
> end;;

# GAP-level functions
#
gap> f:=PartialPerm( [ 4, 5, 7, 8 ], [ 5, 4, 1, 6 ] );
[7,1][8,6](4,5)
gap> g:=PartialPerm([2]);;
gap> NaturalLeqPartialPerm(g, f);
false
gap> g:=PartialPerm([0,0,0,0,4]);;
gap> NaturalLeqPartialPerm(g, f);
true

#
gap> f:=EmptyPartialPerm();;
gap> ImageSetOfPartialPerm(f);
[  ]
gap> ImageListOfPartialPerm(f);
[  ]
gap> f:=EmptyPartialPerm()^-1;;
gap> ImageSetOfPartialPerm(f);
[  ]
gap> ImageListOfPartialPerm(f);
[  ]
gap> IMAGE_SET_PPERM(fail);
Error, IMAGE_SET_PPERM: <f> must be a partial permutation (not the value 'fail\
')

# test input validation
gap> DegreeOfPartialPerm(fail);
Error, DegreeOfPartialPerm: <f> must be a partial permutation (not the value '\
fail')
gap> CoDegreeOfPartialPerm(fail);
Error, CoDegreeOfPartialPerm: <f> must be a partial permutation (not the value\
 'fail')
gap> RankOfPartialPerm(fail);
Error, RankOfPartialPerm: <f> must be a partial permutation (not the value 'fa\
il')
gap> 

# SmallestIdempotentPower, IndexPeriodOfPartialPerm, IsIdempotent
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> IsIdempotent(f^SmallestIdempotentPower(f));
true
gap> x:=IndexPeriodOfPartialPerm(f);;
gap> f^x[1]=f^(x[1]+x[2]);
true
gap> RankOfPartialPerm(f^(x[1]-1))>RankOfPartialPerm(f^x[1]);
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> IsIdempotent(f^SmallestIdempotentPower(f));
true
gap> x:=IndexPeriodOfPartialPerm(f);;
gap> f^x[1]=f^(x[1]+x[2]);
true
gap> RankOfPartialPerm(f^(x[1]-1))>RankOfPartialPerm(f^x[1]);
true
gap> f:=PartialPerm([1, 1000], [1000, 2]);;
gap> IsIdempotent(f^SmallestIdempotentPower(f));
true
gap> x:=IndexPeriodOfPartialPerm(f);;
gap> f^x[1]=f^(x[1]+x[2]);
true
gap> RankOfPartialPerm(f^(x[1]-1))>RankOfPartialPerm(f^x[1]);
true
gap> f:=PartialPermNC( [ 1, 2, 3, 4, 6, 7, 8, 10, 12, 14 ], 
> [ 15, 11, 5, 8, 9, 3, 6, 2, 4, 1 ] );;
gap> IndexPeriodOfPartialPerm(f);
[ 5, 1 ]
gap> f^5=f^6;
true
gap> f^5;
<empty partial perm>
gap> f^6;
<empty partial perm>
gap> f^4;                                                    
[12,9]
gap> f := PartialPerm( [ 1, 2, 3 ], [ 70000, 3, 4 ] );
[1,70000][2,3,4]
gap> IsIdempotent(f);
false
gap> f:=PartialPermNC([1..10]);;   
gap> IsIdempotent(f);
true
gap> f:=PartialPermNC([1..10]); 
<identity partial perm on [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]>
gap> IsIdempotent(f);
true
gap> f:=PartialPerm( [ 1, 2 ], [ 3, 1 ] );;
gap> IsIdempotent(f);
false
gap> f:=PartialPermNC([1..100000]); 
<partial perm on 100000 pts with degree 100000, codegree 100000>
gap> IsIdempotent(f);
true
gap> f:=PartialPermNC([1..100000]);;
gap> IsIdempotent(f);
true
gap> f := PartialPerm([], []);
<empty partial perm>
gap> IndexPeriodOfPartialPerm(f);
[ 1, 1 ]
gap> SmallestIdempotentPower(f);
1
gap> f:=PartialPerm([2,3,1,5,6,7,8,4,10]);
[9,10](1,2,3)(4,5,6,7,8)
gap> SmallestIdempotentPower(f);
15
gap> IndexPeriodOfPartialPerm(f);
[ 2, 15 ]
gap> IsIdempotent(f);
false
gap> IndexPeriodOfPartialPerm(PartialPerm([1, 2, 10 ^ 5], [2, 10 ^ 5, 1]));
[ 1, 3 ]
gap> IsIdempotent(PartialPerm([2,3,1,5,6,7,8,4,10]));
false
gap> IsIdempotent(PartialPermNC([1 .. 70000] + 1));
false

# ComponentsOfPartialPerm, NrComponentsOfPartialPerm, 
# ComponentRepsOfPartialPerm and ComponentPartialPermInt
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> NrComponentsOfPartialPerm(f)=Length(ComponentsOfPartialPerm(f));
true
gap> Union(ComponentsOfPartialPerm(f))=Union(DomainOfPartialPerm(f), 
> ImageSetOfPartialPerm(f));
true
gap> List(ComponentRepsOfPartialPerm(f), i-> ComponentPartialPermInt(f, i))
> =ComponentsOfPartialPerm(f);
true
gap> f:=PartialPerm([1, 100], [100, 2]);;
gap> NrComponentsOfPartialPerm(f)=Length(ComponentsOfPartialPerm(f));
true
gap> Union(ComponentsOfPartialPerm(f))=Union(DomainOfPartialPerm(f), 
> ImageSetOfPartialPerm(f));
true
gap> List(ComponentRepsOfPartialPerm(f), i-> ComponentPartialPermInt(f, i))
> =ComponentsOfPartialPerm(f);
true
gap> f := PartialPerm([], []);
<empty partial perm>
gap> ComponentsOfPartialPerm(f);
[  ]
gap> ComponentRepsOfPartialPerm(f);
[  ]
gap> NrComponentsOfPartialPerm(f);
0
gap> f:=PartialPerm([2,3,1,5,6,7,8,4,10]);
[9,10](1,2,3)(4,5,6,7,8)
gap> ComponentsOfPartialPerm(f);
[ [ 9, 10 ], [ 1, 2, 3 ], [ 4, 5, 6, 7, 8 ] ]
gap> ComponentRepsOfPartialPerm(f);
[ 9, 1, 4 ]
gap> NrComponentsOfPartialPerm(f);
3
gap> ComponentRepsOfPartialPerm(PartialPerm([1, 2, 10 ^ 5], [2, 10 ^ 5, 1]));
[ 1 ]
gap> NrComponentsOfPartialPerm(PartialPerm([1, 2, 10 ^ 5], [2, 10 ^ 5, 1]));
1
gap> ComponentsOfPartialPerm(PartialPerm([1, 2, 10 ^ 5], [2, 10 ^ 5, 1]));
[ [ 1, 2, 100000 ] ]
gap> ComponentPartialPermInt(PartialPerm([1, 2, 10 ^ 5], [2, 10 ^ 5, 1]),
>                              100000);
[ 100000, 1, 2 ]
gap> ComponentPartialPermInt(PartialPerm([1, 2, 10 ^ 5], [2, 10 ^ 5, 1]),
>                              1000);
[  ]
gap> ComponentPartialPermInt(PartialPerm([1, 3], [3, 1]),
>                              1000);
[  ]
gap> ComponentPartialPermInt(PartialPerm([1, 2], [2, 1]),
>                              2);
[ 2, 1 ]

# FixedPointsOfPartialPerm, MovedPoints, 
# NrFixedPoints, NrMovedPoints
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> FixedPointsOfPartialPerm(f)=
> Filtered([1..DegreeOfPartialPerm(f)], i-> i^f=i);
true
gap> f:=PartialPermNC([1..100000]);
<partial perm on 100000 pts with degree 100000, codegree 100000>
gap> FixedPointsOfPartialPerm(f)=[1..100000];
true
gap> f:=PartialPerm( [ 1, 2, 3, 4, 5, 6, 7, 9, 11, 12, 15, 16, 19 ],
> [ 2, 4, 11, 1, 20, 10, 15, 16, 5, 3, 6, 12, 9 ] );;
gap> FixedPointsOfPartialPerm(f)=
> Filtered([1..DegreeOfPartialPerm(f)], i-> i^f=i);
true
gap> f:=PartialPerm( [ 1, 2, 3, 4, 5, 6, 7, 9, 11, 12, 15, 16, 19 ],
> [ 2, 4, 11, 1, 20, 10, 15, 16, 5, 3, 6, 12, 9 ] );;
gap> DomainOfPartialPerm(f);;
gap> FixedPointsOfPartialPerm(f)=
> Filtered([1..DegreeOfPartialPerm(f)], i-> i^f=i);
true
gap> NrFixedPoints(f);
0
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> NrMovedPoints(f)+NrFixedPoints(f)=
> RankOfPartialPerm(f);
true
gap> Union(MovedPoints(f), FixedPointsOfPartialPerm(f))=
> DomainOfPartialPerm(f);
true
gap> Intersection(MovedPoints(f), FixedPointsOfPartialPerm(f));
[  ]
gap> f:=PartialPerm([1, 100], [100, 2]);;
gap> NrMovedPoints(f)+NrFixedPoints(f)=
> RankOfPartialPerm(f);
true
gap> Union(MovedPoints(f), FixedPointsOfPartialPerm(f))=
> DomainOfPartialPerm(f);
true
gap> Intersection(MovedPoints(f), FixedPointsOfPartialPerm(f));
[  ]
gap> f := PartialPerm(List([69950 .. 70000], function(x) 
>   if IsEvenInt(x) then 
>     return 0;
>   else
>     return x;
>   fi;
> end));;
gap> FixedPointsOfPartialPerm(f);
[  ]
gap> NrFixedPoints(f);
0
gap> MovedPoints(f);
[ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 
  42, 44, 46, 48, 50 ]
gap> NrMovedPoints(f);
25
gap> im := ListWithIdenticalEntries(70000, 0);;
gap> im[65536] := 65536;
65536
gap> f := PartialPerm(im);;
gap> FixedPointsOfPartialPerm(f);
[ 65536 ]
gap> NrFixedPoints(f);
1
gap> MovedPoints(f);
[  ]
gap> NrMovedPoints(f);
0
gap> f := PartialPerm(List([7950 .. 8000], function(x) 
>   if IsEvenInt(x) then 
>     return 0;
>   else
>     return x;
>   fi;
> end));;
gap> FixedPointsOfPartialPerm(f);
[  ]
gap> NrFixedPoints(f);
0
gap> MovedPoints(f);
[ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 
  42, 44, 46, 48, 50 ]
gap> NrMovedPoints(f);
25
gap> f := PartialPerm(List([1 .. 100], function(x) 
>   if IsEvenInt(x) then 
>     return 0;
>   else
>     return x;
>   fi;
> end));;
gap> FixedPointsOfPartialPerm(f);
[ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 
  41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 
  79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99 ]
gap> NrFixedPoints(f);
50
gap> MovedPoints(f);
[  ]
gap> NrMovedPoints(f);
0
gap> f := PartialPerm([1, 3 .. 99], [1, 3 .. 99]);;
gap> FixedPointsOfPartialPerm(f);
[ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 
  41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 
  79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99 ]
gap> NrFixedPoints(f);
50
gap> MovedPoints(f);
[  ]
gap> NrMovedPoints(f);
0
gap> f := PartialPerm([70001, 70003 .. 70099], [70001, 70003 .. 70099]);;
gap> FixedPointsOfPartialPerm(f);
[ 70001, 70003, 70005, 70007, 70009, 70011, 70013, 70015, 70017, 70019, 
  70021, 70023, 70025, 70027, 70029, 70031, 70033, 70035, 70037, 70039, 
  70041, 70043, 70045, 70047, 70049, 70051, 70053, 70055, 70057, 70059, 
  70061, 70063, 70065, 70067, 70069, 70071, 70073, 70075, 70077, 70079, 
  70081, 70083, 70085, 70087, 70089, 70091, 70093, 70095, 70097, 70099 ]
gap> NrFixedPoints(f);
50
gap> MovedPoints(f);
[  ]

# LargestMovedPoint, SmallestMovedPoint
gap> f:=PartialPerm([1, 100000], [100000, 2]);; DomainOfPartialPerm(f);;
gap> i:=LargestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> i:=LargestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPerm([1, 100], [100, 2]);;   DomainOfPartialPerm(f);;
gap> i:=LargestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPerm([1, 100], [100, 2]);;
gap> i:=LargestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPermNC([1..100]);;
gap> LargestMovedPoint(f);
0
gap> f:=PartialPermNC([1..100]); 
<partial perm on 100 pts with degree 100, codegree 100>
gap> LargestMovedPoint(f);
0
gap> f:=PartialPermNC([4,2,3]);; DomainOfPartialPerm(f);;
gap> LargestMovedPoint(f);
1
gap> f:=PartialPermNC([4,2,3]);; 
gap> LargestMovedPoint(f);
1
gap> f:=PartialPermNC(Concatenation([100001], [2..100000]));
<partial perm on 100000 pts with degree 100000, codegree 100001>
gap> LargestMovedPoint(f);
1
gap> f:=PartialPermNC(Concatenation([100001], [2..100000]));;
gap> LargestMovedPoint(f);
1
gap> f:=PartialPermNC([1..100000]);                          
<partial perm on 100000 pts with degree 100000, codegree 100000>
gap> LargestMovedPoint(f);
0
gap> f:=PartialPerm([1, 100000], [100000, 2]);; DomainOfPartialPerm(f);;
gap> i:=SmallestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> i:=SmallestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPerm([1, 100], [100, 2]);;   DomainOfPartialPerm(f);;
gap> i:=SmallestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPerm([1, 100], [100, 2]);;
gap> i:=SmallestMovedPoint(f);;
gap> i^f<>i;
true
gap> f:=PartialPermNC([1..100]);;
gap> SmallestMovedPoint(f);
infinity
gap> f:=PartialPermNC([1..100]); 
<partial perm on 100 pts with degree 100, codegree 100>
gap> SmallestMovedPoint(f);
infinity
gap> f:=PartialPermNC([4,2,3]);; DomainOfPartialPerm(f);;
gap> SmallestMovedPoint(f);
1
gap> f:=PartialPermNC([4,2,3]);; 
gap> SmallestMovedPoint(f);
1
gap> f:=PartialPermNC(Concatenation([100001], [2..100000]));
<partial perm on 100000 pts with degree 100000, codegree 100001>
gap> SmallestMovedPoint(f);
1
gap> f:=PartialPermNC(Concatenation([100001], [2..100000]));;
gap> SmallestMovedPoint(f);
1
gap> f:=PartialPermNC([1..70000]);;
gap> SmallestMovedPoint(f);
infinity
gap> LargestMovedPoint(f);
0
gap> f := PartialPermNC([1 .. 10]);;
gap> SmallestMovedPoint(f);
infinity
gap> f := PartialPermNC([1 .. 10], [1 .. 10]);;
gap> SmallestMovedPoint(f);
infinity
gap> SmallestMovedPoint(PartialPerm([69999, 70001], [69999, 70001]));
infinity

# TRIM_PPERM
gap> f:=PartialPermNC([65536]); 
[1,65536]
gap> TRIM_PPERM(f);
[1,65536]
gap> g:=PartialPermNC([2,65536], [70000,1]);           
[2,70000][65536,1]
gap> h:=f*g;
<identity partial perm on [ 1 ]>
gap> IsPPerm4Rep(h);
true
gap> TRIM_PPERM(h); h;
<identity partial perm on [ 1 ]>
gap> IsPPerm2Rep(h);
true
gap> h:=f*g;;
gap> IsPPerm4Rep(h);
true
gap> TRIM_PPERM(h); h;
<identity partial perm on [ 1 ]>
gap> IsPPerm2Rep(h);
true

# HashFuncForPPerm and HASH_FUNC_FOR_PPERM
gap> f := PartialPerm([65536]);;
#@if GAPInfo.BytesPerVariable = 8
gap> HASH_FUNC_FOR_PPERM(f, 10 ^ 6) in [260581, 402746];
true
#@else
gap> HASH_FUNC_FOR_PPERM(f, 10 ^ 6);
953600
#@fi
gap> f := PartialPermNC([65535]);;
#@if GAPInfo.BytesPerVariable = 8
gap> HASH_FUNC_FOR_PPERM(f, 10 ^ 6);
354405
#@else
gap> HASH_FUNC_FOR_PPERM(f, 10 ^ 6);
287798
#@fi
gap> f := PartialPerm([1, 2, 3, 4, 5, 6, 7, 9, 11, 12, 15, 16, 19],
>                     [2, 4, 11, 1, 20, 10, 15, 16, 5, 3, 6, 12, 9]);;
#@if GAPInfo.BytesPerVariable = 8
gap> HASH_FUNC_FOR_PPERM(f, 10 ^ 6) in [773594, 109657];
true
#@else
gap> HASH_FUNC_FOR_PPERM(f, 10 ^ 6) in [982764, 570602];
true
#@fi
gap> f := PartialPermNC([65536]);;
gap> g := PartialPermNC([2, 65536], [70000, 1]);;
gap> h := f * g;
<identity partial perm on [ 1 ]>
gap> IsPPerm4Rep(h);
true
#@if GAPInfo.BytesPerVariable = 8
gap> HASH_FUNC_FOR_PPERM(h, 10 ^ 6) in [567548, 351540];
true
#@else
gap> HASH_FUNC_FOR_PPERM(h, 10 ^ 6) in [464636, 754304];
true
#@fi
gap> IsPPerm2Rep(h);
true

# LeftOne
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );;
> DomainOfPartialPerm(f);;
gap> e:=LeftOne(f);;
gap> IsIdempotent(e);
true
gap> e*f=f;
true
gap> DomainOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> ImageListOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );;
gap> e:=LeftOne(f);;
gap> IsIdempotent(e);
true
gap> e*f=f;         
true
gap> DomainOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> ImageListOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> e:=LeftOne(f);;
gap> IsIdempotent(e);
true
gap> e*f=f;         
true
gap> DomainOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> ImageListOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);; DomainOfPartialPerm(f);;
gap> e:=LeftOne(f);;
gap> IsIdempotent(e);
true
gap> e*f=f;
true
gap> DomainOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> ImageListOfPartialPerm(e)=DomainOfPartialPerm(f);
true
gap> f:=PartialPermNC([65536], [1]);
[65536,1]
gap> e:=LeftOne(f);
<identity partial perm on [ 65536 ]>
gap> e*f=f;
true
gap> f:=PartialPermNC([1], [65536]);
[1,65536]
gap> e:=LeftOne(f);
<identity partial perm on [ 1 ]>
gap> e*f=f;
true

#RightOne
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );; ImageSetOfPartialPerm(f);;
gap> e:=RightOne(f);;
gap> IsIdempotent(e);
true
gap> f*e=f;
true
gap> ImageListOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> DomainOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );; 
gap> e:=RightOne(f);;
gap> IsIdempotent(e);
true
gap> f*e=f;
true
gap> ImageListOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> DomainOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);; ImageSetOfPartialPerm(f);;
gap> e:=RightOne(f);;
gap> IsIdempotent(e);
true
gap> f*e=f;
true
gap> ImageListOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> DomainOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);; 
gap> e:=RightOne(f);;
gap> IsIdempotent(e);
true
gap> f*e=f;
true
gap> ImageListOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> DomainOfPartialPerm(e)=ImageSetOfPartialPerm(f);
true
gap> f:=PartialPermNC([65536], [1]);
[65536,1]
gap> e:=RightOne(f);
<identity partial perm on [ 1 ]>
gap> f*e=f;
true
gap> f:=PartialPermNC([1], [65536]);
[1,65536]
gap> e:=RightOne(f);
<identity partial perm on [ 65536 ]>
gap> f*e=f;
true

# NaturalLeqPartialPerm
gap> f:=PartialPermNC([1], [65536]);
[1,65536]
gap> NaturalLeqPartialPerm(f,f);
true
gap> g:=PartialPermNC([1,2], [65536,4]);
[1,65536][2,4]
gap> NaturalLeqPartialPerm(f,g);
true
gap> NaturalLeqPartialPerm(g,f);
false
gap> f:=PartialPermNC([1], [10]);                               
[1,10]
gap> g:=PartialPermNC([1,2], [10,4]);   
[1,10][2,4]
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:=PartialPerm( [ 1, 2, 3, 4, 6, 7, 8, 10 ], 
> [ 3, 8, 1, 9, 4, 10, 5, 6 ] );; 
gap> DomainOfPartialPerm(g);;
gap> NaturalLeqPartialPerm(f,g);
false
gap> g:=PartialPermNC([1,2], [10,100000]);
[1,10][2,100000]
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:=       
> PartialPerm( [ 1, 2, 4, 6, 8, 9 ], 
> [ 42760, 64197, 33426, 57309, 17780, 69833 ] );
[1,42760][2,64197][4,33426][6,57309][8,17780][9,69833]
gap> NaturalLeqPartialPerm(f,g);
false
gap> f:=PartialPermNC([1,0,0,0,0,10]);;
gap> NaturalLeqPartialPerm(f,g);
false
gap> g:=PartialPermNC([1,5,6], [1,10,100000]);
[5,10][6,100000](1)
gap> NaturalLeqPartialPerm(f,g);
false
gap> g:=PartialPermNC([1,6,7], [1,10,100000]);
[6,10][7,100000](1)
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:=PartialPermNC([1,6,7], [1,10,1000]);  
[6,10][7,1000](1)
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:= 
> PartialPerm( [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 
>    19, 20, 21, 22, 23, 25, 26, 27, 29, 30, 32, 33, 34, 35, 37, 40, 42, 47, 
>    48, 49, 50, 51, 52, 53, 56, 57, 59, 62, 63, 66, 67, 69, 70, 75, 76, 78, 
>    80, 84, 87, 88, 89, 93, 96 ], 
> [ 66, 52, 4, 5, 62, 49, 97, 86, 41, 48, 28, 2, 60, 69, 77, 96, 47, 67, 1, 
>    88, 100, 32, 16, 71, 63, 64, 94, 29, 46, 22, 51, 3, 31, 9, 38, 81, 30, 
>    87, 98, 17, 82, 85, 90, 33, 89, 74, 50, 80, 35, 36, 27, 54, 73, 20, 40, 
>    57, 92, 34, 8, 99, 25 ] );;
gap> NaturalLeqPartialPerm(f,g);
false
gap> f:=PartialPermNC([1],[100000]);;  
gap> f:=PartialPermNC([1],[100000]); 
[1,100000]
gap> f:=PartialPermNC([1],[100000])*PartialPermNC([100000], [2]);
[1,2]
gap> IsPPerm4Rep(f);
false
gap> f:=PartialPermNC([1],[100000])*PartialPermNC([1,100000], [100000,2]);
[1,2]
gap> IsPPerm4Rep(f);
true
gap> g:=PartialPermNC([1,2],[2,3]);
[1,2,3]
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:=
> PartialPerm( [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 
>     20, 21, 22, 23, 27, 28, 29, 30, 31, 32, 33, 34, 35, 38, 39, 40, 41, 42, 
>     45, 46, 49, 52, 53, 54, 56, 58, 59, 60, 66, 71, 72, 73, 74, 75, 77, 79, 
>     80, 85, 86, 92, 93, 96 ], 
>  [ 26, 38, 18, 89, 41, 54, 85, 59, 24, 95, 35, 64, 25, 32, 21, 23, 94, 28, 
>     79, 31, 46, 22, 75, 27, 42, 20, 73, 3, 7, 37, 14, 65, 78, 1, 76, 15, 57, 
>     66, 49, 16, 19, 74, 52, 71, 72, 2, 86, 80, 40, 44, 4, 62, 47, 81, 58, 50, 
>     9, 61, 43, 10 ] );;
gap> NaturalLeqPartialPerm(f,g);
false
gap> f:=PartialPermNC([1],[100000]);                                      
[1,100000]
gap> g:=PartialPermNC([1,2,3], [100000,4,5]);;;
gap> g;
[1,100000][2,4][3,5]
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:=
> PartialPerm( [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 
>     20, 21, 22, 25, 26, 27, 28, 29, 31, 32, 34, 35, 37, 40, 43, 44, 46, 48, 
>     50, 51, 52, 54, 55, 56, 57, 59, 60, 61, 63, 64, 65, 66, 67, 69, 71, 76, 
>     78, 79, 80, 81, 83, 85, 86, 88, 89, 90, 92, 93, 95, 96, 97, 99 ], 
>  [ 12, 67, 52, 69, 96, 43, 38, 58, 72, 99, 87, 33, 22, 7, 35, 89, 15, 42, 77, 
>     3, 70, 39, 34, 25, 81, 83, 88, 30, 97, 64, 36, 17, 14, 26, 51, 55, 11, 
>     10, 1, 59, 75, 71, 93, 44, 74, 4, 5, 63, 31, 32, 85, 53, 66, 94, 46, 27, 
>     68, 100, 86, 8, 90, 65, 47, 48, 45, 29, 57, 82, 92, 24 ] );;
gap> NaturalLeqPartialPerm(f,g);   
false
gap> f:=PartialPermNC([100000]);;   
gap> g:=PartialPermNC([1,2,3], [100000,4,5]);;;
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:=
> PartialPerm( [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 
>     21, 22, 24, 25, 26, 27, 28, 29, 31, 34, 36, 37, 38, 39, 41, 44, 46, 47, 
>     48, 51, 55, 56, 57, 58, 61, 62, 63, 64, 66, 67, 68, 69, 71, 72, 73, 74, 
>     75, 76, 77, 81, 82, 83, 94, 96, 98 ], 
>  [ 86243, 24019, 92473, 44160, 93892, 22630, 39783, 61399, 99288, 31825, 
>     60250, 46007, 6674, 24575, 47097, 15055, 21177, 64280, 53747, 63362, 
>     9651, 76666, 33684, 42123, 38956, 87858, 92587, 4775, 38450, 95306, 
>     48164, 84693, 59170, 65070, 24314, 31294, 54766, 39401, 76714, 86853, 
>     80503, 6128, 29087, 32355, 40641, 62259, 86547, 68053, 36450, 15562, 
>     44576, 37896, 62646, 55753, 21232, 56275, 32817, 52357, 64985, 82822, 
>     78412, 65577, 68433 ] );;
gap> NaturalLeqPartialPerm(f,g);    
false
gap> f:=PartialPermNC([1],[100000])*PartialPermNC([1,100000], [100000,2]);
[1,2]
gap> IsPPerm4Rep(f);
true
gap> g:=PartialPermNC([1,2],[2,3]);            
[1,2,3]
gap> f:=PartialPermNC([100000])*PartialPermNC([1,100000], [100000,2]);;     
gap> IsPPerm4Rep(f);
true
gap> NaturalLeqPartialPerm(f,g);
true
gap> g:=PartialPerm( [ 1, 3 ], [ 3, 1 ] );;     
gap> NaturalLeqPartialPerm(f,g);
false
gap> NaturalLeqPartialPerm(fail, f);
Error, NaturalLeqPartialPerm: <f> must be a partial permutation (not the value\
 'fail')
gap> NaturalLeqPartialPerm(EmptyPartialPerm(), f);
true

# AsPartialPerm
gap> p:=(1,2,7,5)(3,9)(6,10,8);;
gap> f:=AsPartialPerm(p);       
(1,2,7,5)(3,9)(4)(6,10,8)
gap> f:=AsPartialPerm(p,11);
(1,2,7,5)(3,9)(4)(6,10,8)(11)
gap> f:=AsPartialPerm(p,12);
(1,2,7,5)(3,9)(4)(6,10,8)(11)(12)
gap> f:=AsPartialPerm(p,70000);
<partial perm on 70000 pts with degree 70000, codegree 70000>
gap> OnTuples([1..10], f)=OnTuples([1..10], p);
true
gap> f:=AsPartialPerm(p,[1,3,6]);
[1,2][3,9][6,10]
gap> f:=AsPartialPerm(p,[1,3,6,11]);
[1,2][3,9][6,10](11)
gap> f:=AsPartialPerm(p,[1,3,6,70000]);
[1,2][3,9][6,10](70000)
gap> p:=(1,100000);;
gap> f:=AsPartialPerm(p,100001);
<partial perm on 100001 pts with degree 100001, codegree 100001>
gap> OnTuples([1,100000, 100001], f);
[ 100000, 1, 100001 ]
gap> f:=AsPartialPerm(p,10);     
[1,100000](2)(3)(4)(5)(6)(7)(8)(9)(10)
gap> IsPPerm4Rep(f);
true
gap> p:=(1,19)(10,100000);;
gap> AsPartialPerm(p,9); 
[1,19](2)(3)(4)(5)(6)(7)(8)(9)
gap> p:=(1,9)(10,100000);;
gap> AsPartialPerm(p,9);
(1,9)(2)(3)(4)(5)(6)(7)(8)
gap> AsPartialPerm((1,2), [1, 2, 2 ^ 61]);
Error, usage: the second argument must be a set of positive integers,
gap> AsPartialPerm((1,2), [1, 3, 2]);
Error, usage: the second argument must be a set of positive integers,
gap> AsPartialPerm((1,2), [1, "a", 2]);
Error, usage: the second argument must be a set of positive integers,
gap> AsPartialPerm((1,2), 0);
<empty partial perm>
gap> AsPartialPerm(Transformation([10, 8, 4, 6, 4, 5, 3, 8, 8, 2]), [1 .. 4]);
[1,10][2,8][3,4,6]
gap> AsPartialPerm(Transformation([10, 8, 4, 6, 4, 5, 3, 8, 8, 2]), [1 .. 5]);
Error, usage: the first argument must be injective on the second,
gap> AsPartialPerm(Transformation([10, 8, 4, 6, 4, 5, 3, 8, 8, 2]), [1, 2, 2, 3]);
Error, usage: the second argument must be a set of positive integers,
gap> AsPartialPerm(Transformation([10, 8, 4, 6, 4, 5, 3, 8, 8, 2]), 4);
[1,10][2,8][3,4,6]
gap> AsPartialPerm((), []);
<empty partial perm>

# JoinOfPartialPerms
gap> f := PartialPermNC([1], [2]);;
gap> g := PartialPermNC([1, 2, 3], [2, 4, 1]);;
gap> JoinOfPartialPerms(f, g);
[3,1,2,4]
gap> JoinOfPartialPerms(g, f);
[3,1,2,4]
gap> f := PartialPermNC([1], [2]);
[1,2]
gap> g := PartialPermNC([2], [3]);    
[2,3]
gap> JoinOfPartialPerms(f, g);
[1,2,3]
gap> JoinOfPartialPerms(g, f);
[1,2,3]
gap> g := PartialPermNC([2], [1]);
[2,1]
gap> JoinOfPartialPerms(f, g);
(1,2)
gap> JoinOfPartialPerms(g, f);
(1,2)
gap> g := PartialPermNC([1], [3]);
[1,3]
gap> JoinOfPartialPerms(f, g);
fail
gap> JoinOfPartialPerms(g, f);
fail
gap> f := PartialPermNC([2]);;
gap> g := PartialPermNC([3]);;
gap> JoinOfPartialPerms(f, g);
fail
gap> JoinOfPartialPerms(g, f);
fail
gap> f := PartialPermNC([2]);;
gap> g := PartialPermNC([0, 3]);;
gap> JoinOfPartialPerms(f, g);
[1,2,3]
gap> JoinOfPartialPerms(g, f);
[1,2,3]
gap> f := PartialPermNC([2]); 
[1,2]
gap> g := PartialPermNC([0, 3]);;
gap> JoinOfPartialPerms(f, g);
[1,2,3]
gap> JoinOfPartialPerms(g, f);
[1,2,3]
gap> f := PartialPermNC([2]);;
gap> g := PartialPermNC([0, 3]); 
[2,3]
gap> JoinOfPartialPerms(f, g);
[1,2,3]
gap> JoinOfPartialPerms(g, f);
[1,2,3]
gap> f := PartialPermNC([2]); 
[1,2]
gap> g := PartialPermNC([0, 100000]);
[2,100000]
gap> JoinOfPartialPerms(f, g);
[1,2,100000]
gap> JoinOfPartialPerms(g, f);
[1,2,100000]
gap> JoinOfPartialPerms([f, g]);
[1,2,100000]
gap> JoinOfPartialPerms([g, f]);
[1,2,100000]
gap> JoinOfPartialPerms(1, 2);
Error, usage: the argument should be a collection of partial perms,
gap> JoinOfPartialPerms(last, PartialPermNC([100000], [1]));
(1,2,100000)
gap> JoinOfPartialPerms(PartialPermNC([100000], [1]), JoinOfPartialPerms([g, f]));
(1,2,100000)
gap> g := PartialPermNC([0, 100000]);;
gap> JoinOfPartialPerms(f, g);                              
[1,2,100000]
gap> f := PartialPermNC([2]);;
gap> g := PartialPermNC([0, 100000]); 
[2,100000]
gap> JoinOfPartialPerms(f, g);
[1,2,100000]
gap> JoinOfPartialPerms(g, f);
[1,2,100000]
gap> f := PartialPermNC([2]);;
gap> g := PartialPermNC([0, 100000]);;
gap> JoinOfPartialPerms(f, g);
[1,2,100000]
gap> JoinOfPartialPerms(g, f);
[1,2,100000]
gap> last ^ 2;
[1,100000]
gap> f := PartialPermNC([0, 100000]);;
gap> g := PartialPermNC([2]);;       
gap> JoinOfPartialPerms(f, g);
[1,2,100000]
gap> JoinOfPartialPerms(g, f);
[1,2,100000]
gap> f := PartialPermNC([0, 100000]);;
gap> g := PartialPermNC([0, 100000, 4]);;
gap> JoinOfPartialPerms(f, g);
[2,100000][3,4]
gap> JoinOfPartialPerms(g, f);
[2,100000][3,4]
gap> g := PartialPermNC([0, 0, 4]);;     
gap> JoinOfPartialPerms(f, g);
[2,100000][3,4]
gap> JoinOfPartialPerms(g, f);
[2,100000][3,4]
gap> g := PartialPermNC([0, 0, 4]); 
[3,4]
gap> JoinOfPartialPerms(f, g);
[2,100000][3,4]
gap> JoinOfPartialPerms(g, f);
[2,100000][3,4]
gap> f := PartialPermNC([0, 100000]); 
[2,100000]
gap> JoinOfPartialPerms(f, g);
[2,100000][3,4]
gap> JoinOfPartialPerms(g, f);
[2,100000][3,4]
gap> g := PartialPermNC([0, 0, 4]);;
gap> JoinOfPartialPerms(f, g);
[2,100000][3,4]
gap> JoinOfPartialPerms(g, f);
[2,100000][3,4]
gap> f := PartialPermNC([1, 2, 4, 5, 6, 7], [5, 100000, 7, 3, 1, 4])
>  * PartialPermNC([1 .. 99999]);
[6,1,5,3](4,7)
gap> IsPPerm4Rep(f);
true
gap> g := PartialPermNC([8, 100000], [100000, 1]);
[8,100000,1]
gap> JoinOfPartialPerms(f, g);
fail
gap> JoinOfPartialPerms(g, f);
fail
gap> g := PartialPermNC([8], [100000]);         
[8,100000]
gap> JoinOfPartialPerms(f, g);
[6,1,5,3][8,100000](4,7)
gap> JoinOfPartialPerms(g, f);
[6,1,5,3][8,100000](4,7)
gap> JoinOfPartialPerms(f, f);
[6,1,5,3](4,7)

# JOIN_IDEM_PPERMS
gap> JOIN_IDEM_PPERMS(PartialPerm([1 .. 5]), 
>                     PartialPerm([3 .. 10], [3 .. 10]));
<identity partial perm on [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]>
gap> JOIN_IDEM_PPERMS(PartialPerm([3 .. 10], [3 .. 10]),
>                     PartialPerm([1 .. 5]));
<identity partial perm on [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]>
gap> JOIN_IDEM_PPERMS(PartialPerm([3 .. 10], [3 .. 10]),
>                     PartialPerm([65536 .. 65538], [65536 .. 65538]));
<identity partial perm on [ 3, 4, 5, 6, 7, 8, 9, 10, 65536, 65537, 65538 ]>
gap> JOIN_IDEM_PPERMS(PartialPerm([70000 .. 70010], [70000 .. 70010]),
>                     PartialPerm([65536 .. 65538], [65536 .. 65538]));
<identity partial perm on 
[ 65536, 65537, 65538, 70000, 70001, 70002, 70003, 70004, 70005, 70006, 70007,\
 70008, 70009, 70010 ]>
gap> JoinOfIdempotentPartialPermsNC(1, 2);
Error, usage: the argument should be a collection of partial perms,

# MeetOfPartialPerms
gap> f:=PartialPermNC([2]);;
gap> g:=PartialPermNC([3]);;
gap> MeetOfPartialPerms(f,g);
<empty partial perm>
gap> f:=PartialPermNC( [ 1, 2, 3, 4, 5, 8, 10 ], [ 7, 1, 4, 3, 2, 6, 5 ] );;
gap> g:=PartialPermNC( [ 1, 2, 3, 4, 5, 8, 10 ], [ 3, 1, 4, 2, 5, 6, 7 ] );;
gap> MeetOfPartialPerms(f,g);
[2,1][3,4][8,6]
gap> f:=PartialPerm([1, 1000], [1000, 2]);;
gap> g:=JoinOfPartialPerms(f, PartialPermNC([1001..2000], [1001..2000]));;
gap> f=MeetOfPartialPerms(f, g);
true
gap> g:=JoinOfPartialPerms(f, PartialPermNC([1001..100000], [1001..100000]));;
gap> f=MeetOfPartialPerms(f, g);
true
gap> g:=PartialPerm([1, 1000], [1000, 2]);;
gap> f:=JoinOfPartialPerms(g, PartialPermNC([1001..100000], [1001..100000]));;
gap> g=MeetOfPartialPerms(f, g);
true
gap> f:=PartialPermNC([100000,2,3,4,5]); 
[1,100000](2)(3)(4)(5)
gap> g:=PartialPermNC([100001,2,3,4,5]);                                       
[1,100001](2)(3)(4)(5)
gap> MeetOfPartialPerms(f,g);
<identity partial perm on [ 2, 3, 4, 5 ]>
gap> MeetOfPartialPerms(PartialPerm([1]));
<identity partial perm on [ 1 ]>
gap> MeetOfPartialPerms(PartialPerm([1]), PartialPerm([2]));
<empty partial perm>
gap> MeetOfPartialPerms(PartialPerm([1]), PartialPerm([1, 2]));
<identity partial perm on [ 1 ]>
gap> MeetOfPartialPerms([]);
Error, usage: the argument should be a collection of partial perms,
gap> MeetOfPartialPerms([PartialPerm([1]), PartialPerm([1, 2])]);
<identity partial perm on [ 1 ]>
gap> MeetOfPartialPerms(SymmetricInverseMonoid(3));
<empty partial perm>

# RestrictedPartialPerm
gap> f:=PartialPermNC([100000,2,3,4,5]);
[1,100000](2)(3)(4)(5)
gap> RestrictedPartialPerm(f, [2..5]);
<identity partial perm on [ 2, 3, 4, 5 ]>
gap> g:=last;
<identity partial perm on [ 2, 3, 4, 5 ]>
gap> DegreeOfPartialPerm(g);
5
gap> g:=RestrictedPartialPerm(f, [100000]);
<empty partial perm>
gap> g:=RestrictedPartialPerm(f, [1]);
[1,100000]
gap> f:=PartialPermNC([10,2,3,4,5]);    
[1,10](2)(3)(4)(5)
gap> RestrictedPartialPerm(f, [2..5]);
<identity partial perm on [ 2, 3, 4, 5 ]>
gap> g:=RestrictedPartialPerm(f, [1]);
[1,10]
gap> g:=RestrictedPartialPerm(f, [100]);
<empty partial perm>
gap> g:=RestrictedPartialPerm(f, [10]); 
<empty partial perm>
gap> g:=RestrictedPartialPerm(f, [5]); 
<identity partial perm on [ 5 ]>
gap> RestrictedPartialPerm(f, [2, 1, 3]);
Error, usage: the second argument must be a set of positive integers,
gap> RestrictedPartialPerm(f, [1, 2, 2 ^ 61]);
Error, usage: the second argument must be a set of positive integers,
gap> RESTRICTED_PPERM("a", [1, 2, 3]);
fail

# AsPermutation
gap> f:=PartialPermNC([10,2,3,4,5]);      
[1,10](2)(3)(4)(5)
gap> AsPermutation(f);
fail
gap> f:=RestrictedPartialPerm(f, [2..10]);
<identity partial perm on [ 2, 3, 4, 5 ]>
gap> AsPermutation(f);
()
gap> f:=PartialPerm([1, 1000], [1000, 2]);;
gap> x:=IndexPeriodOfPartialPerm(f);;
gap> g:=f^x[1];;
gap> OnTuples(DomainOfPartialPerm(g),AsPermutation(g))=
> OnTuples(DomainOfPartialPerm(g), g);
true
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> x:=IndexPeriodOfPartialPerm(f);;
gap> g:=f^x[1];;
gap> OnTuples(DomainOfPartialPerm(g),AsPermutation(g))=
> OnTuples(DomainOfPartialPerm(g), g);
true
gap> AsPermutation(f);
fail
gap> f := PartialPerm([1, 70000], [70000, 1]);;
gap> AsPermutation(f);
(1,70000)

# PermLeftQuoPartialPerm
gap> f := PartialPerm([1, 100], [100, 2]);;
gap> p := (2, 100);;
gap> g:=f*p;
[1,2](100)
gap> PermLeftQuoPartialPerm(f, g)=p;
true
gap> h := PartialPerm([200, 300, 400, 1900, 10 ^ 6], 
>                     [101, 113, 131, 450, 10 ^ 6]);;
gap> h:=JoinOfPartialPerms(h, PartialPermNC([1..100], [1..100]));;
gap> g=g*h;
true
gap> g:=g*h;;
gap> IsPPerm4Rep(g);
true
gap> p=PermLeftQuoPartialPerm(f, g);
true
gap> f:=
> PartialPerm(
>  [ 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19, 20, 21, 23, 
>     24, 25, 26, 28, 29, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 43, 46, 
>     48, 50, 51, 56, 57, 59, 63, 66, 68, 70, 71, 74, 76, 77, 78, 79, 83, 84, 
>     85, 87, 90, 92, 94, 97, 100 ], 
>  [ 81741, 47535, 89543, 7647, 6928, 97188, 75189, 75720, 16656, 19809, 59830, 
>     16417, 72882, 82179, 79601, 83154, 17509, 84845, 47064, 83836, 71322, 
>     16135, 20341, 76275, 83899, 31052, 74445, 62658, 89822, 77308, 51562, 
>     39893, 31166, 28666, 71421, 60942, 85356, 37758, 73004, 85900, 7741, 
>     60975, 67112, 21368, 84588, 64899, 13092, 33817, 85063, 22848, 98767, 
>     36015, 82759, 4951, 10858, 31285, 49208, 60946, 33562, 4467, 52041, 
>     75960, 83945 ] );;
gap> PermLeftQuoPartialPerm(f, f);
()
gap> IsPerm4Rep(last);
true
gap> PermLeftQuoPartialPerm(f, f);
()
gap> f:=PartialPermNC([1,2], [100000,100001])*
> PartialPermNC([100000, 100001, 100002], [2,1,100002]); 
(1,2)
gap> g:=PartialPermNC([1,2]);     
<identity partial perm on [ 1, 2 ]>
gap> IsPPerm2Rep(g);
true
gap> IsPPerm4Rep(f);
true
gap> PermLeftQuoPartialPerm(f, g);
(1,2)
gap> PermLeftQuoPartialPerm(g, f);
(1,2)
gap> PermLeftQuoPartialPerm(PartialPerm([1]), PartialPerm([2]));
Error, usage: the arguments must be partial perms with equal image sets,

# Kernel level functions
#
# OnePPerm
gap> f:=PartialPerm([1, 100000], [100000, 2]);;
gap> e:=One(f);;
gap> e*f=f;
true
gap> f*e=f;
true
gap> Union(DomainOfPartialPerm(f), ImageSetOfPartialPerm(f))=
> DomainOfPartialPerm(e);
true
gap> Union(DomainOfPartialPerm(f), ImageSetOfPartialPerm(f))=
> ImageSetOfPartialPerm(e);
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);;
gap> e:=One(f);;
gap> e*f=f;    
true
gap> f*e=f;
true
gap> Union(DomainOfPartialPerm(f), ImageSetOfPartialPerm(f))=      
> DomainOfPartialPerm(e);
true
gap> Union(DomainOfPartialPerm(f), ImageSetOfPartialPerm(f))=
> ImageSetOfPartialPerm(e);
true
gap> f:=PartialPermNC([1,2], [100000,100001])*                                 
> PartialPermNC([100000, 100001, 100002], [2,1,100002]);
(1,2)
gap> One(f);
<identity partial perm on [ 1, 2 ]>
gap> IsPPerm2Rep(last);
true
gap> IsPPerm4Rep(f);
true

# EqPPerm22
gap> PartialPerm([1, 2]) = PartialPerm([2, 1]);
false
gap> PartialPerm([1, 2], [2, 1]) = PartialPerm([1, 2], [1, 2]);
false
gap> PartialPerm([2], [2]) = PartialPermNC([1 .. 2], [1 .. 2]);
false
gap> PartialPerm([1, 2]) = PartialPerm([1, 2]);
true
gap> PartialPerm([1, 2], [1, 2]) = PartialPerm([1, 2], [1, 2]);
true

# EqPPerm24
gap> PartialPerm([1, 2]) = PPerm4([2, 1]);
false
gap> PartialPerm([1, 2], [2, 1]) = PPerm4([1, 2], [1, 2]);
false
gap> PartialPerm([2], [2]) = PPerm4([1 .. 2], [1 .. 2]);
false
gap> PartialPerm([1, 2]) = PPerm4([1, 2]);
true
gap> PartialPerm([1, 2], [1, 2]) = PPerm4([1, 2], [1, 2]);
true

# EqPPerm42
gap> PPerm4([1, 2]) = PartialPerm([2, 1]);
false
gap> PPerm4([1, 2], [2, 1]) = PartialPerm([1, 2], [1, 2]);
false
gap> PPerm4([2], [2]) = PartialPermNC([1 .. 2], [1 .. 2]);
false
gap> PPerm4([1, 2]) = PartialPerm([1, 2]);
true
gap> PPerm4([1, 2], [1, 2]) = PartialPerm([1, 2], [1, 2]);
true

# EqPPerm44
gap> PartialPerm([1, 70000]) = PartialPerm([70000, 1]);
false
gap> PartialPerm([1, 70000], [70000, 1]) = PartialPerm([1, 70000], [1, 70000]);
false
gap> PartialPerm([70000], [70000]) = PartialPermNC([1 .. 70000], [1 .. 70000]);
false
gap> PartialPerm([1, 70000]) = PartialPerm([1, 70000]);
true
gap> PartialPerm([1, 70000], [1, 70000]) = PartialPerm([1, 70000], [1, 70000]);
true

# LtPPerm22
gap> PartialPerm([1, 20]) < PartialPerm([20, 1]);
true
gap> PartialPerm([1, 20], [20, 1]) < PartialPerm([1, 20], [1, 20]);
false
gap> PartialPerm([20], [20]) < PartialPermNC([1 .. 20], [1 .. 20]);
true
gap> PartialPerm([1, 20]) < PartialPerm([1, 20]);
false
gap> PartialPerm([1, 20], [1, 20]) < PartialPerm([1, 20], [1, 20]);
false
gap> PartialPerm([1, 21], [1, 21]) < PartialPerm([1, 20], [1, 20]);
false
gap> PartialPerm([1, 21], [1, 21]) < PartialPerm([1, 22], [1, 22]);
true

# LtPPerm24
gap> PartialPerm([1, 20]) < PPerm4([20, 1]);
true
gap> PartialPerm([1, 20], [20, 1]) < PPerm4([1, 20], [1, 20]);
false
gap> PartialPerm([20], [20]) < PPerm4([1 .. 20], [1 .. 20]);
true
gap> PartialPerm([1, 20]) < PPerm4([1, 20]);
false
gap> PartialPerm([1, 20], [1, 20]) < PPerm4([1, 20], [1, 20]);
false
gap> PartialPerm([1, 21], [1, 21]) < PPerm4([1, 20], [1, 20]);
false
gap> PartialPerm([1, 21], [1, 21]) < PPerm4([1, 22], [1, 22]);
true

# LtPPerm42
gap> PPerm4([1, 20]) < PartialPerm([20, 1]);
true
gap> PPerm4([1, 20], [20, 1]) < PartialPerm([1, 20], [1, 20]);
false
gap> PPerm4([20], [20]) < PartialPerm([1 .. 20], [1 .. 20]);
true
gap> PPerm4([1, 20]) < PartialPerm([1, 20]);
false
gap> PPerm4([1, 20], [1, 20]) < PartialPerm([1, 20], [1, 20]);
false
gap> PPerm4([1, 21], [1, 21]) < PartialPerm([1, 20], [1, 20]);
false
gap> PPerm4([1, 21], [1, 21]) < PartialPerm([1, 22], [1, 22]);
true

# LtPPerm44
gap> PartialPerm([1, 70000]) < PartialPerm([70000, 1]);
true
gap> PartialPerm([1, 70000], [70000, 1]) < PartialPerm([1, 70000], [1, 70000]);
false
gap> PartialPerm([70000], [70000]) < PartialPermNC([1 .. 70000], [1 .. 70000]);
true
gap> PartialPerm([1, 70000]) < PartialPerm([1, 70000]);
false
gap> PartialPerm([1, 70000], [1, 70000]) < PartialPerm([1, 70000], [1, 70000]);
false
gap> PartialPerm([1, 70001], [1, 70001]) < PartialPerm([1, 70000], [1, 70000]);
false
gap> PartialPerm([1, 70001], [1, 70001]) < PartialPerm([1, 70002], [1, 70002]);
true

# ProdPPerm2Perm2, Case 1 of 6: codeg(f)<=deg(p), domain known
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );;
> DomainOfPartialPerm(f);;
gap> p:=(7, 100);;
gap> g:=f*p;
[1,2,100][3,8](6,10)
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> f := PartialPerm([1, 2, 3, 6, 10]);;
gap> p := (7, 65536);;
gap> f * p;
[4,6][5,10](1)(2)(3)

# ProdPPerm2Perm2, Case 2 of 6: codeg(f)<=deg(p), domain not known
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );;
gap> p:=(7, 100);;
gap> g:=f*p;
[1,2,100][3,8](6,10)
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );;
gap> p:=(7, 100);;
gap> g:=f*p;
[1,2,100][3,8](6,10)
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPPerm2Perm2, Case 3 of 6: codeg(f)>deg(p), domain known
gap> f:=PartialPerm([1, 100], [100, 2]);; DomainOfPartialPerm(f);;
gap> p:=(7, 10);;
gap> g:=f*p;
[1,100,2]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> f:=PartialPerm([1, 65535], [65535, 2]);;
gap> p:=(17, 10000);;
gap> g:=f*p;
[1,65535,2]
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPPerm2Perm2, Case 4 of 6: codeg(f)>deg(p), domain not known
gap> f:=PartialPerm([1, 100], [100, 2]);;
gap> p:=(7, 10);;
gap> g:=f*p;
[1,100,2]
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);;
gap> p:=(13, 1000);;
gap> g:=f*p;
[1,10000,2]
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPPerm2Perm2, Case 5 of 6: deg(p)=65536, domain not known
gap> p:=(1,65536);;
gap> f:=PartialPerm([1, 10000], [10000, 2]);;
gap> g:=f*p;
[1,10000,2]
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPPerm2Perm2, Case 6 of 6: deg(p)=65536, domain known
gap> f:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(f);;
gap> p:=(1,65536);;
gap> g:=f*p;
[1,10000,2]
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPPerm2Perm4, Case 1 of 2: domain known
gap> f:=PartialPerm( [ 1, 2, 3, 6, 10 ], [ 2, 7, 8, 10, 6 ] );; DomainOfPartialPerm(f);;
gap> p:=(1,100000);;
gap> g:=f*p;
[1,2,7][3,8](6,10)
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPPerm2Perm4, Case 2 of 2: domain not known
gap> f:=PartialPerm([1, 1000], [1000, 2]);;
gap> p:=(1,100000);;
gap> g:=f*p;
[1,1000,2]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true

# ProdPPerm4Perm4, Case 1 of 4: deg(p)>codeg(f) domain not known
gap> p:=(1,100000);;
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,70000]));;
gap> g:=f*p;                  
[65536,100000][65537,70000]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true

# ProdPPerm4Perm4, Case 2 of 4: deg(p)>codeg(f) domain known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,70000]));
[65536,1][65537,70000]
gap> p:=(1,100000);;
gap> g:=f*p;
[65536,100000][65537,70000]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true

# QuoPPerm4Perm4, Case 1 of 4: deg(p)>codeg(f) domain not known
gap> p:=(1,100000,123);;
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,70000]));;
gap> g:=f/p;                  
[65536,123][65537,70000]
gap> OnTuples(ImageListOfPartialPerm(f), p^-1)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> f/p=f*p^-1;
true

# QuoPPerm4Perm4, Case 2 of 4: deg(p)>codeg(f) domain known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,70000]));
[65536,1][65537,70000]
gap> p:=(1,100000,123);;
gap> g:=f/p;
[65536,123][65537,70000]
gap> OnTuples(ImageListOfPartialPerm(f), p^-1)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> f/p=f*p^-1;
true

# QuoPPerm4Perm4, Case 3 of 4: deg(p)<=codeg(f) domain not known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,100001]));;
gap> p:=(1,100000,123);;
gap> g:=f/p;
[65536,123][65537,100001]
gap> OnTuples(ImageListOfPartialPerm(f), p^-1)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> f/p=f*p^-1;
true

# QuoPPerm4Perm4, Case 4 of 4: deg(p)<=codeg(f) domain known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,100001]));
[65536,1][65537,100001]
gap> p:=(1,100000,123);;
gap> g:=f/p;
[65536,123][65537,100001]
gap> OnTuples(ImageListOfPartialPerm(f), p^-1)=ImageListOfPartialPerm(g);  
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true
gap> f/p=f*p^-1;
true

# QuoPPerm4Perm4: Corner cases
gap> EMPTY_PPERM4 / ((1, 65537) * (1, 65537));
<empty partial perm>
gap> PPerm4([1]) / ((1, 65537) * (1, 65537));
<identity partial perm on [ 1 ]>

# QuoPPerm2Perm2, Case 1 of 4: deg(p) > codeg(f) domain not known
gap> p := (1, 10, 12);;
gap> f := PartialPermNC(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> g := f / p;                  
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm2Perm2, Case 2 of 4: deg(p) > codeg(f) domain known
gap> p := (1, 10, 12);;
gap> f := PartialPermNC(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> DomainOfPartialPerm(f);
[ 66, 67 ]
gap> g := f / p;
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm2Perm2, Case 3 of 4: deg(p) <= codeg(f) domain not known
gap> p := (1, 10, 12);;
gap> f := PartialPermNC(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> g := f / p;
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm2Perm2, Case 4 of 4: deg(p) <= codeg(f) domain known
gap> p := (1, 10, 12);;
gap> f := PartialPermNC(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> DomainOfPartialPerm(f);;
gap> g := f / p;
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);  
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm2Perm2: Corner cases
gap> EmptyPartialPerm() / ((1, 10) * (1, 10));
<empty partial perm>
gap> PartialPerm([1]) / ((1, 10) * (1, 10));
<identity partial perm on [ 1 ]>
gap> p := (1, 65535);;
gap> f := PartialPermNC(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> f / p;
[66,65535][67,70]

# QuoPPerm4Perm2, Case 1 of 4: deg(p) > codeg(f) domain not known
gap> p := (1, 10, 12);;
gap> f := PPerm4(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> g := f / p;                  
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm4Perm2, Case 2 of 4: deg(p) > codeg(f) domain known
gap> p := (1, 10, 12);;
gap> f := PPerm4(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> DomainOfPartialPerm(f);
[ 66, 67 ]
gap> g := f / p;
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm4Perm2, Case 3 of 4: deg(p) <= codeg(f) domain not known
gap> p := (1, 10, 12);;
gap> f := PPerm4(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> g := f / p;
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm4Perm2, Case 4 of 4: deg(p) <= codeg(f) domain known
gap> p := (1, 10, 12);;
gap> f := PPerm4(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> DomainOfPartialPerm(f);;
gap> g := f / p;
[66,12][67,70]
gap> OnTuples(ImageListOfPartialPerm(f), p ^ -1) = ImageListOfPartialPerm(g);  
true
gap> CodegreeOfPartialPerm(g) = Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g) = DomainOfPartialPerm(f);
true
gap> f / p = f * p ^ -1;
true

# QuoPPerm4Perm2: Corner cases
gap> EMPTY_PPERM4 / ((1, 10) * (1, 10));
<empty partial perm>
gap> PPerm4([1]) / ((1, 10) * (1, 10));
<identity partial perm on [ 1 ]>
gap> p := (1, 65536);;
gap> f := PPerm4(Concatenation(List([1 .. 65], x -> 0), [1, 70]));;
gap> f / p;
[66,65536][67,70]

# QuoPPerm2Perm4
gap> EmptyPartialPerm() / (1, 65537);
<empty partial perm>
gap> PartialPerm([1]) / ((1, 65537) * (1, 65537));
<identity partial perm on [ 1 ]>
gap> PartialPerm([1]) / (1, 65537);
[1,65537]

# ProdPPerm4Perm4, Case 3 of 4: deg(p)<=codeg(f) domain not known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,100001]));;
gap> p:=(1,100000);;
gap> g:=f*p;
[65536,100000][65537,100001]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true

# ProdPPerm4Perm4, Case 4 of 4: deg(p)<=codeg(f) domain known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,100001]));
[65536,1][65537,100001]
gap> p:=(1,100000);;
gap> g:=f*p;
[65536,100000][65537,100001]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);  
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true

# ProdPPerm4Perm2, Case 1 of 2: domain not known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,100001]));;
gap> p:=(1,2);;
gap> g:=f*p;
[65536,2][65537,100001]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);  
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true

# ProdPPerm4Perm2, Case 2 of 2: domain known
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,100001])); 
[65536,1][65537,100001]
gap> p:=(1,2);;
gap> g:=f*p;
[65536,2][65537,100001]
gap> OnTuples(ImageListOfPartialPerm(f), p)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> DomainOfPartialPerm(g)=DomainOfPartialPerm(f);
true

# ProdPerm2PPerm2, Case 1 of 2: deg(p)<=deg(f)
gap> f:=PartialPermNC([ 1, 2, 3, 6, 8, 10 ], [ 2, 6, 7, 9, 1, 5 ]);;
gap> p:=(1,2,5,3);;
gap> g:=p*f;                                                          
[3,2][8,1,6,9][10,5,7]
gap> OnSets(DomainOfPartialPerm(f), p^-1)=DomainOfPartialPerm(g);
true
gap> OnTuples(OnTuples(DomainOfPartialPerm(g), p), f)=
> ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> ImageSetOfPartialPerm(f)=ImageSetOfPartialPerm(g);
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);;
gap> p:=(13, 9000);;
gap> g:=p*f;;
gap> OnSets(DomainOfPartialPerm(f), p^-1)=DomainOfPartialPerm(g);
true
gap> OnTuples(OnTuples(DomainOfPartialPerm(g), p), f)=
> ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> ImageSetOfPartialPerm(f)=ImageSetOfPartialPerm(g);
true
gap> f:=PartialPermNC( [ 1, 2, 3, 6, 100000 ], [ 2, 6, 7, 1, 5 ] );;
gap> p:=(1,3)(2,9,7,8,6,10,5,4);;
gap> p*f;
[3,2][4,6][8,1,7][100000,5]

# ProdPerm2PPerm2, Case 2 of 2: deg(p)>deg(f)
gap> f:=PartialPermNC([ 1, 2, 3, 6, 8, 10 ], [ 2, 6, 7, 9, 1, 5 ]);;
gap> p:=(1,5,12,8)(2,16,10,15,13,7)(3,4,20,14,6,19,9,18,11,17);;
gap> g:=p*f;
[8,2][12,1][14,9][16,5][17,7,6]
gap> OnSets(DomainOfPartialPerm(f), p^-1);
[ 7, 8, 12, 14, 16, 17 ]
gap> OnTuples(OnTuples(last, p), f)=ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> ImageSetOfPartialPerm(f)=ImageSetOfPartialPerm(g);
true
gap> f:=PartialPerm([1, 1000], [1000, 2]);;
gap> p:=(13, 2000);;
gap> g:=p*f;;
gap> OnSets(DomainOfPartialPerm(f), p^-1)=DomainOfPartialPerm(g);
true
gap> OnTuples(OnTuples(DomainOfPartialPerm(g), p), f)=
> ImageListOfPartialPerm(g);
true
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> ImageSetOfPartialPerm(f)=ImageSetOfPartialPerm(g);          
true

# ProdPerm4PPerm4, Case 1 of 2: deg(p)<=deg(f)
gap> f:=PartialPermNC(Concatenation(List([1..65535], x-> 0), [1,100001]));
[65536,1][65537,100001]
gap> p:=(1,65537);; 
gap> g:=p*f;
[65536,1,100001]
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPerm4PPerm4, Case 2 of 2: deg(p)>deg(f)
gap> f:=PartialPermNC([1,65536], [1,65536]);;
gap> p:=(1,100000);;
gap> g:=p*f;
[100000,1](65536)
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPerm4PPerm2, Case 1 of 2: deg(p)<=deg(f)
gap> p:=(1,100000);;
gap> f:=PartialPermNC([ 1, 2, 3, 6, 8, 10 ], [ 2, 6, 7, 9, 1, 5 ]);;
gap> g:=p*f;
[3,7][8,1][10,5][100000,2,6,9]
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPerm4PPerm2, Case 2 of 2: deg(p)>deg(f)
gap> f:=PartialPermNC([65537],[1]);;
gap> IsPPerm2Rep(f);
true
gap> p:=(65537, 65538);;
gap> g:=p*f;
[65538,1]
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true
gap> (1, 65537) * EmptyPartialPerm();
<empty partial perm>

# ProdPerm2PPerm4, Case 1 of 2: deg(p)<=deg(f)
gap> p:=(1,10000);;
gap> f:=PartialPermNC([ 10000 ], [ 70000 ] );;
gap> g:=p*f;
[1,70000]
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# ProdPerm2PPerm4, Case 2 of 2: deg(p)>deg(f)
gap> f:=PartialPermNC([ 1 ], [ 70000 ] );;    
gap> p:=(1,10000);;
gap> g:=p*f;
[10000,70000]
gap> CodegreeOfPartialPerm(g)=Maximum(ImageSetOfPartialPerm(g));
true

# InvPPerm2, Case 1 of 4, deg>65535 and domain not known
gap> f:=PartialPerm([100000],[1])*PartialPermNC([1]);;
gap> f^-1;
[1,100000]
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# InvPPerm2, Case 2 of 4, deg>65535 and domain known
gap> f:=PartialPerm([100000], [1]);
[100000,1]
gap> f^-1;
[1,100000]
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# InvPPerm2, Case 3 of 4, deg<65536 and domain not known
gap> f:=PartialPermNC( [ 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 16, 17, 18, 19 ], 
> [ 3, 12, 14, 4, 11, 18, 17, 2, 9, 5, 15, 8, 20, 10, 19 ] );;
gap> f:=f*RightOne(f);;
gap> f^-1;
[9,10,18,6][14,3,1][15,12,2,8,16][20,17,7](4)(5,11)(19)
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# InvPPerm2, Case 4 of 4, deg<65536 and domain known
gap> f:=PartialPermNC( [ 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 14, 16, 18, 19, 20 ], 
> [ 13, 1, 8, 5, 4, 14, 11, 12, 9, 20, 2, 18, 7, 3, 19 ] );;
gap> f^-1;
[7,18,16][11,8,3,19,20,12,9,10][13,1,2,14,6](4,5)
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# InvPPerm4, Case 1 of 4, deg>65535 and domain not known
gap> f:=PartialPerm([100000],[100001]);;
gap> f:=f*RightOne(f);;
gap> f^-1;
[100001,100000]
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# InvPPerm4, Case 2 of 4, deg>65535 and domain known
gap> f:=PartialPerm([100000],[100001]);
[100000,100001]
gap> f^-1;
[100001,100000]
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# InvPPerm4, Case 3 of 4, deg<65536 and domain not known
gap> f:=PartialPerm([1],[100001]);;
gap> f:=f*RightOne(f);;
gap> f^-1;
[100001,1]
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# InvPPerm4, Case 4 of 4, deg<65536 and domain known
gap> f:=PartialPerm([1],[100001]);;
gap> f^-1;
[100001,1]
gap> f*f^-1=LeftOne(f);
true
gap> f^-1*f=RightOne(f);
true

# PowPPerm2Perm2, Case 1 of 4, deg(f)>deg(p) and codeg(f)>deg(p)
gap> f:=PartialPermNC( [ 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 16, 17, 18, 19 ], 
> [ 3, 12, 14, 4, 11, 18, 17, 2, 9, 5, 15, 8, 20, 10, 19 ] );;
gap> p:=(1,7,10,4,9,8)(3,6,5);;
gap> f^p;
[5,18,4,8][7,6,14][10,17,20][16,1,2,12,15](3,11)(9)(19)
gap> p^-1*f*p;                     
[5,18,4,8][7,6,14][10,17,20][16,1,2,12,15](3,11)(9)(19)
gap> f^p=p^-1*f*p;
true
gap> EmptyPartialPerm() ^ ();
<empty partial perm>

# PowPPerm2Perm2, Case 2 of 4, deg(f)>deg(p) and codeg(f)<=deg(p)
gap> f:=PartialPermNC( [ 11, 12, 13, 14, 15, 18, 19, 20 ], 
> [ 4, 2, 10, 5, 9, 6, 3, 8 ] );;
gap> CodegreeOfPartialPerm(f);
10
gap> DegreeOfPartialPerm(f);
20
gap> p:=(1,4,8,3,2,7,6,10,9,5);;
gap> f^p;
[11,8][12,7][13,9][14,1][15,5][18,10][19,2][20,3]
gap> p^-1*f*p;
[11,8][12,7][13,9][14,1][15,5][18,10][19,2][20,3]

# PowPPerm2Perm2, Case 3 of 4, deg(f)<=deg(p) and codeg(f)>deg(p)
gap> f:=f^-1;;
gap> DegreeOfPartialPerm(f);
10
gap> CodegreeOfPartialPerm(f);     
20
gap> p:=(1,7,4,8)(2,6,5)(9,10);;
gap> f^p;
[1,20][2,14][3,19][5,18][6,12][8,11][9,13][10,15]
gap> p^-1*f*p;                     
[1,20][2,14][3,19][5,18][6,12][8,11][9,13][10,15]

# PowPPerm2Perm2, Case 4 of 4, deg(f)<=deg(p) and codeg(f)<=deg(p)
gap> f:=PartialPermNC( 
> [ 1, 2, 3, 5, 7, 9, 10, 12, 13, 14, 16, 17, 19, 20, 21, 22, 
>   23, 26, 27, 28, 29, 30, 31, 32, 35, 36, 39, 40, 41, 43, 47, 48, 49 ], 
> [ 5, 4, 45, 24, 43, 28, 21, 31, 13, 49, 20, 46, 11, 17, 29, 22, 7, 27, 32, 
>   30, 42, 6, 44, 39, 15, 16, 34, 37, 1, 12, 40, 47, 8 ] );;
gap> p:=(1,76,65,52,5,59,75,64,37,12,78,41,57,48,94,32,9,3,99,17,89)
> (2,35,33,63,43,28,
> 22,15,100,66,45,4,80,58,51,67,55,24,56,86,49,38,42,93,88,18,77,62,79,19,92,50,
> 83,91,44,95,14,72,60,85,34)(6,16,31,11,97,46,47,73,7,39,27,70,61,71,74,10,
> 96,98,87,53,81)(8,54,20,36,23,26,40,68,25,90,13,30,84,29,21,69,82);;
gap> DegreeOfPartialPerm(f);
49
gap> CodegreeOfPartialPerm(f);
49
gap> f^p;
[3,22,84,16][23,31,36,89,47][26,39,28,78,11,95][33,100][35,80][40,70,9,27,2]
[57,76,59,56][72,38,54][92,97][94,73,68,12][96,69,21,93][99,4](15)(30)
gap> p^-1*f*p;                      
[3,22,84,16][23,31,36,89,47][26,39,28,78,11,95][33,100][35,80][40,70,9,27,2]
[57,76,59,56][72,38,54][92,97][94,73,68,12][96,69,21,93][99,4](15)(30)
gap> f^p=p^-1*f*p;
true

# PowPPerm2Perm4, Case 1 of 2, deg(f)>deg(p) and codeg(f)<=deg(p)
gap> f:=PartialPermNC([100000], [1]);
[100000,1]
gap> IsPPerm2Rep(f);
true
gap> p := (17, 100000);;
gap> f^p=p^-1*f*p;
true
gap> EmptyPartialPerm() ^ (1, 65537);
<empty partial perm>
gap> PartialPerm([1, 10, 3]) ^ ((1, 65537) * (1, 65537));
[2,10](1)(3)

# PowPPerm2Perm4, Case 2 of 2, deg(f)<=deg(p) and codeg(f)<=deg(p)
gap> f := PartialPermNC([1, 2, 3, 4, 5, 6], [2, 5, 8, 1, 3, 4]);;
gap> p := (17, 100000);;
gap> f^p=p^-1*f*p;               
true

# PowPPerm4Perm2, Case 1 of 4, deg(f)>deg(p) and codeg(f)>deg(p)
gap> f:=PartialPermNC([100000], [100000]);
<identity partial perm on [ 100000 ]>
gap> p:=(1,3,2,10)(5,7)(6,9,8);;
gap> f^p;
<identity partial perm on [ 100000 ]>
gap> f:=PartialPerm([1, 100000], [100000, 2]);;        
gap> p:=(17, 50000);;
gap> f^p=p^-1*f*p;
true

# PowPPerm4Perm2, Case 2 of 4, deg(f)>deg(p) and codeg(f)<=deg(p)
gap> f:=PartialPermNC([100000], [1]);     
[100000,1]
gap> p:=(1,10)(3,8)(4,7,5,9);;
gap> f^p;
[100000,10]
gap> p^-1*f*p;
[100000,10]
gap> f:=PartialPermNC( [ 1, 2, 4, 5, 6, 7 ], [ 5, 100000, 7, 3, 1, 4 ] );;
gap> f:=f*PartialPermNC([1..99999]);                                        
[6,1,5,3](4,7)
gap> IsPPerm4Rep(f);
true
gap> f:=JoinOfPartialPerms(f, PartialPermNC([100000],[8]));
[6,1,5,3][100000,8](4,7)
gap> IsPPerm4Rep(f);
true
gap> p:=(1,10,4,5,3,8,2,6,7,9);;
gap> f^p;
[7,10,3,8][100000,2](5,9)
gap> p^-1*f*p;
[7,10,3,8][100000,2](5,9)

# PowPPerm4Perm2, Case 3 of 4, deg(f)<=deg(p) and codeg(f)>deg(p)
gap> p:=(1,6,7,9,4,3,10,2,5,8);;
gap> f:=PartialPermNC( [ 1 ], [100000] );;
gap> IsPPerm4Rep(f);
true
gap> f^p;
[6,100000]
gap> p^-1*f*p;
[6,100000]

# PowPPerm4Perm2, Case 4 of 4, deg(f)<=deg(p) and codeg(f)<=deg(p)
gap> f:=PartialPermNC( [ 1, 2, 4, 5, 6, 7 ], [ 5, 100000, 7, 3, 1, 4 ] );;
gap> f:=f*PartialPermNC([1..99999]);
[6,1,5,3](4,7)
gap> IsPPerm4Rep(f);
true
gap> p:=(1,3,5,4,6)(7,10,8,9);;
gap> f^p;
[1,3,4,5](6,10)
gap> p^-1*f*p;
[1,3,4,5](6,10)

# PowPPerm4Perm2
gap> EMPTY_PPERM4 ^ ();
<empty partial perm>
gap> EMPTY_PPERM4 ^ (1, 65537);
<empty partial perm>
gap> () * EMPTY_PPERM4;
<empty partial perm>

#

# PowPPerm4Perm4, Case 1 of 4, deg(f)>deg(p) and codeg(f)>deg(p)
gap> f:=PartialPerm([1, 100000], [100000, 2]);; 
gap> p:=(17, 65538);;
gap> IsPPerm4Rep(f); IsPerm4Rep(p);
true
true
gap> f^p=p^-1*f*p;
true

# PowPPerm4Perm4, Case 2 of 4, deg(f)>deg(p) and codeg(f)<=deg(p)
gap> f:=PartialPermNC([100000], [65536]);;
gap> p:=(17, 70000);;
gap> f^p=p^-1*f*p;
true

# PowPPerm4Perm4, Case 3 of 4, deg(f)<=deg(p) and codeg(f)>deg(p)
gap> f:=f^-1;
[65536,100000]
gap> f^p=p^-1*f*p;
true

# PowPPerm4Perm4, Case 4 of 4, deg(f)<=deg(p) and codeg(f)<=deg(p)
gap> f:=PartialPerm([1, 66000], [66000, 2]);; 
gap> p:=(17, 70000);;
gap> f^p=p^-1*f*p;
true

# QuoPPerm22, Case 1 of 4, dom(g) known,   dom(f) known
gap> f:=PartialPermNC( [ 1, 2, 4, 5, 6, 9, 10 ], [ 8, 7, 9, 5, 10, 6, 1 ] );;
gap> g:=PartialPermNC( [ 1, 2, 3, 4, 5, 6, 9, 10 ], 
> [ 5, 9, 7, 4, 2, 3, 6, 1 ] );
[10,1,5,2,9,6,3,7](4)
gap> f/g;
[4,2,3][5,1](9)(10)
gap> f*g^-1;
[4,2,3][5,1](9)(10)
gap> f*g^-1=f/g;
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(f);;
gap> g:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(g);;
gap> f/g=f*g^-1;
true
gap> f:=PartialPermNC([100000], [1]);
[100000,1]
gap> f/f;
<identity partial perm on [ 100000 ]>

# QuoPPerm22, Case 2 of 4, dom(g) known,   dom(f) unknown
gap> f:=PartialPermNC([5,9,4,2,0,3,7,6,0,10]);;
gap> g:=PartialPermNC( [ 1, 2, 3, 5, 6, 7, 10 ], [ 1, 8, 10, 4, 3, 7, 2 ] );
[5,4][6,3,10,2,8](1)(7)
gap> f/g;
[4,10,3,5](6)(7)
gap> f*g^-1;
[4,10,3,5](6)(7)
gap> f/g=f*g^-1;
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);;
gap> g:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(g);;
gap> f/g=f*g^-1;
true

# QuoPPerm22, Case 3 of 4, dom(g) unknown, dom(f) known
gap> g:=PartialPermNC([5,9,4,2,0,3,7,6,0,10]);;
gap> f:=PartialPermNC( [ 1, 2, 3, 5, 6, 7, 10 ], [ 1, 8, 10, 4, 3, 7, 2 ] );
[5,4][6,3,10,2,8](1)(7)
gap> f/g;
[5,3,10,4](6)(7)
gap> f*g^-1;
[5,3,10,4](6)(7)
gap> f:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(f);;
gap> g:=PartialPerm([1, 10000], [10000, 2]);;
gap> f/g=f*g^-1;
true

# QuoPPerm22, Case 4 of 4, dom(g) unknown, dom(f) unknown
gap> f:=PartialPermNC([ 1, 8, 10, 0, 4, 3, 7, 0, 0, 2 ]);;
gap> g:=PartialPermNC([5,9,4,2,0,3,7,6,0,10]);;
gap> f/g=f*g^-1;
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);;                          
gap> g:=PartialPerm([1, 10000], [10000, 2]);;
gap> f/g=f*g^-1;
true

# QuoPPerm22: corner cases
gap> PartialPermNC([1, 8, 10, 0, 4, 3, 7, 0, 0, 2]) / EmptyPartialPerm();
<empty partial perm>
gap> EmptyPartialPerm() / PartialPermNC([1, 8, 10, 0, 4, 3, 7, 0, 0, 2]);
<empty partial perm>
gap> PartialPerm([1, 2, 3]) / PartialPerm([4, 5, 6]);
<empty partial perm>

# QuoPPerm42, Case 1 of 4, dom(g) known,   dom(f) known
gap> f:=PPerm4( [ 1, 2, 4, 5, 6, 9, 10 ], [ 8, 7, 9, 5, 10, 6, 1 ] );;
gap> g:=PartialPermNC( [ 1, 2, 3, 4, 5, 6, 9, 10 ], 
> [ 5, 9, 7, 4, 2, 3, 6, 1 ] );
[10,1,5,2,9,6,3,7](4)
gap> f/g;
[4,2,3][5,1](9)(10)
gap> f*g^-1;
[4,2,3][5,1](9)(10)
gap> f*g^-1=f/g;
true
gap> f:=PPerm4([1, 10000], [10000, 2]);; DomainOfPartialPerm(f);;
gap> g:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(g);;
gap> f/g=f*g^-1;
true
gap> f:=PPerm4([100000], [1]);
[100000,1]
gap> f/f;
<identity partial perm on [ 100000 ]>

# QuoPPerm42, Case 2 of 4, dom(g) known,   dom(f) unknown
gap> f:=PPerm4([5,9,4,2,0,3,7,6,0,10]);;
gap> g:=PartialPermNC( [ 1, 2, 3, 5, 6, 7, 10 ], [ 1, 8, 10, 4, 3, 7, 2 ] );
[5,4][6,3,10,2,8](1)(7)
gap> f/g;
[4,10,3,5](6)(7)
gap> f*g^-1;
[4,10,3,5](6)(7)
gap> f/g=f*g^-1;
true
gap> f:=PPerm4([1, 10000], [10000, 2]);;
gap> g:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(g);;
gap> f/g=f*g^-1;
true

# QuoPPerm42, Case 3 of 4, dom(g) unknown, dom(f) known
gap> g:=PartialPermNC([5,9,4,2,0,3,7,6,0,10]);;
gap> f:=PPerm4( [ 1, 2, 3, 5, 6, 7, 10 ], [ 1, 8, 10, 4, 3, 7, 2 ] );
[5,4][6,3,10,2,8](1)(7)
gap> f/g;
[5,3,10,4](6)(7)
gap> f*g^-1;
[5,3,10,4](6)(7)
gap> f:=PPerm4([1, 10000], [10000, 2]);; DomainOfPartialPerm(f);;
gap> g:=PartialPerm([1, 10000], [10000, 2]);;
gap> f/g=f*g^-1;
true

# QuoPPerm42, Case 4 of 4, dom(g) unknown, dom(f) unknown
gap> f:=PPerm4([ 1, 8, 10, 0, 4, 3, 7, 0, 0, 2 ]);;
gap> g:=PartialPermNC([5,9,4,2,0,3,7,6,0,10]);;
gap> f/g=f*g^-1;
true
gap> f:=PPerm4([1, 10000], [10000, 2]);;                          
gap> g:=PartialPerm([1, 10000], [10000, 2]);;
gap> f/g=f*g^-1;
true

# QuoPPerm42: corner cases
gap> PPerm4([1, 8, 10, 0, 4, 3, 7, 0, 0, 2]) / EmptyPartialPerm();
<empty partial perm>
gap> EMPTY_PPERM4 / PartialPermNC([1, 8, 10, 0, 4, 3, 7, 0, 0, 2]);
<empty partial perm>
gap> PPerm4([1, 2, 3]) / PartialPerm([4, 5, 6]);
<empty partial perm>

# QuoPPerm24, Case 1 of 4, dom(g) known,   dom(f) known
gap> f:=PartialPerm( [ 1, 2, 4, 5, 6, 9, 10 ], [ 8, 7, 9, 5, 10, 6, 1 ] );;
gap> g:=PPerm4( [ 1, 2, 3, 4, 5, 6, 9, 10 ], 
> [ 5, 9, 7, 4, 2, 3, 6, 1 ] );
[10,1,5,2,9,6,3,7](4)
gap> f/g;
[4,2,3][5,1](9)(10)
gap> f*g^-1;
[4,2,3][5,1](9)(10)
gap> f*g^-1=f/g;
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);; DomainOfPartialPerm(f);;
gap> g:=PPerm4([1, 10000], [10000, 2]);; DomainOfPartialPerm(g);;
gap> f/g=f*g^-1;
true
gap> f:=PartialPerm([100000], [1]);
[100000,1]
gap> f/f;
<identity partial perm on [ 100000 ]>

# QuoPPerm24, Case 2 of 4, dom(g) known,   dom(f) unknown
gap> f:=PartialPerm([5,9,4,2,0,3,7,6,0,10]);;
gap> g:=PPerm4( [ 1, 2, 3, 5, 6, 7, 10 ], [ 1, 8, 10, 4, 3, 7, 2 ] );
[5,4][6,3,10,2,8](1)(7)
gap> f/g;
[4,10,3,5](6)(7)
gap> f*g^-1;
[4,10,3,5](6)(7)
gap> f/g=f*g^-1;
true
gap> f:=PartialPerm([1, 10000], [10000, 2]);;
gap> g:=PPerm4([1, 10000], [10000, 2]);; DomainOfPartialPerm(g);;
gap> f/g=f*g^-1;
true

# QuoPPerm24, Case 3 of 4, dom(g) unknown, dom(f) known
gap> g:=PPerm4([5,9,4,2,0,3,7,6,0,10]);;
gap> f:=PartialPerm( [ 1, 2, 3, 5, 6, 7, 10 ], [ 1, 8, 10, 4, 3, 7, 2 ] );
[5,4][6,3,10,2,8](1)(7)
gap> f/g;
[5,3,10,4](6)(7)
gap> f*g^-1;
[5,3,10,4](6)(7)
--> --------------------

--> maximum size reached

--> --------------------

[ Dauer der Verarbeitung: 0.22 Sekunden  (vorverarbeitet)  ]