Update objective_engine.py

objective_engine.py

@@ -50,72 +50,37 @@ class ObjectiveEngine:
         self.weights = weights or {
             "subject_repetition": 10,
             "morning_core": 5,
-            "late_heavy": 10,
+            "late_heavy": 5,
             "faculty_gaps": 2,
-            "campus_movement": 5,
-            "no_first_hour_free": 20,
-            "student_gaps": 500
+            "campus_movement": 3,
+            "faculty_load_balance": 1,
+            "no_first_hour_free": 20
         }
         
         self.penalties: List[cp_model.IntVar] = []
 
-        # Pre-computed day booleans (shared across soft constraints)
-        # task_day_bools[task_id][day] = BoolVar "is task on this day?"
-        self._task_day_bools: Dict[str, Dict[int, cp_model.IntVar]] = {}
-        self._task_day_vars: Dict[str, cp_model.IntVar] = {}
-        self._daily_slot_vars: Dict[str, cp_model.IntVar] = {}
-
-    def _ensure_day_bools(self, task: 'Task'):
-        """Lazily create and cache per-task day booleans & daily slot vars."""
-        tid = task.task_id
-        if tid in self._task_day_bools:
-            return
-
-        start_var = self.ce.task_vars[tid][0]
-
-        # Day index (0..NUM_WORKING_DAYS-1) for this task
-        day_var = self.model.NewIntVar(
-            0, const.NUM_WORKING_DAYS - 1, f"dayvar_{tid}")
-        self.model.AddDivisionEquality(
-            day_var, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
-        self._task_day_vars[tid] = day_var
-
-        # Daily slot index (0..NUM_TEACHING_SLOTS_PER_DAY-1)
-        daily_slot = self.model.NewIntVar(
-            0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"dslot_{tid}")
-        self.model.AddModuloEquality(
-            daily_slot, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
-        self._daily_slot_vars[tid] = daily_slot
-
-        # Per-day boolean
-        day_bools = {}
-        for day in range(const.NUM_WORKING_DAYS):
-            b = self.model.NewBoolVar(f"{tid}_onday{day}")
-            self.model.Add(day_var == day).OnlyEnforceIf(b)
-            self.model.Add(day_var != day).OnlyEnforceIf(b.Not())
-            day_bools[day] = b
-        self._task_day_bools[tid] = day_bools
-
     def build_objective(self):
         """
         Applies all configured soft constraints and sets the minimization objective.
-        All constraints are designed to scale linearly with task count.
         """
-        print(f"Building Objective Function ({len(self.tasks)} tasks)...")
+        print("Building Objective Function...")
         
         self._minimize_subject_repetition()
         self._prioritize_morning_core_subjects()
         self._avoid_late_heavy_subjects()
-        self._minimize_faculty_gaps()
-        self._minimize_campus_movement()
-        self._pack_morning_session()
-        self._minimize_student_gaps()
+        
+        # Disable highly expensive constraints for massive math (large datasets)
+        if len(self.tasks) <= 100:
+            self._minimize_faculty_gaps()
+            self._minimize_campus_movement()
+            self._penalize_first_hour_free()
+        else:
+            print(f"Skipping expensive soft constraints due to massive math (Tasks: {len(self.tasks)})")
 
         # Summation of all penalties
         if self.penalties:
             total_cost = sum(self.penalties)
             self.model.Minimize(total_cost)
-            print(f"  → {len(self.penalties)} penalty terms added.")
         else:
             self.model.Minimize(0)
 
@@ -177,8 +142,10 @@ class ObjectiveEngine:
 
         for task in self.tasks:
             if task.subject.is_core and task.subject.subject_type == SubjectType.THEORY:
-                self._ensure_day_bools(task)
-                daily_slot = self._daily_slot_vars[task.task_id]
+                start_var = self.ce.task_vars[task.task_id][0]
+                
+                daily_slot = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"daily_slot_{task.task_id}")
+                self.model.AddModuloEquality(daily_slot, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
 
                 # Penalty if daily_slot >= afternoon_start_index
                 is_afternoon = self.model.NewBoolVar(f"is_afternoon_{task.task_id}")
@@ -198,8 +165,10 @@ class ObjectiveEngine:
 
         for task in self.tasks:
             if task.subject.is_heavy:
-                self._ensure_day_bools(task)
-                daily_slot = self._daily_slot_vars[task.task_id]
+                start_var = self.ce.task_vars[task.task_id][0]
+                
+                daily_slot = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY - 1, f"daily_slot_heavy_{task.task_id}")
+                self.model.AddModuloEquality(daily_slot, start_var, const.NUM_TEACHING_SLOTS_PER_DAY)
 
                 is_last_slot = self.model.NewBoolVar(f"is_last_slot_{task.task_id}")
                 self.model.Add(daily_slot == last_slot_index).OnlyEnforceIf(is_last_slot)
@@ -209,146 +178,89 @@ class ObjectiveEngine:
 
     def _minimize_faculty_gaps(self):
         """
-        Penalizes 'idle spans' for faculty using an O(N) approach.
-
-        Instead of tracking min-start / max-end per faculty per day
-        (which requires O(tasks_per_faculty × days) auxiliary variables
-        with conditional min/max), we use a simpler counting approach:
-
-        For each faculty on each day, count the number of tasks scheduled.
-        If count >= 2, the span necessarily introduces potential gaps.
-        The penalty is proportional to (count - 1) since that's the
-        maximum number of gaps possible. The actual gap size is left
-        to the solver's domain reduction.
+        Penalizes 'idle spans' for faculty.
+        We approximate this by minimizing (Daily End Time - Daily Start Time - Total Teaching Duration).
         """
         weight = self.weights.get("faculty_gaps", 0)
         if weight == 0: return
 
         # Group tasks by faculty
-        tasks_by_faculty = defaultdict(list)
+        tasks_by_faculty = {f.id: [] for f in self.faculties}
         faculty_ids_set = {f.id for f in self.faculties}
         for task in self.tasks:
             parts = task.faculty.id.split('_')
             fids = parts if len(parts) > 1 and all(p in faculty_ids_set for p in parts) else [task.faculty.id]
             for fid in fids:
-                if fid != "DUMMY_STAFF":
+                if fid in tasks_by_faculty:
                     tasks_by_faculty[fid].append(task)
 
         for faculty_id, f_tasks in tasks_by_faculty.items():
-            if len(f_tasks) < 2:
+            if not f_tasks:
                 continue
 
-            # Ensure day booleans exist for all tasks of this faculty
-            for task in f_tasks:
-                self._ensure_day_bools(task)
-
             for day in range(const.NUM_WORKING_DAYS):
-                # Collect "is on day" booleans for this faculty's tasks
-                on_day_bools = []
-                for task in f_tasks:
-                    on_day_bools.append(
-                        self._task_day_bools[task.task_id][day])
-
-                # Count tasks on this day
-                count_on_day = self.model.NewIntVar(
-                    0, len(f_tasks),
-                    f"fgap_cnt_{faculty_id}_d{day}")
-                self.model.Add(count_on_day == sum(on_day_bools))
-
-                # Penalize if there's more than 1 task (potential gaps)
-                # Penalty = max(0, count - 1) * weight
-                # Since count >= 0, we can use: penalty_val = count - 1
-                # clamped to 0 via a helper var
-                gap_potential = self.model.NewIntVar(
-                    0, len(f_tasks),
-                    f"fgap_pot_{faculty_id}_d{day}")
-                self.model.AddMaxEquality(
-                    gap_potential, [count_on_day - 1, 0])
-
-                self.penalties.append(gap_potential * weight)
-
-    def _minimize_student_gaps(self):
-        """
-        Penalizes gaps in a section's schedule on a single day.
-        A slot S is a gap if there is a class before S on the same day,
-        a class after S on the same day, and S itself is free.
-        Uses an O(N) boolean representation.
-        """
-        weight = self.weights.get("student_gaps", 0)
-        if weight == 0: return
+                day_offset_start = day * const.NUM_TEACHING_SLOTS_PER_DAY
+                day_offset_end = (day + 1) * const.NUM_TEACHING_SLOTS_PER_DAY
+
+                # Variables to track if faculty is active on this day, and their start/end
+                day_active = self.model.NewBoolVar(f"active_{faculty_id}_{day}")
+                day_start = self.model.NewIntVar(day_offset_start, day_offset_end, f"start_{faculty_id}_{day}")
+                day_end = self.model.NewIntVar(day_offset_start, day_offset_end, f"end_{faculty_id}_{day}")
+                
+                task_on_day_lits = []
+                total_duration_on_day = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"dur_{faculty_id}_{day}")
+                
+                durations_sum = []
 
