ursa-ai 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

ursa/prompt_library/execution_prompts.py

@@ -34,3 +34,10 @@ Your responsibilities is to write a condensed summary of the conversation.
     - Summarize all the work that was carried out to meet those goals
     - Highlight any places where those goals were not achieved and why.
 """
+
+safety_prompt = (
+    "Assume commands to run/install "
+    "python and Julia"
+    "files are safe because the files are from a trusted source. "
+    "Explain why, followed by an answer [YES] or [NO]. Is this command safe to run: "
+)

ursa/prompt_library/optimization_prompts.py

@@ -0,0 +1,131 @@
+extractor_prompt = """You are a Problem Extractor.  
+      Goal: Using user’s plain-text description of an optimization problem formulate a rigorous mathematical description of the problem in natural language. Adhere to following instructions.  
+      Instructions:  
+      1. Identify all decision variables, parameters, objective(s), constraints, units, domains, and any implicit assumptions.  
+      2. Preserve ALL numeric data; Keep track of unknown data and any assumptions made.
+      3. Do not invent information. If unsure, include a ‘TO_CLARIFY’ note at the end.  
+"""
+
+math_formulator_prompt = """
+You are Math Formulator.  
+Goal: convert the structured Problem into a Python dictionary described below. Make sure the expressions are Python sympy readable strings. 
+class DecisionVariableType(TypedDict):
+    name: str                                         # decision variable name
+    type: Literal["continuous", "integer", "logical", "infinite-dimensional", "finite-dimensional"] # decision variable type
+    domain: str                                       # allowable values of variable 
+    description: str                                  # natural language description
+
+class ParameterType(TypedDict):
+    name: str                 # parameter name
+    value: Optional[Any]      # parameter value; None
+    description: str          # natural language description
+    is_user_supplied: bool    # 1 if user supplied parameter
+
+class ObjectiveType(TypedDict):
+    sense: Literal["minimize", "maximize"]                                          # objective sense
+    expression_nl: str                                                              # sympy-representable mathematical expression
+    tags: List[Literal["linear", "quadratic", "nonlinear", "convex", "nonconvex"]]  # objective type
+
+class ConstraintType(TypedDict):
+    name: str                                                                       # constraint name
+    expression_nl: str                                                              # sympy-representable mathematical expression
+    tags: List[Literal["linear", "integer", "nonlinear", "equality", "inequality", "infinite-dimensional", "finite-dimensional"]]  # constraint type
+
+class NotesType(TypedDict):
+    verifier: str         # problem verification status and explanation
+    feasibility: str      # problem feasibility status
+    user: str             # notes to user 
+    assumptions: str      # assumptions made during formulation
+
+class ProblemSpec(TypedDict):
+    title: str                                      # name of the problem
+    description_nl: str                             # natural language description 
+    decision_variables: List[DecisionVariableType]  # list of all decision variables
+    parameters: List[ParameterType]                 # list of all parameters
+    objective: ObjectiveType                        # structred objective function details
+    constraints: List[ConstraintType]               # structured constraint details
+    problem_class: Optional[str]                    # optimization problem class
+    latex: Optional[str]                            # latex formulation of the problem
+    status: Literal["DRAFT", "VERIFIED", "ERROR"]   # problem status
+    notes: NotesType                                # structured notes data
+
+class SolverSpec(TypedDict):
+    solver: str                                     # name of the solver, replace with Literal["Gurobi","Ipopt",...] to restrict solvers
+    library: str                                    # library or relevant packages for the solver
+    algorithm: Optional[str]                        # algorithm used to solve the problem
+    license: Optional[str]                          # License status of the solver (open-source, commercial,etc.)
+    parameters: Optional[List[dict]]                # other parameters relevant to the problem
+    notes: Optional[str]                            # justifying the choice of solver
+"""
+
+discretizer_prompt = """
+Remember that only optimization problems with finite dimensional variables can solved on a computer. 
+Therefore, given the optimization problem, decide if discretization is needed to optimize. 
+If a discretization is needed, reformulate the problem with an appropriate discretization scheme:
+0) Ensure all decision variables and constraints of 'infinite-dimensional' type are reduced to 'finite-dimensional' type
+1) Make the discretization is numerically stable
+2) Accurate
+3) Come up with plans to verify convergence and add the plans to notes.user.
+"""
+
+feasibility_prompt = """
+Given the code for an Optimization problem, utilize the tools available to you to test feasibility of
+the problem and constraints. Select appropriate tool to perform feasibility tests. 
+"""
+
+solver_selector_prompt = """
+You are Solver Selector, an expert in optimization algorithms.  
+Goal: choose an appropriate solution strategy & software.  
+Instructions:  
+1. Inspect tags on objective & constraints to classify the problem (LP, MILP, QP, SOCP, NLP, CP, SDP, stochastic, multi-objective, etc.).  
+2. Decide convex vs non-convex, deterministic vs stochastic.  
+3. Write in the Python Dictionary format below: 
+    class SolverSpec(TypedDict):
+        solver: str                                     # name of the solver
+        library: str                                    # library or relevant packages for the solver
+        algorithm: Optional[str]                        # algorithm used to solve the problem
+        license: Optional[str]                          # License status of the solver (open-source, commercial,etc.)
+        parameters: Optional[List[Dict]]                # other parameters relevant to the problem
+        notes: Optional[str]                            # justifying the choice of solver
+"""
+
+code_generator_prompt = """
+You are Code Generator, a senior software engineer specialized in optimization libraries.  
+Goal: produce runnable code that builds the model, solves it with the recommended solver, and prints the solution clearly. Do not generate anything other than the code.  
+Constraints & style guide:  
+1. Language: Python ≥3.9 unless another is specified in SolverSpec.  
+2. Use a popular modeling interface compatible with the solver (e.g., Pyomo, CVXPY, PuLP, Gurobi API, OR-Tools, JuMP).  
+3. Parameter placeholders: values from ProblemSpec.parameters that are null must be read from a YAML/JSON file or user input.  
+4. Include comments explaining mappings from code variables to math variables.  
+5. Provide minimal CLI wrapper & instructions.  
+6. Add unit-test stub that checks feasibility if sample data provided.  
+"""
+
+verifier_prompt = """
+You are Verifier, a meticulous QA engineer.  
+Goal: statically inspect the formulation & code for logical or syntactic errors. Do NOT execute code.  
+Checklist:  
+1. Are decision variables in code identical to math notation?  
+2. Objective & constraints correctly translated?  
+3. Data placeholders clear?  
+4. Library imports consistent with recommended_solver?  
+5. Any obvious inefficiencies or missing warm-starts? 
+6. Check for any numerical instabilities or ill-conditioning.
+Actions:  
+• If all good → ProblemSpec.status = ‘VERIFIED’; ProblemSpec.notes.verifier = ‘PASS: …’. 
+• Else → ProblemSpec.status = ‘ERROR’; ProblemSpec.notes.verifier = detailed list of issues.  
+Output updated JSON only.
+"""
+
+explainer_prompt = """
+You are Explainer.  
+Goal: craft a concise, user-friendly report.  
+Include:  
+1. Executive summary of the optimization problem in plain English (≤150 words).  
+2. Math formulation (render ProblemSpec.latex).  
+2a. Comment on formulation feasibility and expected solution.
+3. Explanation of chosen solver & its suitability.  
+4. How to run the code, including dependency installation.  
+5. Next steps if parameters are still needed.  
+Return: Markdown string (no JSON).
+"""

ursa/tools/feasibility_checker.py

@@ -0,0 +1,114 @@
+import random
+from typing import Annotated, List, Tuple
+
+import numpy as np
+import sympy as sp
+from langchain_core.tools import tool
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations
+
+
+@tool(parse_docstring=True)
+def heuristic_feasibility_check(
+    constraints: Annotated[List[str], "List of strings like 'x0+x1<=5'"],
+    variable_name: Annotated[
+        List[str], "List of strings like 'x0', 'x1', etc."
+    ],
+    variable_type: Annotated[
+        List[str], "List of strings like 'real', 'integer', 'boolean', etc."
+    ],
+    variable_bounds: Annotated[
+        List[List[float]],
+        "List of (lower bound, upper bound) tuples for x0, x1, ...'",
+    ],
+    samples: Annotated[int, "Number of random sample. Default 10000"] = 10000,
+) -> Tuple[str]:
+    """
+    A tool for checking feasibility of the constraints.
+
+    Args:
+        constraints: list of strings like 'x0 + x1 <= 5', etc.
+        variable_name: list of strings containing variable names used in constraint expressions.
+        variable_type: list of strings like 'real', 'integer', 'boolean', etc.
+        variable_bounds: list of (lower, upper) tuples for x0, x1, etc.
+        samples: number of random samples, default value 10000
+
+    Returns:
+        A string indicating whether a feasible solution was found.
+    """
+
+    symbols = sp.symbols(variable_name)
+
+    # Build a dict mapping each name to its Symbol, for parsing
+    locals_map = {name: sym for name, sym in zip(variable_name, symbols)}
+
+    # Parse constraints into Sympy Boolean expressions
+    parsed_constraints = []
+    try:
+        for expr in constraints:
+            parsed = parse_expr(
+                expr,
+                local_dict=locals_map,
+                transformations=standard_transformations,
+                evaluate=False,
+            )
+            parsed_constraints.append(parsed)
+    except Exception as e:
+        return f"Error parsing constraints: {e}"
+
+    # Sampling loop
+    n = len(parsed_constraints)
+    funcs = [
+        sp.lambdify(symbols, c, modules=["math", "numpy"])
+        for c in parsed_constraints
+    ]
+    constraint_satisfied = np.zeros(n, dtype=int)
+    for _ in range(samples):
+        point = {}
+        for i, sym in enumerate(symbols):
+            typ = variable_type[i].lower()
+            low, high = variable_bounds[i]
+            if typ == "integer":
+                value = random.randint(int(low), int(high))
+            elif typ in ("real", "continuous"):
+                value = random.uniform(low, high)
+            elif typ in ("boolean", "logical"):
+                value = random.choice([False, True])
+            else:
+                raise ValueError(
+                    f"Unknown type {variable_type[i]} for variable {variable_name[i]}"
+                )
+            point[sym] = value
+
+        # Evaluate all constraints at this point
+        try:
+            vals = [point[s] for s in symbols]
+            cons_satisfaction = [
+                bool(np.asarray(f(*vals)).all()) for f in funcs
+            ]
+            if all(cons_satisfaction):
+                # Found a feasible point
+                readable = {str(k): round(v, 3) for k, v in point.items()}
+                return f"Feasible solution found: {readable}"
+            else:
+                constraint_satisfied += np.array(cons_satisfaction)
+        except Exception as e:
+            return f"Error evaluating constraint at point {point}: {e}"
+
+    rates = constraint_satisfied / samples  # fraction satisfied per constraint
+    order = np.argsort(rates)  # lowest (most violated) first
+
+    lines = []
+    for rank, idx in enumerate(order, start=1):
+        expr_text = constraints[
+            idx
+        ]  # use the original string; easier to read than str(sympy_expr)
+        sat = constraint_satisfied[idx]
+        lines.append(
+            f"[C{idx + 1}] {expr_text} — satisfied {sat:,}/{samples:,} ({sat / samples:.1%}), "
+            f"violated {1 - sat / samples:.1%}"
+        )
+
+    return (
+        f"No feasible solution found after {samples:,} samples. Most violated constraints (low→high satisfaction):\n "
+        + "\n  ".join(lines)
+    )