1 | initial version |

By solving against `Vo`

only, you do as if every other symbols involved in the equations were constants. However, `Vi, Vm, Vx`

are also unknown.

Imagine that the solver would return `[Vo == -A*Vm]`

as a solution, i bet you will not be very happy.

So, what you have to do is to put all unknowns, and let only the constants outside:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vi, Vm, Vx])
[[Vo == (A*R3*r1 + (A*C*R3*r1*s + A*r1)*R2)/(A*R2 - R3), Vi == -((C*R3*r1*s + A*r1 + r1)*R1 + (C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vm == -((C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vx == r1]]
```

Now, as you can see, there is one degree of freedom : `Vx`

can take any value, so Sage added a free parameter `r1`

and gave you all the solutions using this free parameter `r1`

.

Now, i see that you want to solve for `Vo/Vi`

, so let me assume that you want `Vi`

being the free parameter, not `Vx`

.

Hence, the way to do is to solve as if `Vi`

was also a constant:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vm, Vx])
[[Vo == -((A*C*R3*s + A)*R2 + A*R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vm == ((C*R3*s + 1)*R2 + R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vx == -(A*R2 - R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3)]]
```

2 | No.2 Revision |

By solving against `Vo`

only, you do as if every other symbols involved in the equations were constants. However, `Vi, Vm, Vx`

are also unknown.

Imagine that the solver would return `[Vo == -A*Vm]`

as a solution, i bet you will not be very happy.

So, what you have to do is to put all unknowns, and let only the constants outside:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vi, Vm, Vx])
[[Vo == (A*R3*r1 + (A*C*R3*r1*s + A*r1)*R2)/(A*R2 - R3), Vi == -((C*R3*r1*s + A*r1 + r1)*R1 + (C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vm == -((C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vx == r1]]
```

Now, as you can see, there is one degree of freedom : `Vx`

can take any value, so Sage added a free parameter `r1`

and gave you all the solutions using this free parameter `r1`

.

Now, i see in your workaround that you want to solve for `Vo/Vi`

, so let me assume that you want `Vi`

being the free parameter, not `Vx`

.

Hence, the way to do is to solve as if `Vi`

was also a constant:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vm, Vx])
[[Vo == -((A*C*R3*s + A)*R2 + A*R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vm == ((C*R3*s + 1)*R2 + R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vx == -(A*R2 - R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3)]]
```

3 | No.3 Revision |

By solving against `Vo`

only, you do as if every other symbols involved in the equations were constants. However, `Vi, Vm, Vx`

are also unknown.

Imagine that the solver would return `[Vo == -A*Vm]`

as a solution, i bet you will not be very happy.

So, what you have to do is to put all unknowns, and let only the constants outside:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vi, Vm, Vx])
[[Vo == (A*R3*r1 + (A*C*R3*r1*s + A*r1)*R2)/(A*R2 - R3), Vi == -((C*R3*r1*s + A*r1 + r1)*R1 + (C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vm == -((C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vx == r1]]
```

Now, as you can see, there is one degree of freedom : `Vx`

can take any value, so Sage added a free parameter `r1`

and gave you all the solutions using the constants and this free parameter `r1`

.

Now, i see in your workaround that you want to solve for `Vo/Vi`

, so let me assume that you want `Vi`

being the free parameter, not `Vx`

.

Hence, the way to do is to solve as if `Vi`

was also a constant:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vm, Vx])
[[Vo == -((A*C*R3*s + A)*R2 + A*R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vm == ((C*R3*s + 1)*R2 + R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vx == -(A*R2 - R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3)]]
```

4 | No.4 Revision |

`Vo`

only, you do as if every other symbols involved in the equations were constants. However, `Vi, Vm, Vx`

are also unknown.

Imagine that the solver would return `[Vo == -A*Vm]`

as a solution, i bet you will not be very happy.

So, what you have to do is to put all unknowns, and let only the constants outside:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vi, Vm, Vx])
[[Vo == (A*R3*r1 + (A*C*R3*r1*s + A*r1)*R2)/(A*R2 - R3), Vi == -((C*R3*r1*s + A*r1 + r1)*R1 + (C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vm == -((C*R3*r1*s + r1)*R2 + R3*r1)/(A*R2 - R3), Vx == r1]]
```

Now, as you can see, there is one degree of freedom : `Vx`

can take any value, so Sage added a free parameter `r1`

and gave you all the solutions using the constants and this free parameter `r1`

.

Now, i see in your workaround that you want to solve for `Vo/Vi`

, so let me assume that you want `Vi`

being the free parameter, not `Vx`

.

Hence, ~~the way to do is to ~~you can solve as if `Vi`

~~was ~~is also a constant:

```
sage: solve([eq_at_Vm, eq_at_Vx, eq_at_Vo],[Vo, Vm, Vx])
[[Vo == -((A*C*R3*s + A)*R2 + A*R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vm == ((C*R3*s + 1)*R2 + R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3), Vx == -(A*R2 - R3)*Vi/((C*R3*s + A + 1)*R1 + (C*R3*s + 1)*R2 + R3)]]
```

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.