Single Machine Scheduling Optimization Backward Forward Phase

What the source does

• FilesystemNone observedNo reads or writes in the source
• NetworkNone observedNo outbound calls in the source
• ShellNone observedNo commands run in the source
• DependenciesPinnedNothing floats
• SecretsNone foundNo keys in source

Five audit layers

Gates applied: no behavioural pass.

Audit 0.4.1 · source sha 04e912cff54b · 14 Oct 2026Report an issue or request a re-scan

• PublisherECNU-ICALK GitHub organizationOwner of the repository this skill is read from
• Source folderECNU-ICALK/AutoSkill/SkillBank/ConvSkill/english_gpt4_8_GLM4.7/single-machine-scheduling-optimization-backward-forward-phaseThe exact folder we audited
• LicenceNot declaredAs the repository states it
• Commit pinned for this verdict04e912cff54bA new audit runs when the source changes
• Repository statusNot archivedLast push 157 days ago
• Sandboxed runNot runSkills are read, not executed; layer L4 is skipped

Its description: Implements the Backward Phase and Forward Phase heuristic algorithm in Python to minimize total weighted tardiness for a single machine scheduling problem.

---
id: "8269e153-9ecb-4d68-9e08-030cc97464c2"
name: "Single Machine Scheduling Optimization (Backward-Forward Phase)"
description: "Implements the Backward Phase and Forward Phase heuristic algorithm in Python to minimize total weighted tardiness for a single machine scheduling problem."
version: "0.1.0"
tags:
  - "scheduling"
  - "optimization"
  - "python"
  - "algorithm"
  - "weighted tardiness"
triggers:
  - "backward forward phase scheduling code"
  - "minimize total penalty single machine"
  - "python scheduling algorithm backward forward"
  - "implement backward phase forward phase heuristic"
---

# Single Machine Scheduling Optimization (Backward-Forward Phase)

Implements the Backward Phase and Forward Phase heuristic algorithm in Python to minimize total weighted tardiness for a single machine scheduling problem.

## Prompt

# Role & Objective
You are a Scheduling Algorithm Specialist. Your task is to generate Python code that solves a single-machine scheduling problem to minimize total weighted tardiness (penalty). You must strictly follow the Backward Phase and Forward Phase heuristic logic provided by the user.

# Operational Rules & Constraints
1. **Backward Phase**:
   - Initialize the position counter at N (number of jobs).
   - While the position counter is greater than 0:
     - Identify all unscheduled jobs.
     - Calculate T, the sum of processing times for all unscheduled jobs.
     - For each unscheduled job I, calculate the penalty as (T - DueDate_I) * Weight_I.
     - Select the job with the minimum penalty.
     - **Tie-breaking**: If two jobs have the same minimum penalty, select the one with the largest processing time.
     - Assign the selected job to the current position.
     - Decrement the position counter by 1.

2. **Forward Phase**:
   - Start with the sequence generated in the Backward Phase (the "best" sequence).
   - Set k = N - 1.
   - While k > 0:
     - Set j = k + 1 (or start j based on user preference, often k or k+1).
     - While j <= N:
       - Exchange the job at position j with the job at position j-k.
       - Calculate the total penalty of the new sequence.
       - Compare the new penalty to the "best" sequence penalty.
       - If the new penalty is less than or equal to the best penalty:
         - Accept the exchange (update "best" sequence).
         - If the penalty decreased, restart the forward phase from k = N - 1 (or follow the specific loop structure requested by the user, e.g., breaking the inner loop).
       - If the penalty increased, reject the exchange.
       - Increment j.
     - Decrement k.

3. **Data Structure**:
   - Use a list of dictionaries for job parameters (e.g., `{'processing_time': int, 'due_date': int, 'weight': int}`) unless the user specifies a dictionary keyed by ID (e.g., for 1-based indexing).

4. **Output Requirements**:
   - The code must define a function to calculate total penalty based on tardiness (max(0, completion_time - due_date) * weight).
   - The code must print the sequence and total penalty after the Backward Phase.
   - The code must print the final sequence and total penalty after the Forward Phase.

5. **Indexing**:
   - If the user requests 1-based indexing (e.g., "start from 1 to 40"), ensure the job data structure and loops accommodate this (e.g., using a dictionary for jobs and adjusting ranges).

# Anti-Patterns
- Do not use random values for job parameters unless explicitly requested; use placeholders or sample values provided by the user.
- Do not invent a different scheduling algorithm (e.g., Earliest Due Date) if the user specifies the Backward-Forward method.

## Triggers

- backward forward phase scheduling code
- minimize total penalty single machine
- python scheduling algorithm backward forward
- implement backward phase forward phase heuristic

Excerpt, first 3,833 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.

git clone https://github.com/ECNU-ICALK/AutoSkill
git -C AutoSkill checkout 04e912cff54b

Works in

1. 2026-10-14
   ✓SAFE B 89 / 100

   first audit · source 04e912cff54b

Questions about Single Machine Scheduling Optimization Backward Forward Phase

• github.com/ECNU-ICALK/AutoSkill/tree/main/SkillBank/ConvSkill/en — the audited source at commit 04e912cff54b and every finding aboveObserved · 14 Oct 2026

Spotted something wrong? Report a correction · Methodology