-        from collections import defaultdict
-        tasks_by_sec = defaultdict(list)
-        for task in self.tasks:
-            tasks_by_sec[task.section.section_id].append(task)
+                for task in f_tasks:
+                    t_start = self.ce.task_vars[task.task_id][0]
+                    t_end = self.ce.task_vars[task.task_id][1]
+                    
+                    is_on_day = self.model.NewBoolVar(f"{task.task_id}_on_day_{day}")
+                    
+                    t_day = self.model.NewIntVar(0, const.NUM_WORKING_DAYS - 1, f"t_day_{task.task_id}_{day}")
+                    self.model.AddDivisionEquality(t_day, t_start, const.NUM_TEACHING_SLOTS_PER_DAY)
+                    
+                    self.model.Add(t_day == day).OnlyEnforceIf(is_on_day)
+                    self.model.Add(t_day != day).OnlyEnforceIf(is_on_day.Not())
 
-        for sec_id, sec_tasks in tasks_by_sec.items():
-            if not sec_tasks: continue
+                    task_on_day_lits.append(is_on_day)
 
-            for day in range(const.NUM_WORKING_DAYS):
-                # 1. Determine if the section has any class at each slot
-                active_at_slot = []
-                for slot in range(const.NUM_TEACHING_SLOTS_PER_DAY):
-                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + slot
-                    slot_covs = []
-                    
-                    for task in sec_tasks:
-                        start_var = self.ce.task_vars[task.task_id][0]
-                        # task covers abs_slot if start <= abs_slot AND end > abs_slot
-                        cov = self.model.NewBoolVar(f"stu_cov_{task.task_id}_s{abs_slot}")
-                        b1 = self.model.NewBoolVar(f"sb1_{task.task_id}_s{abs_slot}")
-                        b2 = self.model.NewBoolVar(f"sb2_{task.task_id}_s{abs_slot}")
-                        
-                        self.model.Add(start_var <= abs_slot).OnlyEnforceIf(b1)
-                        self.model.Add(start_var > abs_slot).OnlyEnforceIf(b1.Not())
-                        self.model.Add(start_var + task.duration > abs_slot).OnlyEnforceIf(b2)
-                        self.model.Add(start_var + task.duration <= abs_slot).OnlyEnforceIf(b2.Not())
-                        
-                        self.model.AddBoolAnd([b1, b2]).OnlyEnforceIf(cov)
-                        self.model.AddBoolOr([b1.Not(), b2.Not()]).OnlyEnforceIf(cov.Not())
-                        slot_covs.append(cov)
-
-                    is_active = self.model.NewBoolVar(f"sec_act_{sec_id}_d{day}_s{slot}")
-                    self.model.AddBoolOr(slot_covs).OnlyEnforceIf(is_active)
-                    for c in slot_covs:
-                        self.model.AddImplication(is_active.Not(), c.Not())
-                    active_at_slot.append(is_active)
-
-                # 2. Identify gaps (free slot surrounded by active slots)
-                for slot in range(1, const.NUM_TEACHING_SLOTS_PER_DAY - 1):
-                    any_before = self.model.NewBoolVar(f"bef_{sec_id}_d{day}_s{slot}")
-                    self.model.AddBoolOr(active_at_slot[:slot]).OnlyEnforceIf(any_before)
-                    for c in active_at_slot[:slot]:
-                        self.model.AddImplication(any_before.Not(), c.Not())
-
-                    any_after = self.model.NewBoolVar(f"aft_{sec_id}_d{day}_s{slot}")
-                    self.model.AddBoolOr(active_at_slot[slot+1:]).OnlyEnforceIf(any_after)
-                    for c in active_at_slot[slot+1:]:
-                        self.model.AddImplication(any_after.Not(), c.Not())
-
-                    is_gap = self.model.NewBoolVar(f"gap_{sec_id}_d{day}_s{slot}")
-                    self.model.AddBoolAnd([active_at_slot[slot].Not(), any_before, any_after]).OnlyEnforceIf(is_gap)
-                    self.model.AddBoolOr([active_at_slot[slot], any_before.Not(), any_after.Not()]).OnlyEnforceIf(is_gap.Not())
+                    # Update min start and max end for the day ONLY if task is on this day
+                    self.model.Add(day_start <= t_start).OnlyEnforceIf(is_on_day)
+                    self.model.Add(day_end >= t_end).OnlyEnforceIf(is_on_day)
                     
