Add phi-normal form to module Garside

ext/garside/braids.cpp

@@ -24,8 +24,8 @@
 //* Global objects *
 //******************
 
-MonoidFamily ArtinA_mf("Artin A-type",ArtinA_disp,ArtinA_gnum);
-MonoidFamily DualA_mf("Dual A-type",DualA_disp,DualA_gnum);
+MonoidFamily ArtinA_mf("Artin A-type",ArtinA_disp,ArtinA_gnum,ArtinA_rank);
+MonoidFamily DualA_mf("Dual A-type",DualA_disp,DualA_gnum,DualA_rank);
 
 //***********************
 //* Auxiliary functions *

ext/garside/check

@@ -200,3 +200,6 @@ DualA.phi_splitting(2,a34)==[a23,a00]
 DualA.phi_splitting(2,a24)==[a13,a00]
 DualA.phi_splitting(2,a14)==[a23,a00,a00]
 DualA.phi_splitting(2,delta3)==[a23,a00,delta2]
+
+# phi-normal-form
+DualA.phi_normal_form(delta3*delta3)==a12*a14*a12*a13*a12*a12

ext/garside/init.cpp

@@ -106,9 +106,11 @@ extern "C"{
     {"ArtinWordA","left_reverse",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_left_reverse2},
     {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi},
     {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA","Integer"},(void*)mf_phi_power},
+    {"ArtinWordA","phi_normal_form",{"ArtinMonoidFamilyA","ArtinWordA"},(void*)mf_phi_normal},
     {"ArtinWordA","phi_tail",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi_tail},
     {"Tuple","phi_tail_x",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi_tail_x},
     {"Array","phi_splitting",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi_splitting},
+    {"Integer","rank",{"ArtinMonoidFamilyA","ArtinWordA"},(void*)mf_rank},
     {"ArtinWordA","right_complement",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_right_complement},
     {"ArtinWordA","right_denominator",{"ArtinMonoidFamilyA"},(void*)mt_right_denominator},
     {"ArtinWordA","right_lcm",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_right_lcm},
@@ -140,9 +142,11 @@ extern "C"{
     {"DualWordA","left_reverse",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_left_reverse2},
     {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi},
     {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA","Integer"},(void*)mf_phi_power},
+    {"DualWordA","phi_normal_form",{"DualMonoidFamilyA","DualWordA"},(void*)mf_phi_normal},
     {"DualWordA","phi_tail",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi_tail},
     {"Tuple","phi_tail_x",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi_tail_x},
     {"Array","phi_splitting",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi_splitting},
+    {"Integer","rank",{"DualMonoidFamilyA","DualWordA"},(void*)mf_rank},
     {"DualWordA","right_complement",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_right_complement},
     {"DualWordA","right_denominator",{"DualMonoidFamilyA"},(void*)mt_right_denominator},
     {"DualWordA","right_lcm",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_right_lcm},

ext/garside/init.hpp

@@ -48,6 +48,9 @@ void* mf_generators_number(void* m,void* n);
 //! Return the word under ranked Garside automorphism
 void* mf_phi(void* m,void* r,void* w);
 
+//! Return phi-normal form of an element
+void* mf_phi_normal(void* m,void* w);
+
 //! Return the word under power of ranked Garside automorphism
 void* mf_phi_power(void* m,void* r,void* w,void* p);
 
@@ -60,6 +63,9 @@ void* mf_phi_tail_x(void* m,void* r,void* w);
 //! Return the ranked phi-splitting of an element
 void* mf_phi_splitting(void* m,void* r,void* w);
 
+//! Return the rank of a Word
+void* mf_rank(void* m,void* w);
+
 //***************
 //* MonoidTrait *
 //***************
@@ -202,6 +208,16 @@ mf_generators_number(void* m,void* n){
   return Gomu::to_integer(((MonoidFamily*)m)->generators_number(Gomu::get_slong(n)));
 }
 
+inline void*
+mf_phi_normal(void* m,void* w){
+  return (void*)(new Word(((MonoidFamily*)m)->phi_normal(*(Word*)w)));
+}
+
+inline void*
+mf_rank(void* m,void* w){
+  return Gomu::to_integer(((MonoidFamily*)m)->rank(*(Word*)w));
+}
+
 //------
 // Word
 //------

ext/garside/monoid.cpp

@@ -321,7 +321,7 @@ RightReversing::set_word(const Word& den,const Word& num){
 // MonoidFamily::MonoidFamily(string,DisplayGenerator,GeneratorsNumber)
 //----------------------------------------------------------------------
 
-MonoidFamily::MonoidFamily(string l,DisplayGenerator d,GeneratorsNumber n):label(l),gdisp(d),gnum(n){
+MonoidFamily::MonoidFamily(string l,DisplayGenerator d,GeneratorsNumber n,GeneratorRank r):label(l),gdisp(d),gnum(n),grank(r){
   left_reversing=nullptr;
   right_reversing=nullptr;
   ranked_phi_germ=nullptr;
@@ -354,9 +354,33 @@ MonoidFamily::phi(size_t r,const Word& w,int p){
   return res;
 }
 
+//---------------------------------------
+// MonoidFamily::phi_normal(size_t,Word)
+//---------------------------------------
+
+Word
+MonoidFamily::phi_normal(size_t r,const Word& w){
+  if(r<=1) return w;
+  Array<Word> splitting=phi_splitting(r-1,w);
+  size_t b=splitting.size();
+  for(size_t i=0;i<b;++i){
+    splitting[i]=phi_normal(r-1,splitting[i]);
+    apply_phi(r,splitting[i],b-1-i);
+  }
+  Word res(w.size());
+  size_t ind=0;
+  for(size_t i=0;i<b;++i){
+    Word& temp=splitting[i];
+    for(size_t j=0;j<temp.size();++j){
+      res[ind++]=temp[j];
+    }
+  }
+  return res;
+}
+
 //-------------------------------------
 // MonoidFamily::phi_tail(size_t,Word)
-//-------------*-----------------------
+//-------------------------------------
 
 Word
 MonoidFamily::phi_tail(size_t r,const Word& w){
@@ -408,6 +432,20 @@ MonoidFamily::phi_splitting(size_t r,const Word& w){
   return res_array;
 }
 
+//--------------------------
+// MonoidFamily::rank(Word)
+//--------------------------
+
+size_t
+MonoidFamily::rank(const Word& w){
+  if(w.is_empty()) return 0;
+  size_t r=1;
+  for(size_t i=0;i<w.size();++i){
+    size_t t=grank(w.read(i));
+    if(t>r) r=t;
+  }
+  return r;
+}
 
 //***************
 //* MonoidTrait *

ext/garside/monoid.hpp

@@ -49,7 +49,7 @@ typedef string(*DisplayGenerator)(const Generator& x);
 //! Return the number of generators of the monoid of rank n among a monoid familly
 typedef size_t(*GeneratorsNumber)(size_t n);
 //! Return the rank of a Generator
-typedef size_t(*RankGenerator)(const Generator& x);
+typedef size_t(*GeneratorRank)(const Generator& x);
 //! Ranked Generator bijection
 typedef Generator(*RankedGeneratorBijection)(size_t r,const Generator& x,int p);
 //! Return a ranked word
@@ -278,6 +278,8 @@ public:
   DisplayGenerator gdisp;
   //! Function returning the number of generators for a given rank 
   GeneratorsNumber gnum;
+  //! Return rank of a generator
+  GeneratorRank grank;
   //! Label of the monoid family
   string label;
   //! Ranked Garside automorphism germ
@@ -286,7 +288,7 @@ public:
   RankedWordFactory ranked_garside_word_factory;
   
   //! Unique constructor
-  MonoidFamily(string l,DisplayGenerator d,GeneratorsNumber n);
+  MonoidFamily(string l,DisplayGenerator d,GeneratorsNumber n,GeneratorRank r);
 
   //! Destructor
   ~MonoidFamily();
@@ -311,6 +313,12 @@ public:
   
   //! Return the word obtained under phi_r^p
   Word phi(size_t r,const Word& w,int p=1);
+
+  //! Return phi-normal form of an element
+  Word phi_normal(const Word& w);
+
+  //! Return phi-normal form of an element of rank r
+  Word phi_normal(size_t r,const Word& w);
   
   //! Return ranked phi-tail of an element
   Word phi_tail(size_t r,const Word& w);
@@ -328,9 +336,7 @@ public:
   void set_ranked_phi_germ(RankedGeneratorBijection rpg);
   
   //! Set ranked garside word factory
-  void set_ranked_garside_word_factory(RankedWordFactory rgwf);
-  
-  
+  void set_ranked_garside_word_factory(RankedWordFactory rgwf);  
 };
 
 //------
@@ -489,6 +495,12 @@ MonoidFamily::has_garside_automorphism() const{
   return ranked_phi_germ!=nullptr;
 }
 
+inline Word
+MonoidFamily::phi_normal(const Word& w){
+  return phi_normal(rank(w),w);
+}
+
+				    
 inline void
 MonoidFamily::set_ranked_phi_germ(RankedGeneratorBijection rpg){
   ranked_phi_germ=rpg;

module.hpp

@@ -505,11 +505,6 @@ namespace Gomu{
     if(type!=type_symbol) return this;
     return (Value*)ptr;
   }
-
-  //---------------------
-  // Auxiliary Functions
-  //---------------------
-
 }