Datasets:

AKM15

/

arxiv_chunk

like 0

2312.16397v1_120

http://arxiv.org/abs/2312.16397v1

d_G-F(p,q)≤ (1+/2)tW whilep and q might not be a well separated with respect to W. In such case, we have d_H(s,s') ≤ d_H(s,p)+d_H(p,q)+d_H(q,s')≤ d_H(s,p)+d_H(q,s')+d_G-F(p,q) +3· 40(f+1)t^3ε'W≤ d_H(s,p)+d_H(q,s')+d_G-F(s,s')+d_G-F(s',q)+d_G-F(q,s')+3· 40(f+1)t^3ε'W≤ d_G-F(s,s')+(3· 40(f+1)+4·40)t^3ε'W ≤ (1+ε)d_G-F(s,s').The fourth inequality holds because d_G-F(s,p), d_H(s,p), d_G-F(s',q), and d_H(s',q) are at most 40t^3'W. The last inequality holds by the two facts: d_G-F(s,s')≥ W/2

2312.16397v1_121

http://arxiv.org/abs/2312.16397v1

holds by the two facts: d_G-F(s,s')≥ W/2 andε'=ε/500t^3(f+1). Moreover, we can show d_G-F(p,q)≤ (1+/2)tW easily using triangle inequality as following :d_G-F(p,q) ≤ d_G-F(s,p)+d_G-F(s,s')+d_G-F(q,s')≤ (1+80t^2')tW<(1+/2)tW.Recall that d_G-F(s,s')≤ tW and d_G-F(s,p), d_G-F(s',q) are at most 40t^2' W. This section is summarized by the following lemma. lemmalemWellSeparatedPair H is a (s,s',F;)-kernel. Lemma <ref> guarantees that the described query algorithm of the kernel oracle in this paper is

2312.16397v1_122

http://arxiv.org/abs/2312.16397v1

algorithm of the kernel oracle in this paper is correct. Note that every query algorithms of oracles in this paper are based on the kernel query algorithm. § DISTANCE AND SHORTEST PATH ORACLES FOR MODERATELY FAR VERTICESIn this section, we construct approximate distance oracle and shortest path oracle for moderately far vertex queries.Let G be an L-partial f-fault-tolerant Euclidean t-spanner. Here, G might have long edges as the preprocessing step mentioned before only spans the previous

2312.16397v1_123

http://arxiv.org/abs/2312.16397v1

step mentioned before only spans the previous section.Let n and m denote the numbers of vertices and edges of G, respectively.Distance oracle. For an approximate distance oracle, it suffices to construct a kernel oracle. Recall that the approximation factormust be give in the construction of the oracles. Given two moderately far vertices s and s' and a set F of failed vertices, we simply compute an (s,s',F;)-kernel H, and then compute the distance between s and s' in H using Dijkstra's

2312.16397v1_124

http://arxiv.org/abs/2312.16397v1

distance between s and s' in H using Dijkstra's algorithm. This value is an approximate distance between s and s' by the definition of kernels.Therefore, the following theorem holds by Theorem <ref>. Let G be an L-partial f-fault-tolerant Euclidean t-spanner G and >0.There exists an oracle which supports an (1+)-approximate distance of d_G-F(s,s') for a query of two moderatelyvertices s,s', and at most f failed vertices F in G in O(t^8f^4) time. Furthermore, we can construct such oracle in

2312.16397v1_125

http://arxiv.org/abs/2312.16397v1

Furthermore, we can construct such oracle in 2^O(g(t,f,)) nlog^2 n construction time which takes 2^O(g(t,f,))nlog n space complexity, where g(t,f,)=flog(tf/). Shortest path oracle. For an approximate shortest-path oracle, we construct a path-preserving kernel oracle. Given two moderately far vertices s and s', and a set F of failed vertices, we simply compute a path-preserving (s,s',F;)-kernel H, and then compute a shortest path π between s and s' in H using Dijkstra's algorithm.Since π might

2312.16397v1_126

http://arxiv.org/abs/2312.16397v1

s' in H using Dijkstra's algorithm.Since π might contain an edge not in G-F, we replace each edge of π with their corresponding path in G-F. More specifically, for an edge uv of π, either its length is at most tL/m^6, orthere is an -path between u and v of length w_H(uv).For the former case, we replace uv with an arbitrary path of G-Fconsisting of edges of length at most tL/m^6. By the spanner property, u and v are connected in G-F, and moreover, a shortest path between them consists of edges

2312.16397v1_127

http://arxiv.org/abs/2312.16397v1

