Hva spør oppgaven om? Vi skal derivere et produkt av et polynom og en logaritme. Derfor bruker vi produktregelen, og vi må samtidig huske at \(\ln x\) bare er definert for \(x>0\).

Steg 1 — Del uttrykket i to faktorer

Steg 2 — Skriv produktregelen

Steg 3 — Deriver den første faktoren

Steg 4 — Deriver logaritmen

Steg 5 — Sett inn i produktregelen

Steg 6 — Forenkle

from sympy import symbols, log, diff, simplify

x = symbols('x', positive=True)
f = x**2*log(x)
f_prime = diff(f, x)
expected = 2*x*log(x) + x

print("f(x) =", f)
print("f'(x) =", f_prime)
print("Forventet uttrykk =", expected)
print("Differanse etter forenkling =", simplify(f_prime - expected))

f(x) = x**2*log(x)
f'(x) = 2*x*log(x) + x
Forventet uttrykk = 2*x*log(x) + x
Differanse etter forenkling = 0

Fasit: \(f\prime(x)=2x\ln x+x\), for \(x>0\).

Hva spør oppgaven om? Vi deriverer begge kvadratene med kjerneregelen. Deretter samler vi leddene og kan eventuelt bruke dobbeltvinkelidentiteten.

Steg 1 — Deriver \(\sin^2x\)

Steg 2 — Deriver \(\cos^2x\)

Steg 3 — Ta hensyn til minustegnet

Steg 4 — Samle like ledd

Steg 5 — Bruk dobbeltvinkelidentiteten

Steg 6 — Oppgi begge ekvivalente former

from sympy import symbols, sin, cos, diff, simplify, trigsimp

x = symbols('x', real=True)
g = sin(x)**2 - cos(x)**2
g_prime = diff(g, x)

print("g(x) =", g)
print("g'(x) før trigonometrisk forenkling =", g_prime)
print("g'(x) etter trigsimp =", trigsimp(g_prime))
print("Kontroll mot 2*sin(2*x) =", simplify(g_prime - 2*sin(2*x)))

g(x) = sin(x)**2 - cos(x)**2
g'(x) før trigonometrisk forenkling = 4*sin(x)*cos(x)
g'(x) etter trigsimp = 2*sin(2*x)
Kontroll mot 2*sin(2*x) = 0

Fasit: \(g\prime(x)=4\sin x\cos x=2\sin 2x\).

Hva spør oppgaven om? Nevneren er \(x^2+3\), og den deriverte \(2x\) finnes nesten i telleren. Substitusjon er derfor den mest direkte metoden.

Steg 1 — Velg substitusjon

Steg 2 — Deriver substitusjonen

Steg 3 — Løs for \(x\,dx\)

Steg 4 — Skriv integralet i \(u\)

Steg 5 — Integrer

Steg 6 — Sett tilbake

from sympy import symbols, integrate, diff, simplify

x = symbols('x', real=True)
integrand = x/(x**2 + 3)
primitive = integrate(integrand, x)
control = simplify(diff(primitive, x) - integrand)

print("Integrand =", integrand)
print("Stamfunksjon fra SymPy =", primitive)
print("Derivert stamfunksjon =", diff(primitive, x))
print("Derivert minus integrand =", control)

Integrand = x/(x**2 + 3)
Stamfunksjon fra SymPy = log(x**2 + 3)/2
Derivert stamfunksjon = x/(x**2 + 3)
Derivert minus integrand = 0

Fasit: \(\displaystyle \int\frac{x}{x^2+3}dx=\frac12\ln(x^2+3)+C\).

Hva spør oppgaven om? Vi leser integralet som fortegnet areal. Området over førsteaksen bidrar positivt, mens området under førsteaksen bidrar negativt.

Steg 1 — Del intervallet ved nullpunktet

Steg 2 — Finn det positive arealet

Steg 3 — Finn det negative arealets størrelse

Steg 4 — Bruk fortegn

Steg 5 — Regn ut

Steg 6 — Tolk svaret

from sympy import Rational

positive_triangle = Rational(1, 2)*2*2
negative_triangle = Rational(1, 2)*1*1
signed_integral = positive_triangle - negative_triangle
geometric_area = positive_triangle + negative_triangle

print("Positivt trekantareal =", positive_triangle)
print("Størrelsen av negativt trekantareal =", negative_triangle)
print("Fortegnet integral =", signed_integral)
print("Samlet geometrisk areal =", geometric_area)

Positivt trekantareal = 2
Størrelsen av negativt trekantareal = 1/2
Fortegnet integral = 3/2
Samlet geometrisk areal = 5/2

Fasit: \(\displaystyle \int_0^3f(x)dx=\frac32\).

Hva spør oppgaven om? Likningen kan skrives \(y\prime=2y^2\), og variablene kan separeres. Etter integrasjon bruker vi initialbetingelsen til å bestemme konstanten.

Steg 1 — Isoler den deriverte

Steg 2 — Separer variablene

Steg 3 — Integrer begge sider

Steg 4 — Utfør integrasjonen

Steg 5 — Bruk initialbetingelsen

Steg 6 — Løs for \(y\)

Steg 7 — Skriv løsningen

Steg 8 — Oppgi intervallet rundt startpunktet

from sympy import symbols, Function, Eq, diff, dsolve, simplify

x = symbols('x', real=True)
y = Function('y')
solution = dsolve(Eq(diff(y(x), x), 2*y(x)**2), ics={y(0): 1/2})
expression = solution.rhs

print("Løsning fra SymPy =", solution)
print("Kontroll av initialverdi y(0) =", simplify(expression.subs(x, 0)))
print("Kontroll av y' - 2y^2 =", simplify(diff(expression, x) - 2*expression**2))
print("Singularitet finnes ved x = 1")

