#include <kl.h>

Inheritance diagram for atlas::kl::KLContext:

Collaboration diagram for atlas::kl::KLContext:

Public Member Functions
	KLContext (const Block_base &)

PrimitiveRow	extremalRow (BlockElt y) const

PrimitiveRow	primitiveRow (BlockElt y) const

bool	isZero (const KLIndex p) const

KLPolRef	klPol (BlockElt x, BlockElt y) const
	Returns the Kazhdan-Lusztig-Vogan polynomial $P_{x,y}$. More...

KLIndex	KL_pol_index (BlockElt x, BlockElt y) const

const KLRow &	klRow (BlockElt y) const

MuCoeff	mu (BlockElt x, BlockElt y) const
	Returns mu(x,y). More...

const MuRow &	muRow (BlockElt y) const

const KLStore &	polStore () const

BitMap	primMap (BlockElt y) const

void	fill (BlockElt y, bool verbose=true)
	Fills (or extends) the KL- and mu-lists. More...

void	fill (bool verbose=true)

Public Member Functions inherited from atlas::klsupport::KLSupport
	KLSupport (const Block_base &)

void	swap (KLSupport &)

const Block_base &	block () const

size_t	rank () const

size_t	size () const

size_t	length (BlockElt z) const

BlockElt	lengthLess (size_t l) const

BlockElt	cross (size_t s, BlockElt z) const

BlockEltPair	cayley (size_t s, BlockElt z) const

DescentStatus::Value	descentValue (size_t s, BlockElt z) const

const DescentStatus &	descent (BlockElt y) const

const RankFlags &	descentSet (BlockElt z) const

const RankFlags &	goodAscentSet (BlockElt z) const

unsigned int	ascent_descent (BlockElt x, BlockElt y) const

unsigned int	good_ascent_descent (BlockElt x, BlockElt y) const

unsigned int	prim_index (BlockElt x, const RankFlags &descent_set) const

unsigned int	self_index (BlockElt y) const

void	filter_extremal (BitMap &, const RankFlags &) const
	: Flags in b those block elements which are extremal w.r.t. the simple reflections in d. More...

void	filter_primitive (BitMap &, const RankFlags &) const

void	fill ()

void	fillDownsets ()
	Fills in the \|downset\|, \|primset\|, \|descents\| and \|goodAscent\| bitmap/set vectors. Here \|downset\| and \|primset\| are vectors indexed by a simple reflection \|s\|, and giving a bitmap over all block elements, while \|descents\| and \|goodAscent\| are vectors indexed by a block element \|z\| and giving a bitset over all simple reflections. This difference is motivated by their use: \|downset\| and \|primset\| are used to filter bitmaps over the entire block according to some set of simple generators, which is easier if the data is grouped by generator. In fact the data computed is stored twice: one always has \|downset[s].isMember(z) == descents[z].test(s)\| and \|primset[s].isMember(z) != good_ascent[z].test(s)\|. More...

void	fillPrimitivize ()

Private Types
enum	{ d_zero = 0, d_one = 1 }

typedef HashTable< KLPolEntry, KLIndex >	KLHash

Private Member Functions
	KLContext (const KLContext &)

KLContext &	operator= (const KLContext &)

weyl::Generator	firstDirectRecursion (BlockElt y) const
	Returns the first descent generator that is not real type II. More...

weyl::Generator	first_nice_and_real (BlockElt x, BlockElt y) const

std::pair< weyl::Generator, weyl::Generator >	first_endgame_pair (BlockElt x, BlockElt y) const

BlockEltPair	inverseCayley (size_t s, BlockElt y) const

std::set< BlockElt >	down_set (BlockElt y) const

KLPolRef	klPol (BlockElt x, BlockElt y, KLRow::const_iterator klv, PrimitiveRow::const_iterator p_begin, PrimitiveRow::const_iterator p_end) const

void	silent_fill (BlockElt last_y)

void	verbose_fill (BlockElt last_y)

void	fillKLRow (BlockElt y, KLHash &hash)
	Fills in the row for y in the KL-table. More...

void	recursionRow (std::vector< KLPol > &klv, const PrimitiveRow &e, BlockElt y, size_t s)
	Puts into klv the right-hand side of the recursion formula for y corresponding to the descent s. More...

void	muCorrection (std::vector< KLPol > &klv, const PrimitiveRow &e, BlockElt y, size_t s)
	Subtracts from all polynomials in \|klv\| the correcting terms in the K-L recursion. More...

