{"id":"bf010828-3123-46bc-ba92-c29f8c685e41","arxiv_id":"2505.09433","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"SerLiC compresses LiDAR reflectance losslessly by serializing points along the sensor's scan order and using a Mamba sequence model to predict each value, beating prior codecs by up to 22% in bitrate with 98% fewer parameters.","lead":"A new neural compressor, SerLiC, encodes the reflectance values in LiDAR point clouds losslessly by ordering points the way the sensor scans them and predicting each point from its neighbors. It reports smaller compressed files than existing codecs while being far lighter and faster, which matters for autonomous driving and robotics.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Table 1's headline gains use SerLiC-Light bpp, not the standard SerLiC model; the abstract's 22%-vs-Unicorn and 2x-volume claims mix model variants and fail on KITTI/Ford at standard bpp.","rationale":"The paper has a plausible core: serializing along laser scan order is a reasonable inductive bias, the ablations in Tables 4-6 are internally consistent, and the Mamba-based autoregressive coder is well motivated. I read the central claim as the quantitative headline in the abstract. For that claim to hold, the reported bit-rate reductions must be attributable to the model described as SerLiC (2.2M parameters, Table 3). They are not: every 'SerLiC vs baseline' gain in Table 1 is numerically the gain of SerLiC-Light (111K), while the '2% parameters' sentence refers to the full 2.2M model. This is not a subtle statistical issue; it is determinable from the table's own arithmetic. The 'over 2x volume reduction' phrase is likewise unsupported on KITTI and Ford with the standard model, and only holds on nuScenes (or possibly Ford with the light model). This concern does not require new experiments to test, but it changes what can be claimed from the paper. I therefore keep the reader's CONDITIONAL verdict but sharpen the condition: the authors must either report standard-model gains in the headline or explicitly state that the SOTA comparisons use the lightweight model, and must qualify the 2x claim by dataset. If those corrections are not made, the verdict should be REJECT. I partially agree with the reader's weakest assumption: serialization sensitivity to L and W is a real reproducibility concern (W is never reported), but the arithmetic discrepancy in the central claim is more immediately load-bearing.","tokens_in":19720,"tokens_out":10735,"duration_ms":106793,"concrete_test":"Recompute Table 1's percentage-gain columns from the reported BPP values using the standard SerLiC column instead of SerLiC-Light, and recompute compression ratio against original reflectance bit depth (7-bit KITTI, 8-bit Ford/nuScenes) for both model variants. If the corrected numbers are KITTI 20.1% vs RAHT and 11.2% vs Unicorn, and Ford 1.86x, then the abstract and table must be revised to attribute the 22% and >2x numbers to SerLiC-Light only, or the central claim is unsupported.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"Recomputing Table 1 from its own BPP columns shows that the 'SERLIC VS. RAHT/PREDLIFT/UNICORN' gain columns are computed from the SerLiC-Light column, not the standard SerLiC column. On KITTI, average RAHT bpp is 4.88, standard SerLiC is 3.90, and SerLiC-Light is 3.64; the reported 25.41% gain equals (4.88-3.64)/4.88, while the standard model gives only 20.08%. The final 'VS. LIGHT' column (6.67% on KITTI, corresponding to 3.90 vs 3.64) confirms that the gain columns are light-based. On Ford, the reported 22.74% gain vs Unicorn equals (4.97-3.84)/4.97; standard SerLiC gives 13.68%. Thus the abstract's 'outperforming the state-of-the-art by up to 22% ... using only 2% of its parameters' attaches a 111K-light-model gain to a 2.2M-model parameter claim. The 'over 2x volume reduction' claim is also dataset-dependent: against 7-bit KITTI reflectance, standard SerLiC gives 7/3.90=1.79x and even SerLiC-Light gives 7/3.64=1.92x; Ford standard gives 8/4.29=1.86x. Only nuScenes exceeds 2x (8/2.78=2.88x). These are arithmetic inconsistencies in the central claim, independent of code availability.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper presents SerLiC, a lossless neural coding method for LiDAR reflectance attributes. The method serializes an unordered point cloud into 1D sequences using per-point laser and azimuth indices derived from spherical coordinates, then applies a Mamba-based autoregressive entropy model with window-level and sequence-level parallelization. Experiments on KITTI, Ford, nuScenes, and InnovizQC compare SerLiC against G-PCC (RAHT and Predlift), L3C2, and Unicorn in bits per point, with additional ablation studies on context design, window size, network size, and runtime. The paper reports lower bitrates than the baselines at a fraction of the parameter count and latency.","tokens_in":20135,"tokens_out":6739,"duration_ms":61014,"significance":"If the reported numbers are taken at face value, SerLiC is a practical and simple contribution to LiDAR attribute compression: the device-centric serialization is intuitive, the use of Mamba gives linear decoding complexity, and the model is small and fast. The evaluation follows a standard lossless coding protocol with held-out test frames, multiple external baselines, and ablations that cover each design choice. However, the headline claims in the abstract and introduction mix two model variants and overstate the compression ratio on two of the three main datasets, so the paper's central quantitative claims need correction before the contribution can be assessed.","major_comments":[{"comment":"The compression-gain percentages reported for 'SerLiC' are computed from the SerLiC-Light bpp column, not the standard SerLiC column. For KITTI, the average RAHT gain of -25.41% equals (4.88-3.64)/4.88, whereas the standard model gives (4.88-3.90)/4.88 = -20.08%; for Ford, the -22.74% vs Unicorn equals (4.97-3.84)/4.97, while standard SerLiC gives (4.97-4.29)/4.97 = -13.68%. Table 2 repeats this by listing SerLiC-Light bpp (3.57, 4.11) under the heading 'SerLiC'. Because the abstract's 'up to 22% ... using only 2% of its parameters' pairs a light-model gain with a full-model parameter count, the central efficiency claim is numerically inconsistent.","section":"Table 1, Table 2, Abstract"},{"comment":"The claim of 'over 2x volume reduction against the original reflectance data' is not supported by the reported bpp for standard SerLiC on KITTI and Ford. With the paper's own numbers, standard SerLiC achieves 7/3.90 = 1.79x on KITTI and 8/4.29 = 1.86x on Ford; only nuScenes (8/2.78 = 2.88x) exceeds 2x. Even SerLiC-Light gives 1.92x on KITTI. The claim should be qualified per dataset or recomputed with the correct model variant.","section":"Abstract, Section 4.3"},{"comment":"The serialization sorts points by laser index v_i and azimuth index u_i, but points that share the same (v_i,u_i) bin are not given a deterministic ordering. Since the input point cloud is described as unordered (Section 3.1) and the decoder must reconstruct the identical sequence to decode reflectance values losslessly, the lack of a tie-breaking rule leaves the codec under-specified and potentially non-reproducible. The paper should specify how ties are resolved and verify encoder-decoder consistency.","section":"Section 3.2, Reordering"},{"comment":"The experiments do not report the angular resolution values L and W used for each dataset, nor any analysis of how sensitive the bitrate is to errors in these parameters. The serialization's physical grounding depends on these values; without this information, the robustness claim is not fully supported, and the method cannot be reimplemented from the paper alone.","section":"Section 4.1, 4.2, 4.5"}],"minor_comments":[{"comment":"The cross-entropy notation p(X_l|C*_l) does not show the autoregressive conditioning on previous reflectance values that is explicit in Eq. (9); please make the notation consistent.","section":"Section 3.1, Eq. (2)"},{"comment":"The paragraph reports gains on InnovizQC but does not describe how the scan-order serialization is adapted to a non-rotational sensor; please add the adaptation details or clearly state that the same method is applied unchanged.","section":"Section 4.5, Non-Rotational Adaptation"},{"comment":"The column labels do not distinguish the standard SerLiC model from SerLiC-Light, which is a source of the confusion documented in the major comments; please label each model configuration explicitly in the table and caption.","section":"Table 1 and Table 2 captions"},{"comment":"The '1000x Smaller' and '50x Smaller' annotations are not defined in the caption; please clarify what quantities are compared (e.g., parameter count versus Unicorn).","section":"Figure 1(e)"}],"recommendation":"major_revision","confidential_remarks":"The numerical inconsistency in the headline claims appears to stem from table construction rather than from a flawed method. The paper's core idea is sound and the experimental setup is generally appropriate, but the abstract and Tables 1-2 must be corrected to report gains for the standard model separately from the light model, and the 'over 2x' claim should be qualified per dataset."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague —\n\nThe short version: the idea is genuinely new, the ablations are mostly solid, and the headline arithmetic is a mess. SerLiC serializes LiDAR points by scan order (laser index, azimuth index, radial distance) and codes reflectance with a Mamba autoregressive entropy model. That is the right inductive bias for LiDAR reflectance, and no prior neural attribute codec (Unicorn, CNeT/MNeT, PoLoPCAC) does this; L3C2 needs exact sensor parameters and is not neural. The ablations earn their keep: context components each contribute, window-size and depth/width sweeps are sensible, the attention-vs-Mamba comparison is fair, and the supplementary shows inter-sequence modeling buys nothing, which justifies the sequence-level parallelism.\n\nBut the headline claims do not survive contact with the paper's own tables. The gain columns in Table 1 are computed against SerLiC-Light, not the standard model. I re-did the arithmetic: on KITTI, the reported 25.41% vs RAHT equals (4.88−3.64)/4.88, where 3.64 is the light model; the standard model gives (4.88−3.90)/4.88 = 20.08%. On Ford, the 22.74% vs Unicorn equals (4.97−3.84)/4.97, again light; standard gives 13.68%. The \"over 2× volume reduction\" claim is dataset-dependent: 7/3.90 = 1.79× on KITTI and 8/4.29 = 1.86× on Ford at standard settings; only nuScenes (8/2.78 = 2.88×) clears 2×. So the abstract pairs the standard model's 2% parameter count with the light model's bitrate gains.\n\nWorse, the tables contradict each other. Tables 4–6 report the default full model at 3.64 bpp on KITTI with −25.41%; Table 1 credits those exact numbers to the light model and gives the standard model 3.90. Same dataset, same configuration, two different bpp values. Either the ablations used the light config or a table is mislabeled; as printed, the central result is not verifiable from the paper alone. The light model also appears to beat the standard model on KITTI and most nuScenes sequences, which nothing in the ablations explains.\n\nSmaller gaps: no KITTI train/test split is stated, no code, and the serialization premise gets no sensitivity analysis — KITTI and nuScenes are preprocessed (the paper says so when explaining why L3C2 cannot run), so L and W are inferred, and tie-breaking among points sharing a (v,u) bin is unexamined. The InnovizQC non-rotational test mitigates, but doesn't close it.\n\nNone of this kills the contribution. Even at the standard model's own numbers, SerLiC beats Unicorn by 11–14% with a fraction of the parameters and credible runtime, which is a solid within-field result that deserves referee time. But a referee should send it back for a re-tabled comparison separating standard and light variants, a corrected abstract, the training protocol, and ideally code. Reading group: worth a slot, mainly as a case study in how gain columns get computed.","headline":"Genuinely new serialization idea with solid ablations on the merits, but the abstract's headline gains are computed from the light model while the parameter claim belongs to the standard model — the central numbers must be re-tabled before they can be trusted.","tokens_in":20640,"tokens_out":14523,"would_cite":true,"duration_ms":124432,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"SerLiC losslessly compresses LiDAR reflectance to less than half its original size, beating prior learned codecs by up to 22% at 2% of their parameters.","keywords":["LiDAR reflectance compression","scan-order serialization","autoregressive entropy coding","state space model","Mamba","lossless point cloud compression","sensor-aware context"],"falsifier":"Take a fixed LiDAR frame and rerun SerLiC on the same coordinates with the point order randomly shuffled before serialization; if the bit rate barely changes, the scan-order prior is not what carries the gains, and if it degrades sharply, the ordering is essential. A second check is to vary the assumed angular resolutions $L$ and $W$, for example by $\\pm10\\%$ or with a wrong sensor model, and measure bits per point: the paper's physical-grounding argument predicts that mis-specified geometry should measurably erode the 17–23% advantage over the previous learned codec.","tokens_in":19563,"feed_emoji":"📡","tokens_out":7822,"duration_ms":72351,"temperature":0.7,"pith_summary":"The paper claims that lossless compression of LiDAR reflectance can be built on a device-centric inductive bias: reorder the point cloud into 1D sequences that follow the sensor's own scan pattern, then predict each point's reflectance from its scan index, its radial distance, and the reflectance of the immediately preceding point. It proposes SerLiC, which implements this with a Mamba-based autoregressive entropy model and arithmetic coding, and reports over 2× volume reduction against the raw reflectance, up to 22% fewer compressed bits than the previous best learned codec, and a 111K-parameter variant running above 10 frames per second. A sympathetic reader would care because reflectance is essential for downstream tasks such as pedestrian detection, yet prior compression methods treat LiDAR points as an unordered 3D cloud and pay for large 3D convolutions. The paper's core message is that the scan order itself is the correlation structure worth exploiting.","feed_headline":"LiDAR reflectance squeezed to half size with 2% of the parameters","feed_subtitle":"Scan-order serialization lets a Mamba model predict each reflectance from the point before it, halving raw data volume.","key_machinery":"The load-bearing mechanism is scan-order serialization plus a physics-informed token. Each Cartesian point is mapped to spherical coordinates, binned into a laser index $v_i$ and an azimuth index $u_i$ by Eq. (4), grouped by laser, and sorted by azimuth to form $L$ one-dimensional sequences; the previous point in such a sequence is the physically adjacent reflection of the same rotating beam. Each point is then tokenized as an embedding of $(v_i,u_i)$, a normalized radial distance $\\rho_i$, and the already-decoded reflectance of the preceding point, and the token sequence is passed through Mamba blocks whose output feeds a softmax classifier that produces the probability mass function for the current reflectance. A dual parallelization scheme processes sequences independently (justified by an ablation showing inter-sequence context adds no bitrate) and slices each sequence into windows, keeping the autoregressive dependency local while allowing parallel coding. The same machinery is what makes the paper's efficiency claims possible: linear-time sequence modeling replaces the cubic-time masked attention decoding of a windowed transformer.","core_discovery":"On its own terms, the paper establishes that LiDAR reflectance has a sequential structure that standard 3D point cloud codecs ignore: points captured by the same rotating laser in consecutive azimuth steps are strongly correlated, including correlations that are not captured by spatial proximity. SerLiC makes this structure explicit by computing a laser index $v_i$ and an azimuth index $u_i$ from each point's spherical coordinates, grouping points by laser, sorting by azimuth, and then coding each point autoregressively with previous reflectance as part of the context. The reported result is that this simple reordering turns lossless reflectance coding into a sequence-prediction problem that a small Mamba network solves well: on KITTI the method reaches 3.90 bits per point versus 4.88 for G-PCC RAHT and 4.39 for Unicorn, and on Ford 4.29 versus 5.16 and 4.97, with roughly 50x fewer parameters than Unicorn and about 10% of its GPU memory. The paper also demonstrates, through removal experiments on three detectors, that reflectance is load-bearing for object detection, which is why compressing it matters.","pith_inferences":["As an extension of the paper's ablation, prior reflectance alone already delivers a 19.67% gain over G-PCC RAHT on KITTI, which suggests most of the benefit comes from the ordering itself; a cheap testable extension is to replace Mamba with a much smaller 1D predictor or a conditional histogram on the serialized sequences and measure how much of the gain survives.","If scan-order serialization generalizes, similar gains should appear for other sensor-native attributes such as multiple LiDAR intensity channels, or for range-view image compression that uses the same beam-azimuth grid, because the underlying correlation is about the sensor geometry rather than the specific reflectance attribute.","A practical engineering inference is that real deployments would need per-sensor calibration of $L$ and $W$, and possibly learned estimation of those parameters from unlabeled sweeps, since the paper assumes the angular resolutions are known but does not study robustness to miscalibration.","Because the lossless baseline is now cheap and fast, a lossy extension becomes feasible that allocates bits according to downstream detection relevance rather than raw reflectance fidelity; the paper itself flags lossy coding as future work."],"forward_implications":["Lossless reflectance storage can be cut to roughly half, with reported averages of 3.90 bits per point on KITTI and 4.29 on Ford compared with 4.88 and 5.16 for G-PCC RAHT.","The method transfers to non-rotational LiDAR: on the InnovizQC sequences it reports about 39.7% average bitrate reduction relative to G-PCC RAHT.","Coding sequences independently loses nothing: adding inter-sequence context gave no bitrate gain, so laser sequences can be compressed in parallel without a rate penalty.","Mamba matches masked attention in compression quality while cutting decoding latency dramatically, for example 0.23 seconds versus 5.12 seconds per KITTI frame at window size 128.","A 111K-parameter variant runs above 10 frames per second without frame pipelining and above 30 with it, making real-time use plausible for autonomous-driving-style workloads."],"supporting_citations":[{"why":"Supplies Unicorn, the learned baseline whose bitrate and parameter count SerLiC must beat, and the main state-of-the-art comparison.","marker":"Wang et al., 2025"},{"why":"Supplies the G-PCC standard and its RAHT/Predlift modes, the anchors for all compression-gain percentages.","marker":"Zhang et al., 2024b"},{"why":"Supplies Mamba, the selective state space model that SerLiC uses for autoregressive prediction and linear-time decoding.","marker":"Gu & Dao, 2023"},{"why":"Supplies the SemanticKITTI dataset used for the main training and testing frames.","marker":"Behley et al., 2019"},{"why":"Supplies the Ford campus dataset used for the MPEG common test condition comparisons.","marker":"Pandey et al., 2011"},{"why":"Supplies the nuScenes dataset, a third benchmark with different LiDAR sensor characteristics.","marker":"Caesar et al., 2020"},{"why":"Supplies L3C2, the LiDAR-specific MPEG codec compared on Ford, and its reliance on detailed sensor parameters motivates SerLiC's lighter requirements.","marker":"Sébastien & Jonathan, 2021"},{"why":"Supplies the detector used to show that removing reflectance collapses pedestrian and cyclist average precision, justifying the downstream importance of reflectance compression.","marker":"Lang et al., 2019"}],"fun_headline_variants":["Serialized LiDAR scans halve reflectance data with a tiny Mamba","Scan-order serialization compresses LiDAR reflectance to half","Mamba-based codec shrinks LiDAR reflectance data by half","2x smaller LiDAR reflectance using scan-order serialization","Real-time LiDAR reflectance compression with 111K parameters"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that sorting points by sensor scan index and then reading them in that order exposes the dominant correlations in reflectance, so that the immediately preceding point's reflectance is the right primary context; if a LiDAR's angular resolutions $L$ and $W$ are unknown, or the point cloud has been preprocessed so that the coordinates no longer preserve the raw scan order, this serialization loses its physical grounding and the claimed gains have no reason to hold.","fun_headline_variants_meta":{"raw":{"variants":["Serialized LiDAR scans halve reflectance data with a tiny Mamba","Scan-order serialization compresses LiDAR reflectance to half","Mamba-based codec shrinks LiDAR reflectance data by half","2x smaller LiDAR reflectance using scan-order serialization","Real-time LiDAR reflectance compression with 111K parameters"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00064,"raw_usage":{"total_tokens":2962,"prompt_tokens":977,"completion_tokens":1985,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":593,"completion_tokens_details":{"reasoning_tokens":1899}},"tokens_in":593,"tokens_out":1985,"duration_ms":13793,"temperature":1.0,"reasoning_tokens":1899,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T21:31:55.526345+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a fixed LiDAR frame and rerun SerLiC on the same coordinates with the point order randomly shuffled before serialization; if the bit rate barely changes, the scan-order prior is not what carries the gains, and if it degrades sharply, the ordering is essential. A second check is to vary the assumed angular resolutions $L$ and $W$, for example by $\\pm10\\%$ or with a wrong sensor model, and measure bits per point: the paper's physical-grounding argument predicts that mis-specified geometry should measurably erode the 17–23% advantage over the previous learned codec.","supporting_citations":[],"review_version":1}