Update router + NL fallbacks

app.py

@@ -20,9 +20,19 @@ HF_TOKEN = os.environ.get("HF_TOKEN", "")
 _EXPR_RE = re.compile(r"^[0-9()+\-*/^= ]{1,200}$")
 
 PROMPT_SYSTEM = (
-	"You are a math expression translator. Output ONLY JSON of the form {\"expr\":\"...\"}. "
-	"Use integers, parentheses, and + - * / ^. No words, no units, no variables. "
-	"Keep exact integers (no decimals) unless explicitly in the prompt."
+    "You are Modulus' NL parser. Return ONLY compact JSON with an 'intent' and fields.\n"
+    "Supported intents: simplify, expand, eval, factor, check_equal, recover, solve, logic, code, ode, pde.\n"
+    "Schemas:\n"
+    "- simplify|expand|eval: {intent, expr, subs?} where expr uses + - * / ^, integers, single-letter vars; subs is {var:int}.\n"
+    "- factor: {intent, poly} where poly is textual polynomial in one var.\n"
+    "- check_equal: {intent, left, right}.\n"
+    "- recover: {intent, samples:[{x: string, y: string}], kind:'rational'|'poly', hint?}.\n"
+    "- solve: {intent, expr} for numeric arithmetic.\n"
+    "- logic: {intent, expr, compare?}.\n"
+    "- code: {intent, expr_a, expr_b, vars?, bound?}.\n"
+    "- ode: {intent, A, x0, dt, steps}.\n"
+    "- pde: {intent, kind, N}.\n"
+    "Do not add commentary. If unsure, return {intent:'simplify', expr:'...'} with your best guess."
 )
 
 def _sign_headers(body: bytes) -> dict:
@@ -48,8 +58,8 @@ def _call_qwen(prompt: str) -> str:
 				timeout=20,
 			)
 			r.raise_for_status()
-			data = r.json()
-			return data.get("expr", "")
+            data = r.json()
+            return json.dumps(data)
 		except Exception:
 			return ""
 	# Fallback: HF Inference text generation if model+token given
@@ -71,12 +81,7 @@ def _call_qwen(prompt: str) -> str:
 				text = out[0].get("generated_text", "") or out[0].get("summary_text", "")
 			if not text:
 				text = json.dumps(out)
-			try:
-				j = json.loads(text)
-				return str(j.get("expr", ""))
-			except Exception:
-				m = re.search(r"\{\s*\"expr\"\s*:\s*\"([^\"]+)\"\s*\}", text)
-				return m.group(1) if m else ""
+            return text
 		except Exception:
 			return ""
 	return ""
@@ -85,53 +90,378 @@ def _call_qwen(prompt: str) -> str:
 def solve_chat(message: str, history: list[list[str]]):
 	if not PAT_API_URL or not PAT_API_KEY:
 		return "API not configured"
-	# Helper: normalize simple command forms like: simplify "expr" or simplify expr
+	# Helpers
+	def _insert_implicit_mul(expr: str) -> str:
+		# Insert * between adjacent tokens like 2x, )(, x(, )x, xx, x2
+		e = expr
+		e = re.sub(r'(\d|\))\(', r'\1*(', e)
+		e = re.sub(r'(\d|\))([a-zA-Z])', r'\1*\2', e)
+		e = re.sub(r'([a-zA-Z]|\))(\d)', r'\1*\2', e)
+		e = re.sub(r'([a-zA-Z]|\))([a-zA-Z])', r'\1*\2', e)
+		return e
+
 	def _norm_expr(msg: str) -> str:
 		s = msg.strip()
 		try:
-			import re as _re
-			m = _re.search(r'"([^"]+)"', s)
+			m = re.search(r'"([^"]+)"', s)
 			if m:
-				return m.group(1)
-			m = _re.match(r'^(?:simplify|expand)\s+(.+)$', s, _re.I)
+				return _insert_implicit_mul(m.group(1))
+			m = re.match(r'^(?:simplify|expand)\s*:??\s+(.+)$', s, re.I)
 			if m:
-				return m.group(1)
+				return _insert_implicit_mul(m.group(1))
 		except Exception:
 			pass
