Assumption Ignored Symbolic PDF

I want to define as the probability density function of the random variable z. is the cumulative density function.

As , if is the probability density function of z.

However, Matlab ignores this assumption (see code below). Why is that the case and how can I fix it?

Thanks for any help :)

% Set symbols
syms x y beta db dc d 
syms z f(z) F(z) % z, its PDF and CDF
syms rd(z) rp(z) % other functions that depend on z

% Assumptions on parameters
assume(x>0) 
assume(y>0) 
assume(beta*x<y) 

assume(beta<1 & beta>0) 

assume(F(z)<=1 & F(z)>=0) % CDF of z

% PDF of z
f(z) == diff(F(z),z) 

ans = 

assume(f(z)>=0) 
assume(int(f(z), z, 0,1)==1) 

Warning: Ignored assumptions on constants.

%*************************************************************************************
Vb = log(x-db) + beta * int((z * log(rp(z)*db)*f(z)), z, 0,1) ...
              + beta * int(((1-z) * log(rd(z)*db)*f(z)), z, 0,1) 

Vb = 

%*************************************************************************************
% differentiate Vb w.r.t. db and set equal to 0
diff_Vb_db = diff(Vb, db) == 0

diff_Vb_db = 

isolate(diff_Vb_db, db)

ans = 

[Paul]

Hi Lea,

I think what you mean is that F(z) = 0 for < 0 and F(z) = 1 for z > 1. But that's not the same as saying that z is restricted to the open interval between 0 and 1.

I wasn't able to figure out what the code is supposed to be doing, so can't be of any more help without more insight into the mathematical problem.

[Lea]

Hi @Paul,

thanks for your answer!

Yes, you are of course right about F(z) = 0 for < 0 and F(z) = 1 for z > 1, sorry about that.

To give you some context: Vb is a utility function I am trying to maximize by choose the optimal value of db (= savings).

How can I ask Matlab to assume

assume(int(f(z), z, 0,1)==1) ?

Because using that information, the derivative of Vb w.r.t. db set equal to 0 simplifies substantially:

diff_Vb_db = diff(Vb, db) == 0

I would like to set the assumption correctly, so that Matlab arrives at this result by itself...

Or is there another (more efficient way) to tell Matlab that f(z) is the PDF of z and F(z) its CDF with F(z) = 0 for < 0 and F(z) = 1 for z > 1 that would allow me to arrive at said result?

Thanks for your help!

[Walter Roberson]

assume(int(f(z), z, 0,1)==1)

You have implicitly told MATLAB that f is a function of a single variable. The definite integral of a function of a single variable is a constant. Constant == constant is either symtrue or symfalse, and assuming() symtrue or symfalse is ignored.

If you had declared f as being a function of more than one variable, then the int() would not be considered a constant.

Answer 1

[Paul]

I'm not aware of a way to put an assumption like that on an integral.

In this problem, it seems like the actual form of f(z) doesn't matter, so I suppose you could just assign f(z) to be any function that satisfies the integral constraint.

Or, these manipulations worked, but I'm not sure they will generalize. I had to play around a bit to get the expressions into the correct form for the subs command to work

syms f(z)
syms db beta x real
assumeAlso(db ~= 0);
assumeAlso(db ~= x);
eqn = beta*int(-f(z)*(z-1)/db,z,0,1) + beta*int(f(z)*z/db,z,0,1) + 1/(db - x) == 0

eqn = 

eqn = simplify(eqn)

eqn = 

eqn = expand(eqn)

eqn = 

eqn = subs(eqn,int(f(z),z,0,1),1)

eqn = 

eqn = beta/db - simplify(solve(eqn,beta)/db) == 0

eqn = 

[Lea]

Thanks, @Paul!

In this problem, the actual form of f(z) infact doesn't matter. How could I "assign f(z) to be any function that satisfies the integral constraint"?

Also thanks a lot for your code example, this is very helpful! However, it would of course be most useful if this substitution was done automatically, but maybe that is beyond the functionality...

[Paul]

syms f(z)
syms db beta x real
assumeAlso(db ~= 0);
assumeAlso(db ~= x);

Here's one option

f(z) = rectangularPulse(0,1,z);
int(f(z),z,0,1)

ans = 

1

