import sympy as sp
x = sp.symbols("x", positive=True)
f = sp.log(x) + x**2 + 2
f_prime = sp.diff(f, x)
expected = 1/x + 2*x
print("f(x) =", f)
print("f'(x) =", f_prime)
print("Expected =", expected)
print("Difference =", sp.simplify(f_prime-expected))
print("Domain: x > 0")

Utskrift fra Python:
f(x) = x**2 + log(x) + 2
f'(x) = 2*x + 1/x
Expected = 2*x + 1/x
Difference = 0
Domain: x > 0

import sympy as sp
x = sp.symbols("x", real=True)
g = (x**2 + 2)**7
g_prime = sp.diff(g, x)
expected = 14*x*(x**2+2)**6
print("g(x) =", g)
print("g'(x) =", sp.factor(g_prime))
print("Expected =", expected)
print("Difference =", sp.simplify(g_prime-expected))
print("g'(0) =", g_prime.subs(x,0))

Utskrift fra Python:
g(x) = (x**2 + 2)**7
g'(x) = 14*x*(x**2 + 2)**6
Expected = 14*x*(x**2 + 2)**6
Difference = 0
g'(0) = 0

import sympy as sp
x = sp.symbols("x", real=True)
h = 3*x*sp.exp(2*x)
h_prime = sp.diff(h, x)
expected = 3*sp.exp(2*x)*(1+2*x)
print("h(x) =", h)
print("h'(x) =", h_prime)
print("Factored =", sp.factor(h_prime))
print("Expected =", expected)
print("Difference =", sp.simplify(h_prime-expected))

Utskrift fra Python:
h(x) = 3*x*exp(2*x)
h'(x) = 6*x*exp(2*x) + 3*exp(2*x)
Factored = 3*(2*x + 1)*exp(2*x)
Expected = 3*(2*x + 1)*exp(2*x)
Difference = 0

import sympy as sp
x = sp.symbols("x")
expr = (2*x+2)/(x**2-x) - (2*x+2)/(x**2-1) + 1/x + (x+1)/(x**2+x)
combined = sp.together(expr)
simplified = sp.factor(expr)
expected = 2/(x-1)
print("Original expression =", expr)
print("Common-denominator form =", combined)
print("Simplified =", simplified)
print("Expected =", expected)
print("Difference =", sp.simplify(expr-expected))
print("Original exclusions: x != -1, 0, 1")

Utskrift fra Python:
Original expression = (x + 1)/(x**2 + x) + (2*x + 2)/(x**2 - x) - (2*x + 2)/(x**2 - 1) + 1/x
Common-denominator form = 2*(-x*(x - 1)*(x + 1) + (x - 1)*(x**2 - 1) + (x + 1)*(x**2 - 1))/(x*(x - 1)*(x**2 - 1))
Simplified = 2/(x - 1)
Expected = 2/(x - 1)
Difference = 0
Original exclusions: x != -1, 0, 1

import sympy as sp
x = sp.symbols("x", positive=True)
expr = sp.log(4*x) + 3*sp.log(x/2) + sp.log(2*x**2)
expanded = sp.expand_log(expr, force=True)
simplified = sp.simplify(expanded)
print("Original expression =", expr)
print("Expanded logarithms =", expanded)
print("Simplified =", simplified)
print("As one logarithm =", sp.log(x**6))
print("Difference from 6*log(x) =", sp.simplify(simplified-6*sp.log(x)))
print("Domain: x > 0")

Utskrift fra Python:
Original expression = 3*log(x/2) + log(4*x) + log(2*x**2)
Expanded logarithms = 6*log(x)
Simplified = 6*log(x)
As one logarithm = log(x**6)
Difference from 6*log(x) = 0
Domain: x > 0

