Nrthugu

I'm trying to use a recursive function to simplify below 'for-loops' for any number of loops that I may have to run the program based on the requirement. I can define a recursive function without the use of i, j, k, l.... in the function but I have no idea or I'm having difficulty in defining a iterative function with the use of i,j k...
I would be glad if someone could aid my imagination a little bit on it.

adjcent_spin_product_matrix = 

z_partial = 0

spin = [-1, 1]

for i in spin:

    for j in spin:

        for k in spin:

            for l in spin:

               for m in spin:

                   for o in spin:

                       for p in spin:

                           adjcent_spin_product_matrix = adjcent_spin_product_matrix + [i*j+ j*k+ k*l+ l*n+ m*o+ o*p]

No particular need for a recursive function.

You can use a single loop for every number of indices if you use itertools.product; you can simplify the computation too, using sum and zip

from itertools import product

...

spin_products = 

n = int(input('how many indices? '))

...

for indices in product([-1, 1], repeat=n):

    spin_products.append(sum(i*j for i, j in zip(indices, indices[1:])))

My earlier answer was against your unedited post, so here's an update:

From the code you've provided, it's clear that you must have at least the loops for i, and j.

Evaluating that loop on it's own gives the following list:
[1, -1, -1, 1]

Now, each subsequent nested loop in your coded merely duplicates each element in this list, and then adds the array (repeated twice) from the previous loop:

The i, j, and k loops give [1, 1, -1, -1, -1, -1, 1, 1] + [1, -1, -1,
1, 1, -1, -1, 1] = [2, 0, -2, 0, 0, -2, 0, 2]

The i, j, k, and l loops give [1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1] + [1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1] + [1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1] = [3, 1, -1, 1, -1, -3, -1, 1, 1, -1, -3, -1, 1, -1, 1, 3]

And so on...

Therefore, you could simply try something like the following:

adjacent_spin_product_matrix = 

ij_result = [1, -1, -1, 1]



def calc_product(adjacent_spin_product_matrix, number_of_indices):

    if number_of_indices == 2:

        return ij_result

    else:

        number_of_duplicates = 2 ** (number_of_indices - 2)

        curr_array = 

        for elem in ij_result:

            for dup in range(number_of_duplicates):

                curr_array.append(elem)

        prev_array = calc_product(adjacent_spin_product_matrix, number_of_indices - 1)

        temp_array = 

        temp_array.extend(prev_array)

        temp_array.extend(prev_array)

        result = 

        for i, elem in enumerate(curr_array):

            result.append(elem + temp_array[i])



        return result

Now, you should find that:

print(calc_product(, 2))  # equivalent to i and j case

print(calc_product(, 3))  # equivalent to i, j, and k case

print(calc_product(, 4))  # equivalent to i, j, k, and l case

print(calc_product(, 5))  # equivalent to i, j, k, l, and m case

print(calc_product(, 6))  # equivalent to i, j, k, l, m, and o case

print(calc_product(, 7))  # equivalent to i, j, k, l, m, o, and p case

These give the expected results:

[1, -1, -1, 1]

[2, 0, -2, 0, 0, -2, 0, 2]

[3, 1, -1, 1, -1, -3, -1, 1, 1, -1, -3, -1, 1, -1, 1, 3]

[4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4]

[5, 3, 1, 3, 1, -1, 1, 3, 1, -1, -3, -1, 1, -1, 1, 3, 1, -1, -3, -1, -3, -5, -3, -1, 1, -1, -3, -1, 1, -1, 1, 3, 3, 1, -1, 1, -1, -3, -1, 1, -1, -3, -5, -3, -1, -3, -1, 1, 3, 1, -1, 1, -1, -3, -1, 1, 3, 1, -1, 1, 3, 1, 3, 5]

[6, 4, 2, 4, 2, 0, 2, 4, 2, 0, -2, 0, 2, 0, 2, 4, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4, 2, 0, -2, 0, -2, -4, -2, 0, -2, -4, -6, -4, -2, -4, -2, 0, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4, 4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 0, -2, -4, -2, -4, -6, -4, -2, 0, -2, -4, -2, 0, -2, 0, 2, 4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 4, 2, 0, 2, 0, -2, 0, 2, 4, 2, 0, 2, 4, 2, 4, 6]

If you don't want to use a recursive function to do this, what you can do is use a stack. Push each level of your loop to the stack, so you can pop them later on.

A stack is a fundamental data structure in most languages as it's a very natural way to store function call contexts, it's also where Stack Overflow got its name from.