feat(quandledb): v0.3.0 extended invariants — determinant, signature, Alexander, HOMFLY-PT

Server:
- format_alexander: sparse "exp:coeff" store → t^n human-readable display
- format_homfly: two-variable polynomial Dict → l^a·m^b display string
- compute_homfly: on-demand HOMFLY-PT via KnotTheory.jl (≤12 crossings,
  silently skips on error or missing pd_code)
- handle_knot_detail: passes computed HOMFLY into response
- knot_to_dict: adds alexander_display and homfly_polynomial fields

Frontend:
- Types.res: determinant, signature, alexanderPolynomial, alexanderDisplay,
  homflyPolynomial added to knot type
- Decoders.res: decode all five new optional fields in decodeKnot
- Page_KnotDetail.res: Determinant, Signature, Alexander Polynomial, HOMFLY-PT
  rows added to the Invariants table
- Page_Query.res: "By determinant" example query added

ROADMAP.adoc: v0.2.0 and v0.3.0 marked complete

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

quandledb/ROADMAP.adoc

@@ -19,17 +19,23 @@
 
 == v0.2.0 - Resolution Language (KRL)
 
-* [ ] KRL (Knot Resolution Language) parser
-* [ ] Query DSL for topological predicates
-* [ ] Query editor in frontend with syntax highlighting
-* [ ] Composable predicates via text interface
+* [x] KRL (Knot Resolution Language) parser (recursive-descent, 9 precedence levels)
+* [x] SQL→KRL frontend (SELECT/WHERE/ORDER BY/LIMIT desugaring)
+* [x] KRL evaluator (filter, sort, take, skip, return, group_by, aggregate, find_equivalent)
+* [x] Predicate pushdown to Skein.jl (crossing_number, writhe, genus, determinant, signature)
+* [x] Query editor in frontend with Ctrl+Enter shortcut and example quick-load buttons
+* [x] Composable predicates via text interface (AND/OR/NOT, nested parentheses)
+* [x] Per-stage execution trace panel (rows_in/out, elapsed_ms, note)
+* [x] Circuit-breaker fault isolation (Skein DB + semantic sidecar)
+* [x] `/health` and `/metrics` (Prometheus) endpoints
+* [x] DB-free seam test suite (8 seams, MockDataProvider + MockSemProvider)
 
 == v0.3.0 - Extended Invariants
 
-* [ ] Alexander polynomial computation and display
-* [ ] HOMFLY-PT polynomial
-* [ ] Knot signature
-* [ ] Knot determinant
+* [x] Alexander polynomial display (`format_alexander`: sparse coeff map → t^n notation)
+* [x] HOMFLY-PT polynomial (on-demand via KnotTheory.jl, bounded to ≤12 crossings)
+* [x] Knot signature (surfaced from Skein.jl schema to API and frontend)
+* [x] Knot determinant (surfaced to frontend; filterable in KRL and SQL)
 
 == v0.4.0 - Links and Tangles
 

quandledb/frontend/src/Decoders.res

@@ -93,8 +93,13 @@ let decodeKnot = (json: Js.Json.t): result<Types.knot, string> => {
           writhe: wr,
           genus: optInt("genus"),
           seifertCircleCount: optInt("seifert_circle_count"),
+          determinant: optInt("determinant"),
+          signature: optInt("signature"),
+          alexanderPolynomial: optStr("alexander_polynomial"),
+          alexanderDisplay: optStr("alexander_display"),
           jonesPolynomial: optStr("jones_polynomial"),
           jonesDisplay: optStr("jones_display"),
+          homflyPolynomial: optStr("homfly_polynomial"),
           metadata,
           createdAt: optStr("created_at")->Belt.Option.getWithDefault(""),
           updatedAt: optStr("updated_at")->Belt.Option.getWithDefault(""),

quandledb/frontend/src/Page_KnotDetail.res

@@ -54,7 +54,17 @@ let make = (
                   "Seifert Circles",
                   k.seifertCircleCount->Belt.Option.map(Belt.Int.toString),
                 )}
