Modelling Assembly Line Balancing Problem in Answer Set Programming

Transcription

1 201 International Conference on Computational Science and Computational Intelligence Modelling Assembly Line Balancing Problem in Answer Set Programming Omar EL-Khatib Computer Science Department, Taif University Taif, Saudi Arabia Abstract Answer set programming (ASP) is a new programming language paradigm combining the declarative aspect with non-monotonic reasoning. In this paper, we will investigate and evaluate an application of Simple Assembly Line Balancing Problem in Answer Set Programming. The problem is a highly combinatorial and is generally solved by specific programs. We present an approach to solve the simple assembly line balancing problem in Answer Set Programming and compare them with the standard ones. It turns out that, although Answer Set Programming greatly simplifies the problem statement. It is comparable in efficiency to specialized programs. Keywords- Simple assembly line balancing problem, Answer set programming, Logic programming, SALBP. I. INTRODUCTION Many real-life problems belong to the class of NPcomplete problems [1]. Logic Programming under answer set semantics provides a powerful language for a logical formulation of these problems. Its nondeterministic computation liberates the user from the tree-search programming. Answer set programming (ASP) is a form of declarative programming that is emerged from logic programming with negation and reasoning formalism that is based on the answer set semantics [2], [3]. ASP is considered in the early 10s as a new programming paradigm [4]. Answer set programming language has been used to solve many real life application problems, among them, production configuration [5], decision support for NASA shuttle controllers [], synthesis of multiprocessor systems [], reasoning tools in biology [8],[9], job scheduling [10], pixel puzzle problem [11], and many more. A number of solvers have been proposed, such as: smodels [12], dlv [13], cmodels [13] and clasp [14]. In this paper, we show an application of Answer Set Programming to real life assembly line balancing problem (ALBP) occurring in a manufacture or factory, such as automotive, white goods and electronic industries. The paper focuses on the simple assembly line balancing problem type 1 (SALBP-1). The SALBP-1 consists of a finite set of n-tasks to be assigned to m-workstations to assemble a single product. Tasks have processing time (t i : where 0 < i n) and precedence relationships that are known deterministically. The precedence relationships specify the permissible ordering of the tasks. The fundamental assembly line balancing problem is to assign the tasks to an ordered sequence of stations, such that every task is assigned to one workstation (non-divisibility of a task). In addition, the precedence relations must be satisfied. The objective is to minimize the number of workstations (m) for a given cycle time [14]. For SALBP-1, a solution is feasible if (i) the tasks of each station do not have a task time sum larger than the cycle time 'c' and (ii) no direct or indirect predecessor of any task j is assigned to a later station than j is assigned to [15]. SALBP-1 has the following characteristics [1], [1]: 1) Mass-production of one homogeneous product in a production process. 2) Paced line with fixed cycle time c. 3) The processing time of each task is deterministic. The assumption of deterministic task times in most versions of SALBP is justified by the conditions in many real-world settings [1]. 4) The task cannot be subdivided. Therefore, every task is assigned to one station. 5) The precedence relationship between tasks is known and invariable. ) Serial line layout with m-stations. ) All stations are equally equipped with machines and workers. 8) Maximize the line efficiency Eff = 1/(m.c) n j=1 t j (see example 1 below), where m is the number of stations, c is the cycle time, t j is the processing time for each task and n is the number of tasks. Example 1: assume we have -tasks (A, B, C, D, E, and F) and three workstations w 1, w 2, and w 3. In addition, a cycle time of 20 is assumed. Table I, shows the prespecified order of tasks with their operation time and immediate task predecessor. For example, task B requires 4 time unit to complete and it must be processed after task A is complete. Another example is task F which requires time unit and it must be processed after tasks D and E completes. A minus sign '-' in a row in table I means that this task has no immediate predecessor as shown for task A. Figure (1), shows the precedence relationship between tasks in a graph form. For a single workstation (i.e. one employer), a product is assembled in 44 time unit (which is the sum of all task time units: = 44) /1 $ IEEE DOI /CSCI

