Constraint is identifying the violating entities properly, but the score is not improving

[ace19wre]

Constraint InstructorTeachesUnqualifiedCourseConflict(@nonnull ConstraintFactory constraintFactory) {
// Ensure that an Instructor is only teaching a qualified Course
return constraintFactory.forEach(Period.class)
.filter(period -> !period.getInstructor().getTeachingCourses().contains(period.getSubject()))
// Filter out all those period instances where instructor is teaching a qualified course
.penalize(HardMediumSoftLongScore.ofHard(100))
// Penalize each occurrence with ONE_HARD, as an Instructor can only teach a qualified Course
.asConstraint("Instructor Teaches Unqualified Course");
}

This constraint is identifying all the constraint breaking entities properly, but the score doesn't improve at all.....How can I mitigate this?
repo: https://github.com/ace19wre/TimeLith-Wizard

edit 1: I am pretty sure I have to implement custom moves to exchange the instructors based on what courses they can teach, may be a step by step in a nutshell guide will help alot.

[triceo]

Quick look at your constraint provider tells me your biggest problem may actually be score traps.

• If everything is penalized by ONE_HARD (which is the case in your repo, not in this question), you're effectively saying that everything is equally as important. If the solver makes one thing a little worse (-1) to improve another (+1), the result is zero, no change, no improvement. The solver has no incentive to move in either direction.
• This is made worse by the fact that your match weights are always 1. Therefore each constraint match is penalized exactly the same. Typically, we try to penalize proportionally to the amount of damage. Hypothetically: if two lessons by the same teacher overlapped in time, you can choose to penalize by 1, or you can choose to penalize by the number of overlapping minutes. In the first case, the penalty will always be 1, no matter if the overlap is 5 minutes, 15 minutes or an hour. In the second case, if the solver manages to reduce the overlap by one minute, the penalty will decrease by 1 - and therefore it will show the solver a direction to go in.

Obviously this example doesn't apply to your case, but it demonstrates a principle. In principle, you want to make sure that any two fundamentally different solutions have different scores. And your unweighted constraints don't accomplish that. It is possible you will need custom moves, they almost always help, but I'd start with score traps.

[ace19wre]

Thanks Sir, I thought I was going insane..... about the score traps it makes alot of sense in the hindsight, I was obseving the move calculation in the DEBUG logging wondering about the repeated moves which led to the same score.

Probable Solution->

1. I should change the score weights for each constraints in a level to allow for direction and test the results.
   are there any tricks or tips to heuristically approach this task?

2. I should Implement custom moves that are tailored to my domain.

I had another question, in a last diitch attempt I turned on brute force, why did the score value deterioate so much(-51 Hard, max worst possible)? I thought it would go thought every possible combination, was it again related to the score director being without vibe?

Is there any example where custom moves have been implemented so that I may use it as a reference.

Thanks again!.

[ace19wre]

@triceo Sir, I disabled all other constraints except the one mentioned above, the score still doesn't improve, it remains ,same as the number of planning entities , -28(* the arbitary weight), is there something wrong with my implementation?

[triceo]

Without looking deeply into your problem, I still think that the primary issue is the score traps.
Think about the different solutions that the solver can produce - do they have a unique score, different from other solutions? If not, the solver cannot improve, because it cannot find any meaningful change.

If 99 % of your solutions all get a score of -28, then the solver cannot be expected to make progress. Try to get your constraints to a point where every significant difference in the solutions results in a difference in the score - otherwise you have a score trap, and the solver will be trapped.

[ace19wre]

Ok Sir, I'll look into how I can describe my constraint in a way that makes the solution identifiable(any hints please), but it raises another doubt on the other hand,

I designed the above constraint with this constraint(from employee Scheduling) as a reference

Constraint requiredSkill(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Shift.class)
.filter(shift -> !shift.getEmployee().getSkills().contains(shift.getRequiredSkill()))
.penalize(HardSoftBigDecimalScore.ONE_HARD)
.asConstraint("Missing required skill");
}

