Allow combine() to accept a trace

If we add an optional argument, we can allow the user's operators with a
Trace property to be used whenever traces are generated by combine().
This is not strictly necessary as everyone knows what (A)_{a a} means
but it can add some flexibility in notation and also serve as a warm-up
for transpose.

Also, we should remember that the most sensible use of an indexbracket
is to enclose objects that have the ImplicitIndex property.

Signed-off-by: Connor Behan <[email protected]>

Author: cbehan

core/algorithms/combine.cc

@@ -5,8 +5,8 @@
 
 using namespace cadabra;
 
-combine::combine(const Kernel& k, Ex& e)
-	: Algorithm(k, e)
+combine::combine(const Kernel& k, Ex& e, Ex& t)
+	: Algorithm(k, e), trace_op(t)
 	{
 	}
 
@@ -101,6 +101,7 @@ Algorithm::result_t combine::apply(iterator& it)
 			}
 		}
 
+	std::string trace_start="";
 	std::vector<Ex::iterator>::iterator dums1=dummies.begin(), dums2;
 	dums2=dums1;
 	++dums2;
@@ -151,19 +152,19 @@ Algorithm::result_t combine::apply(iterator& it)
 					bool isbrack=*(sib->name)=="\\indexbracket";
 					if(isbrack && isbrack2) {
 						auto es=compare.equal_subtree(tr.begin(parn2), tr.begin(sib));
-						sign*=compare.can_swap(tr.begin(parn2), tr.begin(sib), es, true);
+						sign*=compare.can_swap_components(tr.begin(parn2), tr.begin(sib), es);
 						}
 					else if(isbrack && !isbrack2) {
 						auto es=compare.equal_subtree(parn2, tr.begin(sib));
-						sign*=compare.can_swap(parn2, tr.begin(sib), es, true);
+						sign*=compare.can_swap_components(parn2, tr.begin(sib), es);
 						}
 					else if(!isbrack && isbrack2) {
 						auto es=compare.equal_subtree(tr.begin(parn2), sib);
-						sign*=compare.can_swap(tr.begin(parn2), sib, es, true);
+						sign*=compare.can_swap_components(tr.begin(parn2), sib, es);
 						}
 					else {
 						auto es=compare.equal_subtree(parn2, sib);
-						sign*=compare.can_swap(parn2, sib, es, true);
+						sign*=compare.can_swap_components(parn2, sib, es);
 						}
 					}
 				if(sib==parn1 || sib==parn2) ++hits;
@@ -235,7 +236,22 @@ Algorithm::result_t combine::apply(iterator& it)
 		if(consecutive) {
 			++dums1;
 			++dums2;
+			if(dums2!=dummies.end() && trace_op.size()>0) {
+				if(*(*dums2)->name==trace_start) {
+					iterator parn=tr.parent(*dums2);
+					iterator trace=tr.insert(parn, str_node(trace_op.begin()->name));
+					sibling_iterator nxt=tr.begin(parn);
+					++nxt;
+					++dums1;
+					++dums2;
+					tr.reparent(trace, tr.begin(parn), nxt);
+					multiply(trace->multiplier, *parn->multiplier);
+					tr.erase(parn);
+					trace_start="";
+					}
+				}
 			}
+		else trace_start=*(*dums1)->name;
 		++dums1;
 		++dums2;
 		}

core/algorithms/combine.hh