void	complete_primitives (const std::vector< KLPol > &klv, const PrimitiveRow &e, BlockElt y, KLHash &hash)

void	newRecursionRow (KLRow &klv, const PrimitiveRow &pr, BlockElt y, KLHash &hash)

KLPol	muNewFormula (BlockElt x, BlockElt y, size_t s, const MuRow &muy)
	Stores into \|klv[j]\| the $$-sum appearing a new K-L recursion. More...

Private Attributes
BlockElt	fill_limit

std::vector< KLRow >	d_kl

std::vector< MuRow >	d_mu
	Entry d_mu[y] is a MuRow, which has parallel vectors for x and mu(x,y) More...

KLStore	d_store

Member Typedef Documentation

typedef HashTable<KLPolEntry,KLIndex> atlas::kl::KLContext::KLHash

private

Member Enumeration Documentation

anonymous enum

private

Enumerator
d_zero
d_one

Constructor & Destructor Documentation

atlas::kl::KLContext::KLContext ( const KLContext & )

private

atlas::kl::KLContext::KLContext ( const Block_base & b )

Member Function Documentation

void atlas::kl::KLContext::complete_primitives	(	const std::vector< KLPol > &	klv,
		const PrimitiveRow &	e,
		BlockElt	y,
		KLHash &	hash
	)

private

std::set< BlockElt > atlas::kl::KLContext::down_set ( BlockElt y ) const

private

PrimitiveRow atlas::kl::KLContext::extremalRow ( BlockElt y ) const

void atlas::kl::KLContext::fill	(	BlockElt	y,
		bool	verbose = `true`
	)

Fills (or extends) the KL- and mu-lists.

void atlas::kl::KLContext::fill ( bool verbose = true )

inline

void atlas::kl::KLContext::fillKLRow	(	BlockElt	y,
		KLHash &	hash
	)

private

Fills in the row for y in the KL-table.

Precondition: all lower rows have been filled

Row of $y$ is the set of all $P_{x,y}$ for $x<y$; actually more like a column

std::pair< weyl::Generator, weyl::Generator > atlas::kl::KLContext::first_endgame_pair	(	BlockElt	x,
		BlockElt	y
	)		const

private

weyl::Generator atlas::kl::KLContext::first_nice_and_real	(	BlockElt	x,
		BlockElt	y
	)		const

private

weyl::Generator atlas::kl::KLContext::firstDirectRecursion ( BlockElt y ) const

private

Returns the first descent generator that is not real type II.

BlockEltPair atlas::kl::KLContext::inverseCayley	(	size_t	s,
		BlockElt	y
	)		const

inlineprivate

bool atlas::kl::KLContext::isZero ( const KLIndex p ) const

inline

KLIndex atlas::kl::KLContext::KL_pol_index	(	BlockElt	x,
		BlockElt	y
	)		const

KLPolRef atlas::kl::KLContext::klPol	(	BlockElt	x,
		BlockElt	y
	)		const

Returns the Kazhdan-Lusztig-Vogan polynomial $P_{x,y}$.

Precondition: row $y$ is completely computed, stored in |d_kl[y]|.

KLPolRef atlas::kl::KLContext::klPol	(	BlockElt	x,
		BlockElt	y,
		KLRow::const_iterator	klv,
		PrimitiveRow::const_iterator	p_begin,
		PrimitiveRow::const_iterator	p_end
	)		const

private

const KLRow& atlas::kl::KLContext::klRow ( BlockElt y ) const

inline

MuCoeff atlas::kl::KLContext::mu	(	BlockElt	x,
		BlockElt	y
	)		const

Returns mu(x,y).

This function is not used internally. So we prefer do just use the table of KL polynomials.

void atlas::kl::KLContext::muCorrection	(	std::vector< KLPol > &	klv,
		const PrimitiveRow &	e,
		BlockElt	y,
		size_t	s
	)

private

Subtracts from all polynomials in |klv| the correcting terms in the K-L recursion.

