# Kalika Phase 113 Final Benchmark Report

Generated: 2026-04-28T00:00:00.000Z

## Methodology

Comparisons are a capability map: each system is placed in a capability category
(shared match/exceed/gap framing) and annotated with that system’s specific
focus. This is a coverage-and-positioning assessment, not a bespoke per-system
deep-dive or a head-to-head timing. Runtime numbers are measured separately by
the phase-113 performance benchmark suite
(`phase-113-performance-benchmarks.ts`) and tracked against Kalika’s own
baseline; where a system’s reference number is native C/Fortran throughput,
Kalika’s TypeScript kernels legitimately trail it and the summary below reports
that honestly.

## Executive Summary

- 178 named SOTA/reference systems are compared across 10 domains.
- 36 Kalika package families are mapped to those systems.
- 69 Kalika modules have phase-113 performance benchmark specs; all 114 cases
  are measured at runtime (dense-kernel timings and known-answer references) and
  gated against their SOTA reference, with the live pass/trail split tracked
  against Kalika's own baseline in the performance suite (native C/Fortran
  throughput references legitimately lead the TypeScript kernels).
- 21 systems in this final report are directly represented in the phase-113
  performance benchmark target registry.
- Required task systems covered: Mathematica, FLINT, GAP, PARI/GP, xAct,
  FeynCalc, FORM, LAPACK, PETSc.
- Missing required task systems: none.

## Evidence Gates

- Cross-module integration:
  `libs/kalika/formal-verification/src/phase-113-cross-module-integration.spec.ts`.
- Performance and regression tracking:
  `libs/kalika/core/src/phase-113-performance-benchmarks.ts`.
- Adversarial robustness:
  `libs/kalika/core/src/phase-113-adversarial-testing.ts`.
- Accessibility and mathematical UI signoff:
  `apps/kalika/web/e2e/phase-113-accessibility-compliance.spec.ts`.

## Comparator Matrix