Løsning fra SymPy = Eq(y(x), -1/(2*x - 2.0))
Kontroll av initialverdi y(0) = 0.500000000000000
Kontroll av y' - 2y^2 = 0
Singularitet finnes ved x = 1

Fasit: \(\displaystyle y(x)=\frac{1}{2(1-x)}\), på intervallet \(x<1\).

Hva spør oppgaven om? Vi finner først komponentene ved å trekke startpunktet fra endepunktet. Deretter bruker vi lengdeformelen i rommet.

Steg 1 — Finn \(\overrightarrow{AB}\)

Steg 2 — Finn \(\overrightarrow{AC}\)

Steg 3 — Skriv lengdeformelen

Steg 4 — Beregn \(|\overrightarrow{AB}|\)

Steg 5 — Beregn \(|\overrightarrow{AC}|\)

Steg 6 — Kontroller rimeligheten

from sympy import Matrix, sqrt

A = Matrix([1, 0, 3])
B = Matrix([3, 2, 4])
C = Matrix([5, 3, 0])
AB = B - A
AC = C - A

print("AB =", tuple(AB))
print("AC =", tuple(AC))
print("|AB| =", sqrt(AB.dot(AB)))
print("|AC| =", sqrt(AC.dot(AC)))

AB = (2, 2, 1)
AC = (4, 3, -3)
|AB| = 3
|AC| = sqrt(34)

Fasit: \(|\overrightarrow{AB}|=3\) og \(|\overrightarrow{AC}|=\sqrt{34}\).

Hva spør oppgaven om? Vi bruker komponentformelen for skalarprodukt og determinantregelen for kryssprodukt. Kryssproduktet skal stå vinkelrett på begge de opprinnelige vektorene.

Steg 1 — Bruk vektorene fra del 1

Steg 2 — Beregn skalarproduktet

Steg 3 — Forenkle skalarproduktet

Steg 4 — Sett opp kryssproduktet

Steg 5 — Regn komponentene

Steg 6 — Forenkle

Steg 7 — Kontroller ortogonalitet

from sympy import Matrix

AB = Matrix([2, 2, 1])
AC = Matrix([4, 3, -3])
dot_product = AB.dot(AC)
cross_product = AB.cross(AC)

print("AB · AC =", dot_product)
print("AB × AC =", tuple(cross_product))
print("Kontroll (AB × AC) · AB =", cross_product.dot(AB))
print("Kontroll (AB × AC) · AC =", cross_product.dot(AC))

AB · AC = 11
AB × AC = (-9, 10, -2)
Kontroll (AB × AC) · AB = 0
Kontroll (AB × AC) · AC = 0

Fasit: \(\overrightarrow{AB}\cdot\overrightarrow{AC}=11\) og \(\overrightarrow{AB}\times\overrightarrow{AC}=(-9,10,-2)\).

Hva spør oppgaven om? Vi bruker resultatene fra de foregående delene og regner begge sider separat. Dette er et konkret tilfelle av Lagranges identitet.

Steg 1 — Kvadrer lengden av kryssproduktet

Steg 2 — Kvadrer skalarproduktet

Steg 3 — Regn venstresiden

Steg 4 — Finn \(|AB|^2\)

Steg 5 — Finn \(|AC|^2\)

Steg 6 — Regn høyresiden

Steg 7 — Sammenlign

from sympy import Matrix, simplify

AB = Matrix([2, 2, 1])
AC = Matrix([4, 3, -3])
left_side = AB.cross(AC).dot(AB.cross(AC)) + AB.dot(AC)**2
right_side = AB.dot(AB)*AC.dot(AC)

print("Venstreside =", left_side)
print("Høyreside =", right_side)
print("Differanse =", simplify(left_side - right_side))

Venstreside = 306
Høyreside = 306
Differanse = 0

Fasit: Begge sider er lik \(306\), så identiteten er bekreftet.

Hva spør oppgaven om? Arealet under en positiv graf fra 0 til a finnes med et bestemt integral.

Steg 1 — Identifiser grensene

Steg 2 — Sett opp integralet

Steg 3 — Finn en stamfunksjon

Steg 4 — Sett inn grensene

Steg 5 — Regn ut

Steg 6 — Tolk

from sympy import symbols, integrate

x, a = symbols('x a', positive=True)
F1 = integrate(x**2, (x, 0, a))

print("F1 = integral_0^a x^2 dx")
print("F1 =", F1)

F1 = integral_0^a x^2 dx
F1 = a**3/3

Fasit: \(\displaystyle F_1=\frac{a^3}{3}\).

Hva spør oppgaven om? Vi finner først hele rektangelets areal. Deretter trekker vi fra arealet under grafen og danner forholdet.

Steg 1 — Finn rektangelets bredde

Steg 2 — Finn rektangelets høyde

Steg 3 — Finn rektangelets areal

Steg 4 — Finn \(F_2\)

Steg 5 — Dann forholdet

Steg 6 — Forkort

from sympy import symbols, simplify

a = symbols('a', positive=True)
F1 = a**3/3
rectangle = a*a**2
F2 = simplify(rectangle - F1)
ratio = simplify(F2/F1)

print("Rektangelareal =", rectangle)
print("F1 =", F1)
print("F2 =", F2)
print("F2/F1 =", ratio)

Rektangelareal = a**3
F1 = a**3/3
F2 = 2*a**3/3
F2/F1 = 2

Fasit: \(\displaystyle \frac{F_2}{F_1}=2\).

