x+im = 0 is linear?

[n0rbed]

julia> @variables x
1-element Vector{Num}:
 x

julia> Symbolics.solve_for(x+im, x)
ERROR: AssertionError: islinear

[ChrisRackauckas]

Indeed it seems like the islinear function is currently not complex-aware so it it throws more safety errors than it should. This function should get expanded. I think solve_for may need some handling for complex as well though.

[Bumblebee00]

Hello everybody, I never contributed to symbolics.jl but I started looking into this issue, what do you think of the solution i came up with?

First of all the method solve_for is deprecated and symbolic_linear_solve should be used. This function uses the function linear_expansion to separate a linear expression of the type ax + b into a and b.

"""
    (a, b, islinear) = linear_expansion(t, x)

When `islinear`, return `a` and `b` such that `a * x + b == t`.
"""
function linear_expansion(t, x)
    ...code...

This function works in a recursive way on all the expression tree, and based on the operator of expression tit behaves differently. I noticed that when t contained a complex number im the operator is always the complex number constructor Complex{Real}.

So for example x + 2*im results in Complex{Real} with arguments Any[x, 2]
and im*x+im is factorized in im*(2 + 3x) and results in Complex{Real} of with arguments Any[0, 2 + 3x]

So i added in the operators elif check the following section:

    elseif op === Complex{Real}
        # x+2im is interpreted as Complex{Real}(x, 2)
        real_part, im_part = arguments(t)
        a_real, b_real, islinear_real = linear_expansion(real_part, x, depth=depth+1)
        a_im, b_im, islinear_im = linear_expansion(im_part, x, depth=depth+1)
        return (a_real + a_im * im, b_real + b_im * im, islinear_real && islinear_im)

that does the linearity check on the real and imaginary part separately, and then combines them.

With this addition it works for the following types of expressions:

julia> @variables x y
2-element Vector{Num}:
 x
 y

julia> symbolic_linear_solve(2x-3im,x)
1.5im

julia> symbolic_linear_solve(x*im-y,x)
(0 + 1im)*y

julia> symbolic_linear_solve(x-im+1,x)
-1.0 + im

julia> symbolic_linear_solve(im*x-im+1,x)
1.0 + im

while for these two:

julia> symbolic_linear_solve(x-y*im,x)
-real((0 - 1im)*y) - im*imag((0 - 1im)*y)

julia> symbolic_linear_solve(im*x-y*im,x)
-imag((0 - 1im)*y) + im*real((0 - 1im)*y)

it gives really complicated expression that are technically true but are not printed plainly (y*im for the first and -y for the second)

If this looks good to you I can make a pull request. Also please suggest me other ways to test this.

[n0rbed]

Hi @Bumblebee00

First of all the method solve_for is deprecated and symbolic_linear_solve should be used. This function uses the function linear_expansion to separate a linear expression of the type ax + b into a and b.

symbolic_linear_solve is just a rename for the old solve_for. Can you open a WIP PR? I'd like to see all the changes, in any case you should definitely try out the tests already written for symbolic_linear_solve and see if they fail.

[Bumblebee00]

Sure here it is: #1492

Sure, now i foud the test for solve_for and I will check them