import sympy as sp
A = sp.Matrix([2,2]); B = sp.Matrix([6,1]); C = sp.Matrix([6,5]); D = sp.Matrix([2,6])
v_l = C-A
v_m = D-B
print("A =", tuple(A))
print("C =", tuple(C))
print("Direction AC =", tuple(v_l))
print("l(t) = (2, 2) + t*(4, 3)")
print("B =", tuple(B))
print("D =", tuple(D))
print("Direction BD =", tuple(v_m))
print("m(s) = (6, 1) + s*(-4, 5)")
print("Endpoint checks =", tuple(A+v_l), tuple(B+v_m))

Utskrift fra Python:
A = (2, 2)
C = (6, 5)
Direction AC = (4, 3)
l(t) = (2, 2) + t*(4, 3)
B = (6, 1)
D = (2, 6)
Direction BD = (-4, 5)
m(s) = (6, 1) + s*(-4, 5)
Endpoint checks = (6, 5) (2, 6)

import sympy as sp
t, s = sp.symbols("t s", real=True)
solutions = sp.solve([sp.Eq(2+4*t,6-4*s), sp.Eq(2+3*t,1+5*s)],[t,s], dict=True)
sol = solutions[0]
point_l = (sp.simplify(2+4*sol[t]), sp.simplify(2+3*sol[t]))
point_m = (sp.simplify(6-4*sol[s]), sp.simplify(1+5*sol[s]))
print("Solutions =", solutions)
print("Point from l =", point_l)
print("Point from m =", point_m)
print("Points agree =", point_l==point_m)
print("Decimal point =", tuple(sp.N(v) for v in point_l))

Utskrift fra Python:
Solutions = [{s: 1/2, t: 1/2}]
Point from l = (4, 7/2)
Point from m = (4, 7/2)
Points agree = True
Decimal point = (4.00000000000000, 3.50000000000000)

import sympy as sp
u = sp.Matrix([4,3]); v = sp.Matrix([-4,5])
dot = u.dot(v)
cos_angle = sp.N(dot/(sp.sqrt(u.dot(u))*sp.sqrt(v.dot(v))), 12)
angle = sp.N(sp.acos(dot/(sp.sqrt(u.dot(u))*sp.sqrt(v.dot(v))))*180/sp.pi, 12)
print("u =", tuple(u))
print("v =", tuple(v))
print("Dot product =", dot)
print("Perpendicular =", dot==0)
print("cos(angle) =", cos_angle)
print("Angle in degrees =", angle)

Utskrift fra Python:
u = (4, 3)
v = (-4, 5)
Dot product = -1
Perpendicular = False
cos(angle) = -0.0312347523777
Angle in degrees = 91.7899106082

import sympy as sp
t = sp.symbols("t", positive=True)
A = 10*t/(t**2+4)
A_prime = sp.factor(sp.diff(A,t))
critical = sp.solve(sp.Eq(sp.together(A_prime).as_numer_denom()[0],0),t)
maximum = sp.simplify(A.subs(t,2))
print("A(t) =", A)
print("A'(t) =", A_prime)
print("Positive critical points =", critical)
print("A(2) =", maximum)
print("A'(1) =", sp.N(A_prime.subs(t,1)))
print("A'(3) =", sp.N(A_prime.subs(t,3)))
print("Maximum confirmed by sign change =", A_prime.subs(t,1)>0 and A_prime.subs(t,3)<0)

Utskrift fra Python:
A(t) = 10*t/(t**2 + 4)
A'(t) = -10*(t - 2)*(t + 2)/(t**2 + 4)**2
Positive critical points = [2]
A(2) = 5/2
A'(1) = 1.20000000000000
A'(3) = -0.295857988165680
Maximum confirmed by sign change = True

import sympy as sp
x = sp.symbols("x", real=True)
solutions = sp.solve(sp.Eq(x**2,100),x)
left_at_10 = sp.log(10**2,10)
left_at_minus10 = sp.log((-10)**2,10)
print("Solutions of x^2 = 100 =", solutions)
print("Left statement at x=10 =", left_at_10)
print("Left statement at x=-10 =", left_at_minus10)
print("Left implies x=10 =", solutions==[10])
print("x=10 implies left =", left_at_10==2)
print("Correct symbol: <= (left follows from right)")

