CARTS: A Multidisciplinary Overview

• CARTS is a multifaceted label encompassing methods in surgical robotics, recommender systems, e-commerce patterns, statistical learning, and physics education, each defined by local context and capitalization.
• In surgical robotics, CaRTS and TC-CaRTS integrate kinematics, differentiable rendering, and temporal constraints to achieve robust tool segmentation with high Dice scores under challenging conditions.
• In statistical learning, CARTs denote Classification and Regression Trees that employ greedy splitting and randomized soft routing to improve predictive performance and interpretability.

CARTS is not a single, monosemous research term. In arXiv-indexed literature and adjacent technical writing, it denotes several unrelated constructs: a causality-driven method for robot tool segmentation and its temporal extension in surgical vision, a multi-agent framework for recommendation textual summarization, the Shopping Cart pattern in business-to-consumer e-commerce, the plural form of Classification and Regression Trees in statistical learning, an adaptive 5G uplink sensing scheme for ISAC, and literal collision carts in physics education (Ding et al., 2022, Ding et al., 2022, Chen et al., 21 Jun 2025, Yuan et al., 2011, Blanquero et al., 2021, Hochreiter et al., 2014, Jiang et al., 18 Jul 2025, Wee, 2012). This breadth suggests that the term functions primarily as a domain-local label whose meaning is determined by capitalization, expansion, and research context.

1. Nomenclature and semantic range

Across the literature considered here, the label appears in several orthographic forms. Those forms are not interchangeable; they identify distinct research objects with different formalizations, datasets, and evaluation criteria.

Form	Domain	Meaning
CaRTS / TC-CaRTS	Surgical robotics	Causality-driven Robot Tool Segmentation; Temporally Constrained CaRTS
CARTS	Recommender systems / 5G ISAC / e-commerce pattern writing	Collaborative Agents for Recommendation Textual Summarization; Cooperative and Adaptive Resource Triggering and Stitching; Shopping Cart pattern (“CARTS”)
CARTs	Statistics and ML	Classification and Regression Trees

The most important terminological distinction is between acronymic usages and the statistical-learning usage. In statistical learning, “CARTs” refers to Classification and Regression Trees, an established family of tree methods rather than a newly coined acronym (Blanquero et al., 2021). By contrast, in surgical vision, recommender systems, and 5G ISAC, the uppercase forms name specific frameworks introduced in individual papers (Ding et al., 2022, Chen et al., 21 Jun 2025, Jiang et al., 18 Jul 2025).

A common misconception is to assume that “CARTS” always refers to shopping carts or decision trees. The literature does not support that assumption. Instead, the same surface form is reused across unrelated technical domains, with only local definitional stability. This suggests that disambiguation by field, title, and capitalization is essential.

2. CaRTS and TC-CaRTS in robot tool segmentation

In surgical robotics, CaRTS denotes “Causality-driven Robot Tool Segmentation from Vision and Kinematics Data,” a method that rejects the standard image-only causal graph $I \to S$ and instead adopts a complementary SCM in which latent robot and camera parameters $T$ and environment $E$ jointly generate both the observed image $I$ and the segmentation $S$ (Ding et al., 2022). In this formulation, the relevant inference target is not a direct pixel-to-mask mapping, but the recovery of true kinematics from image evidence and measured kinematics $T_m$.

The core CaRTS pipeline combines forward kinematics, differentiable rendering, and feature-space alignment. A differentiable renderer produces a synthetic image $\hat I$ and silhouette $\hat S$ for a candidate $T$, and a pretrained U-Net encoder extracts feature maps used by an Attentional Cosine Similarity loss. The optimization problem is written as

$\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$

Inference is performed by gradient-based updates on $T$0, initialized from measured $T$1, and the final rendered silhouette is taken as the segmentation. The implementation uses Pytorch3D, a standard U-Net encoder, Adam with learning rate $T$2, and typically $T$3–$T$4 optimization steps. On held-out in-domain test data, CaRTS achieves Dice $T$5; under counterfactual domain shifts including low brightness, smoke, blood, and altered background patterns, it remains at approximately $T$6, whereas an image-based HRNet + augmentation model drops from approximately $T$7 to approximately $T$8 (Ding et al., 2022).

