ifaamas \acmConference[AAMAS ’24]Proc. of the 23rd International Conference on Autonomous Agents and Multiagent Systems (AAMAS 2024)May 6 – 10, 2024 Auckland, New ZealandN. Alechina, V. Dignum, M. Dastani, J.S. Sichman (eds.) \copyrightyear2024 \acmYear2024 \acmDOI \acmPrice \acmSubmissionID33 \affiliation \institutionThe University of Tokyo \cityTokyo \countryJapan \affiliation \institutionThe University of Tokyo \cityTokyo \countryJapan
On the Transit Obfuscation Problem
Abstract.
Concealing an intermediate point on a route or visible from a route is an important goal in some transportation and surveillance scenarios. This paper studies the Transit Obfuscation Problem, the problem of traveling from some start location to an end location while ”covering” a specific transit point that needs to be concealed from adversaries. We propose the notion of transit anonymity, a quantitative guarantee of the anonymity of a specific transit point, even with a powerful adversary with full knowledge of the path planning algorithm. We propose and evaluate planning/search algorithms that satisfy this anonymity criterion.
Key words and phrases:
obfuscation, deceptive planning, planning1. Introduction
In applications such as sensitive cargo transportation or surveillance, it is sometimes necessary to route an agent from a start point to a goal while concealing the location of a transit point, which is either on the route or visible from the route, from adversaries. For example, in a cargo transport application, if a depot or drop location is located somewhere on the route, it is essential to prevent potential adversaries from deducing the transit point location to minimize the risk of theft or interception. In a surveillance application, it is important to be able to conceal which specific location a surveillance agent is targeting on its route.
Obfuscating an agent’s true intention has been previously studied in various fields, including path planning, robotics, and game theory Chakraborti et al. (2019). Previous work has primarily focused on the Goal Obfuscation Problem, which aims to prevent observers from deducing the agent’s actual goal, and has numerous applications, e.g., creating realistic non-player characters (NPCs) capable of deceiving humans Dias et al. (2013), or ensuring secure escorting of a VIP to a hidden location Keren et al. (2016).
Concealing non-goal locations is also important for customer privacy protection in real-world situations. For example, Enayati et al. (2022) considers a scenario where an UAV delivers packages to a private location and returns to the starting point. Chen et al. (2012) notes that some public transportation systems track the stations where each customer boards and leaves, and those systems potentially reveal the location of homes or workplaces, which are the transit points on the round-trip paths. However, Enayati et al. (2022) is limited to path planning in two-dimensional coordinates with the constraint that the start and goal locations are the same, and Chen et al. (2012) focuses on not path planning but anonymizing the collected sequential data.
In this paper, we study the Transit Obfuscation Problem, where given a graph, start location, end location, a target transit point, and a visibility function for an agent, the task is to generate a route from the start to the end location such that the agent’s visibility function covers the target, but the target location is concealed from adversaries. We assume a strong adversary that has full knowledge of the agent’s path, as well as full knowledge of the domain as well the internal decision-making process of the agent (i.e., the adversary has full access to the agent’s code).
We introduce the notion of -Anonymity, which quantifies the level of concealment achieved by a path planner. If a path planner satisfies -Anonymity, there exist at least transit points resulting in the same path up to the first steps, while the deviation among these candidate points is . Thus, -Anonymity is a guarantee that even with full knowledge of the agent’s path and code, an adversary can not distinguish the true target transit point among possible candidates which are at least apart from each other. We analyze some theoretical properties of -Anonymity and propose a graph partitioning-based approach to generating paths that guarantee -Anonymity.
The rest of the paper is structured as follows. First, we define the Transit Obfuscation Problem (TOP) with respect to a path-planning problem with a transit point and visibility constraints (Section 2) Next, in Section 3, we define (-Anonymity for the TOP and analyze its theoretical properties. We also define some metrics for evaluating the tradeoffs between privacy and path costs for the TOP. Then, in Section 4, we propose a partitioning-based search algorithm for the TOP which guarantees anonymity even when when the adversary knows the complete path, i.e., -Anonymity. Section 5 proposes algorithms which guarantees anonymity for up to steps. In Section 6, we experimentally evaluate our search algorithms on some standard benchmark game map instances. Section 7 discusses related work. Section 8 concludes with a discussion and directions for future work. Our code is available at: https://github.com/Koukyosyumei/TOP.
2. Transit Obfuscation Problem
A path-planning domain with visibility constraints is denoted by a triple , where
-
•
is a non-empty set of nodes;
-
•
is a set of transit candidates;
-
•
is a set of edges between nodes;
-
•
is a function that returns the non-negative cost of an edge between two nodes.
-
•
is a visibility function that returns the set of visible nodes from a given node.
The cost of the shortest path (a.k.a minimum cost path) between node and node is denoted by . For simplicity, we assume that does not contain self-loop edges, i.e., if . A path in a path-planning domain is a sequence of nodes such that , where represents the length of . We also denote the subsequence of till -th node as , i.e., . For convenience, we assume that if . The binary operator represents the concatenation of two paths. Specifically, when , , and , we have that . We also introduce notation, where . The cost of is the sum of the costs of each edge in , given by , where is the -th node in . We say that covers node if there exists an index such that .
A path-planning problem with visibility constraints and a transit point (PPVT) is represented by a tuple , where is a domain, is the start node, is the goal node, is the transit point that must be covered. The solution to a PPVT is a path such that , , and .
A path planner takes as input a PPVT and returns a feasible path for that problem, i.e., . returns Failure when it cannot find a feasible path. For convenience, we define Failure such that it is not equal to itself, i.e., Failure Failure.
We assume that there is an adversary who seeks to deduce the actual transit point by observing the trajectory of the agent.
A Transit Obfuscation Problem (TOP) is a tuple , where describes what the adversary can observe.
We make the following assumptions about the abilities of the adversarial observer (similar to the set of assumptions by Kulkarni et al. (2018)):
-
•
Complete Knowledge about the Domain and Transit Candidates: The adversary has complete knowledge about the domain .
-
•
Full Access to the Planner: The adversary has full access to and thoroughly understands the agent’s planning algorithm.
-
•
Independence of Inputs: The adversary can execute the agent’s planner with arbitrary input tuples at any time.
-
•
Observability of Path: The adversary can immediately observe the path executed by the agent so far.
-
•
Semi-Honest Adversary: The adversary is passive, and it does not disturb the action of the agent or gain any additional information beyond what has been specified above.
These are challenging assumptions when trying to conceal the transit point, as the adversary has full information about the mechanism of the path planning algorithm, as well as the ability to rerun/simulate the algorithm many times in order to gain information that might reveal the transit point. When , and is the identity function (the only node visible from a node is itself), this special case of the TOP is similar to the Goal Obfuscation Problem Kulkarni et al. (2018, 2019). Unlike the Goal Obfuscation Problem, where the final node of the path always reveals the actual goal, in the TOP, when , it is possible to have a path where an adversary cannot deduce the actual transit point even after observing the entire trajectory. For example, in Fig. 1, an agent travels from to while covering one of , where black cells are obstacles. Then, if the agent can see nodes within a radius of one, any feasible path covers all of so that an observer cannot infer the true transit point.

3. -Anonymity
Next, we formally define the conditions when a path is anonymized for a transit point, what inputs are anonymizable, and what planners can achieve anonymization.
3.1. Definitions of -Anonymity
In order for a transit point to remain private up to the first steps, even if the adversary has the capabilities enumerated above, it must not be possible to uniquely identify by executing the planner (possibly many times) and observing the output(s) as well as the internal state of the planner.
This is possible if the route output by a planner is indistinguishable for multiple transit candidate points, including the actual transit point . For example, if the set of transit candidates , and , it is indeterminate which of or is the true transit point .
In addition, it is often desirable for the transit candidates to be spread out. For example, if all the transit candidates are close to each other, the adversary may be able to cost-effectively block access to all transit candidates (preventing the agent from covering the transit point). Therefore, it is desirable to be able to disperse the indistinguishable transit candidates in the search space.
Based on this idea, we first define -Anonymized Paths.
Definition 0 (-Anonymized Path).
Let , and . We say that , a path planned by from to covering , where and , is a -Anonymized Path with respect to if there exists a set satisfying and .
In other words, a path is -Anonymized when there are at least transit candidates that result in the same path up to the first nodes from to covering , and the distance between any pair of nodes within that set is equal to or greater than . When , the adversary cannot determine which of those transit candidates is the true even after observing the entire path.
Second, we define a -Anonymizable Tuple.
Definition 0 (-Anonymizable Tuple).
Let and . Given a domain , we say that the tuple , where , , , , and , is a -Anonymizable Tuple if there exists a path planner such that there exists a set satisfying and .
The input tuple is -Anonymizable when at least one planner can output a -Anonymized Path for this input. Since is a positive integer, a tuple is not -Anonymizable Tuple for any if there exists no path from to covering .
Based on the above definitions, we define -Anonymity of a path planner as follows.
Definition 0 (-Anonymity).
A path planner satisfies -Anonymity for a domain if returns a -Anonymized Path for all -Anonymizable Tuples in .
A path planner with -Anonymity is guaranteed to return anonymized paths for all anonymizable tuples in .
We also consider the anonymity of the planner for fixed source and goal locations and define -Local Anonymity as follows:
Definition 0 (-Local Anonymity).
Let be the number of -Anonymizable Tuples in the domain with a fixed source and goal . We say that satisfies -Local Anonymity for if returns -Anonymized Paths for or more -Anonymizable Tuples in with and .
A planner satisfying -Anonymity in satisfies -Local Anonymity for any combination of a start and a goal .
3.2. Properties of -Anonymity
We have identified several important properties about - Anonymity: equivalence conditions for - Anonymizable Tuples and Anonymized Paths, path-extensibility, and existence guarantee of a planner achieving -Anonymity. All omitted proofs, as well as some additional properties can be found in Supp. LABEL:supp:proof:sec3 Takahashi and Fukunaga (2024).
First, the following proposition indicates the necessary and sufficient conditions for a path to be a -Anonymized Path.
Proposition 0 (3C Condition for Output Path).
A path = is -Anonymized Path iff there exists a set of nodes satisfying all of the following:
-
(1)
Cardinality:
-
(2)
Cost:
-
(3)
Coverage: covers all nodes in , and returns whenever the transit point belongs to .
The similar necessary and sufficient conditions for an input tuple to be -Anonymizable are in Supp. LABEL:supp:additional-properties Takahashi and Fukunaga (2024).
Next, the coverage condition of Prop. 5 leads to the computational complexity of planning a -Anonymized Path.
Theorem 6 ( Complexity).
Finding a -Anonymized Path for the given tuple is NP-Hard.
Proof of Theorem 6.
If the domain consists of an undirected graph, we can ensure the existence of a path planner that satisfies -Anonymity.
Theorem 7 (Existence of a Satisfying Path Planner).
If every edge in the domain is undirected, meaning that , there exists a path planner that satisfies -Anonymity for any given , and .
To prove this, we use the Lemma below which states that extending a -Anonymized Path preserves the same level of anonymity.
Lemma 0 (Path-Extension).
Let be a -Anonymized Path with respect to , be a path, constructed independently of , from to , and be an arbitrary path from to . Then, is also a -Anonymized Path with respect to .
Proof of Theorem 7.
Let is -Anonymizable Tuple, and be the -Anonymized Path for . If and all edges in are undirected, there exists , a path from to . By Lemma 8, we have that is a -Anonymized Path with respect to all transit nodes in .
Now, consider a path planner such that if and Failure otherwise. It is evident that satisfies -Anonymity: ∎
Although Theorem. 7 guarantees that there exists a path planner with -Anonymity for any undirected graph, such a guarantee is not possible when the edges are directed. A counterexample is shown in the left-side of Fig. 2, where there are two possible paths from to ; or . Thus, if we assume that the costs of edges are all one, all input tuples are -Anonymizable Tuples. Let . Clearly, any path planner should satisfy and . Then, if , is a -Anonymized Path but is not a -Anonymized Path. Likewise, if , is a -Anonymized Path but is not a -Anonymized Path. On the other hand, if all edges are undirected, we can construct a -Anonymized Path from and by concatenating them.

4. PbP: Partitioning-based Planner for -Anonymity
We now propose an algorithm for -Anonymity. First, note that if we disregard path cost, then in principle, a relatively straightforward approach to achieve -Anonymity would be to return some path which covers all transit candidates. However, a practical algorithm for Transit Obfuscation needs to effectively trade off the privacy objective vs. path costs, on average, overall tuples of interest. We first propose objectives that express this tradeoff and then propose a partitioning-based algorithm which seeks a solution which optimizes this objective. Proofs are in Supp. LABEL:supp:proof:sec4 Takahashi and Fukunaga (2024).
4.1. Objectives
We define two metrics, Anonymized Path Ratio (APR) and Mean Anonymization Cost (MAC), to evaluate the performance of planners that satisfy -Anonymity. Let be the set for the fixed , , and . APR is defined as follows:
Definition 0 (Anonymized Path Ratio (APR)).
where #Coverable Transit Nodes denotes the number of transit nodes within such that there exists a path from to covering . APR is equivalent to the lower bound of , and a larger APR is desirable.
Next, inspired by deception cost Price et al. (2023), a metric for goal obfuscation, we define the MAC metric:
Definition 0 (Mean Anonymization Cost (MAC)).
where is the shortest path from to covering . MAC shows the cost of anonymizing the transit points.
4.2. Pbp: Partitioning-based Planner
We now propose the Partitioning-based Planner (Pbp), a practical algorithm that seeks to achieve -Anonymity while optimizing the above objectives.
Pbp is composed of two phases: (1) the Partitioning/Pre-Processing phase and (2) the path query phase. In the Partitioning/Pre-Processing phase, the algorithm searches for a partition of all transit candidates, denoted as , such that (a) each subset except the final satisfies the 3C Conditions described in Prop. 5, ensuring that each subset covers the required nodes to achieve the desired level of anonymity, and (b) the objectives are optimized. The set consists of transit candidates that the planner cannot anonymize. This phase only needs to be executed once for each domain.
In the path query phase, given a specific , , and , the algorithm finds the shortest path from the source node to the goal node while covering all the nodes assigned to the subset (computed above in the Partitioning phase) that includes the target node .
By utilizing this approach, Pbp can effectively plan a -Anonymized Path, ensuring the privacy requirements are met while efficiently navigating from the source to the destination. If the obtained partition is perfect, Pbp satisfies -Anonymity.
Theorem 11 (Completeness).
Let all edges in be undirected. Then, if is maximized for any pair of and , Alg. 1 satisfies -Anonymity.
4.3. WRP With Targets (WRPT)
A key building block for the Pbp algorithm is a search algorithm for finding the minimum cost path from to , which covers all of the nodes in a set of nodes. We call this the Watchman Route Problem with Targets (WRPT). The WRPT corresponds to the subproblem solved by the path query phase of Pbp in Alg. 1, line 8. The WRPT is also used in the Partitioning phase when evaluating candidate partitionings (Alg. 2, line 20).
The WRPT is a variant of the Watchman Route Problem (WRP) Skyler et al. (2022), The differences between the WRP and WRPT are: (1) WRP does not have a specified goal node, while the WRPT has a specific goal , and (2) the objective of the WRP is to cover all nodes in the graph, while the WRPT seeks to cover some subset of nodes in the graph. Since WRP was shown to be NP-Hard Skyler et al. (2022), the WRPT is clearly NP-Hard. Recent work has studied heuristic search-based algorithms to solve WRP Skyler et al. (2022).
Following Skyler et al. (2022), we use an A* search for the WRPT. We define a state for the search as a tuple , where represents the current location, and represents the set of uncovered nodes. The initial state is , and the final is . Expanding a state involves moving from to one of its neighboring nodes and updating the set of uncovered nodes to . The cost of this expansion equals .
To make the search more efficient, we propose Tunnel Heuristic, which is based on the Singleton Heuristic for the WRP Skyler et al. (2022). The Tunnel Heuristic value is computed as follows:
where the function takes a node and returns the set of nodes from which is observable. The heuristic is admissible since the agent must travel to one of the nodes in to observe an uncovered node and then proceed to the goal after covering all nodes in .
4.4. Searching for a Partitioning
Alg. 1 requires an algorithm that generates a partition of the set of nodes. Let be the largest subset of whose elements all satisfy the conditions of Prop. 5. We denote the sum of the cardinalities of the subsets in as , and the MAC corresponding to as . Specifically, is , where , where denotes the minimal cost path from to covering , and denotes the minimal cost path from to while covering all nodes within , i.e., the solution to a WRPT which covers . We seek a partitioning which first prioritizes maximizing , then minimizes , i.e., a partitioning which anonymizes as many transit nodes as possible while minimizing the average cost of the anonymized paths.
4.4.1. Merge-based Branch-and-Bound
One practical partitioning algorithm is Merge-based Branch-and-Bound Partitioning (Merge-BB). It initially assigns each node to its own separate partition. It removes any node without a valid path from to while covering that node. This pruning step involves calculating all pair-wise shortest paths on the node set , which can be done efficiently within a reasonable amount of time. The algorithm then performs a recursive branch-and-bound search which considers all possible combinations of merges of these partitions.
The termination condition for this recursive search is implemented in Line 9: Return True when (1) the partition contains only one subset, or (2) reaches the upper bound, or (3) the current best partition has an optimal , and the of is not better than . The third termination condition is based on the observation that the cost of the optimal path covering all nodes in the union of and is always equal to or greater than both of the costs of the optimal paths covering all nodes in and .
Alg. 2 explores all potential merges and returns a partition that maximizes the number of anonymized transit points while minimizing the average cost of anonymized paths.
Proposition 0 (Optimality).
Since Theorem 7 tells that there exists a planner satisfying -Anonymity for an undirected graph, which means that it can anonymize all - Transit Anonymizable Tuples, combining Theorem 11 and Prop. 12 immediately yields the guarantee that Alg. 1 with Alg. 2 satisfies -Anonymity.
We also implemented the following enhancements.
Merge Ordering Strategies
The order in which partitions are merged in Alg. 2 by the recursive enumeration is determined by a call to the MergeOrder function in line 10, which returns the list of all pairs of candidate subsets to merge, sorted according to some merge ordering criterion. One simple strategy is Random, which simply returns a randomly shuffled list of the pairs of partitions. Another ordering strategy, CostAsc, sorts the pairs to be merged in ascending order of a heuristic cost function. We use as the cost of a pair , where the first term is the lower bound of the covering path of the merged partition, and the second term is the number of transit candidates assigned to the merged partition. CostAsc helps the planner find a better solution earlier, leading to more upper/lower bound-based pruning.
Pruning Criteria
To determine whether we need to try merging , Alg. 2, line 11 calls Prunable (Alg.3). If both and already satisfy all the conditions stated in Thm.5, the merge is pruned because it would increase the cost of a path covering all the nodes within the set (Alg. 3, Line 2). Furthermore, suppose we have already found a satisfactory solution for anonymizing all possible tuples. In that case, we can establish an upper bound for the path cost covering the union of and to surpass the current best satisfying solution and prune based on this bound (Alg. 3, Line 3). Specifically, we denote as the upper bound for the cost that must meet to improve upon the best , and it is calculated as . To estimate the cost of a path that covers all the nodes within the union of and , we use , which is the lower-bound of . Finally, we check the minimum distance between a node in and . If that distance is less than , we prune this merge, as any set containing the union of and would also violate this condition (Alg. 3, Line 7).
5. Planners for -bounded -Anonymity
We now propose three planners that output -Anonymized Paths with , which means that the adversary cannot identify which node is the transit point until observing more than nodes. If is less than the length of the output path, the adversary might be able to identify the true transit point after obtaining the st and later nodes. Proofs for this section can be found in Supp. LABEL:supp:proof:sec5 Takahashi and Fukunaga (2024).
Random-Walk-based Planner (Rbp)
The first algorithm is a Random-Walk-based Planner (Rbp), which randomly selects the path’s first nodes. Specifically, the planner selects the -th node () of the path randomly from the neighbors of the -th node, where . Subsequently, the planner guides the agent’s movement from to and finally to utilizing the shortest paths available. is the same for all transit candidates, and the planner outputs Failure if there is no feasible path. This planner archives -Anonymity with finite for undirected graphs.
Proposition 0.
If all edges in are undirected, Random-Walk-based Planner satisfies -Anonymity with .
-Pbp
The second planner is -Pbp, which is an extension of Pbp. -Pbp returns , where is the output path up to the -th node planned by Pbp, and is the unanonymized shortest path from the last node of to the goal while covering if does not cover . The anonymity of -Pbp relies on the anonymity of Pbp.
Proposition 0.
If Pbp satisfies -Anonymity for the given domain , -Pbp satisfies -Anonymity for that domain .
Clustering-based Planner (Cbp)
The third -bounded planner is a Clustering-based Planner (Cbp), which first applies -means-like clustering to the transit candidates and then returns the concatenation of paths from to the centroid of the cluster corresponding to and from the centroid to . Following Wasserman and Faust (1994), we call a node that minimizes the maximum distance to cover a node within a set of nodes the centroid of , i.e., . Like -means clustering Ahmed et al. (2020), Cbp iteratively updates the assignment of each transit candidate to minimize the distance between each candidate and the centroid of their respective cluster. After the assignments stabilize, Cbp repeatedly merges a cluster with cardinality less than with the nearest cluster until each cluster has or more nodes. Here, we use the shortest distance from the centroid of the -th cluster to the centroid of the -th cluster as the distance from the -th cluster to the -th cluster. Then, Cbp checks , the length of the shortest path from to the centroid of the cluster containing the true transit node . If it exceeds , Cbp assigns the first nodes from , as . Otherwise, Cbp appends a randomly generated path as padding (Line 12-15 in Algorithm 4) and assigns the extended path to . Finally, Cbp computes , the shortest path from the last node of to , covering , and returns . The sequence of the first nodes of the output paths planned by Cbp is the same for all transit points belonging to the same cluster. Cbp satisfies the following.
Proposition 0.
Let all edges in be undirected. If for any , there exists a path from to while covering , Cbp satisfies -Anonymity.
6. Experiments
Benchmarks and Settings
We evaluate the performance of Pbp on six 2D grid world benchmark instances from the Moving AI pathfinding benchmark set Sturtevant (2012): den101d, den201d, lak102d, lak510d, orz000d, and orz201d. We randomly select 5 pairs of start and goal points for each benchmark. The number of transit candidates, , is 8, 12, and 16, and we randomly select from for each problem. We use a visibility function where nodes within a range less than or equal to distance are covered (for =0,2,10). All experiments used 4-way unit cost movement.
All algorithms were implemented in C++, and experiments were run on an Intel(R) Xeon(R) CPU E5-2650 v2 @ 2.60GHz and 125GB of RAM, running Ubuntu 22.04.2 LTS. A time limit of 300 seconds/instance was used.
6.1. Evaluation of Pbp with
We evaluate Pbp using Merge-BB and DF-BB partitioning strategies, two merge orders (Random and CostAsc), and two WRTP heuristics: the blind heuristic (equivalent to breadth-first search) and the Tunnel heuristic. We also evaluate two baseline partitioning strategies:
Baseline #1: Naive
This generates a partitioning by randomly splitting the transit candidates into pairs of 2 nodes. This approach satisfies ()-Anonymity for this class of undirected grid maps.
Baseline #2: Depth-First Branch-and-Bound (DF-BB) partitioning
The DF-BB partitioning strategy starts with all nodes unassigned and then constructs a partitioning by assigning one unassigned node to an existing subset of or a new subset (details in Supp. LABEL:supp:dfbb Takahashi and Fukunaga (2024)).
For the privacy parameters, we set to 2 and 3 and to 1 and 10.
Results
8 | 12 | 16 | 8 | 12 | 16 | 8 | 12 | 16 | 8 | 12 | 16 | |||||
Planner |
|
Heuristic | Coverage [%] |
|
APR (higher=better) | MAC (lower=better) | ||||||||||
Naive | Blind | n/a | n/a | n/a | <1 | <1 | - | 1.00 | 1.00 | 1.00 | 0.714 | 0.434 | 0.582 | |||
Tunnel | n/a | n/a | n/a | <1 | <1 | - | 1.00 | 1.00 | 1.00 | 0.714 | 0.434 | 0.582 | ||||
DF-BB | Blind | 77 | 0 | 0 | 19 | - | - | 1.00 | 0.672 | 0.439 | 0.232 | - | - | |||
Tunnel | 100 | 20 | 0 | 2 | 92 | - | 1.00 | 0.828 | 0.558 | 0.229 | - | - | ||||
Merge-BB | Random | Blind | 74 | 7 | 0 | 35 | 185 | - | 1.00 | 1.00 | 1.00 | 0.232 | 0.418 | 0.561 | ||
Tunnel | 100 | 27 | 0 | 3 | 13 | - | 1.00 | 1.00 | 1.00 | 0.229 | 0.287 | 0.452 | ||||
CostAsc | Blind | 77 | 7 | 0 | 10 | 80 | - | 1.00 | 1.00 | 1.00 | 0.231 | 0.222 | 0.223 | |||
Tunnel | 100 | 47 | 0 | 1 | 5 | - | 1.00 | 1.00 | 1.00 | 0.229 | 0.190 | 0.205 |
Tab. 1 shows the performance of the Partitioning-based Planner when . We report coverage, APR, MAC, and execution time. Coverage is the percentage of problems on which Pbp completed the search (found the optimal solution and proved its optimality) within the time limit. We report mean MAC for the configurations which found satisfying solutions (ARP=1) for all instances within the time limit. Total Time denotes the average execution time for the instances where Merge-BB with the blind heuristic completed the search for of 8 and 12.
Tab. 2 shows the mean and standard deviation of the MAC of Merge-BB divided by the MAC of Naive, showing over 50% improvement of Merge-BB with CostAsc.
From Tab. 1-2, we observe that: (1) Pbp (Merge-BB) consistently results in better MAC than the Naive baseline, showing that searching for an optimal partition achieves significantly better path costs than a naive partitioning. (2) Merge-BB has significantly higher coverage than DF-BB, showing that the merge-based approach is a more efficient strategy. (3) Overall, combining Merge-BB, CostAsc, and Tunnel gives the best performance.

Fig. 3 depicts the changes over time in ARP and MAC when , . All combinations use . Mege-BB archives higher APR faster, and CostAsc can find solutions with lower MAC earlier.

Fig. 4 shows MAC for each combination of and radius when using Merge-BB with CostAsc and . Larger and result in worse MAC. The correlation between MAC and is not monotonic since larger allows the agent to cover nodes with less movement, decreasing both the numerator and denominator of MAC.

FIg. 5 shows an example of optimal (2, 1, )-Anonnymized Paths in den101 obtained by Pbp (Merge-BB). The cyan (S) and green (G) cells are the source and goal, respectively. The transit candidate belonging to the same subset () has the same color, while its corresponding path is colored in a lighter color. More qualitative examples can be found in Supp. LABEL:supp:additional-results.
MergeOrder | Heuristic | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
Random | Blind |
|
|
|
||||||
Tunnel |
|
|
|
|||||||
CostAsc | Blind |
|
|
|
||||||
Tunnel |
|
|
|
6.2. Evaluation with bounded
We compared the three -bounded anonymity planners, -Pbp, Rbp, and Cbp, for various values of and . For each problem, we set such that is [0.1, 0.3, 0.5, 1.0, 5.0, 10.0], where is the length of the shortest path for that problem. is [2, 3, 5]. The remaining parameters are kept constant: , , and the heuristic function is .
Fig. 6 shows that as increases, the MAC of Rbp and Cbp exhibits exponentia growth (y-axis is log scale), while -Pbp’s performance converges towards that of Pbp. -Pbp aims to cover all nodes within the same partition, while Cbp strives to move towards the centroid of the cluster. Thus, when is small enough that Cbp doesn’t require appending a random-walking path, the MAC of Cbp surpasses that of -Pbp. However, -Pbp exhibits superior performance compared to the other methods for larger values of .
Tab. 3 shows the execution time of each planner. Cbp is clearly faster than -Pbp. Larger makes Cbp faster because the path after the -th node tends to be shorter, reducing the runtime of the search performed by Line 21 in Alg. 4. However, this effect decreases if is too large for Cbp to need additional time to append random nodes.
0.1 | 0.3 | 0.5 | 1.0 | 5.0 | 10.0 | |
---|---|---|---|---|---|---|
Rbp | 0.006 | 0.006 | 0.006 | 0.006 | 0.006 | 0.006 |
Cbp | 0.098 | 0.085 | 0.046 | 0.009 | 0.006 | 0.006 |
-Pbp | 63.985 | 63.985 | 63.985 | 63.985 | 63.985 | 63.985 |

7. Related Work
-Anonymity
-anonymity is a fundamental concept in data privacy and anonymization that aims to safeguard individual identities in a dataset while preserving its utility Sweeney (2002); Terzi et al. (2015). -anonymity seeks to render each record in a dataset indistinguishable from at least -1 other records, i.e., each individual’s data is grouped with a minimum of -1 other individuals with similar attributes. This grouping makes it challenging to identify a specific individual within the group.
Obfuscation
Some existing methods for goal obfuscation leverage concepts similar to -anonymity. For instance, Kulkarni et al. (2018, 2019) define a secure path as one where different goals result in the same path, thereby making it difficult for an observer to discern the true purpose among these nodes. Another example is Dissimulation proposed in Masters and Sardina (2017), where the true goal is considered to be obfuscated if there exist other nodes that look like the goal equally or more than the real goal. While our work refrains from making any assumptions regarding how the observer deduces the agent’s intention, some studies (Masters and Sardina, 2017; Luo et al., 2019; Lewis and Miller, 2023; Savas et al., 2022) model the inference process of the observer and devise obfuscation techniques tailored to these models. However, approaches based on such models do not provide a guarantee of security against adversaries who do not adhere to the model assumptions.
8. Conclusion
This paper introduced the Transit Obfuscation Problem and proposed novel techniques to address this challenge. We introduced -Anonymity as a measure of concealment achieved by a path planner. We proposed a Pbp, a partitioning based algorithm to achieve -Anonymity, and evaluated its performance on 2D grid maps with obstacles. We showed that Pbp with a merge-based branch-and-bound strategy significantly outperforms baseline partitioning approaches.
Although we showed that Merge-BB with the APR and MAC objectives is a viable approach to partitioning, a complete branch-and-bound search to find and prove the optimality of a solution poses a scalability challenge. For example, although our current implementation of Pbp can find solutions for (Tab. 1), it can not complete the search and prove optimality within the 300 sec. limit. Search algorithms finding good partitionings quickly without an optimality guarantee (e.g., local search/metaheuristics) are a direction for future work.
We also investigated algorithms for -bounded anonymity (). We showed that while -Pbp yielded the best MAC scores, Cbp offers fairly good MAC scores but runs much faster. Future work will investigate additional approaches to trading off scalability vs. solution quality.
Finally, while this work focused on a single agent and single adversary in a static environment, an extension of our proposed techniques to more complex scenarios, such as multi-agent systems and dynamic environments, is another direction for future work.
References
- (1)
- Ahmed et al. (2020) Mohiuddin Ahmed, Raihan Seraj, and Syed Mohammed Shamsul Islam. 2020. The k-means algorithm: A comprehensive survey and performance evaluation. Electronics 9, 8 (2020), 1295.
- Chakraborti et al. (2019) Tathagata Chakraborti, Anagha Kulkarni, Sarath Sreedharan, David E Smith, and Subbarao Kambhampati. 2019. Explicability? legibility? predictability? transparency? privacy? security? the emerging landscape of interpretable agent behavior. In Proceedings of the international conference on automated planning and scheduling, Vol. 29. 86–96.
- Chen et al. (2012) Rui Chen, Benjamin CM Fung, Bipin C Desai, and Nériah M Sossou. 2012. Differentially private transit data publication: a case study on the montreal transportation system. In Proceedings of the 18th ACM SIGKDD international conference on Knowledge discovery and data mining. 213–221.
- Dias et al. (2013) Joao Dias, Ruth Aylett, Ana Paiva, and Henrique Reis. 2013. The great deceivers: Virtual agents and believable lies. In Proceedings of the Annual Meeting of the Cognitive Science Society, Vol. 35.
- Enayati et al. (2022) Saeede Enayati, Dennis L. Goeckel, Amir Houmansadr, and Hossein Pishro-Nik. 2022. Privacy-Preserving Path-Planning for UAVs. In 2022 International Symposium on Networks, Computers and Communications (ISNCC). 1–6. https://doi.org/10.1109/ISNCC55209.2022.9851770
- Keren et al. (2016) Sarah Keren, Avigdor Gal, and Erez Karpas. 2016. Privacy Preserving Plans in Partially Observable Environments.. In IJCAI. 3170–3176.
- Kulkarni et al. (2018) Anagha Kulkarni, Matthew Klenk, Shantanu Rane, and Hamed Soroush. 2018. Resource bounded secure goal obfuscation. In AAAI Fall Symposium on Integrating Planning, Diagnosis and Causal Reasoning.
- Kulkarni et al. (2019) Anagha Kulkarni, Siddharth Srivastava, and Subbarao Kambhampati. 2019. A unified framework for planning in adversarial and cooperative environments. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 33. 2479–2487.
- Lewis and Miller (2023) Alan Lewis and Tim Miller. 2023. Deceptive Reinforcement Learning in Model-Free Domains. arXiv preprint arXiv:2303.10838 (2023).
- Luo et al. (2019) Junren Luo, Wanpeng Zhang, Fengtao Xiang, and Su Jiongming. 2019. Intention Obfuscated Adversarial Deceptive Path Recommendation for UGV Patrol Maneuver. 206–211. https://doi.org/10.1109/IHMSC.2019.00055
- Masters and Sardina (2017) Peta Masters and Sebastian Sardina. 2017. Deceptive Path-Planning.. In IJCAI. 4368–4375.
- Price et al. (2023) Adrian Price, Ramon Fraga Pereira, Peta Masters, and Mor Vered. 2023. Domain-Independent Deceptive Planning. In Proceedings of the 2023 International Conference on Autonomous Agents and Multiagent Systems. 95–103.
- Savas et al. (2022) Yagiz Savas, Christos K Verginis, and Ufuk Topcu. 2022. Deceptive decision-making under uncertainty. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 36. 5332–5340.
- Seiref et al. (2020) Shawn Seiref, Tamir Jaffey, Margarita Lopatin, and Ariel Felner. 2020. Solving the watchman route problem on a grid with heuristic search. In Proceedings of the international conference on automated planning and scheduling, Vol. 30. 249–257.
- Skyler et al. (2022) Shawn Skyler, Dor Atzmon, Tamir Yaffe, and Ariel Felner. 2022. Solving the Watchman Route Problem with Heuristic Search. J. Artif. Intell. Res. 75 (2022), 747–793. https://doi.org/10.1613/jair.1.13685
- Sturtevant (2012) N. Sturtevant. 2012. Benchmarks for Grid-Based Pathfinding. Transactions on Computational Intelligence and AI in Games 4, 2 (2012), 144 – 148. http://web.cs.du.edu/~sturtevant/papers/benchmarks.pdf
- Sweeney (2002) Latanya Sweeney. 2002. k-anonymity: A model for protecting privacy. International journal of uncertainty, fuzziness and knowledge-based systems 10, 05 (2002), 557–570.
- Takahashi and Fukunaga (2024) Hideaki Takahashi and Alex Fukunaga. 2024. Supplementary Material for ”On the Transit Obfuscation Problem. arXiv preprint (2024).
- Terzi et al. (2015) Duygu Sinanc Terzi, Ramazan Terzi, and Seref Sagiroglu. 2015. A survey on security and privacy issues in big data. In 2015 10th International Conference for Internet Technology and Secured Transactions (ICITST). IEEE, 202–207.
- Wasserman and Faust (1994) Stanley Wasserman and Katherine Faust. 1994. Social network analysis: Methods and applications. (1994).