2 TABLE I. ASSEMBLY LINE BALANCING PROBLEM EXAMPLE Tasks Task time Immediate predecessor A 5 - B 4 A C 13 A D 9 B E C F D, E A B D Figure 1. Precedence relationship between tasks in graph form. A possible schedule is shown in Table II for three workstations (m=3) and cycle time c= 20. TABLE II. 13 C A POSSIBLE SCHEDULE FOR EXAMPLE (1) WITH 3-STATIONS AND CYCLE TIME OF 20. Workstation Tasks Total workstation time Idle time name w 1 A, C 18 2 w 2 B, D, E 20 0 w 3 F 14 Table II has 4 columns: the workstation name, the tasks assigned to the workstation, the total workstation time to complete the tasks assigned (which is the sum of the times of tasks assigned to that workstation) and the idle time of the workstation which is the difference between cycle time and total workstation time. Therefore, from Table II, workstation w 1 has been assigned tasks A and C with a total time of 5+13=18 time unit and idle time of 20-18=2 time unit. Workstation w 2 has been assigned tasks B, D and E with a total time of 4+9+=20 time unit and an idle time of 20-20=0 time unit. Finally, workstation w 3 has been assigned task F with a total time of time unit and an idle time of 20-=14. Line efficiency is computed from: Eff =1/(m.c) n j=1 t j = 1/(3*20)[ ] = 3.3%. In this paper, we first give a brief overview of Answer Set Programming and its semantics. We then, present the simple assembly line balancing problem formally. After that, we present the solution to the simple assembly line balancing problem type-1 (SALBP-1) under Answer Set Programming. Finally, we present experimental results and conclusion. II. BRIEF OVERVIEW OF ANSWET SET PROGRAMMING We briefly recall the basics about ASP. An ASPprogram is a collection of rules of the form: a 0 a 1,, a m, not a m+1,, not a n (1) Where, each a i is an atom. The head of the rule is a positive atom which is the left hand side of the clause in (1). The/ body of the rule is composed of literals (a literal is an E F atom or its negation, denoted by not a) which is on the right side of the clause in (1). A rule without body is a fact. A rule without head is a constraint. Also, the rules can be positive (m>0, n=0); negative (m=0, n>0) or both (m>0 and n>0). The symbol not stands for default negation, also known as negation as failure. Given rule r as in (1), denote the body of the rule r body(r) = {a 1, a m, not a m+1,... not a n }, body + (r) = {a 1,, a m }, and body - (r) = {a m+1,, a n }. If P is a ground, positive program (no negation as failure used), a unique answer set is defined as the smallest set of literals constructed from the atoms occurring in program P (minimal model). The last definition can be extended to any ground program P containing negation by considering the reduct of P with respect to a set of atoms X obtained by the Gelfond-Lifshitz s operator [2]. The reduct, P X, of P relative to X is the set of rules: a 0 a 1,, a m For all rules (1) in P such that a m+1,, a n X. Then P X is a program without the negation not. Then X is an answer set for P if X is an answer set for P X. Once a program is described as an ASP-program P, its solutions, if any, are represented by the answer set of P. One important difference between ASP semantics and other semantics is that a logic program may have several answer sets or may have no answer set at all. Answer Set Programming is a totally declarative language. ASP programs are not algorithms describing how to solve the problem; the program is just a formal description of the problem. The solution is completely found by the solver. An ASP solver requires grounded programs as input, and that is why before searching the answer set or solutions, the program is grounded by a preprocessor. Actually there are many ASP solvers such as: smodels, dlv, assat, cmodels, and clasp. The computation of answer sets is done in two phases: (i) grounding of the logic program (P): that is eliminating variables to obtain a propositional program ground(p). (ii) Computation of answer sets on the propositional program ground(p). Clingo [18] is a program that combines grounding and solving answer set programs. It provides several features and syntax such as choice rules, cardinality rules, disjunctive rules, aggregates and optimization statements. We used choice rules, aggregates and optimization sentences. Choice rules are rules of the form: L { a 1, a 2,..., a n } U :- body. (2) Where L is a lower bound integer and U is an upper bound integer (L<=U). This rule means: Given an answer set X, if body+ X and body- X =, then an arbitrary number of atoms between lower bound L and upper bound U (inclusive) from the atoms {a 1,, a n } is in the answer set X. Aggregates functions like sum, count, max, and min, is provided by clingo. An aggregate is a set or a multiset of atoms and has a lower and an upper bound. These arithmetic operators increase the expressiveness of answer set. For example: p(1). p(2)

