SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2106.09249 · 2021

Invisible for both Camera and LiDAR: Security of Multi-Sensor Fusion based Perception in Autonomous Driving Under Physical-World Attacks

arXiv · PDF · Open in the Atlas

Code that ran

13 of 20 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 13 have no contract verdict; 0 failures of our instrument; 7 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2106.09249.json · badge: /api/ran/2106.09249.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
ASGuard-UCI/MSF-ADV community (classifier label)
classifier basis not recorded on the link
13 ran · 7 no recorded run
FunctionStatusWhere it lives
DJSFind Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/cluster.py
code served (permissive licence) · get_code("7ef997c38a692004")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

class DisjointSetElement:
    def __init__(self, parent):
        self.parent = parent

grid = [
    DisjointSetElement(0),
    DisjointSetElement(1),
    DisjointSetElement(0),
    DisjointSetElement(2),
    DisjointSetElement(2),
]

x = 3

ARGS = {
    "grid": grid,
    "x": x,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DJSFindRecursive Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/cluster.py
code served (permissive licence) · get_code("6758cb0e62752d1e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

class DisjointSetElement:
    def __init__(self, index):
        self.parent = index

grid = [DisjointSetElement(i) for i in range(5)]

# Set up a chain: 0 -> 1 -> 2, 3 -> 3, 4 -> 4
grid[0].parent = 1
grid[1].parent = 2
grid[2].parent = 2
grid[3].parent = 3
grid[4].parent = 4

ARGS = {
    "grid": grid,
    "x": 0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_ray Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/render.py
code served (permissive licence) · get_code("c75aea10ccb39d17")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create small tensor arguments for the function
# The function expects x_final, y_final, z_final which are used in:
# - torch.pow() operations
# - torch.sqrt() operation
# - torch.div() operations
# - torch.stack() with dim=1

# Create tensors with shape (2, 4) - batch size 2, dimension 4
x_final = torch.randn(2, 4)
y_final = torch.randn(2, 4)
z_final = torch.randn(2, 4)

ARGS = {
    "x_final": x_final,
    "y_final": y_final,
    "z_final": z_final,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
groupPc2Pixel Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/c2p_segmentation.py
code served (permissive licence) · get_code("96451f3f663c7855")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - PT: indexed with [0] and [1], so it's array-like (list, tuple, or tensor)
# - inv_res_x: parameter exists but is not used in the function body
# - range_: used as a number in arithmetic operations

# PT should be a small array-like with at least 2 elements
PT = [30.5, 25.3]

# inv_res_x is not used, but we need to provide it
inv_res_x = 1.0

# range_ is already defined at module level as 60
range_ = 60

ARGS = {
    "PT": PT,
    "inv_res_x": inv_res_x,
    "range_": range_
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family int — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
mapPointToGrid Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/c2p_segmentation.py
code served (permissive licence) · get_code("73745a40802ffe29")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small point cloud with shape (N, 3) where N is number of points
# Each point has [x, y, z] coordinates
# Points should be chosen to exercise the function logic:
# - Some points within valid height range [-5.0, 5.0]
# - Some points outside height range
# - Some points that map to valid grid positions
# - Some points that map to invalid grid positions

PCL = np.array([
    [0.0, 0.0, 0.0],      # valid height, should map to grid
    [1.0, 1.0, 2.5],      # valid height, should map to grid
    [10.0, 10.0, -10.0],  # invalid height (too low)
    [5.0, 5.0, 6.0],      # invalid height (too high)
    [30.0, 30.0, 1.0],    # valid height but may map outside grid
    [-30.0, -30.0, -2.0], # valid height but may map outside grid
], dtype=np.float32)

ARGS = {
    "PCL": PCL
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
my_ransac Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/ground_detector_simple.py
code served (permissive licence) · get_code("0a647dcbd2ecc065")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import random
import math

# Create sample 3D point cloud data (N x 4 format)
# The function uses data[:, 2] for z-values and data[:, :3] for xyz coordinates
np.random.seed(42)
num_points = 2500
data = np.random.randn(num_points, 4).astype(np.float64)
# Adjust z-values to be in a reasonable range for the lidar_height filtering
data[:, 2] = np.random.uniform(-2.0, -1.5, num_points)
# Ensure we have enough points passing the z-filter
z_filter = data[:, 2] < (-1.73 + 0.4)
z_filter_down = data[:, 2] > (-1.73 - 0.2)
filt = np.logical_and(z_filter_down, z_filter)
# If not enough points pass filter, adjust z values
if np.sum(filt) < 200:
    data[:1000, 2] = np.random.uniform(-1.8, -1.6, 1000)

ARGS = {
    'data': data,
    'distance_threshold': 0.1,
    'P': 0.99,
    'sample_size': 3,
    'max_iterations': 1000,
    'lidar_height': -1.73 + 0.4,
    'lidar_height_down': -1.73 - 0.2,
    'first_line_num': 2000,
    'alpha_threshold': 0.05,
    'use_all_sample': False,
    'y_limit': 4
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
processPC Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/inject_cube.py
code served (permissive licence) · get_code("7a7d3e104a7ab70c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a point cloud with at least 7 columns (indices 0-6 are accessed)
# Columns: [0, 1, 2, 3, 4, 5, 6, ...]
# Column 5 is used for vertical filtering (min_v, max_v)
# Column 6 is used for horizontal filtering (min_h, max_h)

np.random.seed(0)

# Create PC with 10 points and 7 columns
PC = np.random.rand(10, 7) * 100

# Ensure some points fall within and outside the filter ranges
PC[:5, 5] = np.random.uniform(30, 70, 5)  # column 5 (vertical) - in range
PC[5:, 5] = np.random.uniform(0, 20, 5)   # column 5 (vertical) - out of range

PC[:5, 6] = np.random.uniform(40, 80, 5)  # column 6 (horizontal) - in range
PC[5:, 6] = np.random.uniform(0, 30, 5)   # column 6 (horizontal) - out of range

min_h = 35
max_h = 85
min_v = 25
max_v = 75

ARGS = {
    "PC": PC,
    "min_h": min_h,
    "max_h": max_h,
    "min_v": min_v,
    "max_v": max_v,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
rc2grid Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/c2p_segmentation.py
code served (permissive licence) · get_code("f29ebe1a2f55300d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    "r": 3,
    "c": 7
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
read_cali Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/attack.py
code served (permissive licence) · get_code("560fface17f291b4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import tempfile
import os

# Create a temporary calibration file with the expected format
temp_dir = tempfile.gettempdir()
cali_file = os.path.join(temp_dir, "test_calibration.txt")

# Write a sample calibration file with rotation and translation data
calibration_content = """Calibration Data
R: 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0
T: 0.5 0.3 0.2
"""

with open(cali_file, 'w') as f:
    f.write(calibration_content)

ARGS = {
    'path': cali_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
render Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/render.py
code served (permissive licence) · get_code("810e3276e34039fe")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Construct ray_direction: n_rays x 3
# These are normalized direction vectors
ray_direction = torch.tensor([
    [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0]
], dtype=torch.float32)

# Construct length: n_rays tensor
# Background distances for each ray
length = torch.tensor([50.0, 60.0], dtype=torch.float32)

# Construct vertex: n_vertices x 3
# Vertices of the mesh
vertex = torch.tensor([
    [0.0, 0.0, 0.0],
    [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0],
    [1.0, 1.0, 0.0]
], dtype=torch.float32)

# Construct face: n_faces x 3
# Triangle indices into vertex array
face = torch.tensor([
    [0, 1, 2],
    [1, 2, 3]
], dtype=torch.int64)

# Construct i_final: n_rays tensor
# Intensity or color values per ray
i_final = torch.tensor([0.5, 0.7], dtype=torch.float32)

ARGS = {
    'ray_direction': ray_direction,
    'length': length,
    'vertex': vertex,
    'face': face,
    'i_final': i_final
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
render_div Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/render.py
code served (permissive licence) · get_code("99bee8a1ad6f406f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Small mesh: 4 vertices, 2 triangular faces
vertex = torch.tensor([
    [0.0, 0.0, 0.0],
    [1.0, 0.0, 0.0],
    [0.0, 1.0, 0.0],
    [1.0, 1.0, 0.0]
], dtype=torch.float32)

# 2 faces, each face has 3 vertex indices
face = torch.tensor([
    [0, 1, 2],
    [1, 3, 2]
], dtype=torch.int32)

# 2 ray directions (normalized)
ray_direction = torch.tensor([
    [0.0, 0.0, 1.0],
    [0.1, 0.1, 0.9]
], dtype=torch.float32)

# Ray lengths for each ray
length = torch.tensor([70.0, 70.0], dtype=torch.float32)

# Ray indices (same size as number of rays)
i_final = torch.tensor([0.5, 0.8], dtype=torch.float32)

ARGS = {
    "ray_direction": ray_direction,
    "length": length,
    "vertex": vertex,
    "face": face,
    "i_final": i_final
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
xyz2grid Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/xyz2grid.py
code served (permissive licence) · get_code("50f11d1830ea88b9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (512, 512, 120) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.autograd import Variable

torch.manual_seed(0)

# Create small test tensors for x, y, z coordinates
# The function expects tensors that will be used in mathematical operations
x_var = torch.randn(2, 4, dtype=torch.float32)
y_var = torch.randn(2, 4, dtype=torch.float32)
z_var = torch.randn(2, 4, dtype=torch.float32)

# Scale them to reasonable ranges for the coordinate system
x_var = x_var * 10
y_var = y_var * 10
z_var = z_var * 5

ARGS = {
    'x_var': x_var,
    'y_var': y_var,
    'z_var': z_var,
    'X_RES': 512,
    'Y_RES': 512,
    'H_RES': 120
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (512, 512, 120) — shape (512, 512, 120) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
xyzi2gridhard Ran
ran on a synthesized input
ASGuard-UCI/MSF-ADV/xyz2grid.py
code served (permissive licence) · get_code("a59cf65f2fe6255f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 512, 512, 120) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.autograd import Variable

torch.manual_seed(0)

# Create small tensors for x, y, z, i variables
# The function expects these to be tensors that support operations like subtraction, addition, multiplication
batch_size = 2
spatial_dim = 4

x_var = torch.randn(batch_size, spatial_dim, dtype=torch.float32)
y_var = torch.randn(batch_size, spatial_dim, dtype=torch.float32)
z_var = torch.randn(batch_size, spatial_dim, dtype=torch.float32)
i_var = torch.randn(batch_size, spatial_dim, dtype=torch.float32)

ARGS = {
    'x_var': x_var,
    'y_var': y_var,
    'z_var': z_var,
    'i_var': i_var,
    'X_RES': 512,
    'Y_RES': 512,
    'H_RES': 120
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 512, 512, 120) — shape (2, 512, 512, 120) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
estimate_plane Not yet run
unverified (harvested, no recorded run)
ASGuard-UCI/MSF-ADV/ground_detector_simple.py
code served (permissive licence) · get_code("559aaaf2325a4e86")
How it ran

no invocation recorded.

injectCube Not yet run
unverified (harvested, no recorded run)
ASGuard-UCI/MSF-ADV/inject_cube.py
code served (permissive licence) · get_code("c9790fbf34397045")
How it ran

no invocation recorded.

injectCylinder Not yet run
unverified (harvested, no recorded run)
ASGuard-UCI/MSF-ADV/inject_cube.py
code served (permissive licence) · get_code("4bc27814ce2c2d13")
How it ran

no invocation recorded.

lossRenderAttack Not yet run
unverified (harvested, no recorded run)
ASGuard-UCI/MSF-ADV/loss_LiDAR.py
code served (permissive licence) · get_code("4eac161e796b8b53")
How it ran

no invocation recorded.

my_ransac_v3 Not yet run
unverified (harvested, no recorded run)
ASGuard-UCI/MSF-ADV/ground_detector_simple.py
code served (permissive licence) · get_code("f555463c4444b6aa")
How it ran

no invocation recorded.

predict_convert Not yet run
unverified (harvested, no recorded run)
ASGuard-UCI/MSF-ADV/attack.py
code served (permissive licence) · get_code("db86dfb6ec8f0a09")
How it ran

no invocation recorded.

xyzi2grid_v2 Not yet run
unverified (harvested, no recorded run)
ASGuard-UCI/MSF-ADV/xyz2grid.py
code served (permissive licence) · get_code("3c0901495eeeb97f")
How it ran

no invocation recorded.

Also present in other papers' code

Of 20 samples lifted from this paper's linked repositories, 20 carry a function identity and 0 do not. Of the 20 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 20 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

In Autonomous Driving (AD) systems, perception is both security and safety critical. Despite various prior studies on its security issues, all of them only consider attacks on camera- or LiDAR-based AD perception alone. However, production AD systems today predominantly adopt a Multi-Sensor Fusion (MSF) based design, which in principle can be more robust against these attacks under the assumption that not all fusion sources are (or can be) attacked at the same time. In this paper, we present the first study of security issues of MSF-based perception in AD systems. We directly challenge the basic MSF design assumption above by exploring the possibility of attacking all fusion sources simultaneously. This allows us for the first time to understand how much security guarantee MSF can fundamentally provide as a general defense strategy for AD perception. We formulate the attack as an optimization problem to generate a physically-realizable, adversarial 3D-printed object that misleads an AD system to fail in detecting it and thus crash into it. We propose a novel attack pipeline that addresses two main design challenges: (1) non-differentiable target camera and LiDAR sensing systems, and (2) non-differentiable cell-level aggregated features popularly used in LiDAR-based AD perception. We evaluate our attack on MSF included in representative open-source industry-grade AD systems in real-world driving scenarios. Our results show that the attack achieves over 90% success rate across different object types and MSF. Our attack is also found stealthy, robust to victim positions, transferable across MSF algorithms, and physical-world realizable after being 3D-printed and captured by LiDAR and camera devices. To concretely assess the end-to-end safety impact, we further perform simulation evaluation and show that it can cause a 100% vehicle collision rate for an industry-grade AD system.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2106.09249")
get_code_for_paper("2106.09249")
have("2106.09249")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2106.09249.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2106.09249.svg)](https://syntology.ai/paper/2106.09249)

Connect an agent — have() is free.