# cas > Pinned bounded external symbolic-computation operations. > 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")`