3 total(p) :- P = #sum { X: p(x) }. Running clingo on the above program produces the answer set: {p(1), p(2), total(3)}. The aggregate #sum will sum the values in atom p/1 and store it in the variable P. Similar usage for the count, max and min functions. Optimization statements provide optimum answer set (minimum or maximum). Two keyword is used: #minimize and #maximize. Adding these statements to an answer set program will produce optimum answer sets. For example: p(1). p(2). 1 { q(x) : p(x) } 1. #minimize {X: q(x) }. The above code uses a choice rule that select one atom only at a time. Withoud the optimization statement #minimize, the answer set solver produces two answer sets {p(1), p(2), q(1)} and {p(1), p(2), q(2)}. Adding the optimization statement #minimize makes the answer set solver produce one answer set of {p(1), p(2), q(1)} only, since it has the minimum value in X for the atom q(x). III. SIMPLE ASSEMBLY LINE BALANCING PROBLEM Simple assembly line balancing problem type 1(SALBP- 1) is an optimization problem in which tasks are assigned, at a specified cycle time, to workstations that satisfy the task precedence relationship and optimize the efficiency (i.e. minimize the number of workstations). There are several problem formulations for the SALBP-1, we have adopted the one presented in [19] as follows: Given a set of n-tasks K = {1,, n}, m-workstations W={1,, m} and a cycle time C. Each task k i (i K) has a constant predefined processing time {t 1,, t n }. Denote x kw as a binary variable which is set to 1 if task k is assigned to workstation w for processing and 0 otherwise. Denote G=(V, E, t) as a non-cyclic diagraph that represents the precedence relationship, where V is the set of tasks' nodes K; E={(k, e) k, e K} is the set of arcs representing a direct precedence relationship and t represents the task time t i that label the nodes. The arc (k, e) denotes the task pairs (k, e), where task k must be processed before task e (k, e K). Let S w be the set of assignments x kw for all tasks k K that are assigned to workstation w for processing. Then, the assembly line balancing problem is represented as follows: Minimize w Subject to: m w=1 x kw = 1 kk (3) n k=1 t k x kw C ww (4) x ew w q=1 x kq k,ek; q,ww and (k, e)e (5) \ x kw {0, 1} k K; ww () C > 0 () Constraint (3) is the assignment constraint and it ensures that each task is assigned to a single workstation. Constraints (4) is cycle time constraint that ensures that the sum of the processing times of the tasks assigned to a workstation w (1 w m) do not exceed the cycle time C. Constraints (5) is the precedence constraint that reflects the precedence relationships between the tasks. More specifically, if task ek is assigned to a workstation ww, then all tasks k K that are immediate predecessors of task ek, must be assigned to workstations qw with q w. Constraint () is the non-divisibility constraint and satisfies that any task can be assigned to a workstation as a whole. Constraint () is trivial that cycle time must be positive. Let P j (P j * ) be the immediate (all) predecessors of task j; i.e. P j * contains all the tasks that must be completed before task j can be started, and P j contains all the tasks i P j * such that i is not the predecessor of any other task in P j *. Similarly, let F j (F j * ) be the set of immediate (all) successors of task j. For a given cycle time c, task set K, task processing time t i, one can find a minimum lower bound on the number of workstations using: LB1 = (8) For a given cycle time c and a given number of stations m one often can derive bounds on the stations a task can be assigned to. For a task k, let E k (c, m) be the earliest admissible station and L k (c, m) be the latest admissible station. For the SALBP-1 these bounds can be set to: E k (c, m) = (9) L k (c, m) = m (10) A task k can only be assigned to one of the feasible stations FS k = {E k, E k +1,, L k }. The feasible station set can be used to reduce the number of variables such that x kw has only to be defined for k K and w FS k. A new constraint can be added for any assignment of task k to workstation w (represented as x kw ) that should satisfies E k (c, m) w L k (c, m) [22]. x kw {0, 1} k K, E k (c, m) w L k (c, m). IV. PROBLEM ENCODING In this section, we describe the simple assembly line balancing problem of type-1 in the language of clingo which is the grounder and solver for the answer set program. The modeling of SALBP-1 in ASP is divided into three modules: data module D 1, preparation module D 2 and finally the solver module D 3. Five conditions need to be satisfied: N1: Precedence relationship of tasks must be satisfied. N2: the sum of processing time of all tasks assigned to a workstation is less than the cycle time. N3: number of workstation lower bound is determined from the sum of processing time of all task divided by the cycle time. N4: Each task is assigned to any station from the feasible stations set. N5: Each task is assigned to one station only. We will use example (1) presented in section (I) to simplify the illustration of the ASP

