Course-level symbolic forms and integration

Load one isolated CAS surface. Its dependencies remain ordinary focused RiX plugins rather than an external computer-algebra process.

Normalize without losing evidence

Runnable RiXRun cell

.Plugin.Load("cas"); x := .calculus.Variable(:x); source := (x+1)*(x-1); collected := .cas.Collect(source,:x); expanded := .cas.Expand(source,:x); factored := .cas.Factor(source,:x); {: collected[:coefficients],expanded[:operation],factored[:factors].Len() };

Integrate a specialized Polynomial directly

A collected Polynomial stores exact coefficients and its mathematical variable name. CAS can integrate that value directly, not just the original expression graph. The returned antiderivative is still a Calculus expression graph.

Runnable RiXRun cell

.Plugin.Load("cas"); t := .calculus.Variable(:t); polynomial := .cas.Collect(t^3+2*t,:t)[:polynomial]; integral := .cas.Integrate(polynomial); replay := .cas.CheckIntegral(integral); integral[:status]==:complete ?: 1 ?_ .Error("Polynomial integration failed"); integral[:variable]==:t ?: 1 ?_ .Error("Expected the Polynomial's variable"); replay[:accepted]==1 ?: 1 ?_ .Error("Polynomial rule replay failed"); {: polynomial.Coefficients(:ascending),integral[:antiderivative],integral[:rules] };

The primitive represents t^4/4+t^2, with the arbitrary additive constant omitted. CAS reads :t from the Polynomial even though Integrate defaults to :x for expression-graph inputs. Zero and constant Polynomial values use the same coefficient rule.

Walk the integration ladder

Runnable RiXRun cell

.Plugin.Load("cas"); x := .calculus.Variable(:x); Exp := .calculus.Exp(); Log := .calculus.Log(); examples := [ .cas.Integrate(3*x^2+4,x), .cas.Integrate((2*x+3)^4,x), .cas.Integrate(Exp(2*x+3),x), .cas.Integrate(x^2*Exp(x),x), .cas.Integrate(Log(2*x+1),x) ]; .Table({= columns=["status","antiderivative","rules","obligations"], rows=examples.Map((result)->[ result[:status],result[:antiderivative],result[:rules],result[:obligations] ]) });

The logarithm row has a positive-argument obligation because Log(2*x+1) is the source function. A reciprocal uses a different, global real primitive:

Runnable RiXRun cell

.Plugin.Load("cas"); x := .calculus.Variable(:x); reciprocal := .cas.Integrate(1/x,x); {: reciprocal[:antiderivative],reciprocal[:obligations], .cas.CheckIntegral(reciprocal)[:accepted] };

Its result is a public Log(Abs(x)) graph with the exact obligation x != 0, not a false positivity restriction.

Add the common trigonometric and quadratic cases

Runnable RiXRun cell

.Plugin.Load("cas"); x := .calculus.Variable(:x); Sin := .calculus.Sin(); Cos := .calculus.Cos(); sine := .cas.Integrate(Sin(2*x+1),x); cosine := .cas.Integrate(Cos(3*x-2),x); quadratic := .cas.Integrate(.rf`1/(x^2+1)`); .Table({= columns=["source family","antiderivative","last rule"], rows=[ ["affine sine",sine[:antiderivative],sine[:rules].Last()], ["affine cosine",cosine[:antiderivative],cosine[:rules].Last()], ["irreducible quadratic",quadratic[:antiderivative],quadratic[:rules].Last()] ] });

The quadratic rule proves the negative discriminant condition exactly and retains the completed-square coefficients.

Reduce powers and products

The power rule lowers the exponent by two at each step. The product rule changes two factors into a sum/difference of harmonics. Neither needs a general identity-search engine.

Runnable RiXRun cell

