As per the practice project, things to look out for in solving the questions are:

Make sure to name functions and arguments as stipulated in the question, but never be afraid to create extra functions of your own, e.g. to break up the code into conceptual sub-parts, or avoid redundancy in your code
Commenting of code is one thing that you will be marked on; get some practice writing comments in your code, focusing on:
Describing key variables when they are first defined (but not things like index variables in for loops)
Describing what "chunks" of code do (i.e. not every line, but chunks of code that perform a particular operation, such as #find the maximum value in the list or #count the number of vowels
Describing what every function does, including what its arguments are, and what it returns.

Background
Consider the problem of moving house

Your goal is to move in to your new house.

Before you can do this, there are many tasks you must perform, e.g., getting boxes to store your belongings, packing your belongings, cleaning the old house, finding a removalist, moving your packed belongings.

There are also dependencies between tasks, e.g., you need to get boxes before you can pack your belongings, you need to move your packed belongings before you can clean the house, and so on.

A plan that achieves your goal specifies the order in which tasks should be executed so that all the dependencies are met, noting that some tasks can be executed in parallel.

For example:
Goal task: move-in
Other tasks: get-boxes, pack, clean, find-removalist, find-cleaner
Dependencies:
get-boxes → pack, find-removalist → move-in
pack → clean,
clean → move-in,
find-cleaner → clean

To generate a plan, we need to assign a time-slot to each task.

We assume each task takes 1 time-step.

Note that some tasks can be done in parallel.

There can be many valid plans for a given goal and set of dependencies.

Valid vs Invalid Plans
A plan is valid if all dependencies are satisfied.

Optimal vs Suboptimal plans
We will consider a plan to be optimal if it follows the just-in-time scheduling strategy, where a task is scheduled for execution just before it is needed, i.e., as late as possible.

Planning metrics
The number of time-steps required by a given plan is called the length of the plan.

The maximum number of tasks in parallel in any time-step of a given plan is called the number of workers required by the plan.

Task Planning Problems
In this project we will define and implement a very simple programming language for task planning:

Is a given plan valid? (Question 1)
How long will it take a plan to execute (Question 2)
How many workers are needed to execute the plan (Question 3)
Assumptions:
Each task is a pre-requisite for at most one other task.

Dependencies : each tuple (1, 2) in the dependency list specifies that task 2 depends upon task 1

When specifying a plan, the order of tasks in a time-step is irrelevant, i.e., the following to plans are equivalent: [[1,4], [5,6, 3], [2]] and [[4,1], [3,5,6], [2]]

There will be no cyclic dependencies given, e.g., you would not be given the following dependencies: [(1,2), (2,3), (3,1)].

The order of tasks between time-steps may be relevant, depending on the dependencies. If (1,3) and (2,3) are the only dependencies, then [[1],[2],[3]] and [[2],[1],[3]] and [[1,2],[3]] are the only valid plans. Of those, only the last one is optimal.

A given goal task will never have another task as a dependent.

There will always be at least one dependency given.

Plans do not contain any empty time-steps. We would never give you a plan such as [[1,2],[],[3]]

An example
Tasks: 1,2,3,4,5,6

Goal: 2

Dependencies: [(1,3), (4,3), (5,2), (6,2), (3,2)]

(Optimal) Plan: [[1,4], [3,5,6], [2]]

Length of plan: 3

Number of workers for plan: 3

Sub-optimal (but valid) Plan : [[1], [4], [3], [5], [6], [2]]

Sub-optimal (but valid) Plan: [[1],[4], [3,5,6], [2]]

An Invalid Plan: [[1],[4], [3,5], [2,6]]