Utskrift fra Python:
Solutions of x^2 = 100 = [-10, 10]
Left statement at x=10 = 2
Left statement at x=-10 = 2
Left implies x=10 = False
x=10 implies left = True
Correct symbol: <= (left follows from right)

import sympy as sp
x = sp.symbols("x", real=True)
solution = sp.solve_univariate_inequality(x**2-2*x<0,x)
print("Factorization =", sp.factor(x**2-2*x))
print("Solution of inequality =", solution)
print("Test x=0.5 gives =", sp.N((x**2-2*x).subs(x,sp.Rational(1,2))))
print("Test x=1.5 gives =", sp.N((x**2-2*x).subs(x,sp.Rational(3,2))))
print("Left implies x in (0,1) = False")
print("x in (0,1) implies left = True")
print("Correct symbol: <= (left follows from right)")

Utskrift fra Python:
Factorization = x*(x - 2)
Solution of inequality = (0 < x) & (x < 2)
Test x=0.5 gives = -0.750000000000000
Test x=1.5 gives = -0.750000000000000
Left implies x in (0,1) = False
x in (0,1) implies left = True
Correct symbol: <= (left follows from right)

import math
line_arrangements = math.factorial(6)
rotations_per_circle = 6
circle_arrangements = line_arrangements // rotations_per_circle
fixed_person_method = math.factorial(5)
print("Linear arrangements =", line_arrangements)
print("Rotations per circular arrangement =", rotations_per_circle)
print("Circular arrangements =", circle_arrangements)
print("Fixed-person method =", fixed_person_method)
print("Methods agree =", circle_arrangements==fixed_person_method)

Utskrift fra Python:
Linear arrangements = 720
Rotations per circular arrangement = 6
Circular arrangements = 120
Fixed-person method = 120
Methods agree = True

import math
favourable_positions = 2
total_positions = 5
probability = favourable_positions/total_positions
favourable_arrangements = 2*math.factorial(4)
total_arrangements = math.factorial(5)
print("Favourable neighbour positions =", favourable_positions)
print("Possible positions for Audun =", total_positions)
print("Probability =", probability)
print("Favourable circular arrangements =", favourable_arrangements)
print("Total circular arrangements =", total_arrangements)
print("Arrangement ratio =", favourable_arrangements/total_arrangements)

Utskrift fra Python:
Favourable neighbour positions = 2
Possible positions for Audun = 5
Probability = 0.4
Favourable circular arrangements = 48
Total circular arrangements = 120
Arrangement ratio = 0.4

import math
favourable = 2*math.factorial(5)
total = math.factorial(6)
probability = favourable/total
print("Favourable arrangements =", favourable)
print("Total arrangements =", total)
print("Probability =", probability)
print("Exact numerator after reduction = 1")
print("Exact denominator after reduction = 3")

Utskrift fra Python:
Favourable arrangements = 240
Total arrangements = 720
Probability = 0.3333333333333333
Exact numerator after reduction = 1
Exact denominator after reduction = 3

import sympy as sp
alpha = sp.symbols("alpha", positive=True)
angle_BAC = alpha/2
angle_BDC = alpha/2
print("Central angle over arc BC =", alpha)
print("Angle BAC =", angle_BAC)
print("Angle BDC =", angle_BDC)
print("Difference =", sp.simplify(angle_BAC-angle_BDC))
print("Reason: both inscribed angles subtend chord BC")

Utskrift fra Python:
Central angle over arc BC = alpha
Angle BAC = alpha/2
Angle BDC = alpha/2
Difference = 0
Reason: both inscribed angles subtend chord BC

import sympy as sp
ED, AB, DC, AC = sp.symbols("ED AB DC AC", positive=True)
ratio_equation = sp.Eq(ED/AB, DC/AC)
cross_multiplied = sp.Eq(ED*AC, AB*DC)
check = sp.simplify(ED/AB-DC/AC)
print("Similarity correspondence: D<->A, E<->B, C<->C")
print("Side ratio equation =", ratio_equation)
print("Cross-multiplied result =", cross_multiplied)
print("If ratio difference is zero, product difference is zero after multiplying by AB*AC")
print("Symbolic multiplied difference =", sp.expand(check*AB*AC))

