cas

Generated by sema doc from the compiler’s authoritative native-signature registry.

cas (native adapter)

Pinned CPython 3.12.12 / SymPy 1.14.0 symbolic producer — bring it in with import cas; calls require proc.run and use a safe non-evaluating expression grammar. External CAS output is unverified immutable evidence.

symbolic_algebra

`cas.simplify(source) -> CasResult`

Simplify an allowlisted mathematical expression with pinned SymPy and return immutable, digest-bound, explicitly unverified CasResult evidence.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.simplify("sin(x)^2 + cos(x)^2")

`cas.expand(source) -> CasResult`

Expand products and powers through the bounded external CAS worker.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.expand("(x + y)^4")

`cas.factor(source) -> CasResult`

Factor a symbolic expression over SymPy’s inferred domain; output remains unverified.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.factor("x^4 - 1")

`cas.cancel(source) -> CasResult`

Cancel common rational-expression factors without claiming the omitted domain conditions are proved.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.cancel("(x^2 - 1) / (x - 1)")

`cas.together(source) -> CasResult`

Combine rational terms over a common denominator.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.together("1/x + 1/y")

`cas.differentiate(source, variable) -> CasResult`

Differentiate a broad elementary or special-function expression with respect to one named symbol.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.differentiate("exp(x) * sin(x)", "x")

`cas.integrate(source, variable) -> CasResult`

Request an indefinite symbolic integral; unevaluated Integral output is an honest successful CAS result, not a proof.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.integrate("exp(-x^2)", "x")

`cas.solve(source, variable) -> CasResult`

Solve one expression or equality for one named symbol and return the external producer’s symbolic result.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.solve("x^3 - 1", "x")

`cas.apart(source, variable) -> CasResult`

Compute a partial-fraction decomposition in one variable.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.apart("1 / (x * (x + 1))", "x")

`cas.collect(source, variable) -> CasResult`

Collect coefficients by powers of one named symbol.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.collect("a*x + b*x + x^2", "x")

`cas.limit(source, variable, point) -> CasResult`

Request a symbolic limit at one parsed point, including infinity constants admitted by the safe expression grammar.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.limit("sin(x) / x", "x", "0")

`cas.substitute(source, variable, replacement) -> CasResult`

Substitute one named symbol with another safely parsed expression.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.substitute("x^2 + y", "x", "z + 1")

`cas.laplace_transform(source, variable, target) -> CasResult`

Request a symbolic Laplace transform and retain convergence-condition output from SymPy.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.laplace_transform("exp(-a*x)", "x", "s")

`cas.inverse_laplace_transform(source, variable, target) -> CasResult`

Request a symbolic inverse Laplace transform.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.inverse_laplace_transform("1 / (s + a)", "s", "x")

`cas.fourier_transform(source, variable, target) -> CasResult`

Request a symbolic Fourier transform using SymPy’s convention.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.fourier_transform("exp(-x^2)", "x", "k")

`cas.inverse_fourier_transform(source, variable, target) -> CasResult`

Request a symbolic inverse Fourier transform using SymPy’s convention.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.inverse_fourier_transform("exp(-k^2)", "k", "x")

`cas.series(source, variable, point, order) -> CasResult`

Produce a symbolic series through a checked order in 1..64, retaining the order term.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.series("exp(x)", "x", "0", 12)

`cas.summation(source, variable, lower, upper) -> CasResult`

Request a symbolic finite or infinite sum over one named index.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.summation("k^2", "k", "1", "n")

`cas.product(source, variable, lower, upper) -> CasResult`

Request a symbolic finite or infinite product over one named index.

domain: safe non-evaluating mathematical expression grammar; 64 KiB per text argument, 10,000 AST nodes, depth 128, 16,384-bit literals, 256 KiB request, 1 MiB response, 512 MiB process-group RSS where host accounting is available, and 15 s per request; exact CPython 3.12.12 plus SymPy 1.14.0; governed runs deny until a production-confined subprocess runner exists
shape: scalar
returns: CasResult
effects: proc.run
example: cas.product("k", "k", "1", "n")