Should the Symbolic Math Toolbox Enforce Assumptions on Assignment?

Consider the following:

syms a real
isAlways(in(a,'real'))

ans = logical
   1

So far, so good. But

a = sym(2)*1i;  % accepted w/o error or warning

Which then leads to some apparent contradictions

isAlways(in(a,'real'))

ans = logical
   0

assumptions

ans = 

Answer 1

[Walter Roberson]

a = sym(2)*1i;  % accepted w/o error or warning

As usual in MATLAB, if you are not using Simulink or MATLAB Coder, then the type of a variable is dynamic, and anything on the right side of an assignment completely overwrites whatever was in the left side of the assignment if it is an unindexed variable.

syms a real

That code is the same as

assignin('caller', 'a', sym('a', 'real'))

executed inside the syms function. So what is being assigned to a is the result of the sym function. MATLAB is not making a symbol-table entry marked as real: MATLAB is assigning an object to the MATLAB variable a

What properties does the object have? It turns out that the object does not store any information about assumptions. Instead, each symbolic object at the MATLAB level has amain properties: the s field which is a MATLAB character vector that is a reference to something that exists inside the Symbolic Engine.

When a + 1 is executed at the MATLAB level, the plus() operator is executed on the symbolic object (because the MATLAB level variable is a symbolic object), and the internal symbolic reference is looked up, and looks something like '_symans_[[32,0,59723]]' and that the 1 is converted to symbolic and has a similar symengine vector, and the two character vectors are passed to the symbolic engine. The symbolic engine looks them up in its internal tables and figures out how to add the two.

When you do

a = sym(2)*1i

then 2 is converted to symbolic number, creating a symbolic object with an s field like '_symans_[[32,0,59724]]' and the 1i is converted to symbolic number, getting something much the same in the s field, and the two _symans values are passed to the symbolic engine which does the appropriate work and returns a new character internal reference character vector that is stored in the s field of a symbolic object. Then, that symbolic object overwrites the MATLAB level object without ever "informing" the existing MATLAB level object, because in MATLAB assignment of an unindexed variable only involves the existing content to the extent that the existing content has its reference count reduced and might possibly be deleted.

When the sym('a','real') part was done, the name 'a' was passed to the symbolic engine to ask for its reference to symbolic engine variable named a and the assumption 'real' and the symbolic engine reference are sent to the symbolic engine, and the symbolic engine marks its internal symbolic engine variable a with the assumption -- the assumption makes no change at the MATLAB level (but might potentially return a different internal reference to be stored.) The MATLAB level has no idea what assumptions are stored against which expressions.

Remember that it is perfectly valid to do

syms a positive
a = a - 1

If you try to interpret this as saying that some kind of absolute variable named a exists at the MATLAB level, and should thereafter have all the properties from the assumptions, then you come to the conclusion that you must be asserting an identity, that a is a value such that a and a - 1 are the same value . You must, in other words, be asserting that a is one of -infinity, +infinity, or NaN ("undefined" as it is known to the symbolic engine.) But with the positivity constraint, you would have to be narrowing that down to say that a must be positive, so the combination would require that a is +infinity . This is, of course, as much incorrect at the MATLAB level as would be the case for saying that

a = 2
a = a - 1

"must" be asserting that a becomes the set of values such that a = 2 and a = 1 both hold -- that just isn't the case !

At the numeric level like that, when the a - 1 is seen in the second line, the current content of a is copied into the expression, and (content of a) - 1 is executed, and the result is stored over top of a .

Just so, symbolically, when you do

syms a positive
a = a - 1

then when you get to the a - 1 part, the current content of a is copied into the expression, with that being a reference to a symbolic engine variable, and then the - 1 part is executed in the symbolic level, and a new symbolic reference is returned, and that symbolic reference overwrites what is stored at the MATLAB level. The new symbolic engine reference returned after the a - 1 is to something that lives in the symbolic engine and has a reference to the symbolic engine variable a and a subtraction, but there is a distinction between the symbolic engine variable a and the MATLAB level variable a

Thus, symbolic variables have exactly the same semantics as numeric variables: content is copied in as needed on the right-hand side, new values are created as needed by the calculation on the right, and the new value overwrites the variable on the left side without the current content of the variable on the left side having anything to say about the matter.

... and as usual, you can force the current variable to be permitted to have a say in the matter by using

a(:) = a - 1

which would go through the subsasgn method associated with the existing a variable and allowing that method to do whatever is meaningful under the circumstances.

Allowing syms a postive to have influence on what happens with a = sym(2)*1i would require a complete change to MATLAB assignment semantics.

And you would have to figure out how to deal with syms a positive; a = a - 1 . For example syms a positive is the same as a = sym('a'); assume(a > 0) so to maintain those constraints in the face of a = a - 1 should the result be that a is still just a name, but that the assumption on a gets updated to (a > 1) and otherwise the -1 part should be discarded ????

[Paul]