Utskrift fra Python:
Similarity correspondence: D<->A, E<->B, C<->C
Side ratio equation = Eq(ED/AB, DC/AC)
Cross-multiplied result = Eq(AC*ED, AB*DC)
If ratio difference is zero, product difference is zero after multiplying by AB*AC
Symbolic multiplied difference = -AB*DC + AC*ED

import sympy as sp
BE, AD, BC, AC = sp.symbols("BE AD BC AC", positive=True)
ratio_equation = sp.Eq(BE/AD, BC/AC)
product_equation = sp.Eq(BE*AC, BC*AD)
print("Similarity correspondence: A<->B, C<->C, D<->E")
print("Side ratio equation =", ratio_equation)
print("Product equation =", product_equation)
print("Cross multiplication check =", sp.expand((BE/AD-BC/AC)*AD*AC))
print("This equals BE*AC - BC*AD")

Utskrift fra Python:
Similarity correspondence: A<->B, C<->C, D<->E
Side ratio equation = Eq(BE/AD, BC/AC)
Product equation = Eq(AC*BE, AD*BC)
Cross multiplication check = AC*BE - AD*BC
This equals BE*AC - BC*AD

import sympy as sp
AC, BE, ED, BC, AD, AB, DC = sp.symbols("AC BE ED BC AD AB DC")
BD = BE+ED
expression = sp.expand(AC*BD)
substituted = expression.subs({AC*BE:BC*AD, AC*ED:AB*DC})
print("BD = BE + ED")
print("AC*BD expanded =", expression)
print("Use AC*BE = BC*AD")
print("Use AC*ED = AB*DC")
print("Result =", substituted)
print("Target difference =", sp.expand(substituted-(AB*DC+BC*AD)))

Utskrift fra Python:
BD = BE + ED
AC*BD expanded = AC*BE + AC*ED
Use AC*BE = BC*AD
Use AC*ED = AB*DC
Result = AB*DC + AD*BC
Target difference = 0

import sympy as sp
a, b, c = sp.symbols("a b c", positive=True)
left = c*c
right = a*a+b*b
print("Ptolemy left AC*BD =", left)
print("Ptolemy right AB*DC + BC*AD =", right)
print("Resulting equation: c^2 = a^2 + b^2")
example_a, example_b = 3, 4
example_c = sp.sqrt(example_a**2+example_b**2)
print("Example a=3, b=4 gives c =", example_c)
print("Check c^2-a^2-b^2 =", sp.simplify(example_c**2-example_a**2-example_b**2))

Utskrift fra Python:
Ptolemy left AC*BD = c**2
Ptolemy right AB*DC + BC*AD = a**2 + b**2
Resulting equation: c^2 = a^2 + b^2
Example a=3, b=4 gives c = 5
Check c^2-a^2-b^2 = 0

import sympy as sp
t, X, Y = sp.symbols("t X Y", real=True)
x = (1-t**2)/(t**2+1)
y = (t**2+2*t)/(t**2+1)
num1 = sp.together(X-x).as_numer_denom()[0]
num2 = sp.together(Y-y).as_numer_denom()[0]
implicit = sp.factor(sp.resultant(num1,num2,t))
print("x(t) =", x)
print("y(t) =", y)
print("r(0) =", (x.subs(t,0),y.subs(t,0)))
print("r(-10) =", (sp.N(x.subs(t,-10),8),sp.N(y.subs(t,-10),8)))
print("r(10) =", (sp.N(x.subs(t,10),8),sp.N(y.subs(t,10),8)))
print("Implicit curve equation =", implicit, "= 0")

Utskrift fra Python:
x(t) = (1 - t**2)/(t**2 + 1)
y(t) = (t**2 + 2*t)/(t**2 + 1)
r(0) = (1, 0)
r(-10) = (-0.98019802, 0.79207921)
r(10) = (-0.98019802, 1.1881188)
Implicit curve equation = 5*X**2 + 4*X*Y - 2*X + 4*Y**2 - 4*Y - 3 = 0

