dharr

Dr. David Harrington

8270 Reputation

22 Badges

20 years, 355 days
University of Victoria
Professor or university staff
Victoria, British Columbia, Canada

Social Networks and Content at Maplesoft.com

Maple Application Center
I am a retired professor of chemistry at the University of Victoria, BC, Canada. My research areas are electrochemistry and surface science. I have been a user of Maple since about 1990.

MaplePrimes Activity


These are answers submitted by dharr

In general if you don't want a formula, use add, not Sum or sum. You have sums 5 deep, so it will take some time. I get the answer in 2 minutes on my machine using add.

add.mw

Applying simplify to the output of EulerLagrange solves the apparent singularity problem - odeplot can now plot the solutions. However x is not changing with time so something is wrong with the physics.

Rolling_circle.mw

As far as I know, that can't be done directly with plot structures, as you surmised. You can convert to images and then manipulate as required with the ImageTools package (but maybe you figured this out already, because you did produce such an image).

restart

with(ImageTools)

Main plot

p1 := plot(sin(x), size = [900, 900]); p1img := convert(p1, Image)

Inset plot

p2 := plot(sin(x), view = [0 .. Pi, .5 .. 1], size = [270, 270], axes = boxed); p2img := convert(p2, Image)

pboth := SetSubImage(p1img, p2img, 20, 620); Embed(pboth)


Download plots.mw

Maple can find a solution to your system if given a hint. This may not be the set of solutions you are looking for. In the paper it looks like u is replaced by f,g and phi (eq 6), but you have u and f and g. So it is hard to understand the relationship of your worksheet to the paper; perhaps yoou can explain further about what you have done to get to this point. Or parhaps you like this solution.

restart

with(PDEtools); with(plots)

alias(u = u(x, y, t), f = f(x, y, t), g = g(x, y, t), q = q(x, y, t))

u, f, g, q

eq1 := 24*g*(diff(q, y))*(diff(q, x))^3-12*(diff(q, y))*(diff(q, x))^2*g^2 = 0

eq2 := 60*g*sigma*(diff(q, y))*(diff(q, x))^3-30*sigma*(diff(q, y))*(diff(q, x))^2*g^2+18*(diff(g, x))*(diff(q, y))*(diff(q, x))^2-15*(diff(q, y))*(diff(q, x))*(diff(g, x))*g+18*g*(diff(q, y))*(diff(q, x))*(diff(q, x, x))-3*(diff(q, y))*g^2*(diff(q, x, x))+6*(diff(g, y))*(diff(q, x))^3+18*g*(diff(q, x))^2*(diff(q, y, x))-9*(diff(g, y))*g*(diff(q, x))^2-3*g^2*(diff(q, x))*(diff(q, y, x)) = 0

eq3 := -6*sigma*(diff(q, x))*(diff(q, y, x))*g^2+50*g*sigma^2*(diff(q, y))*(diff(q, x))^3-24*sigma^2*(diff(q, y))*(diff(q, x))^2*g^2+36*(diff(g, x))*sigma*(diff(q, y))*(diff(q, x))^2-15*(diff(q, x))^2*sigma*(diff(g, y))*g-6*(diff(f, x))*(diff(q, y))*(diff(q, x))*g-6*sigma*(diff(q, y))*(diff(q, x, x))*g^2+36*g*sigma*(diff(q, x))^2*(diff(q, y, x))-3*(diff(q, y))*(diff(g, x))^2+6*(diff(g, y, x))*(diff(q, x))^2-9*(diff(g, y))*(diff(g, x))*(diff(q, x))+6*(diff(g, x))*(diff(q, y))*(diff(q, x, x))+2*g*(diff(q, y))*(diff(q, x, x, x))-6*(diff(f, y))*(diff(q, x))^2*g+2*g*(diff(q, y))*(diff(q, t))-3*(diff(q, x, x))*(diff(g, y))*g-3*g*(diff(q, x))*(diff(g, y, x))+6*(diff(q, y))*(diff(g, x, x))*(diff(q, x))+12*(diff(g, y))*sigma*(diff(q, x))^3+12*(diff(q, x))*(diff(g, x))*(diff(q, y, x))+6*(diff(g, y))*(diff(q, x))*(diff(q, x, x))-3*(diff(q, y, x))*(diff(g, x))*g+6*g*(diff(q, y, x))*(diff(q, x, x))-3*(diff(q, y))*(diff(g, x, x))*g+6*(diff(q, x))*g*(diff(q, y, x, x))+36*g*sigma*(diff(q, y))*(diff(q, x))*(diff(q, x, x))-27*sigma*(diff(q, y))*(diff(q, x))*(diff(g, x))*g = 0