Suppose that assignment to a is implemented by first calling assume (a,'clear') and following that with whatever the assignment does now. One could argue that such an approach is actually how Matlab works with built-ins, i.e., the assignment wipes clear all properties of a and starts a new variable from scratch. I realize that the assumptions on a are not stored with the object, but from the user perspective the implementation isn't relevant, only the behavior.

Serious question because I don't program with Matlab classes. Suppose a and b are instances of a user defined class. What happens when executing this command

>> a = b;

Does a automatically get assigned all the properties of b? Or is it something like C++ where the programmer has the option to define an assignment operator and do whatever with the properties of a?

I've been staring at this for a while now and I still can't get my head wrapped around what the assignment means if a hasn't previously been given a value

syms a real positive
a = a - 1

Nevertheless, one possibility as discussed above would be to clear all assumptions on a. Another might be to remove assumptions on a that are provably false due to the assignment. In this case, a would still be assumed to be real, but not positive.

[Walter Roberson]

MATLAB has no customizable assignment operator that works on unindexed variables.

a = b;

increments the reference count for the data descriptor pointed to b, then prepares a new symbol table entry with name a that is a copy of the pointed to the data descriptor.

At some point near here, any existing a value is examined to see if it is a handle class; if it is, and its reference count is 1, then its delete() method is invoked; if it is not handle class and its reference count is 1, then it is deallocated (or at least scheduled for deallocation)

The old symbol table entry a is destroyed and the new symbol table entry for a is created as the data descriptor.

What I am not completely sure of is whether the delete() / deallocation is done before or after the symbol table is updated. If a were handle class with reference count 1, then inside the delete() method, would executing whos a inside the appropriate workspace show the old content or the new content?

What is known is that if you have some expression like

a = f(a)

then the old a is not removed until f(a) is completely finished executing.

[Walter Roberson]

I've been staring at this for a while now and I still can't get my head wrapped around what the assignment means if a hasn't previously been given a value

syms a real positive
a = a - 1

syms a does

a = sym('a')

which is

a assigned a symbolic object with character vector reference to a variable named a that lives in the symbolic engine

Then a - 1 convert the 1 to symbolic, making it a symbolic object with character vector reference to the symbolic number 1 that lives inside the symbolic engine.

Now the character vector reference stored in MATLAB variable a and the character vector reference in the temporary construct that refers to 1 are passed to the symbolic engine along with instructions to subtract the two.

The symbolic engine looks up the first internal reference and finds it is associated with symbolic engine variable a . It looks up the second internal reference an finds it is associated with symbolic engine numeric value 1 . It constructs an expression tree _minus(symbolic engine "a", 1) and assigns that internally to a generated name, and returns the generated name to MATLAB. The result MATLAB receives is the symbolic engine reference.

MATLAB wraps the symbolic engine reference inside a symbolic object, and overwrites the MATLAB variable a with the new symbolic engine reference. MATLAB does not know what the symbolic reference is to, just that it is a symbolic engine reference.

If the user asks to display what is inside the MATLAB variable a at that point, then MATLAB will extract the symbolic engine reference from the MATLAB object, and pass it to the symbolic engine to convert to character vector, returning back a character vector. MATLAB then returns the character vector to the usual formatting routines. The symbolic engine would have converted the expression tree _minus(symbolic engine "a", 1) to the readable 'a + 1' . MATLAB has no idea that there happens to be a match between the a in the character vector it gets back, and the name of the MATLAB level variable

[Paul]

So the "a" on the LHS of the assignment is an instance of class sym in the Matlab workspace and the "a" on the RHS of the assigment is a reference to an object in the symengine. I think I understand that.

What is the use case for the construct

syms a
a = a - 1;

[Walter Roberson]

Let's rewrite very slightly:

syms a b
c = [a b]

c = 

for K = 1 : length(c)
  result(K,1) = myfun(c(K));
end

result

result = 

function a = myfun(a)
a = a - 1;
end

Now, obviously if you pass in b to myfun, then the answer should be b-1: inside myfun, a is acting as a dummy variable that contains whatever value is passed in, and 1 is subtracted from that value and is returned.

Would it make sense to require that people routinely write

function varargout = myfun(varargin)
   varargout{1} = varargin{1} - 1;
end

which has been carefully arranged to avoid using any variable names other than varargin and varargout since they can't know what the names of the symbolic variables being passed in will be, and you propose that there should be a link between symbolic names and MATLAB variable names ?

... did you know that in MATLAB, it is legal to

syms varargin varargout
myfun(varargin)

I am struggling to find a way to code a function for subtraction of 1 that is generalized for all symbolic variable names... it would be necessary to find a valid MATLAB variable name that is not a valid symbolic name, and I am having difficulty coming up with one.

[Walter Roberson]

The current symbolic system is arguably broken

syms w positive
test_assume(w)

general assumptions

ans = 

assumptions about parameter

ans = 

is parameter always positive?

ans = logical
   1

assumptions after syms w
 
ans =
 
Empty sym: 1-by-0
 
is parameter always positive now?

Warning: Unable to prove '0 < w'.

ans = logical
   0

disp('assumptions after returning'); assumptions()

