1 | initial version |

It seems indeed that you hit a bug:

```
sage: var('x')
x
sage: function('y', x)
y(x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
TypeError:
```

When you write `var('x')`

, two actions are done : it returns the symbolic variable (or "symbol") `x`

and it gives to the Python variable (or 'name') `x`

this value. This process of both returning a value and creating a Python variable with the same name is called *variable injection*, and it is a big source of confusion.

When you write `var('x')`

, is is the same : it returns the symbolic function `y(x)`

and it gives to the Python variable (or 'name') `y`

this value.

The problem comes from the fact that `function()`

does not inject its result into the Python variable `y`

correctly:

```
sage: z = function('y', x)
sage: y
y
sage: z
y(x)
sage: type(y)
<class 'sage.symbolic.function_factory.NewSymbolicFunction'>
sage: type(z)
<type 'sage.symbolic.expression.Expression'>
```

As you can see, `function('y', x)`

returned a correct symbolic expression `y(x)`

, while the Python variable `y`

got some weird stuff.

So, the workaround is to overwrite the variable injection:

```
sage: x = var('x')
sage: y = function('y', x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
sage: de
x*e^y(x)*D[0](y)(x) == 2*x^3*e^(2*x) + 2*e^y(x)
```

Thanks for reporting, actually a similar bug was reported as trac ticket 15025.

2 | No.2 Revision |

It seems indeed that you hit a bug:

```
sage: var('x')
x
sage: function('y', x)
y(x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
TypeError:
```

When you write `var('x')`

, two actions are done : it returns the symbolic variable (or "symbol") `x`

and it gives to the Python variable (or 'name') `x`

this value. This process of both returning a value and creating a Python variable with the same name is called *variable injection*, and it is a big source of confusion.

When you write

, is is function('y', x), it is supposed to be the same : it ~~var('x')~~~~returns ~~should return the symbolic function `y(x)`

and it ~~gives ~~give to the Python variable (or 'name') `y`

this value.

The problem comes from the fact that `function()`

does not inject its result into the Python variable `y`

correctly:

```
sage: z = function('y', x)
sage: y
y
sage: z
y(x)
sage: type(y)
<class 'sage.symbolic.function_factory.NewSymbolicFunction'>
sage: type(z)
<type 'sage.symbolic.expression.Expression'>
```

As you can see, `function('y', x)`

returned a correct symbolic expression `y(x)`

, while the Python variable `y`

got some weird stuff.

So, the workaround is to overwrite the variable injection:

```
sage: x = var('x')
sage: y = function('y', x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
sage: de
x*e^y(x)*D[0](y)(x) == 2*x^3*e^(2*x) + 2*e^y(x)
```

Thanks for reporting, actually a similar bug was reported as trac ticket 15025.

3 | No.3 Revision |

It seems indeed that you hit a bug:

```
sage: var('x')
x
sage: function('y', x)
y(x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
TypeError:
```

When you write `var('x')`

, two actions are done : it returns the symbolic variable (or "symbol") `x`

and it gives to the Python variable (or 'name') `x`

this value. This process of both returning a value and creating a Python variable with the same name is called *variable injection*, and it is a big source of confusion.

When you write `function('y', x)`

, it is supposed to be the same : it should return the symbolic function `y(x)`

and it give to the Python variable (or 'name') `y`

this value.

The problem comes from the fact that `function()`

does not inject its result into the Python variable `y`

correctly:

```
sage: z = function('y', x)
sage: y
y
sage: z
y(x)
sage: y == z
False
sage: type(y)
<class 'sage.symbolic.function_factory.NewSymbolicFunction'>
sage: type(z)
<type 'sage.symbolic.expression.Expression'>
```

As you can see, `function('y', x)`

returned a correct symbolic expression `y(x)`

, while the Python variable `y`

got some weird stuff.

So, the workaround is to overwrite the variable injection:

```
sage: x = var('x')
sage: y = function('y', x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
sage: de
x*e^y(x)*D[0](y)(x) == 2*x^3*e^(2*x) + 2*e^y(x)
```

Thanks for reporting, actually a similar bug was reported as trac ticket 15025.

4 | No.4 Revision |

It seems indeed that you hit a bug:

```
sage: var('x')
x
sage: function('y', x)
y(x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
TypeError:
```

`var('x')`

, two actions are done : it returns the symbolic variable (or "symbol") `x`

and it gives to the Python variable (or 'name') `x`

this value. This process of both returning a value and creating a Python variable with the same name is called *variable injection*, and it is a big source of confusion.

When you write `function('y', x)`

, it is supposed to be the same : it should return the symbolic function `y(x)`

and it give to the Python variable (or 'name') `y`

this value.

`function()`

does not inject its result into the Python variable `y`

correctly:

```
sage: z = function('y', x)
sage: y
y
sage: z
y(x)
sage: y == z
False
sage: type(y)
<class 'sage.symbolic.function_factory.NewSymbolicFunction'>
sage: type(z)
<type 'sage.symbolic.expression.Expression'>
```

As you can see, `function('y', x)`

returned a ~~correct ~~*symbolic expression* `y(x)`

, while the Python variable `y`

got some different stuff, more precisely a *function* (with no variable name specifies, somehow similar to `cos`

or `sin`

).

So, a first workaround is to overwrite the variable injection:

```
sage: x = var('x')
sage: y = function('y', x)
sage: de = x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
sage: de
x*e^y(x)*D[0](y)(x) == 2*x^3*e^(2*x) + 2*e^y(x)
```

Another workaround is to consider `y`

as a function (whose variable name is not specified), and use the symbolic expression `y(x)`

~~, while the Python variable ~~`y`

got some weird stuff.

So, the workaround is to overwrite the variable injection: in your equation:

`sage: `~~x = ~~var('x')
sage: ~~y = function('y', x)
~~function('y')
y
sage: de = ~~x*e^y*diff(y,x) == 2*(e^y+x^3*e^(2*x))
~~x*e^y(x)*diff(y(x),x) == 2*(e^y(x)+x^3*e^(2*x))
sage: de
x*e^y(x)*D[0](y)(x) == 2*x^3*e^(2*x) + 2*e^y(x)

Thanks for reporting, actually a similar bug was reported as trac ticket 15025.

Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.