def left_rauzy_move(self, winner): r""" Performs a Rauzy move on the left. EXAMPLES: :: sage: p = iet.Permutation('a b c','c b a',reduced=True) sage: p.left_rauzy_move(0) a b c b c a sage: p.right_rauzy_move(1) a b c b c a :: sage: p = iet.GeneralizedPermutation('a a','b b c c',reduced=True) sage: p.left_rauzy_move(0) a a b b c c """ winner = interval_conversion(winner) result = copy(self) result._reversed() result = result.right_rauzy_move(winner) result._reversed() return result
def has_rauzy_move(self, winner, side='right'): r""" Tests if the permutation is rauzy_movable on the left. EXAMPLES: :: sage: p = iet.Permutation('a b c','a c b',reduced=True) sage: p.has_rauzy_move(0,'right') True sage: p.has_rauzy_move(0,'left') False sage: p.has_rauzy_move(1,'right') True sage: p.has_rauzy_move(1,'left') False :: sage: p = iet.Permutation('a b c d','c a b d',reduced=True) sage: p.has_rauzy_move(0,'right') False sage: p.has_rauzy_move(0,'left') True sage: p.has_rauzy_move(1,'right') False sage: p.has_rauzy_move(1,'left') True """ side = side_conversion(side) winner = interval_conversion(winner) return self._twin[winner][side] % len(self) != side % len(self)
def length(self, interval=None): r""" Returns the 2-uple of lengths. p.length() is identical to (p.length_top(), p.length_bottom()) If an interval is specified, it returns the length of the specified interval. INPUT: - ``interval`` - None, 'top' (or 't' or 0) or 'bottom' (or 'b' or 1) OUTPUT: integer or 2-uple of integers -- the corresponding lengths EXAMPLES:: sage: p = iet.Permutation('a b c','c b a') sage: p.length() (3, 3) sage: p = iet.GeneralizedPermutation('a a b','c d c b d') sage: p.length() (3, 5) """ if interval is None : return len(self._twin[0]),len(self._twin[1]) else : interval = interval_conversion(interval) return len(self._twin[interval])
def right_rauzy_move(self, winner): r""" Performs a Rauzy move on the right. EXAMPLES: :: sage: p = iet.Permutation('a b c','c b a',reduced=True) sage: p.right_rauzy_move(0) a b c c a b sage: p.right_rauzy_move(1) a b c b c a :: sage: p = iet.GeneralizedPermutation('a a','b b c c',reduced=True) sage: p.right_rauzy_move(0) a b b c c a """ winner = interval_conversion(winner) result = copy(self) loser_to = result._get_loser_to(winner) # beware here, loser_to can contain 2 or 3 items # (depending on the presence of flip) result._twin_rauzy_move(winner, loser_to) return result
def rauzy_move_relabel(self, winner, side='right'): r""" Returns the relabelization obtained from this move. EXAMPLE:: sage: from surface_dynamics.all import * sage: p = iet.Permutation('a b c d','d c b a') sage: q = p.reduced() sage: p_t = p.rauzy_move('t') sage: q_t = q.rauzy_move('t') sage: s_t = q.rauzy_move_relabel('t') sage: print s_t a->a, b->b, c->c, d->d sage: map(s_t, p_t[0]) == map(Word, q_t[0]) True sage: map(s_t, p_t[1]) == map(Word, q_t[1]) True sage: p_b = p.rauzy_move('b') sage: q_b = q.rauzy_move('b') sage: s_b = q.rauzy_move_relabel('b') sage: print s_b a->a, b->d, c->b, d->c sage: map(s_b, q_b[0]) == map(Word, p_b[0]) True sage: map(s_b, q_b[1]) == map(Word, p_b[1]) True """ from surface_dynamics.interval_exchanges.labelled import LabelledPermutationIET from sage.combinat.words.morphism import WordMorphism winner = interval_conversion(winner) side = side_conversion(side) p = LabelledPermutationIET(self.list()) l0_q = p.rauzy_move(winner, side).list()[0] d = dict([(self._alphabet[i],l0_q[i]) for i in range(len(self))]) return WordMorphism(d)
def right_rauzy_move(self, winner): r""" Performs a Rauzy move on the right. EXAMPLE:: sage: p = iet.Permutation('a b c','c b a',reduced=True,flips='c') sage: p.right_rauzy_move('top') -a b -c -a -c b """ winner = interval_conversion(winner) result = copy(self) loser_to = result._get_loser_to(winner) result._flip_rauzy_move(winner, loser_to) result._twin_rauzy_move(winner, loser_to) return result
def in_which_interval(self, x, interval=0): r""" Returns the letter for which x is in this interval. INPUT: - ``x`` - a positive number - ``interval`` - (default: 'top') 'top' or 'bottom' OUTPUT: label -- a label corresponding to an interval TEST: :: sage: t = iet.IntervalExchangeTransformation(('a b c','c b a'),[1,1,1]) sage: t.in_which_interval(0) 'a' sage: t.in_which_interval(0.3) 'a' sage: t.in_which_interval(1) 'b' sage: t.in_which_interval(1.9) 'b' sage: t.in_which_interval(2) 'c' sage: t.in_which_interval(2.1) 'c' sage: t.in_which_interval(3) Traceback (most recent call last): ... ValueError: your value does not lie in [0;l[ .. and for the bottom interval:: sage: t.in_which_interval(0,'bottom') 'c' sage: t.in_which_interval(1.2,'bottom') 'b' sage: t.in_which_interval(2.9,'bottom') 'a' TESTS:: sage: t.in_which_interval(-2.9,'bottom') Traceback (most recent call last): ... ValueError: your value does not lie in [0;l[ """ interval = interval_conversion(interval) if x < 0 or x >= self.length(): raise ValueError("your value does not lie in [0;l[") i = 0 while x >= 0: x -= self._lengths[self._permutation._intervals[interval][i]] i += 1 i -= 1 x += self._lengths[self._permutation._intervals[interval][i]] j = self._permutation._intervals[interval][i] return self._permutation._alphabet.unrank(j)
def in_which_interval(self, x, interval=0): r""" Returns the letter for which x is in this interval. INPUT: - ``x`` - a positive number - ``interval`` - (default: 'top') 'top' or 'bottom' OUTPUT: label -- a label corresponding to an interval TEST: :: sage: t = iet.IntervalExchangeTransformation(('a b c','c b a'),[1,1,1]) sage: t.in_which_interval(0) 'a' sage: t.in_which_interval(0.3) 'a' sage: t.in_which_interval(1) 'b' sage: t.in_which_interval(1.9) 'b' sage: t.in_which_interval(2) 'c' sage: t.in_which_interval(2.1) 'c' sage: t.in_which_interval(3) Traceback (most recent call last): ... ValueError: your value does not lie in [0;l[ .. and for the bottom interval:: sage: t.in_which_interval(0,'bottom') 'c' sage: t.in_which_interval(1.2,'bottom') 'b' sage: t.in_which_interval(2.9,'bottom') 'a' """ interval = interval_conversion(interval) if x < 0 or x >= self.length(): raise ValueError, "your value does not lie in [0;l[" i = 0 while x >= 0: x -= self._lengths[self._permutation._intervals[interval][i]] i += 1 i -= 1 x += self._lengths[self._permutation._intervals[interval][i]] j = self._permutation._intervals[interval][i] return self._permutation._alphabet.unrank(j)