Now I disabled all the other constraints in that quick start to see how would the solution score behave ...

2025-04-09 23:12:49,145 INFO [ai.tim.sol.cor.imp.sol.DefaultSolver] (pool-11-thread-1) Solving started: time spent (15), best score (-133init/0hard/0soft), environment mode (REPRODUCIBLE), move thread count (NONE), random (JDK with seed 0).
2025-04-09 23:12:49,146 INFO [ai.tim.sol.cor.imp.sol.DefaultSolver] (pool-11-thread-1) Problem scale: entity count (133), variable count (133), approximate value count (15), approximate problem scale (2.631101 � 10^156).
2025-04-09 23:12:49,168 INFO [ai.tim.sol.cor.imp.con.DefaultConstructionHeuristicPhase] (pool-11-thread-1) Construction Heuristic phase (0) ended: time spent (39), best score (0hard/0soft), move evaluation speed (99750/sec), step total (133).
2025-04-09 23:13:19,129 INFO [ai.tim.sol.cor.imp.loc.DefaultLocalSearchPhase] (pool-11-thread-1) Local Search phase (1) ended: time spent (30000), best score (0hard/0soft), move evaluation speed (632308/sec), step total (7974613).
2025-04-09 23:13:19,133 INFO [ai.tim.sol.cor.imp.sol.DefaultSolver] (pool-11-thread-1) Solving ended: time spent (30001), best score (0hard/0soft), move evaluation speed (631489/sec), phase total (2), environment mode (REPRODUCIBLE), move thread count (NONE).

as you can see it works, zero constraint matches... What is fundamentally so different between my implementation and the demo, that in my case the LS phase just gets stuck, and here it didn't even matter... how should I even investigate this?

Edit 1:

I'll try out this approach tomorrow morning, do you think it has some mettle?

1)for each period class
2)filter by instructor not teaching that course in that period
4)Map period to Instructor
3)group by instructor-> get count
4)penalize by count

The above won't work, it does the same thing as the original constraint

[ace19wre]

@triceo, Hello Sir, I just had a eureka moment, maybe from your perspective, you already knew the solution, but thanks for guiding me none the less without revealing the answer.

As you can see from the above diagram that I sketched in extreme hurry to show to you,
I will have to give the solver a guiding capability.

1. get the period course,
   find the logcal position of the instructor that can teach that course, compare it with the logical position of the instructor assigned to that period, and then penalize.

But this raises another implementation question, what if there are two faculties that teach the same course, I can randomly chose a faculty and then go through the process above but won't that randomness hinder the solver. How could I over come it?

One more thing, the employee scheduling solver behaviour(why two logically same constraint performed differently in two models), please investigate it.

[triceo]

Unfortunately I cannot afford to spend more time on this than I already have, but I do think you are getting further and further away from what you need to do. You do not need to invent any new mechanism, and you do not need to reinvent a solver.

You need to create a diversity of solutions for the solver to pick from. You accomplish that through these approaches:

• Proper weighting of constraint and matches. If the planning solution changes, so does its score.
• Once properly weighted, you use a variety of move types to reach solutions which the solver won't easily reach with just the default moves. By default, the solver uses change and swap moves, which both change a single entity. You may try pillar moves, which we also provide, and those change many entities at once. Some problems will benefit from sublist/subchain moves, or K-opt. Or you could think of custom moves applicable for your particular situation.

These are the basics of getting the solver unstuck. Don't invent new algorithms, give the solver more different solutions to choose from. If all of the above fails, you can try tweaking local search parameters, but that is likely to lead to over-fitting, not to overall improvements on all datasets.

[simontiffert]

First always check the basics and validate constraints with a unit test (at least when running into issues better before).

A debugger can be helpful as well to analyze the data structure. In your case you are comparing objects (in this case from class Course), so you need to validate that there is either:

• only one object per id
• compare by id
• implement equals/hashcode in Course.class

The JSON Jackson was not referring to course objects, but creating multiple objects with the same content.