eqn = beta*int(-f(z)*(z-1)/db,z,0,1) + beta*int(f(z)*z/db,z,0,1) + 1/(db - x) == 0

eqn = 

Or

f(z) = 2*triangularPulse(0,1,z);
int(f(z),z,0,1)

ans = 

1

eqn = beta*int(-f(z)*(z-1)/db,z,0,1) + beta*int(f(z)*z/db,z,0,1) + 1/(db - x) == 0

eqn = 

[Torsten]

@Paul

Strictly speaking, you only showed the identity for two special functions f(z).

[Paul]

@Torsten

I don't understand what you're getting at. The equation includes a term int(f(z),z,0,1) and the problem statement includes the explicit assumption that that integral is unity. So I was just trying to find a way to simplify the equation. Shouldn't that simplification be the same for any f(z) that satisfiles that assumption?

[Torsten]

I mean that you specified f(z) as

f(z) = rectangularPulse(0,1,z);

in the first case and

f(z) = 2*triangularPulse(0,1,z);

in the second case, and only after this specification, MATLAB was able to simplify "eqn" to

beta/dB + 1/(dB-x) = 0

But this doesn't prove the validity of the equation

beta/dB + 1/(dB-x) = 0

for every function f of which you only know int(f(z),z,0,1) = 1.

Or do I miss something here ?

[Paul]

Is there anything wrong with the derivation in this comment? Or the approach in this comment that let Matlab do all the work to simplify the equation such that int(f(z),z,0,1) could be substituted with its assumed value (1)?

[Torsten]

Is there anything wrong with the derivation in this comment? Or the approach in this comment that let Matlab do all the work to simplify the equation such that int(f(z),z,0,1) could be substituted with its assumed value (1)?

No, sorry. I didn't work through the complete communication, but only read the last post where you worked with two specific functions for f(z).

[Lea]

Hi @Torsten, Hi @Paul,

thanks a lot for your comments!

"Or the approach in this comment that let Matlab do all the work to simplify the equation such that int(f(z),z,0,1) could be substituted with its assumed value (1)?"

This comment achieves what I was trying to do in this specific case. However, it requires that I am aware of this simplifying step myself. I wonder if there is a way to "automize" this, because while it is very easy to see here, I would like to use Matlab to solve more complicated symbolic equations (also involving definite integrals like this one here) for me without me knowing the solution ex ante...

Also many thanks to you, @Walter Roberson !

You stated that I have "implicitly told MATLAB that f is a function of a single variable." and that "The definite integral of a function of a single variable is a constant." -> Here, I want to add the information that the definite integral of this function of a single variable is not a constant, but exactly equal to 1. Can you explain why this information is being ignored and how I can fix that?

Thanks again to all of you!

[Torsten]

@Lea

I think you can never be certain how and if the symbolic toolbox will be able to do exactly what you want it to do. So it is always an iterative process between you and the toolbox until you finally arrive at the expected result. "Automatization" - usual for numerical computations - is only possible for very simple symbolic problems.

[Walter Roberson]

You do not assume() that the definite integral over constant bounds of a function is a particular constant. Instead you take the expression and mapSymType or subs() the constant value in for occurrences of the expression.

[Lea]

@Walter Roberson:

Ah, I see! Thanks for clarifying!

Also thanks again to @Torsten and @Paul; I will now accept this comment as the answer to my question.

[Paul]

@Walter Roberson

I agree that assume doesn't allow for assuming the integral is a particular constant, which is why the original solution posted above used subs for the integral (after some manipulation to get the expression into a form where subs would work). However, I'm wondering if that's the expected behavior based on the linked doc page, which says:

"The toolbox does not support assumptions on symbolic functions. Make assumptions on symbolic variables and expressions instead." (emphasis added)

Let's test this with a simple case

syms x y
symType(x*y)

ans = "expression"

We see that x*y is an expression, so it should be assumable

assume(x*y == 1);
assumptions

ans = 

It is. And the assumption yields the expected result

simplify(x*y)

ans = 

1

Now try with int

syms f(z)
symType(int(f(z),z,0,1))

ans = "expression"

Also an expression. But this expression is not assumable

assume(int(f(z),z,0,1) == 1)

Warning: Ignored assumptions on constants.

assumptions

ans = 

What's the difference between x*y and the int(...) expressions as far as assume() is concerned?