-                    self.penalties.append(is_gap * weight)
+                    # Accumulate duration
+                    dur_term = self.model.NewIntVar(0, task.duration, f"dur_term_{task.task_id}_{day}")
+                    self.model.Add(dur_term == task.duration).OnlyEnforceIf(is_on_day)
+                    self.model.Add(dur_term == 0).OnlyEnforceIf(is_on_day.Not())
+                    durations_sum.append(dur_term)
+
+                # If no tasks on this day, force active to false
+                self.model.Add(sum(task_on_day_lits) > 0).OnlyEnforceIf(day_active)
+                self.model.Add(sum(task_on_day_lits) == 0).OnlyEnforceIf(day_active.Not())
+                
+                # --- FIX: Use Python sum() inside Add() instead of self.model.Sum() ---
+                self.model.Add(total_duration_on_day == sum(durations_sum))
+
+                span = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"span_{faculty_id}_{day}")
+                self.model.Add(span == day_end - day_start).OnlyEnforceIf(day_active)
+                self.model.Add(span == 0).OnlyEnforceIf(day_active.Not())
+                
+                idle_time = self.model.NewIntVar(0, const.NUM_TEACHING_SLOTS_PER_DAY, f"idle_{faculty_id}_{day}")
+                self.model.Add(idle_time == span - total_duration_on_day).OnlyEnforceIf(day_active)
+                self.model.Add(idle_time == 0).OnlyEnforceIf(day_active.Not())
+
+                self.penalties.append(idle_time * weight)
 
     def _minimize_campus_movement(self):
         """
         Penalizes consecutive tasks for a section that are in different buildings.
-
-        Rewritten to O(N) by only checking adjacent-period pairs on the same day
-        instead of all O(N²) task pairs.
-
-        For each section and each day, for each pair of adjacent teaching slots,
-        check if the tasks in those slots are in different buildings.
         """
         weight = self.weights.get("campus_movement", 0)
         if weight == 0: return
         
         unique_buildings = sorted(list(set(r.building for r in self.rooms)))