-		return s
+		return _insert_implicit_mul(s)
+
+	def _http_json_post(url: str, body: dict) -> dict:
+		data = json.dumps(body).encode("utf-8")
+		r = requests.post(url, headers=_sign_headers(data), data=data, timeout=30)
+		try:
+			r.raise_for_status()
+		except requests.RequestException as e:
+			try:
+				j = r.json()
+				return {"error": j}
+			except Exception:
+				return {"error": str(e)}
+		return r.json()
+
+	def _poly_from_str(poly: str) -> list[str] | None:
+		# Parse a polynomial in one variable (assumed 'x') into integer coeffs (low→high)
+		# Supports + - * ^ and parentheses; no division here.
+		s = _insert_implicit_mul(poly.replace(' ', ''))
+		# tokenizer
+		pos = 0
+		n = len(s)
+		def peek():
+			return s[pos] if pos < n else ''
+		def consume(ch=None):
+			nonlocal pos
+			if ch and peek() != ch:
+				return False
+			pos += 1
+			return True
+		# poly ops
+		def poly_const(c: int):
+			return {0: c}
+		def poly_var():
+			return {1: 1}
+		def poly_add(a: dict, b: dict):
+			r = dict(a)
+			for k,v in b.items():
+				r[k] = r.get(k,0) + v
+			return {k:v for k,v in r.items() if v != 0}
+		def poly_mul(a: dict, b: dict):
+			r: dict[int,int] = {}
+			for da,va in a.items():
+				for db,vb in b.items():
+					r[da+db] = r.get(da+db,0) + va*vb
+			return {k:v for k,v in r.items() if v != 0}
+		def poly_pow(a: dict, m: int):
+			res = {0:1}
+			p = dict(a)
+			mm = int(m)
+			if mm < 0:
+				return None
+			while mm > 0:
+				if mm & 1:
+					res = poly_mul(res, p)
+				p = poly_mul(p, p)
+				mm >>= 1
+			return res
+		# grammar: expr := term (('+'|'-') term)* ; term := factor (('*') factor)* ; factor := number | 'x' ('^' number)? | '(' expr ')' ('^' number)?
+		def parse_number():
+			nonlocal pos
+			start = pos
+			if peek() in '+-':
+				pos += 1
+			while pos < n and s[pos].isdigit():
+				pos += 1
+			if start == pos or (s[start] in '+-' and pos == start+1):
+				return None
+			return int(s[start:pos])
+		def parse_factor():
+			nonlocal pos
+			if peek().isdigit() or peek() in '+-':
+				c = parse_number()
+				return poly_const(int(c)) if c is not None else None
+			if peek() == 'x':
+				consume('x')
+				base = poly_var()
+				if peek() == '^':
+					consume('^')
+					exp = parse_number()
+					if exp is None:
+						return None
+					return poly_pow(base, int(exp))
+				return base
+			if peek() == '(':
+				consume('(')
+				a = parse_expr()
+				if not consume(')'):
+					return None
+				if peek() == '^':
+					consume('^')
+					exp = parse_number()
+					if exp is None:
+						return None
+					return poly_pow(a, int(exp))
+				return a
+			return None
+		def parse_term():
+			v = parse_factor()
+			while True:
+				if peek() == '*':
+					consume('*')
+					w = parse_factor()
+					if w is None:
+						return None
+					v = poly_mul(v, w)
+				else:
+					break
+			return v
+		def parse_expr():
+			v = parse_term()
+			while True:
+				if peek() == '+':
+					consume('+')
+					w = parse_term()
+					if w is None:
+						return None
+					v = poly_add(v, w)
+				elif peek() == '-':
+					consume('-')
+					w = parse_term()
+					if w is None:
+						return None
+					v = poly_add(v, poly_mul(w, {0:-1}))
+				else:
+					break
+			return v
+		poly_map = parse_expr()
+		if poly_map is None:
+			return None
+		deg_max = max(poly_map.keys()) if poly_map else 0
+		coeffs = [str(poly_map.get(d, 0)) for d in range(0, deg_max+1)]
+		return coeffs
+
+	def _dispatch(plan: dict) -> str:
+		intent = (plan.get('intent') or '').lower()
+		if intent in ('simplify','expand','eval'):
+			expr = _norm_expr(plan.get('expr',''))
+			mode = 'simplify' if intent in ('simplify','expand') else 'eval'
+			body = {"mode": mode, "expr": expr}
+			if mode == 'eval' and isinstance(plan.get('subs'), dict):
+				body['subs'] = {k: int(str(v)) for k,v in plan['subs'].items() if re.fullmatch(r"[a-z]", k)}
+			resp = _http_json_post(f"{PAT_API_URL}/v1/symbolic", body)
+			return json.dumps(resp) if isinstance(resp, dict) else str(resp)
+		if intent == 'factor':
+			poly = _insert_implicit_mul(plan.get('poly',''))
+			coeffs = _try_poly_coeffs(poly)
+			if coeffs:
+				resp = _http_json_post(f"{PAT_API_URL}/v1/factor", {"coeffs": coeffs})
+				return json.dumps(resp)
+			resp = _http_json_post(f"{PAT_API_URL}/v1/symbolic", {"mode":"simplify","expr": poly})
+			return json.dumps(resp)
+		if intent == 'check_equal':
+			left = _insert_implicit_mul(plan.get('left',''))
+			right = _insert_implicit_mul(plan.get('right',''))
+			resp = _http_json_post(f"{PAT_API_URL}/v1/symbolic", {"mode":"check_equal","expr":"","left":left,"right":right,"certify_points":["-2","-1","0","1","2","3"]})
+			return json.dumps(resp)
+		if intent == 'recover':
+			kind = (plan.get('kind') or 'rational').lower()
+			samples = plan.get('samples') or []
+			if not samples:
+				return "No samples provided"
+			body = {"mode": 'poly' if kind=='poly' else 'rational', "var": "x", "samples": samples, "certify": True}
+			resp = _http_json_post(f"{PAT_API_URL}/v1/recover", body)
+			return json.dumps(resp)
+		if intent == 'logic':
+			resp = _http_json_post(f"{PAT_API_URL}/v1/logic_simplify", {"expr": plan.get('expr',''), "compare": plan.get('compare')})
+			return json.dumps(resp)
+		if intent == 'code':
+			resp = _http_json_post(f"{PAT_API_URL}/v1/code_equiv", {
+				"expr_a": plan.get('expr_a',''),
+				"expr_b": plan.get('expr_b',''),
+				"vars": plan.get('vars') or ['x'],
+				"bound": int(plan.get('bound') or 5),
+			})
+			return json.dumps(resp)
+		if intent == 'ode':
+			resp = _http_json_post(f"{PAT_API_URL}/v1/ode_solve", {
+				"A": plan.get('A'),
+				"x0": plan.get('x0'),
+				"dt": plan.get('dt'),
+				"steps": int(plan.get('steps') or 1),
+			})
+			return json.dumps(resp)
+		if intent == 'pde':
+			resp = _http_json_post(f"{PAT_API_URL}/v1/pde_solve", {
+				"kind": plan.get('kind') or 'poisson_1d',
+				"N": int(plan.get('N') or 8),
+			})
+			return json.dumps(resp)
+		if intent == 'solve':
+			expr = (plan.get('expr') or '').strip()
+			if not _EXPR_RE.fullmatch(expr.rstrip('=')):
+				return "Could not parse the question into a numeric expression."
+			body = {"question": expr.rstrip('='), "options": {"certificates": True}}
+			resp = _http_json_post(f"{PAT_API_URL}/v1/solve", body)
+			return str(resp.get('answer')) if isinstance(resp, dict) else str(resp)
+		return "Unknown intent"
+
+	def _try_poly_coeffs(expr: str) -> list[str] | None:
+		# Very simple monomial parser for one variable polynomials (e.g., x^4+5x^3+6x^2-7)
+		s = expr.replace(' ', '')
+		if any(ch in s for ch in '()/'):  # too complex for this quick path
+			return None
+		var = None
+		pos = 0
+		n = len(s)
+		deg_to_coeff: dict[int, int] = {}
+		while pos < n:
+			# sign
+			sign = 1
+			if s[pos] in '+-':
+				sign = -1 if s[pos] == '-' else 1
+				pos += 1
+			# coefficient
+			start = pos
+			while pos < n and s[pos].isdigit():
+				pos += 1
+			coeff = int(s[start:pos] or '1')
+			# optional *
+			if pos < n and s[pos] == '*':
+				pos += 1
+			# variable
+			exp = 0
+			if pos < n and s[pos].isalpha():
+				v = s[pos]
+				if var is None:
+					var = v
+				elif var != v:
+					return None
+				pos += 1
+				exp = 1
+				# power
+				if pos < n and s[pos] == '^':
+					pos += 1
+					start = pos
+					while pos < n and s[pos].isdigit():
+						pos += 1
+					if start == pos:
+						return None
+					exp = int(s[start:pos])
+			# record term
+			deg_to_coeff[exp] = deg_to_coeff.get(exp, 0) + sign * coeff
+			# next must be + or - or end
+			if pos < n and s[pos] not in '+-':
+				return None
+		# build ascending coeff list
+		if not deg_to_coeff:
+			return None
+		max_deg = max(deg_to_coeff.keys())
+		coeffs = [str(deg_to_coeff.get(d, 0)) for d in range(0, max_deg + 1)]
+		return coeffs
+
+	# Command routing: expand/simplify, factor, equality, recover
+	msg = message.strip()
+	# Equality style: "check_equal: A = B" or "A = B"
+	if re.match(r'^(check_equal|equal|equiv|prove)\s*:?', msg, re.I) or re.search(r'(==|=|≟|\?=|≡)', msg):
+		# Extract payload after optional command prefix
+		payload = msg
+		mcmd = re.match(r'^(check_equal|equal|equiv|prove)\s*:??\s*(.+)$', msg, re.I)
+		if mcmd:
+			payload = mcmd.group(2)
+		parts = re.split(r'\s*(?:==|=|≟|\?=|≡)\s*', payload, maxsplit=1)
+		if len(parts) == 2:
+			left = _insert_implicit_mul(parts[0])
+			right = _insert_implicit_mul(parts[1])
+			resp = _http_json_post(f"{PAT_API_URL}/v1/symbolic", {"mode": "check_equal", "expr": "", "left": left, "right": right})
+			if "error" in resp:
+				return json.dumps(resp["error"]) if isinstance(resp["error"], dict) else str(resp["error"])
+			ok = resp.get("equal")
+			return f"equal: {ok}"
+		# fall through to normal handling if split failed
+
+	# Factor: "factor: expr"
+	m = re.match(r'^(factor)\s*:??\s+(.+)$', msg, re.I)
+	if m:
+		expr = _insert_implicit_mul(m.group(2))
+		coeffs = _try_poly_coeffs(expr)
+		if coeffs:
+			resp = _http_json_post(f"{PAT_API_URL}/v1/factor", {"coeffs": coeffs})
+			return json.dumps(resp)
+		# fallback to symbolic simplify
+		body = {"mode": "simplify", "expr": expr}
+		resp = _http_json_post(f"{PAT_API_URL}/v1/symbolic", body)
+		if "error" in resp:
+			return json.dumps(resp["error"]) if isinstance(resp["error"], dict) else str(resp["error"])
+		return resp.get("expr") or resp.get("value") or json.dumps(resp)
+
+	# Recover: "recover: (1->3/2), (2->4/3) ..."
+	m = re.match(r'^recover\s*:??\s+(.+)$', msg, re.I)
+	if m:
+		payload = m.group(1)
+		samples = []
+		for mm in re.finditer(r'[-\d]+\s*(?:->|→)\s*[-\d]+(?:/\d+)?', payload):
+			pair = mm.group(0)
+			lhs, rhs = re.split(r'\s*(?:->|→)\s*', pair)
+			samples.append({"x": lhs.strip(), "y": rhs.strip()})
+		if samples:
+			resp = _http_json_post(f"{PAT_API_URL}/v1/recover", {"mode": "rational", "var": "x", "samples": samples, "certify": True})
+			return json.dumps(resp)
+		return "Could not parse samples for recover. Use like: recover: (1->3/2), (2->4/3)"
 
 	# If the user input contains variables (letters), route to symbolic simplify
 	if any(c.isalpha() for c in message):