The principal limitation of CaRTS is efficiency and observability. The method requires over $T$9 iterations of optimization to converge for a single image, and single-frame optimization admits many local minima under strong domain shifts. The temporal extension “Rethinking Causality-driven Robot Tool Segmentation with Temporal Constraints” introduces TC-CaRTS precisely to address these issues (Ding et al., 2022).

TC-CaRTS augments CaRTS with three modules: a temporal optimization pipeline, a kinematics correction network (KCN), and spatial-temporal regularization. The temporal pipeline separates time-variant kinematics and time-invariant base configuration, then alternates between updating KCN weights and taking a gradient step on the base configuration. The KCN is a small MLP $E$0 with five hidden layers of widths $E$1. Its input is a positional-encoded flattened sequence $E$2, with $E$3 joint-and-tool angles for two PSMs and sequence length typically $E$4, and its output is a correction vector $E$5. The corrected kinematics are defined by

$E$6

The spatial-temporal regularizer enforces small per-frame measurement error and smooth inter-frame motion:

$E$7

Here, $E$8 penalizes deviation from measured kinematics and $E$9 penalizes large jumps across frames. The empirical protocol uses the same nine 400-frame da Vinci videos as CaRTS, with $I$0 train, $I$1 validation, and $I$2 test sequence, and evaluates on regular plus counterfactual domains including smoke, bleeding, low brightness, and background change. Baselines include Colleoni et al., HRNet, Swin-Transformer, STCN, and CaRTS (Ding et al., 2022).

The principal empirical result is a speed-accuracy improvement. CaRTS requires approximately $I$3 iterations, approximately $I$4 s/frame, and $I$5 FPS to reach approximately $I$6 Dice on the regular domain, whereas TC-CaRTS reaches the same Dice in just $I$7 iterations at $I$8 s/frame and approximately $I$9 FPS, then plateaus. On the bleeding domain, single-iteration TC-CaRTS at $S$0 exceeds CaRTS with $S$1 iterations at $S$2. Across domains, reported Dice values are $S$3 versus $S$4 on regular, $S$5 versus $S$6 on smoke, and $S$7 versus $S$8 on bleeding for CaRTS and TC-CaRTS respectively, with low-light and background-change performance comparable and slightly higher or on par for TC-CaRTS. Ablations confirm that the temporal pipeline, KCN, and regularization each contribute to faster, more stable convergence (Ding et al., 2022).

The broader significance of CaRTS and TC-CaRTS lies in their hybrid model-based and learned formulation. Rather than abandoning geometry for purely image-based segmentation, they use forward kinematics and differentiable rendering to preserve robustness under blood, smoke, and lighting shifts while partially correcting inaccurate kinematics. The stated limitations remain important: the approach is still not real-time, and the original causal model assumes no occlusion (Ding et al., 2022, Ding et al., 2022).

3. CARTS as collaborative textual summarization for recommendation

In recommender systems, CARTS denotes “Collaborative Agents for Recommendation Textual Summarization,” a multi-agent LLM framework for generating short titles for grouped item displays such as product carousels (Chen et al., 21 Jun 2025). The task is formalized as constrained coverage maximization: given $S$9 items $T_m$0, catalog information $T_m$1, title $T_m$2, and reviews or descriptions $T_m$3, the goal is to produce a title $T_m$4 satisfying

$T_m$5

where $T_m$6 indicates semantic relevance and $T_m$7 encodes stylistic or policy constraints beyond length.

The framework decomposes the problem into three stages. The first is Generation-Augmented-Generation (GAG), in which a DISTILL agent extracts salient keywords for each item and a title generator produces an initial candidate $T_m$8 intended to maximize item coverage subject to the character budget. The second is the Refinement Circle, where an EVAL agent identifies uncovered items and checks length compliance, and a GEN agent revises the current title using both feedback and keyword context. The third is Arbitration, which runs GAG plus refinement $T_m$9 times with sampling diversity, uses a moderator to summarize candidate properties such as coverage count and length compliance, and applies an arbitrator to choose the final title (Chen et al., 21 Jun 2025).

The paper also states a convergence-style guarantee under stylized assumptions: with a $\hat I$0-reliable feedback agent and a $\hat I$1-reliable generator, one can show

$\hat I$2