a shortest path between them consists of edges of length at most tL/m^6.For the latter case, we simply replace uv with the -path. The correctness of the query algorithm is guaranteed by the following lemma.lemmalemCorrGenPath The returned path has length at most (1+2ε)d_G-F(s,s'). Since s and s' are moderately far,|ss'|∈[L/m^2,L/t). The total weight of all edges in G-F of length at most tL/m^6 is at most tL/m^5.For sufficiently large m with m∈Ω(t/), the following holds.L/m^5≤

2312.16397v1_128

http://arxiv.org/abs/2312.16397v1

large m with m∈Ω(t/), the following holds.L/m^5≤ d_G-F(s,s')/m^3≤ε/t d_G-F(s,s').The length of the returned path is at most d_H(s,s')+tL/m^5, and the distance d_H(s,s') is at most (1+)d_G-F(s,s') since H is a (s,s',F;)-kernel of G.Thus, the lemma holds by Inequality <ref>. We have a challenge of computing an arbitrary path of G-F consisting of edges of length at most tL/m^6. To handle this problem, we utilize the following lemma which is proved in Section <ref>. lemmalemArbitraryPath For any

2312.16397v1_129

http://arxiv.org/abs/2312.16397v1

in Section <ref>. lemmalemArbitraryPath For any graph G, we can construct a data structure of size O(fmlog nloglog n) in O(mnlog n) time which answers connectivity queries in the presence of f failed vertices.This structure can process a set F of at most f failed verticesin O(f^4log^2 n loglog n) time, and then it allows us to compute an arbitrary path π between any two vertices in G-Fin O(f + e(π)) time, where e(π) is the number of edges of π. We construct a data structure stated in

2312.16397v1_130

http://arxiv.org/abs/2312.16397v1

of π. We construct a data structure stated in Lemma <ref> on the subgraph of G induced by edges of length at most tL/m^6. Then we can get a shortest path oracle who performs as stated in Table <ref>. Let G be an L-partial f-fault-tolerant Euclidean t-spanner G and >0.There exists an oracle which supports an (1+)-approximate shortest path of π_G-F(s,s') for a query of two moderatelyvertices s,s', and at most f failed vertices F in G in O(f^4log^2 nloglog n + ) time. Furthermore, we can construct

2312.16397v1_131

http://arxiv.org/abs/2312.16397v1

nloglog n + ) time. Furthermore, we can construct such oracle in 2^O(g(t,f,)) n^2log^2 n construction time which takes 2^O(g(t,f,))nlog^2 nloglog n space complexity, where g(t,f,)=flog(tf/) andis the number of edges in the returned path.The shortest path oracle of G is the union of path-preserving kernel oracle of G and an arbitrary path oracle of a subgraph Ĝ of G. Thus, we can obtain the construction time and space complexities of the approximate shortest path oracle by combining their

2312.16397v1_132

http://arxiv.org/abs/2312.16397v1

shortest path oracle by combining their performances each described in Theorem <ref> and Lemma <ref>, respectively.The query algorithm for computing an approximate shortest path has three steps as follows. First step is computing a path-preserving kernel H and updating the arbitrary path oracle of Ĝ with respect to the failed vertices. Next, we compute the shortest path π in H, and translate π to a path in G-F. By Lemma <ref> and Lemma <ref>, computing H and updating the oracle of Ĝ takes

2312.16397v1_133

http://arxiv.org/abs/2312.16397v1

computing H and updating the oracle of Ĝ takes O(f^4log^2 n(t^8log(tf/)+loglog n)) time. The number of vertices of H is at most O(t^4flog n). This implies that computing π takes O(t^8f^2log^2 n) time, and the path has O(t^4flog n) edges. Moreover, translating π takes O(t^4f^3log n+t^4f^2log n +) by Lemma <ref> and Lemma <ref>, whereis the number of vertices in the returned solution path. We may assume that n is sufficiently large so that loglog n∈Ω(t^8log^3(tf/)).Then the total query time takes

2312.16397v1_134

http://arxiv.org/abs/2312.16397v1

the total query time takes O(f^4log^2 n loglog n+). We notice that the correctness of the shortest path query is guaranteed by Lemma <ref>.§ ARBITRARY PATH ORACLE We construct an oracle described in Lemma <ref> by slightly modifying the oracle introduced in <cit.>.Duan and Pettie introduced a connectivity oracle of a general graphin the presence of failed vertices in <cit.>. Given a set of failed vertices and two query vertices, it allows us to check if the two query vertices are connected in

2312.16397v1_135

http://arxiv.org/abs/2312.16397v1

check if the two query vertices are connected in the graph in the presence of the failed vertices. To check if two vertices are connected in the presence of failed vertices, they indeed compute an implicit representation of a path.In this case, given an implicit representation of a path, we can report it in time linear in its complexity.However, since this is not explicitly mentioned in <cit.>, we give a brief sketch of their approach here.In the rest of this section, we refer G as a general

2312.16397v1_136

http://arxiv.org/abs/2312.16397v1

the rest of this section, we refer G as a general graph.Summary of <cit.>. Imagine that a spanning tree T of G has maximum degree of four.In this case, for any set F of f failed vertices,we can check the connectivity between any two vertices u and v efficiently as follows.After removing F from T, we have at most 4|F| subtrees.If u and v are contained in the same subtree, they are connected in G-F as well. If it is not the case, for each pair of subtrees, we check if there is an edge connecting

2312.16397v1_137

http://arxiv.org/abs/2312.16397v1

subtrees, we check if there is an edge connecting two subtrees. Assume that we can do this in T_1 time for all pairs of subtrees.We can represent the adjacency between the subtrees asthe adjacency graph where each vertex corresponds to each subtree.Then it suffices to check the connectivity between the two subtrees containing u and v in theadjacencygraph.Since the adjacency graph has complexity O(f^2), we can check if u and v are connected in O(f^2+ T_1) time in total.Duan and Pettie showed how

2312.16397v1_138

http://arxiv.org/abs/2312.16397v1

T_1) time in total.Duan and Pettie showed how to check if two subtrees are connected by an edge in T_1=O(f^2log^2 n) time in total. To generalize this argument,they construct a hierarchy of components, say {𝒞_i}_i, anda set of Steiner forests, say {𝒯_i}_i, of maximum degree at most four.Here, the depth of the hierarchy is O(log n).For any two components in the hierarchy, either they are disjoint, or one of them is contained in the other. For each components γ in C_i, several vertices are marked

2312.16397v1_139

http://arxiv.org/abs/2312.16397v1

components γ in C_i, several vertices are marked as terminals, and they are contained in the same tree of 𝒯_i.Given a set F of f failed vertices, for each level i, at most f trees in 𝒯_i intersect F.Then after removing F, those trees are split into O(f) subtrees. We call such subtrees the affected subtrees.For a technical reason, we also call the trees containing query vertices u or v the affected subtrees. A tree of 𝒯_i not intersecting F∪{u,v} is calledan unaffected tree for any index i.For

2312.16397v1_140

http://arxiv.org/abs/2312.16397v1

is calledan unaffected tree for any index i.For all levels, the total number of affected subtrees is O(flog n). For any two query vertices, if they are contained in the same affected subtree or the same unaffected tree, we can immediately conclude that they are connected in G-F. Another simple case is that for a path π in G-F between u and v,all vertices in π are contained inthe affected subtrees.As we did before, we construct the adjacency graph for all affected subtrees.A vertex of this graph

2312.16397v1_141

http://arxiv.org/abs/2312.16397v1

for all affected subtrees.A vertex of this graph represents each affected subtree,and two vertices are connected by an edge if their corresponding subtrees are connected by a single edge. Duan and Pettie showed how to compute the adjacency graph for these subtreesin O((flog n)^2(loglog n+f^2)) time in total.Then it is sufficient to check if an affected subtree containing u is connected to an affected subtree containing v in the adjacency graph. However, it is possible that a path between u and

2312.16397v1_142

http://arxiv.org/abs/2312.16397v1

However, it is possible that a path between u and v might intersect a large number of unaffected trees of {𝒯_i}_i.We cannot afford to compute the adjacency graph for all trees of {𝒯_i}_i.To overcome this difficulty, they add several artificial edges to G carefully.An artificial edge defined from γ∈𝒞_i for an index i indeed corresponds to a path π in G such thatthe part of π excluding the last two edgesis fully contained in γ.This artificial edge connects the two trees of {𝒯_i}_i containing the

2312.16397v1_143

http://arxiv.org/abs/2312.16397v1

connects the two trees of {𝒯_i}_i containing the two end vertices of π.Let G^+ be the graph obtained from G by adding the artificial edges. Given a set F of failed vertices, they first remove from G^+ artificial edges defined from components intersecting F∪{u,v}.Then they show that for any two vertices u and v connected in G-F,all vertices of a path between u and v in G^+-F are contained inthe affected subtrees, and vice versa. Thus, we can handle this case as we did before. In summary, they

2312.16397v1_144

http://arxiv.org/abs/2312.16397v1

