fixed a bug in the raising/lowering of dummy indices and extended it to work

on single indexed objects also

diff --git a/NEWS b/NEWS
index 67f36b9970b3c6ae4a6b051f90c6508a57f3b9a6..36a5412d455166544ae65517f556dfb5e5cac3f7 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -3,7 +3,7 @@ This file records noteworthy changes.
 1.0.9 (<date>)
 * simplify_indexed() now raises/lowers dummy indices to canonicalize the index
   variance. This allows some simplifications that weren't possible before,
-  like eps~a.b~c~d*X.a*X~b -> 0.
+  like eps~a.b~c~d*X.a*X~b -> 0 and X.a~a-X~a.a -> 0.
 
 1.0.8 (31 March 2002)
 * Improvements in memory usage of the expand() methods.

diff --git a/check/exam_indexed.cpp b/check/exam_indexed.cpp
index 4ba1794bcdba507b2bb00e5f0ba57cb6211ea514..a8c7cbd698f6da73a6673bb32e60cdfd44c387c9 100644 (file)
--- a/check/exam_indexed.cpp
+++ b/check/exam_indexed.cpp
@@ -337,7 +337,7 @@ static unsigned spinor_check(void)
 
 static unsigned dummy_check(void)
 {
-       // check dummy index renaming
+       // check dummy index renaming/repositioning
 
        unsigned result = 0;
 
@@ -356,6 +356,15 @@ static unsigned dummy_check(void)
        e = indexed(p, mu, mu.toggle_variance()) - indexed(p, nu, nu.toggle_variance());
        result += check_equal_simplify(e, 0);
 
+       e = indexed(p, mu.toggle_variance(), nu, mu) * indexed(q, i)
+         - indexed(p, mu, nu, mu.toggle_variance()) * indexed(q, i);
+       result += check_equal_simplify(e, 0);
+
+       e = indexed(p, mu, mu.toggle_variance()) - indexed(p, nu.toggle_variance(), nu);
+       result += check_equal_simplify(e, 0);
+       e = indexed(p, mu.toggle_variance(), mu) - indexed(p, nu, nu.toggle_variance());
+       result += check_equal_simplify(e, 0);
+
        return result;
 }
 