4 A. Constructing Data Module D 1 : This module defines an instance of the SALBP-1. This module consists of a list of tasks with their processing time. The tasks list is defined as a fact of the following form: task(taskname, ProcessTime). The task precedence relationship list (or task dependency list) is defined as a fact of the following form: dep(task1, task2). This facts dep/2 means that task2 depends on task1, i.e. task2 cannot be processed until task1 completes. B. Constructing Preparation Module D 2 This module defines new predicate that will simplify and speeding up finding the answer set models of the SALBP-1. It consists of the following rules: The first group consists of the task dependency transitive relation. It is suffice to write the following rules: depend(k1, K2) :- dep(k1, K2). depend(k1, K3) :- dep(k1, K2),depend(K2, K3). These rules are used to define the task k predecessor (P k * ) list and the task k successor list (or followers) (F k * ). The task k predecessor is represented by depend(k1, k) and the task k successor is represented by depend(k, K3). The second rule is finding the sum of all tasks processing time. It is suffice to write the following rule: tasksum(s) :- S = #sum {P, K: task(k, P) }. The third group consists of the sum of the processing time of all predecessors' tasks rules and successors' tasks rules. It is suffice to write the following rules: pred(k, S) :- task(k, P), S= #sum {P1, K1: depend(k1, K), task(k1, P1)}. succ(k, S) :- task(k, P), S= #sum {P1, K1: depend(k, K1), task(k1, P1)}. The 'pred(k,s)' rule will determine the sum of processing time 's' of all task preceding task k; and the 'succ(k, s)' rule will determine the sum of processing time 's' of all task succeeding task k. The third is a simple fact that defines the cycle time: cycle(c). Note that 'c' is a constant that is determined by the user at run time using the c option in clingo. The fourth rule calculates the lower bounds of the workstations. The rules are as follows: station(w..w+range) :- tasksum(s), cycletime(c), round(a), W=S/C + A. round(0) :- tasksum(s), cycletime(c), S\C=0. round(1) :- tasksum(s), cycletime(c), S\C!=0. 1 { selworkstation(w) : station(w) } 1. workstation(1..w) :- selworkstation(w). The first rule defines the lower bound and upper bound of the workstations as defined in equation (8) in section III, in which the constant 'range' is determined by the user at run time using the c option in clingo. The third and fourth rules are for rounding. The fourth rule is a choice rule that is bounded by a lower limit of one and an upper limit of one. This means that this rule will select one workstation from the workstations that are determined by the user through the constant 'range'. For example (1) in section I, the task sum is 44 and if we assume the cycle time is set by the user is 20; then the minimum workstation lower bound from the first rule is: 44/20 = 2.2 rounded to 3 workstations. If the user set the 'range' to 2, then the range of workstation is {3, 4, 5}. The choice rule in the fourth rule selects one workstation from the set {3, 4, 5}. Let us say that the choice selects workstation 4, then the available workstations to arrange the tasks are {1, 2, 3, 4}; this is defined in the fifth rule. The fifth group is defining the feasible stations that can be assigned for each task as defined in section III. It is suffice to write the following rules: feasible(k, WS, E, L) :- task(k, P), selworkstation(ws), tasksum(s), calcpred(k, E), calcfollower(k, F), L = WS+1 F. calcpred(k, E) :- pred(k, P), cycletime(c), P\C=0, E=P/C. calcpred(k, E) :- pred(k, P), cycletime(c), P\C!=0, E=P/C+1. calcfolower(k, F) :- follower(k, S), cycletime(c), S\C=0, F=S/C. calcfollower(k, F) :- follower(k, S), cycletime(c), S\C!=0, F=F/C+1. The rule 'calcpred/2' calculates the earliest admissible station for each task as in equation (9). The rule 'calcfollower/2' calculates the latest admissible station for each task as in equation (10). These set of rules are implementation of condition N3 listed in section III. C. Constructing Solver Module D 3 In this module, we define the solver of SALBP-1, as follows: The first group of rules is assigning tasks to workstations such that the sum of task per workstation does not exceed the cycle time C. It is suffice to write the following rules: 0 < #sum{p,k:select(k, P, W):task(K, P), feasible(k, WS, E, L), W>=E, W<=L }<=C :- cycletime(c),selworkstation(ws),