this case as we did before. In summary, they can construct a connectivity oracle of size O(fmlog nloglog n) in O(mnlog n) time. This structure can process a set F of at most f failed vertices in O(f^4log^2 n loglog n) time, and then it allows us tocheck if any two vertices are connected in G-F in O(f) time.Modification for arbitrary path queries. Using the connectivity oracle by Duan and Pettie, we can answer arbitrary path queries efficiently.Given a tree T, we can compute the path in T

2312.16397v1_145

http://arxiv.org/abs/2312.16397v1

a tree T, we can compute the path in T between any two vertices u and v in time linear in the complexity of the returned path.First, we compute a lowest common ancestor w of u and v in constant time, and then traverse the path from u to w.Similarly, we traverse the path from v to w. Moreover, we can do this for any affected subtrees.For each component of {𝒞_i}_i, we also compute a spanning tree so that a path between any two vertices in each component can be computed efficiently. Using this

2312.16397v1_146

http://arxiv.org/abs/2312.16397v1

component can be computed efficiently. Using this observation, we can retrieve a path between u and v in G-F.The connectivity oracle contains G^+ obtained from G by adding artificial edges to G.The query algorithm by Duan and Pettie first removes invalid artificial edges from G^+, and compute theadjacency graph between all affected subtrees.Each edge of the adjacency graph represents either an actual edge of G ora path whose inner vertices are fully contained in an unaffected component of

2312.16397v1_147

http://arxiv.org/abs/2312.16397v1

are fully contained in an unaffected component of {𝒞_i}_i.Let π=⟨ e_1, e_2,…,e_ℓ⟩ be a path in the adjacency graph between unaffected subtrees containing u and v.If e_j represents a path whose inner vertices are fully contained in an unaffected component C of{𝒞_i}_i, we replace it with such a path.The two end edges are stored in the connectivity oracle,and we can compute the other part in time linear in its complexity using thespanning tree of C we computed as a data structure.Then for any two

2312.16397v1_148

http://arxiv.org/abs/2312.16397v1

we computed as a data structure.Then for any two consecutive edges e_j and e_j+1 with common endpoint v,note that v is contained in an affected subtree. Also, the endpoints of the paths/edges represented by e_j and e_j+1 are also contained in this subtree. Then we connect them by the path between them in the affected subtree. Therefore, we have Lemma <ref>. *§ PROOFS OF GENERALIZATION LEMMASIn this section, we prove the generalization lemmas: Lemma <ref> and Lemma <ref>. Precisely, we describe

2312.16397v1_149

http://arxiv.org/abs/2312.16397v1

and Lemma <ref>. Precisely, we describe an approximate distance or shortest path oracle which supports general query by utilizing the oracle which supports a query of two moderately far vertices.Let G denote a given f-fault-tolerant Euclidean t-spanner,and n and m denote the numbers of vertices and edges of G, respectively. Recall that m∈ O(n).We basically follow the strategy of <cit.> and <cit.>, but we need to store additional information to handle multiple vertex failures.More specifically,

2312.16397v1_150

http://arxiv.org/abs/2312.16397v1

multiple vertex failures.More specifically, we make use of the following lemma. We can construct five sequences ℒ_1,…,ℒ_5 of real numbersin O(nlog n) time so that given any two vertices p and q,an element L_i of ℒ_k with |pq|∈[L_i/m,L_i/t)can be found in constant time. Moreover, L_i≥ m^2 L_i-1 holds forany two consecutive elements L_i-1 and L_i of a single sequence ℒ_k=⟨ L_1,…,L_r⟩. We construct a data structure with respect to each of the five sequences in Lemma <ref>. To answer a query of two

2312.16397v1_151

http://arxiv.org/abs/2312.16397v1

in Lemma <ref>. To answer a query of two s, s' and failed vertices F, we use the data structure constructed for the sequence which contains L_i with |ss'|∈ [L_i/n, L_i/t).We assume that L_i∈ℒ_1. For j∈ [1,|ℒ_1|], let G_j be the subgraph of G induced by the edges whose lengths are at most L_j∈ℒ_1. Moreover, let E_j be the set of edges in G whose length are in [L_i-1,L_i), and V_j be the set of end vertices of E_j in G. §.§ Partial Spanner S_iFor an element L_i in ℒ_1, we construct a weighted

2312.16397v1_152

http://arxiv.org/abs/2312.16397v1

an element L_i in ℒ_1, we construct a weighted graph S_i as follows. The vertex set of S_i isV_i-1∪ V_i∪ V_i+1.The set V_i-1∪ V_i∪ V_i+1 is decomposed into several components such that the vertices in a single component are connected in G_i-2.For each component U,we compute an f-fault-tolerant Euclidean (1+)t-spanner on (a point set) Uusing the algorithm of <cit.>. Their algorithm computes an O(f^2k)-sized f-fault-tolerant Euclidean spanner of k points in O(klog k+f^2k) time. The edge set of

2312.16397v1_153

http://arxiv.org/abs/2312.16397v1

k points in O(klog k+f^2k) time. The edge set of S_i is the union ofE_i-1, E_i, E_i+1, and the edge sets of the spanners on for all components U. Then S_i is a 4L_i-partial f-fault-tolerant Euclidean (1+)t-spanner by Lemma <ref>.lemmalemComplexityOfSiWe can construct S_i for all elements L_i in O(nlog n+f^2n) time.Furthermore, the total complexity of S_i's is O(f^2n). Clearly, the construction time and space complexity for all V_i, E_i, and G_i is O(m) in total. Therefore, it is sufficient to

2312.16397v1_154

http://arxiv.org/abs/2312.16397v1

is O(m) in total. Therefore, it is sufficient to analyze the construction time and the space complexity of S_i for each component U of V_i-1∪ V_i∪ V_i+1.To do this, we use the algorithm by Narasimhan et al. <cit.>which computes an O(f^2k)-sized f-fault-tolerant Euclidean spanner of k points in O(klog k+f^2k) time. Thus, S_i has complexity of O(f^2n_i), andit can be built in O(n_ilog n_ilog + f^2 n_i) time,where n_i=|V_i-1∪ V_i∪ V_i+1|. Note that the sum of all n_i is at most O(m), and

2312.16397v1_155

http://arxiv.org/abs/2312.16397v1

Note that the sum of all n_i is at most O(m), and O(m)=O(n). Therefore, the construction of all S_i takes O(nlog n+f^2n) time, and the total complexity of S_i's is O(f^2n). lemmalemPropertiesOfSiLet F be a set of at most f failed vertices.For two vertices u and v in V(S_i) with |uv|≤ 4L_i, d_S_i-F(u,v)≤ (1+ε)d_G-F(u,v).Moreover, if they are incident in S_i but not in G, then d_G(u,v)≤ L_i/m^3. Since we add an edge uv in S_i not in G only if u and v are connected in G_i-2. Thus, d_G(u,v)≤

2312.16397v1_156

http://arxiv.org/abs/2312.16397v1