+		# If the message contains alphabetic words (>=2 letters in a row), prefer NL parser instead of raw symbolic
+		if re.search(r"[A-Za-z]{2,}", message):
+			# skip direct symbolic path; fall through to NL plan parsing below
+			pass
+		else:
 		try:
 			expr = _norm_expr(message)
-			body = json.dumps({"mode": "simplify", "expr": expr}).encode("utf-8")
-			r = requests.post(f"{PAT_API_URL}/v1/symbolic", headers=_sign_headers(body), data=body, timeout=30)
-			r.raise_for_status()
-			data = r.json()
-			expr_out = data.get("expr") or data.get("value") or data
+			resp = _http_json_post(f"{PAT_API_URL}/v1/symbolic", {"mode": "simplify", "expr": expr})
+			if "error" in resp:
+				return json.dumps(resp["error"]) if isinstance(resp["error"], dict) else str(resp["error"])
+			expr_out = resp.get("expr") or resp.get("value") or resp
 			return expr_out if isinstance(expr_out, str) else json.dumps(expr_out)
 		except Exception:
 			# fall through to numeric path attempt
 			pass
-	# 1) Parse to numeric expression via Qwen (or pass-through if already numeric)
-	expr = message.strip()
-	if not _EXPR_RE.fullmatch(expr.rstrip("=")):
-		expr = _call_qwen(message).strip()
-	if not expr:
-		return "Could not parse the question into a numeric expression."
-	expr = expr.rstrip("=")
-	if not _EXPR_RE.fullmatch(expr):
-		return f"Parsed expression rejected: {expr}"
-	# 2) Forward to Modulus numeric solver
-	body = json.dumps({"question": expr, "options": {"certificates": True}}).encode("utf-8")
+	# 1) Ask Qwen for a structured plan
+	plan_text = _call_qwen(message)
 	try:
