Fast Surgery: Speeding Up Medical & Quantum Procedures

Updated 14 July 2026

Fast Surgery is a heterogeneous research theme that minimizes latency in both operative procedures and quantum logical measurements.
It leverages advanced techniques such as lightweight residual backbones, efficient frame pruning, and Gaussian splatting to achieve high FPS and reduced processing delays.
In quantum error correction, fast surgery methods reduce syndrome-round overhead through constant-time logical measurements and optimized ancilla scheduling.

Fast Surgery is a heterogeneous research theme centered on reducing time overhead in systems that support surgery and, in a distinct quantum-information usage, in code-surgery primitives for fault-tolerant computation. In operative medicine, the term encompasses real-time instrument segmentation, low-latency surgical video understanding, rapid deformable-scene reconstruction, autonomous field clearing, and high-speed tissue ablation; in quantum error correction, it denotes surgery schemes that replace the usual $O(d)$ syndrome-round overhead with constant-time or amortized-constant-time logical measurement (Pakhomov et al., 2020, Kerse et al., 2014, Baspin et al., 6 Oct 2025).

1. Scope, meanings, and speed metrics

The term is used in at least two distinct literatures. In minimally invasive and robotic surgery, “fast” usually refers to end-to-end latency, frame rate, or time-to-utility: examples include segmentation at up to 125 FPS on $1024\times1280$ images, rendering at 338.80 fps, deformation recovery at 15Hz, and automatic mapping of a 1-hour video in about 15 minutes (Pakhomov et al., 2020, Yang et al., 2024, Zhou et al., 2020, Kiyasseh, 23 Mar 2026). In laser intervention, “fast” denotes higher ablation throughput, specifically 0.75 mm $^3$ /min in burst-mode femtosecond soft-tissue removal (Kerse et al., 2014). In quantum fault tolerance, it denotes constant or amortized-constant syndrome-round overhead, including a constant number of rounds of syndrome measurement for generalized surgery on QLDPC codes and constant time overhead ( $O(1)$ ) in amortization on 2D hypergraph product codes (Baspin et al., 6 Oct 2025, Chang et al., 2 Mar 2026).

Domain	Representative object	Speed notion
Surgical vision	Instrument/video segmentation	FPS or ms latency
Surgical reconstruction	4D tissue modeling	Training time and rendering speed
Surgical intervention	Laser ablation or suction	Tissue-removal rate or reaction time
Quantum code surgery	Logical measurement	Syndrome rounds or execution-time overhead

A common misunderstanding is to treat “Fast Surgery” as a single technique. The literature instead uses the phrase for a family of time-reduction strategies that operate at different layers: perception, reconstruction, control, training infrastructure, and quantum logical operations. What unifies them is not modality but the systems objective of reducing delay without discarding fault tolerance, segmentation quality, geometric fidelity, or safety margins.

2. Real-time perception and scene understanding

In robotic and endoscopic vision, fast surgery has first been framed as a speed/accuracy tradeoff problem rather than an accuracy-only benchmark. “Searching for Efficient Architecture for Instrument Segmentation in Robotic Surgery” designed a lightweight residual backbone for high-resolution instrument segmentation, then used differentiable dilation search to recover accuracy “without any additional parameters or computational overhead.” On the EndoVis 2017 Robotic Instruments dataset, the resulting model reached up to 125 FPS on $1024\times1280$ images; on a Tesla P100, Light ResNet-18-v2 w/ Learnt Dilations achieved 7.95 ms, binary IOU 0.852, and parts IOU 0.729 (Pakhomov et al., 2020). The method preserved ImageNet-pretraining compatibility and targeted the principal runtime bottleneck of dilated high-resolution backbones: late high-channel layers operating on large feature maps.

A later foundation-model adaptation, “Surgical SAM 2: Real-time Segment Anything in Surgical Video by Efficient Frame Pruning,” kept the SAM2 segmentation pipeline largely intact but replaced sequential memory-bank retention with cosine-similarity-based Efficient Frame Pruning. With $n=5$ and $m=2$ , the method pruned the 2 most similar frames among the last 5, while always retaining the first frame as a persistent anchor. On an RTX A6000 48GB GPU with ViT-Small and bfloat16, the fine-tuned system reached about 86 FPS, roughly 3× FPS compared with SAM2, with inference memory around 1.02–1.09 GB; on EndoVis17, one-point prompting improved Dice from 85.1% to 87.3% while increasing speed from 29 to 86 FPS (Liu et al., 2024).

