Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Bib Ind
Top of Book Previous Chapter Next Chapter

8 Algebras
8.1 Creators for FR algebras
8.1-1 FRAlgebra
8.1-2 SCAlgebra
8.1-3 BranchingIdeal
8.2 Operations for FR algebras
8.2-1 MatrixQuotient
8.2-2 ThinnedAlgebra
8.2-3 Nillity

### 8 Algebras

Self-similar algebras and algebras with one (below FR algebras) are simply algebras [with one] whose elements are linear FR machines. They naturally act on the alphabet of their elements, which is a vector space.

Elements may be added, subtracted and multiplied. They can be vector or algebra linear elements; the vector elements are in general preferable, for efficiency reasons.

Finite-dimensional approximations of self-similar algebras can be computed; they are given as matrix algebras.

#### 8.1 Creators for FR algebras

The most straightforward creation method for FR algebras is `Algebra()`, applied with linear FR elements as arguments. There are shortcuts to this somewhat tedious method:

##### 8.1-1 FRAlgebra

`> FRAlgebra`( ring, {definition, } ) | ( operation )

`> FRAlgebraWithOne`( ring, {definition, } ) | ( operation )

Returns: A new self-similar algebra [with one].

This function constructs a new FR algebra [with one], generated by linear FR elements. It receives as argument any number of strings, each of which represents a generator of the object to be constructed.

ring is the acting domain of the vector space on which the algebra will act.

Each definition is of the form `"name=[[...],...,[...]]"` or of the form `"name=[[...],...,[...]]:out"`, namely a matrix whose entries are algebraic expressions in the `names`, possibly using `0,1`, optionally followed by a scalar. The matrix entries specify the decomposition of the element being defined, and the optional scalar specifies the output of that element, by default assumed to be one.

The option `IsVectorElement`, passed e.g. as in `FRAlgebra(Rationals,"a=[[a,1],[a,0]]":IsVectorElement)`, asks for the resulting algebra to be generated by vector elements. The generators must of course be finite-state. Their names ("a",...) are not remembered in the constructing algebra (but can be set using `SetName` (Reference: SetName)).

    gap> m := FRAlgebra(Rationals,"a=[[1,a],[a,0]]");
    <self-similar algebra on alphabet Rationals^2 with 1 generator>
    gap> Display(Activity(m.1,2));
    [ [  1,  0,  1,  1 ],
      [  0,  1,  1,  0 ],
      [  1,  1,  0,  0 ],
      [  1,  0,  0,  0 ] ]

##### 8.1-2 SCAlgebra

`> SCAlgebra`( m ) | ( operation )

`> SCAlgebraWithOne`( m ) | ( operation )

`> SCAlgebraNC`( m ) | ( operation )

`> SCAlgebraWithOneNC`( m ) | ( operation )

Returns: The state-closed algebra [with one] generated by the machine m.

This function constructs a new FR algebra [vith one] `a`, generated by all the states of the FR machine m. There is a bijective correspondence between `GeneratorsOfFRMachine(m)` and the generators of `a`, which is accessible via `Correspondence(a)` (See `Correspondence` (7.1-3)); it is a homomorphism from the stateset of m to `a`, or a list indicating for each state of m a corresponding generator index in the generators of `a` (with 0 for identity).

In the non-`NC` forms, redundant (equal, zero or one) states are removed from the generating set of `a`.

    gap> a := SCAlgebra(AsLinearMachine(Rationals,I4Machine));
    <self-similar algebra on alphabet Rationals^2 with 3 generators>
    gap> a.1 = AsLinearElement(Rationals,I4Monoid.1);
    true

##### 8.1-3 BranchingIdeal

`> BranchingIdeal`( A ) | ( operation )

Returns: An ideal I that contains matrices over itself.

    gap> !!!

#### 8.2 Operations for FR algebras

##### 8.2-1 MatrixQuotient

`> MatrixQuotient`( a, l ) | ( operation )

`> EpimorphismMatrixQuotient`( a, l ) | ( operation )

Returns: The matrix algebra of a's action on level l.

The first function returns the matrix algebra generated by the activities of a on level l (see the examples in 6.1-6). The second functon returns an algebra homomorphism from a to the matrix algebra.

    gap> a := ThinnedAlgebraWithOne(GF(2),GrigorchukGroup);
    <self-similar algebra-with-one on alphabet GF(2)^2 with 4 generators>
    gap> List([0..4],i->Dimension(MatrixQuotient(a,i)));
    [ 1, 2, 6, 22, 78 ]

##### 8.2-2 ThinnedAlgebra

`> ThinnedAlgebra`( r, g ) | ( operation )

`> ThinnedAlgebraWithOne`( r, g ) | ( operation )

Returns: The thinned algebra [with one] associated with g.

The first function returns the thinned algebra of a FR group/monoid/semigroup g, over the domain r. This is the linear envelope of g in its natural action on sequences.

The embedding of g in its thinned algebra is returned by `Embedding(g,a)`.

    gap> a := ThinnedAlgebraWithOne(GF(2),GrigorchukGroup);
    <self-similar algebra on alphabet GF(2)^2 with 5 generators>
    gap> a.1 = GrigorchukGroup.1^Embedding(GrigorchukGroup,a);
    true
    gap> Dimension(VectorSpace(GF(2),[One(a),a.2,a.3,a.4]));
    3

##### 8.2-3 Nillity

`> Nillity`( x ) | ( operation )

Returns: The smallest `n` such that x^n=0.

This command computes the nillity of x, i.e. the smallest `n` such that x^n=0. The command is of course not guaranteed to terminate.

Top of Book Previous Chapter Next Chapter
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 Bib Ind

generated by GAPDoc2HTML