A related corollary gives the expected number of iterations to reach $\hat I$3. These results frame the refinement loop as more than heuristic prompt chaining; it is presented as a structured collaborative process with explicit coverage semantics (Chen et al., 21 Jun 2025).

Implementation uses GPT-4o via API as the primary backbone, with Gemini-2.0, LLaMA-3, and GPT-3.5 also evaluated. Prompts include “Output $\hat I$4 short keywords…,” “Generate a module title $\hat I$5 words, must cover as many items as possible and be $\hat I$6 chars,” and “Point to at least one uncovered item… within 30 words.” Hyperparameters are $\hat I$7 keywords per item, $\hat I$8 characters, up to $\hat I$9 refinement rounds, $\hat S$0 candidate samples, temperature $\hat S$1, and top-$\hat S$2. No additional fine-tuning is used; behavior is induced by prompt engineering (Chen et al., 21 Jun 2025).

The experimental setup uses Amazon Review data from Beauty, Electronics, Fashion, and Home & Kitchen: $\hat S$3 anchors per category, each paired with $\hat S$4 similar items, for $\hat S$5 items total. Baselines are Vanilla GPT, CoT, LLM-CoT, and DRE. Metrics are BERTScore and an LLM Judge Score based on GPT-4o Chain-of-Steps judgment. Offline results show clear gains. In Beauty, CARTS achieves $\hat S$6 on LLM Judge / BERTScore, compared with $\hat S$7 for Vanilla and $\hat S$8 for LLM-CoT; in Electronics, Fashion, and Home & Kitchen, reported CARTS values are $\hat S$9, $T$0, and $T$1, respectively. Ablations show that removing refinement drops LLM Judge by up to $T$2 points and removing the arbitrator drops it by up to $T$3 points. Online A/B testing with 50/50 traffic reports statistically significant lifts of $T$4 CTR, $T$5 ATCR, and $T$6 GMV at $T$7 CI (Chen et al., 21 Jun 2025).

The limitations are explicitly operational: API latency, multi-round cost, and the possibility of hallucinated feedback or generation when prompts are misunderstood. The authors also note that the binary relevance function $T$8 could be replaced by richer continuous scorers. These caveats are important because they locate CARTS within practical recommender-system deployment rather than purely offline NLP benchmarking (Chen et al., 21 Jun 2025).

4. CARTS as the Shopping Cart pattern in B2C e-commerce

In software-pattern literature, CARTS refers to the Shopping Cart pattern described in “Patterns for Business-to-consumer E-Commerce Applications” (Yuan et al., 2011). Its intent is to model the online “shopping basket” metaphor: a customer accumulates selected products, reviews quantities and costs, and then turns that collection into an order and invoice. The stated problem is how a web shop can represent the intermediate state of a customer’s selection so that chosen items are visible, quantities can be updated or removed, and the process terminates in order and invoice generation.

The core class structure consists of Customer, ShoppingCart, CartItem, Product, Order, and Invoice. Customer owns a ShoppingCart; ShoppingCart contains CartItem; CartItem refers to Product; ShoppingCart becomes Order; and Order generates Invoice. The participant roles are correspondingly explicit: ShoppingCart aggregates CartItems and maintains the running total; CartItem holds a reference to exactly one Product and a quantity; Order is created by checking out a ShoppingCart and copies line-items; Invoice is generated from an Order for billing (Yuan et al., 2011).

The shopping flow is presented as a sequence. A customer invokes addItem(productId, qty), the cart queries Product.getPrice(), creates a CartItem, recalculates total price, and displays the updated cart. At checkout, the cart creates an Order, copies each CartItem into it, calls calcCost(), and triggers Invoice.generateFromOrder(order). This yields a canonical middle-layer pattern between catalog browsing and order fulfillment (Yuan et al., 2011).

The numerical layer is given by explicit cart calculations. If $T$9 is the number of distinct cart items, with $\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$0 and $\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$1 for item $\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$2, then

$\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$3

$\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$4

$\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$5

and

$\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$6

When discounts $\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$7 apply, the grand total becomes

$\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$8

These formulas formalize the bookkeeping semantics that the pattern assigns to ShoppingCart, CartItem, and Order (Yuan et al., 2011).

