Why does this PulP allocation optimization problem doenst work as expected?

i'm developing a Python Programm to allocate employees to different appointments.
I'm trying to reach an allocation, where most of employees are not allocatet to appointments. Only if nessesary (because there are more appointments at one timeslot) more employees should work on the the appointments.
My Programm looks like that:

    prob = LpProblem("equally_employee_allocation",LpMinimize)

    #Dictionary mit Mitarbeitern, solange diese nicht im Urlaub sind. (inkl allen weiteren Informationen)
    employee_dict = get_employees(date)
    employee_count = len(employee_dict)

    #Dict aller Slots und wie viele Terminen zu diesem Zeitslot bearbeitet werden müssen
    slot_appo_dict = get_slot_appo_dict(date)

    #Binärvariablen, welche angeben, ob ein Mitarbeiter einem Termin zugeteilt wurde, oder nicht.
    empl_appo_bin = LpVariable.dicts("employ_appoi_bin", (slot_appo_dict, employee_dict),cat=LpBinary)

    #Variable, welche die Anzahl der Termine des jeweiligen Mitarbeiters angibt
    empl_appo_count= LpVariable.dicts("employ_appoi_count", employee_dict, cat=LpInteger, lowBound= 0)



    ##### Zielfunktion #####
    prob+=lpSum(empl_appo_count[emp] for emp in employee_dict)

    ##### Nebenbedingungen #####


    #Die Anzahl der aufgeteilten Mitarbeiter auf einen Slot muss der denen der gebuchten Termine entsprechen:
    for slot in slot_appo_dict:
        prob += lpSum(empl_appo_bin[slot][e] for e in employee_dict) == slot_appo_dict[slot]

    for empl in employee_dict:
        # Die Anzahl der zugewiesenen Termine von Mitarbeiter M:
        prob += empl_appo_count[empl] == lpSum(empl_appo_bin[slot][empl] for slot in slot_appo_dict)

        #elastic Constraint: Abweichung von der durchschnittlichen Anzahl der bearbeiteten Termine wird bestraft
        flex_constraint1 = LpConstraint(e=empl_appo_count[empl], name=f"equal_allocation{empl}", sense=LpConstraintEQ, rhs= 1)
        prob.extend(flex_constraint1.makeElasticSubProblem(penalty=1, proportionFreeBound=0))




    prob.writeLP("data/low_allocation.lp")
    prob.solve()

I think this lines does'nt do what i want:

        #elastic Constraint: Abweichung von der durchschnittlichen Anzahl der bearbeiteten Termine wird bestraft
        flex_constraint1 = LpConstraint(e=empl_appo_count[empl], name=f"equal_allocation{empl}", sense=LpConstraintEQ, rhs= 0)
        prob.extend(flex_constraint1.makeElasticSubProblem(penalty=1, proportionFreeBound=0))

The result with 4 Employees and 12 Appointments (all at different times) should be, that only one Employee works on every Appointment.

But instead of that it Allocates:
Empl 1 - 2 Appointments
Empl 2 - 9 Appointments
Empl 3 - 1 Appointments
Empl 4 - 0 Appointments

Objective Value is 24

What am i doing wrong? Or Maybe you have an idea, how to formulate the problem in a better way?

I hope, you can Help!
Thank you!

I tried changing sense, penalty, proportionFreeBound and rhs in different ways... Only thing i reached was an unbounded problem, althoug the lower bound is 0.

Example
There are 12 Appointments. Employee 1 should get all of the apointments (12). Only if there are more than one appointments at the same time, employee 2 should get the second one (empl 3 the 3rd and so on...) After that, Employee 1 should get the rest.

The concept that will help you do this is the use of an indicator variable that indicates whether an employee has any assignments on the day in question. In order to make that work, you need to introduce a "big M" constraint (google it). Basically you can multiply the binary indicator variable by a suitably large number to make the logic work in the new constraint I added.

There were a few extra things in your code that were not needed, so I commented them out.

Code:

from pulp import *

prob = LpProblem("equally_employee_allocation",LpMinimize)

#Dictionary mit Mitarbeitern, solange diese nicht im Urlaub sind. (inkl allen weiteren Informationen)
employee_list = ['Bob', 'Sam', 'Hans', 'Gertrude']
employee_count = len(employee_list)

#Dict aller Slots und wie viele Terminen zu diesem Zeitslot bearbeitet werden müssen
#               slot : appts
slot_appo_dict = {	1: 1,
					2: 1,
					3: 3,
					4: 2,
					5: 2,
					6: 1}

M = len(slot_appo_dict.keys())  # the max number of possible assignments per employee (every slot)

#Binärvariablen, welche angeben, ob ein Mitarbeiter einem Termin zugeteilt wurde, oder nicht.
empl_appo_bin = LpVariable.dicts("employ_appoi_bin", (slot_appo_dict, employee_list),cat=LpBinary)

# this below is NOT needed
#Variable, welche die Anzahl der Termine des jeweiligen Mitarbeiters angibt
# empl_appo_count= LpVariable.dicts("employ_appoi_count", employee_list, cat=LpInteger, lowBound= 0)

# an "indicator" variable that is 1 if employee works *any* shift and 0 otherwise
employee_works = LpVariable.dicts("works", employee_list, cat=LpBinary)

##### Zielfunktion #####
# minimize the number of employees who are working:
prob+= sum(employee_works[e] for e in employee_list)

##### Nebenbedingungen #####


#Die Anzahl der aufgeteilten Mitarbeiter auf einen Slot muss der denen der gebuchten Termine entsprechen:
for slot in slot_appo_dict:
	prob += lpSum(empl_appo_bin[slot][e] for e in employee_list) == slot_appo_dict[slot]

for empl in employee_list:
	# not needed
	# Die Anzahl der zugewiesenen Termine von Mitarbeiter M:
	# prob += empl_appo_count[empl] == lpSum(empl_appo_bin[slot][empl] for slot in slot_appo_dict)

	prob += sum(empl_appo_bin[slot][empl] for slot in slot_appo_dict) <= M * employee_works[empl]

	# I'm not sure what you are trying to do here, but it is not needed:
	# #elastic Constraint: Abweichung von der durchschnittlichen Anzahl der bearbeiteten Termine wird bestraft
	# flex_constraint1 = LpConstraint(e=empl_appo_count[empl], name=f"equal_allocation{empl}", sense=LpConstraintEQ, rhs= 1)
	# prob.extend(flex_constraint1.makeElasticSubProblem(penalty=1, proportionFreeBound=0))

	
res = prob.solve()

for slot in slot_appo_dict:
	for employee in employee_list:
		if empl_appo_bin[slot][employee].varValue:  # will be true if varValue == 1...
			print(f'employee {employee} is assigned to slot {slot}')

Output:

Result - Optimal solution found

Objective value:                3.00000000
Enumerated nodes:               0
Total iterations:               0
Time (CPU seconds):             0.01
Time (Wallclock seconds):       0.01

Option for printingOptions changed from normal to all
Total time (CPU seconds):       0.01   (Wallclock seconds):       0.01

employee Bob is assigned to slot 1
employee Sam is assigned to slot 2
employee Bob is assigned to slot 3
employee Sam is assigned to slot 3
employee Hans is assigned to slot 3
employee Bob is assigned to slot 4
employee Sam is assigned to slot 4
employee Bob is assigned to slot 5
employee Sam is assigned to slot 5
employee Bob is assigned to slot 6