5 workstation(w). :- select(k1, P1, W1), select(k1, P1, W2), W1!=W2, workstation(w1), workstation(w2), task(k1, P1), selworkstation(ws), W1<=WS,W2<=WS. :- select(k1, P1, W1), select(k2, P2, W2), depend(k1, K2), K1!= K2,W2<W1, workstation(w1), workstation(w2), task(k1, P1), task(k2, P2), selworkstation(ws), W1<=WS, W2<=WS. The first rule assigns task to each workstation, such that the sum of processing time of tasks assigned to each workstation does not exceed the cycle time C. This rule implements conditions N2, and N4 that are listed above at the beginning of section IV. The second rule is a constraint rule that prevents assigning a task to two workstations; this implements condition N5 that is listed in the beginning of section IV. The third rule is a constraint rule that prevents assigning task K2, that depend on task K1, to workstation that is lower than the workstation assigned to task K1; implementing condition N1 listed above in the beginning of section IV. The third group is to confirm that all tasks are assigned to workstations. It suffice to write the following rules: taskselected(k) :- select(k, P, W), task(k, P), workstation(w). :- task(k, P), not taskselected(k). The last group of rules is the optimization objective. For SALBP-1, the objective function is to minimize the number of workstation. It is suffice to write the following rule: #minimize {W: selworkstation(w) }. V. EXPERIEMENTAL RESULTS Our experiments were designed to assess the performance of each of the ASP on SALBP-1. We used the SALBP-1 instances from Scholl website ( data sets.zip). The data set includes twenty five SALBP instances that are based from real world problems that have been collected from the literature [20]. Each of these problems consists of a number of tasks to be assigned to a number of workstations subject to precedence relationship among tasks and cycle time constraints. Tasks must not violate the precedence relation. Further, each task requires one of workstation resource and each workstation resource can be used by at most one task at a time. The ASP was run on An Intel core 2 due laptop with 1.2 GHz processor and 4GB RAM. To run the answer set program, we write: clingo c range=range c=c d1.lp d2.lp d3.lp Where clingo is the answer set solver. Modules d1, d2, and d3 are the modules defined in section IV. The RANGE and C are constants, determined by the user that set the range of workstation above the minimum bound to search for the solution and the specific cycle time, respectively. For example, if the range is set to 10 and cycle time of 20, then we write: clingo c range=10 c=20 d1.lp d2.lp d3.lp The 'RANGE' constant is determined by trial and error. The 'RANGE' constant has a big influence on the answer set program performance. Sometimes choosing a large value for 'RANGE' makes the answer set program never terminates for hours. Therefore, we start 'RANGE' with value 0, then increase it by 1 every step if no solution found in the previous step. Table III shows running the answer set program on several instances of the SALBP-1 and comparing the results with SALOM solver [21] (one of the standard programs for solving SALBP). Table III shows six problem instances (due to space limitation), the combination of cycle time and workstation found, the efficiency and the CPU time in seconds, and finally comparing with SALOM program. With each problem instance there are two number in parenthesis. The first number is the number of tasks and the second number is the maximum task processing time. Some values under the CPU time column has a minus sign (- ) to indicate that the answer set program or SALOM produces no answer and did not terminate for more than 10 minutes. Problem Instance ARC (111) (589) GUNTHER (35) (40) HAHN (53) (15) LUTZ1 (32) (1400) Cycle time TABLE III. Minimum Workstation EXPERIMENTAL RESULTS Efficiency % CPU Time (sec) SALOM CPU Time (sec)