The pattern is explicitly composite. In the larger e-commerce domain model, the Catalog pattern provides Product and ProductInfo, the Shopping Cart pattern aggregates selected products into CartItems, and the Order & Shipment pattern uses those cart items as line items to create Orders, link to Shipments, and generate Invoices. A key integration note is that CartItem corresponds one-to-one with LineItem in Order & Shipment, so the duplicate class is removed and CartItem is reused by Order. CustomerProfile links back to the Catalog to support personalized recommendations (Yuan et al., 2011).

Security and validation are handled through RBAC instances and procedural checks. A Customer role has viewShoppingCart, addItem, and removeItem rights on its own cart; Manager or Employee has viewShoppingCart on any cart and updateProduct on Product. Availability validation in addItem checks product stock and available quantity, throwing OutOfStockException if violated. At checkout, the system verifies format and expiration of creditInfo, verifies shippingInfo completeness, and calls checkCustomerCredit(customerId, orderTotal) (Yuan et al., 2011).

The pattern is also positioned as a Semantic Analysis Pattern in a Computation-Independent Model for MDA. The guidance is to label it “CART,” annotate mandatory associations and operations, bind Money to a chosen currency library at the PSM stage, and implement ShoppingCart persistence via session or database tables. Extensions include SavedCart and ActiveCart, a TaxPolicy pattern for multi-currency or international tax rules, StockManager for real-time inventory checks, and Façade or Adapter for external ERP integration (Yuan et al., 2011).

5. CARTs in statistical learning

In statistics and machine learning, CARTs are Classification and Regression Trees. “Optimal randomized classification trees” describes CARTs as off-the-shelf techniques built by a greedy, top-down binary partitioning procedure that selects splitting predictor variables and associated thresholds node by node (Blanquero et al., 2021). At a branch node $\arg\min_T \; ACSLoss[\,f(I), f(R(T))\,].$9, the classical split can be expressed as

$T$00

where $T$01 measures impurity drop. The paper emphasizes the familiar limitations: local greedy choices can be globally suboptimal, hard splits create discontinuous boundaries, and class-specific error control is difficult (Blanquero et al., 2021).

The ORCT formulation replaces hard splits with randomized soft routing. For branch node $T$02,

$T$03

is the probability that observation $T$04 goes left, where $T$05 is a univariate CDF such as the logistic. Leaf-assignment probabilities are products of such routing probabilities over left and right ancestor sets, and the overall training objective is a continuous nonlinear program minimizing expected misclassification cost. The model includes constraints forcing each leaf to predict exactly one class and allowing optional lower bounds on class-specific true-positive rates. A key theorem states that at any optimal solution the leaf-label variables $T$06 become integer $T$07, despite being modeled continuously (Blanquero et al., 2021).

Empirically, ORCT is compared with CART (rpart), OC1, oblique.tree, OCT-H MIO, OCT-H LS, and Random Forests on UCI datasets including Sonar, Wisconsin, Credit Approval, Pima, German Credit, Ozone, Spambase, Gamma Telescope, Iris, Wine, Seeds, Thyroid, and Car. Reported findings are that ORCT substantially outperforms CART and OC1 even at depth $T$08, outperforms or matches OCT-H MIO, is often close to OCT-H LS, and on average lies within $T$09–$T$10 percentage points of a full Random Forest while yielding a single compact tree. Running times are on the order of seconds for $T$11, tens of seconds for $T$12, and a few minutes for $T$13–$T$14 (Blanquero et al., 2021).

A different but complementary use of CARTs appears in land-cover classification from airborne laser-scanning point clouds. In “Effects of Sampling Methods on Prediction Quality,” the authors use the R package rpart to grow classification trees for $T$15 geo-coded ALS points labeled into $T$16 ground-cover classes over the lower Rhine area (Hochreiter et al., 2014). Although the splitting rule is not stated explicitly, rpart’s default is to maximize decrease in Gini impurity,

$T$17

The study compares simple random sampling without replacement and a balanced stratified scheme designed to ensure representation of very rare classes such as “walls/buildings,” with only $T$18 points in $T$19 million (Hochreiter et al., 2014).

The evaluation uses three confusion-matrix-derived metrics:

$T$20

$T$21

and Cohen’s

$T$22