diff --git a/ginac/indexed.cpp b/ginac/indexed.cpp
index eec7b11fe6fa4cd8057d1059240172b7de31f590..dcd6d9510d6d0ac688802373f30f7d93e0f07362 100644 (file)
--- a/ginac/indexed.cpp
+++ b/ginac/indexed.cpp
@@ -493,7 +493,7 @@ exvector power::get_free_indices(void) const
 
 /** Rename dummy indices in an expression.
  *
- *  @param e Expression to be worked on
+ *  @param e Expression to work on
  *  @param local_dummy_indices The set of dummy indices that appear in the
  *    expression "e"
  *  @param global_dummy_indices The set of dummy indices that have appeared
@@ -554,6 +554,72 @@ static ex rename_dummy_indices(const ex & e, exvector & global_dummy_indices, ex
        }
 }
 
+/** Given a set of indices, extract those of class varidx. */
+static void find_variant_indices(const exvector & v, exvector & variant_indices)
+{
+       exvector::const_iterator it1, itend;
+       for (it1 = v.begin(), itend = v.end(); it1 != itend; ++it1) {
+               if (is_exactly_a<varidx>(*it1))
+                       variant_indices.push_back(*it1);
+       }
+}
+
+/** Raise/lower dummy indices in a single indexed objects to canonicalize their
+ *  variance.
+ *
+ *  @param e Object to work on
+ *  @param variant_dummy_indices The set of indices that might need repositioning (will be changed by this function)
+ *  @param moved_indices The set of indices that have been repositioned (will be changed by this function)
+ *  @return true if 'e' was changed */
+bool reposition_dummy_indices(ex & e, exvector & variant_dummy_indices, exvector & moved_indices)
+{
+       bool something_changed = false;
+
+       // If a dummy index is encountered for the first time in the
+       // product, pull it up, otherwise, pull it down
+       exvector::const_iterator it2, it2start, it2end;
+       for (it2start = ex_to<indexed>(e).seq.begin(), it2end = ex_to<indexed>(e).seq.end(), it2 = it2start + 1; it2 != it2end; ++it2) {
+               if (!is_exactly_a<varidx>(*it2))
+                       continue;
+
+               exvector::iterator vit, vitend;
+               for (vit = variant_dummy_indices.begin(), vitend = variant_dummy_indices.end(); vit != vitend; ++vit) {
+                       if (it2->op(0).is_equal(vit->op(0))) {
+                               if (ex_to<varidx>(*it2).is_covariant()) {
+                                       e = e.subs(lst(
+                                               *it2 == ex_to<varidx>(*it2).toggle_variance(),
+                                               ex_to<varidx>(*it2).toggle_variance() == *it2
+                                       ));
+                                       something_changed = true;
+                                       it2 = ex_to<indexed>(e).seq.begin() + (it2 - it2start);
+                                       it2start = ex_to<indexed>(e).seq.begin();
+                                       it2end = ex_to<indexed>(e).seq.end();
+                               }
+                               moved_indices.push_back(*vit);
+                               variant_dummy_indices.erase(vit);
+                               goto next_index;
+                       }
+               }
+
+               for (vit = moved_indices.begin(), vitend = moved_indices.end(); vit != vitend; ++vit) {
+                       if (it2->op(0).is_equal(vit->op(0))) {
+                               if (ex_to<varidx>(*it2).is_contravariant()) {
+                                       e = e.subs(*it2 == ex_to<varidx>(*it2).toggle_variance());
+                                       something_changed = true;
+                                       it2 = ex_to<indexed>(e).seq.begin() + (it2 - it2start);
+                                       it2start = ex_to<indexed>(e).seq.begin();
+                                       it2end = ex_to<indexed>(e).seq.end();
+                               }
+                               goto next_index;
+                       }
+               }
+
+next_index: ;
+       }
+
+       return something_changed;
+}
+
 /* Ordering that only compares the base expressions of indexed objects. */
 struct ex_base_is_less : public std::binary_function<ex, ex, bool> {
        bool operator() (const ex &lh, const ex &rh) const
@@ -695,10 +761,7 @@ contraction_done:
 
        // Filter out the dummy indices with variance
        exvector variant_dummy_indices;
-       for (it1 = local_dummy_indices.begin(), itend = local_dummy_indices.end(); it1 != itend; ++it1) {
-               if (is_exactly_a<varidx>(*it1))
-                       variant_dummy_indices.push_back(*it1);
-       }
+       find_variant_indices(local_dummy_indices, variant_dummy_indices);
 
        // Any indices with variance present at all?
        if (!variant_dummy_indices.empty()) {
@@ -715,46 +778,8 @@ contraction_done:
                        if (!is_ex_of_type(*it1, indexed))
                                continue;
 
-                       ex new_it1;
-                       bool it1_dirty = false; // It this is true, then new_it1 holds a new value for *it1
-
-                       // If a dummy index is encountered for the first time in the
-                       // product, pull it up, otherwise, pull it down
-                       exvector::iterator it2, it2end;
-                       for (it2 = const_cast<indexed &>(ex_to<indexed>(*it1)).seq.begin(), it2end = const_cast<indexed &>(ex_to<indexed>(*it1)).seq.end(); it2 != it2end; ++it2) {
-                               if (!is_exactly_a<varidx>(*it2))
-                                       continue;
-
-                               exvector::iterator vit, vitend;
-                               for (vit = variant_dummy_indices.begin(), vitend = variant_dummy_indices.end(); vit != vitend; ++vit) {
-                                       if (it2->op(0).is_equal(vit->op(0))) {
-                                               if (ex_to<varidx>(*it2).is_covariant()) {
-                                                       new_it1 = (it1_dirty ? new_it1 : *it1).subs(*it2 == ex_to<varidx>(*it2).toggle_variance());
-                                                       it1_dirty = true;
-                                                       something_changed = true;
-                                               }
-                                               moved_indices.push_back(*vit);
-                                               variant_dummy_indices.erase(vit);
-                                               goto next_index;
-                                       }
-                               }
-
-                               for (vit = moved_indices.begin(), vitend = moved_indices.end(); vit != vitend; ++vit) {
-                                       if (it2->op(0).is_equal(vit->op(0))) {
-                                               if (ex_to<varidx>(*it2).is_contravariant()) {
-                                                       new_it1 = (it1_dirty ? new_it1 : *it1).subs(*it2 == ex_to<varidx>(*it2).toggle_variance());
-                                                       it1_dirty = true;
-                                                       something_changed = true;
-                                               }
-                                               goto next_index;
-                                       }
-                               }
-
-next_index:            ;
-                       }
-
-                       if (it1_dirty)
-                               *it1 = new_it1;
+                       if (reposition_dummy_indices(*it1, variant_dummy_indices, moved_indices))
+                               something_changed = true;
                }
        }
 
@@ -795,11 +820,27 @@ ex simplify_indexed(const ex & e, exvector & free_indices, exvector & dummy_indi
        ex e_expanded = e.expand();
 
        // Simplification of single indexed object: just find the free indices
-       // and perform dummy index renaming
+       // and perform dummy index renaming/repositioning
        if (is_ex_of_type(e_expanded, indexed)) {
+
+               // Find the dummy indices
                const indexed &i = ex_to<indexed>(e_expanded);
                exvector local_dummy_indices;
                find_free_and_dummy(i.seq.begin() + 1, i.seq.end(), free_indices, local_dummy_indices);
+
+               // Filter out the dummy indices with variance
+               exvector variant_dummy_indices;
+               find_variant_indices(local_dummy_indices, variant_dummy_indices);
+
+               // Any indices with variance present at all?
+               if (!variant_dummy_indices.empty()) {
+
+                       // Yes, reposition them
+                       exvector moved_indices;
+                       reposition_dummy_indices(e_expanded, variant_dummy_indices, moved_indices);
+               }
+
+               // Rename the dummy indices
                return rename_dummy_indices(e_expanded, dummy_indices, local_dummy_indices);
        }
 

diff --git a/ginac/indexed.h b/ginac/indexed.h
index 58c8bbd4ce16bda7ad563a7c3fb987610ed11317..f539444e7b29f04b39edf42bbf38d0059ecd1924 100644 (file)
--- a/ginac/indexed.h
+++ b/ginac/indexed.h
@@ -42,6 +42,7 @@ class indexed : public exprseq
 
        friend ex simplify_indexed(const ex & e, exvector & free_indices, exvector & dummy_indices, const scalar_products & sp);
        friend ex simplify_indexed_product(const ex & e, exvector & free_indices, exvector & dummy_indices, const scalar_products & sp);
+       friend bool reposition_dummy_indices(ex & e, exvector & variant_dummy_indices, exvector & moved_indices);
 
        // other constructors
 public: