check_torque_balance

Instructions

Verifies whether a system of torques is balanced (net torque = 0).
Essential for rotational equilibrium and lever problems.

Args:
    torques: List of torque vectors [[x,y,z], ...] in N⋅m (or JSON string)
    tolerance: Tolerance for equilibrium check (fraction, default 0.01)

Returns:
    Dict containing:
        - net_torque: Net torque vector [x, y, z] in N⋅m
        - net_torque_magnitude: Net torque magnitude in N⋅m
        - is_balanced: Whether torques are in equilibrium
        - individual_magnitudes: Magnitude of each torque

Example - Seesaw balance:
    result = await check_torque_balance(
        torques=[[0, 0, 100], [0, 0, -100]],
        tolerance=0.01
    )

Implementation Reference

• src/chuk_mcp_physics/tools/statics.py:48-83 (handler)

  Async MCP tool handler that parses input, creates TorqueBalanceRequest, calls the core calculation, and returns the response dict.

  @tool  # type: ignore[arg-type]
  async def check_torque_balance(
      torques: list[list[float]] | str,
      tolerance: float = 0.01,
  ) -> dict:
      """Check if torques are in equilibrium: Στ = 0.
  
      Verifies whether a system of torques is balanced (net torque = 0).
      Essential for rotational equilibrium and lever problems.
  
      Args:
          torques: List of torque vectors [[x,y,z], ...] in N⋅m (or JSON string)
          tolerance: Tolerance for equilibrium check (fraction, default 0.01)
  
      Returns:
          Dict containing:
              - net_torque: Net torque vector [x, y, z] in N⋅m
              - net_torque_magnitude: Net torque magnitude in N⋅m
              - is_balanced: Whether torques are in equilibrium
              - individual_magnitudes: Magnitude of each torque
  
      Example - Seesaw balance:
          result = await check_torque_balance(
              torques=[[0, 0, 100], [0, 0, -100]],
              tolerance=0.01
          )
      """
      from ..statics import TorqueBalanceRequest
      from ..statics import check_torque_balance as check_torques
  
      if isinstance(torques, str):
          torques = json.loads(torques)
  
      request = TorqueBalanceRequest(torques=torques, tolerance=tolerance)
      response = check_torques(request)
      return response.model_dump()

• src/chuk_mcp_physics/statics.py:37-54 (schema)

  Pydantic model for torque balance input (torques, tolerance).

  class TorqueBalanceRequest(BaseModel):
      """Request for torque balance verification."""
  
      torques: list[list[float]] = Field(..., description="List of torque vectors [x, y, z] in N⋅m")
      tolerance: float = Field(
          default=0.01, description="Tolerance for equilibrium check (fraction)", ge=0.0
      )
  
  
  class TorqueBalanceResponse(BaseModel):
      """Response for torque balance verification."""
  
      net_torque: list[float] = Field(..., description="Net torque vector [x, y, z] in N⋅m")
      net_torque_magnitude: float = Field(..., description="Net torque magnitude in N⋅m")
      is_balanced: bool = Field(..., description="Whether torques are in equilibrium")
      individual_magnitudes: list[float] = Field(
          ..., description="Magnitude of each input torque in N⋅m"
      )

• src/chuk_mcp_physics/statics.py:46-54 (schema)

  Pydantic model for torque balance output (net_torque, net_torque_magnitude, is_balanced, individual_magnitudes).

  class TorqueBalanceResponse(BaseModel):
      """Response for torque balance verification."""
  
      net_torque: list[float] = Field(..., description="Net torque vector [x, y, z] in N⋅m")
      net_torque_magnitude: float = Field(..., description="Net torque magnitude in N⋅m")
      is_balanced: bool = Field(..., description="Whether torques are in equilibrium")
      individual_magnitudes: list[float] = Field(
          ..., description="Magnitude of each input torque in N⋅m"
      )

• src/chuk_mcp_physics/statics.py:232-256 (helper)

  Core calculation function that sums torque vectors, computes magnitudes, and determines if the system is balanced.

  def check_torque_balance(request: TorqueBalanceRequest) -> TorqueBalanceResponse:
      """Check if torques are in equilibrium: Στ = 0.
  
      Args:
          request: Torque balance request
  
      Returns:
          Torque balance analysis
      """
      net_torque = _vector_add(request.torques)
      net_magnitude = _vector_magnitude(net_torque)
  
      individual_magnitudes = [_vector_magnitude(t) for t in request.torques]
      total_magnitude = sum(individual_magnitudes)
  
      is_balanced = (
          net_magnitude <= request.tolerance * total_magnitude if total_magnitude > 0 else True
      )
  
      return TorqueBalanceResponse(
          net_torque=net_torque,
          net_torque_magnitude=net_magnitude,
          is_balanced=is_balanced,
          individual_magnitudes=individual_magnitudes,
      )

• src/chuk_mcp_physics/server.py:39-64 (registration)

  Importing the statics module registers all @tool-decorated functions (including check_torque_balance) via the chuk_mcp_server tool decorator.

  from .tools import (
      basic,
      rotational,
      oscillations,
      circular_motion,
      collisions,
      conservation,
      fluid as fluid_tools,
      kinematics_tools,
      statics,
      convert_units as unit_conversion_tools,
  )
  
  # Silence unused import warnings - these imports register @tool decorated functions
  _ = (
      basic,
      unit_conversion_tools,
      rotational,
      oscillations,
      circular_motion,
      collisions,
      conservation,
      fluid_tools,
      kinematics_tools,
      statics,
  )