+                {renderOptField(
+                  "Determinant",
+                  k.determinant->Belt.Option.map(Belt.Int.toString),
+                )}
+                {renderOptField(
+                  "Signature",
+                  k.signature->Belt.Option.map(Belt.Int.toString),
+                )}
+                {renderOptField("Alexander Polynomial", k.alexanderDisplay)}
                 {renderOptField("Jones Polynomial", k.jonesDisplay)}
+                {renderOptField("HOMFLY-PT", k.homflyPolynomial)}
               </tbody>
             </table>
           </div>

quandledb/frontend/src/Page_Query.res

@@ -18,6 +18,10 @@ let examples = [
     "SQL: figure-eight",
     "SELECT name, crossing_number, writhe\nFROM knots\nWHERE crossing_number = 4\nORDER BY name ASC",
   ),
+  (
+    "By determinant",
+    "from knots\n| filter determinant == 3\n| return name, crossing_number, determinant, signature, alexander_polynomial",
+  ),
   (
     "All invariants",
     "from invariants",

quandledb/frontend/src/Types.res

@@ -17,8 +17,13 @@ type knot = {
   writhe: int,
   genus: option<int>,
   seifertCircleCount: option<int>,
+  determinant: option<int>,
+  signature: option<int>,
+  alexanderPolynomial: option<string>,
+  alexanderDisplay: option<string>,
   jonesPolynomial: option<string>,
   jonesDisplay: option<string>,
+  homflyPolynomial: option<string>,
   metadata: Js.Dict.t<string>,
   createdAt: string,
   updatedAt: string,

quandledb/server/serve.jl

@@ -475,25 +475,136 @@ function format_jones(jp::String)
     replace(s, "q^" => "q^")
 end
 
-function knot_to_dict(record::KnotRecord; semantic=nothing)
+"""
+    format_alexander(poly) -> Union{String, Nothing}
+
+Pretty-print a stored Alexander polynomial.  The serialised form is
+`"exp:coeff,exp:coeff,..."` (produced by `_serialise_int_poly` in KnotTheoryExt).
+Renders using the variable `t`, e.g. `"-1:1,0:-3,1:1"` → `"t⁻¹ - 3 + t"`.
+Returns `nothing` for a nothing/missing input.
+"""
+function format_alexander(poly::Nothing)
+    nothing
+end
+
+function format_alexander(poly::String)
+    try
+        terms = String[]
+        for pair in split(poly, ",")
+            parts = split(pair, ":")
+            length(parts) == 2 || continue
+            exp  = parse(Int, parts[1])
+            coef = parse(Int, parts[2])
+            coef == 0 && continue
+            base = exp == 0 ? "" :
+                   exp == 1 ? "t" :
+                   exp == -1 ? "t⁻¹" :
+                   exp > 0 ? "t^$(exp)" : "t^($(exp))"
+            if coef == 1
+                push!(terms, isempty(base) ? "1" : base)
+            elseif coef == -1
+                push!(terms, isempty(base) ? "-1" : "-$(base)")
+            else
+                push!(terms, isempty(base) ? string(coef) : "$(coef)$(base)")
+            end
+        end
+        isempty(terms) && return "0"
+        # Join with sign-aware spacing
+        result = terms[1]
+        for t in terms[2:end]
+            if startswith(t, "-")
+                result *= " - " * t[2:end]
+            else
+                result *= " + " * t
+            end
+        end
+        result
+    catch
+        poly   # fall back to raw string on any parse failure
+    end
+end
+
+"""
+    format_homfly(poly) -> Union{String, Nothing}
+
+Render a HOMFLY-PT polynomial (Dict{Tuple{Int,Int},Int} keyed by (l-exp, m-exp))
+as a human-readable string, e.g. `"-l⁻¹m² + lm²"`.
+"""
+function format_homfly(poly::Nothing)
+    nothing
+end
+
+function format_homfly(poly::Dict)
+    isempty(poly) && return "0"
+    var_str = (exp::Int, letter::String) ->
+        exp == 0  ? "" :
+        exp == 1  ? letter :
+        exp == -1 ? "$(letter)⁻¹" :
+        exp > 0   ? "$(letter)^$(exp)" : "$(letter)^($(exp))"
+    terms = String[]
+    for (le, me) in sort(collect(keys(poly)))
+        c = poly[(le, me)]
+        c == 0 && continue
+        lpart = var_str(le, "l")
+        mpart = var_str(me, "m")
+        mono  = lpart * mpart
+        isempty(mono) && (mono = "1")
+        if c == 1
+            push!(terms, mono)
+        elseif c == -1
+            push!(terms, "-$(mono)")
+        else
+            push!(terms, "$(c)$(mono)")
+        end
+    end
+    isempty(terms) && return "0"
+    result = terms[1]
+    for t in terms[2:end]
+        result *= startswith(t, "-") ? " - " * t[2:end] : " + " * t
+    end
+    result
+end
+
+"""
+    compute_homfly(record) -> Union{String, Nothing}
+
+Attempt on-demand HOMFLY-PT computation via KnotTheory.jl.  Skips knots with
+more than 12 crossings (state-sum is exponential) and silently returns `nothing`
+on any error.
+"""
+function compute_homfly(record::KnotRecord)
+    record.crossing_number > 12 && return nothing
+    isnothing(record.pd_code) && return nothing
+    try
+        pd   = to_planardiagram(record)     # requires KnotTheory.jl loaded
+        raw  = KnotTheory.homfly_polynomial(pd)
+        format_homfly(raw)
+    catch
+        nothing
+    end
+end
+
+function knot_to_dict(record::KnotRecord; semantic=nothing, homfly=nothing)
     Dict{String, Any}(
-        "id" => record.id,
-        "name" => record.name,
-        "gauss_code" => record.gauss_code.crossings,
-        "diagram_format" => record.diagram_format,
-        "crossing_number" => record.crossing_number,
-        "writhe" => record.writhe,
-        "genus" => record.genus,
+        "id"                   => record.id,
+        "name"                 => record.name,
+        "gauss_code"           => record.gauss_code.crossings,
+        "diagram_format"       => record.diagram_format,
+        "crossing_number"      => record.crossing_number,
+        "writhe"               => record.writhe,
+        "genus"                => record.genus,
         "seifert_circle_count" => record.seifert_circle_count,
-        "determinant" => record.determinant,
-        "signature" => record.signature,
+        "determinant"          => record.determinant,
+        "signature"            => record.signature,
         "alexander_polynomial" => record.alexander_polynomial,
-        "jones_polynomial" => record.jones_polynomial,
-        "jones_display" => format_jones(record.jones_polynomial),
-        "metadata" => record.metadata,
-        "semantic" => semantic,
-        "created_at" => string(record.created_at),
-        "updated_at" => string(record.updated_at),
+        "alexander_display"    => format_alexander(record.alexander_polynomial),
+        "jones_polynomial"     => record.jones_polynomial,
+        "jones_display"        => format_jones(record.jones_polynomial),
+        "homfly_polynomial"    => homfly,
+        "metadata"             => record.metadata,
+        "semantic"             => semantic,
+        "created_at"           => string(record.created_at),
+        "updated_at"           => string(record.updated_at),
     )
 end
 
@@ -610,7 +721,10 @@ end
 function handle_knot_detail(db::SkeinDB, sdb::SemanticIndexDB, name::String)
     record = fetch_knot(db, name)
     isnothing(record) && return error_response("Knot '$name' not found"; status = 404)
-    json_response(knot_to_dict(record; semantic = semantic_summary_by_name(sdb, record.name)))
+    homfly = compute_homfly(record)
+    json_response(knot_to_dict(record;
+        semantic = semantic_summary_by_name(sdb, record.name),
+        homfly   = homfly))
 end
 
 function handle_semantic_detail(db::SkeinDB, sdb::SemanticIndexDB, name::String)