eq4 := 9*(diff(g, y, x))*sigma*(diff(q, x))^2+7*(diff(g, y))*sigma^2*(diff(q, x))^3-3*sigma^2*(diff(q, y))*(diff(q, x, x))*g^2+21*g*sigma^2*(diff(q, x))^2*(diff(q, y, x))-3*sigma^2*(diff(q, x))*(diff(q, y, x))*g^2+9*sigma*(diff(q, y))*(diff(g, x, x))*(diff(q, x))-3*sigma*(diff(q, y))*(diff(g, x, x))*g+9*(diff(g, x))*sigma*(diff(q, y))*(diff(q, x, x))+3*g*sigma*(diff(q, y))*(diff(q, x, x, x))+18*sigma*(diff(q, x))*(diff(g, x))*(diff(q, y, x))-3*sigma*(diff(q, x))*(diff(g, y, x))*g+9*(diff(g, y))*sigma*(diff(q, x))*(diff(q, x, x))+9*sigma*(diff(q, x))*g*(diff(q, y, x, x))-3*sigma*(diff(q, y, x))*(diff(g, x))*g-3*(diff(g, y))*(diff(q, x))*(diff(f, x))-6*(diff(g, x))*(diff(q, x))*(diff(f, y))-3*(diff(q, y))*(diff(g, x))*(diff(f, x))-3*sigma*(diff(q, y))*(diff(g, x))^2-3*(diff(g, y, x))*(diff(g, x))-3*(diff(g, x, x))*(diff(g, y))+g*(diff(q, y, t))+3*(diff(g, y, x))*(diff(q, x, x))+3*(diff(g, x))*(diff(q, y, x, x))+(diff(g, y))*(diff(q, x, x, x))+(diff(q, y, x, x, x))*g+(diff(q, y))*(diff(g, x, x, x))+3*(diff(q, x))*(diff(g, y, x, x))-6*(diff(q, x))^2*sigma^2*(diff(g, y))*g+21*(diff(g, x))*sigma^2*(diff(q, y))*(diff(q, x))^2+15*g*sigma^3*(diff(q, y))*(diff(q, x))^3-6*sigma^3*(diff(q, y))*(diff(q, x))^2*g^2+9*g*sigma*(diff(q, y, x))*(diff(q, x, x))-3*sigma*(diff(q, x, x))*(diff(g, y))*g-9*sigma*(diff(q, x))*(diff(g, x))*(diff(g, y))-9*(diff(f, x))*(diff(q, y))*(diff(q, x))*sigma*g-12*sigma^2*(diff(q, y))*(diff(q, x))*(diff(g, x))*g+21*g*sigma^2*(diff(q, y))*(diff(q, x))*(diff(q, x, x))+(diff(g, y))*(diff(q, t))+(diff(q, y))*(diff(g, t))+3*(diff(g, x, x))*(diff(q, y, x))-9*(diff(f, y))*(diff(q, x))^2*sigma*g+3*g*sigma*(diff(q, y))*(diff(q, t))-3*g*(diff(f, y))*(diff(q, x, x))-3*(diff(q, y))*g*(diff(f, x, x))-3*g*(diff(q, x))*(diff(f, y, x))-3*g*(diff(q, y, x))*(diff(f, x)) = 0

