Redistributing times Original problem:
Given \$x\$ number of tests that should run in \$y\$ number of seconds shift the time per test so that each test takes a little longer than the next.
Example: If running 10 tests over 10 seconds, the equal time per test would be 1 second each.
Instead, have the first test take .5 seconds and the last test take 1.5 seconds while each subsequent test take a progressively longer duration.  We shift the time per test around while still maintaining the original duration of 10 seconds for the 10 tests.
I am slightly ignorant of what math principles are occurring.  I knew how I wanted to solve the problem but I can't describe the problem. I've made it possible to adjust how much shifting can be done.  Since the array of times is linear (and we can't really have negative times) I put a limit on that 'shifting' value.

How do you describe this function / math problem?  (which would hopefully result in a better name for it).
What should the pct variable be called?  I originally thought it to be a percentage of each second, but as I developed the function I realized this was inaccurate; since after the first value, the percentage of shifting per time slice goes down then back up again.

def duration_spread(tests: float, seconds: float, pct: float = .75):
    assert -1 &lt;= pct &lt;= 1, &quot;pct must be within +/-100% otherwise it will push times into negative&quot;
    pct *= 2
    original_velocity = seconds/tests
    seconds_per_tests = original_velocity  # couldn't decide on naming convention
    average_velocity = original_velocity
    diff_average_velocity = pct * average_velocity
    acceleration = diff_average_velocity/tests

    multiplier_list = get_multipliers(tests)
    results = []
    for i, multiplier in enumerate(multiplier_list):
        newadjustment = (multiplier * acceleration)
        newtime = original_velocity + newadjustment
        print(f&quot;{original_velocity} -&gt; {newtime} :: {abs(newadjustment)}&quot;)
        results.append(newtime)

    return results


def get_multipliers(tests: float):
    odd = int(tests % 2)
    half_tests = int(tests // 2)
    result = list(range(-half_tests, half_tests+1))
    if not odd:
        result.pop(half_tests)
    return result
How do you describe this function / math problem?

The input is a list of tests with the same duration. For example, \$input=[2,2,2,2]\$. Given the indexes from 0 to 3, we can see it in a graph:

So we can define the input as a (discrete) function \$f(x)=2\$, or in general \$f(x) = seconds/tests\$. Where \$0&lt;=x&lt;=tests,x∈Z\$.
The function \$durationSpread\$ can be described as \$durationSpread = g(x) * f(x)\$. Where \$g(x)\$ is a function that depends on \$pct\$ and \$tests\$. In the following I am going to refer it as \$g(pct,tests)\$.
Function analysis
For pct=0 the input remains the same: \$g(pct,tests) * input = g(0,4) * [2,2,2,2] = [2, 2, 2, 2]\$. Meaning that all elements of the input are multiplied by 1. So \$g\$ should look like this:

For pct=-1 the result &quot;should be&quot;: \$g(-1,4) * [2,2,2,2] = [4.0, 2.67, 1.33, 0.0]\$. The first element of of the input is multiplied by 2, the last one by 0, and the elements in between by a descending factor.
I said &quot;should be&quot; because your code outputs \$[4.0,3.0,1.0,0.0]\$, which is not possible if we consider a constant factor (the gap betweenn 4.0 and 3.0 is 1, but between 3.0 and 1.0 is 2).
So \$g\$ should look like this:

For pct=1 the result is: \$g(1,4) * [2,2,2,2] = [0.0, 1.33, 2.67, 4.0]\$. In this case, the first element is multiplied by 0 and the last one by 2. So the function \$g\$ is:

How to find \$g\$? From the three examples, we know that \$g\$ is a linear function. A linear function can be represented as y = mx + b. How to find m and b? They can be found given two points.
Let's choose the first point (x0,y0) in the origin. x0 is always 0. While y0 depends on pct. Looking at the examples, we can tell that it's equal to abs(pct - 1). Explanation:

In the first example pct=0 and y0=1. In fact, y0 = abs(0 - 1) = 1
In the second example pct=-1 and y0=2. In fact, y0 = abs(- 1 - 1) = abs(-2) = 2
In the third example pct=1 and y0=0. In fact, y0 = abs(1 - 1) = abs(0) = 0

For the second point (x1,y1), we can choose the center. Where y1 is always 1. While x1 can be found as x1 = (tests-1)/2. (You can double-check in the three examples).
Given two points we can find the slope m as m = (y1 - y0) / (x1 - x0). Once we have m, we calculate the constant b as b = y0 - (m * x0).
Now that we found \$g\$, we can multiply the input by \$g\$.
def duration_spread(tests, seconds, pct):
    x0, y0 = 0, abs(pct - 1)
    x1, y1 = (tests - 1) / 2, 1
    m = (y1 - y0) / (x1 - x0)
    b = y0 - (m * x0)
    unit_time = seconds / tests
    return [unit_time * (m * x + b) for x in range(tests)]

Some tests:
times = duration_spread(4, 8, 1)
print(' '.join(f'{x:.1f}' for x in times))
# output: 0.0 1.3 2.7 4.0

times = duration_spread(5, 10, -1)
print(' '.join(f'{x:.1f}' for x in times))
# output: 4.0 3.0 2.0 1.0 0.0

times = duration_spread(5, 10, .5)
print(' '.join(f'{x:.1f}' for x in times))
# output: 1.0 1.5 2.0 2.5 3.0

Code review
Very short since @Reinderien covered most of the ground.

Input type: tests represents the number of tests, so I am not sure why it's a float. It should be an integer.
Missing return type hint: the return type hint is missing in both functions.