assumptions after returning
 
ans =
 
Empty sym: 1-by-0
 

function test_assume(x)
    disp('general assumptions'); assumptions()
    disp('assumptions about parameter'); assumptions(x)
    disp('is parameter always positive?'); isAlways(x>0)
    syms w
    disp('assumptions after syms w'); assumptions
    disp('is parameter always positive now?'); isAlways(x>0)
end

One could argue that inside the function, w should be a local variable, and therefore changing assumptions about w in the function should not be changing assumptions outside. But assumptions live inside the symbolic engine, and "syms w" talks about the symbolic variable named w that lives in the engine.

This does mean that symbolic variable names that you use inside functions are effectively global, and so you need to be very careful about them. But hardly anyone is... I know it is something I seldom think about myself when I am writing a function.

Answer 2

[Tanmay Das]

Hi,

Symbolic objects and their assumptions are stored separately. When you set an assumption that a is real using

syms a real

you actually create a symbolic object a and the assumption that the object is real. The object is stored in the MATLAB workspace, and the assumption is stored in the symbolic engine. When you replace a symbolic object from the MATLAB workspace using

a = sym(2)*1i;

the assumption that a is real stays in the symbolic engine. If you declare a new symbolic variable a later using sym, it inherits the assumption that a is real instead of getting a default assumption. To clear the assumption, enter

syms a

Please refer to Use Assumptions on Symbolic Variables documention for further information.

However, in() function refers to a variable from the MATLAB workspace and hence has the latest status of its numeric type. So a possible workaround can be the following:

syms a real
isAlways(in(a,'real'))

syms a % to clear the earlier assumption
a = sym(2)*1i;
isAlways(in(a,'real'))
assumptions

[Paul]

@Tanmay Das

Perhaps I'm missing some subtleties in your answer.

Is there a difference between a "symbolic object" and a "symbolic variable"?

What do you mean by "replace a symbolic object"? What exactly is being replaced in that assignment statement?

In any case, I appreciate the explanation on the distinction between the workspace and the symbolic engine.

But my question is really if that's the way it should work? In other words should setitng the value of a variable to an expression delete assumptions on that variable that are provable to be inconsistent with that value?

[John D'Errico]

I learn something new every day. I never really thought about how this works. When I do this:

syms a real positive
whos a

  Name      Size            Bytes  Class    Attributes

  a         1x1                 8  sym                

a is declared as a symbolic variable. But the assumption about a being real valued is not stored in that variable. Instead, you have a list that comprises the set of assumptions we have made. We can interrogate that list via assumptions.

assumptions

ans = 

b = a + 1;
assumptions

ans = 

There is no new assumption created about b, nor is one needed. We only interrogate that set of assumptions when we need to perform some computation that involves a. For example, we might do this:

isreal(sqrt(a))

ans = logical
   1

and MATLAB does know that value is real, because it knows that a is real and positive. As well, we can work with b, which has no assumption attached to it directly, but because a is real, then so must be b.

isreal(b)

ans = logical
   1

But what happens when we give a some explicit value?

a = sym(3 + 1i)

a = 

This has effectively overwritten the unknown symbolic value of a, now with a symbolic constant.

isreal(a)

ans = logical
   0

So a is clearly not real. isreal does not look at the set of assumptions to verify that fact, since a now has an explicit value. The assumption about a still exists, but it is now an orphan assumption. (Probably not a good metaphor there.)

assumptions

ans = 

This essentially replaces a, giving it a new value, but we have not touched that list of assumptions stored separately.

[Paul]

@John D'Errico

FWIW, isreal not a documented function for sym objects. I think we are instead supposed to use

syms a real
isAlways(in(a,'real'))

ans = logical
   1

In addition to the examples shown in my question and your comment, we get some other interesting effects:

syms f
f = a;
a = sym(2)*1i;
isAlways(in(f,'real'))

ans = logical
   1

subs(f)

ans = 

Which I guess is pretty much the same result, just sort of one level removed from the underlying variable.

I also discovered this

clear all
assumptions

 
ans =
 
Empty sym: 1-by-0
 

syms z
z = sym(2)*1i

z = 

assume(z,'real')

Warning: Ignored assumptions on constants.

assumptions

 
ans =
 
Empty sym: 1-by-0
 

Interesting that the assumption can't apply to z if it has a value inconsistent with the assumption, but z can be assigned a value inconsistent with a previously defined assumption.

syms b
z = b

z = 

b

assume(z,'real')
assumptions

ans = 

An assumption on z is translated to an assumption on b, and the assumption on z is nowhere to be found.

[Tanmay Das]

Regarding automatically updating assumptions, MATLAB does not inform when it deletes a MATLAB variable or assigns new values to it. So the assumptions, which are stored within the Symbolic engine, cannot be removed automatically. Furthermore, such a call into Symbolic may lead to slowdown MATLAB execution in general. Also, it is complicated to decide when to raise warning and when not to. Hence, it is recommended to use 'syms' to reinitialize the symbolic variable and reset all the assumptions associated with it.