eq5 := 3*(diff(g, x))*sigma^3*(diff(q, y))*(diff(q, x))^2+g*sigma^2*(diff(q, y))*(diff(q, t))+g*sigma^4*(diff(q, y))*(diff(q, x))^3-3*(diff(f, x))*sigma*(diff(q, y))*(diff(g, x))-3*(diff(f, x))*sigma*(diff(q, x))*(diff(g, y))-6*(diff(f, y))*sigma*(diff(q, x))*(diff(g, x))+3*g*sigma^3*(diff(q, x))^2*(diff(q, y, x))+g*sigma^2*(diff(q, y))*(diff(q, x, x, x))-3*(diff(f, x))*sigma*(diff(q, y, x))*g-3*(diff(f, y))*sigma*(diff(q, x, x))*g-3*g*sigma*(diff(q, y))*(diff(f, x, x))-3*sigma*(diff(q, x))*g*(diff(f, y, x))+diff(g, y, t)+3*(diff(g, x))*sigma^2*(diff(q, y))*(diff(q, x, x))+3*(diff(g, y))*sigma^2*(diff(q, x))*(diff(q, x, x))+3*(diff(g, x, x))*sigma^2*(diff(q, y))*(diff(q, x))+6*(diff(g, x))*sigma^2*(diff(q, x))*(diff(q, y, x))-3*(diff(f, x))*(diff(q, y))*(diff(q, x))*sigma^2*g+diff(g, y, x, x, x)+3*(diff(g, y, x))*sigma*(diff(q, x, x))+(diff(g, y))*sigma*(diff(q, x, x, x))+3*(diff(g, x, x))*sigma*(diff(q, y, x))+g*sigma*(diff(q, y, x, x, x))-3*(diff(g, x))*(diff(f, y, x))-3*(diff(g, y))*(diff(f, x, x))+3*(diff(g, y, x))*sigma^2*(diff(q, x))^2+3*(diff(g, y, x, x))*sigma*(diff(q, x))+g*sigma*(diff(q, y, t))+(diff(g, x, x, x))*sigma*(diff(q, y))+3*(diff(g, x))*sigma*(diff(q, y, x, x))+3*g*sigma^3*(diff(q, y))*(diff(q, x))*(diff(q, x, x))+(diff(g, y))*sigma*(diff(q, t))+(diff(g, t))*sigma*(diff(q, y))+(diff(g, y))*sigma^3*(diff(q, x))^3+3*g*sigma^2*(diff(q, x))*(diff(q, y, x, x))-3*(diff(f, y))*(diff(q, x))^2*sigma^2*g+3*g*sigma^2*(diff(q, y, x))*(diff(q, x, x))-3*(diff(f, x))*(diff(g, y, x))-3*(diff(f, y))*(diff(g, x, x)) = 0

eq6 := -3*(diff(f, x))*(diff(f, y, x))-3*(diff(f, y))*(diff(f, x, x))+diff(f, y, x, x, x)+diff(f, y, t) = 0

sys := {eq1, eq2, eq3, eq4, eq5, eq6}

sol := pdsolve(sys, {f, g, q}, HINT = `+`)

{f = f__1(x)+c__1+f__3(t), g = f__4(x)+c__2+f__6(t), q = f__7(x)+c__3+f__9(t)}

pdetest(sol, sys)

{0}

So we can replace the subscripted f functions with arbitrary functions of x (or t), e.g.,

sol1 := eval(sol, {f__1(x) = x^2, f__3(t) = sin(t), f__4(x) = exp(x), f__6(t) = t, f__7(x) = cos(x), f__9(t) = t^3})

{f = x^2+c__1+sin(t), g = exp(x)+c__2+t, q = cos(x)+c__3+t^3}

pdetest(sol1, sys)

{0}

NULL

Download PDEs_system_solution.mw

I played aound with the record form. It is nice to look at (similar to Display(dec,R) on the default output), but hard to extract the pieces. The pieces from the piecewise output can be extracted as follows.

with(RegularChains)

eq_5382 := {(-x-y+1)*p+m*x*y = 0, y*(m*x-m-n+1)+(-x+1)*n-x = 0, (-p+t)*k+p*y-t = 0, (k-x-y)*t-k*p+y = 0, (-x-y+1)*t+(-k+y)*n+s*x = 0, (-x-y+1)*p+m*y^2+x-y = 0, m*x^2+(-m-n+1)*x+(-y+1)*n+t*y-1 = 0, -k*n+s*x = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < n+(t-1)*p, 0 < (m*y-1)*n+(1-p)*(m*x-m+1), 0 < (m*x-m-t+1)*p+m*y*(t-n), 1 < y+x, k < 1, m < 1, s < t, t < 1}

Triangularize with output as piecewise. You need to look at this to see when conditions are Anded. (Could be automated.)

sys := eq_5382; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5382 := RealTriangularize(sys, R, output = piecewise)

[s, k, n, p, m, t, x, y]

polynomial_ring

