# 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