|   # | SOTA/reference system    | Domain                                                                                | Kalika match                                                                                                                                                                                                                                           | Kalika exceeds                                                                                                                                                                                              | Remaining gap                                                                                                                                                             | Closure plan                                                                                                                                                                                                              |
| --: | ------------------------ | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|   1 | Mathematica              | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for general symbolic algebra and notebook-driven exact computation with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.  | Kalika exceeds a single-purpose Mathematica workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API. | Kalika is not yet a drop-in replacement for the full mature Mathematica ecosystem, plugin library, and highly tuned native kernels at very large scales.                  | Close the gap by adding external Mathematica bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                 |
|   2 | Maple                    | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for symbolic manipulation, exact calculus, and worksheet workflows with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.  | Kalika exceeds a single-purpose Maple workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.       | Kalika is not yet a drop-in replacement for the full mature Maple ecosystem, plugin library, and highly tuned native kernels at very large scales.                        | Close the gap by adding external Maple bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                       |
|   3 | SageMath                 | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for open-source integrated mathematics system workflows with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.             | Kalika exceeds a single-purpose SageMath workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.    | Kalika is not yet a drop-in replacement for the full mature SageMath ecosystem, plugin library, and highly tuned native kernels at very large scales.                     | Close the gap by adding external SageMath bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                    |
|   4 | SymPy                    | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for Python symbolic mathematics and expression manipulation with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.         | Kalika exceeds a single-purpose SymPy workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.       | Kalika is not yet a drop-in replacement for the full mature SymPy ecosystem, plugin library, and highly tuned native kernels at very large scales.                        | Close the gap by adding external SymPy bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                       |
|   5 | Maxima                   | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for classic open-source computer algebra with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                            | Kalika exceeds a single-purpose Maxima workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.      | Kalika is not yet a drop-in replacement for the full mature Maxima ecosystem, plugin library, and highly tuned native kernels at very large scales.                       | Close the gap by adding external Maxima bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                      |
|   6 | FriCAS                   | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for strongly typed computer algebra descended from Axiom with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.            | Kalika exceeds a single-purpose FriCAS workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.      | Kalika is not yet a drop-in replacement for the full mature FriCAS ecosystem, plugin library, and highly tuned native kernels at very large scales.                       | Close the gap by adding external FriCAS bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                      |
|   7 | Reduce                   | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for portable symbolic algebra and simplification with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                    | Kalika exceeds a single-purpose Reduce workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.      | Kalika is not yet a drop-in replacement for the full mature Reduce ecosystem, plugin library, and highly tuned native kernels at very large scales.                       | Close the gap by adding external Reduce bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                      |
|   8 | Axiom                    | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for typed algebraic hierarchy for symbolic computation with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.              | Kalika exceeds a single-purpose Axiom workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.       | Kalika is not yet a drop-in replacement for the full mature Axiom ecosystem, plugin library, and highly tuned native kernels at very large scales.                        | Close the gap by adding external Axiom bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                       |
|   9 | GiNaC                    | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for C++ symbolic computation library embedding with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                      | Kalika exceeds a single-purpose GiNaC workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.       | Kalika is not yet a drop-in replacement for the full mature GiNaC ecosystem, plugin library, and highly tuned native kernels at very large scales.                        | Close the gap by adding external GiNaC bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                       |
|  10 | SymEngine                | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for fast symbolic core library with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                                      | Kalika exceeds a single-purpose SymEngine workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.   | Kalika is not yet a drop-in replacement for the full mature SymEngine ecosystem, plugin library, and highly tuned native kernels at very large scales.                    | Close the gap by adding external SymEngine bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                   |
|  11 | FLINT                    | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for integer, polynomial, finite-field, and number-theory kernels with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.    | Kalika exceeds a single-purpose FLINT workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.       | Kalika is not yet a drop-in replacement for the full mature FLINT ecosystem, plugin library, and highly tuned native kernels at very large scales.                        | Close the gap by adding external FLINT bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                       |
|  12 | Arb                      | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for ball arithmetic and rigorous special functions with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                  | Kalika exceeds a single-purpose Arb workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.         | Kalika is not yet a drop-in replacement for the full mature Arb ecosystem, plugin library, and highly tuned native kernels at very large scales.                          | Close the gap by adding external Arb bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                         |
|  13 | Acb                      | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for complex ball arithmetic with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                                         | Kalika exceeds a single-purpose Acb workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.         | Kalika is not yet a drop-in replacement for the full mature Acb ecosystem, plugin library, and highly tuned native kernels at very large scales.                          | Close the gap by adding external Acb bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                         |
|  14 | NTL                      | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for number-theory and polynomial arithmetic with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                         | Kalika exceeds a single-purpose NTL workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.         | Kalika is not yet a drop-in replacement for the full mature NTL ecosystem, plugin library, and highly tuned native kernels at very large scales.                          | Close the gap by adding external NTL bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                         |
|  15 | GMP                      | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for multi-precision integer arithmetic with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                              | Kalika exceeds a single-purpose GMP workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.         | Kalika is not yet a drop-in replacement for the full mature GMP ecosystem, plugin library, and highly tuned native kernels at very large scales.                          | Close the gap by adding external GMP bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                         |
|  16 | MPFR                     | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for correctly rounded arbitrary-precision floating point with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.            | Kalika exceeds a single-purpose MPFR workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.        | Kalika is not yet a drop-in replacement for the full mature MPFR ecosystem, plugin library, and highly tuned native kernels at very large scales.                         | Close the gap by adding external MPFR bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                        |
|  17 | MPC                      | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for arbitrary-precision complex arithmetic with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                          | Kalika exceeds a single-purpose MPC workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.         | Kalika is not yet a drop-in replacement for the full mature MPC ecosystem, plugin library, and highly tuned native kernels at very large scales.                          | Close the gap by adding external MPC bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                         |
|  18 | Nemo                     | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for Julia exact algebra built on FLINT/Arb with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                          | Kalika exceeds a single-purpose Nemo workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.        | Kalika is not yet a drop-in replacement for the full mature Nemo ecosystem, plugin library, and highly tuned native kernels at very large scales.                         | Close the gap by adding external Nemo bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                        |
|  19 | Hecke                    | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for algebraic number theory over Nemo/Julia with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.                         | Kalika exceeds a single-purpose Hecke workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.       | Kalika is not yet a drop-in replacement for the full mature Hecke ecosystem, plugin library, and highly tuned native kernels at very large scales.                        | Close the gap by adding external Hecke bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                       |
|  20 | Symbolica                | Computer algebra, exact arithmetic, and symbolic kernels                              | Kalika matches the workflow class for high-performance symbolic manipulation for large expressions with typed expression trees, exact serialization, rewrite/e-graph infrastructure, OpenMath/MathML interchange, and phase-113 benchmark fixtures.    | Kalika exceeds a single-purpose Symbolica workflow by connecting exact algebra to proof export, notebooks, citations, knowledge-graph provenance, and adversarial input gates in the same TypeScript API.   | Kalika is not yet a drop-in replacement for the full mature Symbolica ecosystem, plugin library, and highly tuned native kernels at very large scales.                    | Close the gap by adding external Symbolica bridge fixtures where licensing permits, expanding conformance notebooks, and tracking native-kernel parity in the benchmark baseline store.                                   |
|  21 | GAP                      | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for computational group theory through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                                   | Kalika exceeds isolated GAP runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                         | Kalika still trails GAP in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                          | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  22 | Magma                    | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for algebra, number theory, and arithmetic geometry through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.              | Kalika exceeds isolated Magma runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                       | Kalika still trails Magma in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                        | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  23 | PARI/GP                  | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for number theory and arithmetic computation through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                     | Kalika exceeds isolated PARI/GP runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                     | Kalika still trails PARI/GP in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                      | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  24 | SINGULAR                 | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for polynomial algebra and singularity computation through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.               | Kalika exceeds isolated SINGULAR runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                    | Kalika still trails SINGULAR in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                     | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  25 | Macaulay2                | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for commutative algebra and algebraic geometry through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                   | Kalika exceeds isolated Macaulay2 runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                   | Kalika still trails Macaulay2 in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                    | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  26 | CoCoA                    | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for computations in commutative algebra through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                          | Kalika exceeds isolated CoCoA runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                       | Kalika still trails CoCoA in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                        | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  27 | ApCoCoA                  | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for applied computational commutative algebra through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                    | Kalika exceeds isolated ApCoCoA runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                     | Kalika still trails ApCoCoA in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                      | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  28 | Bertini                  | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for numerical algebraic geometry and homotopy continuation through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.       | Kalika exceeds isolated Bertini runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                     | Kalika still trails Bertini in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                      | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  29 | HomotopyContinuation.jl  | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for Julia homotopy continuation for polynomial systems through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.           | Kalika exceeds isolated HomotopyContinuation.jl runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                     | Kalika still trails HomotopyContinuation.jl in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.      | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  30 | PHCpack                  | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for polynomial homotopy continuation through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                             | Kalika exceeds isolated PHCpack runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                     | Kalika still trails PHCpack in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                      | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  31 | polymake                 | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for polyhedral geometry and combinatorics through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                        | Kalika exceeds isolated polymake runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                    | Kalika still trails polymake in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                     | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  32 | Normaliz                 | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for affine monoids, lattice polytopes, and cones through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                 | Kalika exceeds isolated Normaliz runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                    | Kalika still trails Normaliz in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                     | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  33 | 4ti2                     | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for algebraic statistics and integer lattice problems through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.            | Kalika exceeds isolated 4ti2 runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                        | Kalika still trails 4ti2 in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                         | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  34 | TOPCOM                   | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for triangulations of point configurations and oriented matroids through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage. | Kalika exceeds isolated TOPCOM runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                      | Kalika still trails TOPCOM in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                       | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  35 | Gfan                     | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for Groebner fans and tropical geometry through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                          | Kalika exceeds isolated Gfan runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                        | Kalika still trails Gfan in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                         | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  36 | LinBox                   | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for exact linear algebra over finite fields and rings through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.            | Kalika exceeds isolated LinBox runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                      | Kalika still trails LinBox in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                       | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  37 | FPLLL                    | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for lattice reduction algorithms through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                                 | Kalika exceeds isolated FPLLL runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                       | Kalika still trails FPLLL in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                        | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  38 | LattE integrale          | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for lattice point counting and integration over polytopes through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.        | Kalika exceeds isolated LattE integrale runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                             | Kalika still trails LattE integrale in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.              | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  39 | KASH                     | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for computational algebraic number theory through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.                        | Kalika exceeds isolated KASH runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                        | Kalika still trails KASH in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                         | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  40 | msolve                   | Algebra, arithmetic geometry, computational geometry, and polyhedral tools            | Kalika matches the research workflow for polynomial system solving over finite fields and rationals through exact algebraic structures, Groebner/D-module interfaces, Ehrhart/matroid tooling, positive geometry, and tropical computation coverage.   | Kalika exceeds isolated msolve runs by wiring algebraic results into CAS serialization, citations, formal verification, notebooks, and cross-module integration tests.                                      | Kalika still trails msolve in decades of specialized algorithms, database breadth, and native performance for the largest classification workloads.                       | Close the gap with importer/exporter fixtures, benchmark cases for canonical examples, and delegated external execution adapters for workloads where Kalika should orchestrate rather than reimplement.                   |
|  41 | LAPACK                   | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for dense numerical linear algebra with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                                | Kalika exceeds a standalone LAPACK call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                            | Kalika does not yet match LAPACK native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                     | Close the gap by using LAPACK as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                   |
|  42 | BLAS                     | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for standard dense vector and matrix kernels with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                      | Kalika exceeds a standalone BLAS call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                              | Kalika does not yet match BLAS native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                       | Close the gap by using BLAS as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                     |
|  43 | OpenBLAS                 | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for optimized open-source BLAS/LAPACK kernels with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                     | Kalika exceeds a standalone OpenBLAS call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                          | Kalika does not yet match OpenBLAS native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                   | Close the gap by using OpenBLAS as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                 |
|  44 | BLIS                     | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for portable high-performance BLAS-like framework with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                 | Kalika exceeds a standalone BLIS call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                              | Kalika does not yet match BLIS native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                       | Close the gap by using BLIS as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                     |
|  45 | Intel oneMKL             | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for vendor-tuned math kernels with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                                     | Kalika exceeds a standalone Intel oneMKL call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                      | Kalika does not yet match Intel oneMKL native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                               | Close the gap by using Intel oneMKL as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.             |
|  46 | Eigen                    | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for C++ template linear algebra with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                                   | Kalika exceeds a standalone Eigen call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                             | Kalika does not yet match Eigen native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                      | Close the gap by using Eigen as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                    |
|  47 | SuiteSparse              | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for sparse direct solvers and graph algorithms with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                    | Kalika exceeds a standalone SuiteSparse call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                       | Kalika does not yet match SuiteSparse native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                | Close the gap by using SuiteSparse as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.              |
|  48 | PETSc                    | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for parallel sparse solvers and PDE systems with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                       | Kalika exceeds a standalone PETSc call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                             | Kalika does not yet match PETSc native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                      | Close the gap by using PETSc as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                    |
|  49 | Trilinos                 | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for parallel solver and scientific-computing packages with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                             | Kalika exceeds a standalone Trilinos call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                          | Kalika does not yet match Trilinos native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                   | Close the gap by using Trilinos as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                 |
|  50 | SLEPc                    | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for scalable eigenvalue solvers on PETSc with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                          | Kalika exceeds a standalone SLEPc call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                             | Kalika does not yet match SLEPc native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                      | Close the gap by using SLEPc as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                    |
|  51 | MUMPS                    | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for multifrontal sparse direct solver with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                             | Kalika exceeds a standalone MUMPS call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                             | Kalika does not yet match MUMPS native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                      | Close the gap by using MUMPS as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                    |
|  52 | SuperLU                  | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for sparse direct LU solvers with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                                      | Kalika exceeds a standalone SuperLU call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                           | Kalika does not yet match SuperLU native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                    | Close the gap by using SuperLU as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                  |
|  53 | Hypre                    | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for parallel multigrid preconditioners and solvers with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                | Kalika exceeds a standalone Hypre call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                             | Kalika does not yet match Hypre native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                      | Close the gap by using Hypre as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                    |
|  54 | FFTW                     | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for fast Fourier transform planning and execution with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                 | Kalika exceeds a standalone FFTW call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                              | Kalika does not yet match FFTW native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                       | Close the gap by using FFTW as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                     |
|  55 | GNU Scientific Library   | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for C numerical routines with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                                          | Kalika exceeds a standalone GNU Scientific Library call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.            | Kalika does not yet match GNU Scientific Library native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                     | Close the gap by using GNU Scientific Library as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.   |
|  56 | SciPy                    | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for Python scientific computing with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                                   | Kalika exceeds a standalone SciPy call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                             | Kalika does not yet match SciPy native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                      | Close the gap by using SciPy as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                    |
|  57 | NumPy                    | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for array programming and numerical kernels with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                       | Kalika exceeds a standalone NumPy call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                             | Kalika does not yet match NumPy native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                      | Close the gap by using NumPy as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                    |
|  58 | DifferentialEquations.jl | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for Julia differential equation solvers with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                           | Kalika exceeds a standalone DifferentialEquations.jl call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.          | Kalika does not yet match DifferentialEquations.jl native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                   | Close the gap by using DifferentialEquations.jl as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses. |
|  59 | SUNDIALS                 | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for ODE, DAE, and nonlinear solver suite with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                          | Kalika exceeds a standalone SUNDIALS call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                          | Kalika does not yet match SUNDIALS native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                   | Close the gap by using SUNDIALS as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                 |
|  60 | deal.II                  | Numerical analysis, solvers, meshing, and HPC kernels                                 | Kalika matches the workflow class for finite element library with deterministic linear algebra, sparse/PDE/ODE fixtures, solver diagnostics, and phase-113 regression tracking.                                                                        | Kalika exceeds a standalone deal.II call by preserving symbolic provenance, verification evidence, notebook replay, and adversarial failure handling around the numerical result.                           | Kalika does not yet match deal.II native throughput, distributed-memory maturity, or hardware-vendor tuning for production-scale jobs.                                    | Close the gap by using deal.II as a backend target where appropriate, adding hardware-specific baselines, and broadening performance gates from moderate fixtures to external-scale benchmark harnesses.                  |
|  61 | SDPB                     | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for high-precision SDP for conformal bootstrap with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                             | Kalika exceeds a siloed SDPB workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                           | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace SDPB.             | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  62 | CVXPY                    | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for disciplined convex programming in Python with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                               | Kalika exceeds a siloed CVXPY workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                          | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace CVXPY.            | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  63 | CVXOPT                   | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for convex optimization and cone programming with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                               | Kalika exceeds a siloed CVXOPT workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                         | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace CVXOPT.           | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  64 | MOSEK                    | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for commercial conic and mathematical optimization with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                         | Kalika exceeds a siloed MOSEK workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                          | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace MOSEK.            | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  65 | Gurobi                   | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for commercial LP, QP, and MIP optimization with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                | Kalika exceeds a siloed Gurobi workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                         | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace Gurobi.           | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  66 | CPLEX                    | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for commercial mathematical programming solver with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                             | Kalika exceeds a siloed CPLEX workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                          | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace CPLEX.            | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  67 | HiGHS                    | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for open-source LP, QP, and MIP solvers with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                    | Kalika exceeds a siloed HiGHS workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                          | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace HiGHS.            | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  68 | SCIP                     | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for constraint integer programming and MIP with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                 | Kalika exceeds a siloed SCIP workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                           | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace SCIP.             | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  69 | Ipopt                    | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for large-scale nonlinear optimization with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                     | Kalika exceeds a siloed Ipopt workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                          | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace Ipopt.            | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  70 | NLopt                    | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for nonlinear local and global optimization with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                | Kalika exceeds a siloed NLopt workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                          | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace NLopt.            | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  71 | OSQP                     | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for operator-splitting quadratic programming with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                               | Kalika exceeds a siloed OSQP workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                           | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace OSQP.             | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  72 | SCS                      | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for splitting conic solver with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                                 | Kalika exceeds a siloed SCS workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                            | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace SCS.              | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  73 | ECOS                     | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for embedded conic solver with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                                  | Kalika exceeds a siloed ECOS workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                           | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace ECOS.             | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  74 | Clarabel                 | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for interior-point conic optimization with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                      | Kalika exceeds a siloed Clarabel workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                       | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace Clarabel.         | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  75 | JuMP                     | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for Julia algebraic modeling for optimization with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                              | Kalika exceeds a siloed JuMP workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                           | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace JuMP.             | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  76 | CasADi                   | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for algorithmic differentiation and nonlinear optimization with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                 | Kalika exceeds a siloed CasADi workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                         | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace CasADi.           | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  77 | COIN-OR                  | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for open operations-research solver ecosystem with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                              | Kalika exceeds a siloed COIN-OR workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                        | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace COIN-OR.          | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  78 | CUTEst                   | Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           | Kalika matches the modeling class for optimization test problem collection with LP, SDP, DCP, nonlinear, global, variational, and AD-backed optimization interfaces.                                                                                   | Kalika exceeds a siloed CUTEst workflow by carrying solver output into formal certificates, differentiable physics, benchmark regression gates, and notebook-level reproducibility.                         | Kalika still needs broader production solver bindings, larger industrial model corpora, and vendor-grade presolve/performance coverage to fully replace CUTEst.           | Close the gap by adding adapter-level conformance suites, solver-specific import/export paths, and public benchmark deltas for each optimization family.                                                                  |
|  79 | Lean                     | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for dependent type theory and mathlib formalization with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                  | Kalika exceeds isolated Lean proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                               | Kalika is not a replacement for the full Lean theorem library, tactic ecosystem, or expert IDE workflow.                                                                  | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  80 | Coq                      | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for interactive theorem proving with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                                      | Kalika exceeds isolated Coq proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                                | Kalika is not a replacement for the full Coq theorem library, tactic ecosystem, or expert IDE workflow.                                                                   | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  81 | Isabelle                 | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for generic proof assistant and HOL libraries with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                        | Kalika exceeds isolated Isabelle proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                           | Kalika is not a replacement for the full Isabelle theorem library, tactic ecosystem, or expert IDE workflow.                                                              | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  82 | HOL Light                | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for HOL theorem proving and formalized analysis with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                      | Kalika exceeds isolated HOL Light proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                          | Kalika is not a replacement for the full HOL Light theorem library, tactic ecosystem, or expert IDE workflow.                                                             | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  83 | Agda                     | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for dependently typed programming and proofs with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                         | Kalika exceeds isolated Agda proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                               | Kalika is not a replacement for the full Agda theorem library, tactic ecosystem, or expert IDE workflow.                                                                  | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  84 | Metamath                 | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for small-kernel formal proof database with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                               | Kalika exceeds isolated Metamath proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                           | Kalika is not a replacement for the full Metamath theorem library, tactic ecosystem, or expert IDE workflow.                                                              | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  85 | Mizar                    | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for formalized mathematics library with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                                   | Kalika exceeds isolated Mizar proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                              | Kalika is not a replacement for the full Mizar theorem library, tactic ecosystem, or expert IDE workflow.                                                                 | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  86 | ACL2                     | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for industrial theorem proving for recursive functions with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                               | Kalika exceeds isolated ACL2 proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                               | Kalika is not a replacement for the full ACL2 theorem library, tactic ecosystem, or expert IDE workflow.                                                                  | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  87 | Z3                       | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for SMT solving with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                                                      | Kalika exceeds isolated Z3 proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                                 | Kalika is not a replacement for the full Z3 theorem library, tactic ecosystem, or expert IDE workflow.                                                                    | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  88 | CVC5                     | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for SMT solving and automated reasoning with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                              | Kalika exceeds isolated CVC5 proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                               | Kalika is not a replacement for the full CVC5 theorem library, tactic ecosystem, or expert IDE workflow.                                                                  | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  89 | Vampire                  | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for first-order automated theorem proving with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                            | Kalika exceeds isolated Vampire proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                            | Kalika is not a replacement for the full Vampire theorem library, tactic ecosystem, or expert IDE workflow.                                                               | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  90 | E prover                 | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for equational first-order theorem proving with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                           | Kalika exceeds isolated E prover proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                           | Kalika is not a replacement for the full E prover theorem library, tactic ecosystem, or expert IDE workflow.                                                              | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  91 | Prover9                  | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for automated theorem proving with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                                        | Kalika exceeds isolated Prover9 proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                            | Kalika is not a replacement for the full Prover9 theorem library, tactic ecosystem, or expert IDE workflow.                                                               | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  92 | TPTP                     | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for ATP problem library and formats with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                                  | Kalika exceeds isolated TPTP proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                               | Kalika is not a replacement for the full TPTP theorem library, tactic ecosystem, or expert IDE workflow.                                                                  | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  93 | SMT-LIB                  | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for SMT benchmark language and logic standards with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                       | Kalika exceeds isolated SMT-LIB proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                            | Kalika is not a replacement for the full SMT-LIB theorem library, tactic ecosystem, or expert IDE workflow.                                                               | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  94 | MONA                     | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for WS1S/WS2S automata decision procedures with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                           | Kalika exceeds isolated MONA proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                               | Kalika is not a replacement for the full MONA theorem library, tactic ecosystem, or expert IDE workflow.                                                                  | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  95 | SPASS                    | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for automated theorem proving with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                                        | Kalika exceeds isolated SPASS proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                              | Kalika is not a replacement for the full SPASS theorem library, tactic ecosystem, or expert IDE workflow.                                                                 | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  96 | Why3                     | Formal verification, theorem proving, SMT, ATP, and decidable logics                  | Kalika matches the workflow class for deductive program verification platform with Lean/SMT/TPTP emitters, proof-certificate checks, Presburger decision procedures, and cross-prover deduplication fixtures.                                          | Kalika exceeds isolated Why3 proof sessions by linking proof obligations to CAS computations, numerical evidence, citations, and research-agent repair loops.                                               | Kalika is not a replacement for the full Why3 theorem library, tactic ecosystem, or expert IDE workflow.                                                                  | Close the gap with proof-library import maps, round-trip proof scripts for canonical theorems, and CI gates that compare Kalika proof exports against native prover acceptance.                                           |
|  97 | FeynCalc                 | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for symbolic QFT algebra in Mathematica with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                    | Kalika exceeds standalone FeynCalc workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                   | Kalika still trails FeynCalc in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                          | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
|  98 | FORM                     | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for large-scale high-energy physics algebra with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                | Kalika exceeds standalone FORM workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                       | Kalika still trails FORM in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                              | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
|  99 | FeynArts                 | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for Feynman diagram generation with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                             | Kalika exceeds standalone FeynArts workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                   | Kalika still trails FeynArts in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                          | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 100 | Package-X                | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for one-loop Feynman integral computation with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                  | Kalika exceeds standalone Package-X workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                  | Kalika still trails Package-X in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                         | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 101 | LoopTools                | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for one-loop integral numerical evaluation with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                 | Kalika exceeds standalone LoopTools workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                  | Kalika still trails LoopTools in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                         | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 102 | Collier                  | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for one-loop tensor and scalar integrals with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                   | Kalika exceeds standalone Collier workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                    | Kalika still trails Collier in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                           | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 103 | QGRAF                    | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for Feynman diagram generation with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                             | Kalika exceeds standalone QGRAF workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                      | Kalika still trails QGRAF in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                             | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 104 | MadGraph5_aMC@NLO        | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for matrix elements and event generation with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                   | Kalika exceeds standalone MadGraph5_aMC@NLO workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.          | Kalika still trails MadGraph5_aMC@NLO in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                 | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 105 | Sherpa                   | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for Monte Carlo event generator with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                            | Kalika exceeds standalone Sherpa workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                     | Kalika still trails Sherpa in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                            | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 106 | Herwig                   | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for Monte Carlo event generator with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                            | Kalika exceeds standalone Herwig workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                     | Kalika still trails Herwig in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                            | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 107 | Pythia                   | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for particle collision event generator with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                     | Kalika exceeds standalone Pythia workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                     | Kalika still trails Pythia in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                            | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 108 | Rivet                    | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for analysis preservation and validation with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                   | Kalika exceeds standalone Rivet workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                      | Kalika still trails Rivet in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                             | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 109 | FastJet                  | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for jet finding with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                                            | Kalika exceeds standalone FastJet workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                    | Kalika still trails FastJet in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                           | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 110 | LHAPDF                   | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for parton distribution function access with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                    | Kalika exceeds standalone LHAPDF workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                     | Kalika still trails LHAPDF in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                            | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 111 | HepMC                    | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for event record format with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                                    | Kalika exceeds standalone HepMC workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                      | Kalika still trails HepMC in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                             | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 112 | ROOT                     | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for HEP data analysis framework with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                            | Kalika exceeds standalone ROOT workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                       | Kalika still trails ROOT in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                              | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 113 | YODA                     | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for analysis object and histogram format with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                   | Kalika exceeds standalone YODA workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                       | Kalika still trails YODA in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                              | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 114 | HEPData                  | High-energy physics, QFT algebra, event formats, and phenomenology                    | Kalika matches the workflow class for publication data repository with symbolic QFT, color/Dirac algebra, loop-provider interfaces, event-format handling, and phenomenology data adapters.                                                            | Kalika exceeds standalone HEPData workflows by integrating amplitude algebra, citations, benchmark evidence, formal checks, and notebook reproducibility under one typed research graph.                    | Kalika still trails HEPData in community-tuned generators, full detector/analysis ecosystem coverage, and large collaboration validation depth.                           | Close the gap by adding file-format round trips, public reference analyses, bridge adapters, and regression suites keyed to established HEP benchmark cards.                                                              |
| 115 | xAct                     | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for tensor calculus for relativity with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                                     | Kalika exceeds a detached xAct run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                           | Kalika does not yet replace xAct for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                   | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native xAct reference cases.                                                                 |
| 116 | Einstein Toolkit         | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for numerical relativity infrastructure with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                                | Kalika exceeds a detached Einstein Toolkit run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                               | Kalika does not yet replace Einstein Toolkit for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.       | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native Einstein Toolkit reference cases.                                                     |
| 117 | GRChombo                 | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for adaptive mesh numerical relativity with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                                 | Kalika exceeds a detached GRChombo run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                       | Kalika does not yet replace GRChombo for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.               | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native GRChombo reference cases.                                                             |
| 118 | SpECTRE                  | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for high-performance relativity and astrophysics simulations with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                           | Kalika exceeds a detached SpECTRE run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                        | Kalika does not yet replace SpECTRE for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native SpECTRE reference cases.                                                              |
| 119 | LALSuite                 | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for gravitational-wave data analysis libraries with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                         | Kalika exceeds a detached LALSuite run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                       | Kalika does not yet replace LALSuite for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.               | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native LALSuite reference cases.                                                             |
| 120 | EinsteinPy               | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for Python relativity and geodesic tooling with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                             | Kalika exceeds a detached EinsteinPy run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                     | Kalika does not yet replace EinsteinPy for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.             | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native EinsteinPy reference cases.                                                           |
| 121 | CLASS                    | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for cosmological Boltzmann solver with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                                      | Kalika exceeds a detached CLASS run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                          | Kalika does not yet replace CLASS for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                  | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native CLASS reference cases.                                                                |
| 122 | CAMB                     | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for CMB anisotropy and matter power spectra with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                            | Kalika exceeds a detached CAMB run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                           | Kalika does not yet replace CAMB for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                   | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native CAMB reference cases.                                                                 |
| 123 | Cobaya                   | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for cosmological Bayesian analysis with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                                     | Kalika exceeds a detached Cobaya run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                         | Kalika does not yet replace Cobaya for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                 | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native Cobaya reference cases.                                                               |
| 124 | MontePython              | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for cosmological parameter inference with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                                   | Kalika exceeds a detached MontePython run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                    | Kalika does not yet replace MontePython for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.            | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native MontePython reference cases.                                                          |
| 125 | CosmoMC                  | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for cosmological MCMC inference with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                                        | Kalika exceeds a detached CosmoMC run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                        | Kalika does not yet replace CosmoMC for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native CosmoMC reference cases.                                                              |
| 126 | Astropy                  | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for astronomy and astrophysics Python ecosystem with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                        | Kalika exceeds a detached Astropy run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                        | Kalika does not yet replace Astropy for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native Astropy reference cases.                                                              |
| 127 | HEALPix                  | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for spherical pixelization and map analysis with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                            | Kalika exceeds a detached HEALPix run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                        | Kalika does not yet replace HEALPix for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native HEALPix reference cases.                                                              |
| 128 | Core Cosmology Library   | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for cosmology observables and likelihood support with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                       | Kalika exceeds a detached Core Cosmology Library run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                         | Kalika does not yet replace Core Cosmology Library for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines. | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native Core Cosmology Library reference cases.                                               |
| 129 | Gadget-4                 | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for cosmological N-body and SPH simulations with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                            | Kalika exceeds a detached Gadget-4 run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                       | Kalika does not yet replace Gadget-4 for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.               | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native Gadget-4 reference cases.                                                             |
| 130 | SWIFT                    | Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       | Kalika matches the workflow class for hydrodynamics and cosmological simulation code with tensor calculus, exact solutions, BSSN-oriented fixtures, waveform/cosmology interfaces, and likelihood data structures.                                     | Kalika exceeds a detached SWIFT run by connecting tensor, numerical, cosmological, citation, and verification evidence in a single reproducible notebook pipeline.                                          | Kalika does not yet replace SWIFT for full production simulation campaigns, mission-scale data archives, or collaboration-validated parameter pipelines.                  | Close the gap with adapter-backed cross-checks, public benchmark notebooks, and release gates that compare Kalika outputs to native SWIFT reference cases.                                                                |
| 131 | Regina                   | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for low-dimensional topology with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                          | Kalika exceeds a single Regina workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                      | Kalika still trails Regina in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                  | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 132 | SnapPy                   | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for 3-manifold topology and hyperbolic geometry with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                       | Kalika exceeds a single SnapPy workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                      | Kalika still trails SnapPy in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                  | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 133 | SageManifolds            | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for differential geometry and tensor calculus on manifolds with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                            | Kalika exceeds a single SageManifolds workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                               | Kalika still trails SageManifolds in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                           | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 134 | Kenzo                    | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for computational algebraic topology with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                  | Kalika exceeds a single Kenzo workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                       | Kalika still trails Kenzo in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                   | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 135 | GUDHI                    | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for computational topology and TDA with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                    | Kalika exceeds a single GUDHI workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                       | Kalika still trails GUDHI in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                   | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 136 | Ripser                   | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for persistent homology computation with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                   | Kalika exceeds a single Ripser workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                      | Kalika still trails Ripser in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                  | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 137 | Dionysus                 | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for computational topology and persistence with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                            | Kalika exceeds a single Dionysus workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                    | Kalika still trails Dionysus in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 138 | CHomP                    | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for computational homology with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                            | Kalika exceeds a single CHomP workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                       | Kalika still trails CHomP in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                   | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 139 | JavaPlex                 | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for persistent homology and TDA with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                       | Kalika exceeds a single JavaPlex workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                    | Kalika still trails JavaPlex in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 140 | CGAL                     | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for computational geometry algorithms with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                 | Kalika exceeds a single CGAL workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                        | Kalika still trails CGAL in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                    | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 141 | Gmsh                     | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for finite-element meshing with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                            | Kalika exceeds a single Gmsh workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                        | Kalika still trails Gmsh in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                    | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 142 | TetGen                   | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for tetrahedral mesh generation with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                       | Kalika exceeds a single TetGen workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                      | Kalika still trails TetGen in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                  | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 143 | Triangle                 | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for 2D triangular mesh generation with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                     | Kalika exceeds a single Triangle workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                    | Kalika still trails Triangle in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 144 | Qhull                    | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for convex hulls, Delaunay triangulations, and Voronoi diagrams with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                       | Kalika exceeds a single Qhull workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                       | Kalika still trails Qhull in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                   | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 145 | Geogram                  | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for geometric algorithms and meshing with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                                  | Kalika exceeds a single Geogram workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                     | Kalika still trails Geogram in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                 | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 146 | OpenFOAM                 | Topology, manifolds, computational geometry, meshing, and TDA                         | Kalika matches the workflow class for finite-volume CFD and meshing workflows with topology, manifold, persistent-homology, polytope, geometry, and meshing fixtures across phase-113 tests.                                                           | Kalika exceeds a single OpenFOAM workflow by linking geometry outputs to symbolic algebra, physics modules, knowledge-graph queries, and reproducible notebook evidence.                                    | Kalika still trails OpenFOAM in specialized dataset breadth, native computational geometry performance, and visualization/editor maturity.                                | Close the gap with canonical dataset imports, mesh/complex round trips, more exact-vs-numerical cross-checks, and native backend adapters for heavy geometry kernels.                                                     |
| 147 | Jupyter                  | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for interactive computational notebooks with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                          | Kalika exceeds standalone Jupyter surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                           | Kalika still trails Jupyter in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                     | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 148 | JupyterLab               | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for browser-based notebook workbench with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                             | Kalika exceeds standalone JupyterLab surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                        | Kalika still trails JupyterLab in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                  | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 149 | VS Code Notebooks        | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for IDE-integrated computational notebooks with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                       | Kalika exceeds standalone VS Code Notebooks surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                 | Kalika still trails VS Code Notebooks in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                           | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 150 | LaTeX                    | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for scientific typesetting with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                                       | Kalika exceeds standalone LaTeX surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                             | Kalika still trails LaTeX in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                       | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 151 | MathJax                  | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for accessible mathematical rendering with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                            | Kalika exceeds standalone MathJax surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                           | Kalika still trails MathJax in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                     | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 152 | KaTeX                    | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for fast mathematical rendering with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                                  | Kalika exceeds standalone KaTeX surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                             | Kalika still trails KaTeX in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                       | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 153 | Manim                    | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for mathematical animation with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                                       | Kalika exceeds standalone Manim surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                             | Kalika still trails Manim in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                       | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 154 | TikZ                     | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for programmatic diagrams in TeX with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                                 | Kalika exceeds standalone TikZ surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                              | Kalika still trails TikZ in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                        | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 155 | Graphviz                 | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for graph layout and rendering with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                                   | Kalika exceeds standalone Graphviz surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                          | Kalika still trails Graphviz in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                    | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 156 | Cytoscape                | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for graph visualization and network analysis with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                     | Kalika exceeds standalone Cytoscape surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                         | Kalika still trails Cytoscape in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                   | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 157 | D3.js                    | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for browser data visualization with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                                   | Kalika exceeds standalone D3.js surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                             | Kalika still trails D3.js in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                       | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 158 | NetworkX                 | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for graph algorithms and network analysis with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                        | Kalika exceeds standalone NetworkX surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                          | Kalika still trails NetworkX in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                    | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 159 | Neo4j                    | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for property graph database with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                                      | Kalika exceeds standalone Neo4j surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                             | Kalika still trails Neo4j in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                       | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 160 | RDF4J                    | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for RDF storage and SPARQL tooling with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                               | Kalika exceeds standalone RDF4J surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                             | Kalika still trails RDF4J in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                       | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 161 | Blazegraph               | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for RDF graph database and query engine with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                          | Kalika exceeds standalone Blazegraph surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                        | Kalika still trails Blazegraph in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                  | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 162 | ArangoDB                 | Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    | Kalika matches the workflow class for multi-model document and graph database with executable notebooks, MathML/LaTeX rendering, citation provenance, graph navigation, share links, and accessibility-tested UI.                                      | Kalika exceeds standalone ArangoDB surfaces by making computation, formal evidence, benchmark results, and literature provenance first-class in the same artifact.                                          | Kalika still trails ArangoDB in ecosystem size, third-party extensions, editor polish, and hosted collaboration scale.                                                    | Close the gap with migration guides, import/export compatibility, accessibility regression gates, and public examples that exercise every publishing and graph workflow.                                                  |
| 163 | PyTorch                  | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for deep learning and tensor computation with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                 | Kalika exceeds a standalone PyTorch model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                         | Kalika does not yet match PyTorch hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                  | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 164 | TensorFlow               | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for machine learning and production inference with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                            | Kalika exceeds a standalone TensorFlow model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                      | Kalika does not yet match TensorFlow hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                               | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 165 | JAX                      | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for accelerated differentiable programming with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                               | Kalika exceeds a standalone JAX model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                             | Kalika does not yet match JAX hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                      | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 166 | Flux.jl                  | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for Julia machine learning with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                               | Kalika exceeds a standalone Flux.jl model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                         | Kalika does not yet match Flux.jl hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                  | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 167 | DiffEqFlux.jl            | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for scientific machine learning with differential equations with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                              | Kalika exceeds a standalone DiffEqFlux.jl model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                   | Kalika does not yet match DiffEqFlux.jl hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                            | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 168 | torchdiffeq              | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for neural ODE training with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                                  | Kalika exceeds a standalone torchdiffeq model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                     | Kalika does not yet match torchdiffeq hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                              | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 169 | DeepXDE                  | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for physics-informed neural networks with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                     | Kalika exceeds a standalone DeepXDE model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                         | Kalika does not yet match DeepXDE hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                  | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 170 | NVIDIA Modulus           | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for physics-ML and surrogate modeling with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                    | Kalika exceeds a standalone NVIDIA Modulus model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                  | Kalika does not yet match NVIDIA Modulus hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                           | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 171 | PySR                     | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for symbolic regression with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                                  | Kalika exceeds a standalone PySR model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                            | Kalika does not yet match PySR hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                     | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 172 | Eureqa                   | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for symbolic regression system with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                           | Kalika exceeds a standalone Eureqa model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                          | Kalika does not yet match Eureqa hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                   | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 173 | AI Feynman               | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for physics-guided symbolic regression with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                   | Kalika exceeds a standalone AI Feynman model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                      | Kalika does not yet match AI Feynman hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                               | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 174 | gplearn                  | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for genetic programming symbolic regression with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                              | Kalika exceeds a standalone gplearn model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                         | Kalika does not yet match gplearn hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                  | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 175 | scikit-learn             | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for classical machine learning with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                           | Kalika exceeds a standalone scikit-learn model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                    | Kalika does not yet match scikit-learn hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                             | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 176 | XGBoost                  | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for gradient-boosted decision trees with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                      | Kalika exceeds a standalone XGBoost model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                         | Kalika does not yet match XGBoost hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                  | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 177 | ONNX Runtime             | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for portable model inference runtime with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                                     | Kalika exceeds a standalone ONNX Runtime model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                    | Kalika does not yet match ONNX Runtime hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                             | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |
| 178 | Ray                      | Machine learning, differentiable programming, symbolic regression, and neural physics | Kalika matches the research workflow for distributed Python execution and ML workflows with AD, neural-physics fixtures, symbolic regression, tensor-network contractions, and research-agent evaluation paths.                                        | Kalika exceeds a standalone Ray model workflow by keeping learned outputs connected to exact expressions, verification checks, citations, and deterministic benchmark evidence.                             | Kalika does not yet match Ray hardware acceleration, model zoo breadth, distributed training stack, or production serving ecosystem.                                      | Close the gap with backend bindings, differentiable solver benchmarks, model-card provenance, and external accelerator baselines in the phase benchmark registry.                                                         |