The sequence of pieces may be extracted by using op. They are condition,solution,condition, solution, ..., otherwise  as in the ?piecewise help page.
The conditions (inequalities), if more than one, are Anded together, and can be separated out by another op

nops(dec_5382); sol := op(dec_5382); sol1conds := op(sol[1]); sol1eqns := sol[2][][]; sol2conds := sol[3]; sol2eqns := sol[4][][]; solotherwise := sol[5]

5

y^3-2*y^2+y < 1, 0 < y-1, 23*y^3-37*y^2+13*y-3 <> 0

s*x-k*n = 0, (p-t)*k+(y+x)*t-y = 0, (x+y-1)*n+(-x*y+y)*m+x-y = 0, (x+y-1)*p-m*y^2-x+y = 0, m*y-1 = 0, t*y^2+x^2+(y-1)*x-y^2 = 0, x^3+(3*y-2)*x^2+(2*y^2-3*y+1)*x-y^3+y^2 = 0, 0 < k, 0 < s, 0 < x, 0 < -2*x^2*y^2-2*x*y^3+2*y^4+x^2*y+3*x*y^2-3*y^3-x*y+y^2, 0 < x^2*y^2+2*x*y^3+y^4-x^2*y-4*x*y^2-3*y^3+2*x*y+3*y^2-y, 0 < -x^2*y-x*y^2+y^3+x*y-y^2, 0 < x+y-1, 0 < 1-k, 0 < t-s, 0 < 1-t

23*y^3-37*y^2+13*y-3 = 0

s*x-k*n = 0, (p-t)*k+(y+x)*t-y = 0, (x+y-1)*n+(-x*y+y)*m+x-y = 0, (x+y-1)*p-m*y^2-x+y = 0, m*y-1 = 0, t*y^2+x^2+(y-1)*x-y^2 = 0, (2377326*y^2-1587000*y+302588)*x^2+(390793*y^2+497766*y+138115)*x-507805*y^2+152032*y-109047 = 0, 23*y^3-37*y^2+13*y-3 = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < 700112222844255556263586865*x*y^2-260269572171898884295316974*x*y-93795749047261033657544191*y^2+73822886321394794237709987*x+34866975665513154551125606*y-9877974587657378842117575, 0 < -26166721441919*x*y^2+9412709182291*x*y+53422638514257*y^2-3387596446782*x-21180373503698*y+6484087812711, 0 < 21236600258115*x*y^2-8079468597142*x*y-3053799376681*y^2+2340822678357*x+1387037467490*y-370794765921, 0 < x+y-1, 0 < 1-k, 0 < 1-m, 0 < t-s, 0 < 1-t

[]

``

NULL

Download Output_of_RegularChains.mw

I agree that the geometry and geom3d packages can be frustrating in the sense that they work differently from the rest of Maple. For some reason, these packages make extensive use of attributes, which are hidden behind the scenes; attributes are rarely used in the rest of Maple. So c1 is actually just a symbol - it doesn't have a value, but its attached attributes can be seen using attributes(c1).

From a practical point of view this means you need to do all your geometry calculations with the commands in the package (or decide to calculate outside the package). In particular, use the draw command to plot objects created in the package, e.g. draw([c1,A,B,C],printtext=true);

It is possible to assign the result of draw to a variable, and then it can be combined with other regular plots with display.

As for Equation vs equation, that is frustrating though clearly outlined on the circle help page.

Well, as is often the case, Maple needs help to go the extra mile. Actually, ThueSolve sends this case to isolve, but without the inequalities.

restart;

isolve({a*b=4,a>=1,b>=1});

Warning, solutions may have been lost

sols:=NumberTheory:-ThueSolve(a*b=4);
goodsols:=select(x->eval((a>=1 and b>=1),x),sols);

[[a = -4, b = -1], [a = -2, b = -2], [a = -1, b = -4], [a = 1, b = 4], [a = 2, b = 2], [a = 4, b = 1]]

[[a = 1, b = 4], [a = 2, b = 2], [a = 4, b = 1]]

isolve(a*b=4);

{a = -4, b = -1}, {a = -2, b = -2}, {a = -1, b = -4}, {a = 1, b = 4}, {a = 2, b = 2}, {a = 4, b = 1}

NULL

Download Thue.mw

My take on it is that the elimination process does not lead to any valid solutions.

