It is easy to check the truth of the identity   

So we get

restart;
is((2*x^2022+1)/(x^2023+x)=1/x+x^2021/(x^2022+1));
int(1/x+x^2021/(x^2022+1), x);

You can use the technique of stitching sequential animations from the post
https://mapleprimes.com/posts/207840-Combinations-Of-Multiple-Animations

restart;
Frame:=proc(t,Range,Color)
local SinArc, p, l1, l2, l3, l4, l, Circle;
uses plots, plottools;
SinArc:=plot(sin(x),x=Range[1]..t, color=Color, thickness=2);
p:=pointplot([[-2,0],[-2,sin(t)],[cos(t)-2,sin(t)],[t,sin(t)]], symbolsize=11, symbol=solidcircle);
l:=line([-2,-1.4],[-2,1.4], thickness=0);
l1:=line([-2,0],[-2,sin(t)], color=Color, thickness=2);
l2:=line([-2,0],[cos(t)-2,sin(t)]);
l3:=line([cos(t)-2,sin(t)],[t,sin(t)]);
l4:=line([-2,sin(t)],[cos(t)-2,sin(t)]);
Circle:=circle([-2,0], color=Color, thickness=2);
display(SinArc,p,l,l1,l2,l3,l4,Circle, scaling=constrained);
end proc:

Example of use:

with(plots):
A:=animate(Frame,[t,[0,2*Pi],red], t=0..2*Pi, frames=90, size=[800,200], view=-1.4..1.4):
B:=animate(Frame,[t,[2*Pi,4*Pi],blue], t=2*Pi..4*Pi, frames=90, size=[800,200], view=-1.4..1.4):
C:=animate(Frame,[t,[4*Pi,6*Pi],green], t=4*Pi..6*Pi, frames=90, size=[800,200], view=-1.4..1.4):
display([A, display(op([1,-1,1],A),B), display(op([1,-1,1],A),op([1,-1,1],B),C)], insequence, view=[-3..19,-1.4..1.4]);

restart;
local D, O;
with(Student:-MultivariateCalculus):
A := [0, 0, 0]:
B := [a, 0, 0]:
C := [a, b, 0]:
D := [0, b, 0]:
S := [0, 0, h]:
O := [x, y, z]:
lineSC := Line(S, C);
lineSD := Line(S, D);
H := Projection(A, lineSC);
K := Projection(A, lineSD);
OH:=H-O; OK:=K-O; OC:=C-O;
M:=Matrix([OH, OK, OC]);
O:=eval(O,%): # The center of the desired circle
R:=simplify(Distance(O, H));  # The radius of the circle

Addition - visualization made from calculation results:

with(plots): with(plottools):
a:=2: b:=3: h:=4:
BAD:=curve([B,A,D],linestyle=3,color=blue):
BCD:=curve([B,C,D],thickness=2,color=blue):
SA:=line(S,A,linestyle=3,color=blue, thickness=2): SB:=line(S,B,color=blue, thickness=2): SC:=line(S,C,color=blue, thickness=2): SD:=line(S,D,color=blue, thickness=2):
AH:=line(A,H,linestyle=3,color=black): AK:=line(A,K,linestyle=3,color=black):
p:=Plane(C,S,D):
s:=(x-O[1])^2+(y-O[2])^2+(z-O[3])^2=R^2:
c:=intersectplot(GetRepresentation(p),s, x=-1..a+0.7, y=-1..b+0.7, z=-1..h+0.7, color=red, thickness=3):
T:=textplot3d([[A[],"A"],[B[],"B"],[C[],"C"],[D[],"D"],[S[],"S"],[H[],"H"],[K[],"K"]], font=[times,roman,18], align=left):
display(BAD,BCD,SA,SB,SC,SD,AH,AK,c,T, axes=none, scaling=constrained);

f := (x1, t1)->eval(u(x, t), (pds:-value(t = t1))(x1)):

# Examples 
f(0, 0.1); 
f(0, 0.7); 
f(0.3, 0.3);

For example you can do this using the loop with while :

restart;
n:=294912: d:=8:
r:=irem(n,d):
while r=0 do
n:=n/d; r:=irem(n,d);
od:
n;

                                                          9

restart;
R:=Student:-MultivariateCalculus:-LagrangeMultipliers(z,[4*x-3*y+8*z-5,z^2-x^2-y^2], [x,y,z], output=detailed);
P1:=plots:-intersectplot(4*x-3*y+8*z-5=0,z^2-x^2-y^2=0, x=-1.7..1.4, y=-1.4..1.4, z=-0.4..2.1, color=blue, thickness=2, axes=normal):
P2:=plots:-pointplot3d([eval([x,y,z],R[1]),eval([x,y,z],R[2])], color=red, symbolsize=12, symbol=solidsphere):
plots:-display(P1,P2);

Using the  Student:-Calculus1:-Roots  command, we find 2 real roots of the equation  log[2](7*x/10)=log[3](3*x-1)  and, based on the plot, find the solution to the inequality:

restart;
Student:-Calculus1:-Roots(log[2](7*x/10)=log[3](3*x-1));
plot([log[2](7*x/10),log[3](3*x-1)], x=0..20, -3..4, color=[red,blue], numpoints=5000, size=[800,400]);