import sympy as sp
import math
t = sp.symbols("t", real=True)
x = (1-t**2)/(t**2+1)
y = (t**2+2*t)/(t**2+1)
dx = sp.factor(sp.diff(x,t)); dy = sp.factor(sp.diff(y,t))
v2 = sp.factor(dx**2+dy**2)
dv2_num = sp.factor(sp.together(sp.diff(v2,t)).as_numer_denom()[0])
roots = [z for z in sp.nroots(dv2_num) if abs(complex(z).imag)<1e-10]
t_star = float(sp.re(roots[0]))
values = {"t=-10":float(v2.subs(t,-10)),"t=t*":float(v2.subs(t,t_star)),"t=10":float(v2.subs(t,10))}
print("x'(t) =", dx)
print("y'(t) =", dy)
print("v(t)^2 =", v2)
print("Numerator of derivative of v^2 =", dv2_num)
print("Real critical time =", t_star)
print("Squared-speed comparisons =", values)
print("Maximum speed =", math.sqrt(values["t=t*"]))

Utskrift fra Python:
x'(t) = -4*t/(t**2 + 1)**2
y'(t) = -2*(t**2 - t - 1)/(t**2 + 1)**2
v(t)^2 = 4*(t**4 - 2*t**3 + 3*t**2 + 2*t + 1)/(t**2 + 1)**4
Numerator of derivative of v^2 = -8*(2*t**5 - 5*t**4 + 7*t**3 + 10*t**2 + t - 1)
Real critical time = 0.2546744458213951
Squared-speed comparisons = {'t=-10': 0.00047207198442373867, 't=t*': 5.211123753440004, 't=10': 0.0003198526978576606}
Maximum speed = 2.2827885914906805

import sympy as sp
t = sp.symbols("t", real=True)
x = (1-t**2)/(t**2+1)
y = (t**2+2*t)/(t**2+1)
dx = sp.factor(sp.diff(x,t)); dy = sp.factor(sp.diff(y,t))
solutions = sp.solve(sp.Eq(dy,0),t)
print("x'(t) =", dx)
print("y'(t) =", dy)
print("Solutions y'(t)=0 =", solutions)
for value in solutions:
    print("t =", value, "decimal =", sp.N(value,10), "x'(t) =", sp.simplify(dx.subs(t,value)))
print("Both times are inside [-10, 10]")

Utskrift fra Python:
x'(t) = -4*t/(t**2 + 1)**2
y'(t) = -2*(t**2 - t - 1)/(t**2 + 1)**2
Solutions y'(t)=0 = [1/2 - sqrt(5)/2, 1/2 + sqrt(5)/2]
t = 1/2 - sqrt(5)/2 decimal = -0.6180339888 x'(t) = 2/5 + 2*sqrt(5)/5
t = 1/2 + sqrt(5)/2 decimal = 1.618033989 x'(t) = 2/5 - 2*sqrt(5)/5
Both times are inside [-10, 10]

from fractions import Fraction
p_no_green = Fraction(36,37)**10
p_at_least_one = 1-p_no_green
print("P(no green in one game) =", Fraction(36,37))
print("P(no green in 10 games) =", p_no_green)
print("P(at least one green) =", p_at_least_one)
print("Decimal probability =", float(p_at_least_one))
print("Percentage =", 100*float(p_at_least_one))

Utskrift fra Python:
P(no green in one game) = 36/37
P(no green in 10 games) = 3656158440062976/4808584372417849
P(at least one green) = 1152425932354873/4808584372417849
Decimal probability = 0.23966012512231558
Percentage = 23.966012512231558

import math
threshold = math.log(0.5)/math.log(36/37)
n = math.floor(threshold)+1
p25 = 1-(36/37)**25
p26 = 1-(36/37)**26
print("Continuous threshold =", threshold)
print("Smallest integer n =", n)
print("P(at least one green in 25 games) =", p25)
print("P(at least one green in 26 games) =", p26)
print("25 games exceeds 0.5 =", p25>0.5)
print("26 games exceeds 0.5 =", p26>0.5)