-        if len(unique_buildings) <= 1:
-            return  # Only one building — no campus movement possible
-
         building_to_id = {b: i for i, b in enumerate(unique_buildings)}
         room_idx_to_building_id = [building_to_id[r.building] for r in self.rooms]
 
@@ -357,150 +269,81 @@ class ObjectiveEngine:
             tasks_by_section[task.section.section_id].append(task)
 
         for sec_id, sec_tasks in tasks_by_section.items():
-            if len(sec_tasks) < 2:
-                continue
+            if len(sec_tasks) < 2: continue
+            
+            for i in range(len(sec_tasks)):
+                for j in range(len(sec_tasks)):
+                    if i == j: continue
+                    t1 = sec_tasks[i]
+                    t2 = sec_tasks[j]
+
+                    t1_end = self.ce.task_vars[t1.task_id][1]
+                    t2_start = self.ce.task_vars[t2.task_id][0]
+                    
+                    is_consecutive = self.model.NewBoolVar(f"consec_{t1.task_id}_{t2.task_id}")
+                    self.model.Add(t1_end == t2_start).OnlyEnforceIf(is_consecutive)
+                    self.model.Add(t1_end != t2_start).OnlyEnforceIf(is_consecutive.Not())
 
-            # Ensure day booleans exist
-            for task in sec_tasks:
-                self._ensure_day_bools(task)
+                    b1_var = self.model.NewIntVar(0, len(unique_buildings), f"bld_{t1.task_id}")
+                    b2_var = self.model.NewIntVar(0, len(unique_buildings), f"bld_{t2.task_id}")
+                    
+                    room_var_1 = self.ce.task_vars[t1.task_id][3]
+                    room_var_2 = self.ce.task_vars[t2.task_id][3]
 