.Plugin.Load("cas"); x := .calculus.Variable(:x); Sin := .calculus.Sin(); Cos := .calculus.Cos(); sources := [Sin(2*x+1)^4,Cos(x)^3,Sin(x)*Cos(3*x),Sin(x)*Sin(x)]; integrals := sources.Map((source)->.cas.Integrate(source,x)); integrals.Map((result)->{; .cas.CheckIntegral(result)[:accepted] ?: 1 ?_ .Error("Trig rule replay failed"); {: result[:antiderivative],result[:rules].Last() }; });

For the last row, the difference frequency is zero. Its cosine term is a constant, so the primitive includes x/2; the implementation does not divide by a zero frequency. Compare this product route with Sin(x)^2 and differentiate both answers: primitives may look different and still differ only by a constant.

Runnable RiXRun cell

.Plugin.Load("cas"); x := .calculus.Variable(:x); Sin := .calculus.Sin(); tooLarge := .cas.Integrate(Sin(x)^9,x); tooLarge[:reason]==:trigonometricDegreeBudgetExceeded ?: 1 ?_ .Error("Expected a bounded unsupported result"); {: tooLarge[:status],tooLarge[:reason] };

Nonnegative integer powers through degree 8 are supported. Mixed powers and nonaffine arguments remain explicit unsupported cases, not guessed answers.

Let exact partial fractions do the algebra

Runnable RiXRun cell

.Plugin.Load("cas"); rational := .rf`(2*x+3)/(x^2-1)`; integral := .cas.Integrate(rational); replay := .cas.CheckIntegral(integral); {: integral[:antiderivative],integral[:obligations],replay[:accepted] };

The RationalFunction service proves the decomposition; CAS integrates the polynomial and linear-factor terms. The log obligations retain the selected real branches.

Unsupported is a useful result

Runnable RiXRun cell

.Plugin.Load("cas"); x := .calculus.Variable(:x); Sqrt := .calculus.Sqrt(); unsupported := .cas.Integrate(Sqrt(x^2+1),x); {: unsupported[:status],unsupported[:reason],unsupported[:antiderivative] };

This integral has a closed form involving inverse hyperbolic functions, but it is outside the current course ladder. A visible unsupported record is safer and more educational than a guessed transformation.

Keep diagnostics separate from the successful computation

CAS uses ?_> both in helper prep lists and inside selected rule branches. You can use the same style when consuming its results. This helper propagates an unsupported record before attempting to differentiate a missing primitive:

Runnable RiXRun cell

.Plugin.Load("cas"); DifferentiateIntegral(source, variable) ?!- [ integral = .cas.Integrate(source,variable), integral[:status]==:complete ?_> integral ] -> .calculus.PartialResult(integral[:antiderivative],variable); x := .calculus.Variable(:x); Sin := .calculus.Sin(); supported := DifferentiateIntegral(Sin(2*x+1),x); unsupported := DifferentiateIntegral(Sin(x^2),x); unsupported[:reason]==:nonAffineSineArgument ?: 1 ?_ .Error("Expected the original CAS diagnostic"); {: supported[:expression],unsupported[:status],unsupported[:reason] };

The check describes what must hold to continue. Its diagnostic is evaluated only on failure, and returns from the function call. Inside a function body, the same check can follow intermediate work, including inside a branch block. Do not use it at tutorial top level: there is no function call to return from. ??> handles undecided checks; an explicit CAS :unsupported result is a decided status and uses ?_>, not ??>.

Further work

1. Differentiate each returned antiderivative and compare it with the source. 2. Try repeated linear factors such as 1/(x-1)^2 through .rf. 3. Compare the source-domain obligation for Log(x) with the reciprocal-domain obligation for 1/x. 4. Derive the completed-square formula used for (m*x+n)/(a*x^2+b*x+c) when 4*a*c-b^2 > 0. 5. Derive the two-degree power recurrence by integration by parts, then compare its answer for Sin(x)^2 with the product-to-sum route.

Bounded course continuation

See [the executable course calculus guide](../../documentation/eval/course-calculus.md) for mixed powers, radicals, definite integrals, local domain rewrites, and inert equation/declared-derivative records. It includes exact, bounded-failure and explicitly approximate examples.