u and v are connected in G_i-2. Thus, d_G(u,v)≤ L_i/m^3. As a base case, we assume that u and v are connected in G_i-2. This means they are in a single component U of V_i-1∪ V_i∪ V_i+1.Since S_i contains an f-fault-tolerant Euclidean (1+ε)-spanner on U,d_S_i-F(u,v) is at most (1+ε)|uv|. In this case, the lemma immediately holds. Hence, we assume that u and v are not connected in G_i-2.Let π be the shortest path between u and v in G-F.Since |uv|≤ 4L_i,π does not contain any edge whose length is

2312.16397v1_157

http://arxiv.org/abs/2312.16397v1

4L_i,π does not contain any edge whose length is longer than L_i+1, so π is a path in G_i+1-F.Consider a maximal subpath π whose edges are in G_i-2. Let p and q be its endpoints, and let π[p,q] be the subpath of π between p and q. We replace π[p,q] witha path π̂_pq between p and q in S_i-F as follows. Note that p and q are connected in G_i-2, andboth p and q are in V(S_i) by themaximality of π[p,q].Then we have d_S_i-F(p,q)≤ (1+)|pq| by the base case,and there is a path π̂_pq between p and q in

2312.16397v1_158

http://arxiv.org/abs/2312.16397v1

case,and there is a path π̂_pq between p and q in S_i-F whose length is at most (1+ε)|pq|. We can obtain a path π̂ between u and v in S_i-F by replacing every maximal subpath π[p,q] of π contained in G_i-2 withits corresponding path π̂_pq in S_i-F.Then the path π̂ has length at most (1+ε)|π|=(1+)d_G-F(u,v).§.§ f-Fault-Tolerant Connection Tree For a sequence ℒ_1, an f-fault-tolerant connection tree of ℒ_1is a modifictaion of the connection tree introduced in <cit.>.An f-fault-tolerant connection

2312.16397v1_159

http://arxiv.org/abs/2312.16397v1

in <cit.>.An f-fault-tolerant connection tree is a rooted tree such thateach node c corresponds to a connected component of G_j for j∈[1,|ℒ_1|].The tree allows us to findtwo moderately far vertices p and q in S_i such that p or q is not in F and p and s (and q and s') are connected in G_i-2.To construct an f-fault-tolerant connection tree T, we consider every connected component of G_j in the increasing order of j∈ [0,|ℒ_1|]. Observe that every single vertex is a component of size one in G_0.

2312.16397v1_160

http://arxiv.org/abs/2312.16397v1

single vertex is a component of size one in G_0. For a single vertex v of G, we add a leaf node c corresponding to v, and set i(c)=0. For j≥ 1, a component in G_j is a union of components in G_j-1. For a component C of G_j which is not contained in G_j-1, we add a new node c which corresponds to C, and assign i(c)=j. For every node c' that has no parent yet and corresponds to a component C' with C'⊂ C,we set c to be the parent of c' by adding an edge cc'.Furthermore, we select (f+1) arbitrary

2312.16397v1_161

http://arxiv.org/abs/2312.16397v1

edge cc'.Furthermore, we select (f+1) arbitrary vertices from(V_i(c)∪ V_i(c)+1)∩ C', and store them at the edge cc'. If the number of vertices in (V_i(c)∪ V_i(c)+1)∩ C' is less than (f+1),then we store all of them.We do this until j=|ℒ_1|, and then we have a single tree T. Note that each node of T does not store its corresponding component.Every leaf node of T corresponds to one vertex of G. By the construction,for a node c in T, i(c) is the smallest index i such that the vertices corresponding

2312.16397v1_162

http://arxiv.org/abs/2312.16397v1

index i such that the vertices corresponding to the leaf nodes in the subtree rooted at c areconnected in G_i.lemmalemComplexityConnectionTree We can construct an f-fault-tolerant connection tree of size O(fn) in O(nlog n) timewhich supports LCA queries in constant time.lemmalemConnectionTreeIndexFor a query of two vertices s, s' with |ss'|∈ [L_i/m,L_i/t), the lowest common ancestor c of the leaf nodes in Twhich corresponds to s and s' stores i(c)=i or i-1.The lemma holds if s and s' are

2312.16397v1_163

http://arxiv.org/abs/2312.16397v1

i(c)=i or i-1.The lemma holds if s and s' are connected in G_i, but not in G_i-2. More specifically,for such pair (s,s') of vertices,if s and s' are connected in G_i-1, then the lowest common ancestor c of the leaf nodes s and s' on T stores i(c)=i-1. Otherwise, it stores i(c)=i.Thus, in the following, we show that they are connected in G_i, but not connected in G_i-2. First, s and s' are connected in G_i since G is an Euclidean t-spanner, and Thus, d_G(s,s') lies in [L_i/m,L_i).There is no

2312.16397v1_164

http://arxiv.org/abs/2312.16397v1

