193 lines
9.0 KiB
GDScript3
193 lines
9.0 KiB
GDScript3
## bytable.gd RAQ Quasigroups, racks, and quandles by multiplication tables.
|
|
|
|
#! @Chapter basic
|
|
#! @Section table_predicates
|
|
#! @SectionTitle Predicates on multiplication tables
|
|
#! @Arguments matrix
|
|
#! @Description This property is true if <A>matrix</A> is the multiplication
|
|
#! table of a magma which satisfies the left self-distributive property (see
|
|
#! <Ref Filt="IsLSelfDistElement" Label="for IsMultiplicativeElement"/>))
|
|
#! for all triples of elements.
|
|
DeclareProperty( "IsLeftSelfDistributiveTable", IsMatrix );
|
|
#! @Arguments matrix
|
|
#! @Description This property is true if <A>matrix</A> is the multiplication
|
|
#! table of a magma which satisfies the rightt self-distributive property (see
|
|
#! <Ref Filt="IsLSelfDistElement" Label="for IsMultiplicativeElement"/>))
|
|
#! for all triples of elements.
|
|
DeclareProperty( "IsRightSelfDistributiveTable", IsMatrix );
|
|
#! @Arguments matrix
|
|
#! @Description This property is true if for all $i$ less than or equal to the
|
|
#! number of rows of <A>matrix</A>, the $(i,i)$ entry of <A>matrix</A> is
|
|
#! $i$.
|
|
DeclareProperty( "IsElementwiseIdempotentTable", IsMatrix );
|
|
|
|
#! @Chapter operate
|
|
#! @Section table
|
|
#! @Section Information related to the multiplication table.
|
|
#! Note that typically the functions in this section will fail unless the
|
|
#! argument was either created with a multiplication table, or at least has
|
|
#! had its multiplication table explicitly computed.
|
|
#! @Arguments obj
|
|
#! @Returns a list of permutations of length equal to `Size(obj)`, or fail
|
|
#! @Description The $i$th element of the list returned is the permutation
|
|
#! determined by the $i$th row of the multiplication table of
|
|
#! <A>obj</A> (in the sense of the core &GAP;
|
|
#! function `PermList`). Returns fail if any row of the multiplication table
|
|
#! does not determine a permuation.
|
|
DeclareAttribute("LeftPerms", HasMultiplicationTable);
|
|
#! @BeginExampleSession
|
|
#! gap> D3 := LeftQuandleByMultiplicationTable([[1,3,2],[3,2,1],[2,1,3]]);
|
|
#! <left quandle with 3 generators>
|
|
#! gap> LeftPerms(D3);
|
|
#! [ (2,3), (1,3), (1,2) ]
|
|
#! @EndExampleSession
|
|
|
|
#! @Arguments obj
|
|
#! @Returns a list of permutations of length equal to `Size(obj)`, or fail
|
|
#! @Description The $i$th element of the list returned is the permutation
|
|
#! determined by the $i$th column of the multiplication table of
|
|
#! <A>obj</A> (in the sense of the core &GAP;
|
|
#! function `PermList`). Returns fail if any column of the multiplication table
|
|
#! does not determine a permuation.
|
|
DeclareAttribute("RightPerms", HasMultiplicationTable);
|
|
#! @Arguments obj
|
|
#! @Returns an operation table matrix, or fail
|
|
#! @Description Presuming it is well-defined, this produces the operation
|
|
#! table (following similar conventions for multiplication tables, e.g.,
|
|
#! every entry is a natural number less than `Size(obj)`) for `LeftQuotient`
|
|
#! on the given <A>obj</A>. Returns fail if `LeftQuotient` is not
|
|
#! well-defined for <A>obj</A>.
|
|
DeclareAttribute("LeftDivisionTable", HasMultiplicationTable);
|
|
#! @Arguments obj
|
|
#! @Returns an operation table matrix, or fail
|
|
#! @Description Presuming it is well-defined, this produces the operation
|
|
#! table for `\/` (the typical elementwise (right) quotient) on the given
|
|
#! <A>obj</A>. Returns fail if `\/` is not
|
|
#! well-defined for <A>obj</A>.
|
|
DeclareAttribute("RightDivisionTable", HasMultiplicationTable);
|
|
#! @BeginExampleSession
|
|
#! gap> A4 := RightQuandleByMultiplicationTable([[1,4,2,3],
|
|
#! > [3,2,4,1],
|
|
#! > [4,1,3,2],
|
|
#! > [2,3,1,4]]);
|
|
#! <right quandle with 4 generators>
|
|
#! gap> RightDivisionTable(A4);
|
|
#! [ [ 1, 3, 4, 2 ], [ 4, 2, 1, 3 ], [ 2, 4, 3, 1 ], [ 3, 1, 2, 4 ] ]
|
|
#! @EndExampleSession
|
|
#! @Chapter construct
|
|
#! @Section from_scratch
|
|
#! @BeginGroup table_constructors
|
|
#! @GroupTitle Constructors from tables
|
|
#! @Returns a magma of the designated category
|
|
#! @Description These functions produce magmas from their multiplication
|
|
#! tables, exactly analogously with the core &GAP; function
|
|
#! `MagmaByMultiplicationTable` (q.v.); all of the same conventions are
|
|
#! followed, such as the table should be an $n\times n$ matrix in which
|
|
#! every entry is a natural number less than or equal to $n$. These
|
|
#! functions verify that the tables supplied in fact define an example of
|
|
#! the designated category.
|
|
#! @GroupInitialArguments table
|
|
DeclareGlobalFunction("LeftQuasigroupByMultiplicationTable");
|
|
DeclareGlobalFunction("LeftRackByMultiplicationTable");
|
|
DeclareGlobalFunction("LeftQuandleByMultiplicationTable");
|
|
DeclareGlobalFunction("RightQuasigroupByMultiplicationTable");
|
|
DeclareGlobalFunction("RightRackByMultiplicationTable");
|
|
DeclareGlobalFunction("RightQuandleByMultiplicationTable");
|
|
#! @EndGroup
|
|
|
|
#! @BeginExampleSession
|
|
#! gap> D3 := LeftQuandleByMultiplicationTable([[1,3,2],[3,2,1],[2,1,3]]);
|
|
#! <left quandle with 3 generators>
|
|
#! gap> SpecifyElmNamePrefix(D3, "d");
|
|
#! gap> Elements(D3);
|
|
#! [ d1, d2, d3 ]
|
|
#! gap> IsBound(d1);
|
|
#! false
|
|
#! gap> BindElmNames(D3);
|
|
#! gap> d1 * d2;
|
|
#! d3
|
|
#! @EndExampleSession
|
|
|
|
#! @BeginGroup unchecked_table_constructors
|
|
#! @GroupTitle Unchecked constructors from tables
|
|
#! @Returns a magma of the designated category
|
|
#! @Description Each of these functions is exactly like its counterpart
|
|
#! without the `NC` suffix, except that it does not perform any verification
|
|
#! that the supplied table in fact satisfies the necessary axioms for the
|
|
#! designated category. (The verification is skipped to save computation
|
|
#! time, for use in cases when the properties are known to hold.) Hence, use
|
|
#! with caution: the behavior of this
|
|
#! package if you supply a table which does not satisfy the appropiate
|
|
#! axioms is undefined.
|
|
#! @GroupInitialArguments table
|
|
DeclareGlobalFunction("LeftQuasigroupByMultiplicationTableNC");
|
|
DeclareGlobalFunction("LeftRackByMultiplicationTableNC");
|
|
DeclareGlobalFunction("LeftQuandleByMultiplicationTableNC");
|
|
DeclareGlobalFunction("RightQuasigroupByMultiplicationTableNC");
|
|
DeclareGlobalFunction("RightRackByMultiplicationTableNC");
|
|
DeclareGlobalFunction("RightQuandleByMultiplicationTableNC");
|
|
#! @EndGroup
|
|
|
|
## Property of a collection that its elements know their multiplication table
|
|
#! @Chapter technical
|
|
#! @Section reps
|
|
#! @SectionTitle Representational issues
|
|
#! @Arguments collection
|
|
#! @Description True if the family of the elements in the collection possesses
|
|
#! a global multiplication table. This value is used to control whether more
|
|
#! efficient algorithms are used in particular cases.
|
|
DeclareProperty("IsBuiltFromMultiplicationTable", IsCollection);
|
|
|
|
## Create quasigroups etc by permutations
|
|
#! @Chapter construct
|
|
#! @Section from_scratch
|
|
#! @BeginGroup perms_constructors
|
|
#! @GroupTitle Constructors from permutations
|
|
#! @Returns a magma of the designated category
|
|
#! @Description These functions produce magmas from a sequence of
|
|
#! permutations. That is to say, because all of the categories supported in
|
|
#! &RAQ; are quasigroups on at least one side, either the left
|
|
#! multiplicative action of an element on the magma is always a permutation
|
|
#! (in the case of left quasigroups) or the right multiplicative action of
|
|
#! an element on the magma is always a permutation. Hence, a magma in these
|
|
#! categories can always be specified by a list of $n$ permutations on
|
|
#! the natural numbers less than or equal to $n$ (i.e., ordinary &GAP;
|
|
#! permutations) and that's what these
|
|
#! functions do. In effect, the argument to the `Left` functions gives the
|
|
#! rows of the multiplication table (as permutation objects), and the to the
|
|
#! `Right` functions gives the columns.
|
|
#! @GroupInitialArguments permutation-list
|
|
DeclareGlobalFunction("LeftQuasigroupByPerms");
|
|
DeclareGlobalFunction("LeftRackByPerms");
|
|
DeclareGlobalFunction("LeftQuandleByPerms");
|
|
DeclareGlobalFunction("RightQuasigroupByPerms");
|
|
DeclareGlobalFunction("RightRackByPerms");
|
|
DeclareGlobalFunction("RightQuandleByPerms");
|
|
#! @EndGroup
|
|
|
|
#! @BeginExampleSession
|
|
#! gap> D3 := LeftQuandleByPerms( [ (2,3), (1,3), (1,2) ] );
|
|
#! <left quandle with 3 generators>
|
|
#! gap> SpecifyElmNamePrefix(D3, "p");
|
|
#! gap> BindElmNames(D3);
|
|
#! gap> p2*p3;
|
|
#! p1
|
|
#! @EndExampleSession
|
|
|
|
#! @BeginGroup unchecked_perms_constructors
|
|
#! @GroupTitle Unchecked constructors from permutations
|
|
#! @Returns a magma of the designated category
|
|
#! @Description These functions are exactly the same as their counterparts
|
|
#! without `NC` except that to save time they do not verify that the given
|
|
#! permutations satisfy the appropriate axioms. Hence use caution, as
|
|
#! supplying a list of permutations which does not form the proper structure
|
|
#! can lead to undefined behavior. Note that there are no unchecked versions
|
|
#! for the bare quasigroup constructors because the only properties required
|
|
#! are that all of the rows (or columns, in the `Right` case) are permutations.
|
|
#! @GroupInitialArguments permutation-list
|
|
DeclareGlobalFunction("LeftRackByPermsNC");
|
|
DeclareGlobalFunction("LeftQuandleByPermsNC");
|
|
DeclareGlobalFunction("RightRackByPermsNC");
|
|
DeclareGlobalFunction("RightQuandleByPermsNC");
|
|
#! @EndGroup
|