Added methods to RC's.

src/sage/combinat/rigged_configurations/bij_type_B.py

@@ -580,7 +580,7 @@ def run(self, verbose=False):
                                                           self.cur_partitions[-1].rigging,
                                                           self.cur_partitions[-1].vacancy_numbers)
 
-                bij = RCToKRTBijectionTypeA2Odd(RC(*self.cur_partitions))
+                bij = RCToKRTBijectionTypeA2Odd(RC(*self.cur_partitions, use_vacancy_numbers=True))
                 for i in range(len(self.cur_dims)):
                     if bij.cur_dims[i][0] != self.n:
                         bij.cur_dims[i][1] *= 2

src/sage/combinat/rigged_configurations/rigged_configuration_element.py

@@ -226,15 +226,17 @@ def __init__(self, parent, rigged_partitions=[], **options):
                     for partition_data in data:
                         nu.append(RiggedPartition(tuple(partition_data)))
         elif parent._cartan_type.classical().rank() == len(rigged_partitions) and \
-            isinstance(rigged_partitions[0], RiggedPartition):
-            # The isinstance check is to make sure we are not in the n == 1 special case because
-            #   Parent's __call__ always passes at least 1 argument to the element constructor
-
-            # Special display case
-            if parent.cartan_type().type() == 'B':
-                rigged_partitions[-1] = RiggedPartitionTypeB(rigged_partitions[-1])
-            ClonableArray.__init__(self, parent, rigged_partitions)
-            return
+                isinstance(rigged_partitions[0], RiggedPartition):
+            if options.get('use_vacancy_numbers', False):
+                # The isinstance check is to make sure we are not in the n == 1 special case because
+                #   Parent's __call__ always passes at least 1 argument to the element constructor
+
+                # Special display case
+                if parent.cartan_type().type() == 'B':
+                    rigged_partitions[-1] = RiggedPartitionTypeB(rigged_partitions[-1])
+                ClonableArray.__init__(self, parent, rigged_partitions)
+                return
+            nu = rigged_partitions
         else:
             # Otherwise we did not receive any info, create a size n array of
             #   empty rigged partitions
@@ -510,6 +512,87 @@ def to_tensor_product_of_kirillov_reshetikhin_crystals(self, display_steps=False
         kr_tab = self.to_tensor_product_of_kirillov_reshetikhin_tableaux(display_steps)
         return kr_tab.to_tensor_product_of_kirillov_reshetikhin_crystals()
 
+    def left_split(self):
+        r"""
+        Return the image of ``self`` under the left column splitting
+        map `\beta`.
+
+        Consider the map `\beta : RC(B^{r,s} \otimes B) \to RC(B^{r,1}
+        \otimes B^{r,s-1} \otimes B)` for `s > 1` which is a natural classical
+        crystal injection. On rigged configurations, the map `\beta` does
+        nothing (except possibly changing the vacancy numbers).
+
+        EXAMPLES::
+
+            sage: RC = RiggedConfigurations(['C',4,1], [[3,3]])
+            sage: mg = RC.module_generators[-1]
+            sage: ascii_art(mg)
+            0[ ][ ]0  0[ ][ ]0  0[ ][ ]0  0[ ]0
+                      0[ ][ ]0  0[ ][ ]0  0[ ]0
+                                0[ ][ ]0  0[ ]0
+            sage: ascii_art(mg.left_split())
+            0[ ][ ]0  0[ ][ ]0  1[ ][ ]0  0[ ]0
+                      0[ ][ ]0  1[ ][ ]0  0[ ]0
+                                1[ ][ ]0  0[ ]0
+        """
+        P = self.parent()
+        B = list(P.dims)
+        if B[0][1] == 1:
+            raise ValueError("cannot split a single column")
+        B[0] = (B[0][0], B[0][1] - 1)
+        B.insert(0, (B[0][0], 1))
+        from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations
+        RC = RiggedConfigurations(P._cartan_type, B)
+        return RC(*self)
+
+    def delta(self, return_b=False):
+        r"""
+        Return the image of ``self`` under the map basic map `\delta`. If the
+        left-most factor is not a single column, then this also performs a
+        :meth:`left_split()`.
+
+        The map `\delta : RC(B^{r,1} \otimes B) \to RC(B^{r-1,1}
+        \otimes B)` (if `r = 1`, then we remove the left-most factor) is the
+        basic map in the bijection `\Phi` between rigged configurations and
+        tensor products of Kirillov-Reshetikhin tableaux. For more
+        information, see
+        :meth:`to_tensor_product_of_kirillov_reshetikhin_tableaux()`.
+
+        INPUT:
+
+        - ``return_b`` -- return the resulting letter from `\delta`
+
+        EXAMPLES::
+
+            sage: RC = RiggedConfigurations(['C',4,1], [[3,2]])
+            sage: mg = RC.module_generators[-1]
+            sage: ascii_art(mg)
+            0[ ][ ]0  0[ ][ ]0  0[ ][ ]0  0[ ]0
+                      0[ ][ ]0  0[ ][ ]0  0[ ]0
+                                0[ ][ ]0  0[ ]0
+            sage: ascii_art(mg.delta())
+            0[ ]0  0[ ][ ]0  0[ ][ ]0  0[ ]0
+                   0[ ]0     0[ ][ ]0  0[ ]0
+            sage: x,b = mg.delta(True)
+            sage: b
+            -1
+        """
+        from sage.combinat.rigged_configurations.bijection import RCToKRTBijection
+        rc = self
+        if self.parent().dims[0][1] != 1:
+            rc = self.left_split()
+        bij = RCToKRTBijection(rc)
+        bij.cur_dims[0][0] -= 1 # This takes care of the indexing
+        b = bij.next_state(bij.cur_dims[0][0])
+        if bij.cur_dims[0][0] == 0:
+            bij.cur_dims.pop(0)
+        from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations
+        RC = RiggedConfigurations(self.parent()._cartan_type, bij.cur_dims)
+        rc = RC(*bij.cur_partitions)
+        if return_b:
+            return (rc, b)
+        return rc
+
     def nu(self):
         r"""
         Return the list `\nu` of rigged partitions of this rigged