SMTB: Fast Structure-Mapping with Tight Bounds
Daniel Weitekamp, Christopher MacLellan
cs.AI
Quick verdict
SMTB claims 5-15x speedups and ~50% better mappings than SME in large domains; dual-objective eval on 5845 pairs is persuasive, but timing mixes C++ vs Lisp.
Summary
The paper introduces SMTB (Structure-Mapping with Tight Bounds), a new structure-mapping algorithm inside the open-source Cognitive Rule Engine (CRE), a Python-accessible C++ toolkit. Unlike the 40-year-old Structure-Mapping Engine (SME), SMTB assigns correspondences incrementally, entity by entity, rather than through higher-order kernels, and does not privilege higher-order relations — a bias the authors argue is an arbitrary side effect of predicate-logic notation that fails on flat representations, cyclic graphs, and partial matches (illustrated with an algebra self-explanation example, Table 2). SMTB's bounded-backtracking search starts from a loose admissible bound, tightened via dependency-matrix one-step lookahead (Tables 5-6), plus a paired-walk connectivity bias. On 5845 domain pairs from the SME corpus against SME v4 in Allegro Common Lisp, SMTB (w=3, d=1) runs 5-15x faster (8.47s vs 70.95s corpus-wide) and scores 21.6-22.6% higher on its own objective; for problems with more than 128 entities it reaches 1.80x on SMTB's objective and 1.52x on SME's own objective. With SME-forbidden kernel-violation correspondences removed (~1.2-1.8% of the total), corpus-level gains on the SME objective are 14.7-16.0% (Table 7). Gains concentrate in deeply nested domains (ap-physics +41.9% on the SME objective at L=3); geometry and oddity, 73% of the corpus, improve only ~1% with occasional small losses. Limitations: cross-language timing confound, no statistical uncertainty reporting, quality judged only by the two competing objectives, LLM-assisted corpus translation.
Review complete
Assessment at a glance
5
risk flags identified
● high 0
● medium 3
● low 2
5 strengths · 5 weaknesses · 5 author questions
AI text signal = Binoculars zero-shot detector score over 20 sampled passages (Fast-DetectGPT co-reported) — absence does not prove human authorship, and a flag does not imply misconduct.
Levels reflect verification complexity — not a quality score. Evolve never rates your paper.
Key claims under review
- SMTB in the w=3, d=1 configuration is 5-15x faster than SME v4 across problem sizes on the 5845-pair SME corpus (8.47s vs 70.95s corpus-wide).
- On problems with more than 128 entities, SMTB reaches 1.80x SME's score under its own objective and 1.52x under SME's SES objective.
- Explicitly privileging higher-order relations (SME's systematicity constraint 4b) is unnecessary: connectivity-based alignment suffices and avoids SME's failure modes on flat, cyclic, and partially matchable structures (Table 2 algebra example).
- A dependency-matrix lookahead tightens the naive admissible bound enough that greedy bounded-backtracking search with w=3, d=1 finds high-quality mappings without expensive backtracking.
- In deeply nested domains (ap-physics, moraldm), SMTB maps roughly 50% more mutually consistent correspondences than SME (Table 8: e.g., ap-physics base entities 20.1 vs 13.5).
Strengths
Dual-objective validation design
Section 5 scores SMTB's mappings under SME's own SES objective with kernel-violation correspondences removed (only 1.24-1.78% overall, Table 7); beating SME 1.52x on its own scale for >128-entity problems directly answers the different-objective confound.
Verified experimental controls
Head-to-head, single-threaded, same device, with starting match hypotheses verified identical between SMTB and SME (Section 5), isolating the search procedure as the manipulated variable.
Checkable algorithmic exposition
Concrete failure-mode demonstration
Honest boundary conditions
Weaknesses
Cross-language timing confound
Quality metric circularity
Gains concentrated off the bulk of the corpus
No uncertainty quantification
Unresolved technical loose ends
Full Review Report
$1.99 · one-timeUnlock the complete preliminary analysis Evolve produced for this paper.
Report preview
Scope & Claims
SMTB (Structure-Mapping with Tight Bounds) is a method paper from the Cognitive Rule Engine (CRE) project: a Python-accessible C++ toolkit that aims to do for cognitive systems what PyTorch did for deep learning. The claims are precise and quantitative: (1) 5-15x faster than SME v4 across problem sizes; (2) roughly 50% better mapping discovery in large nested domains — instantiated in Results as 1.80x on SMTB's objective and 1.52x on SME's own SES objective for problems with more than 128 entities (Section 6), plus ~50% more mapped entities/expressions in nested sub-corpora (Table 8, e.g., ap-physics base entities 20.1 vs 13.5); and (3) a conceptual claim that SME's systematicity bias toward higher-order relations (constraint 4b, Section 2.1) is an arbitrary notational artifact producing genuine failure modes (Section 3, Table 2 algebra example), and that relational connectivity alone suffices.
The framing is honest about where the gains live: below 64 entities the systems are nearly tied (at most 1.05x on SMTB's objective, 0.99-1.01x on SME's), and the win is explicitly confined to large, deeply nested problems.
The remaining sections cover Methodology Assessment, Statistical Evidence, Results & Reproducibility, Limitations & Risks, and Verdict & Recommendations.
- All 5 strengths & 5 weaknesses, analyzed in detail
- 5 risk flags with severity, section & reviewer questions
- Methods & statistical evidence assessment
- 5 questions a peer reviewer would ask
- Full six-dimension evaluation report & recommendations
One-time purchase · this paper only
One-time purchase, this paper only. AI-generated preliminary analysis — not peer review.
Frequently asked questions
What is SMTB and how is it different from SME?
SMTB (Structure-Mapping with Tight Bounds) is a structure-mapping algorithm: it aligns two relational descriptions (a base and a target) by shared structure rather than surface features. Unlike the classic Structure-Mapping Engine (SME, 1989), which assembles mappings from nested higher-order 'kernels' and privileges higher-order relations, SMTB assigns entities one-to-one incrementally using a tight upper-bound heuristic, and works equally over flat, cyclic, or nested relational graphs.
How much faster is SMTB than SME?
The authors report 5-15x speedups across problem sizes on 5,845 domain pairs from the SME corpus: SME v4 takes 70.95 seconds corpus-wide versus 8.47 seconds for SMTB in the w=3, d=1 configuration (roughly 8x aggregate). Note the comparison pits a C++ implementation against one written in Allegro Common Lisp on a single machine, so part of the gain may reflect implementation language rather than algorithm.
What does 'about 50% better at finding mappings' mean?
On problems with more than 128 entities, SMTB's mappings score about 1.8x SME's under SMTB's own objective and 1.52x under SME's own SES objective. In nested domains like ap-physics and moraldm, SMTB maps roughly 50% more base entities and expressions (Table 8: ap-physics 20.1 vs 13.5 base entities). On small problems under 64 entities the two systems perform nearly identically.
Is the code available?
SMTB is part of the Cognitive Rule Engine (CRE), published on GitHub (github.com/DannyWeitekamp/Cognitive-Rule-Engine) as a C++ framework with Python bindings. The paper does not state whether the translated 5,845-problem corpus or the per-pair result files are released; the corpus translation was LLM-assisted.
About this review
This is an AI-generated preliminary review by Evolve.Pub, produced from the openly available text of the paper. It is not peer review and does not represent the authors' views. The canonical record of the paper is at the publisher link above.
- Figure 1 (per-size score-ratio and runtime curves) is not analyzable from the extracted text; per-size numbers beyond those quoted in Section 6 could not be independently verified.
- Section 6 quotes a corpus runtime 'for L = 10' although Table 7's walk-depth grid is L in {0,1,3,5} — an unresolved inconsistency in the source text.
- The extraction contains minor typographical noise (e.g., inconsistent capitalization in headings); no substantive content appeared truncated, but all figure-dependent claims could not be checked.
Go deeper on this paper
Wrote a paper? Stress-test it before reviewers do.
Upload your manuscript for the same structured scrutiny — reasoning, statistics, evidence, figures, and reproducibility.