Fix index renaming to handle new cases in explicit_indices.

Author: kpeeters

cmake/version.cmake

@@ -1,7 +1,7 @@
 set(CADABRA_VERSION_MAJOR 2)
 set(CADABRA_VERSION_MINOR 3)
 set(CADABRA_VERSION_PATCH 5)
-set(CADABRA_VERSION_TWEAK 3)
+set(CADABRA_VERSION_TWEAK 4)
 set(COPYRIGHT_YEARS "2001-2020")
 math(EXPR SYSTEM_BITS "${CMAKE_SIZEOF_VOID_P} * 8")
 find_program(GIT git PATHS ${GIT_DIR})

core/Algorithm.cc

@@ -40,7 +40,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <sstream>
 
-// #define DEBUG
+//#define DEBUG
 
 using namespace cadabra;
 
@@ -272,8 +272,10 @@ Algorithm::result_t Algorithm::apply_deep(Ex::iterator& it)
 			result_t res = apply(work);
 			if(res==Algorithm::result_t::l_applied || res==Algorithm::result_t::l_applied_no_new_dummies) {
 				some_changes_somewhere=result_t::l_applied;
-				if(res==Algorithm::result_t::l_applied)
+				if(res==Algorithm::result_t::l_applied) {
+//					std::cerr << "rename replacement on " << work << std::endl;
 					rename_replacement_dummies(work, true);
+					}
 				deepest_action=tr.depth(work);
 				// If we got a zero at 'work', we need to propagate this up the tree and
 				// then restart our post-order traversal such that everything that has
@@ -660,7 +662,7 @@ bool Algorithm::rename_replacement_dummies(iterator two, bool still_inside_algo)
 	index_map_t ind_free, ind_dummy;
 	index_map_t ind_free_full, ind_dummy_full;
 
-	if(still_inside_algo) {
+	if(false && still_inside_algo) {
 		if(tr.is_head(two)==false)
 			classify_indices_up(tr.parent(two), ind_free_full, ind_dummy_full);
 		}
@@ -675,6 +677,9 @@ bool Algorithm::rename_replacement_dummies(iterator two, bool still_inside_algo)
 	std::cerr << "free indices above us" << std::endl;
 	for(auto& ii: ind_free_full)
 		std::cerr << ii.first << std::endl;
+	std::cerr << "dummy indices above us" << std::endl;
+	for(auto& ii: ind_dummy_full)
+		std::cerr << ii.first << std::endl;
 #endif
 
 	index_map_t must_be_empty;
@@ -684,7 +689,9 @@ bool Algorithm::rename_replacement_dummies(iterator two, bool still_inside_algo)
 	determine_intersection(ind_dummy_full, ind_dummy, must_be_empty);
 	index_map_t::iterator it=must_be_empty.begin();
 	while(it!=must_be_empty.end()) {
-		// std::cerr << "double index pair" << std::endl;
+#ifdef DEBUG
+		std::cerr << "double index pair" << std::endl;
+#endif
 		Ex the_key=(*it).first;
 		const Indices *dums=kernel.properties.get<Indices>(it->second, true);
 		if(!dums)

core/Algorithm.hh

@@ -131,9 +131,11 @@ namespace cadabra {
 			// The set to which the first index belongs..
 			std::string get_index_set_name(iterator it) const;
 
+			/// Rename the dummies in the sub-tree starting with head at the given iterator.
+			/// Ensures that no dummies in this sub-tree overlap with the indices elsewhere
+			/// in the tree.			
 			bool     rename_replacement_dummies(iterator, bool still_inside_algo=false);
 
-
 			/// Determines whether the indicated node is 'like a term in a
 			/// sum'.  This requires that the node is not a `\sum` node, not
 			/// a child of a `\prod` node, and that its parent rel is of

core/IndexClassifier.cc

@@ -8,7 +8,7 @@
 #include "properties/IndexInherit.hh"
 #include <sstream>
 
-// #define DEBUG
+// #define DEBUG 1
 
 using namespace cadabra;
 
@@ -156,11 +156,11 @@ void IndexClassifier::classify_add_index(Ex::iterator it, index_map_t& ind_free,
 		}
 	}
 
-// This classifies indices bottom-up, that is, given a node, it goes up the tree to find
-// all free and dummy indices in the product in which this node would end up if a full
-// distribute would be done on the entire expression.
 void IndexClassifier::classify_indices_up(Ex::iterator it, index_map_t& ind_free, index_map_t& ind_dummy)  const
 	{
+#ifdef DEBUG
+	std::cerr << "classify_indices_up at " << it << std::endl;
+#endif
 loopie:
 	if(Ex::is_head(it)) return;
 	Ex::iterator par=Ex::parent(it);
@@ -180,8 +180,14 @@ void IndexClassifier::classify_indices_up(Ex::iterator it, index_map_t& ind_free
 		// children; add the indices thus found to the maps since they will end up in our factor.
 		Ex::sibling_iterator sit=par.begin();
 		while(sit!=par.end()) {
+#ifdef DEBUG
+			std::cerr << "checking " << sit << std::endl;
+#endif
 			if(sit!=Ex::sibling_iterator(it)) {
 				if(sit->is_index()==false) {
+#ifdef DEBUG
+					std::cerr << "classifying at " << sit << std::endl;
+#endif
 					index_map_t factor_free, factor_dummy;
 					classify_indices(sit, factor_free, factor_dummy);
 
@@ -264,8 +270,6 @@ void IndexClassifier::dumpmap(std::ostream& str, const index_map_t& mp) const
 	str << std::endl;
 	}
 
-// This classifies indices top-down, that is, finds the free indices and all dummy
-// index pairs used in the full subtree below a given node.
 void IndexClassifier::classify_indices(Ex::iterator it, index_map_t& ind_free, index_map_t& ind_dummy) const
 	{
 	const IndexInherit *inh=kernel.properties.get<IndexInherit>(it);

core/IndexClassifier.hh

@@ -46,8 +46,18 @@ namespace cadabra {
 			                                bool move_out=false) const;
 
 			void     classify_add_index(Ex::iterator it, index_map_t& ind_free, index_map_t& ind_dummy) const;
+
+			/// Classify indices bottom-up, that is, given a node, it goes up the tree to find
+         /// all free and dummy indices in the product in which this node would end up if a full
+         /// distribute would be done on the entire expression.
+
 			void     classify_indices_up(Ex::iterator, index_map_t& ind_free, index_map_t& ind_dummy) const;
+
+         /// Classify indices top-down, that is, finds the free indices and all dummy
+         /// index pairs used in the full subtree below a given node.
+
 			void     classify_indices(Ex::iterator, index_map_t& ind_free, index_map_t& ind_dummy) const;
+			
 			int      max_numbered_name_one(const std::string& nm, const index_map_t * one) const;
 			int      max_numbered_name(const std::string&, const index_map_t *m1, const index_map_t *m2=0,
 			                           const index_map_t *m3=0, const index_map_t *m4=0, const index_map_t *m5=0) const;

core/algorithms/explicit_indices.cc

@@ -89,6 +89,8 @@ Algorithm::result_t explicit_indices::apply(iterator& it)
 
 	// Classify all free and dummy indices already present. Any new
 	// indices cannot be taken from these.
+//	std::cerr << "acting at " << it << std::endl;
+	
 	ind_free_sum.clear();
 	ind_dummy_sum.clear();
 	classify_indices(it, ind_free_sum, ind_dummy_sum);
@@ -116,13 +118,15 @@ Algorithm::result_t explicit_indices::apply(iterator& it)
 				sibling_iterator args=tr.begin(factor);
 				while(args!=tr.end(factor)) {
 					if(args->fl.parent_rel==str_node::p_none) {
+						res=result_t::l_applied;
 						handle_factor(args, trace!=0);
 						break;
 						}
 					++args;
 					}
 				}
 			else {
+				res=result_t::l_applied;				
 				handle_factor(factor, trace!=0);
 				}
 			++factor;
@@ -147,8 +151,17 @@ Algorithm::result_t explicit_indices::apply(iterator& it)
 		it=parit;
 		it = tr.flatten_and_erase(it);
 		}
-	cleanup_dispatch(kernel, tr, it);
-
+	if(*it->name=="\\sum" && tr.number_of_children(it)==1)
+		it = tr.flatten_and_erase(it);
+	// It looks like we will have trouble if we also flatten the
+	// \prod node, becuase then rename_dummies will only act on
+	// the first factor we introduced, and fail to rename
+	// properly.
+//	cleanup_dispatch(kernel, tr, it);
+
+//	std::cerr << "after explicit_indicex: " << tr.begin() << std::endl;
+//	std::cerr << "and it is now " << it << std::endl;
+	
 	return res;
 	}