## Category Coverage

| Category                                                                              | Systems | Kalika packages                                                                                                           |
| ------------------------------------------------------------------------------------- | ------: | ------------------------------------------------------------------------------------------------------------------------- |
| Computer algebra, exact arithmetic, and symbolic kernels                              |      20 | @kalika/core, @kalika/number-theory, @kalika/typesetting                                                                  |
| Algebra, arithmetic geometry, computational geometry, and polyhedral tools            |      20 | @kalika/algebra, @kalika/algebraic-geometry, @kalika/algebraic-combinatorics, @kalika/positive-geometry, @kalika/tropical |
| Numerical analysis, solvers, meshing, and HPC kernels                                 |      20 | @kalika/numerical, @kalika/optimization, @kalika/fluid-dynamics, @kalika/hpc-orchestrator, @kalika/neural-physics         |
| Optimization modeling, convex solvers, nonlinear solvers, and bootstrap SDP           |      18 | @kalika/optimization, @kalika/bootstrap, @kalika/autodiff                                                                 |
| Formal verification, theorem proving, SMT, ATP, and decidable logics                  |      18 | @kalika/formal-verification, @kalika/core, @kalika/research-agents                                                        |
| High-energy physics, QFT algebra, event formats, and phenomenology                    |      18 | @kalika/quantum-field-theory, @kalika/hep-phenomenology, @kalika/lattice, @kalika/statistical-mechanics                   |
| Relativity, numerical relativity, gravitational waves, cosmology, and astronomy       |      16 | @kalika/general-relativity, @kalika/gravitational-waves, @kalika/cosmology, @kalika/astrophysics                          |
| Topology, manifolds, computational geometry, meshing, and TDA                         |      16 | @kalika/topology, @kalika/three-manifolds, @kalika/geometric-analysis, @kalika/symplectic, @kalika/numerical              |
| Notebooks, knowledge graphs, publishing, visualization, and mathematical rendering    |      16 | @kalika/notebooks, @kalika/renderer, @kalika/knowledge-graph, @kalika/citations, @kalika/typesetting, @kalika/sdk         |
| Machine learning, differentiable programming, symbolic regression, and neural physics |      16 | @kalika/autodiff, @kalika/neural-physics, @kalika/symbolic-regression, @kalika/research-agents, @kalika/tensor-networks   |
