Explore exact forms and abstract derivatives together

.symbolic loads the formal and Calculus workspaces while preserving the focused plugin mounts and aliases.

Runnable RiXRun cell

.Plugin.Load("symbolic"); fraction := .frac(6,8); form := .ff`(x^2-1)/(x-1)`; canonical := form.R(); {: fraction, form.Form(), canonical(3), .symbolic.Services() };

Use .fraction, .fracfun, or .calculus directly when only one focused surface is needed.

Find the right transformation owner

The Symbolic registry is a catalog, not another transformation engine. Query it when you know the representation or intent but not the focused API:

Runnable RiXRun cell

.Plugin.Load("symbolic"); formal := .symbolic.Transformations({= input=:FractionFunction }); canonical := .symbolic.Transformations({= owner=:ratfun }); chosen := .symbolic.Transformation("fracfun.cancel"); .Table({= columns=["id", "owner", "domain policy", "call"], rows=formal.Map((entry)->[ entry[:id], entry[:owner], entry[:domainPolicy], entry[:call] ]) }); {: canonical.Map((entry)->entry[:id]), chosen[:summary] };

Descriptors are immutable documentation records. They do not contain executable handlers: call the named owner directly. The domainPolicy field makes the important distinction between a source-domain-preserving rewrite such as Cancel and the explicit ForgetRestrictions escape hatch.

Simplify without filling domain holes

The shared checked simplifier handles unconditional neutral identities and returns its complete transformation record:

Runnable RiXRun cell

.Plugin.Load("symbolic"); x := .calculus.Variable(:x); safe := .symbolic.SimplifyResult(-(-(x+0))); unsafe := .symbolic.SimplifyResult(x/x); {: safe[:targetGraph], safe[:checker][:accepted], unsafe[:changed], .symbolic.CheckSimplification(unsafe)[:accepted] };

x/x stays unchanged because replacing it by one would fill the hole at zero. Conditional identities will require explicit, checkable assumptions; a bare Symbolic request is not authority to change a partial function's domain.

Cross into a portable Calculus expression

FractionFunction's displayed form crosses the same public schema as a core {#} specification:

Runnable RiXRun cell

.Plugin.Load("symbolic"); F := .ff`(x+1)*(x-1)`; expression := .symbolic.CalculusExpression(F); fromSpec := .symbolic.CalculusExpression({#t# t^2+1}); {: .calculus.ToSpec(expression), .calculus.ToSpec(fromSpec) };

Differentiate unconditional expressions

.symbolic.Differentiate delegates to Calculus and returns a bare expression when no condition would be lost:

Runnable RiXRun cell

.Plugin.Load("symbolic"); x := .calculus.Variable(:x); Exp := .calculus.Exp(); derivative := .symbolic.Differentiate(Exp(x^2+1), :x); .calculus.ToSpec(derivative);

Preserve quotient domains and function branches

Use DifferentiateResult whenever a formula has conditions. The result keeps the transformed expression, obligations, and rule evidence together:

Runnable RiXRun cell

.Plugin.Load("symbolic"); x := .calculus.Variable(:x); logResult := .symbolic.DifferentiateResult(.calculus.Log()(x^2), :x); form := .ff`(x^2-1)/(x-1)`; formResult := .symbolic.DifferentiateResult(form, :x); .Table({= columns=["source", "derivative", "obligations"], rows=[ ["Log(x^2)", .calculus.ToSpec(logResult[:expression]), logResult[:obligations]], [form.Form(), .calculus.ToSpec(formResult[:expression]), formResult[:obligations]] ] });

Log requires a positive real argument. The quotient requires its denominator to be nonzero. Real-principal Sqrt and Asin, and principal ComplexLog, use the same contract for their domain or branch requirements.

Keep cancelled holes visible

A cancelled FractionFunction has a different display form but retains its source-domain evaluation expression. Symbolic exposes both and converts the stored denominator into a Calculus obligation:

Runnable RiXRun cell

.Plugin.Load("symbolic"); F := .ff`(x^2-1)/(x-1)`; C := F.Cancel(); {: .calculus.ToSpec(C.CalculusExpression()), .calculus.ToSpec(C.EvaluationCalculusExpression()), .symbolic.Obligations(C), C.Domain().Get("calculusRestrictions") };

Evaluate through linked numerical implementations

The Symbolic façade can evaluate a Calculus expression or transformation while retaining the implementation links and unresolved conditions:

Runnable RiXRun cell

.Plugin.Load("symbolic"); .Plugin.Load("numerics"); x := .calculus.Variable(:x); Exp := .calculus.Exp((value)->.numerics.Exp(value)); Log := .calculus.Log((value)->.numerics.Ln(value)); derivative := .symbolic.DifferentiateResult(Exp(Log(x)),:x); evaluation := .symbolic.EvaluateResult(derivative,{= x=2 }); {: .calculus.ToSpec(derivative[:expression]), evaluation[:links].Map((link)->link[:semanticId]), evaluation[:obligationValues] };

Differentiation uses exact semantic rules. Evaluation separately follows the linked providers. Seeing that an obligation's subject is 2 does not by itself mark the positivity obligation proved.

Use higher and multivariate façades

Runnable RiXRun cell

.Plugin.Load("symbolic"); P := .ff`x^3+x`; second := .symbolic.DifferentiateN(P,:x,2); gradient := .symbolic.Gradient({#x,y# x^2+x*y },[:x,:y]); {: .calculus.ToSpec(second), .symbolic.Evaluate(second,{= x=3 }), gradient.Map((expression)->.calculus.ToSpec(expression)) };

Jacobian, Hessian, and each corresponding ...Result form follow the same variable ordering and obligation rules as the focused Calculus API.

Use the shared derivative graph and integral façades

Symbolic exposes Calculus reuse rather than introducing a second differentiator:

Runnable RiXRun cell

.Plugin.Load("symbolic"); x := .calculus.Variable(:x); Exp := .calculus.Exp((value)->value+1); derivative := .symbolic.DifferentiateResult(Exp(x)^2,:x); evaluation := .symbolic.EvaluateResult(derivative,{= x=2 }); {: .calculus.ToSpec(derivative[:expression]), derivative[:evidence], evaluation[:semanticEvaluations] };

The result uses the exact differential identity D Exp = Exp to retain 2*Exp(x)^2; general exponential-product normalization remains a distinct symbolic transformation.

The integral façades accept Calculus expressions, core specifications, and FractionFunctions:

Runnable RiXRun cell

.Plugin.Load("symbolic"); F := .ff`1/x`; x := .calculus.Variable(:x); family := .symbolic.AntiderivativeFamily(F,:x,.calculus.Log()(x),:C); definite := .symbolic.DefiniteIntegral(F,:x,1,2); {: family, definite };

FractionFunction's original nonzero-denominator obligation is copied into both integral records. These are formulation records, not automatic integration or proof results.