1#############################################################################
2##
3#W  listops.gd              automgrp package                   Yevgen Muntyan
4#W                                                             Dmytro Savchuk
5##
6#Y  Copyright (C) 2003 - 2018 Yevgen Muntyan, Dmytro Savchuk
7##
8
9
10##  No function here checks correctness of arguments
11
12
13###############################################################################
14##
15##  AG_IsCorrectAutomatonList( <list>, <invertible> )
16##
17##  Checks whether the list is correct list to define automaton, i.e.:
18##  $[[a_11,...,a_1n,p_1],[a_21,...,a_2n,p_2],...,[a_m1...a_mn,p_m]]$,
19##  where $n >= 2$, $m >= 1$, $a_ij$ are IsInt in $[1..m]$; and all $p_i$ are
20##  in `SymmetricGroup'($n$) (semigroup of transformations of the set $\{1..n\}$)
21##  if <invertible>=`true' (`false').
22##
23DeclareGlobalFunction("AG_IsCorrectAutomatonList");
24
25
26###############################################################################
27##
28##  AG_IsCorrectRecurList( <list>, <invertible> )
29##
30##  Checks whether the list is correct list to define a self-similar group, i.e.:
31##  $[[a_11,...,a_1n,p_1],[a_21,...,a_2n,p_2],...,[a_m1...a_mn,p_m]]$,
32##  where $n >= 2$, $m >= 1$, $a_ij$ are `IsInt' in $[1..m]\cup [-m..-1]$ or `IsList' with
33##  entries from $[1..m]\cup [-m..-1]$; and all $p_i$ are
34##  in `SymmetricGroup'($n$) (semigroup of transformations of the set $\{1..n\}$)
35##  if <invertible>=`true' (`false').
36##
37DeclareGlobalFunction("AG_IsCorrectRecurList");
38
39
40###############################################################################
41##
42##  AG_InverseAutomatonList(<list>)
43##
44DeclareGlobalFunction("AG_InverseAutomatonList");
45
46
47###############################################################################
48##
49##  AG_ConnectedStatesInList( <state>, <list>)
50##
51##  Returns list of states which can be reached from given state.
52##
53DeclareGlobalFunction("AG_ConnectedStatesInList");
54
55
56###############################################################################
57##
58##  AG_IsTrivialStateInList( <state>, <list>)
59##
60##  Checks whether given state is trivial.
61##
62DeclareGlobalFunction("AG_IsTrivialStateInList");
63
64
65###############################################################################
66##
67##  AG_IsObviouslyTrivialStateInList( <state>, <list>)
68##
69##  Checks whether given state is obviously trivial.
70##  Works for lists generating self-similar groups.
71##  Returns `true' if <state>=(*,...,*)(), where
72##  * could be either +-<state> or [+-<state>].
73##
74DeclareGlobalFunction("AG_IsObviouslyTrivialStateInList");
75
76
77###############################################################################
78##
79##  AG_IsInvertibleStateInList( <state>, <list>)
80##
81##  Checks whether given state is invertible.
82##
83DeclareGlobalFunction("AG_IsInvertibleStateInList");
84
85
86###############################################################################
87##
88##  AG_AreEquivalentStatesInList( <state1>, <state2>, <list> )
89##
90##  Checks whether two given states are equivalent.
91##
92DeclareGlobalFunction("AG_AreEquivalentStatesInList");
93
94
95###############################################################################
96##
97##  AG_AreEquivalentStatesInLists( <state1>, <state2>, <list1>, <list2>)
98##
99##  Checks whether two given states in different lists are equivalent.
100##
101DeclareGlobalFunction("AG_AreEquivalentStatesInLists");
102
103
104###############################################################################
105##
106##  AG_ReducedAutomatonInList( <list> )
107##
108##  Returns [new_list, list_of_states] where new_list is a new list which
109##  represents reduced form of given automaton, i-th elmt of list_of_states
110##  is the number of i-th state of new automaton in the old one.
111##
112##  First state of returned list is always first state of given one.
113##  It does not remove trivial state, so it's not really ``reduced automaton'',
114##  it just removes equivalent states.
115##  TODO: write such function which removes trivial state
116##
117DeclareGlobalFunction("AG_ReducedAutomatonInList");
118
119
120###############################################################################
121##
122##  AG_MinimalSubAutomatonInlist(<states>, <list>)
123##
124##  Returns list representation of automaton given by <list> which is minimal
125##  subatomaton of automaton containing states <states>.
126##
127DeclareGlobalFunction("AG_MinimalSubAutomatonInlist");
128
129
130###############################################################################
131##
132##  AG_PermuteStatesInList(<list>, <perm>)
133##
134##  I guess it means that i-th state goes to (i^perm)-th place.
135##
136DeclareGlobalFunction("AG_PermuteStatesInList");
137
138
139###############################################################################
140##
141##  AG_ImageOfVertexInList(<list>, <init>, <vertex>)
142##
143DeclareGlobalFunction("AG_ImageOfVertexInList");
144
145
146###############################################################################
147##
148##  AG_WordStateInList(<word>, <s>, <list>, <reduce>, <trivstate>)
149##  AG_WordStateAndPermInList(<word>, <s>, <list>)
150##
151##  It's ProjectWord from selfs.g
152##
153DeclareGlobalFunction("AG_WordStateInList");
154DeclareGlobalFunction("AG_WordStateAndPermInList");
155
156
157###############################################################################
158##
159##  AG_DiagonalPowerInList(<list>, <n>)
160##
161DeclareGlobalFunction("AG_DiagonalPowerInList");
162
163
164###############################################################################
165##
166##  AG_MultAlphabetInList(<list>, <n>)
167##
168DeclareGlobalFunction("AG_MultAlphabetInList");
169
170
171###############################################################################
172##
173##  AG_HasDualInList(<list>)
174##  AG_HasDualOfInverseInList(<list>)
175##  AG_DualAutomatonList(<list>)
176##
177DeclareGlobalFunction("AG_HasDualInList");
178DeclareGlobalFunction("AG_HasDualOfInverseInList");
179DeclareGlobalFunction("AG_DualAutomatonList");
180
181
182#E
183