The same latency logic has recently been extended to non-GPU-oriented architectures. “Surgical Scene Segmentation using a Spike-Driven Video Transformer with Real-Time Potential” introduced SpikeSurgSeg, a spike-driven Conv+Transformer video model with surgical-scene masked autoencoding pretraining. On EndoVis18, the small model achieved 41.65% mIoU at 8.2 ms and 40.8 mJ, while the larger model achieved 43.21% mIoU at 35.9 ms and 178.8 mJ on the AMD Xilinx ZCU104 estimate; the paper reports inference latency reduced by at least $8\times$ and over $20\times$ relative to most foundation-model baselines (Zou et al., 24 Dec 2025). The operative claim is not absolute state-of-the-art accuracy on every class, but non-GPU real-time potential under strict power and latency constraints.

A related efficiency-oriented foundation model is “General surgery vision transformer: A video pre-trained foundation model for general surgery,” which paired an EfficientViT-derived backbone with forward video prediction on 680 hours of video across 28 procedures. GSViT reported 10,621 images/second, 10.6 images/millisecond, and $12.1 \pm 0.1$ ms per image on a single 12GB NVIDIA RTX A5500 GPU, while obtaining $1024\times1280$ 0 accuracy on Cholec80 with 13.7M tunable parameters (Schmidgall et al., 2024). Taken together, these works suggest that fast surgical perception is increasingly defined by compact backbones, aggressive memory control, and task-specific pretraining rather than by large decoder stacks or long temporal windows at inference.

3. Deformation recovery, 4D reconstruction, and real-time visualization

Fast surgery in reconstruction addresses a different latency bottleneck: dynamic tissue geometry must be updated quickly enough that navigation, AR overlays, or scene models do not lag behind deformation. “Real-time Surface Deformation Recovery from Stereo Videos” estimated surface motion from stereo by combining ICP, ORB feature matching, and an ARAP regularizer with dense control-point connections. The system was designed for GPU parallel computing, achieved an update rate of 15Hz, and reported accuracy of less than 2.5 mm on a NVIDIA Titan X GPU; on the Hamlyn phantom dataset it achieved RMSE < 1 mm with 32.7 ms/frame, and in EM-tracked porcine liver validation the mean error was 1.06 mm with standard deviation 0.56 mm (Zhou et al., 2020). Its two main technical additions were a 1-point RANSAC and reweighting method for non-rigid ORB inlier preselection and a denser ARAP cost that improved smoothing under limited iterations.

NeRF-style dynamic reconstruction initially delivered strong fidelity but poor turnaround. “Neural LerPlane Representations for Fast 4D Reconstruction of Deformable Tissues” reparameterized a surgical scene as six explicit 2D planes: three spatial planes for the static field and three space-time planes for the dynamic field. On EndoNeRF, it reached comparable quality in 3 minutes against an around 14 hours EndoNeRF baseline, with experimentally nearly 280-fold acceleration; at 10 minutes, LerPlane outperformed both E-DSSR and EndoNeRF in all metrics (Yang et al., 2023). The acceleration came from explicit factorization, bilinear interpolation, element-wise feature fusion, a tiny MLP decoder, and a spatiotemporal importance sampler that emphasized tool-occluded and high-motion regions.

Gaussian splatting then pushed the same trend further. “Deform3DGS: Flexible Deformation for Fast Surgical Scene Reconstruction with Gaussian Splatting” reported PSNR 37.90, 64 seconds training time, and 338.80 fps rendering on EndoNeRF, and 66 seconds plus 330.37 fps on StereoMIS (Yang et al., 2024). Its flexible deformation modeling used 17 learnable Gaussian basis functions per deformation channel, while motion-aware point fusion improved canonical initialization under occlusion. The paper’s one-minute-per-scene regime directly targeted intraoperative feasibility rather than offline scene fitting.

