Collaboration diagram for atlas::kl::helper::Thicket:
Public Types | |
| typedef std::vector< Edge > | EdgeList |
Public Member Functions | |
| Thicket () | |
| Thicket (Helper &, BlockElt) | |
| Constructs a thicket from y. | |
| ~Thicket () | |
| BlockElt | cross (size_t s, BlockElt y) const |
| Cross action of simple reflection s on block element y. | |
| const descents::DescentStatus & | descent (BlockElt y) const |
| List of RankMax unsigned chars; number s gives the descent status 0-7 of simple root s for y. | |
| descents::DescentStatus::Value | descentValue (size_t s, BlockElt y) const |
| Unsigned char between 0 and 7; gives the descent of simple root s for y. | |
| const EdgeList & | edgeList (size_t j) const |
| List of |Edge|s ending at y_j. | |
| KLPolRef | klPol (BlockElt x, size_t pos) const |
| KL polynomial P_{x,y_pos}, for any y_pos in Thicket. | |
| const klsupport::PrimitiveRow & | primitiveRow (size_t j) const |
| List of all x of length strictly less than l(y) that are primitive with respect to y_j. | |
| size_t | nonExtremal (BlockElt x) const |
| Returns the position in d_vertices of the first y that is not extremal w.r.t. x, size() if there is no such y. | |
| KLIndex | one () const |
| Pointer to the KL polynomial one. | |
| size_t | rank () const |
| Semisimple rank. | |
| size_t | size () const |
| Number of vertices in Thicket. | |
| const std::vector< BlockElt > & | vertices () const |
| List of vertices in Thicket. | |
| KLIndex | zero () const |
| Pointer to the KL polynomial zero. | |
| bool | ascentCompute (BlockElt x, size_t pos) |
| Checks if x has an ascent in row y_pos, and computes the K-L pol in that case. | |
| void | edgeCompute (BlockElt x, size_t pos, const Edge &e) |
| Computes the K-L polynomial for x in row pos, using the recurrence relation from e. | |
| void | fill () |
| Fills in the K-L polynomials for the elements of the thicket. | |
| void | fillXList () |
| Puts in d_xlist the union of the extremal lists for the elements of the thicket, top element excluded. | |
| KLRow & | klRow (BlockElt y) |
| KLStore & | store () |
Private Types | |
| typedef klsupport::PrimitiveRow::iterator | PI |
| typedef KLRow::iterator | KLI |
Private Attributes | |
| std::vector< BlockElt > | d_vertices |
| List of elements y_j in Thicket. | |
| std::vector< EdgeList > | d_edges |
| Entry j lists the edges ending at y_j. | |
| std::vector< BlockElt > | d_xlist |
| List of all x that are extremal with respect to some y in Thicket. | |
| std::vector< klsupport::PrimitiveRow > | d_extr |
| Entry j lists all x of length strictly less than l(y) that are extremal with respect to y_j. | |
| std::vector< klsupport::PrimitiveRow > | d_prim |
| Entry j lists all x of length strictly less than l(y) that are primitive with respect to y_j. | |
| std::vector< KLRow > | d_klr |
| std::vector< PI > | d_firstPrim |
| std::vector< KLI > | d_firstKL |
| Helper * | d_helper |
A pair (y_j, s x y_j) (with s type II real) is an Edge of the thicket. Such an s is a descent for both y_j and s x y_j. The pair is the image of the Cayley transform (type II imaginary) of a single element y_0, of length one less. The first class of KL recursion relations used in a Thicket is this:
P_{x,y_j} + P_{x,s x y_j} = [formula involving various P_{? , y_0}].
The right hand side terms here are known by induction on y, and recorded in the recursion data member of the Edge. We can therefore compute P_{x,y} as soon as we know P_{x,y'} for a single element y' in the thicket. For that (given x) we find essentially three possibilities:
1) x is equal to y', so P_{x,y'} = 1.
2) There is an s that is a good ascent for x (not in tau(x), and leading to an x' of length one more than the length of x), but is type II real for y'. In this case there is a recursion formula something like
P_{x,y'} = P_{x' , y'}.
(If s is type II imaginary for x, then there are two terms on the right.) In any case the right side is known by downward induction on x, so finally we know all P_{x,y_j} for y_j in the Thicket.
3) P_{x,y'} = 0.
This computation is carried out in the member function fill(). '
Definition at line 278 of file kl.cpp.
|
|
Definition at line 283 of file kl.cpp. Referenced by Thicket(). |
|
|
|
|
|
|
|
|
|
|
||||||||||||
|
Constructs a thicket from y. Explanation: the thicket of y is the connected component of y in the graph whose edges are the real type II cross-actions. It is therefore contained in the R-packet of y. The edges of the thicket are a spanning tree; each edge goes from y1 to y2, where y2 is obtained from y1 through real cross action by s (the position of y2 in the vertex list, and s, are recorded in the edge). The recursion recorded is the recursion for s as a descent of y2. In this way, we can move along a path of edges and have the required recursion formulas available for computing the polynomial for y2 from that of y1 (all edges are two-sided, i.e., we also make the corresponding edge from y2 to y1.) Definition at line 1689 of file kl.cpp. References atlas::hashtable::HashTable< Entry, Number >::begin(), cross(), d_edges, d_extr, d_firstKL, d_firstPrim, d_helper, d_klr, d_prim, d_vertices, descentValue(), atlas::graph::Edge, EdgeList, atlas::hashtable::HashTable< Entry, Number >::end(), atlas::hashtable::HashTable< Entry, Number >::find(), atlas::kl::KLContext::makeExtremalRow(), atlas::kl::KLContext::makePrimitiveRow(), rank(), atlas::kl::helper::Helper::recursionRow(), size(), and atlas::hashtable::HashTable< Entry, Number >::swap(). |
|
|
|
|
||||||||||||
|
Checks if x has an ascent in row y_pos, and computes the K-L pol in that case. Precondition: x is primitive in the row; Explanation: If the ascent exists, it will be imaginary type II. if x1 = (x1.first,x1.second) is the corresponding Cayley transform, the formula is P_x = P_x1.first + P_x1.second, both of which can be read off from the known part of the row. Definition at line 1806 of file kl.cpp. References atlas::kl::helper::Helper::cayley(), d_firstKL, d_firstPrim, atlas::kl::helper::Helper::d_hashtable, d_helper, d_vertices, descent(), atlas::kl::helper::firstAscent(), atlas::polynomials::Polynomial< C >::isZero(), klPol(), atlas::kl::KLPol, atlas::hashtable::HashTable< Entry, Number >::match(), rank(), and atlas::polynomials::Polynomial< C >::safeAdd(). Referenced by fill(). |
|
||||||||||||
|
Cross action of simple reflection s on block element y.
Definition at line 340 of file kl.cpp. References atlas::kl::helper::Helper::cross(). Referenced by Thicket(). |
|
|
List of RankMax unsigned chars; number s gives the descent status 0-7 of simple root s for y.
Definition at line 348 of file kl.cpp. References atlas::kl::helper::Helper::descent(). Referenced by ascentCompute(), and nonExtremal(). |
|
||||||||||||
|
Unsigned char between 0 and 7; gives the descent of simple root s for y.
Definition at line 357 of file kl.cpp. References atlas::kl::helper::Helper::descentValue(). Referenced by Thicket(). |
|
||||||||||||||||
|
Computes the K-L polynomial for x in row pos, using the recurrence relation from e. Precondition: x is extremal in the row; e points towards pos; the polynomial for x for the source of e is known. Explanation: P_{x,pos} + P_{x,source} will be given by the recurrence relation corresponding to x. Definition at line 1839 of file kl.cpp. References atlas::hashtable::HashTable< Entry, Number >::begin(), d_extr, d_firstKL, d_firstPrim, atlas::kl::helper::Helper::d_hashtable, d_helper, d_vertices, atlas::polynomials::Polynomial< C >::isZero(), klPol(), atlas::kl::KLPol, atlas::hashtable::HashTable< Entry, Number >::match(), atlas::kl::helper::Thicket::Edge::recursion, atlas::polynomials::Polynomial< C >::safeSubtract(), and atlas::kl::helper::Thicket::Edge::source. Referenced by fill(). |
|
|
List of |Edge|s ending at y_j.
Definition at line 364 of file kl.cpp. Referenced by atlas::kl::helper::ThicketIterator::operator++(), and atlas::kl::helper::ThicketIterator::ThicketIterator(). |
|
|
Fills in the K-L polynomials for the elements of the thicket. Algorithm: for each element y_j of the thicket, we have the list of primitive elements pr[j], and a list of K-L polynomials klv[j]. We are going to fill in the polynomials downwards from the top (the top elements being all ones); at the end of the process, we will have iterators pointing into each pr[j] and each klv[j], where the extremal list from that iterator on will contain all x'es for which the klpol is non zero (in other words, the other ones have been "weeded out" from pr[j]), and klv[j] from the iterator on contains the corresponding polynomials. Then all that remains to do is copy these onto the corresponding lists of the context. In order to achieve this, we put in d_xlist an ordered list of all elements that are primitive for _some_ y_j, not equal to y_j, and we move downwards in that list. It is guaranteed by Lemma 6.2 in David's notes, that for each x in d_xlist there is a y_j for which there is an easy reduction (i.e., x might be primitive for y_j, but not extremal.) So we can deduce P_{x,y_j} from the already known part of klv[j], and then traversing the tree structure of edge relations imposed on the thicket, we can compute all the other P_{x,y_i} that need to be (i.e., those for which x is in pr[j].) We record the result only if the corresponding polynomial is non-zero. Definition at line 1888 of file kl.cpp. References ascentCompute(), atlas::bits::copy(), d_firstKL, d_firstPrim, d_helper, atlas::kl::KLContext::d_kl, d_klr, atlas::kl::KLContext::d_one, atlas::kl::KLContext::d_prim, d_prim, d_vertices, d_xlist, atlas::kl::helper::ThicketIterator::edge(), edgeCompute(), fillXList(), nonExtremal(), atlas::kl::helper::Helper::nr_of_prim_nulls, atlas::kl::helper::Helper::prim_size, primitiveRow(), and size(). Referenced by atlas::kl::helper::Helper::fillThickets(). |
|
|
Puts in d_xlist the union of the extremal lists for the elements of the thicket, top element excluded.
Definition at line 1946 of file kl.cpp. References atlas::bits::copy(), d_xlist, primitiveRow(), and size(). Referenced by fill(). |
|
||||||||||||
|
KL polynomial P_{x,y_pos}, for any y_pos in Thicket.
Definition at line 371 of file kl.cpp. References atlas::kl::helper::Helper::klPol(), and atlas::kl::KLPolRef. Referenced by ascentCompute(), and edgeCompute(). |
|
|
Definition at line 433 of file kl.cpp. References atlas::kl::KLContext::d_kl, and atlas::kl::KLRow. |
|
|
Returns the position in d_vertices of the first y that is not extremal w.r.t. x, size() if there is no such y.
Definition at line 1780 of file kl.cpp. References d_vertices, descent(), atlas::kl::helper::firstAscent(), rank(), and size(). Referenced by fill(). |
|
|
Pointer to the KL polynomial one.
Definition at line 392 of file kl.cpp. References atlas::kl::KLContext::d_one, and atlas::kl::KLIndex. |
|
|
List of all x of length strictly less than l(y) that are primitive with respect to y_j. Primitive means that each descent for y_j is either a descent for x or type II imaginary for x. Definition at line 383 of file kl.cpp. Referenced by fill(), and fillXList(). |
|
|
Semisimple rank.
Definition at line 399 of file kl.cpp. References atlas::kl::KLContext::rank(). Referenced by ascentCompute(), nonExtremal(), and Thicket(). |
|
|
Number of vertices in Thicket.
Definition at line 406 of file kl.cpp. References atlas::kl::KLContext::size(). Referenced by fill(), fillXList(), nonExtremal(), atlas::kl::helper::ThicketIterator::operator++(), Thicket(), and atlas::kl::helper::ThicketIterator::ThicketIterator(). |
|
|
Definition at line 437 of file kl.cpp. References atlas::kl::KLContext::d_store, and atlas::kl::KLStore. |
|
|
List of vertices in Thicket.
|
|
|
Pointer to the KL polynomial zero.
Definition at line 420 of file kl.cpp. References atlas::kl::KLContext::d_zero, and atlas::kl::KLIndex. |
|
|
Entry j lists the edges ending at y_j.
Definition at line 298 of file kl.cpp. Referenced by Thicket(). |
|
|
Entry j lists all x of length strictly less than l(y) that are extremal with respect to y_j. Extremal means that each descent for y_j is a descent for x. Definition at line 311 of file kl.cpp. Referenced by edgeCompute(), and Thicket(). |
|
|
Definition at line 323 of file kl.cpp. Referenced by ascentCompute(), edgeCompute(), fill(), and Thicket(). |
|
|
Definition at line 322 of file kl.cpp. Referenced by ascentCompute(), edgeCompute(), fill(), and Thicket(). |
|
|
Definition at line 324 of file kl.cpp. Referenced by ascentCompute(), edgeCompute(), fill(), and Thicket(). |
|
|
|
|
|
Entry j lists all x of length strictly less than l(y) that are primitive with respect to y_j. Primitive means that each descent for y_j is either a descent for x or type II imaginary for x. |
|
|
List of elements y_j in Thicket.
Definition at line 293 of file kl.cpp. Referenced by ascentCompute(), edgeCompute(), fill(), nonExtremal(), and Thicket(). |
|
|
List of all x that are extremal with respect to some y in Thicket.
Definition at line 303 of file kl.cpp. Referenced by fill(), and fillXList(). |
1.3.9.1