Utskrift fra Python:
Continuous threshold = 25.29828948343004
Smallest integer n = 26
P(at least one green in 25 games) = 0.4958968427156847
P(at least one green in 26 games) = 0.5095212523720176
25 games exceeds 0.5 = False
26 games exceeds 0.5 = True

import math
p = 18/37
terms = []
for k in range(7,11):
    value = math.comb(10,k)*p**k*(1-p)**(10-k)
    terms.append((k,value))
total = sum(value for _,value in terms)
print("Distribution: X ~ Binomial(n=10, p=18/37)")
for k,value in terms:
    print(f"P(X={k}) = {value:.12f}")
print("P(X>=7) =", total)
print("Rounded to three decimals =", round(total,3))

Utskrift fra Python:
Distribution: X ~ Binomial(n=10, p=18/37)
P(X=7) = 0.104793017011
P(X=8) = 0.037229098149
P(X=9) = 0.007837704873
P(X=10) = 0.000742519409
P(X>=7) = 0.1506023394423857
Rounded to three decimals = 0.151

import math
p_red = 18/37
q = sum(math.comb(10,k)*p_red**k*(1-p_red)**(10-k) for k in range(7,11))
probability = math.comb(8,3)*q**3*(1-q)**5
print("q = P(one friend gets at least 7 red) =", q)
print("Number of friends = 8")
print("Required successes = 3")
print("Binomial coefficient C(8,3) =", math.comb(8,3))
print("P(Y=3) =", probability)
print("Percentage =", 100*probability)

Utskrift fra Python:
q = P(one friend gets at least 7 red) = 0.1506023394423857
Number of friends = 8
Required successes = 3
Binomial coefficient C(8,3) = 56
P(Y=3) = 0.08457431406545474
Percentage = 8.457431406545474

import sympy as sp
x = sp.symbols("x", real=True)
AB = 120-x
BD = sp.sqrt(x**2+20**2)
P_geometric = 800*AB+1500*BD
P_given = 96000-800*x+1500*sp.sqrt(x**2+400)
print("AB =", AB)
print("BD =", BD)
print("Road cost =", sp.expand(800*AB))
print("Terrain cost =", 1500*BD)
print("Total cost =", P_geometric)
print("Difference from stated formula =", sp.simplify(P_geometric-P_given))
print("Domain: 0 <= x <= 120")

Utskrift fra Python:
AB = 120 - x
BD = sqrt(x**2 + 400)
Road cost = 96000 - 800*x
Terrain cost = 1500*sqrt(x**2 + 400)
Total cost = -800*x + 1500*sqrt(x**2 + 400) + 96000
Difference from stated formula = 0
Domain: 0 <= x <= 120

import sympy as sp
x = sp.symbols("x", nonnegative=True)
P = 96000-800*x+1500*sp.sqrt(x**2+400)
P_prime = sp.diff(P,x)
x_star = 160/sp.sqrt(161)
P_star = sp.simplify(P.subs(x,x_star))
print("P(x) =", P)
print("P'(x) =", P_prime)
print("Critical x =", x_star)
print("Critical x decimal =", sp.N(x_star,12))
print("Minimum price exact =", P_star)
print("Minimum price decimal =", sp.N(P_star,12))
print("P(0) =", P.subs(x,0))
print("P(120) =", sp.N(P.subs(x,120),12))
print("Derivative left/right =", sp.N(P_prime.subs(x,5)), sp.N(P_prime.subs(x,30)))

Utskrift fra Python:
P(x) = -800*x + 1500*sqrt(x**2 + 400) + 96000
P'(x) = 1500*x/sqrt(x**2 + 400) - 800
Critical x = 160*sqrt(161)/161
Critical x decimal = 12.6097664998
Minimum price exact = 2000*sqrt(161) + 96000
Minimum price decimal = 121377.155081
P(0) = 126000
P(120) = 182482.875909
Derivative left/right = -436.196562445501 448.075441506766