restart;

expr :=[a, b, c]^~2 =~ 4*[y*z/((x + y)*(x + z)), z*x/((y + z)*(y + x)), x*y/((z + x)*(z + y))];

[a^2 = 4*y*z/((x+y)*(x+z)), b^2 = 4*z*x/((y+z)*(x+y)), c^2 = 4*x*y/((x+z)*(y+z))]

The following assumes denominators are not zero

expr2:=map(w->numer(normal(lhs(w)-rhs(w))),expr);

[a^2*x^2+a^2*x*y+a^2*x*z+a^2*y*z-4*y*z, b^2*x*y+b^2*x*z+b^2*y^2+b^2*y*z-4*x*z, c^2*x*y+c^2*x*z+c^2*y*z+c^2*z^2-4*x*y]

denoms1:={map(denom@rhs,expr)[]};

{(x+y)*(x+z), (x+z)*(y+z), (y+z)*(x+y)}

Interesting result - probably an error message or null result would be better

eliminate(expr2,{x,y,z});

[{x = 0, y = FAIL, z = 0}, {}]

Let's do it "by hand" - eliminate x between pairs, leaving 2 eqns in y and z. Denominators in expressions for x must be nonzero

e12:=eliminate(expr2[1..2],x);
e23:=eliminate(expr2[2..3],x);
expr3 := e12[2] union e23[2];

[{x = -b^2*y*(y+z)/(b^2*y+b^2*z-4*z)}, {4*y*z*(a^2*b^2*y^2-a^2*b^2*z^2-b^4*y^2-2*b^4*y*z-b^4*z^2+4*a^2*z^2+8*b^2*y*z+8*b^2*z^2-16*z^2)}]

[{x = -c^2*z*(y+z)/(c^2*y+c^2*z-4*y)}, {b^2*c^2*y^3+b^2*c^2*y^2*z-b^2*c^2*y*z^2-b^2*c^2*z^3-4*b^2*y^3-4*b^2*y^2*z+4*c^2*y*z^2+4*c^2*z^3}]

{4*y*z*(a^2*b^2*y^2-a^2*b^2*z^2-b^4*y^2-2*b^4*y*z-b^4*z^2+4*a^2*z^2+8*b^2*y*z+8*b^2*z^2-16*z^2), b^2*c^2*y^3+b^2*c^2*y^2*z-b^2*c^2*y*z^2-b^2*c^2*z^3-4*b^2*y^3-4*b^2*y^2*z+4*c^2*y*z^2+4*c^2*z^3}

denoms2:={denom(rhs(e12[1][])), denom(rhs(e23[1][]))};

{b^2*y+b^2*z-4*z, c^2*y+c^2*z-4*y}

Now eliminate y between the remaining 2 equations - denom has no restrictions on z

e13:=eliminate(expr3,y);

[{y = -z*c^2*(-a^2*b^4*c^2+a^4*b^2+2*a^2*b^4+5*a^2*b^2*c^2+b^6+3*b^4*c^2-4*a^4-12*a^2*b^2-4*a^2*c^2-16*b^4-12*b^2*c^2+16*a^2+48*b^2)/(-a^2*b^4*c^4+a^4*b^2*c^2+2*a^2*b^4*c^2+3*a^2*b^2*c^4+b^6*c^2+3*b^4*c^4-16*b^4*c^2-4*b^2*c^4-16*a^4-16*a^2*b^2-32*a^2*c^2-16*c^4+128*a^2+64*b^2+128*c^2-256)}, {c*z*(b-2)*(b+2)*(a-2)*(a+2)*(-a*b*c+a^2+b^2+c^2-4)*(a*b*c+a^2+b^2+c^2-4)}]

denoms3:=denom(rhs(e13[1][]));

-a^2*b^4*c^4+a^4*b^2*c^2+2*a^2*b^4*c^2+3*a^2*b^2*c^4+b^6*c^2+3*b^4*c^4-16*b^4*c^2-4*b^2*c^4-16*a^4-16*a^2*b^2-32*a^2*c^2-16*c^4+128*a^2+64*b^2+128*c^2-256

eqz:={isolate(e13[2][],z)};

{z = 0}

From which we conclude y=0

eqy:=eval(e13[1],eqz);

{y = 0}

So we have a problem at the eliminate x stage, and with the original equations