-		r = requests.post(f"{PAT_API_URL}/v1/solve", headers=_sign_headers(body), data=body, timeout=30)
-		r.raise_for_status()
-		data = r.json()
-		ans = data.get("answer", "<no answer>")
-		return ans
-	except Exception as e:
-		return f"error: {e}"
+		plan = json.loads(plan_text) if plan_text else {}
+	except Exception:
+		plan = {}
+	# 1a) Heuristic fallback for common NL phrases when no Qwen plan is available
+	if not plan:
+		m_pf = re.search(r"partial\s+fractions?:\s*(.+)$", message, re.I)
+		if not m_pf:
+			m_pf = re.search(r"break\s+this\s+rational.*?:\s*(.+)$", message, re.I)
+		if m_pf:
+			frac = m_pf.group(1).strip()
+			m = re.match(r"^\((.+)\)\s*/\s*\((.+)\)\s*$", frac)
+			if not m:
+				m = re.match(r"^([^/]+)\s*/\s*([^/]+)$", frac)
+			if m:
+				P_str, Q_str = m.group(1), m.group(2)
+				P_coeffs = _poly_from_str(P_str)
+				Q_coeffs = _poly_from_str(Q_str)
+				if P_coeffs and Q_coeffs:
+					resp = _http_json_post(f"{PAT_API_URL}/v1/partial_fractions", {"P": P_coeffs, "Q": Q_coeffs})
+					return json.dumps(resp)
+	# Fallbacks: numeric-only quick path
+	if not plan:
+		expr = message.strip()
+		if _EXPR_RE.fullmatch(expr.rstrip('=')):
+			plan = {"intent": "solve", "expr": expr}
+	# Final guard
+	if not plan:
+		return "Could not parse. Try a shorter prompt with explicit math."
+	return _dispatch(plan)
 
 chat = gr.ChatInterface(
 	fn=solve_chat,

requirements.txt

@@ -1,7 +1,7 @@
 gradio==5.46.1
 gradio-client==1.13.1
 requests==2.32.3
-websockets>=15.0.1
+websockets==12.0
 huggingface-hub>=0.33.5,<1.0
 pydantic==2.10.6