| intro | Introduces a sympy variable with specified assumptions and stores it. Takes a variable name and a list of positive and negative assumptions. |
| intro_many | Introduces multiple sympy variables with specified assumptions and stores them. Takes a list of VariableDefinition objects for the 'variables' parameter.
Each object in the list specifies:
- var_name: The name of the variable (string).
- pos_assumptions: A list of positive assumption strings (e.g., ["real", "positive"]).
- neg_assumptions: A list of negative assumption strings (e.g., ["complex"]).
The JSON payload for the 'variables' argument should be a direct list of these objects, for example:
```json
[
{
"var_name": "x",
"pos_assumptions": ["real", "positive"],
"neg_assumptions": ["complex"]
},
{
"var_name": "y",
"pos_assumptions": [],
"neg_assumptions": ["commutative"]
}
]
```
The assumptions must be consistent, so a real number is not allowed to be non-commutative.
Prefer this over intro() for multiple variables because it's more efficient. |
| introduce_expression | Parses a sympy expression string using available local variables and stores it. Assigns it to either a temporary name (expr_0, expr_1, etc.) or a user-specified global name. Uses Sympy parse_expr to parse the expression string.
Applies default Sympy canonicalization rules unless canonicalize is False.
For equations (x^2 = 1) make the input string "Eq(x^2, 1") not "x^2 == 1"
Examples:
{expr_str: "Eq(x^2 + y^2, 1)"}
{expr_str: "Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))"}
{expr_str: "pi+e", "expr_var_name": "z"} |
| print_latex_expression | Prints a stored expression in LaTeX format, along with variable assumptions. |
| solve_algebraically | Solves an equation (expression = 0) algebraically for a given variable. Args:
expr_key: The key of the expression (previously introduced) to be solved.
solve_for_var_name: The name of the variable (previously introduced) to solve for.
domain: The domain to solve in: Domain.COMPLEX, Domain.REAL, Domain.INTEGERS, or Domain.NATURALS. Defaults to Domain.COMPLEX.
Returns:
A LaTeX string representing the set of solutions. Returns an error message string if issues occur. |
| solve_linear_system | Solves a system of linear equations using SymPy's linsolve. Args:
expr_keys: The keys of the expressions (previously introduced) forming the system.
var_names: The names of the variables to solve for.
domain: The domain to solve in (Domain.COMPLEX, Domain.REAL, etc.). Defaults to Domain.COMPLEX.
Returns:
A LaTeX string representing the solution set. Returns an error message string if issues occur. |
| solve_nonlinear_system | Solves a system of nonlinear equations using SymPy's nonlinsolve. Args:
expr_keys: The keys of the expressions (previously introduced) forming the system.
var_names: The names of the variables to solve for.
domain: The domain to solve in (Domain.COMPLEX, Domain.REAL, etc.). Defaults to Domain.COMPLEX.
Returns:
A LaTeX string representing the solution set. Returns an error message string if issues occur. |
| introduce_function | Introduces a SymPy function variable and stores it. Takes a function name and creates a SymPy Function object for use in defining differential equations.
Example:
{func_name: "f"} will create the function f(x), f(t), etc. that can be used in expressions
Returns:
The name of the created function. |
| dsolve_ode | Solves an ordinary differential equation using SymPy's dsolve function. Args:
expr_key: The key of the expression (previously introduced) containing the differential equation.
func_name: The name of the function (previously introduced) to solve for.
hint: Optional solving method from ODEHint enum. If None, SymPy will try to determine the best method.
Example:
# First introduce a variable and a function
intro("x", [Assumption.REAL], [])
introduce_function("f")
# Create a second-order ODE: f''(x) + 9*f(x) = 0
expr_key = introduce_expression("Derivative(f(x), x, x) + 9*f(x)")
# Solve the ODE
result = dsolve_ode(expr_key, "f")
# Returns solution with sin(3*x) and cos(3*x) terms
Returns:
A LaTeX string representing the solution. Returns an error message string if issues occur. |
| pdsolve_pde | Solves a partial differential equation using SymPy's pdsolve function. Args:
expr_key: The key of the expression (previously introduced) containing the PDE.
If the expression is not an equation (Eq), it will be interpreted as
PDE = 0.
func_name: The name of the function (previously introduced) to solve for.
This should be a function of multiple variables.
Example:
# First introduce variables and a function
intro("x", [Assumption.REAL], [])
intro("y", [Assumption.REAL], [])
introduce_function("f")
# Create a PDE: 1 + 2*(ux/u) + 3*(uy/u) = 0
expr_key = introduce_expression(
"Eq(1 + 2*Derivative(f(x, y), x)/f(x, y) + 3*Derivative(f(x, y), y)/f(x, y), 0)"
)
# Solve the PDE
result = pdsolve_pde(expr_key, "f")
# Returns solution with exponential terms and arbitrary function
Returns:
A LaTeX string representing the solution. Returns an error message string if issues occur. |
| create_predefined_metric | Creates a predefined spacetime metric. |
| search_predefined_metrics | Searches for predefined metrics in einsteinpy.symbolic.predefined. |
| calculate_tensor | Calculates a tensor from a metric using einsteinpy.symbolic. |
| create_custom_metric | Creates a custom metric tensor from provided components and symbols. |
| print_latex_tensor | Prints a stored tensor expression in LaTeX format. |
| simplify_expression | Simplifies a mathematical expression using SymPy's simplify function. Args:
expr_key: The key of the expression (previously introduced) to simplify.
Example:
# Introduce variables
intro("x", [Assumption.REAL], [])
intro("y", [Assumption.REAL], [])
# Create an expression to simplify: sin(x)^2 + cos(x)^2
expr_key = introduce_expression("sin(x)**2 + cos(x)**2")
# Simplify the expression
simplified = simplify_expression(expr_key)
# Returns 1
Returns:
A key for the simplified expression. |
| integrate_expression | Integrates an expression with respect to a variable using SymPy's integrate function. Args:
expr_key: The key of the expression (previously introduced) to integrate.
var_name: The name of the variable to integrate with respect to.
lower_bound: Optional lower bound for definite integration.
upper_bound: Optional upper bound for definite integration.
Example:
# Introduce a variable
intro("x", [Assumption.REAL], [])
# Create an expression to integrate: x^2
expr_key = introduce_expression("x**2")
# Indefinite integration
indefinite_result = integrate_expression(expr_key, "x")
# Returns x³/3
# Definite integration from 0 to 1
definite_result = integrate_expression(expr_key, "x", "0", "1")
# Returns 1/3
Returns:
A key for the integrated expression. |
| differentiate_expression | Differentiates an expression with respect to a variable using SymPy's diff function. Args:
expr_key: The key of the expression (previously introduced) to differentiate.
var_name: The name of the variable to differentiate with respect to.
order: The order of differentiation (default is 1 for first derivative).
Example:
# Introduce a variable
intro("x", [Assumption.REAL], [])
# Create an expression to differentiate: x^3
expr_key = introduce_expression("x**3")
# First derivative
first_deriv = differentiate_expression(expr_key, "x")
# Returns 3x²
# Second derivative
second_deriv = differentiate_expression(expr_key, "x", 2)
# Returns 6x
Returns:
A key for the differentiated expression. |
| create_coordinate_system | Creates a 3D coordinate system for vector calculus operations. Args:
name: The name for the coordinate system.
coord_names: Optional list of coordinate names (3 names for x, y, z).
If not provided, defaults to [name+'_x', name+'_y', name+'_z'].
Example:
# Create a coordinate system
coord_sys = create_coordinate_system("R")
# Creates a coordinate system R with coordinates R_x, R_y, R_z
# Create a coordinate system with custom coordinate names
coord_sys = create_coordinate_system("C", ["rho", "phi", "z"])
Returns:
The name of the created coordinate system. |
| create_vector_field | Creates a vector field in the specified coordinate system. Args:
coord_sys_name: The name of the coordinate system to use.
component_x: String expression for the x-component of the vector field.
component_y: String expression for the y-component of the vector field.
component_z: String expression for the z-component of the vector field.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a vector field F = (y, -x, z)
vector_field = create_vector_field("R", "R_y", "-R_x", "R_z")
Returns:
A key for the vector field expression. |
| calculate_curl | Calculates the curl of a vector field using SymPy's curl function. Args:
vector_field_key: The key of the vector field expression.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a vector field F = (y, -x, 0)
vector_field = create_vector_field("R", "R_y", "-R_x", "0")
# Calculate curl
curl_result = calculate_curl(vector_field)
# Returns (0, 0, -2)
Returns:
A key for the curl expression. |
| calculate_divergence | Calculates the divergence of a vector field using SymPy's divergence function. Args:
vector_field_key: The key of the vector field expression.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a vector field F = (x, y, z)
vector_field = create_vector_field("R", "R_x", "R_y", "R_z")
# Calculate divergence
div_result = calculate_divergence(vector_field)
# Returns 3
Returns:
A key for the divergence expression. |
| calculate_gradient | Calculates the gradient of a scalar field using SymPy's gradient function. Args:
scalar_field_key: The key of the scalar field expression.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a scalar field f = x^2 + y^2 + z^2
scalar_field = introduce_expression("R_x**2 + R_y**2 + R_z**2")
# Calculate gradient
grad_result = calculate_gradient(scalar_field)
# Returns (2x, 2y, 2z)
Returns:
A key for the gradient vector field expression. |
| convert_to_units | Converts a quantity to the given target units using sympy.physics.units.convert_to. Args:
expr_key: The key of the expression (previously introduced) to convert.
target_units: List of unit names as strings (e.g., ["meter", "1/second"]).
unit_system: Optional unit system (from UnitSystem enum). Defaults to SI.
The following units are available by default:
SI base units: meter, second, kilogram, ampere, kelvin, mole, candela
Length: kilometer, millimeter
Mass: gram
Energy: joule
Force: newton
Pressure: pascal
Power: watt
Electric: coulomb, volt, ohm, farad, henry
Constants: speed_of_light, gravitational_constant, planck
IMPORTANT: For compound units like meter/second, you must separate the numerator and
denominator into separate units in the list. For example:
- For meter/second: use ["meter", "1/second"]
- For newton*meter: use ["newton", "meter"]
- For kilogram*meter²/second²: use ["kilogram", "meter**2", "1/second**2"]
Example:
# Convert speed of light to kilometers per hour
expr_key = introduce_expression("speed_of_light")
result = convert_to_units(expr_key, ["kilometer", "1/hour"])
# Returns approximately 1.08e9 kilometer/hour
# Convert gravitational constant to CGS units
expr_key = introduce_expression("gravitational_constant")
result = convert_to_units(expr_key, ["centimeter**3", "1/gram", "1/second**2"], UnitSystem.CGS)
SI prefixes (femto, pico, nano, micro, milli, centi, deci, deca, hecto, kilo, mega, giga, tera)
can be used directly with base units.
Returns:
A key for the converted expression, or an error message. |
| quantity_simplify_units | Simplifies a quantity with units using sympy's built-in simplify method for Quantity objects. Args:
expr_key: The key of the expression (previously introduced) to simplify.
unit_system: Optional unit system (from UnitSystem enum). Not used with direct simplify method.
The following units are available by default:
SI base units: meter, second, kilogram, ampere, kelvin, mole, candela
Length: kilometer, millimeter
Mass: gram
Energy: joule
Force: newton
Pressure: pascal
Power: watt
Electric: coulomb, volt, ohm, farad, henry
Constants: speed_of_light, gravitational_constant, planck
Example:
# Simplify force expressed in base units
expr_key = introduce_expression("kilogram*meter/second**2")
result = quantity_simplify_units(expr_key)
# Returns newton (as N = kg·m/s²)
# Simplify a complex expression with mixed units
expr_key = introduce_expression("joule/(kilogram*meter**2/second**2)")
result = quantity_simplify_units(expr_key)
# Returns a dimensionless quantity (1)
# Simplify electrical power expression
expr_key = introduce_expression("volt*ampere")
result = quantity_simplify_units(expr_key)
# Returns watt
Example with Speed of Light:
# Introduce the speed of light
c_key = introduce_expression("speed_of_light")
# Convert to kilometers per hour
km_per_hour_key = convert_to_units(c_key, ["kilometer", "1/hour"])
# Simplify to get the numerical value
simplified_key = quantity_simplify_units(km_per_hour_key)
# Print the result
print_latex_expression(simplified_key)
# Shows the numeric value of speed of light in km/h
Returns:
A key for the simplified expression, or an error message. |
| reset_state | Resets the state of the SymPy MCP server. Clears all stored variables, functions, expressions, metrics, tensors,
coordinate systems, and resets the expression counter.
Then reinitializes unit variables.
Runs after all tool calls for a given computation are done to reset the state for the next computation.
Returns:
A message confirming the reset. |
| create_matrix | Creates a SymPy matrix from the provided data. Args:
matrix_data: A list of lists representing the rows and columns of the matrix.
Each element can be a number or a string expression.
matrix_var_name: Optional name for storing the matrix. If not provided, a
sequential name will be generated.
Example:
# Create a 2x2 matrix with numeric values
matrix_key = create_matrix([[1, 2], [3, 4]], "M")
# Create a matrix with symbolic expressions (assuming x, y are defined)
matrix_key = create_matrix([["x", "y"], ["x*y", "x+y"]])
Returns:
A key for the stored matrix. |
| matrix_determinant | Calculates the determinant of a matrix using SymPy's det method. Args:
matrix_key: The key of the matrix to calculate the determinant for.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [3, 4]])
# Calculate its determinant
det_key = matrix_determinant(matrix_key)
# Results in -2
Returns:
A key for the determinant expression. |
| matrix_inverse | Calculates the inverse of a matrix using SymPy's inv method. Args:
matrix_key: The key of the matrix to invert.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [3, 4]])
# Calculate its inverse
inv_key = matrix_inverse(matrix_key)
Returns:
A key for the inverted matrix. |
| matrix_eigenvalues | Calculates the eigenvalues of a matrix using SymPy's eigenvals method. Args:
matrix_key: The key of the matrix to calculate eigenvalues for.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [2, 1]])
# Calculate its eigenvalues
evals_key = matrix_eigenvalues(matrix_key)
Returns:
A key for the eigenvalues expression (usually a dictionary mapping eigenvalues to their multiplicities). |
| matrix_eigenvectors | Calculates the eigenvectors of a matrix using SymPy's eigenvects method. Args:
matrix_key: The key of the matrix to calculate eigenvectors for.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [2, 1]])
# Calculate its eigenvectors
evecs_key = matrix_eigenvectors(matrix_key)
Returns:
A key for the eigenvectors expression (usually a list of tuples (eigenvalue, multiplicity, [eigenvectors])). |
| substitute_expression | Substitutes a variable in an expression with another expression using SymPy's subs method. Args:
expr_key: The key of the expression to perform substitution on.
var_name: The name of the variable to substitute.
replacement_expr_key: The key of the expression to substitute in place of the variable.
Example:
# Create variables x and y
intro("x", [], [])
intro("y", [], [])
# Create expressions
expr1 = introduce_expression("x**2 + y**2")
expr2 = introduce_expression("sin(x)")
# Substitute y with sin(x) in x^2 + y^2
result = substitute_expression(expr1, "y", expr2)
# Results in x^2 + sin^2(x)
Returns:
A key for the resulting expression after substitution. |