eval(denoms2, eqy union eqz);
eval(denoms1, eqy union eqz);

{0}

{0, x^2}

solve(expr,{x,y,z},parametric); # correct

[]

Here the c<>0 solution doesn't solve the original equations (zero denoms). And solve is too lazy to do the c=0 case (default option - see ?solve,parametric

ans := solve(expr2,{x,y,z},parametric);

ans := piecewise(c = 0, %SolveTools[Parametric]({-4*y*x, a^2*x^2+a^2*x*y+a^2*x*z+a^2*y*z-4*y*z, b^2*x*y+b^2*x*z+b^2*y^2+b^2*y*z-4*x*z}, {x, y, z}, {a, b}), c <> 0, [{x = 0, y = 0, z = 0}])

Force it. None of these solve the original equations either.

op(2,ans);
value(%);

%SolveTools[Parametric]({-4*y*x, a^2*x^2+a^2*x*y+a^2*x*z+a^2*y*z-4*y*z, b^2*x*y+b^2*x*z+b^2*y^2+b^2*y*z-4*x*z}, {x, y, z}, {a, b})

piecewise(b = 0, [{x = 0, y = 0, z = z}, {x = 0, y = y, z = 0}], b <> 0, [{x = 0, y = 0, z = z}])

In one step

ans := solve(expr2,{x,y,z},parametric=full);

ans := piecewise(c = 0, piecewise(b = 0, [{x = 0, y = 0, z = z}, {x = 0, y = y, z = 0}], b <> 0, [{x = 0, y = 0, z = z}]), c <> 0, [{x = 0, y = 0, z = 0}])

Same result.

SolveTools:-PolynomialSystem(expr2,[x,y,z]);

{x = 0, y = 0, z = 0}

 

NULL

Download eliminate.mw

Your question is not clear. Is this what you want to do?

restart

Output from solve - the variables we solved for are only on the left of the =.

case1 := {alpha = alpha, beta = gamma, delta = delta, gamma = gamma, k = k, lambda = 0, m = 2*n, mu = mu, n = n, sigma = 32*alpha*mu^2*n^4/a[-1]^2, w = -2*alpha*k^2*n-4*alpha*mu^2*n+delta^2, a[-1] = a[-1], a[0] = 0, a[1] = 0}

To remove the restriction on beta so it is now arbitrary (actually would remove if beta was on the right also)

case2 := remove(has, case1, beta)

{alpha = alpha, delta = delta, gamma = gamma, k = k, lambda = 0, m = 2*n, mu = mu, n = n, sigma = 32*alpha*mu^2*n^4/a[-1]^2, w = -2*alpha*k^2*n-4*alpha*mu^2*n+delta^2, a[-1] = a[-1], a[0] = 0, a[1] = 0}

A little more specific for the left-hand side.

case3 := remove(proc (q) options operator, arrow; has(lhs(q), beta) end proc, case1)

{alpha = alpha, delta = delta, gamma = gamma, k = k, lambda = 0, m = 2*n, mu = mu, n = n, sigma = 32*alpha*mu^2*n^4/a[-1]^2, w = -2*alpha*k^2*n-4*alpha*mu^2*n+delta^2, a[-1] = a[-1], a[0] = 0, a[1] = 0}

NULL

Download removal.mw

Put the plots in an Array to achieve this. Attached is an example. (grid is for the fineness of the points plotted, and insequence is, as you found, for animations.)

grid.mw

I don't know a way that doesn't involve a string. But this is slightly shorter:

cat(``,String(x)[1]);

I think you just want to solve the 3 equations simultaneously - if there is a solution it lies on the line; if no solution it does not

solve({seq(l[i] = P[i], i = 1 .. 3)}, alpha)

2024-12-21_Q_3D_point_lies_on_3D_line.mw

It means complex conjugate, i.e., every i is replaced by -i.

No artificial intelligence used.

We consider an ellipse x^2/a^2+y^2/b^2-1=0 and 2 vertices of this ellipse A(a,0) and B(0,b). We imagine a variable equilateral hyperbola passing through the points O, A and B. This curve meets the ellipse at 2 other points A1 and B1. Show that the line A1B1 passes through a fixed point.

https://www.mapleprimes.com/questions/239553-Variable-Equilateral-Hyperbole-Passing

restart

