{'fraction_non_alphanumeric': 0.03760017738921093, 'fraction_numerical': 0.007095568437391111, 'mean_word_length': 4.0861930078943125, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 5, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Pairbot: A Novel Model for Autonomous Mobile Robot Systems Consisting of Paired Robots

Programmable matter consists of many self-organizing computational entities which are autonomous and cooperative with one another to achieve a goal and it has been widely studied in various fields, e.g., robotics or mobile agents, theoretically and practically. In the field of computer science, programmable matter can be theoretically modeled as a distributed system consisting of simple and small robots equipped with limited capabilities, e.g., no memory and/or no geometrical coordination. A lot of theoretical research is studied based on such theoretical models, to clarify the relation between the solvability of various problems and the considered models. We newly propose a computational model named Pairbot model where two autonomous mobile robots operate as a pair on a grid plane. In Pairbot model, every robot has the one robot as its unique partner, called buddy, each other. We call the paired two robots pairbot. Two robots in one pairbot can recognize each other, and repeatedly change their geometrical relationships, long and short, to achieve the goal. In this paper, as a first step to show the feasibility and effectiveness of the proposed Pairbot model, we introduce two simple problems, the marching problem and the object coating problem, and propose two algorithms to solve these two problems, respectively. In both algorithms, it is assumed that the visibility range is one (every robot can observe only its neighboring robots) and the scheduler is asynchronous (ASYNC).

As an extended capability of mobile robots, an externally visible memory register, called light, is proposed in [25]. An autonomous mobile robot with the light is called a luminous robot, and every luminous robot maintains a persistent value, called color, which means that the value is never reset even if an oblivious robot terminates its action. Each luminous robot can observe the colors of the other robots within its visibility range, and this improves the power of each mobile robot, hence, many problems are newly investigated based on this capability such as [26,27,15,16,28].
Recently, a programming matter [29], which is a matter that can change its physical properties, e.g., shape or density, in a programmable fashion, and it attracts much attention of many researchers as one of the practical applications of distributed coordination, e.g., the realization of surgical treatments using nanorobots [30] or a set of modular robots which can freely transform its shape [31,32]. As the one method to realize a programming matter, a self-organizing particle system, also called Amoebot model, is newly proposed in [33]. Amoebot model consists of a large number of computational particles on a (triangular) grid plane which locally interacts one another to solve the given problem. Each particle repeatedly changes its state, either contraction or expansion, which means the state that a particle occupies one node and two adjacent nodes respectively. In Amoebot model, it allows two connected particles to perform a coordinated movement, called a handover, which is an interaction that a particle can contract out of a certain node at the same time as another particle expand into that node. Amoebot model can realize many distributed coordination problems such as a universal coating problem [34], a leader election [35], convex hull formation [36], and many others.
Amoebot model has some imperative differences from the conventional autonomous mobile robots [1]. In Amoebot model, each particle can communicate by writing their local memory and reading the local memory of adjacent particles, whereas there is no explicit communication in autonomous mobile robots (known as LCM-model). In LCM-model, each robot determines its behavior based on the snapshot taken at Look phase instead of a communication. Moreover, Amoebot model assumes the symmetry breaking: when two or more particles attempt to move to the same cell, one of them will succeed. On the other hand, each robot in autonomous mobile robots cannot break the symmetry when two or more robots attempt to move the same point, which implies that a sophisticate algorithm is required to avoid some unintended movement among the robots.

Contribution
In this paper, we consider a new method for realizing a programmable matter that makes it easy to investigate and analyze its capabilities and feasibilities by using existing knowledge. We introduce a new model named Pairbot model where two robots operate as a pair on a grid plane. Pairbot model has several new capabilities, e.g., local label or exclusive move, which are not assumed in a classical LCM-model, but most of capabilities are the same as LCM-model's. The new capabilities provide higher computational power (i.e., solvability) than LCM-model, as well as good insight for realization of programmable matter based on LCM-model.
Amoebot model [33] is another new model for programmable matter which is inspired by the behavior of amoeba. Amoebot model has new computational capabilities, e.g., communication, symmetry breaking, and occupying two points, which are not assumed in the conventional LCM-model. Therefore, it is difficult to directly compare the computational capability between Amoebot model and LCM-model. On the other hand, Pairbot model is a new theoretical model which has many same capabilities as LCM-model's, thus the differences between Pairbot model and LCM-model are also clear. By the similarity and difference between Pairbot model and LCM-model, Pairbot model provides higher computational power than LCM-model, moreover, it is also possible to introduce plenty of knowledge from many results about LCM-model investigated over twenty years.
In the proposed model, Pairbot model, each robot has the one robot as its unique partner, called buddy, each other, and we call the paired two robots pairbot. A pairbot system consists of two or more pairbot. Each of two robots in one pairbot can recognize each other as its buddy, and the two robots repeatedly change their geometrical relationship, short and long, to achieve a goal. When a pairbot is in short state, the two robots occupy the same point, whereas in long state, the two robots are located on the two distinct (adjacent) points.
As the first step to show the feasibility and effectiveness of Pairbot model, we introduce two simple problems, the marching problem and the object coating problem, and propose two deterministic algorithms to solve these two problems respectively. We expect that these two problems and algorithms help to understand Pairbot model, and provide a good insight for its computational power and limitations.

Paper Organization
This paper is organized as follows: Section 2 introduces the proposed system model named Pairbot model. Section 3 gives the marching problem based on Pairbot model, and proposes an algorithm to solve the marching problem, and we present another problem named the object coating problem and the algorithm to solve the problem in Section 4. We conclude our work in Section 5.
: Triangular grid plane T We consider a set of n autonomous mobile robots, denoted by R = {r 1 , r 2 , . . . , r n } on a 2-dimensional triangular grid plane T = Z 2 like Fig.1. The distance between two points u and v on T is defined by the following equation.
If the distance between two points is one, we say that the two points are adjacent. The triangular grid plane T can be also represented as an infinite regular graph G T = (V T , E T ), where V T consists of all the points on T and E T is defined by every two adjacent points on T, i.e., for u, v ∈ V T , (u, v) ∈ E T iff dist(u, v) = 1.

Geometric Agreement
Every robot has its own local coordinate system which can be defined by the directions, i.e., X and Y axes, and the orientations, i.e., the positive and negative side of each axis. We can consider some levels of consistency among the robots on their local compass: total agreement, when all the robots agree on the directions and orientations of both axes; partial agreement, when all the robots agree on the direction and orientation of only one axis or they agree on chirality which means a sense of the orientation of the axes, i.e., clockwise or counter-clockwise; or no agreement, when there is no agreement among the local coordinate system of each robot.
In this paper, we assume total agreement that all the robots in R agree on the directions and orientations of both axes, but no robot knows the position of the origin. In other words, no robot knows its global coordinate, however, all the robots agree on the sense of directions, e.g., north, south, east, and west.

Pairbot
In Pairbot model, every robot has its unique partner (called buddy): robot r i is the buddy of robot r j if and only if robot r j is the buddy of robot r i . When robots r i and r j are determined as a pair, we call the two robots r i and r j a pairbot, and denote as pair (r i , r j ).
The buddy of each robot is initially determined and never changes. Obviously, the number of robots n is an even number because every robot has its corresponding buddy, and without loss of generality, we assume that robots r i and r i+1 are the pairbot for an odd number i, i.e., pair (r i , r i+1 ), where ∀r i ∈ R | i = 2k + 1 (0 ≤ k ≤ (n/2 − 1)).

Operations
Each robot r i cyclically performs the following three operations, Look, Compute, and Move, based on a well-known computational model as LCM-model or Suzuki-Yamashita model [1].
• Look: Each robot takes a snapshot consisting of the robots within the visibility range with respect to its local coordinate system. • Compute: Each robot performs a local computation based on the snapshot taken by Look phase according to algorithm A . Algorithm A is basically uniform, i.e., every robot executes the same algorithm. As the result of Compute phase, each robot determines its destination point to move. • Move: Based on the result of Compute phase, each robot actually moves to the adjacent destination point from the current point in Move phase. Each robot moves instantly, this implies that each robot is never looked by the other robots while moving. Null movement (staying) is also allowed, i.e., a robot does not move.

Local Label
Each robot locally maintains the labels for each incident edge, from 1 to 6, to distinguish its adjacent points. Each robot selects one incident edge, labels the selected edge as 1, and labels the other edges from 2 to 6 in clockwise order. Note that the direction of the edge labeled as 1 may be different by the assumption of the geometric agreements among robots, moreover, the clockwise order may also vary by the assumption of chirality.  Fig.2, robot r i labels the edge on the right side as 1, however, robot r j or r k labels the edge which has different direction with r i 's as 1. This is because the robots do not agree on the directions and orientation of any axis. Moreover, the edges of robot r k are labeled in counter-clockwise order, because the robots do not agree on chirality.
In this paper, every robot has the same local labels, e.g., every robot maintains the same labels as robot r i in Fig.2 due to total agreement.

Capabilities
All the robots are oblivious, i.e., no memory, which means every robot never knows any past executions of itself.
Each robot can recognize the other robots within its visibility range V , this means each robot can sense only up to V hops far from itself. In other words, robot r u on point u and robot r v on point v (where r u , r v ∈ R and u, v ∈ V T ) can observe each other only when dist(u, v) ≤ V . In this paper, we assume that the visibility range of each robot is one, i.e., each robot can observe only the robots at the adjacent points.
Moreover, we assume that each robot has capability of weak multiplicity detection, that is, each robot can distinguish from the following three cases on the points within its visibility, no robot exists, only one robot exists, and more than one robot exists. Note that if each robot can count the exact number of the robots occupying the point within its visibility range, we say it strong multiplicity detection.
All the robots in R are anonymous: each robot has no identifier and no robot is distinguishable by its appearance. However, each robot maintains the position of its buddy using its local label. This implies that each robot has a local memory to maintain the position (local label) where its buddy is located.
Moreover, we assume that when a pairbot occupies the same point, only one robot can move to its adjacent point when it moves and we call this an exclusive move. Note that no robot knows that any other two robots are pairbot or not. The two robots in one pairbot occupy the same point or two adjacent points on T as Fig.3. We call the former one short state and the latter one long state respectively. When a pairbot is in short state, only one robot in the pairbot can (exclusively) move the adjacent point from its current point and the pairbot becomes long state. When a pairbot is in long state, either of the two robots can move to the point occupied by its buddy, and the state is changed back to short state. In Pairbot model, every pairbot repeatedly changes its state, short and long, to achieve the goal. Obviously, a pairbot never knows which robot moved while its state changed because all the robots are oblivious. Fig.4 illustrates an example of pairbots. pairbot, r i and r j , is in long state, and some other robots are placed on the other points on T. In this case, robot r i recognizes that its buddy is robot r j on its right side. However, r i cannot know the pair relations of the other robots, e.g., robot r i never knows the buddy of robot r x on its lower left side. Robot r y can recognize another robot is on the same point due to weak multiplicity detection, moreover, r y can know that the buddy r x is on the point of its upper left side and it is in long state.

Scheduler
We consider a scheduler which decides which robot to activate and the timing of each operation. There are three representative assumptions (models) for a scheduler, fully-synchronous (FSYNC), semi-synchronous (SSYNC), and asynchronous (ASYNC).
In an FSYNC scheduler, all the robots are activated at the same time and all the three operations, Look, Compute, and Move, are executed based on the exactly same cycle time. In an SSYNC scheduler, all the robots execute their operations at the same time, but some robots may not be activated. The robots which are not activated by a scheduler wait till all the activated robots terminate their operations. And in an ASYNC scheduler, there is no assumption on the cycle time of each robot. This implies that all the robots execute their operations at unpredictable time instants and durations.
In this paper, we assume an ASYNC scheduler such that Move phase operates atomically: each robot requires unpredictable finite time to operate Look or Compute phase, but it can atomically move, called the move-atomic property. Therefore, each robot is never observed while it is moving. We assume that the two robots which are the pairbot are activated at the same time by the scheduler.

Configuration
A configuration C t consists of the positions of all the robots in R at time t: C t = {(r 1 .x(t), r 1 .y(t)), (r 2 .x(t), r 2 .y(t)), . . . , (r n .x(t), r n .y(t))}, where (r i .x(t), r i .y(t)) is the global coordinate of robot r i at time t on T. Note that no robot knows its global coordinate on T. Let R be a non-empty subset of R and A be an algorithm, we denote C t → (R ,A ) C t+1 if a configuration C t+1 is obtained when each robot in R simultaneously performs its Move operation of A in configuration C t . Hence a scheduler can be presented as an infinite sequence R 1 , R 2 , · · · of non-empty subsets of R. An execution Ξ A (S , C 0 ) of algorithm A along schedule S = R 1 , R 2 , · · · starting from configuration C 0 , where C 0 is an initial configuration, can be defined as the infinite sequence of configurations C 0 , C 1 , · · · such that C i → (Ri+1,A ) C i+1 for all i ≥ 0.

Marching Problem and Algorithm
In this section, we introduce a basic problem, named the marching problem, for Pairbot model, and propose an algorithm to solve the marching problem.

Problem Definition
We consider a marching, which is a linear movement of the robots lined up in a straight line to the agreed direction keeping their line formation, as a basic moving operation of the set of pairbots. Before the formal definition of the marching problem, we define a specific formation of the pairbots.
We consider that the set of robots R initially forms a straight line as Fig.5, i.e., if any two points are occupied by robots, every point located between the two points is occupied by a robot. We assume that the straight line formed by the robots is parallel to the agreed direction. And we also assume that there are at most two robots on each point, however, there exist no two pairbots which are in long state on the two same points. For example, let robots r a and r b be one pairbot and robots r c and r d be another pairbot. In this case, we do not consider the configuration such that r a and r c occupy the same point and r b and r d occupy another same point (which is an adjacent to the point occupied by r a and r c ). We call above configuration the robots (pairbots) are line-formed. • The robots are line-formed.
• Robot r h moves to its adjacent unoccupied point on the side of the directions to move within the finite number of executions.
Intuitively, in the marching problem, all the robots repeatedly move to the agreed direction keeping line-formed. And the termination is not considered in the marching problem.

Marching Algorithm
To help to understand, in this subsection, we assume that the positive direction of X axis is on the right side like Fig.1. Note that all the robots agree on the direction and orientation of one axis, thus we can assume that every robot labels the edge on its right side as 1 (refer to robot r i in Fig.2).
Algorithm 1 represents the marching algorithm where the move to the direction is 1 . In Algorithm 1, line 1 can be executed only when a pairbot is in short state, and line 2 or line 3 can be executed only when a pairbot is in long state. To help to explain, we call the robot which has no neighboring robot on 1 the head robot (denote r h ), i.e., r h .occupy( 1 ) = 0, and call the robot which has no neighboring robot on 4 (the counter direction of 1 ) the tail robot (denote r t ), i.e., r t .occupy( 4 ) = 0. Note that there can be two head robots (and/or tail robots) when the pairbot is in short state.
A pairbot in short state, i.e., buddy = 0 , checks the adjacent point 1 , and it becomes long state by an exclusive move of one robot to the point 1 if one or no robot is on 1 . Obviously, the head robot always moves to 1 and becomes long state when it is in short state.
If the pairbots are in long state, the tail-sided robot of the two robots, i.e., a robot which has its buddy on 1 , moves toward its buddy (on 1 ) when either of the two conditions (lines 2 and 3) is satisfied. Let r i be a robot which has its buddy on 1 , i.e., buddy = 1 (long state). If there is no robot on r i . 4 , which means r i is the tail robot, robot r i moves to 1 and becomes short state (line 2). If r i is not the tail robot, i.e., r i .occupy( 4 ) ≥ 1, robot r i moves to 1 only when another robot (denote r j ) is on the same point of r i (line 3). Note that r j is not the buddy of r i because the pair of r i is on r i . 1 .

Correctness of Marching Algorithm
Now we show the correctness of the marching algorithm proposed in the previous subsection.
Lemma 1 If all the robots in R are line-formed in configuration C t , the robots are also line-formed in C u for any u > t.
Proof 1 Note that the proposed algorithm consists of three rules, one makes a pairbot long state (line 1), and the other two rules make a pairbot short state (lines 2 and 3). Obviously, when all the robots in R are line-formed, even if some pairbots in R becomes long state from short state, all the robots in R are also line-formed. This is because even if either of the two robots in short state moves to the adjacent point, another one (its buddy) leaves the current point. Therefore, we consider only two rules which make a pairbot short state.
In the proposed algorithm, every robot moves to 1 (the agreed direction) only, which implies that if two robots r i and r j are the pairbot and in long state, robot r i occupies the point r j . 1 (or r j . 4 ). We assume r i is on r j . 4 without loss of generality, hence r j never executes the algorithm because r j .buddy = 1 .
Assume that robot r i satisfies < guard > in line 2 under configuration C t such that the robots are line-formed. From the condition of < guard > in line 2, there is no robot on r i . 4 , this means that robot r i is the tail robot and there exists no robot on the left side of r i because the pairbots are line-formed. Therefore, the execution of line 2 never makes the pairbots not line-formed. Note that no other robot can move to the point occupied by r i or r j even under ASYNC scheduler because every robot can move to only 1 . This implies that the execution of line 2 is never interrupted by any other robots.
Now we consider the case that robot r i satisfies < guard > in line 3 under configuration C t . In this case, robot r i finds that there exists another robot (say r k ) which is not the buddy of r i in the current occupying point, this means that the current point is occupied by r k even if r i moves to r i . 1 . Note that if r i does not move to r i . 1 , (1) r k never moves, (2) no other robot (even r k .buddy) moves to the point occupied by r i (and r k ), and (3) occupy(r i . 1 ) is never changed. This means that the result (the snapshot) of r i 's Look operation is never changed before r i 's Move operation even under ASYNC scheduler.
Now we show that all the robots repeatedly move toward the agreed direction by the proposed algorithm. To help to understand, without loss of generality, we assume that each robot r i attempts to move to r i . 1 (the agreed direction).

Lemma 2
The head robot, i.e., the robot which has no neighboring robot on 1 , eventually moves to 1 .

Proof 2
We denote the head robot as r h , and we consider two cases such that the pairbot including r h is in (1) short state, and (2) long state.
If the pairbot including r h is in short state, it executes line 1 of the algorithm, thus, either of the two robots (r h ) exclusively moves to r h . 1 . Unless r h moves to r h . 1 , no other robot can move to the point occupied by r h because occupy(r h ) = 2. Therefore, this operation is never interrupted by any other robot even under ASYNC scheduler.
On the other hand (the pairbot including r h is in long state), the buddy of r h (say r i ) occupies point r h . 4 . Now we consider the following two cases: (2a) occupy(r h . 4 ) = 1 and (2b) occupy(r h . 4 ) = 2.
In case (2a), if there exists another robot on the point occupied by r i , r i moves to r i . 1 by executing line 3 of the algorithm. Obviously, unless r i moves to r h , no other robot can move to the point occupied r i or r h . Therefore, pairbot, r h and r i , becomes short state which causes the case (1).
Now we consider case (2b) which means that there exists no other robot on the point occupied by r i . Let p i be the nearest point from r i which occupied by two robots. If the two robots occupy p i and the two robots are a pairbot, either of them must exclusively move to 1 by line 1 without any interrupt. This makes a new point p j which is the nearer point from r i than p i . Otherwise, i.e., the two robots occupying p i are not a pairbot, either of them has its buddy on 1 , thus it must move to 1 by line 3 of the algorithm. Even if there is no point occupied by two robots, there exists a robot which has no robot on 4 , i.e., the tail robot, it must move to 1 by line 2 of the algorithm, and becomes short state. As a result, the nearest point occupied by two robots (p i ) repeatedly moves toward r h and makes the pairbot including r h short state.
Note that the shift of point p i is never interrupted by any other robot's operation, moreover, every robot on 1 side (agreed direction side) of the nearest point p i never moves because no guard in Algorithm 1 becomes true, unless the robot on p i moves to 1 . Hence, the position of point p i is shifted toward r h step by step even under ASYNC scheduler.

Object Coating Problem and Algorithm
In this section, we introduce an algorithm to surround the given object (called coating) when line-formed pairbots find an object while marching.

Problem Definition
The induced subgraph G O is also called an object. We assume that G O is connected, and Fig.6 illustrates the examples of two different objects. Now we define several subsets of the points on T. We simply denote N (O, R) as N if O and R are obvious. In Fig.7(a), all the circles (including the filled circles) describes the surface set S. And the filled circles illustrate the non-coating set N (⊂ S): some points are not reachable from any robot, and some points has no two or more disjoint paths from the robot due to an articulation point. We simply denote C(O, R) as C if O and R are obvious. Fig.7(b) illustrate a configuration that all the points in C are occupied by the robots. Now we define the object coating problem using coating set when O and R are given.
Definition 5 Object Coating Problem. Given a set of n robots (n/2 pairbots) R which are line-formed and they agree the direction to move. And given object O, where |C(O, R)| ≤ n/2, which are connected and located on the side of the direction to move agreed by the robots. Algorithm A solves the object coating problem if R satisfies all the following conditions when A terminates: • All the points in coating set C(O, R) are occupied by the robots in R.
• All the pairbots are in short state.
• Algorithm A eventually terminates: algorithm A eventually reaches a configuration such that no robot can move. Fig.8 illustrates an example of the object coating problem. Fig.8(a) presents an initial configuration. The robots in R are line-formed, and they agree label 1 ( 1 ) as the direction to move. Intuitively, the given line-formed set of robots executes marching algorithm introduced in the previous subsection during it does not recognize any object. If the head robot recognize any object, it changes the direction to move based on the agreed chirality, and the other robots follows the head robot, as a result, they surround the given object and terminate. In Fig.8(b), the object coating problem is solved because all the points in C are occupied by the pairbots which are in short state. Note that some robots are remained, i.e., not on the points in C, when n/2 > |C(O, R)|.

Object Coating Algorithm
In this subsection, we introduce an algorithm to solve the object coating problem. And we assume that the each robot can recognize whether itself is the head robot or not to terminate the proposed algorithm. To help to understand, we assume that the agreed direction to move is 1 (positive direction of X axis). Algorithm 2 represents an object coating algorithm when object O is given. In Algorithm 2, each robot locally executes function dir () to determine the next direction to move, and move to the determined direction if some conditions are satisfied. Fig.9 illustrates some examples that robot r i locally determines the direction to move (function dir ()) when it recognizes an object, i.e., r i .O = ∅ (rules 2 and 3 of function dir ()). Note that robot r i does not recognize any object, it moves to the agreed direction (marching) by the first rule of function dir (). In Fig.9(a), r i determines 2 to its direction to move because an object exists on 1 and no object exists on 2 , 3 , and 4 by the second rule of function dir (). For the same reason, in Fig.9(b), r i determines 5 to its direction because no object exists on 5 , 6 , and 1 . Also in the case of Fig.9(c), r i determines 1 to its direction because no object exists on 1 , 2 , and 3 , this prevents r i from move to non-coating points. The third rule of function dir () can be satisfied only when two different objects located opposite to each other, e.g., 2 and 5 . Fig.9(d) represents the case such that the third rule is satisfied. In this case, r i determines 2 to its direction to move because r j exists on 3 , note that a robot may also exist on r i . 2 .
Algorithm 2 is similar to marching algorithm (Algorithm 1): the pairbot in short state exclusively moves to the direction to move if one or less robot exists on the destination point, the pairbot in long state becomes short state by tail-sided robot (say r i ) move if another robot exists on the point occupied by r i . However, different from marching algorithm, every robot repeatedly changes its direction to move based on the result of function dir (). Lines 1 and 2 are the executions for a pairbot in short state to make it long state, however the head robot never executes line 2 in order to avoid collision, i.e., two different pairbot which are in short state (exclusively) move to the same point, when the head robot return back after move around the object. Lines 3 and 4 are the executions for a pairbot in long state to make it short state. By line 3, the pairbot becomes short state when another robot exists on the point occupied tail-sided robot. Exceptionally, the tail robot in long state always becomes short state, if no other robot exists on the point occupied by head-sided robot. We omit the proof of an object coating algorithm because it can be easily proved by the similar manner of the proof of Algorithm 1.

Conclusion and Discussion
In this paper, we introduced a new computational model named Pairbot model consisting of paired robots called pairbots, which is based on LCM-model [1]. In the proposed model, each pairbot repeatedly changes its positional relation of the two robots, long and short, to achieve the goal. Moreover, as the basic problems of Pairbot model, we introduced two problems, the marching (linear movement) problem and the object coating problem, and proposed the two algorithms to solve these problems respectively to help to understand the computational power and limitations of Pairbot model. Pairbot model has basically the similar variations of the assumptions, e.g., scheduler, geometric agreement, visibility, etc., however, it has one big different feature: every robot has one implicitly distinguishable robot as its buddy. In this paper, we introduced two simple problems only, however, we are considering various problems in Pairbot model, e.g., pattern formation (a line or a triangle), filling problem, or uniform deployment, as the future work then we have already solved some problems in Pairbot model. Interestingly, we found some problem which is not solvable in LCM-model but it is solvable in Pairbot model with the same capabilities (except the basic capabilities for Pairbot model), e.g., line formation from an arbitrary connected set of robots with 1-visibility range. We strongly expect that this special (a) (b) (c) (d) Figure 9: Examples of the direction to move feature of Pairbot model provides many new possibilities in the field of autonomous mobile robots or the feasibility of a programmable matter.