A deployment-oriented extension is “G-SHARP: Gaussian Surgical Hardware Accelerated Real-time Pipeline,” which built a surgical pipeline natively on GSplat (Apache-2.0) and reported 37.98 dB PSNR, 2 min training, and > 60 FPS rendering on EndoNeRF pulling, with a Holoscan application on NVIDIA IGX Orin and Thor (Nath et al., 2 Dec 2025). A plausible implication is that fast surgical visualization has shifted from purely algorithmic acceleration toward jointly optimized representation, licensing, and edge deployment. The contrast with implicit radiance fields is explicit throughout this line of work: speed is obtained by replacing repeated volumetric sampling and heavy MLP evaluation with explicit planes or Gaussians whose rasterization is naturally GPU-friendly.

4. Fast intervention: tissue removal and field clearing

In intervention rather than perception, fast surgery has been pursued through direct reduction of time-to-resection or time-to-visualization recovery. “Efficient, high-speed ablation of soft tissue with few-microjoule, femtosecond pulse bursts” showed that grouping femtosecond pulses into bursts could raise soft-tissue ablation throughput while avoiding the thermal damage associated with uniform high repetition rates. The reported brain-tissue result was about 1 mm $1024\times1280$ 1 removed in 80 s, corresponding to 0.75 mm $1024\times1280$ 2/min, with 3 $1024\times1280$ 3J pulse energy, 600 mW average power, and no discernible heat-induced collateral damage in burst mode, while uniform 200 kHz operation caused substantial thermal damage and devascularization (Kerse et al., 2014). The paper explicitly compared this with a prior 0.09 mm $1024\times1280$ 4/min report, yielding about 8.3× improvement, and emphasized that few-microjoule operation is compatible with eventual flexible-fiber delivery.

Hemostatic workflow offers another notion of speed. “Autonomous Robotic Suction to Clear the Surgical Field for Hemostasis using Image-based Blood Flow Detection” did not automate vessel closure; it automated the first phase of hemostasis, namely clearing flowing blood so the field becomes visible again. In benchtop trials on a dVRK setup, reaction times ranged from 2.6 s to 6.4 s, liquid suctioned ranged from 93.6% to 96.8%, and trajectory execution ranged from 23.9 s to 47.4 s depending on the injection site (Richter et al., 2020). The perception front end used CNN optical flow, an HMM over per-pixel blood states, and graph-based path planning that followed the blood stream upstream while favoring central pixels in the flow region.

These two examples also delimit the concept. Fast intervention does not automatically imply complete autonomy or full procedural acceleration. In laser ablation, the primary achievement is higher volumetric removal with reduced collateral injury; in autonomous suction, the contribution is faster restoration of a usable visual field, not definitive hemostasis. The shared objective is reduction of the time spent in rate-limiting bottlenecks.

5. Fast development loops, simulation throughput, and workflow mapping

A substantial part of the fast-surgery literature shifts attention from the operating room to the research and development loop. In surgical robotics, reinforcement learning is limited less by optimizer design than by the cost of generating contact-rich interaction data. “Surgical Gym: A high-performance GPU-based platform for reinforcement learning with surgical robots” moved both simulation and PPO training to the GPU and reported $1024\times1280$ 5 fps for pure simulation and $1024\times1280$ 6 fps for simulation plus learning on a single 8 GB NVIDIA Quadro RTX 4000, with headline speedups of 100–5000× faster training times compared with prior surgical learning platforms (Schmidgall et al., 2023). The platform scaled to 20,000 environments in parallel and used tensorized observation, reward, and action pipelines.

