+ 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
+ {
+ return (is_a<indexed>(lh) ? lh.op(0) : lh).compare(is_a<indexed>(rh) ? rh.op(0) : rh) < 0;
+ }
+};
+
+/** Simplify product of indexed expressions (commutative, noncommutative and
+ * simple squares), return list of free indices. */
+ex simplify_indexed_product(const ex & e, exvector & free_indices, exvector & dummy_indices, const scalar_products & sp)
+{
+ // Remember whether the product was commutative or noncommutative
+ // (because we chop it into factors and need to reassemble later)
+ bool non_commutative = is_ex_exactly_of_type(e, ncmul);
+
+ // Collect factors in an exvector, store squares twice
+ exvector v;
+ v.reserve(e.nops() * 2);
+
+ if (is_ex_exactly_of_type(e, power)) {
+ // We only get called for simple squares, split a^2 -> a*a
+ GINAC_ASSERT(e.op(1).is_equal(_ex2));
+ v.push_back(e.op(0));
+ v.push_back(e.op(0));
+ } else {
+ for (unsigned i=0; i<e.nops(); i++) {
+ ex f = e.op(i);
+ if (is_ex_exactly_of_type(f, power) && f.op(1).is_equal(_ex2)) {
+ v.push_back(f.op(0));
+ v.push_back(f.op(0));
+ } else if (is_ex_exactly_of_type(f, ncmul)) {
+ // Noncommutative factor found, split it as well
+ non_commutative = true; // everything becomes noncommutative, ncmul will sort out the commutative factors later
+ for (unsigned j=0; j<f.nops(); j++)
+ v.push_back(f.op(j));
+ } else
+ v.push_back(f);
+ }
+ }
+
+ // Perform contractions
+ bool something_changed = false;
+ GINAC_ASSERT(v.size() > 1);
+ exvector::iterator it1, itend = v.end(), next_to_last = itend - 1;
+ for (it1 = v.begin(); it1 != next_to_last; it1++) {
+
+try_again:
+ if (!is_ex_of_type(*it1, indexed))
+ continue;
+
+ bool first_noncommutative = (it1->return_type() != return_types::commutative);
+
+ // Indexed factor found, get free indices and look for contraction
+ // candidates
+ exvector free1, dummy1;
+ find_free_and_dummy(ex_to<indexed>(*it1).seq.begin() + 1, ex_to<indexed>(*it1).seq.end(), free1, dummy1);
+
+ exvector::iterator it2;
+ for (it2 = it1 + 1; it2 != itend; it2++) {
+
+ if (!is_ex_of_type(*it2, indexed))
+ continue;
+
+ bool second_noncommutative = (it2->return_type() != return_types::commutative);
+
+ // Find free indices of second factor and merge them with free
+ // indices of first factor
+ exvector un;
+ find_free_and_dummy(ex_to<indexed>(*it2).seq.begin() + 1, ex_to<indexed>(*it2).seq.end(), un, dummy1);
+ un.insert(un.end(), free1.begin(), free1.end());
+
+ // Check whether the two factors share dummy indices
+ exvector free, dummy;
+ find_free_and_dummy(un, free, dummy);
+ unsigned num_dummies = dummy.size();
+ if (num_dummies == 0)
+ continue;
+
+ // At least one dummy index, is it a defined scalar product?
+ bool contracted = false;
+ if (free.empty()) {
+ if (sp.is_defined(*it1, *it2)) {
+ *it1 = sp.evaluate(*it1, *it2);
+ *it2 = _ex1;
+ goto contraction_done;
+ }
+ }
+
+ // Try to contract the first one with the second one
+ contracted = ex_to<basic>(it1->op(0)).contract_with(it1, it2, v);
+ if (!contracted) {
+
+ // That didn't work; maybe the second object knows how to
+ // contract itself with the first one
+ contracted = ex_to<basic>(it2->op(0)).contract_with(it2, it1, v);
+ }
+ if (contracted) {
+contraction_done:
+ if (first_noncommutative || second_noncommutative
+ || is_ex_exactly_of_type(*it1, add) || is_ex_exactly_of_type(*it2, add)
+ || is_ex_exactly_of_type(*it1, mul) || is_ex_exactly_of_type(*it2, mul)
+ || is_ex_exactly_of_type(*it1, ncmul) || is_ex_exactly_of_type(*it2, ncmul)) {
+
+ // One of the factors became a sum or product:
+ // re-expand expression and run again
+ // Non-commutative products are always re-expanded to give
+ // simplify_ncmul() the chance to re-order and canonicalize
+ // the product
+ ex r = (non_commutative ? ex(ncmul(v, true)) : ex(mul(v)));
+ return simplify_indexed(r, free_indices, dummy_indices, sp);
+ }
+
+ // Both objects may have new indices now or they might
+ // even not be indexed objects any more, so we have to
+ // start over
+ something_changed = true;
+ goto try_again;
+ }
+ }
+ }
+
+ // Find free indices (concatenate them all and call find_free_and_dummy())
+ // and all dummy indices that appear
+ exvector un, individual_dummy_indices;
+ for (it1 = v.begin(), itend = v.end(); it1 != itend; ++it1) {
+ exvector free_indices_of_factor;
+ if (is_ex_of_type(*it1, indexed)) {
+ exvector dummy_indices_of_factor;
+ find_free_and_dummy(ex_to<indexed>(*it1).seq.begin() + 1, ex_to<indexed>(*it1).seq.end(), free_indices_of_factor, dummy_indices_of_factor);
+ individual_dummy_indices.insert(individual_dummy_indices.end(), dummy_indices_of_factor.begin(), dummy_indices_of_factor.end());
+ } else
+ free_indices_of_factor = it1->get_free_indices();
+ un.insert(un.end(), free_indices_of_factor.begin(), free_indices_of_factor.end());
+ }
+ exvector local_dummy_indices;
+ find_free_and_dummy(un, free_indices, local_dummy_indices);
+ local_dummy_indices.insert(local_dummy_indices.end(), individual_dummy_indices.begin(), individual_dummy_indices.end());
+
+ // 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, bring the product into a canonical order that only depends on
+ // the base expressions of indexed objects
+ if (!non_commutative)
+ std::sort(v.begin(), v.end(), ex_base_is_less());
+
+ exvector moved_indices;
+
+ // Iterate over all indexed objects in the product
+ for (it1 = v.begin(), itend = v.end(); it1 != itend; ++it1) {
+ if (!is_ex_of_type(*it1, indexed))
+ continue;
+
+ if (reposition_dummy_indices(*it1, variant_dummy_indices, moved_indices))
+ something_changed = true;
+ }
+ }
+
+ ex r;
+ if (something_changed)
+ r = non_commutative ? ex(ncmul(v, true)) : ex(mul(v));
+ else
+ r = e;
+
+ // The result should be symmetric with respect to exchange of dummy
+ // indices, so if the symmetrization vanishes, the whole expression is
+ // zero. This detects things like eps.i.j.k * p.j * p.k = 0.
+ if (local_dummy_indices.size() >= 2) {
+ lst dummy_syms;
+ for (int i=0; i<local_dummy_indices.size(); i++)
+ dummy_syms.append(local_dummy_indices[i].op(0));
+ if (r.symmetrize(dummy_syms).is_zero()) {
+ free_indices.clear();
+ return _ex0;
+ }
+ }
+
+ // Dummy index renaming
+ r = rename_dummy_indices(r, dummy_indices, local_dummy_indices);
+
+ // Product of indexed object with a scalar?
+ if (is_ex_exactly_of_type(r, mul) && r.nops() == 2
+ && is_ex_exactly_of_type(r.op(1), numeric) && is_ex_of_type(r.op(0), indexed))
+ return ex_to<basic>(r.op(0).op(0)).scalar_mul_indexed(r.op(0), ex_to<numeric>(r.op(1)));
+ else
+ return r;
+}
+
+/** This structure stores the original and symmetrized versions of terms
+ * obtained during the simplification of sums. */
+class terminfo {
+public:
+ terminfo(const ex & orig_, const ex & symm_) : orig(orig_), symm(symm_) {}
+
+ ex orig; /**< original term */
+ ex symm; /**< symmtrized term */
+};
+
+class terminfo_is_less {
+public:
+ bool operator() (const terminfo & ti1, const terminfo & ti2) const
+ {
+ return (ti1.symm.compare(ti2.symm) < 0);
+ }
+};
+
+/** This structure stores the individual symmetrized terms obtained during
+ * the simplification of sums. */
+class symminfo {
+public:
+ symminfo() : num(0) {}
+
+ symminfo(const ex & symmterm_, const ex & orig_, unsigned num_) : orig(orig_), num(num_)
+ {
+ if (is_exactly_a<mul>(symmterm_) && is_exactly_a<numeric>(symmterm_.op(symmterm_.nops()-1))) {
+ coeff = symmterm_.op(symmterm_.nops()-1);
+ symmterm = symmterm_ / coeff;
+ } else {
+ coeff = 1;
+ symmterm = symmterm_;
+ }
+ }
+
+ ex symmterm; /**< symmetrized term */
+ ex coeff; /**< coefficient of symmetrized term */
+ ex orig; /**< original term */
+ unsigned num; /**< how many symmetrized terms resulted from the original term */
+};
+
+class symminfo_is_less_by_symmterm {
+public:
+ bool operator() (const symminfo & si1, const symminfo & si2) const
+ {
+ return (si1.symmterm.compare(si2.symmterm) < 0);
+ }
+};
+
+class symminfo_is_less_by_orig {
+public:
+ bool operator() (const symminfo & si1, const symminfo & si2) const
+ {
+ return (si1.orig.compare(si2.orig) < 0);
+ }
+};
+
+/** Simplify indexed expression, return list of free indices. */
+ex simplify_indexed(const ex & e, exvector & free_indices, exvector & dummy_indices, const scalar_products & sp)
+{
+ // Expand the expression
+ ex e_expanded = e.expand();
+
+ // Simplification of single indexed object: just find the free indices
+ // 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);
+ }
+
+ // Simplification of sum = sum of simplifications, check consistency of
+ // free indices in each term
+ if (is_ex_exactly_of_type(e_expanded, add)) {
+ bool first = true;
+ ex sum;
+ free_indices.clear();
+
+ for (unsigned i=0; i<e_expanded.nops(); i++) {
+ exvector free_indices_of_term;
+ ex term = simplify_indexed(e_expanded.op(i), free_indices_of_term, dummy_indices, sp);
+ if (!term.is_zero()) {
+ if (first) {
+ free_indices = free_indices_of_term;
+ sum = term;
+ first = false;
+ } else {
+ if (!indices_consistent(free_indices, free_indices_of_term)) {
+ std::ostringstream s;
+ s << "simplify_indexed: inconsistent indices in sum: ";
+ s << exprseq(free_indices) << " vs. " << exprseq(free_indices_of_term);
+ throw (std::runtime_error(s.str()));
+ }
+ if (is_ex_of_type(sum, indexed) && is_ex_of_type(term, indexed))
+ sum = ex_to<basic>(sum.op(0)).add_indexed(sum, term);
+ else
+ sum += term;
+ }
+ }
+ }