with(Student:-MultivariateCalculus); with(plots); _local(D)

Define ellipse and an arbitrary hyperbola (B^2-4A*C>0) (see Wikipedia)

ellipse := x^2/a^2+y^2/b^2-1; hyperbola := A*x^2+B*x*y+C*y^2+D*x+E*y+F

x^2/a^2+y^2/b^2-1

A*x^2+B*x*y+C*y^2+D*x+E*y+F

The hyperbola is equilateral when A=-C

hyperbola2 := eval(hyperbola, C = -A)

A*x^2-A*y^2+B*x*y+D*x+E*y+F

Intersection points between ellipse and hyperbola are at O (assume this means the origin), A, B. Use these to eliminate D,E,F

eqO := eval(hyperbola2, {x = 0, y = 0}); eqA := eval(hyperbola2, {x = a, y = 0}); eqB := eval(hyperbola2, {x = 0, y = b})

F

A*a^2+D*a+F

-A*b^2+E*b+F

solve({eqA, eqB, eqO}, {D, E, F}); hyperbola3 := eval(hyperbola2, %)

{D = -A*a, E = A*b, F = 0}

-A*a*x+A*b*y+A*x^2-A*y^2+B*x*y

A1 and B1 are two points on both the ellipse and the hyperbola. The 4 solutions are points B, A, A1, B1; A1 and B1 are complicated expressions in A.B,a,b

ans := sort([solve({ellipse, hyperbola3}, {x, y}, explicit)]); nops(%)

4

A1 := eval([x, y], ans[3]); B1 := eval([x, y], ans[4])

If the assertion is true, then the line A1-B1 intersects at the same point for different {A,B} pairs.

L1 := Line(eval([A1, B1][], {A = A__1, B = B__1})); L2 := Line(eval([A1, B1][], {A = A__2, B = B__2}))

And we indeed find a value independent of A__1, A__2, B__1, B__2

X__0 := GetIntersection(L1, L2)

[-b^2*a/(a^2+b^2), -a^2*b/(a^2+b^2)]

Construct a diagram for two different hyperbolas

params0 := {a = 1.5, b = 1.}; params := `union`(params0, {A = 1., B = 1.}); params2 := `union`(remove(has, params, B), {B = 3.})

{A = 1., B = 1., a = 1.5, b = 1.}

{A = 1., B = 3., a = 1.5, b = 1.}

Red points are O,A,B,X; Black and blue points are A1,B1 for the blue and black hyperbolas

ellipseplot := implicitplot(eval(ellipse, params), x = -1.5 .. 1.5, y = -1 .. 1, color = magenta); hyperbola1plot := implicitplot(eval(hyperbola3, params), x = -2 .. 2, y = -1.5 .. 1.5, color = black); hyperbola2plot := implicitplot(eval(hyperbola3, params2), x = -2 .. 2, y = -1.5 .. 1.5, color = blue); pts := pointplot(eval([[0, 0], [a, 0], [0, b], X__0], params), symbol = solidcircle, color = red, symbolsize = 10); pts1 := pointplot(eval([A1, B1], params), symbol = solidcircle, color = black, symbolsize = 10); pts2 := pointplot(eval([A1, B1], params2), symbol = solidcircle, color = blue, symbolsize = 10); pline1 := plottools:-line(eval([A1, B1][], params), color = black, linestyle = dash); pline2 := plottools:-line(eval([A1, B1][], params2), color = blue, linestyle = dash); t1 := textplot(eval([[A1[], A__1], [B1[], B__1]], params), color = black, align = below); t2 := textplot(eval([[A1[], A__1], [B1[], B__1]], params2), color = blue, align = right); t3 := textplot(eval([[0, 0, O], [X__0[], X], [a, 0, A]], params0), color = red, align = right); t4 := textplot(eval([[0, b, B]], params0), color = red, align = above); display(t1, t2, t3, t4, pline1, pline2, ellipseplot, hyperbola1plot, hyperbola2plot, pts, pts1, pts2, axes = none, scaling = constrained)

NULL

Download Ellipse.mw

I'm not sure exactly what you mean by labelled sets. You can do something like this

ans := sort([solve({x^2 - x + 1}, x)])

sort will sort in a consistent way from session to session, though what exact the order is is nontrivial.

First 8 9 10 11 12 13 14 Last Page 10 of 82