Fdtxjr

Do summations always increment by one?

Having a more of background in programming than math. I am just learning about summations and I look at them as loops that increment by one.

If my assumption correct what an equivalent method / form to increment by values not equal to one?

Do summations always increment by one?

That depends on what you mean by summation.

E.g
$$
S = sum_i = 1^n s_i = sum_i in I s_i
$$
means a summation, where the indices are picked from $I = 1,ldots, n$.
The index set $I$ could be traversed by starting at $1$ and incrementing to $n$ in steps of $+1$. But that is just one way of $n!$ possible ways to sum the $s_i$ up.

Having a more of background in programming than math. I am just
learning about summations and I look at them as loops that increment
by one.

If my assumption correct what an equivalent method / form to increment
by values not equal to one?

You could start with $n$ and finish with $1$. Or you first use the odd indices ascending and the the even ones descending.
$$
S = sum_overseti in I i bmod 2 = 1 s_i +
sum_overseti in I i bmod 2 = 0 s_i
$$

It should lead to the same sum, as order does not matter to the finite index set.

In programming, many languages provide for an optional step in the loop. It defaults to $1$, but you can set it to something else. In math, it is similar. The default is to increment by $1$. If you want to add up all the multiples of $3$ from $3$ to $30$, you could write $$sum_i=1^103i$$, where $i$ increments by $1$ and the factor $3$ gets you the increment you really want. In programming you can do the same thing. You can write for i=1 to 10;k=3*i and use k instead of i for your computations. You can also write for i=3 to 30 step 3. In math you can write $$sum_ substack i=3\ iequiv 0 pmod 3^30i$$ to get a step of 3. It seems fairly rare in math, more common in programming, in my experience

This may at first seem like a problem, but once you start thinking about how to solve it the solution becomes obvious and attests to the beauty of simplicity in math.

Let's solve the problem of being able to increment by any real number: simply multiply $i$ by $p$, the desired real number.

Using negative numbers? Increment by a negative number, etc.

No, summations do not always increment by one. In fact, summations can be over many kinds of sets, possibly not even restricted to integers or countable cardinality. Some examples from Wikipedia:

An example of a proof involving a summation over an uncountable set can be seen here on SE: The sum of an uncountable number of positive numbers

Edit, okay, okay strait to it then (if ya want more examples check the edits), so let's commence with the pealing with Python!

$$
h left( x right) = x over 2
$$

$$
sum_i=1^end=10 hleft( i right)
$$

end=10 really should just be 10 to conform with the normal but it's labeled for referencing

$sum$ is very analogous to sum(), not much really has to be done, but to ensure everyone's on the same page, both, under the hood kinda look like...

def sum_of_list(l):
 last_value = 0
 for value in l:
 last_value += value

 return value

... and $h left( x right)$ is a bit like...

def h(x):
 # According to lore, multiplication is often faster than division.
 return x * 0.5

... though not quite because that does not sufficiently express infinities, but let's set that aside for a moment.

$i = textstart$ is very much like an iterator, especially when paired with a limit such as $textend$, above an bellow $sum$ respectively. So let's consider it as such for now.

$h left( i right)$ when combined with $sum$, eg $sum_h left( i right)$ is almost a function call, it's not quite equivalent but let's not quibble.

To approximate these behaviors with some code, here's what I came up with...

#!/usr/bin/env python3

from collections import Iterator


class Rolling_Summation(Iterator):
 """
 Rolling_Summation is an __approximation__ of Sigma Notation

 On each iteration of `Rolling_Summation` the result of `f(i.next())` are `yeild`ed

 The current sum maybe inspected at any point via the `.current_sum` property
 """

 def __init__(self, i = range(1, 11), f = lambda x: float(x)):
 super(Rolling_Summation, self).__init__()
 self.i = i
 self.f = f
 self.__current_sum = 0
 self.__finished = False

 @property
 def current_sum(self):
 return self.__current_sum

 @property
 def is_finished(self):
 if bool(self.__finished) is True:
 return True

 return False

 def throw(self, type = None, traceback = None):
 raise StopIteration

 def next(self):
 try:
 if hasattr(i, 'next'):
 # Python 2
 i_value = self.i.next()
 else:
 # Python 3
 i_value = self.i.__next__()
 except (StopIteration, GeneratorExit):
 self.__finished = True
 else:
 f_value = self.f(i_value)
 self.__current_sum += f_value
 return f_value

 if self.is_finished:
 self.throw(GeneratorExit)

 # Python 3 compatibility
 __next__ = next

... along with some examples.

$$
sum_i=1^10
$$

results = 0
sum_iter = Rolling_Summation(iter(range(1, 11)), lambda x: float(x))
for r in sum_iter:
 print("r -> 0".format(r))
 results += r
print("results -> 0".format(results))
print("sum_iter.current_sum -> 0".format(sum_iter.current_sum))

The above Python code could also be expressed as...

sigma = sum([x for x in Rolling_Summation(iter(range(1, 11)), lambda x: float(x))])

... if you're one for one-liners.

Both sum_iter.current_sum and sigma from above should result in the same value of 55.0

How do you increment by a negative number?

Stepping by -1 starting at -1 and going to -10...

$$
sum_i = -1^-10
$$

sum([x for x in Rolling_Summation(iter(range(-1, -11, -1)), lambda x: float(x))])
# -> -55.0

While that may not be technically correct I doubt you'll confuse anyone as to the intent or the results expected. However to be explicit one could also translate it as...

$$
n left( x right) = -1n
$$

$$
sum_i = n left( 1 right)^-10
$$

... if you're one that must be reminded to decrement, and also a hint to yet another answer to...

Or any real number?

$$
p left( x right) = n + 2
$$

$$
sum_i = p left( 0 right)^ge10
$$

sum([x for x in Rolling_Summation(iter(range(2, 12, 2)), lambda x: float(x))])

Now even with this classy method it's just an approximation, a close one if ya dig into what the code is really doing to emulate much of what sigma notation can relay, but eventually you'll find something that'll compute as an oscillating value, or find floating point errors accumulating (just as two examples), and things'll get messy.

Bonus examples

It's a good idea to second-guess one's self when going from one to the other; off by one errors can be a pain, eg matrix vs list indexing...

$$
M = beginpmatrix0, 1, 2, dots 9 endpmatrix
$$

$$
sum_i = 1^10 M_i
$$

M = [x for x in range(0, 9)]
# -> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

sum([x for x in Rolling_Summation(iter(range(0, len(M) - 1)), M.index)])

... note where those 0s and 1s differ above to save yourself future headaches...

$$
f left( x right) = begincases
1, & textif 2 mid x \
0, & textotherwise
endcases
$$

$$
sum_i = M_1^10 fleft( i right)
$$

def f(x):
 if x % 2 == 0:
 return 1
 return 0


sum([x for x in Rolling_Summation(iter(M[0:10]), f)])

But this has all just been one interpretation for how to translate as many of the features from one to the other, hopefully all before attention spans have run-out.