Public Member Functions | |
| Helper (const KLContext &) | |
| ~Helper () | |
| blocks::BlockEltPair | cayley (size_t s, BlockElt y) const |
| Cayley transform of block element y through simple root s. | |
| BlockElt | cross (size_t s, BlockElt y) const |
| Cross action of simple root s on block element y. | |
| const descents::DescentStatus & | descent (BlockElt y) const |
| Returns vector of RANK_MAX unsigned char; entry s gives descent status of simple root s for block element y. | |
| descents::DescentStatus::Value | descentValue (size_t s, BlockElt y) const |
| Unsigned char whose value gives the descent status of simple root s for block element y. | |
| size_t | firstDirectRecursion (BlockElt y) const |
| Returns the first descent generator that is not real type II. | |
| blocks::BlockEltPair | inverseCayley (size_t s, BlockElt y) const |
| KLPolRef | klPol (BlockElt x, BlockElt y, KLRow::const_iterator klv, klsupport::PrimitiveRow::const_iterator p_begin, klsupport::PrimitiveRow::const_iterator p_end) const |
| Returns the Kazhdan-Lusztig polynomial for x corresponding to the given row. | |
| bool | ascentMu (BlockElt x, BlockElt y, size_t s) const |
| Computes whether |mu(x,y)==1| in a good ascent situation. | |
| MuCoeff | goodDescentMu (BlockElt x, BlockElt y, size_t s) const |
| Gets |mu(x,y)| by a good descent recursion. | |
| MuCoeff | lengthOneMu (BlockElt x, BlockElt y) const |
| Computes $(x,y)$ in the special case that $l(y)-l(x) = 1$. | |
| size_t | orbit (BlockElt y) const |
| First coordinate (corresponding to K orbit on G/B) of pair of integers specifying block element y. | |
| size_t | dualOrbit (BlockElt y) const |
| Second coordinate (corresponding to K^vee orbit on G^vee/B^vee) of pair of integers specifying block element y. | |
| MuCoeff | type2Mu (BlockElt x, BlockElt y) const |
| Gets mu(x,y) by type II recursion. | |
| void | completePacket (BlockElt y) |
| Finishes the filling of the R-packet starting at y. | |
| void | directRecursion (BlockElt y, size_t s) |
| Fills in the row for y using a direct recursion. | |
| void | fill () |
| Dispatches the work of filling the KL- and mu-lists. | |
| void | fillKLRow (BlockElt y) |
| Fills in the row for y in the KL-table. | |
| void | fillMuRow (BlockElt y) |
| Fills in the row for y in the mu-table. | |
| void | fillThickets (BlockElt y) |
| Finishes the filling of the R-packet starting at y. | |
| void | muCorrection (std::vector< KLPol > &klv, const klsupport::PrimitiveRow &e, BlockElt y, size_t s) |
| Subtracts from klv the correcting terms in the K-L recursion. | |
| void | recursionRow (std::vector< KLPol > &klv, const klsupport::PrimitiveRow &e, BlockElt y, size_t s) |
| Puts in klv the right-hand side of the recursion formula for y corresponding to the descent s. | |
| void | writeRow (const std::vector< KLPol > &klv, const klsupport::PrimitiveRow &e, BlockElt y) |
| Writes down row y in d_kl and d_prim. | |
| KLPolRef | klPol (BlockElt x, BlockElt y) const |
| The Kazhdan-Lusztig-Vogan polynomial P_{x,y}. | |
Private Attributes | |
| KLHashStore | d_hashtable |
| size_t | prim_size |
| size_t | nr_of_prim_nulls |
Friends | |
| class | Thicket |
|
|
|
|
|
|
|
||||||||||||||||
|
Computes whether |mu(x,y)==1| in a good ascent situation. Preconditions: $l(y)>0$; $l(x)=l(y)-1$; $s$ is an ascent for $x$ w.r.t. $y$ Explanation: this is the situation where |mu(x,y)| is directly expressible. The point is that |x| will ascend to an element of the same length as |y|, so that the corresponding K-L polynomial is zero unless |x| ascends to |y|. Definition at line 884 of file kl.cpp. References cayley(), cross(), and descentValue(). Referenced by lengthOneMu(), and type2Mu(). |
|
||||||||||||
|
Cayley transform of block element y through simple root s.
Definition at line 147 of file kl.cpp. Referenced by atlas::kl::helper::Thicket::ascentCompute(), ascentMu(), and writeRow(). |
|
|
Finishes the filling of the R-packet starting at y. Precondition: all the rows in the packet capable of a direct recursion are filled; at least one row is of this form; Explanation: what we do here, is completing the rows that can be completed from the already filled ones, using real type II recursions. Whatever is left will constitute "thickets", and will be dealt with by another function. Algorithm: we traverse the set of y1 in the packet that can be obtained from one of the filled ones through real type II cross-actions. Definition at line 1078 of file kl.cpp. References atlas::kl::KLContext::block(), cross(), descentValue(), fillThickets(), klPol(), atlas::kl::KLContext::makeExtremalRow(), atlas::blocks::Block::R_packet(), atlas::kl::KLContext::rank(), recursionRow(), and writeRow(). Referenced by fillKLRow(). |
|
||||||||||||
|
Cross action of simple root s on block element y.
Definition at line 154 of file kl.cpp. Referenced by ascentMu(), completePacket(), atlas::kl::helper::Thicket::cross(), goodDescentMu(), muCorrection(), recursionRow(), and type2Mu(). |
|
|
Returns vector of RANK_MAX unsigned char; entry s gives descent status of simple root s for block element y.
Definition at line 162 of file kl.cpp. Referenced by atlas::kl::helper::Thicket::descent(), firstDirectRecursion(), type2Mu(), and writeRow(). |
|
||||||||||||
|
Unsigned char whose value gives the descent status of simple root s for block element y.
Definition at line 170 of file kl.cpp. Referenced by ascentMu(), completePacket(), atlas::kl::helper::Thicket::descentValue(), goodDescentMu(), muCorrection(), recursionRow(), and type2Mu(). |
|
||||||||||||
|
Fills in the row for y using a direct recursion. Precondition: s is either a complex, or a real type I descent generator for y. The real work is done by the recursionRow function, that will be used also in the real type II descents. Definition at line 1146 of file kl.cpp. References atlas::kl::KLContext::makeExtremalRow(), recursionRow(), and writeRow(). Referenced by fillKLRow(). |
|
|
Second coordinate (corresponding to K^vee orbit on G^vee/B^vee) of pair of integers specifying block element y.
|
|
|
Dispatches the work of filling the KL- and mu-lists.
Reimplemented from atlas::kl::KLContext. Definition at line 1166 of file kl.cpp. References atlas::hashtable::HashTable< Entry, Number >::capacity(), d_hashtable, atlas::klsupport::KLSupport::fill(), fillKLRow(), fillMuRow(), atlas::kl::KLPol, atlas::kl::KLContext::length(), atlas::kl::KLContext::lengthLess(), prim_size, atlas::hashtable::HashTable< Entry, Number >::size(), and atlas::klsupport::KLSupport::size(). Referenced by atlas::kl::KLContext::fill(). |
|
|
Fills in the row for y in the KL-table. Precondition: all lower rows have been filled; y is of length > 0; R-packets are consecutively numbered; Explanation: this function actually fills out the whole R-packet to which y belongs (unless it returns immediately). This is done in two stages: first, we fill the rows for which there is a direct recursion relation. The second stage, if any, is forwarded to the completePacket function. Definition at line 1274 of file kl.cpp. References atlas::kl::KLContext::block(), completePacket(), directRecursion(), firstDirectRecursion(), atlas::blocks::Block::R_packet(), and atlas::kl::KLContext::rank(). Referenced by fill(). |
|
|
Fills in the row for y in the mu-table. Precondition: the row for y in the KL-table has been filled; length(y) > 0; Explanation: for the elements of length < length(y) - 1, mu(x,y) can be non-zero only if x is extremal w.r.t. y; so we run through d_kl[y], and look at the cases where the polynomial is of degree (1/2)(l(y)-l(x)-1) (the biggest possible). For the elements of colength 1, in the classical case we always had mu(x,y)=1. Here that's not true anymore, zero might be a possibility, and also larger values I believe; but at any rate the mu-values can be computed in terms of other mu-values. NOTE: we are not using the hasse-list here, although it is probably a good idea to compute that; that will reduce the mu-computation. Definition at line 1317 of file kl.cpp. References atlas::kl::KLIndex, atlas::kl::KLPolRef, atlas::kl::KLContext::length(), atlas::kl::KLContext::lengthLess(), lengthOneMu(), and atlas::kl::MuCoeff. Referenced by fill(). |
|
|
Finishes the filling of the R-packet starting at y. Precondition: all the rows in the packet that are not part of a "thicket" have already been filled. Explanation: a thicket is an element that has only real type II descents, and that moreover is such that all elements in its conected component for the relation of being connected by a sequence of real type II cross-actions, is of the same form (for instance, it happens quite often that the principal series representations are a thicket.) Then we must use the "structural fact" in Lemma 6.2 of David's Park City notes: for each x lower than y, there is an element y' of the thicket for which x has an ascent (or if there is no such y', the K-L polynomial is zero.) Algorithm: (a) for each y' in the R-packet that has not already been filled, we determine the thicket of y' via a traversal algorithm, as usual (b) we fill in all the P_{x,y} in that thicket by a downwards recursion. In order to do that, we put the union of all the x'es in the extremal lists in a common ordered list. Then we move down the list; for each x, by assumption there is an y' in the thicket for which it is not extremal, and starting from there we can fill in P_{x,y} in all the rows where it needs to be filled. NOTE: thickets are always small, at the very worst a few hundred elements, so we don't have to worry about efficiency here. NOTE: perhaps it might be expected that there is usually (always?) a "large" element in the thicket, that would provide ascents for all x'es. So it might be worthwhile to sort the elements in the thicket in order of number of descents. Definition at line 1393 of file kl.cpp. References atlas::kl::KLContext::block(), atlas::kl::helper::Thicket::fill(), and atlas::blocks::Block::R_packet(). Referenced by completePacket(). |
|
|
Returns the first descent generator that is not real type II. Explanation: those are the ones that give a direct recursion formula for the K-L basis element. Definition at line 832 of file kl.cpp. References descent(), and atlas::kl::KLContext::rank(). Referenced by fillKLRow(). |
|
||||||||||||||||
|
Gets |mu(x,y)| by a good descent recursion. Precondition: $l(y)>0$; $l(x)=l(y)-1$; all previous mu-rows have been filled in; |s| is a good descent for |y|; Explanation: a good descent for |y| is a descent that is neither real type II nor imaginary compact (so it is either a complex or real type I); these are the cases where |mu(x,y)| is directly expressed by recursion. Definition at line 919 of file kl.cpp. References cross(), descentValue(), inverseCayley(), atlas::kl::KLContext::mu(), and atlas::kl::MuCoeff. Referenced by type2Mu(). |
|
||||||||||||
|
Definition at line 176 of file kl.cpp. Referenced by goodDescentMu(), muCorrection(), and recursionRow(). |
|
||||||||||||
|
The Kazhdan-Lusztig-Vogan polynomial P_{x,y}.
|
|
||||||||||||||||||||||||
|
Returns the Kazhdan-Lusztig polynomial for x corresponding to the given row. Precondition: |klv| holds the tail of the set of primitive Kazhdan-Lusztig polynomials for |y|, enough to find the required one by elementary lookup; |[p_begin,p_end[| is the corresponding range of primitive elements. Algorithm: primitivize |x| with respect to the descents in |y|; if a real nonparity situation is encountered, return |Zero|; otherwise look up the primitive |x| in the range and return the corresponding element from |klv| Definition at line 860 of file kl.cpp. References atlas::kl::KLContext::descentSet(), atlas::kl::KLPolRef, and atlas::klsupport::KLSupport::primitivize(). Referenced by completePacket(), atlas::kl::helper::Thicket::klPol(), lengthOneMu(), muCorrection(), recursionRow(), and writeRow(). |
|
||||||||||||
|
Computes $(x,y)$ in the special case that $l(y)-l(x) = 1$. Preconditions: $l(y) > 0$; $l(x) = l(y)-1$; the $$-rows for all $y$ of smaller lengths have already been filled in. Explanation: these are the $$-values that can come up in possibly non-extremal situations. The value can be obtaind simply as the constant term of |klPol(x,y)|, but for efficiency reasons we handle some easy cases directly, avoiding the cost of calling |klPol|. In fact in all the cases these values of $$ can be, and used to be, computed recursively by formulas using only other $$-values of the same kind. Definition at line 964 of file kl.cpp. References atlas::bitset::BitSet< n >::andnot(), atlas::bitset::BitSet< n >::any(), ascentMu(), atlas::kl::KLContext::descentSet(), atlas::bitset::BitSet< n >::firstBit(), klPol(), atlas::kl::KLPolRef, atlas::kl::MuCoeff, and atlas::bitset::RankFlags. Referenced by fillMuRow(). |
|
||||||||||||||||||||
|
Subtracts from klv the correcting terms in the K-L recursion. Precondtion: klp contains the terms corresponding to c_s.c_y, for the x that are extremal w.r.t. y; the mu-table and KL-table has been filled in for elements of length <= y. Explanation: the recursion formula is of the form: lhs = c_s.c_{y1} - sum_{z} mu(z,y1)c_z where z runs over the elements < y such that s is a descent for z, y1 is s.y, and lhs is c_y when s is a complex descent or real type I for y, and c_{y}+c_{s.y} when s is real type II. Definition at line 1425 of file kl.cpp. References cross(), descentValue(), inverseCayley(), klPol(), atlas::kl::KLPolRef, atlas::kl::KLContext::length(), atlas::kl::MuCoeff, and atlas::kl::MuRow. Referenced by recursionRow(). |
|
|
First coordinate (corresponding to K orbit on G/B) of pair of integers specifying block element y.
|
|
||||||||||||||||||||
|
Puts in klv the right-hand side of the recursion formula for y corresponding to the descent s. Precondition: s is either a complex, or a real type I or type II descent generator for y. Explanation: the shape of the formula is: P_{x,y} = (c_s.c_{y1})-part - correction term where y1 = cross(s,y) when s is complex for y, one of the two elements in inverseCayley(s,y) when s is real. The (c_s.c_{y1})-part depends on the status of x w.r.t. s (we look only at extremal x, so we know it is a descent); the correction term, coming from sum_z mu(z,y1)c_z, depends only on y1. Definition at line 1511 of file kl.cpp. References cross(), descentValue(), inverseCayley(), klPol(), and muCorrection(). Referenced by completePacket(), directRecursion(), and atlas::kl::helper::Thicket::Thicket(). |
|
||||||||||||
|
Gets mu(x,y) by type II recursion. This code is currently unused (see lengthOneMu above). Precondition: length(y) > 0; length(x) = length(y)-1; all previous mu-rows have been filled in; x is extremal w.r.t. y, and all descents of y are real type II; Explanation: in this situation, we have recursion formulas that will yield mu(x,y)+mu(x,s.y). It is known that proceeding in this way we must end up with a y' for which x is not extremal. Algorithm: we keep a stack of recursion formulas of the above kind, walking through the orbit of y under the simple descents, until we reach a y that (a) has a non-type-II descent, or (b) for which x is non-extremal. Definition at line 1005 of file kl.cpp. References ascentMu(), cross(), descent(), descentValue(), atlas::kl::helper::firstAscent(), goodDescentMu(), atlas::kl::MuCoeff, and atlas::kl::KLContext::rank(). |
|
||||||||||||||||
|
Writes down row y in d_kl and d_prim. Precondition: klv contains the polynomials corresponding to the extremal values in the row; er contains the corresponding (extremal with respect to y) block elements. Explanation: the difficulty is that we want to write down the _primitive_ elements, i.e., those x for which all descents for y are either descents or imaginary type II ascents; and moreover, we write down only those values for which the polynomial is nonzero. The values for which there is an imaginary type II ascent are computed "on the fly", from higher up values in the row. Definition at line 1604 of file kl.cpp. References atlas::hashtable::HashTable< Entry, Number >::begin(), cayley(), atlas::bits::copy(), d_hashtable, descent(), atlas::hashtable::HashTable< Entry, Number >::end(), atlas::kl::helper::firstAscent(), atlas::polynomials::Polynomial< C >::isZero(), klPol(), atlas::kl::KLPol, atlas::kl::KLRow, atlas::kl::KLContext::makePrimitiveRow(), atlas::hashtable::HashTable< Entry, Number >::match(), nr_of_prim_nulls, prim_size, atlas::kl::KLContext::rank(), and atlas::polynomials::Polynomial< C >::safeAdd(). Referenced by completePacket(), and directRecursion(). |
|
|
|
|
|
Definition at line 120 of file kl.cpp. Referenced by atlas::kl::helper::Thicket::ascentCompute(), atlas::kl::helper::Thicket::edgeCompute(), fill(), and writeRow(). |
|
|
Definition at line 125 of file kl.cpp. Referenced by atlas::kl::helper::Thicket::fill(), and writeRow(). |
|
|
Definition at line 124 of file kl.cpp. Referenced by atlas::kl::helper::Thicket::fill(), fill(), and writeRow(). |
1.3.9.1