Hva spør oppgaven om? G1 er arealet under grafen til x^n fra 0 til a. Vi bruker potensregelen for integrasjon.

Steg 1 — Sett opp arealintegralet

Steg 2 — Bruk potensregelen

Steg 3 — Sett inn grensene

Steg 4 — Evaluer øvre grense

Steg 5 — Evaluer nedre grense

Steg 6 — Konkluder

from sympy import symbols, integrate

x, a = symbols('x a', positive=True)
n = symbols('n', integer=True, positive=True)
G1 = integrate(x**n, (x, 0, a))

print("G1 =", G1)

G1 = a**(n + 1)/(n + 1)

Fasit: \(\displaystyle G_1=\frac{a^{n+1}}{n+1}\).

Hva spør oppgaven om? Vi bruker samme idé som for x²: rektangelets areal er bredde ganger høyde, og G2 er det som blir igjen over grafen.

Steg 1 — Finn høyden ved \(x=a\)

Steg 2 — Finn rektangelets areal

Steg 3 — Trekk fra \(G_1\)

Steg 4 — Sett på felles nevner

Steg 5 — Forenkle

Steg 6 — Dann forholdet

Steg 7 — Tolk

from sympy import symbols, simplify

a = symbols('a', positive=True)
n = symbols('n', integer=True, positive=True)
G1 = a**(n + 1)/(n + 1)
rectangle = a**(n + 1)
G2 = simplify(rectangle - G1)
ratio = simplify(G2/G1)

print("G1 =", G1)
print("Rektangelareal =", rectangle)
print("G2 =", G2)
print("G2/G1 =", ratio)

G1 = a**(n + 1)/(n + 1)
Rektangelareal = a**(n + 1)
G2 = a**(n + 1)*n/(n + 1)
G2/G1 = n

Fasit: \(\displaystyle \frac{G_2}{G_1}=n\).

Hva spør oppgaven om? Vi identifiserer første ledd, differanse og n-te ledd. Deretter bruker vi sumformelen for en aritmetisk rekke.

Steg 1 — Kontroller differansen

Steg 2 — Identifiser første og siste ledd

Steg 3 — Skriv sumformelen

Steg 4 — Sett inn

Steg 5 — Forenkle parentesen

Steg 6 — Regn ferdig

Steg 7 — Tolk

from sympy import symbols, summation, simplify

k, n = symbols('k n', integer=True, positive=True)
sum_expression = summation(2*k - 1, (k, 1, n))

print("Symbolsk sum =", sum_expression)
print("Forventet uttrykk =", n**2)
print("Differanse =", simplify(sum_expression - n**2))
for value in range(1, 6):
    print(f"n={value}: sum={sum_expression.subs(n, value)}")

Symbolsk sum = n**2
Forventet uttrykk = n**2
Differanse = 0
n=1: sum=1
n=2: sum=4
n=3: sum=9
n=4: sum=16
n=5: sum=25

Fasit: \(S_n=n^2\).

Hva spør oppgaven om? Rekken er geometrisk med første ledd 1 og kvotient 1/3. Vi finner delsumformelen og løser deretter en eksponentialulikhet.

Steg 1 — Identifiser dataene

Steg 2 — Bruk sumformelen

Steg 3 — Sett inn

Steg 4 — Forenkle

Steg 5 — Sett opp ulikheten

Steg 6 — Isoler eksponentialleddet

Steg 7 — Forenkle ulikheten

Steg 8 — Finn minste heltall

from sympy import symbols, Rational, summation, simplify, log, ceiling

k, n = symbols('k n', integer=True, positive=True)
S_n = summation(Rational(1, 3)**(k - 1), (k, 1, n))
threshold = Rational(145, 100)
critical = log(30, 3)

print("S_n fra symbolsk summering =", S_n)
print("Forenklet kontroll =", simplify(S_n - Rational(3, 2)*(1 - 3**(-n))))
print("log_3(30) =", critical.evalf(15))
print("Minste heltall større enn log_3(30) =", ceiling(critical))
for value in [3, 4]:
    current = S_n.subs(n, value)
    print(f"S_{value} = {current} = {current.evalf(12)}; større enn 1,45: {current > threshold}")

S_n fra symbolsk summering = 3/2 - 9*3**(-n - 1)/2
Forenklet kontroll = 0
log_3(30) = 3.09590327428938
Minste heltall større enn log_3(30) = 4
S_3 = 13/9 = 1.44444444444; større enn 1,45: False
S_4 = 40/27 = 1.48148148148; større enn 1,45: True

Fasit: \(\displaystyle S_n=\frac32(1-3^{-n})\), og minst 4 ledd må tas med.

Hva spør oppgaven om? En uendelig geometrisk rekke har sum bare når absoluttverdien av kvotienten er mindre enn 1. Her er kvotienten 1/3.

Steg 1 — Kontroller konvergenskravet

Steg 2 — Konkluder at summen finnes

Steg 3 — Bruk formelen

Steg 4 — Sett inn

Steg 5 — Regn ut

Steg 6 — Koble til delsummen

from sympy import symbols, Rational, summation, oo, limit

k, n = symbols('k n', integer=True, positive=True)
infinite_sum = summation(Rational(1, 3)**(k - 1), (k, 1, oo))
limit_sum = limit(Rational(3, 2)*(1 - 3**(-n)), n, oo)

print("Uendelig sum =", infinite_sum)
print("Grenseverdi av S_n =", limit_sum)
print("Desimaltall =", infinite_sum.evalf(15))

Uendelig sum = 3/2
Grenseverdi av S_n = 3/2
Desimaltall = 1.50000000000000

Fasit: Den uendelige rekken konvergerer mot \(\frac32=1{,}5\).