Thus, d_G(s,s') lies in [L_i/m,L_i).There is no edge on the shortest path in G between s and s' whose length at least L_i.Second, they are not connected in G_i-2 because d_G(s,s') ≥ L_i/m. If it is not the case,d_G(s,s') ≤ nL_i-2 < L_i-1 < L_i/m, which is a contradiction. lemmalemConnectionTree We can compute p and q in S_i-F in O(f) time such thatp and q are moderately far in S_i and s and p (q and s') are connected in G_i-2.The algorithm takes O(f) time by Lemma <ref>. We show that the

2312.16397v1_165

http://arxiv.org/abs/2312.16397v1

takes O(f) time by Lemma <ref>. We show that the algorithm always finds a vertex p connected to s in G_i-2,then we can analogously prove for q.Recall that c is the LCA of two leaf nodes s and s' in T,and c' is the child node of c with s∈ L(c'). By Lemma <ref>, i(c) is either i or i-1.Then i(c')≤ i-1 and the following holds:(V_i(c)∪ V_i(c)+1)∩ L(c') ⊆ (V_i-1∪ V_i∪ V_i+1)∩ L(c') =V(S_i-F)∩ L(c'). The vertices stored in the edge cc' are in S_i-F and connected with s in G_i(c'). We show that if

2312.16397v1_166

http://arxiv.org/abs/2312.16397v1

and connected with s in G_i(c'). We show that if i(c')≤ i-2, then there exists a vertex p stored in cc' but not in F.The other case is that i(c')=i-1, andthen i(c”)≤ i-2,where c” be the child node of c' with s∈ L(c”).Thus, this case can be analogously proved with respect to c” instead of c'. Now we assume that i(c')≤ i-2. Suppose that all the vertices stored atcc' are contained in F.In this case, cc' stores all vertices in (V_i(c)∪ V_i(c)+1)∩ L(c') . Recall that the number of vertices stored

2312.16397v1_167

http://arxiv.org/abs/2312.16397v1

L(c') . Recall that the number of vertices stored incc'is exactly min{f+1, |(V_i(c)∪ V_i(c)+1)∩ L(c')|}. This means that s and s' are not connected in G_i-F because i(c)=i or i-1.This contradicts that s and s' are connected in G_i-F. Thus, there is a vertex p stored in cc' but not in F.Furthermore, s and p are in L(c'), and they are connected in G_i-2.We show that p and q are moderately far in S_i. Recall that S_i is anf-fault-tolerant Euclidean 4L_i-partial t(1+ε)-spannerby Lemma <ref>. Note

2312.16397v1_168

http://arxiv.org/abs/2312.16397v1

4L_i-partial t(1+ε)-spannerby Lemma <ref>. Note that d_G(s,p) and d_G(q,s') are both at most mL_i-2 since s and p (and q and s') are connected in G_i-2. By the triangle inequality, the following inequalities hold since m is strictly larger than t:|pq| ≥ |st|-|ps|-|s't|≥ L_i/m -2mL_i-2≥ L_i(1/m-2/m^3)>4L_i/m^2 ,and|pq| ≤ |st|+|ps|+|s't|≤ L_i/t +2mL_i-2< 2L_i/t. The last term of the first inequalityis strictly larger than 4L_i/m^2 for m≥ 5. Thus, p and q are moderately far. §.§ Distance Oracle:

2312.16397v1_169

http://arxiv.org/abs/2312.16397v1

p and q are moderately far. §.§ Distance Oracle: Proof of Lemma <ref>We construct an (1+)-approximate distance oracles for every partial spanners S_i which supports a query of two moderately far points and at most f failed vertices in S_i.For a query of s,s' and a set F of at most f failed vertices, our goal is to compute an approximate distance between s and s' in G-F. We compute an element L in a sequence ℒ in the sequences described in Lemma <ref> with |ss'|∈ [L/m,L/t). Note that we have a

2312.16397v1_170

http://arxiv.org/abs/2312.16397v1

with |ss'|∈ [L/m,L/t). Note that we have a partial spanner S with respect to L and a f-fault-tolerant connection tree of ℒ. We compute two moderately far vertices p and q in S-F using Lemma <ref>, and compute d_pq which is an (1+)-approximate distance between p and q in S-F.The query algorithm returns d_pq+2tL/m^2lemmalemEpsCorrectness The query algorithm returns an approximate distance between s and s' in G-F. in O(f+T), where T is the time for computing d_pq.It is clear that the query time is

2312.16397v1_171

http://arxiv.org/abs/2312.16397v1

computing d_pq.It is clear that the query time is in O(f+T). To prove this lemma, we show that the d_pq+2tL/m^2 is an (1+8)-approximate distance between s and s' in G-F.For this purpose, we first show inequality (<ref>) and inequality (<ref>).Recall that |ss'|∈[L/m,L/t), and d_G-F(s,s')≥ L/m. Thus, we have L/m^2≤ d_G-F(s,s')/m≤ε/2t d_G-F(s,s') . By Lemma <ref>, d_G(s,p)≤ mL_i-2, where L_i=L, since G is an f-fault-tolerant Euclidean t-spanner. Then by inequality (<ref>), we prove d_G-F(s,p)≤ε/2

2312.16397v1_172

http://arxiv.org/abs/2312.16397v1

by inequality (<ref>), we prove d_G-F(s,p)≤ε/2 d_G-F(s,s') as follows:d_G-F(s,p) ≤ td_G(s,p)≤ tm L_i-2≤tL/2m^2≤ε/2 d_G-F(s,s') . Analogously, d_G-F(s',q)≤ε/2 d_G-F(s,s'). Now we are ready to prove that the upper bound holds. We have d_pq≤ (1+)d_S-F(p,q), and then d_pq is at most (1+)^2d_G-F(p,q) by Lemma <ref>. Thus, the following holds:d_pq+2tL/m^2≤ (1+)^2d_G-F(p,q)+ d_G-F(s,s')≤ (1+)^2(d_G-F(s,s')+d_G-F(p,s)+d_G-F(q,s'))+ d_G-F(s,s') ≤ (1+)^3d_G-F(s,s')+ d_G-F(s,s')≤ (1+8)d_G-F(s,s').To show

2312.16397v1_173

http://arxiv.org/abs/2312.16397v1

d_G-F(s,s')≤ (1+8)d_G-F(s,s').To show that the lower bound holds, we construct a walk between p and q in G-F whose length is at most d_pq+2tL/m^2.Let π_S-F(p,q) be a shortest path between p and q in S-F. For each edge uv in π_S-F(p,q) not appearing in G,we replace this edge with a shortest path π_G-F(u,v) between u and v. Note that |π_G-F(u,v)|≤ tmL_i-2, where L_i=L, sincewe add an edge in S_i=S only if the edge is in G or its two end vertices are connected in G_i-2. Therefore, this process

2312.16397v1_174

http://arxiv.org/abs/2312.16397v1

are connected in G_i-2. Therefore, this process increases the length of the path by at most tm^2L_i-2≤ tL/m^2 in total. In other words,the obtained path is a path between p and q in G-F whose length is at most d_S-F(p,q)+tL/m^2. Note that d_pq is at least d_S-F(p,q). By the triangle inequality and inequality (<ref>),d_G-F(s,s') ≤ d_G-F(p,q)+d_G-F(s,p)+d_G-F(q,s')≤ d_S_i-F(p,q)+tL/m^2+tL/m^2 ≤ d_pq+2tL/m^2.By combining Lemmas <ref>, <ref>, <ref>, and <ref>, we can obtain Lemma <ref>.* By

2312.16397v1_175

http://arxiv.org/abs/2312.16397v1

and <ref>, we can obtain Lemma <ref>.* By combining the lemma with Theorem <ref>, the following theorem holds.Let G be an f-fault-tolerant Euclidean t-spanner G and >0.There exists an oracle which supports an (1+)-approximate distance of d_G-F(s,s') for a query of twovertices s,s', and at most f failed vertices F in G in O(t^8f^4) time. Furthermore, we can construct such oracle in 2^O(g(t,f,)) nlog^2 n construction time which takes 2^O(g(t,f,))nlog n space complexity, where

2312.16397v1_176

http://arxiv.org/abs/2312.16397v1

takes 2^O(g(t,f,))nlog n space complexity, where g(t,f,)=flog(tf/).§.§ Shortest Path Oracle: Lemma <ref>We construct an (1+)-approximate shortest path oracles for every partial spanners S_i which supports a query of two moderately far points and at most f failed vertices in S_i. Then we can compute a path in S_i for a query.To report an actual path in G, we need additional data structures which allow us to transform a path in S_i into a path in G.Let G^_i be the subgraph of G induced by the

2312.16397v1_177

http://arxiv.org/abs/2312.16397v1

in G.Let G^_i be the subgraph of G induced by the edges of length at most tL_i/m^3.We refer G^_i as the short edges subgraph with respect to tL_i/m^3. We construct an arbitrary path oracle described in Lemma <ref> of G^_iso that we can efficiently compute a path between two connected vertices in G^_i-F for any set of at most f failed vertices.For a query of s,s' and a set F of at most f failed vertices, the query algorithm is similar to the distance query. We compute an element L with

2312.16397v1_178

http://arxiv.org/abs/2312.16397v1

the distance query. We compute an element L with |ss'|∈[L/m,L/t) by Lemma <ref>, and two moderately far vertices p and q in a partial spanner S-F using Lemma <ref>.Note that we have a partial spanner S and induced subgraph the G^ with respect to the tL/m^3. First, we update the arbitrary path oracle of G^ for the failed vertices F. Moreover, we get a path γ_pq which is an (1+)-approximate shortest path between p and q in S-F. We transform γ_pq into an actual path between s and s' in G-F.First,

2312.16397v1_179

http://arxiv.org/abs/2312.16397v1

an actual path between s and s' in G-F.First, we compute an arbitrary path γ_sp between s and p in G^-Fand an arbitrary path γ_qs' between s' and q in G^-F. Then, we transform γ_pq into a path in G-F by replacing each edge uv of γ_pq not appearing in G-F with an arbitrary path in G^-F between u and v. Finally, we return the path π̂(s,s') which is the concatenation of γ_sp, γ_qs' and the transformed γ_pq. lemmalemCorrGenPath_gen The query algorithm returns an approximate shortest path between s

2312.16397v1_180

http://arxiv.org/abs/2312.16397v1

returns an approximate shortest path between s and s' in G-F. in O(f^4log^2nloglog n + T+ f· e(π̂)), where T is the time for computing γ_pq and e(π̂) is the number of edges in the returned path π̂(s,s'). The query time is trivial by Lemma <ref>. In this proof, we show that the length of returned path is smaller than the distance returned by the distance query algorithm which is an approximate distance by Lemma <ref>. The total weight of all edges in G^ is at most tL/m^2. Thus, |π̂(s,s')| is at

2312.16397v1_181

http://arxiv.org/abs/2312.16397v1

in G^ is at most tL/m^2. Thus, |π̂(s,s')| is at most |γ|+tL/m^2. Note that |γ| is at most (1+)d_S-F(p,q)≤ (1+)^2d_G-F(p,q) by Lemma <ref>.The length |π̂(s,s')| of π̂(s,s') is at most (1+8)d_G-F(s,s') by Inequalities <ref> and <ref>. Thus, the returned path is an approximate shortest path between s and s' in G-F. By combining Lemmas <ref>, <ref>, <ref>, <ref>, and <ref>, we can obtain Lemma <ref>. *By combining the lemma with Theorem <ref>, the following theorem holds.Let G be an

2312.16397v1_182

http://arxiv.org/abs/2312.16397v1

the following theorem holds.Let G be an f-fault-tolerant Euclidean t-spanner G and >0.There exists an oracle which supports an (1+)-approximate shortest path of π_G-F(s,s') for a query of twovertices s,s', and at most f failed vertices F in G in O(f^4log^2 nloglog n +f·) time. Furthermore, we can construct such oracle in 2^O(g(t,f,)) n^2log^2 n construction time which takes 2^O(g(t,f,))nlog^2 nloglog n space complexity, where g(t,f,)=flog(tf/) andis the number of edges in the returned path.§

2312.16397v1_183

http://arxiv.org/abs/2312.16397v1

andis the number of edges in the returned path.§ CONCLUSIONIn this paper, we presented efficient approximate distance and shortest-path oracles for an f-fault-tolerant Euclidean t-spanner and a value >0.Although we state our results in the case that the underlying space is two-dimensional, we can extend our results to the d-dimensional Euclidean space.In this case, we can apply all strategies outlined in this paper slightly increasing the performance of the oracles stated in Table <ref>. This

2312.16397v1_184

http://arxiv.org/abs/2312.16397v1

of the oracles stated in Table <ref>. This extension does not impact on the dependency on n while the dependency on {t,f,} increases. More specifically, in a d-dimensional space, for any r-net 𝒩 of a Euclidean graph G, there exist at most (2c+2)^d net vertices of 𝒩 within a ball of radius cr.As a result, the result in Lemma <ref> can be turned into a single exponential function in d. Consequently, the function h(t,f,) in Table <ref> becomes h(d,t,f,)= exp (O((d+f)log (dtf/))). Analogously, the

2312.16397v1_185

http://arxiv.org/abs/2312.16397v1

exp (O((d+f)log (dtf/))). Analogously, the kernel oracle answers a t^O(d)f^2-sized kernel in t^O(d)f^4 time for a query of two moderately far vertices and failed vertices, andthe path-preserving kernel oraclecan return the kernel of size t^O(d)f^2log^3(dtf/)log^2n in t^O(d)f^4log^3(dtf/)log^2n time. Then the query times stated in Table <ref> increase accordingly. Although this is the first near-linear-sized approximate shortest-path oracle for graphs with vertex failures,one might think that it

2312.16397v1_186

http://arxiv.org/abs/2312.16397v1

with vertex failures,one might think that it is still not practical because of large hidden constants in the performance guarantees. Although it seems hard to avoid the exponential dependency on t and f in the oracle sizes theoretically, we believe that it can be made more efficient in practice by applying several optimization tricks.This is indeed one of interesting directions for future work; our work is just a starting point.We hope that our work would be a stepping stone towards bridging

2312.16397v1_187

http://arxiv.org/abs/2312.16397v1

work would be a stepping stone towards bridging the gap between theory and practice in the routing problem for dynamic networks. plainurl

2312.15971v1_0

http://arxiv.org/abs/2312.15971v1

Graph Context Transformation Learning for Progressive Correspondence Pruning Myung-Ki Cheoun January 14, 2024 ============================================================================ Most of existing correspondence pruning methods only concentrate on gathering the context information as much as possible while neglecting effective ways to utilize such information. In order to tackle this dilemma, in this paper we propose Graph Context Transformation Network (GCT-Net) enhancing context

2312.15971v1_1

http://arxiv.org/abs/2312.15971v1

Network (GCT-Net) enhancing context information to conduct consensus guidance for progressive correspondence pruning. Specifically, we design the Graph Context Enhance Transformer which first generates the graph network and then transforms it into multi-branch graph contexts. Moreover, it employs self-attention and cross-attention to magnify characteristics of each graph context for emphasizing the unique as well as shared essential information. To further apply the recalibrated graph contexts

2312.15971v1_2

http://arxiv.org/abs/2312.15971v1

To further apply the recalibrated graph contexts to the global domain, we propose the Graph Context Guidance Transformer. This module adopts a confident-based sampling strategy to temporarily screen high-confidence vertices for guiding accurate classification by searching global consensus between screened vertices and remaining ones. The extensive experimental results on outlier removal and relative pose estimation clearly demonstrate the superior performance of GCT-Net compared to

2312.15971v1_3

http://arxiv.org/abs/2312.15971v1

the superior performance of GCT-Net compared to state-of-the-art methods across outdoor and indoor datasets. The source code will be available at: https://github.com/guobaoxiao/GCT-Net/.§ INTRODUCTIONTwo-view correspondence pruning methods strive to form robust correspondences between two sets of interest points to lay the foundation for many computer vision tasks, such as, Structure from Motion (SfM) <cit.>, Simultaneous Localization and Mapping (SLAM) <cit.> and Image Fusion <cit.>.

2312.15971v1_4

http://arxiv.org/abs/2312.15971v1

Mapping (SLAM) <cit.> and Image Fusion <cit.>. Correspondence pruning involves three steps: keypoints and relating descriptors extraction, the initial correspondence set establishment and outlier (i.e. false correspondence) removal. More specifically, we employ established methods, such as SuperPoint <cit.> and SIFT <cit.>, to generate keypoints and computer their descriptors at first. Subsequently, the initial correspondence set is generated by applying the nearest matching algorithm to the

2312.15971v1_5

http://arxiv.org/abs/2312.15971v1

by applying the nearest matching algorithm to the descriptors. However, the initial correspondence set often contains numerous outliers (shown in Fig. <ref>) due to the limitations of local descriptor representation and the presence of low-quality images. Therefore, the third step, identifying and eliminating outliers, is indispensable. As illustrated in Fig. <ref> and Fig. <ref>, outliers are removed and most of inliers are preserved, enhancing the available insights for post-processing

2312.15971v1_6

http://arxiv.org/abs/2312.15971v1

the available insights for post-processing endeavors. Correspondence pruning methods are mainly evolved into two distinct factions, i.e., tradition methods and learning-based methods. RANSAC <cit.> and its modifications <cit.> are representative of traditional methods. These methods adopt a sampling-verification loop to retain most of correspondences adhering to a specific geometric model. However, in scenarios with a high proportion of outliers, the runtime of these methods will rapidly

2312.15971v1_7

http://arxiv.org/abs/2312.15971v1

the runtime of these methods will rapidly increase and simultaneously, the quality of the results will significantly deteriorate. In our task, it is common for the initial correspondence set to have an outlier proportion exceeding 80%, rendering these methods inapplicable.The most of learning-based advancements approach the correspondence pruning as a binary classification problem and achieve remarkable potential. But this treatment also poses formidable challenges: (1) unordered data should be

2312.15971v1_8

http://arxiv.org/abs/2312.15971v1

challenges: (1) unordered data should be handled appropriately to ensure its permutation invariance. (2) local context and global context should be adequately mined to provide the basis to identify outliers.For example, LFGC-Net <cit.> and OANet <cit.> employ the PointNet-like architecture <cit.> which embeds Context Normalization (CN) into Multi-Layer Perceptrons (MLPs) to deal with each correspondence individually for gaining the global context. CLNet <cit.>, MS^2DG-Net <cit.> and NCM-Net

2312.15971v1_9

http://arxiv.org/abs/2312.15971v1

CLNet <cit.>, MS^2DG-Net <cit.> and NCM-Net <cit.> all construct the graph network via K-Nearest Neighbor (KNN) to build relationships among adjacent correspondences for searching and aggregating local context. All these methods aim to obtain adequate local and global context information while preserving the permutation invariance of input data. However, their primary emphasis lies in acquiring abundant context information, overlooking the practical utilization of such context knowledge. In

2312.15971v1_10

http://arxiv.org/abs/2312.15971v1

utilization of such context knowledge. In this paper, we propose the Graph Context Enhance Transformer (GCET) block that not only gathers multi-branch graph contexts but also thoroughly mines and emphasizes respective and common significant context information via self-attention and cross-attention to boost the discriminating capability of the network. In specific, we first employ KNN to construct the graph network where each node represents a correspondence and each edge denotes a relationship

2312.15971v1_11

http://arxiv.org/abs/2312.15971v1

and each edge denotes a relationship between two correspondences. Next, we transform the graph network filled with a wealth of context information into two completely different types of graph context to receive various evidence. In one type, local context is aggregated by MLPs and maxpooling, which, although sacrificing a considerable amount of structure information, guarantees the reliability of graph context. In the other type of graph context, local context is gathered by affinity-based

2312.15971v1_12

http://arxiv.org/abs/2312.15971v1

local context is gathered by affinity-based convolution which captures the vast majority of relationships in the graph structure while preserving contaminated information. It is feasible to immediately integrate the complementary graph contexts from multiple branches, but it is not the optimal choice because there is untapped potential yet to be explored. Here, we utilize self-attention to amplify the crucial parts and reliable dependencies among correspondences for emphasizing the

2312.15971v1_13

http://arxiv.org/abs/2312.15971v1

among correspondences for emphasizing the distinctiveness of graph context within each branch. In parallel, we employ cross-attention to uncover and enhance the shared importance between different salient graph contexts. Finally, the discriminative fusion strategy is applied to absorb highlight components of graph contexts and discard redundant portions meanwhile.Moreover, in order to further apply the fused graph context to the global domain, we present the Graph Context Guidance Transformer

2312.15971v1_14

http://arxiv.org/abs/2312.15971v1

we present the Graph Context Guidance Transformer (GCGT) block which adopts the score-based sampling to select a set of candidates and utilize transformer to guide spatial consensus at the global level through sampled candidates. Specifically, we first employ the linear layer to score the confidence values for each correspondence. Then, we select a set of correspondences with high scores as the global guiding source and regard original correspondences as the guiding target. It is worth noting

2312.15971v1_15

http://arxiv.org/abs/2312.15971v1

as the guiding target. It is worth noting that before the guiding procedure, we also perform the cluster operation on the guiding source and target to enhance their reliability and reduce computational overhead. At last, the guiding source and target are fed into transformer to steer correspondences with high global consistency and shape long-range dependencies. Additionally, we also capture short-range spatial dependencies to complement the output of transformer.Our contributions are

2312.15971v1_16

http://arxiv.org/abs/2312.15971v1

the output of transformer.Our contributions are three-fold: (1) We propose the GCET block which generates multi-branch graph contexts with respective characteristics and employs self-attention and cross-attention to emphasize individual nature and shared crucial knowledge for better absorbing advantages from each branch. (2) Drawing on the foundation of global consensus and guided by the principle of distinct inliers to guide hidden inliers, we design the GCGT block which samples credible

2312.15971v1_17

http://arxiv.org/abs/2312.15971v1

we design the GCGT block which samples credible inliers to direct remaining inliers exhibiting high spatial consensus. (3) By combining the GCET block and GCGT block, we develop an effective Graph Context Transformation Network (GCT-Net) for outlier removal and relative pose estimation, achieving the state-of-the-art performance on both outdoor and indoor datasets.§ RELATED WORK§.§ Learning-Based Correspondence Pruning MethodsThe advent of deep learning has provided many new inspirations for

2312.15971v1_18

http://arxiv.org/abs/2312.15971v1

learning has provided many new inspirations for tackling outlier rejection. As a pioneer in this field, LFGC-Net <cit.>, driven by <cit.>, subdivides the correspondence pruning task into outlier/inlier labeling and essential matrix regression. Besides, it further designs a permutation-equivariant architecture, which integrates CN into MLPs, thereby dealing with unordered data while obtaining the global context. The most of subsequent works adopt the de facto framework and incorporate or modify

2312.15971v1_19

http://arxiv.org/abs/2312.15971v1

the de facto framework and incorporate or modify components to gain context information to enhance the network performance. For example, in order to overcome the disturbance of contaminated information caused by CN, ACNet <cit.> transforms CN into attentive ones to discriminately treat various information. OANet <cit.> clusters correspondences by the differentiable pooling layer and recovers the original order of correspondences based on the differentiable unpooling layer for exploiting

2312.15971v1_20

http://arxiv.org/abs/2312.15971v1

the differentiable unpooling layer for exploiting potential local context as well as reducing computation overhead. CLNet <cit.> first constructs the local graph for each correspondence to gather local context and then connects all local graphs to generate a global one to acquire abundant global context. MS^2DG-Net <cit.> leverages the combination of maxpooling and self-attention to progressively update the local graphs for multi-level context. Diverging from the aforementioned approaches,

2312.15971v1_21

http://arxiv.org/abs/2312.15971v1

Diverging from the aforementioned approaches, which generates a solitary graph context and directly employs it in a superficial manner, our method generates multi-branch graph contexts with respective characteristics and knowledge and refine graph contexts through both self-interactions and collaborative interactions. §.§ Attention Mechanism in Correspondence PruningCurrently, attention mechanisms have been extensively employed in many computer tasks, including semantic segmentation <cit.>,

2312.15971v1_22

http://arxiv.org/abs/2312.15971v1

tasks, including semantic segmentation <cit.>, image fusion <cit.> and so on. For the field of correspondence pruning, the introduction of attention mechanisms is beneficial to focus on inlier information and suppress redundant information, but it still necessitates some appropriate modifications. For instance, SENet <cit.> is a simple yet efficient channel attention mechanism that emphasizes important knowledge in the channel dimension via the squeeze-and-excitation (SE) block. However, it

2312.15971v1_23

http://arxiv.org/abs/2312.15971v1

squeeze-and-excitation (SE) block. However, it prioritizes the global aspect and neglects the demand for local aspect in correspondence pruning. Therefore, MSA <cit.> introduces the multi-scale attention by remoulding the SE block, carrying out information recalibration from multiple perspectives for accurate inlier/outlier classification. Additionally, CA <cit.> and CBAM <cit.>, integrating the spatial attention mechanisms, further consider the weight allocation in the spatial dimension. But

2312.15971v1_24

http://arxiv.org/abs/2312.15971v1

weight allocation in the spatial dimension. But their effectiveness is limited for correspondence pruning methods. The emergence of vanilla Transformer brings new prospects for addressing the problem of capturing long-range spatial dependencies, but simultaneously introduces various challenges. Firstly, considering that the number of correspondence N typically falls within the range of 1500 to 2000 in correspondence pruning, the computation complexity of Transformers, which is O(N^2· D),

2312.15971v1_25

http://arxiv.org/abs/2312.15971v1

complexity of Transformers, which is O(N^2· D), results in a substantial computational burden. Although some varieties of transformer, like ViT <cit.> and Swin-Transformer <cit.>, reduce the computational load, the patch strategy can negatively impact the handling of unordered data. Secondly, in the initial correspondence set, outliers constitute the majority, and their presence can interfere with similarity computation, significantly diminishing the reliability of the output attention map.

2312.15971v1_26

http://arxiv.org/abs/2312.15971v1

the reliability of the output attention map. Therefore, we propose the GCGT block which mitigates the impact of contaminated information during interaction process and reduces computational overhead in a scaling approach. This transformation renders Transformer-like architecture well-suited for correspondence pruning.§ METHODOLOGY§.§ Problem FormulationGiven a putative set of image pairs (I,I^'), we first employ off-the-shelf keypoint extraction methods <cit.> to search interest points and

2312.15971v1_27

http://arxiv.org/abs/2312.15971v1

methods <cit.> to search interest points and calculate concerning descriptors. Afterwards, the initial correspondence set Q=[q_1, q_2,q_3,…, q_N] ∈ R^N×4 consisted of N correspondences is generated by roughly matching keypoints through descriptor similarities. As the basic element in Q, q_i represents the i-th correspondence which involves two coordinates normalized by camera intrinsics in respective image. However, the brute-force matching process contributes to an overwhelming proportion of

2312.15971v1_28

http://arxiv.org/abs/2312.15971v1

contributes to an overwhelming proportion of outliers in the initial correspondence set. Consequently, an efficient correspondence pruning method should be developed to conduct more accurate correspondence classification and relative pose estimation. In pursuit of this objective, we propose Graph Context Transformation Network (GCT-Net) and illustrate its network architecture in Fig. <ref>. We adopt the progressive pruning strategy <cit.> in our network which is capable of gradually screening

2312.15971v1_29

http://arxiv.org/abs/2312.15971v1

network which is capable of gradually screening outliers and thus mitigates the negative impact of contaminated information. With the perspective of pruning module, the input data passes through 3 ResNet blocks, the Graph Context Enhance Transformer (GCET), another 3 ResNet blocks and Graph Context Guidance Transformer (GCGT). ResNet blocks are used to boost representation ability of the network, GCET aims to enhance the converted graph context, and GCGT further leverages enhanced context to

2312.15971v1_30

http://arxiv.org/abs/2312.15971v1

and GCGT further leverages enhanced context to guide remaining inliers. In general, we first utilize two series-connected pruning modules to deal with the input correspondence set Q. The operations in these two modules can be respectively expressed as: (Q_1,o_1)=f_σ1(Q) and (Q_2,o_2)=f_σ2(Q_1) where σ1 and σ2 are their related parameters. Here, Q_1∈ℝ^N_1×4 and Q_2∈ℝ^N_2×4 denote the pruned correspondence set (N>N_1>N_2) and o_1∈ℝ^N_1×1 and o_2∈ℝ^N_2×1 represent the output logit values. Based on

2312.15971v1_31

http://arxiv.org/abs/2312.15971v1

represent the output logit values. Based on logit values, we sort correspondences in descending order and preserve 50% of correspondences by pruning the lower 50%.. It is worth noting that the feature map of Q_2 is preserved and additionally passed through a linear layer to estimate the inlier weight set w. The next step (i.e. model estimation), regarding w as supplementary input, involves and Q_2 with w to execute the parametric model calculation (i.e., estimate essential matrix Ê). Finally,