Parcourir la source

Add phi-tail for garside module

Jean Fromentin il y a 8 ans
Parent
commit
025b41c0f4
7 fichiers modifiés avec 112 ajouts et 10 suppressions
  1. 25 8
      ext/garside/check
  2. 17 1
      ext/garside/init.cpp
  3. 18 0
      ext/garside/init.hpp
  4. 28 0
      ext/garside/monoid.cpp
  5. 22 0
      ext/garside/monoid.hpp
  6. 1 1
      ext/garside/stacked_list.hpp
  7. 1 0
      kernel.cpp

+ 25 - 8
ext/garside/check

@@ -5,10 +5,15 @@
 # Garside element
 
 ArtinA.garside_element(0)==a0
-ArtinA.garside_element(1)==a1
-ArtinA.garside_element(2)==a1*a2*a1
-ArtinA.garside_element(3)==a1*a2*a3*a1*a2*a1
-ArtinA.garside_element(4)==a1*a2*a3*a4*a1*a2*a3*a1*a2*a1
+Delta1=ArtinA.garside_element(1)
+Delta2=ArtinA.garside_element(2)
+Delta3=ArtinA.garside_element(3)
+Delta4=ArtinA.garside_element(4)
+Delta1==a1
+Delta2==a1*a2*Delta1
+Delta3==a1*a2*a3*Delta2
+Delta4==a1*a2*a3*a4*Delta3
+
 
 #******************
 #* Dual of type A *
@@ -168,7 +173,19 @@ DualA.phi(2,a12*A13)==a23*A12
 # Garside element
 
 DualA.garside_element(0)==a00
-DualA.garside_element(1)==a12
-DualA.garside_element(2)==a12*a23
-DualA.garside_element(3)==a12*a23*a34
-DualA.garside_element(4)==a12*a23*a34*a45
+delta1=DualA.garside_element(1)
+delta2=DualA.garside_element(2)
+delta3=DualA.garside_element(3)
+delta4=DualA.garside_element(4)
+delta1==a12
+delta2==delta1*a23
+delta3==delta2*a34
+delta4==delta3*a45
+
+# phi-tail
+DualA.phi_tail(1,delta2)==delta1
+DualA.phi_tail(2,delta3)==delta2
+DualA.phi_tail(3,delta4)==delta3
+DualA.phi_tail(1,delta2*delta2)==delta1*delta1
+DualA.phi_tail(2,delta3*delta3)===delta2*delta2
+DualA.phi_tail(3,delta4*delta4)===delta3*delta3

+ 17 - 1
ext/garside/init.cpp

