basic.at Function Index

Functions

Function	Argument(s) -> Results
#	int n->[int]: for i
#	bool b->int
assert	bool b,string message->void
assert	bool b->void
list	(int->bool) filter, int limit->[int]
complement	(int->bool) filter, int limit->[int]
count	(int->bool) filter, int limit->int
all	[bool] p->bool
none	[bool] p->bool
first	[bool] p->int
last	[bool] p->int
all	int limit,(int->bool) filter->bool
none	int limit,(int->bool) filter->bool
first	int limit,(int->bool) filter->int
last	int limit,(int->bool) filter->int
all	[(->bool)] p->bool
none	[(->bool)] p->bool
first	[(->bool)] p->int
last	[(->bool)] p->int
binary_search_first	(int->bool)pred, int low, int high->int
from_stops	[int] stops->(int->int)
abs	int k->int
sign	int k->int
is_odd	int n->bool
is_even	int n->bool
min	int k, int l->int
max	int k, int l->int
min	[int] a->int
max	[int] a->int
min_loc	[int] a->int
max_loc	[int] a->int
min	int !seed->([int]->int)
max	int !seed->([int]->int)
lcm	[int] list) = let (,d->%(ratvec
=	(int,int)(x0,y0),(int,int)(x1,y1)->bool
!=	(int,int)(x0,y0),(int,int)(x1,y1)->bool
is_integer	rat r->bool
sign	rat a->int
abs	rat a->rat
floor	rat a->int
ceil	rat a->int
\_(rat,int)p->int1	(rat,int)p->int
\_(rat,rat)p->int1	(rat,rat)p->int
%	(rat,int)p->(int,rat)
%	(rat,rat)p->(int,rat)
floor	[rat] v->vec
ceil	[rat] v->vec
rat_as_int	rat r->int
*	int n,string s->string
+	string s, int i->string
+	int i, string s->string
plural	int n->string
plural	int n,string s->string
l_adjust	int w, string s->string
r_adjust	int w, string s->string
c_adjust	int w, string s->string
width	int n->int
split_lines	string text->[string]
is_substring	string s, string text->bool
fgrep	string s, string text->[string]
vector	int n,(int->int)f->vec: for i
ones	int n->vec: for i
gcd	[int] v->int
*	int c,vec v->vec
sum	vec v->int
product	vec v->1 in for e in v do s*
half	int n->int
reverse	vec v->vec: v~[
lower	int k,vec v->vec: v[
upper	int k,vec v->vec: v[k~
drop_lower	int k,vec v->vec: v[k
drop_upper	int k,vec v->vec: v[
<=	vec v->bool
<	vec v->bool
is_member	[int] v->(int->bool)
contains	int val->([int]->bool): ([int] v)bool
rec_fun all_0_1_vecs	int n->[vec]
rec_fun power_set	int n->[[int]]
power_set	[int] S->[[int]]
matrix	(int,int)(r,c),(int,int->int) f->mat
n_rows	mat m->int
n_columns	mat m->int
column	vec v->mat
row	vec v->mat
=	mat m,int k->bool
#	mat m, vec v->mat: n_rows(m)  # (([vec]
#	vec v, mat m->mat: n_rows(m)  # (v#([vec]
^	mat m, vec v->mat: n_columns(m) ^ (([vec]
^	vec v, mat m->mat: n_columns(m) ^ (v#([vec]
##	mat A, mat B->mat
^	mat A, mat B->mat
##	int n,[mat] L->mat
map_on	mat m->((int->int)->mat)
*	int c,mat m->mat: map_on(m)((int e) int
-	mat m->mat
\_mat_m,int_d->mat:_map_on(m)((int_e)_int1	mat m,int d->mat: map_on(m)((int e) int
%	mat m,int d->mat: map_on(m)((int e) int
inverse	mat M->mat
det	mat M->int
saturated_span	mat M->bool
all	mat M,(vec->bool) filter->bool
none	mat M,(vec->bool) filter->bool
first	mat M,(vec->bool) filter->int
last	mat M,(vec->bool) filter->int
columns_with	(int,vec->bool) p,mat m->mat
columns_with	(vec->bool) p,mat m->mat
columns_with	(int->bool) p,mat m->mat
rows_with	(int,vec->bool) p,mat m->mat
rows_with	(vec->bool) p,mat m->mat
rows_with	(int->bool) p,mat m->mat
>=	mat m->bool
>	mat m->bool
<=	mat m->bool
<	mat m->bool
lookup_column	vec v,mat m->int
lookup_row	vec v,mat m->int
sum	mat m->vec
order	mat !M->int
numer	ratvec a->vec
denom	ratvec a->int
*	int i,ratvec v->ratvec
*	rat r,ratvec v->ratvec
##	ratvec a,ratvec b->ratvec: ##([rat]:a,[rat]
##	[ratvec] rs->ratvec: ## for r in rs do [rat]
sum	[ratvec] list, int l->ratvec
*	[ratvec] M,ratvec v->ratvec
is_integer	ratvec v->bool
*	ratvec v, ratvec w->rat
*	vec v, ratvec w->rat
\_ratvec_v,_int_k->vec1	ratvec v, int k->vec
ratvec_as_vec	ratvec v->vec
reverse	ratvec v->ratvec: v~[
lower	int k,ratvec v->ratvec: v[
upper	int k,ratvec v->ratvec: v[k~
drop_lower	int k,ratvec v->ratvec: v[k
drop_upper	int k,ratvec v->ratvec: v[
sum	ratvec v->rat
<=	ratvec v->bool
<	ratvec v->bool
solve	mat A, ratvec b->[ratvec]
one_minus_s = split:_1,-1->split1	1,-1->Split
int_part	Split x->int
s_part	Split x->int
s_to_1	Split x->int
s_to_minus_1	Split x->int
times_s	Split x) = let (a,b->%x in Split
split_as_int	Split x->int
%	Split x, int n->(Split,Split)
half	Split w->Split
/	Split w,int n->Split
%	Split w,int n->Split
exp_s	int n->Split
is_pure	Split w->bool
split_format	Split w->string
^ =let rec_fun split_power	Split x,int n->Split
sum	[Split] list->Split
root_datum	[vec] simple_roots, [vec] simple_coroots, int r->RootDatum
root_datum	LieType t, [ratvec] gens->RootDatum
root_datum	LieType t, ratvec gen->RootDatum
is_root	(RootDatum,vec) (rd,):p->bool
is_coroot	(RootDatum,vec) (rd,):p->bool
is_posroot	(RootDatum,vec)(rd,):p->bool
is_poscoroot	(RootDatum,vec)(rd,):p->bool
posroot_index	(RootDatum,vec)p->int
poscoroot_index	(RootDatum,vec)p->int
rho	RootDatum rd->ratvec
rho_as_vec	RootDatum r->vec
rho_check	RootDatum rd->ratvec
is_positive_root	RootDatum rd->(vec->bool)
is_positive_coroot	RootDatum rd->(vec->bool)
is_negative_root	RootDatum rd->(vec->bool)
is_negative_coroot	RootDatum rd->(vec->bool)
is_positive_root	RootDatum rd,vec alpha->bool
is_positive_coroot	RootDatum rd,vec alphav->bool
is_negative_root	RootDatum rd,vec alpha->bool
is_negative_coroot	RootDatum rd,vec alphav->bool
roots_all_positive	RootDatum rd->(mat->bool)
coroots_all_positive	RootDatum rd->(mat->bool)
among_posroots	RootDatum rd->(mat M)bool
among_poscoroots	RootDatum rd->(mat M)bool
roots	RootDatum rd->mat
coroots	RootDatum rd->mat
root	RootDatum rd, vec alpha_v->vec
coroot	RootDatum rd, vec alpha->vec
reflection	RootDatum rd, int i->mat
reflection	(RootDatum,vec)(rd,):p->mat
coreflection	RootDatum rd, int i->mat
coreflection	(RootDatum,vec)(rd,):p->mat
reflect	RootDatum rd, int i, vec v->vec
reflect	RootDatum rd, vec alpha, vec v->vec
coreflect	RootDatum rd, vec v, int i->vec
coreflect	RootDatum rd, vec v, vec alpha->vec
reflect	RootDatum rd, int i, ratvec v->ratvec
reflect	RootDatum rd, vec alpha, ratvec v->ratvec
coreflect	RootDatum rd, ratvec v, int i->ratvec
coreflect	RootDatum rd, ratvec v, vec alpha->ratvec
left_reflect	RootDatum rd, int i, mat M->mat
left_reflect	RootDatum rd, vec alpha, mat M->mat
right_reflect	RootDatum rd, mat M, int i->mat
right_reflect	RootDatum rd, mat M, vec alpha->mat
conjugate	RootDatum rd, int i, mat M->mat
conjugate	RootDatum rd, vec alpha, mat M->mat
singular_simple_indices	RootDatum rd,ratvec v->[int]
is_imaginary	mat theta->(vec->bool): (vec alpha)
is_real	mat theta->(vec->bool): (vec alpha)
is_complex	mat theta->(vec->bool): (vec alpha)
imaginary_roots	RootDatum rd, mat theta->mat
real_roots	RootDatum rd, mat theta->mat
imaginary_coroots	RootDatum rd, mat theta->mat
real_coroots	RootDatum rd, mat theta->mat
imaginary_posroots	RootDatum rd,mat theta->mat
real_posroots	RootDatum rd,mat theta->mat
imaginary_poscoroots	RootDatum rd,mat theta->mat
real_poscoroots	RootDatum rd,mat theta->mat
imaginary_sys	(RootDatum,mat)p->(mat,mat)
real_sys	(RootDatum,mat)p->(mat,mat)
is_dominant	RootDatum rd, ratvec v->bool
is_strictly_dominant	RootDatum rd, ratvec v->bool
is_regular	RootDatum rd,ratvec v->bool
is_integral	RootDatum rd, ratvec v->bool
radical_basis	RootDatum rd->mat
coradical_basis	RootDatum rd->mat
is_semisimple	RootDatum rd->bool
derived_is_simply_connected	RootDatum rd->bool
has_connected_center	RootDatum rd->bool
is_simply_connected	RootDatum rd->bool
is_adjoint	RootDatum rd->bool
derived	RootDatum rd->RootDatum
mod_central_torus	RootDatum rd->RootDatum
adjoint	RootDatum rd->RootDatum
is_simple_for	vec dual_two_rho->(vec->bool)
simple_from_positive	mat posroots,mat poscoroots->(mat,mat)
fundamental_weights	RootDatum rd->[ratvec]
fundamental_coweights	RootDatum rd->[ratvec]
dual_integral	InnerClass ic, ratvec gamma->InnerClass
Cartan_classes	InnerClass ic->[CartanClass]
print_Cartan_info	CartanClass cc->void
fundamental_Cartan	InnerClass ic->CartanClass
most_split_Cartan	InnerClass ic->CartanClass
compact_rank	CartanClass cc->int
split_rank	CartanClass cc->int
compact_rank	InnerClass ic->int
split_rank	RealForm G->int
is_equal_rank	InnerClass ic->bool
is_split	RealForm G->bool
=	CartanClass H,CartanClass J->bool
number	CartanClass H,RealForm G->int
form_name	RealForm f->string
real_forms	InnerClass ic->[RealForm]
dual_real_forms	InnerClass ic->[RealForm]
is_quasisplit	RealForm G->bool
is_quasicompact	RealForm G->bool
split_form	RootDatum r->RealForm
split_form	LieType t->RealForm
quasicompact_form	InnerClass ic->RealForm
is_compatible	RealForm f, RealForm g->bool
is_compact	RealForm G->bool
root_datum	KGBElt x->RootDatum
inner_class	KGBElt x->InnerClass
KGB	RealForm rf->[KGBElt]: for i
KGB	CartanClass H,RealForm G->[KGBElt]
KGB_elt	(InnerClass, mat, ratvec) (,theta,v):all->KGBElt
KGB_elt	RootDatum rd, mat theta, ratvec v->KGBElt
Cartan_class	InnerClass ic, mat theta->CartanClass
Bruhat_order	RealForm G->(KGBElt,KGBElt->bool)
status	vec alpha,KGBElt x->int
cross	vec alpha,KGBElt x->KGBElt
Cayley	vec alpha,KGBElt x->KGBElt
W_cross	[int] w,KGBElt x->KGBElt
KGB_status_text	int i->string
status_text	(int,KGBElt)p->string
status_text	(vec,KGBElt)p->string
status_texts	KGBElt x->[string]
is_imaginary	KGBElt x->(vec->bool)
is_real	KGBElt x->(vec->bool)
is_complex	KGBElt x->(vec->bool)
imaginary_posroots	KGBElt x->mat
real_posroots	KGBElt x->mat
imaginary_poscoroots	KGBElt x->mat
real_poscoroots	KGBElt x->mat
imaginary_sys	KGBElt x->(mat,mat)
real_sys	KGBElt x->(mat,mat)
rho_i	KGBElt x->ratvec
rho_r	KGBElt x->ratvec
rho_check_i	KGBElt x->ratvec
rho_check_r	KGBElt x->ratvec
rho_i	(RootDatum,mat) rd_theta->ratvec
rho_r	(RootDatum,mat) rd_theta->ratvec
rho_check_i	(RootDatum,mat) rd_theta->ratvec
rho_check_r	(RootDatum,mat) rd_theta->ratvec
is_compact	KGBElt x->(vec->bool)
is_noncompact	KGBElt x->(vec->bool)
is_compact_imaginary	KGBElt x->(vec->bool)
is_noncompact_imaginary	KGBElt x->(vec->bool)
compact_posroots	KGBElt x->mat
noncompact_posroots	KGBElt x->mat
rho_ci	KGBElt x->ratvec
rho_nci	KGBElt x->ratvec
is_imaginary	vec v,KGBElt x->bool
is_real	vec v,KGBElt x->bool
is_complex	vec v,KGBElt x->bool
is_compact_imaginary	vec v,KGBElt x->bool
is_noncompact_imaginary	vec v,KGBElt x->bool
print_KGB	KGBElt x->void
no_Cminus_roots	KGBElt x->bool
no_Cplus_roots	KGBElt x->bool
blocks	InnerClass ic->[Block]
raw_KL	(RealForm,RealForm) p->(mat,[vec],vec)
dual_KL	(RealForm,RealForm) p->(mat,[vec],vec)
print_block	(RealForm,RealForm) p->void
print_blocku	(RealForm,RealForm) p->void
print_blockd	(RealForm,RealForm) p->void
print_KL_basis	(RealForm,RealForm) p->void
print_prim_KL	(RealForm,RealForm) p->void
print_KL_list	(RealForm,RealForm) p->void
print_W_cells	(RealForm,RealForm) p->void
print_W_graph	(RealForm,RealForm) p->void
root_datum	Param p->RootDatum
inner_class	Param p->InnerClass
null_module	Param p->ParamPol
x	Param p->KGBElt
lambda_minus_rho	Param p->vec
lambda	Param p->ratvec
infinitesimal_character	Param p->ratvec
nu	Param p->ratvec
Cartan_class	Param p->CartanClass
integrality_datum	Param p->RootDatum
is_regular	Param p->bool
survives	Param p->bool
trivial	RealForm G->Param
W_cross	[int] w,Param p->Param
parameter	RealForm G,int x,ratvec lambda,ratvec nu->Param
parameter	KGBElt x,ratvec lambda,ratvec nu->Param
parameter_gamma	KGBElt x, ratvec lambda, ratvec gamma->Param
singular_block	Param p->([Param],int)
block_of	Param p->[Param]
singular_block_of	Param p->[Param]
imaginary_type	int s, Param p->int
real_type	int s,Param p->int
imaginary_type	vec alpha, Param p->int
real_type	vec alpha, Param p->int
is_nonparity	int s,Param p->bool
is_parity	int s,Param p->bool
is_nonparity	vec alpha,Param p->bool
is_parity	vec alpha,Param p->bool
status	vec alpha,Param p->int
status	int s,Param p->int
block_status_text	int i->string
status_text	int s,Param p->string
status_texts	Param p->[string]
status_text	(vec,Param) ap->string
parity_poscoroots	Param p->mat
nonparity_poscoroots	Param p->mat
is_descent	int s,Param p->bool
tau_bitset	Param p->((int->bool),int)
tau	Param p->[int]
tau_complement	Param p->[int]
is_descent	(vec,Param) ap->bool
lookup	Param p, [Param] block->int
null_module	ParamPol P->ParamPol
-	ParamPol P->ParamPol
first_param	ParamPol P->Param
last_param	ParamPol P->Param
s_to_1	ParamPol P->ParamPol
s_to_minus_1	ParamPol P->ParamPol
-	ParamPol a, (Split,Param) (c,p)->ParamPol
sum	RealForm G,[ParamPol] Ps->ParamPol
map	(Param->Param)f, ParamPol P->ParamPol
map	(Param->ParamPol)f, ParamPol P->ParamPol
half	ParamPol P->ParamPol
divide_by	int n, ParamPol P->ParamPol
root_datum	ParamPol P->RootDatum
virtual	Param p->ParamPol
virtual	RealForm G, [Param] ps->ParamPol
branch	Param std, Param K_type->int
branch	ParamPol P, Param K_type->Split
pol_format	ParamPol P->string
infinitesimal_character	ParamPol P->ratvec
height_split	ParamPol P, int h->(ParamPol,ParamPol)
separate_by_infinitesimal_character	ParamPol P->[(ratvec,ParamPol)]
is_pure_1	ParamPol P->bool
is_pure_s	ParamPol P->bool
is_pure	ParamPol P->bool
purity	ParamPol P->(int,int,int)
find	[int] v, int k->int:      first(#v,(int i)bool
find	[Param] P,Param p->int:   first(#P,(int i)bool
find	[KGBElt] S,KGBElt x->int: first(#S,(int i)bool
find	[vec] S,vec v->int:       first(#S,(int i)bool
in_string_list	string s,[string] S->bool
delete	[int] v, int k->[int]:     v[:k]##v[k+1
delete	[vec] v, int k->[vec]:     v[:k]##v[k+1
delete	[ratvec] v, int k->[ratvec]:  v[:k]##v[k+1
delete	[[ratvec]] v, int k->[[ratvec]]:v[:k]##v[k+1
delete	[[vec]] v, int k->[[vec]]:   v[:k]##v[k+1
delete	[ParamPol] P, int k->[ParamPol]:P[:k]##P[k+1
imaginary_roots_and_coroots	(RootDatum, mat)p->(mat,mat)
imaginary_roots_and_coroots	KGBElt x->(mat,mat)
real_roots_and_coroots	(RootDatum, mat)p->(mat,mat)
real_roots_and_coroots	KGBElt x->(mat,mat)
complex_posroots	RootDatum rd,mat theta->mat
complex_posroots	KGBElt x->mat
pad	string s,int padding->string
monomials	ParamPol P->[Param]
monomial	ParamPol P,int i->Param