Make ImplicitIndex much more flexible.

Author: kpeeters

core/Algorithm.cc

@@ -37,7 +37,7 @@
 
 #include <sstream>
 
-#define DEBUG
+// #define DEBUG
 
 using namespace cadabra;
 

core/Compare.cc

@@ -1260,11 +1260,69 @@ int Ex_comparator::can_swap_ilist_ilist(Ex::iterator obj1, Ex::iterator obj2)
 	return sign;
 	}
 
+bool Ex_comparator::can_swap_different_indexsets(Ex::iterator obj1, Ex::iterator obj2) 
+	{
+	std::set<const Indices *> index_sets1;
+	// std::cerr << "Are " << obj1 << " and " << obj2 << " swappable?" << std::endl;
+
+	index_iterator it1=index_iterator::begin(properties, obj1);
+	while(it1!=index_iterator::end(properties, obj1)) {
+		auto ind = properties.get<Indices>(it1, true);
+		if(!ind) return false;
+		index_sets1.insert(ind);
+		++it1;
+		}
+	index_iterator it2=index_iterator::begin(properties, obj2);
+	while(it2!=index_iterator::end(properties, obj2)) {
+		auto ind = properties.get<Indices>(it2, true);
+		if(!ind) return false;
+		if(index_sets1.find(ind)!=index_sets1.end()) {
+			// std::cerr << "NO" << std::endl;
+			return false;
+			}
+		++it2;
+		}
+	// std::cerr << "YES" << std::endl;		
+	return true;
+	}
+
 int Ex_comparator::can_swap(Ex::iterator one, Ex::iterator two, match_t subtree_comparison,
-										 bool ignore_implicit_indices) 
+									 bool ignore_implicit_indices) 
 	{
 	// std::cerr << "can_swap " << *one->name << " " << *two->name << " " << ignore_implicit_indices << std::endl;
 
+	// Explicitly declared commutation behaviour goes first.
+	const CommutingBehaviour *com = properties.get_composite<CommutingBehaviour>(one, two, true);
+	if(com) 
+		return com->sign();
+
+
+	// If both objects have implicit indices, we cannot swap the
+	// objects because that would re-order the index line. The sole
+	// exception is when these indices are explicitly stated to be in
+	// different sets.
+	
+	const ImplicitIndex *ii1 = properties.get_composite<ImplicitIndex>(one);
+	const ImplicitIndex *ii2 = properties.get_composite<ImplicitIndex>(two);
+	if(!ignore_implicit_indices) {
+		if(ii1) {
+			if(ii1->explicit_form.size()==0) {
+				if(ii2) return 0; // nothing known about explicit form
+				}
+			else one=ii1->explicit_form.begin();
+			}
+		if(ii2) {
+			if(ii2->explicit_form.size()==0) {
+				if(ii1) return 0; // nothing known about explicit form
+				}
+			else two=ii2->explicit_form.begin();
+			}
+		// Check that indices in one and two are in mutually exclusive sets.
+		if(ii1 && ii2) 
+			if(!can_swap_different_indexsets(one, two))
+				return false;
+		}
+
 	// Differential forms in a product cannot be moved through each
 	// other except when the degree of one of them is zero.  In a wedge
 	// product, we can move them and potentially pick up a sign.
@@ -1287,43 +1345,6 @@ int Ex_comparator::can_swap(Ex::iterator one, Ex::iterator two, match_t subtree_
 				}
 			}
 		}
-	
-	const ImplicitIndex *ii1 = properties.get_composite<ImplicitIndex>(one);
-	const ImplicitIndex *ii2 = properties.get_composite<ImplicitIndex>(two);
-
-	// When both objects carry an implicit index but the index lines are not connected,
-	// we should not be using explicit commutation rules, as this would mess up the
-	// index lines and make the expression meaningless.
-	// FIXME: this would ideally make use of index and conjugate index lines.
-
-	const DiracBar *db2 = properties.get_composite<DiracBar>(two);
-	if(! (ii1 && ii2 && db2) ) {
-
-		// First of all, check whether there is an explicit declaration for the commutativity 
-		// of these two symbols.
-//		std::cout << *one->name << " explicit " << *two->name << std::endl;
-		const CommutingBehaviour *com = properties.get_composite<CommutingBehaviour>(one, two, true);
-		
-		if(com) {
-//			std::cout << typeid(com).name() << std::endl;
-//			std::cout << "explicit " << com->sign() << std::endl;
-			return com->sign();
-			}
-		}
-	
-	if(ignore_implicit_indices==false) {
-		// Two implicit-index objects cannot move through each other if they have the
-		// same type of implicit index.
-//		std::cout << "can_swap " << *one->name << " " << *two->name << std::endl;
-
-		if(ii1 && ii2) {
-			if(ii1->set_names.size()==0 && ii2->set_names.size()==0) return 0; // empty index name
-			for(size_t n1=0; n1<ii1->set_names.size(); ++n1)
-				for(size_t n2=0; n2<ii2->set_names.size(); ++n2)
-					if(ii1->set_names[n1]==ii2->set_names[n2])
-						return 0;
-			}
-		}
 
 	// Do we need to use Self* properties?
 	const SelfCommutingBehaviour *sc1 =properties.get_composite<SelfCommutingBehaviour>(one, true);

