A note on proving the strong NP-hardness of a scheduling problem with position dependent job processing times

In this paper, we show that the strong NP-hardness proof of the single machine makespan minimization problem with ready times and job processing times described by a non-increasing power function dependent on a job position in a sequence presented in Bachman and Janiak (J Oper Res Soc 55:257–264, 2004) is incorrect. Namely, the applied transformation from 3- Partition problem to the considered scheduling problem is polynomial not pseudopolynomial. Thus, the related problem is NP-hard, but it is not proved to be strongly NP-hard.


Introduction
Bachman and Janiak [1] claimed that the single machine makespan minimization problem with ready times is strongly NP-hard if job processing times are described by a non-increasing power function dependent on a job position in a sequence. To prove it, the authors constructed a reduction from 3-Partition to the decision version of this problem. However, we show that the reduction is only polynomial not pseudopolynomial. Therefore, the authors did not prove the strong NP-hardness, but NP-hardness only. Thus, the complete computational status of this problem is still an open issue. Furthermore, the results presented in this paper can be a useful hint: how to avoid serious mistakes during proving the strong NP-hardness.
Throughout the paper, we will keep the notation and terminology used by Bachman and Janiak [1]. R

Problem formulation
There are given a single machine and a set J = {1, . . . , n} of n independent and nonpreemptive jobs available for processing at their ready times r i , i = 1, . . . , n. The processing time p i (v) of job i is a function dependent on its position v in a sequence. The considered model of the job processing time is characterized by position-dependent function: where a i and b denote a normal processing time and a learning ratio, respectively. It is assumed that a i are positive integers and b is a non-negative rational.
The completion time C π(i) of a job placed in the ith position in the schedule π is given by the following recursive expression: where C π(0) = 0 and i = 1, . . . , n. The problem is to find a schedule π for which the criterion value C max (the makespan) is minimized, i.e., C max C π(n) . The problem according to the three field notation scheme is denoted by 1|

Computational complexity
In this section, we will show that the strong NP-hardness proof in [1] is incorrect. The decision version of the considered scheduling problem is given as follows: Does there exist such a schedule π of jobs on the machine for which the criterion value C max is equal or lower than the given value y?
Based on an instance of 3-Partition, the authors constructed an instance of n = m(m 4 B + 3) jobs with a common learning ratio b = 1. Among them there are 3m partition jobs with the following parameters: There are m 5 B enforcer jobs, which are characterized by a common normal processing time a E ( j−1)m 4 B+i = a E = 1, where j = 1, . . . , m and i = 1, . . . , m 4 B. However, the enforcer jobs have different ready times, which partition them into m groups with the following parameters: where j = 1, . . . , m, and i = 1, . . . , m 4 B. Finally the parameter y, that was missing in [1], is defined as follows y = m 5 B + B m 4 B+1 m k=1 1 k . At first recall that the computational complexity theory requires "reasonable and concise" encoding scheme for the problem to represent values of its parameters on Deterministic Turing Machine (see [3]). Therefore, the values of parameters of the considered problem have to be expressed as integer numbers. If it is not the case, then the values of parameters have to be transformed (by multiplying) to the integer numbers. Note that only r E j in (3)   1 k . Therefore, to use the computational complexity theory, we have to express each r E j and y as the integer numbers. Without loss of generality the value of y and each parameter a l and r l for l = 1, . . . , m(m 4 B + 3) have to be multiplied by the number A = (m 4 B + 3)(m 4 B + 1) · A such that r E j = A · r E j and y = A · y are integer numbers for j = 1, . . . , m. On this basis, the constructed instance of the decision version of the considered scheduling problem has the following integer parameters: Since the values of the parameters have to be integers, therefore, A is such number that all terms A ·  = 1, . . . , m) are the least integers if A is the least common multiple (lcm) of the following numbers 1, 2, . . . , m, i.e., A = lcm(1, 2, . . . , m). Following [2,4], we know that log lcm (1, 2, . . . , m) m, thus, A can be bounded below by 2 m as m tends to infinity.
Recall now a condition from a definition of a pseudopolynomial reduction [3,5,6]. Let π 1 and π 2 are two decision problems. Let D π 1 and D π 2 denote their sets of all possible instances, Max(I ) denotes the maximum value of the numbers for an instance I and N (I ) is the size of I . Let f : D π 2 −→ D π 1 denote the reduction from π 2 to π 1 . One of the requirements for f to be pseudopolynomial is such that there must exist a polynomial Q of two variables that holds: It means that the values of any instance I of the problem π 2 cannot increase in an exponential manner if π 2 is reduced to π 1 .
Let π 2 denote 3-Partition and π 1 is the considered scheduling problem. It is obvious that for the given reduction and I ∈ D π 2 , we have Max(I ) = B, N (I ) = 3m, Max( f (I )) > A ≥ 2 m and N ( f (I )) = m(m 4 B + 3). Note that the values of the problem π 1 increase in an exponential manner depending on the values of π 2 , thus, there does not exist such Q for which (4) holds, thereby the reduction cannot be pseudopolynomial. Therefore, the proof of the strong NP-hardness is incorrect.
Nevertheless, the constructed reduction is polynomial one, thus, the problem 1| p i (v) = a i v −b |C max is at least NP-hard, but the strong NP-hardness is not determined.

Conclusion
In this note, we showed that the strong NP-hardness proof of the single machine makespan minimization problem with ready times and job processing times described by a non-increasing power function dependent on a job position in a sequence provided by Bachman and Janiak [1] is incorrect. Thus, the problem is at least NP-hard. However, the complete computational complexity of this problem is still an open issue: strongly or ordinary NP-hard?