Lecture 5 - JSSP Continued Flashcards
How do you determine if a solution is feasible?
A solution y ∈ Y is feasible if it satisfies all the constraints defined by the problem instance.
- A feasible solution is one that satisfies constraints such as non-overlapping job execution, correct job-machine assignments, and sub-job ordering. Only feasible solutions can be implemented in practice.
What are the Constraints for Feasability
- All sub-jobs must be completed on the correct machines.
- Only jobs/machines defined in the problem can be used.
- Each sub-job must take exactly the time specified.
- No overlapping sub-jobs on the same machine.
- Sub-jobs must respect the order defined in the job.
ie: ONLY A GANTT CHART OBEYING ALL THESE CONSTRAINTS IS FEASIBLE
Constrant - All sub-jobs must be completed on the correct machines.
○ All sub-jobs must be assigned and completed
* Every job consists of a sequence of operations (sub-jobs).
* Each sub-job must be scheduled on its required machine, with its exact processing time.
* You cannot skip or shorten any sub-job.
○ Why this matters:
* If any sub-job is missing or not completed properly, the job isn’t truly “finished,” making the schedule infeasible.
Constrant - Only jobs/machines defined in the problem can be used.
○ Only the defined jobs and machines may be used
* You cannot introduce “extra” machines or jobs that weren’t in the original instance.
* All resources must belong to the problem definition.
○ Why this matters:
* Using undeclared resources breaks the constraints and could distort the makespan calculation.
Constrant - Each sub-job must take exactly the time specified.
○ Correct time allocation
* Each sub-job must be scheduled for exactly the time specified in the problem instance.
* You can’t make it faster or slower than given.
○ Why this matters:
○ Duration mismatches create invalid output — it misrepresents machine load and job completion time.
Constrant - No overlapping sub-jobs on the same machine.
- A machine can only work on one job at a time.
- Time windows for jobs on a machine must be non-overlapping.
○ Why this matters: - This reflects physical constraints — a machine can’t multitask.
- Time windows for jobs on a machine must be non-overlapping.
Constrant - Sub-jobs must respect the order defined in the job.
○ Preserve precedence of sub-jobs
* Jobs must be processed in the defined order.
* You can’t do step 3 before step 1 in a job, even if the machine is free.
○ Why this matters:
Operations within a job are dependent — breaking order can cause logical or physical failure (e.g., painting before assembly).
Why does Feasibility ≠ Optimality
○ A feasible solution is valid, but not necessarily efficient.
○ You may have a very bad makespan but still have a feasible solution.
○ Optimization algorithms search for feasible + low makespan solutions.
Why do Deadlocks = Infeasibility?
○ A common reason a solution becomes infeasible is if it causes a deadlock:
§ Two jobs wait on each other to release the same machine.
§ Job A needs M1, but it’s busy with Job B, which in turn is waiting on M2, occupied by Job A.
○ The system gets stuck.
What is the Search Space X?
Definition: Because solution space Y (all feasible Gantt charts) is complicated and often filled with infeasible solutions, we define a simpler, structured search space X to explore.
REFER TO SLIDES FOR FORMULA
Why are we mapping the Search Space X Formula?
- Searching directly in Y is hard due to constraints and deadlocks. X gives us a cleaner space with encodings that implicitly enforce constraints.
- Basically, the search space X consists of simple representations (e.g., job ID sequences) that can be mapped to feasible schedules in Y. This makes optimization easier while preserving solution validity.
EXAMPLE DEMO OF SEARCH SPACE X
REFER TO SLIDES
What is a Canonical Representation?
This is a structured and assumption-driven way to represent job schedules in a minimal format.
What are the key assumptions of Canonical Representation?
- Jobs are scheduled as early as possible (“slide left”).
- No unnecessary waiting between sub-jobs.
- Only the order of execution matters; the rest can be inferred.
Why are Canonical Representation important?
- Why is it important?
○ Canonical forms reduce the number of representations to consider and remove inefficient or redundant ones from the search.
What is the Size of Solution Space Y?
The number of all possible candidate Gantt charts for a given JSSP instance.
- Without constraints: (n!)^m possibilities (very large!).
- With constraints: still huge, but fewer than the theoretical maximum.
We are interested in number of feasible solutions
- Sometimes we don’t have a closed form expression - we just have to generate them and look for patterns
What is a Closed Form Expression?
A theoretical upper bound on solution space size
REFER TO SLIDES FOR EXAMPLE
What is the Size of Solution Space X?
All possible encoded sequences (like vectors) that map to feasible or near-feasible solutions via γ.
- X is typically larger than Y because it includes more representations.
- But: X avoids infeasible Gantt charts, so it’s often more efficient for algorithms.
- Trade-off: We increase size for simplicity. REFER TO SLIDES FOR EXAMPLE INTERPRETATION
How can you have Infeasible Solutions in the Hypothesis Space and Why do we allow them?
Even though some solutions in X might not map to valid schedules, they can serve as stepping stones toward better ones.
* Why allow infeasible solutions?
○ They can guide optimization toward promising areas.
○ Some infeasible schedules may be very close to the optimal one.
How do you known when to stop (Termination Criteria)?
Rules that determine when an algorithm stops searching in the solution or search space.
Common types:
- Time-based (e.g. stop after 3 minutes)
- Iteration-based (e.g. after 1000 generations)
- Convergence-based (e.g. no improvement in last 50 steps)
Why is a Termination Criteria Important?
JSSP is NP-hard — searching forever is not feasible. We must balance solution quality and runtime.