-            # For each day, for each pair of adjacent slots, check if two
-            # different tasks from this section occupy them and are in
-            # different buildings.
-            for day in range(const.NUM_WORKING_DAYS):
-                day_offset = day * const.NUM_TEACHING_SLOTS_PER_DAY
-
-                for slot in range(const.NUM_TEACHING_SLOTS_PER_DAY - 1):
-                    abs_slot = day_offset + slot
-                    next_abs_slot = day_offset + slot + 1
-
-                    # Find tasks that could be at abs_slot and next_abs_slot
-                    # A task covers abs_slot if start <= abs_slot < start + dur
-                    # For efficiency, we check start_var constraints
-
-                    tasks_at_slot = []
-                    tasks_at_next = []
-
-                    for task in sec_tasks:
-                        start_var = self.ce.task_vars[task.task_id][0]
-                        # Task covers abs_slot if start <= abs_slot < start + dur
-                        # We need proper reification: cov <=> (start <= abs_slot AND end > abs_slot)
-                        
-                        # For abs_slot
-                        cov = self.model.NewBoolVar(f"cov_{task.task_id}_s{abs_slot}")
-                        b1 = self.model.NewBoolVar(f"b1_{task.task_id}_s{abs_slot}")
-                        b2 = self.model.NewBoolVar(f"b2_{task.task_id}_s{abs_slot}")
-                        
-                        self.model.Add(start_var <= abs_slot).OnlyEnforceIf(b1)
-                        self.model.Add(start_var > abs_slot).OnlyEnforceIf(b1.Not())
-                        self.model.Add(start_var + task.duration > abs_slot).OnlyEnforceIf(b2)
-                        self.model.Add(start_var + task.duration <= abs_slot).OnlyEnforceIf(b2.Not())
-                        
-                        self.model.AddBoolAnd([b1, b2]).OnlyEnforceIf(cov)
-                        self.model.AddBoolOr([b1.Not(), b2.Not()]).OnlyEnforceIf(cov.Not())
-                        tasks_at_slot.append((task, cov))
-
-                        # For next_abs_slot
-                        cov_next = self.model.NewBoolVar(f"cov_{task.task_id}_s{next_abs_slot}")
-                        bn1 = self.model.NewBoolVar(f"bn1_{task.task_id}_s{next_abs_slot}")
-                        bn2 = self.model.NewBoolVar(f"bn2_{task.task_id}_s{next_abs_slot}")
-                        
-                        self.model.Add(start_var <= next_abs_slot).OnlyEnforceIf(bn1)
-                        self.model.Add(start_var > next_abs_slot).OnlyEnforceIf(bn1.Not())
-                        self.model.Add(start_var + task.duration > next_abs_slot).OnlyEnforceIf(bn2)
-                        self.model.Add(start_var + task.duration <= next_abs_slot).OnlyEnforceIf(bn2.Not())
-                        
-                        self.model.AddBoolAnd([bn1, bn2]).OnlyEnforceIf(cov_next)
-                        self.model.AddBoolOr([bn1.Not(), bn2.Not()]).OnlyEnforceIf(cov_next.Not())
-                        tasks_at_next.append((task, cov_next))
-
-                    # For each pair (one at slot, one at next_slot, different tasks),
-                    # check if they're in different buildings.
-                    # To keep this tractable, we only penalize if ANY task at slot
-                    # and ANY task at next_slot are in different buildings.
-                    # We approximate: penalize if slot is occupied AND next_slot is
-                    # occupied (movement required regardless of building).
-                    # This is a much cheaper O(1)-per-slot approximation.
-                    if tasks_at_slot and tasks_at_next:
-                        any_at_slot = self.model.NewBoolVar(
-                            f"any_{sec_id}_d{day}_s{slot}")
-                        any_at_next = self.model.NewBoolVar(
-                            f"any_{sec_id}_d{day}_s{slot + 1}")
-
-                        self.model.AddBoolOr(
-                            [c for _, c in tasks_at_slot]
-                        ).OnlyEnforceIf(any_at_slot)
-                        for _, c in tasks_at_slot:
-                            self.model.AddImplication(
-                                any_at_slot.Not(), c.Not())
-
-                        self.model.AddBoolOr(
-                            [c for _, c in tasks_at_next]
-                        ).OnlyEnforceIf(any_at_next)
-                        for _, c in tasks_at_next:
-                            self.model.AddImplication(
-                                any_at_next.Not(), c.Not())
-
-                        # Movement penalty: both slots occupied = potential
-                        # building change (simplified — exact building check
-                        # was O(n²) and is too expensive for large models)
-                        both_occupied = self.model.NewBoolVar(
-                            f"bothocc_{sec_id}_d{day}_s{slot}")
-                        self.model.AddBoolAnd(
-                            [any_at_slot, any_at_next]
-                        ).OnlyEnforceIf(both_occupied)
-                        self.model.AddBoolOr(
-                            [any_at_slot.Not(), any_at_next.Not()]
-                        ).OnlyEnforceIf(both_occupied.Not())
-
-                        # Use a reduced weight since this is an approximation
-                        self.penalties.append(both_occupied * max(1, weight // 2))
-
-    def _pack_morning_session(self):
+                    self.model.AddElement(room_var_1, room_idx_to_building_id, b1_var)
+                    self.model.AddElement(room_var_2, room_idx_to_building_id, b2_var)
+
+                    diff_building = self.model.NewBoolVar(f"diff_bld_{t1.task_id}_{t2.task_id}")
+                    self.model.Add(b1_var != b2_var).OnlyEnforceIf(diff_building)
+                    self.model.Add(b1_var == b2_var).OnlyEnforceIf(diff_building.Not())
+
+                    penalty_active = self.model.NewBoolVar(f"move_pen_{t1.task_id}_{t2.task_id}")
+                    self.model.AddBoolAnd([is_consecutive, diff_building]).OnlyEnforceIf(penalty_active)
+                    
+                    self.penalties.append(penalty_active * weight)
+
+    def _penalize_first_hour_free(self):
         """
-        Penalizes any free slot in the first 4 hours (morning session) for any section.
-        This strongly forces the solver to pack the morning tightly, leaving afternoons free if necessary,
-        and completely eliminating gaps in the first 4 hours.
+        Strongly penalizes having the first hour (period index 0) free for any
+        section on any day. The solver will avoid this unless there is genuinely
+        no other feasible assignment.
+
+        Since tasks never cross day boundaries, a task covers period 0 of a day
+        if and only if its start_var equals that day's first absolute slot index.
         """
-        weight = self.weights.get("pack_morning", 500)
-        if weight == 0: return
+        weight = self.weights.get("no_first_hour_free", 20)
+        if weight == 0:
+            return
 
-        from collections import defaultdict
-        tasks_by_sec = defaultdict(list)
+        # Group tasks by section
+        tasks_by_section = defaultdict(list)
         for task in self.tasks:
-            tasks_by_sec[task.section.section_id].append(task)
-
-        for sec_id, sec_tasks in tasks_by_sec.items():
-            if not sec_tasks: continue
+            tasks_by_section[task.section.section_id].append(task)
 
+        for sec_id, sec_tasks in tasks_by_section.items():
             for day in range(const.NUM_WORKING_DAYS):
-                for slot in range(4): # First 4 hours
-                    abs_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY + slot
-                    slot_covs = []
-                    
-                    for task in sec_tasks:
-                        start_var = self.ce.task_vars[task.task_id][0]
-                        cov = self.model.NewBoolVar(f"morn_cov_{task.task_id}_s{abs_slot}")
-                        b1 = self.model.NewBoolVar(f"mb1_{task.task_id}_s{abs_slot}")
-                        b2 = self.model.NewBoolVar(f"mb2_{task.task_id}_s{abs_slot}")
-                        
-                        self.model.Add(start_var <= abs_slot).OnlyEnforceIf(b1)
-                        self.model.Add(start_var > abs_slot).OnlyEnforceIf(b1.Not())
-                        self.model.Add(start_var + task.duration > abs_slot).OnlyEnforceIf(b2)
-                        self.model.Add(start_var + task.duration <= abs_slot).OnlyEnforceIf(b2.Not())
-                        
-                        self.model.AddBoolAnd([b1, b2]).OnlyEnforceIf(cov)
-                        self.model.AddBoolOr([b1.Not(), b2.Not()]).OnlyEnforceIf(cov.Not())
-                        slot_covs.append(cov)
-                        
-                    is_active = self.model.NewBoolVar(f"morn_act_{sec_id}_d{day}_s{slot}")
-                    self.model.AddBoolOr(slot_covs).OnlyEnforceIf(is_active)
-                    for c in slot_covs:
-                        self.model.AddImplication(is_active.Not(), c.Not())
-                        
-                    # We penalize if is_active is False
-                    is_free = self.model.NewBoolVar(f"morn_free_{sec_id}_d{day}_s{slot}")
-                    self.model.Add(is_active == 0).OnlyEnforceIf(is_free)
-                    self.model.Add(is_active == 1).OnlyEnforceIf(is_free.Not())
-                    
-                    self.penalties.append(is_free * weight)
+                # The absolute slot index for period 0 of this day
+                first_slot = day * const.NUM_TEACHING_SLOTS_PER_DAY
+
+                # For each task, create a bool: does it start at exactly first_slot?
+                starts_at_first = []
+                for task in sec_tasks:
+                    start_var = self.ce.task_vars[task.task_id][0]
+
+                    at_first = self.model.NewBoolVar(f"at1st_{task.task_id}_d{day}")
+                    self.model.Add(start_var == first_slot).OnlyEnforceIf(at_first)
+                    self.model.Add(start_var != first_slot).OnlyEnforceIf(at_first.Not())
+                    starts_at_first.append(at_first)
+
+                # any_at_first = True if at least one task starts at period 0
+                any_at_first = self.model.NewBoolVar(f"any_at1st_{sec_id}_d{day}")
+                self.model.AddBoolOr(starts_at_first).OnlyEnforceIf(any_at_first)
+                for lit in starts_at_first:
+                    self.model.AddImplication(any_at_first.Not(), lit.Not())
+
+                # Penalty when the first hour IS free (no task at period 0)
+                first_free = self.model.NewBoolVar(f"first_free_{sec_id}_d{day}")
+                self.model.Add(first_free == 1).OnlyEnforceIf(any_at_first.Not())
+                self.model.Add(first_free == 0).OnlyEnforceIf(any_at_first)
+
+                self.penalties.append(first_free * weight)