“FF-SRL: High Performance GPU-Based Surgical Simulation For Robot Learning” pursued the same principle with an NVIDIA Warp soft-tissue simulator and rl_games training on one GPU. On a laptop RTX 2060 Mobile GPU, it achieved $1024\times1280$ 7 fps for one environment, $1024\times1280$ 8 fps for 80 environments in simulation-only mode, and reduced a complex tissue manipulation task from over 5 hours to less than 24 minutes for one environment, or to less than 2 minutes at 32 environments (Dall'Alba et al., 24 Mar 2025). The paper explicitly framed this as acceleration of surgical robot learning rather than acceleration of intraoperative execution.

Workflow mapping applies the same logic to surgical video analytics. “A vision-LLM and platform for temporally mapping surgery from video” introduced Halsted, trained on 658,268 samples from 616 videos across 8 specialties, and reported 0.31 s to process a 10-second video clip on an NVIDIA A4000 GPU, equivalent to roughly 50 frames/s, with about 15 minutes to map a 1-hour video through the deployed platform (Kiyasseh, 23 Mar 2026). Because the platform reduces the burden of manual review, the speed gain is organizational: it shortens the time needed to turn raw operative video into structured timelines of procedure, step, action, anatomy, suturing phase, and proficiency. This suggests that fast surgery also includes faster analysis of surgery, not only faster execution during surgery.

6. Fast surgery in quantum error correction

In quantum information, “surgery” denotes fault-tolerant logical measurement by temporarily merging code blocks or deforming a code. The relevant speed metric is the number of noisy syndrome-measurement rounds. Earlier lattice-surgery work on triangular 4.8.8 color codes already emphasized that lattice surgery uses fewer qubits and the same time or less than defect braiding, and that color-code lattice surgery can implement Hadamard and phase in a single transversal step; the optimized logical CNOT depth was $1024\times1280$ 9 rounds (Landahl et al., 2014). That line established the general idea that “fast” can mean reducing logical gate time without sacrificing topological protection.

Recent QLDPC work makes the term more literal. “Fast surgery for quantum LDPC codes” introduced a generalized-surgery scheme using a constant number of rounds of syndrome measurement, with the merged code constructed as the total complex of the base code and a homomorphic ancilla chain complex (Baspin et al., 6 Oct 2025). In its Abelian multi-cycle-code example, the merged code had parameters $^3$ 0 and the procedure achieved fault distance $^3$ 1 while numerically performing comparably to standard generalized surgery with multiple rounds. The central technical move was to encode syndrome protection into the ancilla complex itself, so that one-round measurement could be fault-tolerant.

A broader abstract framework appeared in “Fast and fault-tolerant logical measurements: Auxiliary hypergraphs and transversal surgery,” which stated that generic surgery operations need $^3$ 2 repeated syndrome rounds, then gave general conditions for constant time overhead, introduced block reading, studied intermediate overheads between $^3$ 3 and $^3$ 4, and established a circuit equivalence between homomorphic measurement and hypergraph surgery (Cowtan et al., 16 Oct 2025). The paper’s abstract explicitly argued that achievable measurement time overhead is determined chiefly by the connectivity between a code and its measurement ancilla system, rather than by single-shot quantum memory alone.

On 2D hypergraph product codes, “Constant-Time Surgery on 2D Hypergraph Product Codes with Near-Constant Space Overhead” made the constant-time claim precise in amortized form: surgery gadgets perform parallel logical measurements with constant time overhead ( $^3$ 5) and near-constant space overhead ( $^3$ 6), because performing $^3$ 7 surgery operations in $^3$ 8 time is fault tolerant (Chang et al., 2 Mar 2026). A common misreading is to equate constant-time surgery with a standalone isolated $^3$ 9-round operation; in this setting the claim is explicitly amortized, not per-operation worst-case latency.

Two adjacent developments further sharpen the picture. “Efficient and high-performance routing of lattice-surgery paths on three-dimensional lattice” reduced the execution time of benchmark programs generated from quantum phase estimation by 2.7 times compared with a naive greedy scheduler, using Dijkstra projection to treat surgery scheduling as 3D path routing (Hamada et al., 2024). “Parsimonious Quantum Low-Density Parity-Check Code Surgery” then reduced the ancilla size for measuring an arbitrary logical Pauli of weight $O(1)$ 0 from $O(1)$ 1 to $O(1)$ 2 and propagated that improvement to fast-surgery schemes, including a reduction of constant-time surgery space overhead from $O(1)$ 3 to $O(1)$ 4 (Yuan et al., 5 Mar 2026). This suggests that fast surgery in the quantum sense now rests on three coupled optimizations: fewer syndrome rounds, more efficient spacetime routing, and smaller ancilla systems.

Across both medical and quantum usages, Fast Surgery therefore denotes a shift from static correctness criteria to explicit optimization of latency, throughput, and time-to-utility. In surgical AI, that shift is visible in frame pruning, lightweight residual backbones, Gaussian splatting, spike-driven transformers, and GPU-resident simulators. In quantum error correction, it is visible in constant-round generalized surgery, hypergraph ancillas, amortized constant-time measurement, and low-overhead scheduling and ancilla design. The shared principle is that speed is treated as a first-class systems objective rather than a secondary benchmark statistic.