core/Compare.hh

@@ -337,6 +337,7 @@ class Ex_comparator {
 		int  can_swap_prod_sum(Ex::iterator prod, Ex::iterator sum, bool) ;
 		int  can_swap_sum_sum(Ex::iterator sum1, Ex::iterator sum2, bool) ;
 		int  can_swap_ilist_ilist(Ex::iterator obj1, Ex::iterator obj2);
+		bool can_swap_different_indexsets(Ex::iterator obj1, Ex::iterator obj2);		
 
 		std::string tab() const;
 		match_t     report(match_t r) const;

core/properties/DifferentialForm.hh

@@ -8,7 +8,7 @@
 
 namespace cadabra {
 
-	class DifferentialForm : public ImplicitIndex, public IndexInherit, public DifferentialFormBase {
+	class DifferentialForm : public IndexInherit, public DifferentialFormBase {
 		public:
 			virtual std::string name() const override;
 			virtual bool parse(Kernel&, keyval_t&) override;

core/properties/ImplicitIndex.cc

@@ -15,10 +15,10 @@ bool ImplicitIndex::parse(Kernel&, keyval_t& keyvals)
 	while(ki!=keyvals.end()) {
 //		std::cout << "ImplicitIndex: " << ki->first << " = " << *ki->second->name << std::endl;
 		if(ki->first=="name") {
-			if(*ki->second->multiplier!=1) {
-				throw std::logic_error("ImplicitIndex: use quotes to label names when they start with a number.");
-				}
-			set_names.push_back(*ki->second->name);
+			throw std::logic_error("ImplicitIndex: argument 'name' no longer supported");
+			}
+		else if(ki->first=="explicit") {
+			explicit_form=ki->second;
 			}
 		else throw ConsistencyException("Property 'ImplicitIndex' does not accept key '"+ki->first+"'.");
 		++ki;
@@ -30,8 +30,8 @@ bool ImplicitIndex::parse(Kernel&, keyval_t& keyvals)
 void ImplicitIndex::latex(std::ostream& str) const
 	{
 	property::latex(str);
-	for(size_t n=0; n<set_names.size(); ++n) {
-		if(n>0) str << ", ";
-		str << set_names[n];
-		}
+//	for(size_t n=0; n<set_names.size(); ++n) {
+//		if(n>0) str << ", ";
+//		str << set_names[n];
+//		}
 	}

core/properties/ImplicitIndex.hh

@@ -9,10 +9,10 @@ namespace cadabra {
 		public:
 			virtual bool parse(Kernel&, keyval_t&) override;
 			virtual std::string name() const override;
-			virtual std::string unnamed_argument() const override { return "name"; };
+			virtual std::string unnamed_argument() const override { return "explicit"; };
 			virtual void latex(std::ostream& str) const override;
-			
-			std::vector<std::string> set_names;
+
+			Ex explicit_form;
 	};
 
 }

frontend/gtkmm/Cadabra.cc

@@ -149,6 +149,9 @@ void Cadabra::on_open(const Gio::Application::type_vec_files& files, const Glib:
 
 bool Cadabra::open_help(const std::string& nm, const std::string& title) 
 	{
+#ifdef DEBUG
+	std::cerr << "Opening help file " << nm << std::endl;
+#endif
 	std::ifstream fl(nm);
 	if(fl) {
 		auto nw = new cadabra::NotebookWindow(this, true);

tests/CMakeLists.txt

@@ -71,6 +71,7 @@ set(RTESTS
   factor
   field_theory
   gamma_paper
+  implicit
   fierz
   selecting
   kaluza_klein

tests/derivative.cdb

@@ -399,8 +399,8 @@ test21()
 
 def test22():
     __cdbkernel__=create_scope()
-    {\alpha,\beta,\gamma}::Indices(spinor).
-    {\theta,\lambda}::ImplicitIndex(spinor).
+    {\alpha,\beta,\gamma}::Indices().
+    {\theta,\lambda}::ImplicitIndex().
     {\alpha,\beta,\gamma,\theta,\lambda}::AntiCommuting.
     D{#}::Derivative.
     obj22:= D_{\alpha}{\theta \lambda};