import sympy as sp
x, k = sp.symbols("x k", positive=True)
Q = 1000*(120-x)+k*sp.sqrt(x**2+400)
Q_prime = sp.diff(Q,x)
solution = sp.solve(sp.Eq(Q_prime.subs(x,10),0),k)[0]
second = sp.simplify(sp.diff(Q,x,2).subs({x:10,k:solution}))
print("Q(x) =", Q)
print("Q'(x) =", Q_prime)
print("Equation at x=10 =", sp.Eq(Q_prime.subs(x,10),0))
print("k exact =", solution)
print("k decimal =", sp.N(solution,12))
print("Q''(10) after substitution =", second)
print("Minimum confirmed =", second>0)

Utskrift fra Python:
Q(x) = k*sqrt(x**2 + 400) - 1000*x + 120000
Q'(x) = k*x/sqrt(x**2 + 400) - 1000
Equation at x=10 = Eq(sqrt(5)*k/5 - 1000, 0)
k exact = 1000*sqrt(5)
k decimal = 2236.06797750
Q''(10) after substitution = 80
Minimum confirmed = True

import sympy as sp
x, b = sp.symbols("x b", real=True)
f = x**3-2*b*x**2+(b**2+3)*x
factored = x*((x-b)**2+3)
print("f(x) =", f)
print("Factorized =", sp.factor(f))
print("Target factorization =", factored)
print("Difference =", sp.expand(f-factored))
print("Minimum possible value of second factor = 3")
print("Only real zero is x=0")

Utskrift fra Python:
f(x) = -2*b*x**2 + x**3 + x*(b**2 + 3)
Factorized = x*(b**2 - 2*b*x + x**2 + 3)
Target factorization = x*((-b + x)**2 + 3)
Difference = 0
Minimum possible value of second factor = 3
Only real zero is x=0

import sympy as sp
x, b = sp.symbols("x b", real=True)
f = x**3-2*b*x**2+(b**2+3)*x
f_prime = sp.diff(f,x)
discriminant = sp.factor(sp.discriminant(f_prime,x))
condition = sp.solve_univariate_inequality(discriminant>0,b)
print("f'(x) =", f_prime)
print("Discriminant =", discriminant)
print("Condition discriminant > 0 =", condition)
for value in [-4,-3,0,3,4]:
    roots = sp.solve(sp.Eq(f_prime.subs(b,value),0),x)
    print(f"b={value}: stationary roots = {roots}")

Utskrift fra Python:
f'(x) = b**2 - 4*b*x + 3*x**2 + 3
Discriminant = 4*(b - 3)*(b + 3)
Condition discriminant > 0 = (3 < b) | (b < -3)
b=-4: stationary roots = [-8/3 - sqrt(7)/3, -8/3 + sqrt(7)/3]
b=-3: stationary roots = [-2]
b=0: stationary roots = []
b=3: stationary roots = [2]
b=4: stationary roots = [8/3 - sqrt(7)/3, sqrt(7)/3 + 8/3]

import sympy as sp
x, b = sp.symbols("x b", real=True)
f = x**3-2*b*x**2+(b**2+3)*x
line = 3*x
difference = sp.factor(f-line)
f_at_b = sp.simplify(f.subs(x,b))
slope_at_b = sp.simplify(sp.diff(f,x).subs(x,b))
print("f(x)-3x =", difference)
print("f(b) =", f_at_b)
print("Line value at x=b =", line.subs(x,b))
print("f'(b) =", slope_at_b)
print("Line slope = 3")
print("Point of tangency = (b, 3*b)")
print("Function-value difference =", sp.simplify(f_at_b-3*b))
print("Slope difference =", sp.simplify(slope_at_b-3))

Utskrift fra Python:
f(x)-3x = x*(-b + x)**2
f(b) = 3*b
Line value at x=b = 3*b
f'(b) = 3
Line slope = 3
Point of tangency = (b, 3*b)
Function-value difference = 0
Slope difference = 0