Merge branch 'fix/wedgewedge'

Author: kpeeters

core/Cleanup.cc

@@ -3,6 +3,7 @@
 #include "Functional.hh"
 #include "Algorithm.hh"
 #include "algorithms/collect_terms.hh"
+#include "properties/SelfAntiCommuting.hh"
 #include "properties/Diagonal.hh"
 #include "properties/ExteriorDerivative.hh"
 #include "properties/KroneckerDelta.hh"
@@ -30,7 +31,7 @@ void cleanup_dispatch(const Kernel& kernel, Ex& tr, Ex::iterator& it)
 			break;
 			}
 		// std::cerr << "zero " << changed << std::endl;
-		if(*it->name=="\\prod")  res = cleanup_productlike(kernel, tr, it);
+		if(*it->name=="\\prod" || *it->name=="\\wedge")  res = cleanup_productlike(kernel, tr, it);
 		changed = changed || res;
 		// std::cerr << "product " << changed << std::endl;
 		if(*it->name=="\\sum")   res = cleanup_sumlike(kernel, tr, it);
@@ -98,12 +99,13 @@ bool cleanup_productlike(const Kernel& k, Ex&tr, Ex::iterator& it)
 	{
 	bool ret=false;
 
-	assert(*it->name=="\\prod");
+	assert(*it->name=="\\prod" || *it->name=="\\wedge");
+	std::string nm = *it->name;
 
 	// Flatten prod children inside this prod node.
 	auto sib=tr.begin(it);
 	while(sib!=tr.end(it)) {
-		if(*sib->name=="\\prod") {
+		if(*sib->name==nm) {
 			multiply(it->multiplier, *sib->multiplier);
 			tr.flatten(sib); 
 			sib=tr.erase(sib);
@@ -136,7 +138,44 @@ bool cleanup_productlike(const Kernel& k, Ex&tr, Ex::iterator& it)
 		multiply(it->multiplier, mult);
 		}
 
-	// Handle edge cases where the product should collapse to a single node,
+	// Turn products with two adjacent identical anti-commuting siblings to zero.
+	if(nm=="\\prod") {
+		auto s1=tr.begin(it);
+		auto s2=s1;
+		++s2;
+		while(s2!=tr.end(it)) {
+			auto ac = k.properties.get<SelfAntiCommuting>(s1);
+			if(ac) {
+				if(subtree_compare(0, s1, s2)==0) {
+					tr.erase_children(it);
+					zero(it->multiplier);
+					ret=true;
+					break;
+					}
+				}
+			++s2;
+			++s1;
+			}
+		}
+
+	// Turn wedge products containing two identical siblings to zero.
+	if(nm=="\\wedge") {
+		auto s1=tr.begin(it);
+		auto s2=s1;
+		++s2;
+		while(s2!=tr.end(it)) {
+			if(subtree_compare(0, s1, s2)==0) {
+				tr.erase_children(it);
+				zero(it->multiplier);
+				ret=true;				
+				break;
+				}
+			++s2;
+			++s1;
+			}
+		}
+
+   // Handle edge cases where the product should collapse to a single node,
 	// e.g. when we have just a single factor, or when the product vanishes.
 
 	if(tr.number_of_children(it)==1) { // i.e. from '3*4*7*a*9'

core/DisplayTeX.cc

@@ -59,7 +59,7 @@ bool DisplayTeX::needs_brackets(Ex::iterator it)
 	if(parent=="\\pow" && (child=="\\prod" || child=="\\sum" || der)) return  true;
 
 
-	if(*tree.parent(it)->name=="\\prod" || *tree.parent(it)->name=="\\frac" || *tree.parent(it)->name=="\\pow") {
+	if(parent=="\\prod" || parent=="\\frac" || parent=="\\pow" || parent=="\\wedge") {
 		if(*tree.parent(it)->name!="\\frac" && *it->name=="\\sum") return true;
 //		if(*tree.parent(it)->name=="\\pow" && (*it->multiplier<0 || (*it->multiplier!=1 && *it->name!="1")) ) return true;
 		}

core/PythonCdb.cc

@@ -808,7 +808,7 @@ void inject_defaults(Kernel *k)
 	k->inject_property(new IndexInherit(),       make_Ex_from_string("\\frac{#}",false), 0);
 	k->inject_property(new DependsInherit(),     make_Ex_from_string("\\frac{#}",false), 0);
 
-//	k->inject_property(new Distributable(),      make_Ex_from_string("\\wedge{#}",false), 0);
+	k->inject_property(new Distributable(),      make_Ex_from_string("\\wedge{#}",false), 0);
 	k->inject_property(new IndexInherit(),       make_Ex_from_string("\\wedge{#}",false), 0);
 //	k->inject_property(new CommutingAsProduct(), make_Ex_from_string("\\prod{#}",false), 0);
 	k->inject_property(new DependsInherit(),     make_Ex_from_string("\\wedge{#}",false), 0);

core/algorithms/distribute.cc

@@ -100,6 +100,7 @@ Algorithm::result_t distribute::apply(iterator& prod)
 		}
 	if(rep.number_of_children(top)==1) { // nothing happened, no sum was present
 //		prod->fl.mark=0; // handled
+		// std::cerr << "only one for " << Ex(prod) << std::endl;		
 		return result_t::l_no_action;
 		}
 

core/algorithms/factor_out.cc

@@ -115,9 +115,11 @@ Algorithm::result_t factor_out::apply(iterator& it)
 			// its product sorted), we first sort the collector product.
 
 			sort_product sp(kernel, collector);
+			sp.dont_cleanup(); // otherwise single-factor products will get stripped of the \prod wrapper.
 			auto coltop=collector.begin();
-			if(sp.can_apply(coltop))
+			if(sp.can_apply(coltop)) {
 				sp.apply(coltop);
+				}
 			multiply(prod->multiplier, *coltop->multiplier);
 			one(coltop->multiplier);
 

core/algorithms/sort_product.cc

@@ -1,17 +1,23 @@
 
+#include "Cleanup.hh"
 #include "algorithms/sort_product.hh"
 
 using namespace cadabra;
 
 sort_product::sort_product(const Kernel&k, Ex& tr)
-	: Algorithm(k, tr), ignore_numbers_(false)
+	: Algorithm(k, tr), ignore_numbers_(false), cleanup(true)
 	{
 //	if(has_argument("IgnoreNumbers")) {
 //		txtout << "ignoring numbers" << std::endl;
 //		ignore_numbers_=true;
 //		}
 	}
 
+void sort_product::dont_cleanup()
+	{
+	cleanup=false;
+	}
+
 bool sort_product::can_apply(iterator st) 
 	{
 	if(*st->name=="\\prod" || *st->name=="\\dot" || *st->name=="\\wedge") return true;
@@ -62,5 +68,8 @@ Algorithm::result_t sort_product::apply(iterator& st)
 			}
 		}
 
+	if(cleanup)
+		cleanup_dispatch(kernel, tr, st);
+	
 	return ret;
 	}

core/algorithms/sort_product.hh

@@ -11,9 +11,12 @@ namespace cadabra {
 
 			virtual bool     can_apply(iterator);
 			virtual result_t apply(iterator&);
+
+			void dont_cleanup();
 
 		private:
 			bool ignore_numbers_;
+			bool cleanup;
 	};
 
 }

core/properties/AntiCommuting.cnb

@@ -1,14 +1,11 @@
-
 {
 	"cells" : 
 	[
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "latex",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "client",
 					"cell_type" : "latex_view",
@@ -18,25 +15,21 @@
 			"hidden" : true,
 			"source" : "\\property{AntiCommuting}{Make objects anti-commuting.}\n\nMakes components anti-commuting, for example"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "input",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
-					"source" : "\\begin{dmath*}{}\\text{Attached property AntiCommuting to~}(A, B).\\end{dmath*}"
+					"source" : "\\begin{dmath*}{}\\text{Attached property AntiCommuting to~}\\left[A,~\\discretionary{}{}{} B\\right].\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
 					"source" : "\\begin{dmath*}{}B A\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
@@ -45,13 +38,11 @@
 			],
 			"source" : "{A,B}::AntiCommuting;\nex:=B A;\nsort_product(_);"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "latex",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "client",
 					"cell_type" : "latex_view",
@@ -61,19 +52,16 @@
 			"hidden" : true,
 			"source" : "It also works for objects with indices:"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "input",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
 					"source" : "\\begin{dmath*}{}\\psi_{m} \\chi \\psi_{n}\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
@@ -82,13 +70,11 @@
 			],
 			"source" : "{\\psi_{m}, \\chi}::AntiCommuting.\nex:= \\psi_{m} \\chi \\psi_{n};\nsort_product(_);"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "latex",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "client",
 					"cell_type" : "latex_view",
@@ -98,13 +84,11 @@
 			"hidden" : true,
 			"source" : "If you want a pattern like \\verb|\\psi_{m}| to anti-commute with\nitself, you should use the \\prop{SelfAntiCommuting} property instead."
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "latex",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "client",
 					"cell_type" : "latex_view",
@@ -114,59 +98,50 @@
 			"hidden" : true,
 			"source" : "You can think about the difference\nbetween \\prop{SelfAntiCommuting} and \\prop{AntiCommuting} in\nthe following way. If \\verb|A_{m n}| is \\prop{SelfAntiCommuting}, it\nmeans that for each value of the indices the expression \\verb|A_{m n}|\nis an operator which anti-commutes with the operator for any other\nvalue of the indices. The matrix~$A$ is thus a matrix of\noperator-valued components which mutually anti-commute. On the other\nhand, if \\verb|A| and\n \\verb|B| are declared to\nbe \\prop{AntiCommuting}, then these can be viewed as two matrices of\ncommuting components, whose matrix product satisfies~$A B = - B A$."
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "latex",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "client",
 					"cell_type" : "latex_view",
-					"source" : "If you attach the \\prop|AntiCommuting| property to an object\nwith an \\prop{ImplicitIndex} property, the commutation property does\nnot refer to the object as a whole, but rather to its components. The\nlogic behind that becomes clear when considering e.g.~spinor bilinears,"
+					"source" : "If you attach the \\prop{AntiCommuting} property to an object\nwith an \\prop{ImplicitIndex} property, the commutation property does\nnot refer to the object as a whole, but rather to its components. The\nlogic behind that becomes clear when considering e.g.~spinor bilinears,"
 				}
 			],
 			"hidden" : true,
-			"source" : "If you attach the \\prop|AntiCommuting| property to an object\nwith an \\prop{ImplicitIndex} property, the commutation property does\nnot refer to the object as a whole, but rather to its components. The\nlogic behind that becomes clear when considering e.g.~spinor bilinears,"
+			"source" : "If you attach the \\prop{AntiCommuting} property to an object\nwith an \\prop{ImplicitIndex} property, the commutation property does\nnot refer to the object as a whole, but rather to its components. The\nlogic behind that becomes clear when considering e.g.~spinor bilinears,"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "input",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
-					"source" : "\\begin{dmath*}{}\\text{Attached property Spinor to~}(\\chi, \\psi).\\end{dmath*}"
+					"source" : "\\begin{dmath*}{}\\text{Attached property Spinor to~}\\left[\\chi,~\\discretionary{}{}{} \\psi\\right].\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
-					"source" : "\\begin{dmath*}{}\\text{Attached property AntiCommuting to~}(\\chi, \\psi).\\end{dmath*}"
+					"source" : "\\begin{dmath*}{}\\text{Attached property AntiCommuting to~}\\left[\\chi,~\\discretionary{}{}{} \\psi\\right].\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
 					"source" : "\\begin{dmath*}{}\\text{Attached property DiracBar to~}\\bar{\\#}.\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