6 LUTZ2 (89) (10) For some problems such as GUNTHER, HAHN, LUTZ1, and LUTZ2, ASP results were competitive with those obtained by SALOM. Two instances of ARC111, when the cycle time is 589 and 104, were solved by ASP and not solved by SALOM. The problems with large value of tasks can have big influence on the program s performance when employing Answer Set programming as solution method, since the number of answer set candidates that need to be checked is heavily dependent on the number of tasks and task precedence relationship. For larger problems such as 1000 tasks the cpu time is large (more than many days). This is due to the grounding process that generates too many ground rules. Other problems such as LUTZ2, SALOM was faster than ASP specifically when the cycle time is 13 and 15. VI. CONCKUSION AND FUTURE WORK In this paper, we have presented an approach that uses ASP to represent a real life application of SALBP-1 to produce optimal plans. SALBP-1 is used in automotive, white goods and electronic industries and it is known to be a hard problem (NP-complete). The SALBP-1 has a finite, but extremely large number of feasible solutions. There are n! different possible sequences of n-tasks, without considering the precedence relationship. However, the precedence relationship and the cycle time constraints drastically reduce that number. For r-precedence relations among n-tasks, there are roughly n!/(2r) distinct sequences, even this is a too large number to handle. The cycle time restriction will reduce that number more but still it is too large for large number of tasks. We have proposed to investigate and evaluate the capabilities of ASP to SALBP-1. ASP is expressive enough to represents the constraint of the SALBP problem. It is very easy to write the other types of SALBP; SALBP-2, SALBP- E and SALBP-F. The paper also shows the expressive use of the aggregates and optimization sentences defined in the 'clingo' solver. SALBP can be a killer application of ASP when the number of tasks increases. As a future work, [22] proposed a stronger formulation of precedence constraints and the stations limit for the SALBP-1 that requires evaluation and include in the ASP program. In addition, solving other SALBP and general ALBP is an interesting future work. REFERENCES [1] M.R. Gary, and D. S. Johnson, "Computers and Intractability: a Guide to the Theory of NP Completeness," Freeman 19. [2] M. Gelfond, and V. Lifschitz, "The Stable Model Semantics for Logic Programming," ICLP/SLP, pp , 19. [3] C. Baral, "Knowledge Representation, Reasoning and Declarative Problem Solving", Cambridge University Press, [4] V. Marek, and M. Truszczyński, "Stable models and an alternative logic programming paradigm", In Apt, Krzysztof R. The Logic programming paradigm: a 25-year perspective, Springer, pp , 11. [5] T. Soininen, and I. Niemela, "Developing a declarative rule language for applications in product configuration", In G. Gupta, ed.: Proceedings of the First International Workshop on Practical Aspects of Declarative Languages (PADL ), Springer, pp , 19. [] M. Nogueira, M. Balduccini, M. Gelfond, R. Watson, and M. Barry, "An A-prolog decision support system for the space shuttle", Proceedings of the Third International Symposium on Practical Aspects of Declarative Languages (PADL'01), Springer-Verlag, pp , [] H. Shebabi, P. Mahr, C. Bobda, M. Gebser, and T. Schaub, "Answer set vs integer linear programming for automatic synthesis of multiprocessor systems from real-time parallel programs", Journal of Reconfigurable Computing, [8] O. El-Khatib, "Job Shop Scheduling under Answer Set Programming," International Journal of Engineering and innovative Technology (IJEIT), volume 5, issue 5, pp. 3-41, Nov [9] O. EL-Khatib, "Solving the Pixel Puzzle under Answer Set Programming," International Journal of Computer Systems (IJCS), Volume 3, number 3, pp , March 201. [10] P. Simons, P., I. Niemels, and T. Soininen, "Extending and implementing the stable model semantics," Artificial Intelligence 138 (1-2), pp , [11] N. Leone, G. Pfeifer, W. Faber, T. Eite, G. Gottlob, S. Perri, and F. Scarcello, "The DLV system for knowledge representation and reasoning," ACM Transactions on Computational Logic, (3), pp. 4 52, July 200. [12] Yu. Lierler, and M. Maratea, "Cmodels-2: SAT-based answer set solver enhanced to non-tight programs," In Proc. of LPNMR-, [13] M. Gebser, M., B. Kaufmann, A. Neumann, and T. Schaub, "clasp: A Conflict-Driven Answer Set Solver", LPNMR'0, 200. [14] S. Ghosh, and R. J. Gagnon, "A comprehensive literature review and analysis of the design," balancing and scheduling of assembly systems, Internat.J. Production Res. 2, pp. 3 0, 19. [15] Tom Pape: "Heuristics and lower bounds for the simple assembly line balancing problem type 1: Overview, computational tests and improvements," European Jounral of Operation Research, 240, pp , [1] I. Baybars, "A survey of exact algorithms for the simple assembly line balancing problem," Management Sci. 32, pp , 1. [1] N. Boysen, M. Fliedner, and A. Scholl, "A classification of assembly line balancing problems," European Journal of Operational Research, Volume 183, Issue 2, pp. 4 93, December 200. [18] M. Gebser, Kaminski, R., Kaufmann, B., Schaub, T.: "Clingo= ASP+Control: Preliminary Report," ArXiv e-prints, 2014, " [19] E. H. Bowman: "Assembly line balancing by linear programming," Operat Resear, 8, pp , 190. [20] A. Scholl: "Data of Assembly Line Balancing Problems". Schriften zur Quantitativen Betriebswirtschaftslehre 1, TU Darmstadt, 13. [21] A. Scholl, and R. Klein,"SALOME: a bidirectional branch-and-bound procedure for assembly line balanicing," INFORMS Journal on Computing, 9(4), pp , 1. [22] Marcus Ritta, Alysson M. Costa: "Improved integer programming models for simple assembly line balancing and related problems," International Transactions in Operational Research, doi: /itor.1220,