@@ -82,6 +82,8 @@ extern "C"{
   Gomu::Module::Function functions[]={
     {"ArtinWordA","operator*",{"ArtinWordA","ArtinWordA"},(void*)word_concatenate},
     {"DualWordA","operator*",{"DualWordA","DualWordA"},(void*)word_concatenate},
+    {"Boolean","operator===",{"ArtinWordA","ArtinWordA"},(void*)ArtinWordA_equivalent},
+    {"Boolean","operator===",{"DualWordA","DualWordA"},(void*)DualWordA_equivalent},
     {"Word","word",{"Array"},(void*)word_from_array},
     FUNC_SENTINEL
   };
@@ -104,6 +106,7 @@ extern "C"{
     {"ArtinWordA","left_reverse",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_left_reverse2},
     {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mt_phi},
     {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA","Integer"},(void*)mt_phi_power},
+    {"ArtinWordA","phi_tail",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mt_phi_tail},
     {"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},
@@ -135,6 +138,7 @@ extern "C"{
     {"DualWordA","left_reverse",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_left_reverse2},
     {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mt_phi},
     {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA","Integer"},(void*)mt_phi_power},
+    {"DualWordA","phi_tail",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mt_phi_tail},
     {"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},
@@ -205,7 +209,7 @@ extern "C"{
 
 void* mt_garside_element(void* m,void* r){
   MonoidTrait* monoid=(MonoidTrait*)m;
- if(not monoid->has_garside_element())
+  if(not monoid->has_garside_element())
     RuntimeError("Monoid doesn't have Garside element");
  return (void*)(new Word(monoid->garside_element(Gomu::get_slong(r))));
 }
@@ -377,6 +381,18 @@ void* mt_phi_power(void* m,void* r,void* w,void* p){
   return new Word(monoid->phi(rank,*(Word*)w,power));
 }
 
+//----------------------------------------
+// Word phi_tail(MonoidTrai,Integer,Word)
+//----------------------------------------
+
+void* mt_phi_tail(void* m,void* r,void* w){
+  MonoidTrait* monoid=(MonoidTrait*)m;
+  if(not monoid->has_garside_automorphism())
+    RuntimeError("Monoid has not Garside automorphism");
+  size_t rank=Gomu::get_slong(r);
+  return new Word(monoid->phi_tail(rank,*(Word*)w));
+}
+
 //----------------------------------------------
 // Word right_complement(MonoidTrait,Word,Word)
 //----------------------------------------------

+ 18 - 0
ext/garside/init.hpp

@@ -88,6 +88,9 @@ void* mt_phi(void* m,void* r,void* w);
 //! Return the word under power of ranked Garside automorphism
 void* mt_phi_power(void* m,void* r,void* w,void* p);
 
+//! Return ranked phi-tail of an element
+void* mt_phi_tail(void* m,void* r,void* w);
+
 //! Left reverse a word
 void* mt_left_reverse(void* m,void* w);
 
@@ -157,6 +160,9 @@ void* word_concatenate(void*,void*);
 //! Display a ArtinWordA
 string ArtinWordA_display(void* w);
 
+//! Test equivalence between ArtinWordA
+void* ArtinWordA_equivalent(void* u,void* v);
+
 //*************
 //* DualWordA *
 //*************
@@ -164,6 +170,9 @@ string ArtinWordA_display(void* w);
 //! Display a DualWordA
 string DualWordA_display(void* w);
 
+//! Test equivalence between DualWordA
+void* DualWordA_equivalent(void* u,void* v);
+
 //**********************
 //* Inline definitions *
 //**********************
@@ -235,6 +244,11 @@ ArtinWordA_display(void* w){
   return ((Word*)w)->display(ArtinA_disp);
 }
 
+inline void*
+ArtinWordA_equivalent(void* u,void* v){
+  return Gomu::to_boolean(ArtinA_mf.are_equivalent(*(Word*)u,*(Word*)v));
+}
+
 //------------
 // DualWordA
 //------------
@@ -244,3 +258,7 @@ DualWordA_display(void* w){
   return ((Word*)w)->display(DualA_disp);
 }
 
+inline void*
+DualWordA_equivalent(void* u,void* v){
+  return Gomu::to_boolean(DualA_mf.are_equivalent(*(Word*)u,*(Word*)v));
+}

+ 28 - 0
ext/garside/monoid.cpp

@@ -343,6 +343,16 @@ MonoidTrait::~MonoidTrait(){
   if(right_reversing!=nullptr) delete right_reversing;
 }
 
+//---------------------------------------
+// MonoidTrait::are_equivalen(Word,Word)
+//---------------------------------------
+
+bool
+MonoidTrait::are_equivalent(const Word& u,const Word& v){
+  left_reversing->set_word(u,v);
+  left_reversing->check_positivity();
+  return left_reversing->word.is_empty();
+}
 
 //-----------------------------------------
 // MonoidTrait::apply_phi(size_t,Word,int)
@@ -432,6 +442,24 @@ MonoidTrait::phi(size_t r,const Word& w,int p){
   return res;
 }
 
+//------------------------------------
+// MonoidTrait::phi_tail(size_t,Word)
+//------------------------------------
+
+Word
+MonoidTrait::phi_tail(size_t r,const Word& w){
+  Word u=w;
+  Word res;
+  Word delta=garside_element(r);
+  while(true){
+    pair<Word,Word> temp=right_gcd_x(u,delta);
+    if(temp.first.is_empty()) return res;
+    res=res*temp.first;
+    u=temp.second;
+  }
+  return res;
+}
+
 //----------------------------------------------------
 // MonoidTrait::right_complement(Generator,Generator)
 //----------------------------------------------------

+ 22 - 0
ext/garside/monoid.hpp

@@ -183,6 +183,9 @@ public:
   //! Apply phi_r^p to the word
   void apply_phi(size_t r,Word& w,int p=1);
 
+  //! Test if two words are equivalent
+  bool are_equivalent(const Word& u,const Word& v);
+  
   //! Return garside_element of rank r
   Word garside_element(size_t r);
   
@@ -245,6 +248,9 @@ public:
   //! Return the word obtained under phi_r^p
   Word phi(size_t r,const Word& w,int p=1);
 
+  //! Return ranked phi-tail of an element
+  Word phi_tail(size_t r,const Word& w);
+
   //! Return right complement of x and y
   Word right_complement(const Generator& x,const Generator& y);
   
@@ -338,6 +344,12 @@ public:
   //! Construct a word from an array
   Word(const Array<Generator>&);
   Word(Array<Generator>&&);
+
+  //! Assignement operator with copy
+  Word& operator=(const Word& w);
+
+  //! Assignement operator with move
+  Word& operator=(Word&& w);
   
   //! Concatenate a word to this one
   Word concatenate(const Word& w) const;
@@ -609,6 +621,16 @@ Word::concatenate(const Word& w) const{
   return Word(append(w));
 }
 
+inline Word&
+Word::operator=(const Word& w){
+  Array::operator=(w);
+}
+
+inline Word&
+Word::operator=(Word&& w){
+  Array::operator=(w);
+}
+
 //***********************
 //* Auxiliary functions *
 //***********************

+ 1 - 1
ext/garside/stacked_list.hpp

@@ -103,7 +103,7 @@ public:
 
   //! Test if the StackedList is empty
   bool is_empty() const;
-
+  
   //! Return last data of the list
   NData last();
 };

+ 1 - 0
kernel.cpp

@@ -344,6 +344,7 @@ namespace Gomu{
     interpreter.add_operator("<=","operator<=",opBinary,8);
     interpreter.add_operator(">=","operator>=",opBinary,8);
     interpreter.add_operator("==","operator==",opBinary,8);
+    interpreter.add_operator("===","operator===",opBinary,8);
     interpreter.add_operator("!=","operator!=",opBinary,8);
     interpreter.add_operator("+","operator+",opBinary,4);
     interpreter.add_operator("-","operator-",opBinary,4);