Precondtion: |klv| already contains, for all $x$ that are primitive w.r.t. |y| in increasing order, the terms in $P_{x,y}$ corresponding to $c_s.c_{y'}$, whery |y'| is $s.y$ if |s| is a complex descent, and |y'| is an inverse Cayley transform of |y| if |s| is real type I. The mu-table and KL-table have been filled in for elements of length < l(y).

Explanation: the recursion formula is of the form: $$ lhs = c_s.c_{y'} - {z} mu(z,y')c_z $$ where |z| runs over the elements $< y'$ such that |s| is a descent for |z|. Here $lhs$ stands for $c_y$ when |s| is a complex descent or real type I for |y|, and for $c_{y}+c_{s.y}$ when |s| is real type II; however it plays no part in this function that only subtracts $$-terms.

The element $y'$ is called |sy| in the code below.

We construct a loop over |z| first, before traversing |klv| (the test for $z<sy$ is absent, but $(z,sy)$ implies $z<sy$ (strict, as mu(sy,sy) is 0; in any case no coefficient for |sy| is stored in |d_mu[sy]|, and moreover $z=sy$ would be rejected by the descent condition). The choix have the out loop over $z$ and the inner loop over $x$ (i.e., over |klv|) allows fetching $(z,sy)$ only once, and terminating each scan of |klv| once its values |x| become too large to produce a non-zero $P_{x,z}$. (In fact we stop once $l(x)=l(z)$, and separately consider the case $x=z$.) Either direction of the loop on $z$ would work, but taking it decreasing is more natural; we keep track of the index |zi| at which $x=z$ occurs, if it does.

Elements of length at least $l(sy)=l(y)-1$ on the list |e| are always rejected, so the tail of |e| never reached.

KLPol atlas::kl::KLContext::muNewFormula	(	BlockElt	x,
		BlockElt	y,
		size_t	s,
		const MuRow &	mu_y
	)

private

Stores into |klv[j]| the $$-sum appearing a new K-L recursion.

Precondition: |pr| is the primitive row for |y|, $s$ is real nonparity for $y$ and either C+ or imaginary for $x=pr[j]$ (those are the cases for which the formula is used; the status w.r.t. $x$ is not actually used by the code), and for all $k>j$ one already has stored $P_{pr[k],y}$ in |klv[k]|.

The mu-table and KL-table have been filled in for elements of length < l(y), so that for $z<y$ we can call |klPol(x,z)|.

Explanation: the various recursion formulas involve a sum: $$ {x<z<y} mu(z,y) q^{(l(y)-l(z)+1)/2}P_{x,z} $$ where in addition to the condition given, |s| must be a descent for |z|.

We construct a loop over |z|. The test for $z<y$ is absent, but implied by $(z,y)$; the $(,y)$ information is passed in the |mu_y| argument to this method. The chosen loop order allows fetching $(z,y)$ only once, and terminating the scan of |klv| once its values |x| become too large to produce a non-zero $P_{x,z}$.

const MuRow& atlas::kl::KLContext::muRow ( BlockElt y ) const

inline

void atlas::kl::KLContext::newRecursionRow	(	KLRow &	klv,
		const PrimitiveRow &	pr,
		BlockElt	y,
		KLHash &	hash
	)

private

KLContext& atlas::kl::KLContext::operator= ( const KLContext & )

private

const KLStore& atlas::kl::KLContext::polStore ( ) const

inline

PrimitiveRow atlas::kl::KLContext::primitiveRow ( BlockElt y ) const

BitMap atlas::kl::KLContext::primMap ( BlockElt y ) const

void atlas::kl::KLContext::recursionRow	(	std::vector< KLPol > &	klv,
		const PrimitiveRow &	e,
		BlockElt	y,
		size_t	s
	)

private

Puts into 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 descent 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 $ mu(z,y1)c_z$, is handled by |muCorrection|; the form of the summation depends only on |y1| (which it recomputes), but involves polynomials $P_{x,z}$ that depend on $x$ as well.

void atlas::kl::KLContext::silent_fill ( BlockElt last_y )

private

void atlas::kl::KLContext::verbose_fill ( BlockElt last_y )

private

Member Data Documentation

std::vector<KLRow> atlas::kl::KLContext::d_kl

private

std::vector<MuRow> atlas::kl::KLContext::d_mu

private

Entry d_mu[y] is a MuRow, which has parallel vectors for x and mu(x,y)

KLStore atlas::kl::KLContext::d_store

private

BlockElt atlas::kl::KLContext::fill_limit

private

The documentation for this class was generated from the following files:

/home/ran/atlas_project/latest_branch_07182016/sources/gkmod/kl.h
/home/ran/atlas_project/latest_branch_07182016/sources/gkmod/kl.cpp

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation