Square roots are simplified to decimals

[omelancon]

The function simplify always evaluates sqrt instead of leaving some forms such as sqrt(2) unchanged.

To Reproduce

Simplify the following:

math.simplify('sqrt(2)')

The result is a ConstantNode with value 1.4142135623730951, but I expected a FunctionNode where the sqrt function was not applied.

When its argument is an exact, it feels like sqrt should only simplify to a constant if the result is an exact integer. This would be akin to divide that simplifies fractions, but does not apply division if the result is not an integer.

[josdejong]

We can discuss how to improve on this. Let's do that in the discussions section.

[josdejong]

Right now, simplify will indeed evaluate functions when possible, also when resulting in a decimal result. There is an option exactFractions than can be useful to output a fraction like 2/5 instead of 0.4, but that is not helpful for irrational numbers.

I can imagine that we built a new option that counts the number of digits after a calcuation, and if that more than a configured maximum, leaves that part of the expression unevaluated. For example abs(-1) is ok to simplify to 1, and 0.2 + 0.01 should be simplified to 0.21, but sqrt(2) should not be simplified to 1.4142135623730951. More complex: 1/3 should not be simplified to 0.3333333333333333, but if it is part of an expression 1/3+2/3, we do want to calculate the end result, so it is not enough to look locally.

[omelancon]

Thanks for you answer! 😃

That sounds like a good start, I tried on a few input and it feels like this would give the expected result. Checking for decimals works well with the fact the root of an integer is always either an irrational or an integer.

math.simplify('(1 + sqrt(3))/ 2') // would not be simplified because no term can be simplified further without introducing decimals
math.simplify('(1 + sqrt(4))/3') // would be simplified to 1 after sqrt(2) is simplified to 2
math.simplify('(1 + sqrt(9))/3') // would be simplified to 4/3 after sqrt(9) is simplified to 3
math.simplify('1/sqrt(2)') // would not be simplified because sqrt(2) would introduce decimals.

Some cases would not be covered, so maybe a rule should attempts to distribute the square root on multiplication and division and keep the result with distribution if that allowed simplification in either operand:

math.simplify('sqrt(1/9)') // should simplify to 1/3
math.simplify('sqrt(4 * x)') // should simplify to 2 sqrt(x)
math.simplify('sqrt(2/3)') // should not distribute because neither sqrt(2) nor sqrt(3) simplifies

Maybe also introduce a case where simplifying to a decimal number is allowed if the argument already contains a constant that exceeds the decimal limit?

math.simplifiy('sqrt(0.1234567)') // should probably simplify anyway

I only spent about ten minutes looking at simplify.js so I am mostly listing examples for now. I don't know how easy that would be to implement.

[josdejong]

Thanks for your inputs!

Anyone interested in improving simplify with some of these ideas? Help would be welcome.

[nickkolok]

The upcoming journey seems to be long, very long...
Looks like we should start with introducing a special atom in simplify rules that corresponds only to integers (no matter to what of them: 'usual' JS ones, BigInts etc). For a constant, we have c1, c2 etc; for integers, let's assume m1, m2 etc.

Then, let us state that some operations on integers are absolutely safe. These are: addition, division, multiplication. Then the corresponding simplification rules are:

safeIntegerSimplification = [
	{ l: "m1+m2",   r: "forceSimplifyConstants(m1+m2)" },
	{ l: "m1-m2",   r: "forceSimplifyConstants(m1-m2)" },
	{ l: "m1*m2",   r: "forceSimplifyConstants(m1*m2)" },
];

function forceSimplifyConstantsInNode(node){
	if(node.fn && node.fn.name === 'forceSimplifyConstants'){
		return math.simplifyConstant(node.args[0]);
	}
	for(let i = 0; node.args && i < node.args.length; i++){
		node.args[i] = forceSimplifyConstantsInNode(node.args[i]);
	}
	return node;
}

Now we can deal with fractions, e.g. {l: 'm1/m2 + m3/m4', r: '(m1*m4 + m3*m2) / (m2*m4)'}

The problem sounds classic and should have been solved somehow - e.g. in Maxima.

[nickkolok]

I did a completely other attempt, my it didn't work for me (it runs forever). Maybe someone can find anything useful in it :)

let mathjsRules = {};
mathjsRules.simplifyCarefully = [
	{ l: 'ce1', r: 'carefullySimplifyConstants(ce1)', repeat: false },
	mathjs_helpers.carefullySimplifyConstantsInNode,
];

let mathjs_helpers = {
	carefullySimplifyConstantsInNode : function(node){
		if(node.fn && node.fn.name === 'carefullySimplifyConstants'){
			let simp = math.simplifyConstant(node.args[0]/*,{exactFractions:true}*/);
			if (simp.toTex().length < 10){
				return simp;
			}
			//Failure!
		}
		for(let i = 0; node.args && i < node.args.length; i++){
			node.args[i] = mathjs_helpers.carefullySimplifyConstantsInNode(node.args[i]);
		}
		return node;
	},
};

let e1 = math.parse('1+2+sqrt(3)+sqrt(4)');
math.simplify(e1).toTex();
math.simplify(e1,mathjsRules.simplifyCarefully, {repeat:false}).toTex();

[josdejong]

Thanks for looking into this @nickkolok!