The experimental design comprises $T$23 sampling methods, $T$24 target sample sizes from $T$25 down to $T$26, and $T$27 replicates per setting, together with three fitting variants for stratified samples: no correction, post-stratification weights, and true class priors (Hochreiter et al., 2014).

The resulting trade-off is metric-dependent. If the goal is lowest total error or highest $T$28, simple random sampling is superior, even at very small sample sizes. If the goal is low average per-class error, balanced stratified sampling without weight or prior correction performs best. The paper explicitly cautions against automatically correcting stratification by weighting or prior adjustment when the evaluation metric rewards balanced per-class performance (Hochreiter et al., 2014). This is a useful reminder that “better CART performance” is not a context-free claim; it depends on the sampling design and on whether the criterion is aggregate accuracy, agreement, or rare-class sensitivity.

6. Additional technical usages: 5G ISAC and collision carts

In wireless sensing, CARTS denotes “Cooperative and Adaptive Resource Triggering and Stitching for 5G ISAC,” an uplink sensing scheme that fuses two CSI streams traditionally handled separately in 5G base stations: DMRS and SRS (Jiang et al., 18 Jul 2025). The stated motivation is that communication and sensing both depend on accurate, up-to-date CSI, yet current implementations treat these measurements as separate information streams. CARTS addresses that limitation through two coordinated components: channel stitching and compensation across asynchronous CSI estimates, and a real-time aperiodic SRS triggering algorithm that complements the uncontrollable DMRS schedule (Jiang et al., 18 Jul 2025).

The channel model is defined over a $T$29 MHz uplink band with $T$30 RBs at $T$31 kHz, $T$32 OFDM symbols per slot, and sub-band CSI estimates $T$33 stamped at times $T$34. Stitching proceeds in three stages. Spatial smoothing forms a time-weighted covariance matrix with weights $T$35, extracts its principal eigenvector, and rotates each sub-band accordingly. Time-domain alignment removes each sub-band’s internal phase slope and imposes a reference slope. Frequency-domain calibration estimates a complex gain $T$36 from overlapping or nearest measured sub-bands, after which the full-band estimate is assembled by keeping the most recent value for each subcarrier. Performance is evaluated by

$T$37

The adaptive SRS triggering algorithm uses urgency scores over users and preconfigured SRS resources to enforce coverage and non-redundancy (Jiang et al., 18 Jul 2025).

The reported results are trace-driven. CARTS achieves median NMSE approximately $T$38, $T$39-tile timing error no greater than $T$40 samples, and UE localization error approximately $T$41 m for $T$42 active UEs, versus $T$43 m for a periodic SRS-only baseline at $T$44 UEs. The abstract summarizes this as an NMSE of $T$45 and UE tracking accuracy of $T$46 cm while supporting twice the number of users as a periodic SRS-only baseline with similar performance. The system is described as standard-compliant because it uses only DCI Format $T$47 fields for aperiodic SRS and requires no RRC reconfiguration or vendor scheduling changes (Jiang et al., 18 Jul 2025).

A non-acronymic usage appears in physics education, where “collision carts” refers literally to idealized one-dimensional carts simulated in Easy Java Simulations (Wee, 2012). The model combines continuous motion between collisions,

$T$48

with a discrete collision update based on conservation of momentum and kinetic energy. For the perfectly elastic case, the post-collision velocities are

$T$49

The simulation design emphasizes world-view consistency with pen-and-paper representations, multiple representations through tables, graphs, and symbolic equations, and a game mode for concept testing (Wee, 2012).

The pedagogical contribution is explicitly hybrid rather than purely virtual. The paper recommends complementing the simulation with physical carts in order to provide tacit 3D experience, expose measurement errors, and reinforce the “just before” and “just after” structure of conservation laws. Student feedback is reported as relatively positive, with $T$50 reporting high gains in understanding after the session versus $T$51 before, over $T$52 finding the activity fun, and over $T$53 rating it valuable (Wee, 2012).

Taken together, these additional usages reinforce the broader pattern seen throughout the literature: “CARTS” is a highly overloaded label. In one domain it names a CSI-fusion and resource-triggering algorithm for 5G sensing, while in another the relevant term is simply literal carts used to teach one-dimensional collisions. The only stable encyclopedia-level treatment, therefore, is contextual rather than singular.