@@ -7,14 +7,15 @@ namespace cadabra {
 
 	class combine : public Algorithm {
 		public:
-			combine(const Kernel&, Ex&);
+			combine(const Kernel&, Ex&, Ex&);
 
 			virtual bool     can_apply(iterator) override;
 			virtual result_t apply(iterator&) override;
 
 		private:
 			typedef std::map<nset_t::iterator, iterator> indexlocmap_t;
 
+			Ex trace_op;
 			indexlocmap_t iloc;
 		};
 

core/pythoncdb/py_algorithms.cc

@@ -81,7 +81,6 @@ namespace cadabra {
 		def_algo<collect_components>(m, "collect_components", true, false, 0);
 		def_algo<collect_factors>(m, "collect_factors", true, false, 0);
 		def_algo<collect_terms>(m, "collect_terms", true, false, 0);
-		def_algo<combine>(m, "combine", true, false, 0);
 		def_algo<decompose_product>(m, "decompose_product", true, false, 0);
 		def_algo<distribute>(m, "distribute", true, false, 0);
 		def_algo<eliminate_kronecker>(m, "eliminate_kronecker", true, false, 0);
@@ -100,9 +99,10 @@ namespace cadabra {
 		def_algo<sort_sum>(m, "sort_sum", true, false, 0);
 		def_algo<tabdimension>(m, "tab_dimension", true, false, 0);
 		def_algo<young_project_product>(m, "young_project_product", true, false, 0);
-		def_algo<drop_weight, Ex>(m, "drop_weight", false, false, 0, py::arg("condition") = Ex{});
+		def_algo<combine, Ex>(m, "combine", true, false, 0, py::arg("trace_op") = Ex{});
 		def_algo<complete, Ex>(m, "complete", false, false, 0, py::arg("add"));
 		def_algo<decompose, Ex>(m, "decompose", false, false, 0, py::arg("basis"));
+		def_algo<drop_weight, Ex>(m, "drop_weight", false, false, 0, py::arg("condition") = Ex{});
 		def_algo<eliminate_metric, Ex>(m, "eliminate_metric", true, false, 0, py::arg("preferred") = Ex{});
 		def_algo<eliminate_vielbein, Ex>(m, "eliminate_vielbein", true, false, 0, py::arg("preferred") = Ex{});		
 		def_algo<keep_weight, Ex>(m, "keep_weight", false, false, 0, py::arg("condition"));

tests/implicit.cdb

@@ -83,16 +83,28 @@ test06()
 def test07():
     __cdbkernel__=create_scope()
     {a,b}::Indices(vector);
-    {A,B}::AntiCommuting;
+    Tr{#}::Trace(indices=vector);
     ex:=(A)_{a b} (B)_{b a};
-    combine(_)
-    tst:= (-B A)_{b b} - @(ex);
+    combine(_, trace_op=$Tr$)
+    tst:= Tr( B A ) - @(ex);
     assert(tst==0)
     print("Test 07 passed")
 
 test07()
 
 def test08():
+    __cdbkernel__=create_scope()
+    {a,b}::Indices(vector);
+    {A,B}::AntiCommuting;
+    ex:=(A)_{a b} (B)_{b a};
+    combine(_)
+    tst:= (-B A)_{b b} - @(ex);
+    assert(tst==0)
+    print("Test 08 passed")
+
+test08()
+
+def test09():
     __cdbkernel__=create_scope()
     {m,n}::Indices(vector);
     {a,b,c}::Indices(spinor, position=fixed);
@@ -102,33 +114,33 @@ def test08():
     expand(_)
     tst:= (\Gamma^{m})^{a}_{b} (\Gamma^{n})^{b}_{c} - @(ex);
     assert(tst==0)
-    print("Test 08 passed")
+    print("Test 09 passed")
 
-test08()
+test09()
 
-def test09():
+def test10():
     __cdbkernel__=create_scope()
     {a,b}::Indices(vector);
     ex:=(u)_{a} (M)^{a b} (v)_{b};
     combine(_)
     tst:= \indexbracket(u M v) - @(ex);
     assert(tst==0)
-    print("Test 09 passed")
+    print("Test 10 passed")
 
-test09()
+test10()
 
-def test10():
+def test11():
     __cdbkernel__=create_scope()
     {a,b,c}::Indices(vector);
     ex:=(B)_{b c} (A)_{a b};
     combine(_);
     tst:= (A B)_{a c} - @(ex);
     assert(tst==0)
-    print("Test 10 passed")
+    print("Test 11 passed")
 
-test10()
+test11()
 
-def test11():
+def test12():
     __cdbkernel__=create_scope()
     {a,b}::Indices(vector);
     Tr{#}::Trace(indices=vector);
@@ -140,11 +152,11 @@ def test11():
     sort_product(_);
     tst:= -C D Tr( A B ) - @(ex);
     assert(tst==0)
-    print("Test 11 passed")
+    print("Test 12 passed")
 
-test11()
+test12()
 
-def test12():
+def test13():
     __cdbkernel__=create_scope()
     {a,b}::Indices(vector);
     Tr{#}::Trace(indices=vector);
@@ -155,18 +167,18 @@ def test12():
     sort_product(_);
     tst:= Tr( -A B ) - @(ex);
     assert(tst==0)
-    print("Test 12 passed")
+    print("Test 13 passed")
 
-test12()
+test13()
 
-def test13():
+def test14():
     __cdbkernel__=create_scope()
     {A,B,C}::ImplicitIndex;
     ex:=(B A C)_{a a};
     sort_product(_);
     tst:= (A C B)_{a a} - @(ex);
     assert(tst==0)
-    print("Test 13 passed")
+    print("Test 14 passed")
 
-test13()
+test14()