-					"source" : "\\begin{dmath*}{}\\text{Attached property GammaMatrix to~}\\Gamma(\\#).\\end{dmath*}"
+					"source" : "\\begin{dmath*}{}\\text{Attached property GammaMatrix to~}\\Gamma\\left(\\#\\right).\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
-					"source" : "\\begin{dmath*}{}\\text{Attached property SortOrder to~}(\\chi, \\psi).\\end{dmath*}"
+					"source" : "\\begin{dmath*}{}\\text{Attached property SortOrder to~}\\left[\\chi,~\\discretionary{}{}{} \\psi\\right].\\end{dmath*}"
 				},
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
@@ -175,13 +150,11 @@
 			],
 			"source" : "{\\chi, \\psi}::Spinor(dimension=10, type=MajoranaWeyl);\n{\\chi, \\psi}::AntiCommuting;\n\\bar{#}::DiracBar;\n\\Gamma{#}::GammaMatrix;\n{\\chi, \\psi}::SortOrder;\nex:=\\bar{\\psi} \\Gamma_{m n p} \\chi;"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "input",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "server",
 					"cell_type" : "latex_view",
@@ -190,28 +163,24 @@
 			],
 			"source" : "sort_product(_);"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "input",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "server",
-					"cell_type" : "error",
-					"source" : "{\\color{red}{\\begin{verbatim}Traceback (most recent call last):\n  File \"<string>\", line 1, in <module>\nNameError: name 'sort_spinors' is not defined\n\\end{verbatim}}}"
+					"cell_type" : "latex_view",
+					"source" : "\\begin{dmath*}{}\\bar{\\chi} \\Gamma_{m n p} \\psi\\end{dmath*}"
 				}
 			],
 			"source" : "sort_spinors(_);"
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "latex",
 			"cells" : 
 			[
-				
 				{
 					"cell_origin" : "client",
 					"cell_type" : "latex_view",
@@ -221,14 +190,12 @@
 			"hidden" : true,
 			"source" : "Here \\algo{sort_product} did not act because both the spinors and\nthe gamma matrices have the \\prop{ImplicitIndex} property and\nthere are thus no simple rules for their re-ordering. However,\nthe \\algo{sort_spinors} algorithm did act, and took into account\nthe fact that the components of the spinors are anti-commuting."
 		},
-		
 		{
 			"cell_origin" : "client",
 			"cell_type" : "input",
 			"source" : ""
 		}
 	],
 	"description" : "Cadabra JSON notebook format",
-	"version" : 1.0
+	"version" : 1
 }
-