So the result is   0.3730125034<= x <= 16.60731835

I replaced your operators  Not, Or  and so on (I never used them)  with more standard ones (not, or, and, implies) in prefix form . As a result of simplifications in 2 ways, we get  false , that is, your expression is internally contradictory for any values of the variables  x  and  y , just as, for example, x and not x  is contradictory.

restart;
expr:=`and`(
   `not`(`or`(`or`(0 >- 0, y^3=x), 
     `and`(((y*x - 0^0)^2 + (y^2 - x^2)^2)*(y^2 + x^2) > 
       0, 0 <- (y^3 - x)*(y - x^3)^3, 
      `implies`(y + 2*x >= 2*y^3 + x^3, 
       `or`(y + x < y^3 + x^3)), `not`((y^3 - x)*(y - x^3) = 0), 
      0 >= 0), y <> x^3)));
convert(expr, 'boolean_function'); # The first way
Logic:-BooleanSimplify(expr); # The second way

Do  

factor(simplify((2)));

restart;
with(plots): with(plottools):
Sph:=display(sphere(),spacecurve([cos(t),sin(t),0], t=0..2*Pi, color=red, thickness=3), orientation=[60,60,20]):
animate(display@rotate,[Sph,phi,[[0,0,0],[0,0,1]]], phi=0..2*Pi, frames=90, axes=none, paraminfo=false);

In my opinion, all 3 limits were found correctly. We obtain the first limit if we substitute gamma = 0  in A and simplify. The second limit is the generic result for arbitrary parameter values. The third limit does not contradict the second, since  subject to conditions on parameters  sigma__e>0 , sigma__v>0 , sigma__d>0  will be  -sigma__d*sigma__e^2+sqrt(sigma__d^2*sigma__e^4) = 0

restart;
leader:=0:
parms:=[colour=red,thickness=0,linestyle =dash]:
i:=ListTools:-Search(thickness=0, parms);
 if leader=0 then parms:=subsop(i=(thickness=3),parms) fi:
parms;
plots:-display(plottools:-line([1,2], [3,4]),op(parms));

Let us introduce the concept of sublists of a given list and somewhat generalize the problem.

Definitions1. A list  N  is called a sublist of  L  if every element of  N  is included in  L  and these elements in L are in the same order as in  N .

Definitions2. The list  N  is called a sublist of the list  L  in the sense of definition1; moreover, the elements of  N  are in  L  next to each other.

The procedure  IsSubList  tests in the sense of the first or second definition. This is indicated by the third formal parameter.

restart;
IsSubList:=proc(N::list,L::list,i::posint)
local n, P, T, k, M;
uses ListTools, combinat;
n:=nops(N);
P:=map([ListTools:-SearchAll],N,L);
T:= cartprod(P);
k := 0; 
while not T[finished] do k := k+1; M[k] := T[nextvalue]() end do: M:=convert(M, list):
if i=1 then
if not (convert(N,set) subset convert(L,set)) then return false else if `or`(seq(`and`(seq(m[j]<m[j+1],j=1..nops(N)-1)), m=M)) then true else false fi; fi; else
if not (convert(N,set) subset convert(L,set)) then return false else if `or`(seq(`and`(seq(m[j]<m[j+1] and m[j]+1=m[j+1] ,j=1..nops(N)-1)), m=M)) then true else false fi; fi; 
fi;
end proc:

Examples of use:

N:=[7,2,4]:
L1:=[7,4,2,7,2,4]:
L2:=[7,7,7,7,2,2,2,7,4]:
L3:=[7,2,2,7]:
                             
IsSubList(N,L1,1);
IsSubList(N,L2,1);
IsSubList(N,L1,2);
IsSubList(N,L2,2);
IsSubList(N,L3,1);
IsSubList(N,L3,2);

                                                       true
                                                       true
                                                       true
                                                       false
                                                       false
                                                       false

A procedure named  IsSameOrder  does this. For the comparison to be correct, all other elements of the lists L1  and L2  must differ from the elements of the list  N  in order to uniquely determine the positions of the elements of the list  N  in the lists  L1  and  L2 . So I changed 2 elements in  L1  and  L2 .

restart;
IsSameOrder:=proc(N,L)
local n, P;
uses ListTools;
n:=nops(N);
P:=map(ListTools:-Search,N,L);
if `and`(seq(P[i+1]-P[i]>0, i=1..n-1)) then true else false fi; 
end proc:

Examples of use:

N:=[7,2,4]:
L1:=[1,6,5,7,3,2,9,4]:
L2:=[2,1,4,5,6,7,3,9]:
IsSameOrder(N,L1);
IsSameOrder(N,L2);

                                                 true
                                                false

restart;
p:=2345: q:=1536:
dp:=convert(p,base,10);
dq:=convert(q,base,10);
S:=`intersect`(convert~([dp,dq],set)[]);
dp1:=remove(`in`, dp, S);
dq1:=remove(`in`, dq, S);
p1:=add(dp1[i]*10^(i-1), i=1..nops(dp1));
q1:=add(dq1[i]*10^(i-1), i=1..nops(dq1));