Hva spør oppgaven om? Hvert ledd fås ved å multiplisere med x/3. Vi bruker konvergenskravet for geometriske rekker og sumformelen.

Steg 1 — Finn kvotienten

Steg 2 — Skriv konvergenskravet

Steg 3 — Sett inn kvotienten

Steg 4 — Løs ulikheten

from sympy import symbols, Abs, solve_univariate_inequality, simplify

x = symbols('x', real=True)
ratio = x/3
convergence = solve_univariate_inequality(Abs(ratio) < 1, x)
S = simplify(1/(1 - ratio))

print("Kvotient =", ratio)
print("Konvergensområde =", convergence)
print("S(x) =", S)

Kvotient = x/3
Konvergensområde = (-3 < x) & (x < 3)
S(x) = -3/(x - 3)

Hva spør oppgaven om? Vi løser likningene med uttrykket 3/(3-x), men må til slutt kontrollere at løsningene ligger i konvergensområdet \(-3

Steg 1 — Løs \(S(x)=4\)

Steg 2 — Kryssmultipliser

Steg 3 — Finn løsningen

Steg 4 — Kontroller konvergensområdet

Steg 5 — Løs \(S(x)=-2\)

Steg 6 — Kryssmultipliser

Steg 7 — Kontroller området

Steg 8 — Konkluder

from sympy import symbols, Eq, solve, Rational

x = symbols('x', real=True)
S = 3/(3 - x)
solutions_4 = solve(Eq(S, 4), x)
solutions_minus2 = solve(Eq(S, -2), x)

print("Løsninger av S(x)=4:", solutions_4)
for value in solutions_4:
    print(value, "ligger i (-3,3):", -3 < value < 3)
print("Løsninger av S(x)=-2:", solutions_minus2)
for value in solutions_minus2:
    print(value, "ligger i (-3,3):", -3 < value < 3)
print("S(9/2) som rasjonal funksjon =", S.subs(x, Rational(9, 2)))

Løsninger av S(x)=4: [9/4]
9/4 ligger i (-3,3): True
Løsninger av S(x)=-2: [9/2]
9/2 ligger i (-3,3): False
S(9/2) som rasjonal funksjon = -2

Fasit: \(S(x)=4\) gir \(x=\frac94\). Likningen \(S(x)=-2\) har ingen løsning i konvergensområdet.

Hva spør oppgaven om? Vi gjennomfører et fullstendig induksjonsbevis: grunntrinn, hypotese og induksjonssteg. Det avgjørende er å vise nøyaktig hvordan uttrykket for k+1 oppstår.

Steg 1 — Grunntrinn \(n=1\)

Steg 2 — Induksjonshypotese

Steg 3 — Skriv summen til og med neste ledd

Steg 4 — Bruk hypotesen på den første delen

Steg 5 — Sett på felles nevner

Steg 6 — Faktoriser

Steg 7 — Gjenkjenn målet

Steg 8 — Konklusjon

from sympy import symbols, summation, simplify, factor

j, k, n = symbols('j k n', integer=True, positive=True)
term = j*(j + 1)/2
closed_form = n*(n + 1)*(n + 2)/6
symbolic_sum = summation(term, (j, 1, n))
induction_left = k*(k + 1)*(k + 2)/6 + (k + 1)*(k + 2)/2
induction_target = (k + 1)*(k + 2)*(k + 3)/6

print("Grunntrinn venstre =", 1)
print("Grunntrinn høyre =", closed_form.subs(n, 1))
print("Symbolsk sum =", symbolic_sum)
print("Lukket form =", closed_form)
print("Differanse for generell n =", simplify(symbolic_sum - closed_form))
print("Induksjonssteg før faktorisering =", induction_left)
print("Induksjonssteg faktorisert =", factor(induction_left))
print("Differanse mot mål for k+1 =", simplify(induction_left - induction_target))

Grunntrinn venstre = 1
Grunntrinn høyre = 1
Symbolsk sum = n**3/6 + n**2/2 + n/3
Lukket form = n*(n + 1)*(n + 2)/6
Differanse for generell n = 0
Induksjonssteg før faktorisering = k*(k + 1)*(k + 2)/6 + (k + 1)*(k + 2)/2
Induksjonssteg faktorisert = (k + 1)*(k + 2)*(k + 3)/6
Differanse mot mål for k+1 = 0

Fasit: Formelen er bevist ved induksjon for alle \(n\ge1\).

Hva spør oppgaven om? Vi summerer netto migrasjon og naturlig befolkningsvekst. Den prosentvise delen er proporsjonal med folketallet, mens fødsler minus dødsfall gir et konstant tillegg.

Steg 1 — Finn netto innvandringsrate

Steg 2 — Skriv prosenten som desimaltall

Steg 3 — Skriv netto migrasjon per år

Steg 4 — Finn fødselsoverskuddet

Steg 5 — Legg sammen bidragene

Steg 6 — Koble til den deriverte

immigration_rate = 0.014
emigration_rate = 0.005
births = 60000
deaths = 42000

net_migration_rate = immigration_rate - emigration_rate
natural_increase = births - deaths

print("Netto migrasjonsrate =", net_migration_rate)
print("Netto migrasjonsrate i prosent =", 100*net_migration_rate, "%")
print("Fødselsoverskudd =", natural_increase)
print("Modell: y' =", net_migration_rate, "* y +", natural_increase)

Netto migrasjonsrate = 0.009000000000000001
Netto migrasjonsrate i prosent = 0.9000000000000001 %
Fødselsoverskudd = 18000
Modell: y' = 0.009000000000000001 * y + 18000

Fasit: Befolkningsmodellen er \(y\prime=0{,}009y+18\,000\).

Hva spør oppgaven om? Å vokse med 72 000 per år betyr at den deriverte y′ er 72 000. Vi setter dette inn i modellen og løser en lineær likning for y.

Steg 1 — Sett veksthastigheten lik 72 000

Steg 2 — Bruk differensiallikningen

Steg 3 — Trekk fra det konstante bidraget

Steg 4 — Regn venstresiden

Steg 5 — Divider med 0,009

Steg 6 — Regn ut

Steg 7 — Kontroller i modellen

from sympy import symbols, Eq, solve, Rational

y = symbols('y', real=True)
rate = Rational(9, 1000)
equation = Eq(72000, rate*y + 18000)
solution = solve(equation, y)[0]
control = rate*solution + 18000

print("Likning =", equation)
print("Folketall y =", solution)
print("Kontroll av årlig vekst =", control)

Likning = Eq(72000, 9*y/1000 + 18000)
Folketall y = 6000000
Kontroll av årlig vekst = 72000

Fasit: Folketallet er \(6\,000\,000\) når den årlige veksten er 72 000.

Hva spør oppgaven om? Likningen er lineær med konstant koeffisient. Vi kan løse den ved å finne likevektsløsningen og legge til løsningen av den homogene likningen, eller ved separasjon etter en forskyvning.

Steg 1 — Skriv likningen på standardform

Steg 2 — Finn en konstant partikulær løsning

Steg 3 — Løs for likevektsverdien

Steg 4 — Løs den homogene likningen

Steg 5 — Skriv homogen løsning

Steg 6 — Legg sammen

Steg 7 — Kontroller ved derivasjon

from sympy import symbols, Function, Eq, diff, dsolve, Rational, simplify

t = symbols('t', real=True)
y = Function('y')
rate = Rational(9, 1000)
solution = dsolve(Eq(diff(y(t), t), rate*y(t) + 18000))
expression = solution.rhs

print("Generell løsning fra SymPy =", solution)
print("Kontroll y'-(0.009y+18000) =", simplify(diff(expression, t) - (rate*expression + 18000)))

Generell løsning fra SymPy = Eq(y(t), C1*exp(9*t/1000) - 2000000)
Kontroll y'-(0.009y+18000) = 0

Fasit: \(\displaystyle y(t)=Ce^{0{,}009t}-2\,000\,000\).

Hva spør oppgaven om? Tidspunktet 1. januar 2009 svarer til t=0. Vi setter y(0)=4 800 000 inn i den generelle løsningen.

Steg 1 — Skriv den generelle løsningen

Steg 2 — Sett \(t=0\)

Steg 3 — Bruk \(e^0=1\)

Steg 4 — Sett inn folketallet

Steg 5 — Legg til 2 000 000

Steg 6 — Skriv den bestemte modellen

Steg 7 — Kontroller startverdien

from sympy import symbols, Eq, solve, exp, Rational, simplify

t, C = symbols('t C', real=True)
model = C*exp(Rational(9, 1000)*t) - 2000000
constant = solve(Eq(model.subs(t, 0), 4800000), C)[0]
final_model = model.subs(C, constant)

print("Likning for C =", Eq(model.subs(t, 0), 4800000))
print("C =", constant)
print("Endelig modell y(t) =", final_model)
print("Kontroll y(0) =", simplify(final_model.subs(t, 0)))

Likning for C = Eq(C - 2000000, 4800000)
C = 6800000
Endelig modell y(t) = 6800000*exp(9*t/1000) - 2000000
Kontroll y(0) = 4800000

Fasit: \(C=6\,800\,000\), og modellen blir \(y(t)=6\,800\,000e^{0{,}009t}-2\,000\,000\).

Hva spør oppgaven om? Vi setter den bestemte befolkningsmodellen lik 6 millioner, isolerer eksponentialleddet og bruker naturlig logaritme.

Steg 1 — Sett inn måltallet

Steg 2 — Legg til 2 000 000

Steg 3 — Divider med 6 800 000

Steg 4 — Ta naturlig logaritme

Steg 5 — Isoler t

Steg 6 — Beregn numerisk

Steg 7 — Tolk i kalenderår

Steg 8 — Kontroller

from sympy import symbols, Eq, solve, exp, log, Rational, N, simplify

t = symbols('t', real=True)
rate = Rational(9, 1000)
model = 6800000*exp(rate*t) - 2000000
solution = solve(Eq(model, 6000000), t)[0]

print("Eksakt løsning t =", solution)
print("Forenklet uttrykk =", log(Rational(20, 17))/rate)
print("Numerisk tid i år =", N(solution, 20))
print("Kontroll y(t) =", simplify(model.subs(t, solution)))

Eksakt løsning t = 1000*log(17**(8/9)*20**(1/9)/17)
Forenklet uttrykk = 1000*log(20/17)/9
Numerisk tid i år = 18.057658833086101465
Kontroll y(t) = 6000000

Fasit: Det tar omtrent \(18{,}1\) år, altså til omtrent begynnelsen av 2027.

Hva spør oppgaven om? Vi omskriver funksjonen til en sum av en sinus med periode 2π og en dobbeltvinkelsinus med periode π. Felles minste periode blir 2π, og grafen tegnes på to perioder.

Steg 1 — Bruk dobbeltvinkelidentiteten

Steg 2 — Finn perioden til første ledd

Steg 3 — Finn perioden til andre ledd

Steg 4 — Finn felles minste periode

Steg 5 — Kontroller direkte

Steg 6 — Tegn på gitt intervall

from sympy import symbols, sin, cos, pi, simplify, trigsimp

x = symbols('x', real=True)
f = 2*sin(x) + 2*sin(x)*cos(x)
check_2pi = trigsimp(f.subs(x, x + 2*pi) - f)
check_pi = trigsimp(f.subs(x, x + pi) - f)

print("f(x) =", f)
print("Omskrevet med dobbeltvinkel =", trigsimp(f.rewrite(sin)))
print("f(x+2*pi)-f(x) =", check_2pi)
print("f(x+pi)-f(x) =", check_pi)
print("Minste felles periode = 2*pi")

f(x) = 2*sin(x)*cos(x) + 2*sin(x)
Omskrevet med dobbeltvinkel = 2*(cos(x) + 1)*sin(x)
f(x+2*pi)-f(x) = 0
f(x+pi)-f(x) = -4*sin(x)
Minste felles periode = 2*pi

Fasit: Perioden er \(2\pi\). Grafen er vist nedenfor på \([0,4\pi]\).

Hva spør oppgaven om? Vi faktoriserer funksjonen slik at nullproduktregelen kan brukes. Deretter finner vi alle løsninger i intervallet fra 0 til 4π.

Steg 1 — Sett funksjonen lik null

Steg 2 — Faktoriser

Steg 3 — Bruk nullproduktregelen

Steg 4 — Løs \(\sin x=0\)

Steg 5 — Løs \(\cos x=-1\)

Steg 6 — Begrens til intervallet

Steg 7 — Kontroller

from sympy import symbols, sin, cos, pi, simplify

x = symbols('x', real=True)
f = 2*sin(x) + 2*sin(x)*cos(x)
zeros = [k*pi for k in range(1, 4)]

print("Nullpunkter i 0<x<4*pi:")
for value in zeros:
    print("x =", value, ", f(x) =", simplify(f.subs(x, value)))

Nullpunkter i 0<x<4*pi:
x = pi , f(x) = 0
x = 2*pi , f(x) = 0
x = 3*pi , f(x) = 0

Fasit: Nullpunktene i definisjonsområdet er \(x=\pi,2\pi,3\pi\).

Hva spør oppgaven om? Vi deriverer funksjonen, omskriver sin² ved hjelp av identiteten sin²+cos²=1, og løser deretter en andregradslikning i cos x. Fortegn eller andrederivert brukes til klassifisering.

Steg 1 — Deriver første ledd

Steg 2 — Deriver produktleddet

Steg 3 — Samle

Steg 4 — Bruk \(\sin^2x=1-\cos^2x\)

Steg 5 — Løs \(f\prime(x)=0\)

Steg 6 — Faktoriser andregradslikningen

Steg 7 — Finn kandidatene i intervallet

Steg 8 — Klassifiser og finn y-verdier

from sympy import symbols, sin, cos, pi, diff, simplify, trigsimp, sqrt

x = symbols('x', real=True)
f = 2*sin(x) + 2*sin(x)*cos(x)
f_prime = trigsimp(diff(f, x))
expected = 4*cos(x)**2 + 2*cos(x) - 2
candidates = [pi/3, pi, 5*pi/3, 7*pi/3, 3*pi, 11*pi/3]

print("f'(x) =", f_prime)
print("Kontroll mot oppgitt uttrykk =", trigsimp(f_prime - expected))
print("Stasjonære kandidater og funksjonsverdier:")
for value in candidates:
    print("x =", value, ", f(x) =", simplify(f.subs(x, value)))
print("Ekstremverdier =", 3*sqrt(3)/2, "og", -3*sqrt(3)/2)

f'(x) = 2*cos(x) + 2*cos(2*x)
Kontroll mot oppgitt uttrykk = 0
Stasjonære kandidater og funksjonsverdier:
x = pi/3 , f(x) = 3*sqrt(3)/2
x = pi , f(x) = 0
x = 5*pi/3 , f(x) = -3*sqrt(3)/2
x = 7*pi/3 , f(x) = 3*sqrt(3)/2
x = 3*pi , f(x) = 0
x = 11*pi/3 , f(x) = -3*sqrt(3)/2
Ekstremverdier = 3*sqrt(3)/2 og -3*sqrt(3)/2

Fasit: Topper: \((\pi/3,3\sqrt3/2)\) og \((7\pi/3,3\sqrt3/2)\). Bunner: \((5\pi/3,-3\sqrt3/2)\) og \((11\pi/3,-3\sqrt3/2)\).

Hva spør oppgaven om? Vi deriverer det oppgitte uttrykket for f′, faktoriserer f″ og finner nullpunkter. Deretter må vi kontrollere fortegnsskifte, fordi f″=0 alene ikke er nok.

Steg 1 — Deriver \(4\cos^2x\)

Steg 2 — Deriver resten

Steg 3 — Samle og faktoriser

Steg 4 — Løs \(f\prime\prime(x)=0\)

Steg 5 — Finn løsninger i det indre av intervallet

Steg 6 — Kontroller fortegnsskifte

Steg 7 — Finn y-verdiene for cosinusløsningene

Steg 8 — Oppgi punktene

from sympy import symbols, sin, cos, pi, diff, simplify, acos, sqrt, N

x = symbols('x', real=True)
f = 2*sin(x) + 2*sin(x)*cos(x)
f_second = simplify(diff(f, x, 2))
alpha = acos(-1/4)
points = [alpha, pi, 2*pi - alpha]

print("f''(x) =", f_second)
print("alpha = arccos(-1/4) =", N(alpha, 15))
print("Vendepunktkandidater og y-verdier:")
for value in points:
    print("x =", value, ", numerisk =", N(value, 12), ", f(x) =", simplify(f.subs(x, value)))
print("Positiv y-verdi =", 3*sqrt(15)/8)
print("Negativ y-verdi =", -3*sqrt(15)/8)

f''(x) = -2*(4*cos(x) + 1)*sin(x)
alpha = arccos(-1/4) = 1.82347658193698
Vendepunktkandidater og y-verdier:
x = 1.82347658193698 , numerisk = 1.82347658194 , f(x) = 1.45236875482778
x = pi , numerisk = 3.14159265359 , f(x) = 0
x = -1.82347658193698 + 2*pi , numerisk = 4.45970872524 , f(x) = -1.45236875482778
Positiv y-verdi = 3*sqrt(15)/8
Negativ y-verdi = -3*sqrt(15)/8

Fasit: \(f\prime\prime(x)=-2\sin x(4\cos x+1)\). Vendepunktene er \((\alpha,3\sqrt{15}/8)\), \((\pi,0)\) og \((2\pi-\alpha,-3\sqrt{15}/8)\), der \(\alpha=\arccos(-1/4)\).

Hva spør oppgaven om? På intervallet fra 0 til π er sin x ikke-negativ og 1+cos x ikke-negativ. Funksjonen ligger derfor over førsteaksen, så arealet er det bestemte integralet uten absoluttverdikorreksjon.

Steg 1 — Kontroller fortegnet

Steg 2 — Sett opp arealintegralet

Steg 3 — Integrer første ledd

Steg 4 — Integrer produktleddet

Steg 5 — Skriv stamfunksjonen

Steg 6 — Sett inn øvre grense

Steg 7 — Sett inn nedre grense

Steg 8 — Trekk fra

from sympy import symbols, sin, cos, pi, integrate, simplify

x = symbols('x', real=True)
f = 2*sin(x) + 2*sin(x)*cos(x)
area = integrate(f, (x, 0, pi))
primitive = integrate(f, x)

print("Stamfunksjon =", primitive)
print("Bestemt integral fra 0 til pi =", area)
print("Kontroll mot 4 =", simplify(area - 4))

Stamfunksjon = sin(x)**2 - 2*cos(x)
Bestemt integral fra 0 til pi = 4
Kontroll mot 4 = 0

Fasit: Arealet er \(4\) arealenheter.

Hva spør oppgaven om? Vi finner den deriverte for å bestemme tangentens stigningstall, og bruker punkt-stigning-formen gjennom punktet P.

Steg 1 — Finn punktet på grafen

Steg 2 — Deriver funksjonen

Steg 3 — Finn stigningstallet ved \(x=a\)

Steg 4 — Bruk punkt-stigning-formen

Steg 5 — Multipliser ut høyresiden

Steg 6 — Isoler y

Steg 7 — Kontroller at linjen går gjennom P

from sympy import symbols, sin, cos, diff, expand, simplify

x, a = symbols('x a', real=True)
f = cos(x)
slope = diff(f, x).subs(x, a)
tangent = expand(cos(a) + slope*(x - a))
expected = -sin(a)*x + a*sin(a) + cos(a)

print("f'(x) =", diff(f, x))
print("Stigningstall f'(a) =", slope)
print("Tangentlikning y =", tangent)
print("Differanse mot oppgitt uttrykk =", simplify(tangent - expected))
print("Kontroll i x=a: y =", simplify(tangent.subs(x, a)))

f'(x) = -sin(x)
Stigningstall f'(a) = -sin(a)
Tangentlikning y = a*sin(a) - x*sin(a) + cos(a)
Differanse mot oppgitt uttrykk = 0
Kontroll i x=a: y = cos(a)

Fasit: Tangentlikningen er \(y=-(\sin a)x+a\sin a+\cos a\).

Hva spør oppgaven om? B er skjæringen med y-aksen og finnes ved x=0. A er skjæringen med x-aksen og finnes ved y=0. Trekanten er rettvinklet, så arealet er halvparten av produktet av katetene.

Steg 1 — Finn B ved å sette \(x=0\)

Steg 2 — Finn A ved å sette \(y=0\)

Steg 3 — Flytt x-leddet

Steg 4 — Divider med \(\sin a\)

Steg 5 — Identifiser katetene

Steg 6 — Bruk trekantarealet

Steg 7 — Sett inn lengdene

from sympy import symbols, sin, cos, simplify, factor

a = symbols('a', positive=True)
x_intercept = simplify((a*sin(a) + cos(a))/sin(a))
y_intercept = a*sin(a) + cos(a)
area = simplify(x_intercept*y_intercept/2)
expected = (a*sin(a) + cos(a))*(a + cos(a)/sin(a))/2

print("x-koordinaten til A =", x_intercept)
print("y-koordinaten til B =", y_intercept)
print("Trekantareal =", area)
print("Faktorisert areal =", factor(area))
print("Differanse mot oppgitt formel =", simplify(area - expected))

x-koordinaten til A = a + 1/tan(a)
y-koordinaten til B = a*sin(a) + cos(a)
Trekantareal = (a*sin(a) + cos(a))**2/(2*sin(a))
Faktorisert areal = (a*sin(a) + cos(a))**2/(2*sin(a))
Differanse mot oppgitt formel = 0

Fasit: \(A=(a+\cot a,0)\), \(B=(0,a\sin a+\cos a)\), og arealformelen er vist.

Hva spør oppgaven om? Det fargelagte området er hele trekanten OAB minus arealet under cosinusgrafen fra 0 til π/2. Det sistnevnte arealet er et enkelt bestemt integral.

Steg 1 — Beskriv oppdelingen

Steg 2 — Sett opp arealet under grafen

Steg 3 — Integrer

Steg 4 — Sett inn grensene

Steg 5 — Trekk fra trekantarealet

Steg 6 — Sett inn \(A_{\cos}=1\)

Steg 7 — Skriv funksjonen eksplisitt

from sympy import symbols, cos, sin, pi, integrate, simplify

x, a = symbols('x a', positive=True)
area_under_cos = integrate(cos(x), (x, 0, pi/2))
triangle_area = (a*sin(a) + cos(a))*(a + cos(a)/sin(a))/2
T = simplify(triangle_area - area_under_cos)

print("Areal under cos(x) fra 0 til pi/2 =", area_under_cos)
print("Trekantareal =", triangle_area)
print("T(a) =", T)

Areal under cos(x) fra 0 til pi/2 = 1
Trekantareal = (a + cos(a)/sin(a))*(a*sin(a) + cos(a))/2
T(a) = (a*sin(a) + cos(a))**2/(2*sin(a)) - 1

Fasit: \(\displaystyle T(a)=F_{\triangle OAB}-1\).

Hva spør oppgaven om? Vi legger inn arealfunksjonen i et digitalt verktøy med riktig definisjonsområde. Grafen faller først, har ett minimum og stiger deretter mot en endelig grenseverdi.

Steg 1 — Skriv funksjonen

Steg 2 — Angi området

\[\frac15

Steg 3 — Legg inn i GeoGebra

Bruk kommandoen Function(T,1/5,pi/2) etter at \(T\) er definert.

Steg 4 — Velg egnet vindu

Et vindu med a-akse fra 0,2 til 1,57 og T-akse fra 0 til omtrent 2 viser hele den relevante formen.

Steg 5 — Les hovedtrekkene

Grafen synker bratt fra venstre, når et minimum nær \(a=0,86\), og stiger deretter svakt.

Steg 6 — Kontroller noen verdier

\[T(0{,}2)\approx1{,}617,\qquad T(0{,}9)\approx0{,}123,\qquad T(1{,}5)\approx0{,}231.\]

GeoGebra / CAS-kontroll

GeoGebra · CAS

1

T(a)=1/2(a sin(a)+cos(a))(a+cos(a)/sin(a))-1

→\(T(a)\)

2

Function(T,1/5,pi/2)

→Graf på angitt intervall

Tolkning: Høyre endepunkt behandles som en grenseverdi fordi intervallet er åpent der.

Python-kontroll med SymPy

Python 3Kjørt kontroll

from sympy import symbols, sin, cos, pi, N

a = symbols('a', positive=True)
T = (a*sin(a) + cos(a))*(a + cos(a)/sin(a))/2 - 1

print("T(a) =", T)
for value in [0.2, 0.5, 0.9, 1.2, 1.5]:
    print(f"T({value}) = {N(T.subs(a, value), 15)}")
print("Høyre intervallgrense pi/2 =", N(pi/2, 15))

T(a) = (a + cos(a)/sin(a))*(a*sin(a) + cos(a))/2 - 1
T(0.2) = 1.61739681062279
T(0.5) = 0.301921525435354
T(0.9) = 0.123336021758435
T(1.2) = 0.176336093139747
T(1.5) = 0.230795821252451
Høyre intervallgrense pi/2 = 1.57079632679490

Fasit: Grafen er vist nedenfor; den har et minimum nær \(a=0{,}8603\).

Vanlig feil: Å inkludere a=0, der uttrykket inneholder divisjon med sin a og ikke er definert.

Sensorpunkt: Sensor ser etter korrekt funksjon, korrekt intervall og et grafvindu som viser minimumet tydelig.

Hva spør oppgaven om? Vi forenkler T, deriverer og finner den eneste kritiske verdien i intervallet. Deretter beregner vi minimumet numerisk og tar grenseverdien mot π/2.

Steg 1 — Forenkle arealfunksjonen

Steg 2 — Deriver og faktoriser

Steg 3 — Analyser faktorene i intervallet

Steg 4 — Finn kritisk verdi

Steg 5 — Klassifiser

Steg 6 — Beregn minimumsarealet

Steg 7 — Finn grenseverdien mot \(\pi/2\)

Steg 8 — Oppgi numerisk grense

from sympy import symbols, sin, cos, tan, pi, diff, factor, nsolve, limit, N

a = symbols('a', positive=True)
T = (a*sin(a) + cos(a))*(a + cos(a)/sin(a))/2 - 1
T_prime = factor(diff(T, a))
critical = nsolve(a*tan(a) - 1, 0.85, prec=50)
minimum = N(T.subs(a, critical), 30)
right_limit = limit(T, a, pi/2, dir='-')

print("T(a) =", T)
print("Faktorisert T'(a) =", T_prime)
print("Løsning av a*tan(a)=1 =", critical)
print("T_min =", minimum)
print("Grenseverdi når a -> pi/2 fra venstre =", right_limit)
print("Numerisk grenseverdi =", N(right_limit, 30))

T(a) = (a + cos(a)/sin(a))*(a*sin(a) + cos(a))/2 - 1
Faktorisert T'(a) = (a*sin(a) - cos(a))*(a*sin(a) + cos(a))*cos(a)/(2*sin(a)**2)
Løsning av a*tan(a)=1 = 0.86033358901937976248389342413766233341188436323765
T_min = 0.122192676382090135080807506322
Grenseverdi når a -> pi/2 fra venstre = -1 + pi**2/8
Numerisk grenseverdi = 0.233700550136169827354311374985

Fasit: \(a\approx0{,}86033\) gir \(T_{\min}\approx0{,}12219\). Når \(a\to\pi/2\), går \(T(a)\to\pi^2/8-1\approx0{,}23370\).