When replying to the problem, I ask that you make posts for solutions and submit comments, jokes, smilies, etc. separately. Please use LaTeX for posting solutions. Thanks.

Just to make a small correction, the original text of the problem (via Kalva) says $2003^{2003}$

We do the following moves alternately: (a) from a position with odd sum to a position with exactly one odd number; (b) from a position with exactly one odd number to a position with odd sum, and with smaller maximum too, or to the all-zero position. The maximum value never increases and move (b) decreases the maximum, so this process must terminate at the all-zero position. Now we shall prove that the moves are always possible. Assume we have a position with odd sum $ (a,b,c,d,e,f)$, so either $ a+c+e$ is odd or $ b+d+f$ is odd. Without loss of generality assume $ a+c+e$ is odd. Now consider everything modulo 2. If one of them is odd, say $ a$, we can do the following moves: $ (1,b,0,d,0,f)\rightarrow(1,1,0,0,0,1)\rightarrow(0,1,0,0,0,1)\rightarrow(0,1,0,0,0,0)$. If all three of them are odd, we do the following: $ (1,b,1,d,1,f)\rightarrow(1,0,1,0,1,0)\rightarrow(1,0,0,0,0,0)$. Therefore move (a) is always possible. Now assume we have a position with exactly one odd number, say $ a$, and the maximum is $ m$. (i) First case, $ m$ is even. The following moves give us a position with odd sum: $ (1,0,0,0,0,0)\rightarrow(1,1,0,0,0,0)\rightarrow(1,1,1,0,0,0)\rightarrow(1,1,1,1,0,0)\rightarrow(1,1,1,1,1,0)$ Call this last position $ (a',b',c',d',e',f')$. Note that $ a',b',c',d',e'$ are odd. But $ m$ is even. Also, $ f'=|a'-e'|\le\max\{{a',e'\}<m}$. So the maximum value must be decreased. (ii) Second case, $ m$ is odd. That is, $ m=a$. Assume $ c>0$. We do the moves: $ (1,0,0,0,0,0)\rightarrow(1,1,0,0,0,0)\rightarrow(1,1,0,0,0,1)\rightarrow(0,1,0,0,0,1)\rightarrow(0,1,0,0,0,0)$ Call the last position $ (a',b',c',d',e',f')$. If the sum does not decrease, then the maximum is the odd number, that is $ b'$. But $ b'=|a-c|<a$. If $ e>0$, we do the same thing, interchanging $ b$ and $ c$ with $ f$ and $ e$ respectively. If $ c=e=0$, we can reach the desired position $ (a,b,0,d,0,f)\rightarrow(a,a,0,0,0,a)\rightarrow(0,a,0,0,0,a)\rightarrow(0,0,0,0,0,0)$. So our proof is complete.

I'm not sure if this solution is correct because it seems too easy for a #6, but here goes: We will show that Bert can make a sequence of moves such that the sum of all six integers, which we will denote in order as $ x_1, x_2, x_3, x_4, x_5, x_6$ will only decrease until it equals zero. Since each move involves an absolute value, no integer will ever be negative, so when the sum of all six equals zero, it follows that each integer itself also equals zero. Assume that at some point Bert cannot make a move that will decrease the sum of the integers. In other words, he can only make moves that either do not change or increase the sum. Choose an arbitrary integer to perform the move on, say $ x_2$, and without loss of generality, let $ x_3 \ge x_1$. It follows that $ x_3-x_1 \ge x_2$ and $ x_3 \ge x_2$. Since every possible move will not decrease the sum of the integers, we also perform the move on $ x_3$. Because $ x_3 \ge x_2$, we must have $ x_4 \ge x_3$ otherwise $ x_3$ will necessarily decrease when the move is performed. So far we have $ x_2 \le x_3 \le x_4$, and by repeating the same argument over and over, we will have $ x_2 \le x_3 \le x_4 \le x_5 \le x_6 \le x_1 \le x_2$ implying that $ x_1=x_2=x_3=x_4=x_5=x_6=c$. If $ c>0$, then any move that Bert makes will obviously decrease the sum of the integers by creating a zero. The sum will only stop decreasing once $ c=0$. Contradiction, so each time it will be possible for Bert to make a move that decreases the sum of the integers until they all eventually equal 0.

Unfortunately, $ \{k,k,0,k,k,0\}$ is problematic (the $ x_4 \ge x_3$ assumption doesn't hold here).

any other holes? I guess that one that azjps pointed out is pretty easy to correct since 2003 is odd.

It needs a bit more fixing than that (perhaps a parity argument like Johan Gunardi's). One could start with $ (1,1,0,1,1,1999)$ and on the first move, remove $ 1999$ (in fact, your argument would remove $ 1999$, the only move that immediately decreases the sum). The only (afaik) case that messes up a simple decreasing invariant solution would be $ (k_1,k_1,0,k_2,k_2,0)$, but it's enough.

Hello, Here is my solution which also uses a monovarient. [geogebra]8844b4a5554a71a813f9548c10f71ccbe4a80741[/geogebra] Ok, let us use a,b,c,d,e,f to represent the values of the vertices. Now I claim that there always exists a move the strictly decreases the total sum a+b+c+d+e+f UNLESS one or more of the values is zero. To prove this, consider the following. (>= means greater than or equal to) b >= d,f. Now if a + f > b then we can simply make the move a -> b-f which will decrease the total sum. Likewise, if c+d > b then we can make a similar move that decreases the total sum. So assume that both of those equations are false, which means that b >= a + f b >= c + d Now, wlog c >= a. So by the two equations above, a + b > c which means that the move b -> c-a will decrease the total sum. So every time, you can always decrease the total sum unless someone is 0 in which case you are already done. QED

That solution is not complete - the question asks about ALL points being 0, not just one.

oh thanks.. Darn well, I guess casework?? I haven't completely worked the cases out yet though

Hello, We first prove that Bert is able to make a sequence of moves such that the numbers on the hexagon are alternately odd and even. This can be done with a lot of casework: Case 1: one vertex $P$ contains an odd number. Then, apply a move to the vertices adjacent to $P$. Then, apply a move to the vertices which are two edges away from $P$. Then, again apply a move to the vertices adjacent to $P$, resulting in a hexagon with alternately odd and even numbers. Case 2: three vertices contain an odd number. There are then two adjacent odd numbers (say, at $P$ and $Q$), else the numbers on the hexagon are already alternately odd and even. Let the third odd number be located at $R$. Then, $R$ is either adjacent to one of $P$, $Q$ or it isn't. Case 2a: $R$ is adjacent to one of $P$, $Q$. WLOG, $R$ is adjacent to $Q$. Then, apply a move to the vertices which are two edges away from $Q$. Then, apply a move to $P$. Then, apply a move to $R$, resulting in a hexagon with alternately odd and even numbers. Case 2b: $R$ is not adjacent to one of $P$, $Q$. WLOG, $R$ is closer to $Q$ than to $P$. Let $S \neq Q$ be adjacent to $P$. Then, apply a move to $S$. Then, apply a move to $P$, resulting in a hexagon with alternately even numbers. Case 3: five vertices contain an odd number. Then there is a regular triangle $ABC$ such that $A, B, C$ contain odd numbers. A move can be applied to every vertex not in this regular triangle, resulting in a hexagon with alternately odd and even numbers. Now, after applying three more moves, we arrive at a hexagon with numbers $(a, |a-b|, b, |b-c|, c, |c-a|)$ (in that order) written at its vertices, where $a, b, c$ are odd. We will prove that it is possible to make a sequence of moves after which the number $0$ appears at all six vertices by strong induction on $3 \max\{a, b, c\} + f(a, b, c)$ where $f(a, b, c)$ is the number of elements of $\{a, b, c\}$ which are equal to $\max\{a, b, c\}$. In the base case $3 \max\{a, b, c\} + f(a, b, c) \leq 6$, we must have $\max\{a, b, c\} = 1$, the hexagon has the numbers $(1, 0, 1, 0, 1, 0)$ written at its vertices, and moves can be applied to each vertex containing the number $1$. Otherwise, $\max\{a, b, c\} > 1$. Because of the rotational and reflectional symmetry of the hexagon and the moves, we can WLOG assume $a \geq b \geq c$. If $a = b = c$, we simply apply a move to the vertices containing $a, b, c$, resulting in a hexagon containing all $0$'s. Otherwise, $a > c$, and we can perform the moves: \[\begin{align*} (a, a-b, b, b-c, c, a-c) \mapsto & (b-c, a-b, b, b-c, c, a-c) \\ \mapsto & (b-c, c, b, b-c, c, a-c) \\ \mapsto & (|a-2c|, c, b, b-c, c, a-c) \\ \mapsto & (|a-2c|, |b - |a-2c| |, b, b-c, c, a-c) \\ \end{align*}. \] This is again a hexagon containing numbers $(a', |a'-b'|, b', |b'-c'|, c', |c'-a'|)$ (where $a' = |a - 2c|, b' = b, c' = c$). It is also easy to see that $\max\{a', b', c'\} \leq \max\{a, b, c\}$. Also, since $a' < a$, if $\max\{a', b', c'\} = \max\{a, b, c\}$ then $b = a$ and we get $1 = f(a', b', c') < f(a, b, c) = 2$. Therefore, $3 \max\{a', b', c'\} + f(a', b', c') < 3 \max\{a, b, c\} + f(a, b, c)$. We can apply the inductive hypothesis to complete the induction.

Call a configuration of six numbers nice if its elements are $(0,1,0,1,0,1) \pmod{2}$.Our effort is to keep the sum of the numbers odd at every stage after the transformations. I will first show that if the sum of the six numbers are odd,then we can reach a nice configuration from any such configuration.As the sum is odd,we have the following cases with the initial configurations at the start (ignoring symmetry) : >> $(1,0,0,0,0,0) \rightarrow (1,1,0,0,0,0) \rightarrow (1,1,1,0,0,0) \rightarrow (1,1,1,1,0,0) \rightarrow (1,1,1,1,1,0) \rightarrow (1,0,1,0,1,0)$ >> $(1,0,1,0,1,0)$ >> $(1,1,0,0,1,0) \rightarrow (1,1,1,0,1,0) \rightarrow (1,0,1,0,1,0)$ >> $(1,1,1,0,0,0) \rightarrow (1,0,1,0,0,0) \rightarrow (1,0,1,1,0,0) \rightarrow (1,0,1,1,1,0) \rightarrow (1,0,1,0,1,0)$ We come back to our main problem.Taking a configuration with odd sum,translate it by a sequence of steps to a nice configuration.Now just consider the maximum number of the final configuration.If it is even,then it can be transformed so that the maximum is made smaller while keeping the sum odd.Consider the case when the maximum number $M$ is odd.We have the following cases: <> If all the odd numbers are equal then the configuration is like $(M,a,M,b,M,c)$.Then $(M,a,M,b,M,c) \rightarrow (M,0,M,0,M,0) \rightarrow (0,0,0,0,0,0)$ <>If two odd numbers equal $M$,then we have a confsiguration like $(M,a,M,b,P,c)$.Then$(M,a,M,b,P,c) \rightarrow (|a-c|,a,M,b,P,c) \rightarrow (|a-c|,a,|a-b|,b,P,c)$ <>If there is only one maximum,then the configuration is like $(M,a,P,b,Q,c)$,Then $(M,a,P,b,Q,c) \rightarrow (|a-c|,a,P,b,Q,c) \rightarrow (|a-c|,a,|a-b|,b,Q,c)$ In each case we see that either the final configuration $(0,0,0,0,0,0)$ can be reached,or the maximum can be made smaller while keeping the sum odd at the same time.In the former case we are done,while in the later case we can again translate the configuration into a nice one and then making the maximum still smaller.We shall continue this algorithm as long as the maximum reaches $0$,when we must have $(0,0,0,0,0,0)$

sorry for reviving the thread. but can any body tell me if there's a flaw in my proof. let the number on each vertices be $a,b,c,d,e,f$ maximum of $a,b,c,d,e,f$ would monotonically decrease at each step as if $a$ is the max then at the next move at A, it would change to $ |b-c|<a $ decreasing the a maximum . hence maximum would become 0 after finitely many move , implies all the numbers change to 0

funstar007 wrote: sorry for reviving the thread. but can any body tell me if there's a flaw in my proof. let the number on each vertices be $a,b,c,d,e,f$ maximum of $a,b,c,d,e,f$ would monotonically decrease at each step as if $a$ is the max then at the next move at A, it would change to $ |b-c|<a $ decreasing the a maximum . hence maximum would become 0 after finitely many move , implies all the numbers change to 0 Same as mine

funstar007 wrote: it would change to $ |b-c|<a $ decreasing the a maximum $|b-c|<a$ is not always true, say for $b=a,c=0$. Well it can be handled with some cases (and an extra move to reduce the maximum).

funstar007 wrote: sorry for reviving the thread. but can any body tell me if there's a flaw in my proof. let the nuber on each vertices be $a,b,c,d,e,f$ maximum of $a,b,c,d,e,f$ would monotonically decrease at each step as if $a$ is the max then at the next move at A, it would change to $ |b-c|<a $ decreasing the a maximum . hence maximum would become 0 after finitely many move , implies all the numbers change to 0 Not at all.Consider this configuration (a,a,0,a,a,0).This configuration is a point of no return in the sense that Bert can no longer perform any move that will reduce the sum of the numbers on the hexagon or turn all of them into zero

I'm astonished that no one has mentioned in this thread that more generally \[ (1 \bmod 2, 1 \bmod 2, 0 \bmod 2, 1 \bmod 2, 1 \bmod 2, 0 \bmod 2) \]is a fatal configuration: one cannot change the parities. This is as I see it the core difficulty of the problem, it means that if you are not careful with parity (yes, we all want to overwrite the maximum) then you can walk Bert into a trap well before reaching the $(t,t,0,t,t,0)$ configuration. Thus the mistake pointed out several times in this thread (in #7, #16, #17) is actually fatal, you cannot just fix it at the end; it seems any correct solution has to worry about parity the entire time.

If $a \le b \le c$ are odd integers, the configuration which has $(a,b-a,b,c-b,c,c-a)$ around the hexagon in some order (up to cyclic permutation and reflection) is said to be great (picture below). Claim: We can reach a great configuration from any configuration with odd sum. Proof. We should be able to find an equilateral triangle whose vertices have odd sum. If all three vertices are odd, then we are already done. Otherwise, operate as in the following picture (modulo $2$). [asy][asy] size(10cm); picture[] h = new picture[4]; h[0] = new picture; h[1] = new picture; h[2] = new picture; h[3] = new picture; pen cu = blue + fontsize(9pt); pen cd = deepgreen + fontsize(7pt); pen mu = lightred + fontsize(9pt); pen md = orange + fontsize(7pt); for (int i=0; i<=3; ++i) { draw(h[i], dir(30)--dir(150)--dir(270)--cycle, cd); draw(h[i], dir(90)--dir(210)--dir(330)--cycle, cu); draw(h[i], dir(30)--dir(90)--dir(150)--dir(210)--dir(270)--dir(330)--cycle, lightgrey); } label(h[0], "$1$", dir(90), dir(90), cu); label(h[0], "$\ast$", dir(150), dir(150), cd); label(h[0], "$0$", dir(210), dir(210), cu); label(h[0], "$\ast$", dir(270), dir(270), cd); label(h[0], "$0$", dir(330), dir(330), cu); label(h[0], "$\ast$", dir(30), dir(30), cd); label(h[1], "$1$", dir(90), dir(90), cu); label(h[1], "$1$", dir(150), dir(150), md); label(h[1], "$0$", dir(210), dir(210), cu); label(h[1], "$0$", dir(270), dir(270), md); label(h[1], "$0$", dir(330), dir(330), cu); label(h[1], "$1$", dir(30), dir(30), md); label(h[2], "$1$", dir(90), dir(90), cu); label(h[2], "$1$", dir(150), dir(150), cd); label(h[2], "$1$", dir(210), dir(210), mu); label(h[2], "$0$", dir(270), dir(270), cd); label(h[2], "$1$", dir(330), dir(330), mu); label(h[2], "$1$", dir(30), dir(30), cd); label(h[3], "$1$", dir(90), dir(90), cu); label(h[3], "$0$", dir(150), dir(150), md); label(h[3], "$1$", dir(210), dir(210), cu); label(h[3], "$0$", dir(270), dir(270), md); label(h[3], "$1$", dir(330), dir(330), cu); label(h[3], "$0$", dir(30), dir(30), md); add(shift(0,0)*h[0]); add(shift(3,0)*h[1]); add(shift(6,0)*h[2]); add(shift(9,0)*h[3]); [/asy][/asy] Thus we arrived at a great configuration. $\blacksquare$ Claim: Bert's goal is possible for all great configurations. Proof. If $a=b=c$ then we have $(t,0,t,0,t,0)$ which is obviously winnable. Otherwise, perform six moves as shown in the diagram to reach a new great configuration whose odd entries are $b$, $|c-2a|$, $\left\lvert |c-2b|-(c-a) \right\rvert$ (and perform three more moves to get the even numbers). The idea is to show the largest odd entry has decreased. [asy][asy] size(12.5cm); picture[] h = new picture[5]; h[0] = new picture; h[1] = new picture; h[2] = new picture; h[3] = new picture; h[4] = new picture; pen cu = blue + fontsize(9pt); pen cd = deepgreen + fontsize(7pt); pen mu = lightred + fontsize(9pt); pen md = orange + fontsize(7pt); for (int i=0; i<=4; ++i) { draw(h[i], dir(30)--dir(150)--dir(270)--cycle, cd); draw(h[i], dir(90)--dir(210)--dir(330)--cycle, cu); draw(h[i], dir(30)--dir(90)--dir(150)--dir(210)--dir(270)--dir(330)--cycle, lightgrey); } label(h[0], "$a$", dir(90), dir(90), cu); label(h[0], "$b-a$", dir(150), dir(150), cd); label(h[0], "$b$", dir(210), dir(210), cu); label(h[0], "$c-b$", dir(270), dir(270), cd); label(h[0], "$c$", dir(330), dir(330), cu); label(h[0], "$c-a$", dir(30), dir(30), cd); label(h[1], "$c-b$", dir(90), dir(90), mu); label(h[1], "$b-a$", dir(150), dir(150), cd); label(h[1], "$b$", dir(210), dir(210), cu); label(h[1], "$c-b$", dir(270), dir(270), cd); label(h[1], "$b-a$", dir(330), dir(330), mu); label(h[1], "$c-a$", dir(30), dir(30), cd); label(h[2], "$c-b$", dir(90), dir(90), cu); label(h[2], "$|c-2b|$", dir(150), dir(150), md); label(h[2], "$b$", dir(210), dir(210), cu); label(h[2], "$a$", dir(270), dir(270), md); label(h[2], "$b-a$", dir(330), dir(330), cu); label(h[2], "$c-a$", dir(30), dir(30), cd); label(h[3], "$||c-2b|-(c-a)|$", dir(90), dir(90), mu); label(h[3], "$|c-2b|$", dir(150), dir(150), cd); label(h[3], "$b$", dir(210), dir(210), cu); label(h[3], "$a$", dir(270), dir(270), cd); label(h[3], "$|c-2a|$", dir(330), dir(330), mu); label(h[3], "$c-a$", dir(30), dir(30), cd); label(h[4], "$||c-2b|-(c-a)|$", dir(90), dir(90), cu); label(h[4], "$b$", dir(210), dir(210), cu); label(h[4], "$|c-2a|$", dir(330), dir(330), cu); add(shift(0,3)*h[0]); add(shift(3,3)*h[1]); add(shift(6,3)*h[2]); add(shift(1,0)*h[3]); add(shift(5,0)*h[4]); [/asy][/asy] This is annoying, but straightforward. Our standing assumption is $a \ne c$ (but possibly $b=c$). It's already obvious that $|c-2a| < c$, so focus on the last term. If $c > 2b$, then $\left\lvert (c-2b)-(c-a) \right\rvert = \left\lvert 2b-a \right\rvert < c$ as well for $a \ne c$. When $c \le 2b$ we instead have $\left\lvert (2b-c)-(c-a) \right\rvert \le \max \left( 2b-c, c-a \right)$ with equality if and only if $c-a = 0$; but $2b-c \le c$ as needed. Thus, in all situations we have \[ c \ne a \implies \max\left( \left\lvert \left\lvert c-2b \right\rvert - (c-a) \right\rvert, \left\lvert c-2a \right\rvert \right) < c. \] Now denote the new odd entries by $a' \le b' \le c'$ (in some order). If $b < c$ then $c' < c$, while if $b = c$ then $c' = b$ but $b' < c = b$. Thus $(c', b', a')$ precedes $(c, b, a)$ lexicographically, and we can induct down. $\blacksquare$

In any configuration, we label the vertices $1$ to $6$ and let $a_i$ be the value of the number at the vertex labelled $i$ and $a_{i+6} = a_i$ Call a configuration "bad" if there exists an $i$ such that $v_2(a_i) = v_2(a_{i+1}) = v_2(a_{i+3}) = v_2(a_{i+4}) = a$ for some $a$, and $v_2(a_{i+2}), v_2(a_{i+5}) > a.$ We claim that a configuration can reach all 0's if and only if it is not bad. The proof is kind of long but the main idea is to show that if our configuration is not of the above type, we can make a sequence of moves such that $\sum_{i=1}^6 a_i$ decreases and the configuration is still not of that type. This also solves the problem. Outline (Incomplete): 1. Show that if a configuration is not bad, we can always decrease $\sum_{i=1}^6 a_i$ via a sequence of moves. In fact, we can even do this in one move unless, for some $a$ and $b,$ there exists an $i$ such that $a_i = a_{i+1} = a,$ $a_{i+2} = a_{i+5} = 0,$ and $a_{i+3} = a_{i+4} = b,$ in which case we can manually find a sequence of moves to decrease the total sum such that the resulting configuration is not bad, given that the original configuration is not bad, so we assume for the rest of the proof that we can decrease the total sum in one move from now on. 2. Now, assume that by making a move decreasing the sum, we result in a bad configuration such that $v_2(a_1) = v_2(a_2) = v_2(a_4) = v_2(a_5).$ It remains to consider 2 cases - if the last move made was at vertex $1$ and if the last move made was at vertex $6$ (other cases follow by symmetry). 2.1. If the last move made was at vertex $1,$ we split into cases based on whether $a_1$ is maximal or not. 2.2. If the last move made was at vertex $6,$ the proof is similar to above and is omitted for now.

Please help me and tell me why my solution is wrong. Algorithm: At every step we choose the maximum of those numbers and apply the process (i.e. write the absolute value of the different of the adjacent numbers). It clearly decrease the sum of the numbers and it is monovariant. Hence, At some moment we will reach $0$. Where is the mistake? @below Thanks! Actually I tried it and thought that this can be solution. I haven't read the previous posts because I want to do it on my own.

ayan_mathematics_king wrote: Please help me and tell me why my solution is wrong. Algorithm: At every step we choose the maximum of those numbers and apply the process (i.e. write the absolute value of the different of the adjacent numbers). It clearly decrease the sum of the numbers and it is monovariant. Hence, At some moment we will reach $0$. Where is the mistake? Read posts 6, 16, 17, 18 above.

I appear to have a different solution, that is essentially the natural "remove maximum but avoid the fatal configuration mentioned in #18". It's possible it's just wrong, so could someone please check? Thanks! The idea is to decrease the maximum value of the configuration while avoiding the patterns $(0,0,0,0,0,0)$ and $(0,1,1,0,1,1)$ mod $2$. Call a configuration $(x_1,x_2,x_3,x_4,x_5,x_6)$ bad if it is part of one of the two previously mentioned patterns. Call a configuration $(x_1,x_2,x_3,x_4,x_5,x_6)$ reducible if it is good and we can apply a sequence of moves to it such that the maximum value of the configuration strictly decreases (or the number of common maximums decreases) and the final configuration is good. We have the following claim which shows that basically all good configurations are reducible. Claim: Any good configuration $(x_1,\ldots,x_6)$ that is not of the form $(M,x,0,x,0,x)$ (or cyclic shifts) is good. Proof: We have the following cases. Case 1: Suppose that all the $x_i$ are odd. In this case, simply apply the operation to the maximum value, since there is no way the resulting configuration can be bad. Thus, the configuration is reducible. Case 2: Suppose that five out of six of the $x_i$ are odd. WLOG assume $x_1$ is the only even one, so the parity configuration is $(1,0,0,0,0,0)$. The only move that would make the configuration bad is applying it on $x_4$, so if a maximum is not at $x_4$, the configuration is clearly reducible. Now suppose the only maximum is at $x_4$. Note that we can make the sequence of moves \[(x_1,x_2,x_3,x_4,x_5,x_6)\to(x_1,x_2,x_4-x_2,x_4,x_5,x_6)\to(x_1,x_2,x_4-x_2,|(x_4-x_2)-x_5|,x_5,x_6),\]which clearly reduces the maximum since $x_2$ is odd, so at least $1$. Furthermore, the parity of this final configuration is $(0,1,0,1,1,1)$, so the configuration is reducible, as desired. Case 3: Suppose that four out of six of the $x_i$ are odd. Since the configuration is good, its parity is either $(1,1,1,0,1,0)$ or $(1,1,1,1,0,0)$ up to cyclic shifts. Applying a single move to either of these leads to a good configuration, so the configuration is reducible, as in case 1. Case 4: Suppose that three out of six of the $x_i$ are odd. Up to cyclic shifts and reflections, the only possible parity configurations are $(1,1,1,0,0,0)$, $(1,0,1,0,1,0)$, or $(1,1,0,1,0,0)$. In the first two cases, any move leads to a good configuration, so we may simply apply a move on the maximum to reduce. In the final case, the only bad move is on $x_5$, so WLOG assume that the only maximum is at $x_5$. We may now apply the sequence of moves \[(x_1,x_2,x_3,x_4,x_5,x_6)\to(x_1,x_2,x_3,x_4,x_5,x_5-x_1)\to(x_1,x_2,x_3,x_4,|(x_5-x_1)-x_4|,x_5-x_1),\]which clearly reduces the maximum since $x_1$ is odd, so at least $1$. Furthermore, the parity of this final configuration is $(1,1,0,1,0,1)$, so the configuration is reducible, as desired. Case 5: Suppose that two out of six of the $x_i$ are odd. It is easy to see that any move leads to a good configuration, so the configuration is reducible simply by applying a move on the maximum. Case 6: Suppose that one out of size of the $x_i$ are odd. WLOG suppose $x_1$ is odd and the rest are even. Applying a move to anything other than $x_1$ leads to a good configuration, so suppose WLOG that the only maximum is at $x_1$. If $x_3$ is nonzero, then we may apply the sequence of moves \[(x_1,x_2,x_3,x_4,x_5,x_6)\to(x_1,x_1-x_3,x_3,x_4,x_5,x_6)\to(|(x_1-x_3)-x_6)|,x_1-x_3,x_3,x_4,x_5,x_6).\]Since $x_3>0$, the maximum has decreased, and the new parity configuration is $(1,1,0,0,0,0)$, so the configuration is reducible. Similarly if $x_5$ is nonzero, we can essentially flip the sequence and do the same thing as above, so WLOG suppose that $x_3=x_5=0$. If $x_2\ne x_4$, then we may do the move \[(x_1,x_2,x_3,x_4,x_5,x_6)\to(x_1,x_2,|x_4-x_2|,x_4,x_5,x_6).\]This has parity $(1,0,0,0,0,0)$, and the third element is nonzero, so it is reducible by the above logic. Thus, WLOG we have $x_2=x_4$, and similarly $x_6=x_4$. Thus, the configuration is reducible as long as it is not of the form $(M,x,0,x,0,x)$, as desired. $\blacksquare$ Note that out original configuration has an odd sum, so it is good. By the above claim, we may keep reducing it until it is not longer reducible, so eventually we reach $(M,x,0,x,0,x)$. It is easy to see that we win in this configuration by applying \[(M,x,0,x,0,x)\to(0,x,0,x,0,x)\to(0,0,0,0,0,0),\]where the last step is three moves applied individually to each of the $x$s. This shows that the configuration can be reduced down to $(0,0,0,0,0,0)$, as desired.

Roughly the same as other solutions in the thread. The only important fact about $2003^{2003}$ is that it is odd, which means that an odd number of the elements on the board are odd. We will begin by reducing the given position to having exactly $1$ odd entry. If there is exactly $1$ odd entry to begin with, there is nothing to do. If there are $3$ odd entries, we have the following cases, up to reflection and rotation (where the entries are taken $\pmod 2$): \begin{align*} (1, \mathbf 1, 1, 0, 0, 0) \to (1, 0, \mathbf 1, 0, 0, 0) \to (1, 0, 0, 0, 0, 0) \\ (1, 1, 0, 1, 0, \mathbf 0) \to (\mathbf 1, 1, 0, 1, 0, 1) \to (0, \mathbf 1, 0, \mathbf 1, 0, 1) \to (0, 0, 0, 0, 0, 1) \\ (1, 0, 1, 0, 1, 0) \to (1, 0, \mathbf 1, 0, \mathbf 1, 0) \to (1, 0, 0, 0, 0, 0). \end{align*}Finally, if there are $5$ odd entries, we have \begin{align*} (1, \mathbf 1, 1, \mathbf 1, 1, 0) \to (1, 0, 1, 0, 1, 0), \end{align*}whence we can finish as before. Henceforth, we assume that there is exactly one odd entry on the board. Let the hexagon be $ABCDEF$, and suppose the number at $A$ is odd while the rest are even. We show an algorithm which strictly decreases the maximum element while maintaining the fact that the only odd number on the board is at $A$. First, if $3$ of the entries on the board are zero, we are able to finish directly. Indeed, suppose there are at least $3$ zeroes, and note that $A$ is nonzero since it is odd. If there are some $3$ zeros which are pairwise all non-consecutive, we have \begin{align*} (\mathbf A, 0, \mathbf C, 0, \mathbf E, 0) \to (0, 0, 0, 0, 0, 0). \end{align*}Otherwise, if, out of any $3$ zeros, some two are consecutive, we have, up to reflection, the following cases: \begin{align*} (A, 0, C, 0, 0, \mathbf F) \to (A, 0, C, 0, \mathbf 0, A) \to (A, 0, C, 0, A, \mathbf A) \to (A, 0, C, 0, A, 0) \\ (A, \mathbf B, 0, 0, 0, \mathbf F) \to (\mathbf A, A, 0, 0, 0, A) \to (0, A, 0, 0, 0, A). \end{align*}In either case, we arrive at a state where we have $3$ zeros no two of which are consecutive, whence we may finish as before. Henceforth, we suppose at most $2$ of the entries on the board are $0$. WLOG, suppose $B \geq F$ (if not, reflect the board). If there are two diametrically opposed zeros, these are hence at $C$ and $F$ (since $B \geq F$). If the maximum number is at $A$, we go by the following moves: \begin{align*} (A, B, C, D, E, \mathbf F) \to (A, B, C, D, \mathbf E, F_1) \to (A, B, C, \mathbf D, E_2, F_1) \to \\ (A, B, \mathbf C, D_3, E_2, F_1) \to (A, B, C_4, D_3, E_2, F_1). \end{align*}Note that $C_4, D_3, E_2, F_1$ are all odd, and that each of them is at most $A$ (since $B, C, D, E, F \leq A$, the absolute difference between any two of them is also at most $A$; then we can just iterate this). Now, from the position $(A, B, C_4, D_3, E_2, F_1)$, we operate on $A$ so as to arrive at the position $(A', B, C_4, D_3, E_2, F_1)$. Note that $A' = |B - F_1| \leq \max(B, F_1) \leq A$. Suppose $A' = A$. In this case, one of $B$ and $F_1$ is zero, while the other is equal to $A$. Since $B$ is even, in fact $B = 0$ and $F_1 = A$. Then, we have $F_1 = |A - E| = A$. As $E < A$ (since $E$ is even, $A$ is odd, and $E \leq A$), we require $E = 0$. Hence, we have diametrically opposed zeros at $B$ and $E$, impossible as we previously reflected the board so that any diametrically opposed zeros are at $C$ and $F$. Therefore, $A' < A$. Now, we do the following sequence of moves: \begin{align*} (A', B, C_4, \mathbf D_3, E_2, \mathbf F_1) \to (A', B, \mathbf C_4, D', \mathbf E_2, F') \to (A', B, C', D', E', F'). \end{align*}Now, $C', D', E', F'$ are all even numbers, and $0 < C_4, D_3, E_2, F_1 \leq A \implies C', D', E', F' < A$ as well. Therefore, the maximal element on the board is now less than $A$, and, as before, the only odd number on the board is at $A$, which completes this step of the algorithm. Otherwise, suppose there is a maximum number at $B$. As before, we begin with the moves \begin{align*} (A, B, C, D, E, \mathbf F) \to (A, B, C, D, \mathbf E, F_1) \to (A, B, C, \mathbf D, E_2, F_1) \to \\ (A, B, \mathbf C, D_3, E_2, F_1) \to (A, B, C_4, D_3, E_2, F_1). \end{align*}Note that $B > A$ since $B$ is even and $A$ is odd. Hence, $F_1 = |A - E| < B$ is odd, and similarly $C_4, D_3, E_2$ are also odd numbers less than $B$. Now, we operate on $B$ so that $(A, B, C_4, D_3, E_2, F_1) \to (A, B', C_4, D_3, E_2, F_1)$, where $B' = |A - C_4| < B$. We then do the sequence of moves \begin{align*} (A, B', C_4, \mathbf D_3, E_2, \mathbf F_1) \to (A, B', \mathbf C_4, D', \mathbf E_2, F') \to (A, B', C', D', E', F'). \end{align*}Note that $C', D', E', F'$ are all even and less than $B$ (since $C_4, D_3, E_2, F_1$ are all odd and less than $B$), so, once again, we have maintained the invariant that $A$ is the only odd number, while strictly reducing the maximum. Otherwise, suppose there is a maximum at $C$ or $E$; if necessary, reflect the board so that there is a maximum at $C$. Note that $C > \max(B, F)$: if $C = \max(B, F)$, we would have done the procedure in the previous paragraph. In the case that $(B, D) \neq (0, C)$, replacing $C$ by $|B - D|$ does the job. Suppose $(B, D) = (0, C)$. We have two cases: when $E = 0$, and when $E \neq 0$. If $E \neq 0$, we have \begin{align*} (A, 0, C, \mathbf C, E, F) \to (A, 0, \mathbf C, C - E, E, F) \to (A, 0, C - E, C - E, E, F). \end{align*}If $C \neq E$, we have reduced the maximum while maintaining our invariant, while if $C = E$, we are done as we have $3$ zeros. If $E = 0$, we have \begin{align*} &(A, \mathbf 0, C, C, 0, F) \to (A, C - A, \mathbf C, C, 0, F) \to (A, C - A, A, \mathbf C, 0, F) \to (A, C - A, \mathbf A, A, 0, F) \to \\ &(A, \mathbf{C - A}, |C - 2A|, \mathbf A, 0, F) \to (A, |A - |C - 2A||, |C - 2A|, |C - 2A|, 0, F). \end{align*}As $0 < A < C$, we have $\max(A, |A - |C - 2A||, |C - 2A|, F) < C$. Otherwise, suppose there is a maximum at $D$; this maximum must be unique, as otherwise we would have done the procedures detailed in one of the two prior paragraphs. As $\max(C, E) < D$, we go by $(A, B, C, \mathbf D, E, F) \to (A, B, C, |C - E|, E, F)$, which is enough as $|C - E| < D$. Thus, at each step of the algorithm, we either finish, or we decrease the maximum number while keeping invariant the fact that the only odd number is at $A$. As the maximum number must always be nonnegative, the algorithm eventually terminates, so we are done. $\Box$

For conciseness, for a position $(a,b,c,d,e,f)$ on board, let $\max = \max(a,b,c,d,e,f)$ and $\Sigma = a+b+c+d+e+f$. We give a strategy that always decreases $\max + \Sigma$, which means that the board will eventually become all zero. We use the following terminologies. A position is bad if after dividing all numbers by their gcd, it is $(0,1,1,0,1,1)$ or its cyclic/symmetric variations modulo 2. A position is dangerous if it is not bad and operating on any maximal number results in a bad position. A position is stagnant if it is not bad and operating on any maximal number does not change the position. Notice that the starting position is not bad since $\Sigma$ is odd. The strategy is: if the position is not dangerous or stagnant, then operate on the largest number so that the resulting position is not bad and $\Sigma$ decreases; if the position is dangerous, we perform the moves specified in part 1 to get a position that is not dangerous. If the position is stagnant, we perform the moves specified in part 2 to get a dangerous position. Part 1. Because we use it repeatedly, the sequence of moves \[(a,b,c,d,e,f) \to (a,b,d-b,d,d-f,f) \to (a,b,d-b,|b-f|,d-f,f)\]is called a moov centered at $d$. It's not hard to verify that the only dangerous positions are the following four. $(a,b,c,d,e,f) \equiv (0,1,1,1,1,1)$ modulo 2 and $d$ is the unique maximal number. In this case, we do a moov centered at $d$, which results in $(0,1,0,0,0,1)$ modulo 2. Notice that $\max$ decreases since $b,f$ are both odd. $(a,b,c,d,e,f) \equiv (1,0,1,0,0,1)$ modulo 2 and $d$ is the unique maximal number. In this case, we do a moov centered at $d$, which results in $(1,0,0,1,1,1)$ modulo 2. Notice that $\max$ decreases unless $b=0$. If $b = 0$, we continue to do a moov centered at the third entry (which is equal to $d-b=d$), which results in $(1,1,0,1,1,1)$ modulo 2. Notice that now $\max$ strictly decreases since the first and fifth entries are both odd. Now we just use the strategy in the first item if necessary. $(a,b,c,d,e,f) \equiv (0,0,0,1,0,0)$ modulo 2 and $d$ is the unique maximal number. We do a moov centered at $d$, which results in $(0,0,1,0,1,0)$ modulo 2. Clearly $b$ and $f$ cannot both be zero, since otherwise $(a,b,c,|c-e|,e,f) = (a,0,c,|c-e|,e,0)$ does not result in a bad position after we divide all components by their common gcd. If $b,f$ are both nonzero, then $\max$ decreases. Otherwise, WLOG $b=0$. Then we do a moov centered at the third entry (which is $d-b=d$), which results in $(0,1,1,0,1,0)$ modulo 2. We know that $a\neq 0$, since otherwise $(a,b,c,|c-e|,e,f) = (0,0,c,|c-e|,e,f)$ does not result in a bad position after we divide all components by their common gcd. Therefore $\max$ decreases. Now we just use the strategy in the second item if necessary. $a,b,c,d,e,f$ are all even. In this case, just divide all numbers by their $\gcd$ if it exists, and if it does not, we're automatically done since there are at least five 0's. These all strictly decrease $\max$ until we win. Part 2. For a stagnant configuration $(a,b,c,d,e,f)$, WLOG $a = b = \max$ and $c=f=0$. In this case, we claim that we can move to a dangerous position. WLOG $d\ge e$. If $d,e$ do not have the same parity, we do \[(a,a,0,d,e,0) \to (a,a,0,d,e,a-e) \to (e,a,0,d,e,a-e) \to (e,e,0,d,e,a-e) \to (e,e,0,d,e,0).\]Otherwise, $a,d$ are of different parity, and we do \[(a,a,0,d,e,0) \to (a,a,a-d,d,e,0) \to (a,d,a-d,d,e,0) \to (a,d,0,d,e,0).\]The two cases we obtained are both dangerous, and furthermore this strictly decreases $\Sigma$.

We can also note that there's nothing special about the given number that was used in the solution unless it's odd. Note that the maximum never increases, and we want to have a strategy that monotonically decreases it. Our strategy will be an algorithm that 1. makes only one number remain odd and then 2. if the sum is odd, decreases the maximum, while preserving odd sum until we get all 0s. It's clear that if this works but maximum never increases, we would be done. Suppose the vertices are ABCDEF cyclically. Since A+B+C+D+E+F is odd, WLOG A+C+E is odd (why would we think of this? because you want to break it down into smaller parts and use an algorithm to guarantee parity of B D F). If only, say, A, is odd, in A,C,E, then I let everyone verify that BFDAF makes only B odd. (to find this just use intuition with easy testing, since parity is not guaranteed of B D F we need to change them, and A C E "hug" B D F) If A,C,E are all odd, then do BDF (in any order,) CE (in any order lol). Hence we have established our first goal again of making only one odd, this time is namely A. (this one's obvious to find on your own ) $(Algorithm 1)$ Now for the second step, rename them s.t. only A is odd. Case 1. Maximum is even. In this case the maximum is one of BCDEF, then make moves BCDEF, whence it's obvious the maximum strictly decreases (unless there are two maximums, in which case we remove one of them, and then apply it again). Case 2. Maximum is odd (namely A). In this case if C=E=0 the sequence BFDABF leaves all numbers 0 (the most annoying edge case, hardest to find but pretty easy to prove, since two zeros are a lot to work with and do obvious subtracting into 0 or making terms equal) Otherwise WLOG C>0 and make the moves BFAF, from where it's easily seen that the maximum decreases with odd sum. (it's relatively easy to find this one, too) $(Algorithm 2)$ Hence we do this until we get all 0s, applying algorithm 1 if needed. $\blacksquare$

An exercise in WISHFUL THINKING. Not an optimized solution Let the state of the hexagon be $(a,b,c,d,e,f)$. We freely refer to "moves on $a$" and similar terms, which mean what you think they do. Refer to $a+b+c+d+e+f$ as the sum and the parity of the sum as the parity. Finally, use $\equiv$ to mean equivalent modulo $2$. Claim 1: If all our numbers are nonzero at some point and have odd sum, then we can get some of them to equal zero such that no diametrically opposed numbers are both zero, while preserving the odd sum. Proof: If all our numbers are nonzero at some point and the maximum of the numbers is $M$, then $M$ cannot appear as the result of any operation. WLOG suppose that $a=M$. We will decrease the number of times $M$ occurs, while ensuring that we will not generate two diametrically opposed zeroes, and also preserving the fact that the six integers have odd sum, with the following caveat: if, in the middle of one run of the procedure, we generate a zero, then we no longer case about decreasing the number of times $M$ occurs (we still wish to avoid diametrically opposed zeros and preserve the parity). If a single run of the procedure does not involve moving on the same point twice, then any zeroes we generate will still be there. Otherwise, I will specifically explain why our procedure either leaves us with a zero or decreases the occurrences of the maximum. If moving on $a$ preserves the parity of $a$ (removing an occurrence of $M$), then do this and repeat/finish. Otherwise, if we may move on $a$ (removing an occurrence of $M$), and then move on either $b$ or $f$, and find that the parity is preserved, then do this and repeat/finish. Only $f,a,b$ can become zero, so no diametrically opposed zeroes appear. Otherwise, if $a$ is even, then by the first assumption, up to reflection we can uniquely determine $(f,b) \equiv (1,0)$, and then by the second we can uniquely determine $(e,c)\equiv (0,1)$, so then for parity reasons $d \equiv 1$. Then move on $f$, then $a$ (removing an occurrence of $M$), then on $e$, then repeat/finish. This will not generate any diametrically opposed zeroes. Otherwise, if $a$ is odd and $b$ is even, then we must have $f$ even by the first assumption, so then $(e,c) \equiv (0,0)$ as well by the second, and thus $d \equiv 0$ for parity reasons. Then move on $b$ and $f$, then $a$, then $b$ again, then repeat/finish. The first two moves cannot possibly generate zeroes for parity reasons, so we will remove an occurrence of $M$ when moving on $a$, and then after this we no longer care. Since we never move on diametrically opposed points we never generate any diametrically opposed zeroes. On the other hand, if $a$ and $b$ are both odd, then we can similarly get $f \equiv 1$, hence $(e,c) \equiv (1,1)$ and then $d \equiv 0$. It turns out we can still repeat the same order as before: $b$ and $f$, then $a$, then $b$ again, and repeat/finish. This works for the same reason as before. It is clear that this operation cannot be repeated indefinitely, so at some point we must end up with at least one zero, but never any diametrically opposed zeroes. Claim 2: With one zero, WLOG at $a$, and odd sum, we can make $b=c$, $e=f$, $b \not \equiv f$, and preserve odd sum, $a=0$, and $d \neq 0$. Proof: If $c \not \equiv e$, then we can move on $f$ (making it odd, thus nonzero), then $b$, then $f$ and finish. Otherwise, if $d \equiv 0$, then we must have $b \not \equiv f$, so either $b \not \equiv c$ or $e \not \equiv f$; WLOG the former. Then move on $c$, then $d$. If $d \equiv 1$, then first move on $b$ and $f$ to make $b \equiv c \equiv e \equiv f$. Then move on $c$, then $b$, then $f$, which can be seen to work. Claim 3: With one zero, WLOG at $a$, odd sum, and $b=c$, $e=f$ (so $d \equiv 1$ is nonzero), but $b \not \equiv f$, we can either make $b=c=0$ or $e=f=0$. Proof: First move on $d$, so it now equals $|b-f| \equiv 1 \neq 0$. Now WLOG let $b>f$, and move on $c$, $b$, $c$, $b$, after which both $b$ and $c$ now equal $|b-2d|$ (where we use the "starting" value of $b$ but the "post-operation" value of $d$), which is strictly less than $b$ since $d \leq b$. Furthermore, all the conditions are preserved, so eventually we will either reach $b=c=0$ or $e=f=0$, at which point we can skip ahead to claim 6. Claim 4: If we have two diametrically opposed zeroes, odd sum, then we can return to all nonzero values with odd sum (and then apply claim 1). Proof: WLOG let $a=d=0$. Then we cannot have $b \equiv f$ and $c \equiv e$, so WLOG the former is false and additionally that $b \equiv 0$. If $c \equiv d \equiv 0$, then move on $a,f,e,d$, making them all odd, which is fine. Otherwise, $c \equiv d \equiv 1$, so move on $a,e,d,e$, making them all odd, which is also fine. Claim 5: If we have exactly two zeroes which are adjacent, then we can return to one zero and odd sum (and then apply claim 2). Proof: WLOG let the two zeroes be $a$ and $b$. Then if either $f$ is even, we move at $a$, and likewise if $c$ is even we move at $b$. Thus suppose $c \equiv f \equiv 1$. Then one of $d$ or $e$, WLOG $d$, is even. Then move at $c$, which makes it even but nonzero, and then move at $b$, making it nonzero (and even), then at $d$, making it odd. Claim 6: Otherwise (i.e. exactly two zeroes separated by exactly one point, or at least three zeroes), then we can make everything zero. Proof: First, if we have exactly two zeroes separated by exactly one point, then we move on that point and create three zeroes, so assume we have at least three zeroes. For any nonzero value adjacent to two zeroes, move on that value, making it zero. After we do this until we cannot, we are either left with six zeroes, in which case we're just done, or either three or four adjacent zeroes (and no others). In the former case, WLOG let $a=b=c=0$; then move on $d$ and $f$ to make $d=e=f$. In the latter, WLOG let $a=b=c=d=0$. Then move on $f$, then $d$, to make $d=e=f$ as well. Then, given the state $(0,0,0,k,k,k)$, move on $a$ and $c$, making them both equal to $k$, then on $f$ and $d$, making them both $0$, so our state is now $(k,0,k,0,k,0)$, and we win by moving on $a,c,e$. These six claims finish the proof. $\blacksquare$ Remark: The "flow" of the claims is claim 4 -> claim 1, claim 1 -> claim 2/3/5/6, claim 5 -> claim 2, claim 2 -> claim 3, claim 3 -> claim 6. Everything ends up at claim 6 eventually.

We first show that if we reach a configuration where three adjacent vertices are all 0, then we can reach a configuration where all vertices are 0.A move on vertex $V$ is a move where the value at vertex $V$ is replaced by the difference of its neighbours. In all diagrams which follow, the vertices colored in red or those which have a move executed on them, resulting in the successive picture. Simply consider the following moves. [asy][asy] /* Geogebra to Asymptote conversion, documentation at artofproblemsolving.com/Wiki go to User:Azjps/geogebra */ import graph; size(13.cm); real labelscalefactor = 0.5; /* changes label-to-point distance */ pen dps = linewidth(0.7) + fontsize(10); defaultpen(dps); /* default pen style */ pen dotstyle = black; /* point style */ real xmin = 1., xmax = 22., ymin = -8., ymax = -2.; /* image dimensions */ pen zzttqq = rgb(0.6,0.2,0.); draw((3.,-7.)--(5.,-7.)--(6.,-5.267949192431122)--(5.,-3.5358983848622447)--(3.,-3.5358983848622443)--(2.,-5.2679491924311215)--cycle, linewidth(2.) + zzttqq); draw((7.8224165016050815,-7.)--(9.822416501605082,-7.)--(10.822416501605082,-5.267949192431122)--(9.822416501605082,-3.5358983848622447)--(7.822416501605082,-3.5358983848622443)--(6.8224165016050815,-5.2679491924311215)--cycle, linewidth(2.) + zzttqq); draw((13.,-7.)--(15.,-7.)--(16.,-5.267949192431122)--(15.,-3.5358983848622447)--(13.,-3.5358983848622443)--(12.,-5.2679491924311215)--cycle, linewidth(2.) + zzttqq); draw((18.,-7.)--(20.,-7.)--(21.,-5.267949192431122)--(20.,-3.5358983848622447)--(18.,-3.5358983848622443)--(17.,-5.2679491924311215)--cycle, linewidth(2.) + zzttqq); /* draw figures */ draw((3.,-7.)--(5.,-7.), linewidth(2.) + zzttqq); draw((5.,-7.)--(6.,-5.267949192431122), linewidth(2.) + zzttqq); draw((6.,-5.267949192431122)--(5.,-3.5358983848622447), linewidth(2.) + zzttqq); draw((5.,-3.5358983848622447)--(3.,-3.5358983848622443), linewidth(2.) + zzttqq); draw((3.,-3.5358983848622443)--(2.,-5.2679491924311215), linewidth(2.) + zzttqq); draw((2.,-5.2679491924311215)--(3.,-7.), linewidth(2.) + zzttqq); draw((7.8224165016050815,-7.)--(9.822416501605082,-7.), linewidth(2.) + zzttqq); draw((9.822416501605082,-7.)--(10.822416501605082,-5.267949192431122), linewidth(2.) + zzttqq); draw((10.822416501605082,-5.267949192431122)--(9.822416501605082,-3.5358983848622447), linewidth(2.) + zzttqq); draw((9.822416501605082,-3.5358983848622447)--(7.822416501605082,-3.5358983848622443), linewidth(2.) + zzttqq); draw((7.822416501605082,-3.5358983848622443)--(6.8224165016050815,-5.2679491924311215), linewidth(2.) + zzttqq); draw((6.8224165016050815,-5.2679491924311215)--(7.8224165016050815,-7.), linewidth(2.) + zzttqq); draw((13.,-7.)--(15.,-7.), linewidth(2.) + zzttqq); draw((15.,-7.)--(16.,-5.267949192431122), linewidth(2.) + zzttqq); draw((16.,-5.267949192431122)--(15.,-3.5358983848622447), linewidth(2.) + zzttqq); draw((15.,-3.5358983848622447)--(13.,-3.5358983848622443), linewidth(2.) + zzttqq); draw((13.,-3.5358983848622443)--(12.,-5.2679491924311215), linewidth(2.) + zzttqq); draw((12.,-5.2679491924311215)--(13.,-7.), linewidth(2.) + zzttqq); draw((18.,-7.)--(20.,-7.), linewidth(2.) + zzttqq); draw((20.,-7.)--(21.,-5.267949192431122), linewidth(2.) + zzttqq); draw((21.,-5.267949192431122)--(20.,-3.5358983848622447), linewidth(2.) + zzttqq); draw((20.,-3.5358983848622447)--(18.,-3.5358983848622443), linewidth(2.) + zzttqq); draw((18.,-3.5358983848622443)--(17.,-5.2679491924311215), linewidth(2.) + zzttqq); draw((17.,-5.2679491924311215)--(18.,-7.), linewidth(2.) + zzttqq); label("$c$",(6.093284611706853,-4.929590874940235),SE*labelscalefactor,red); label("$b$",(5.027783621337343,-2.989832661703436),SE*labelscalefactor); label("$a$",(2.896781640598323,-2.962512123488833),SE*labelscalefactor,red); label("$0$",(5.178046581517658,-6.760066935318623),SE*labelscalefactor); label("$b$",(9.86351888532204,-3.0034929308107374),SE*labelscalefactor,red); label("$b$",(7.732516904583021,-2.93519158527423),SE*labelscalefactor); label("$b$",(10.970000683013456,-4.929590874940235),SE*labelscalefactor); label("0",(15.204684106276893,-3.331339389385971),SE*labelscalefactor); label("$b$",(12.74583566696264,-3.0034929308107374),SE*labelscalefactor,red); label("$b$",(16.13358240557339,-4.9159306058329335),SE*labelscalefactor,red); label("$0$",(1.653697151833895,-4.88861006761833),SE*labelscalefactor); label("$0$",(2.6099159893449935,-6.691765589782116),SE*labelscalefactor); label("$0$",(6.489432415818594,-4.943251144047536),SE*labelscalefactor); label("$0$",(7.5002923297588975,-6.814708011747828),SE*labelscalefactor); label("$0$",(9.904499692643945,-6.814708011747828),SE*labelscalefactor); label("$0$",(11.653014138378525,-4.943251144047536),SE*labelscalefactor); label("$0$",(12.595572706782322,-6.801047742640527),SE*labelscalefactor); label("$0$",(20.0950604466908,-3.1127750836691486),SE*labelscalefactor); label("$0$",(17.677192814698447,-3.0581340072399428),SE*labelscalefactor); label("$0$",(15.17736356806229,-6.801047742640527),SE*labelscalefactor); label("$0$",(17.69085308380575,-6.760066935318623),SE*labelscalefactor); label("$0$",(16.62535209343624,-4.929590874940235),SE*labelscalefactor); label("$0$",(21.051279284201897,-4.88861006761833),SE*labelscalefactor); label("$0$",(20.040419370261592,-6.883009357284336),SE*labelscalefactor); /* dots and labels */ dot((3.,-7.),dotstyle); dot((5.,-7.),dotstyle); dot((6.,-5.267949192431122),dotstyle); dot((5.,-3.5358983848622447),dotstyle); dot((3.,-3.5358983848622443),dotstyle); dot((2.,-5.2679491924311215),dotstyle); dot((7.8224165016050815,-7.),dotstyle); dot((9.822416501605082,-7.),dotstyle); dot((10.822416501605082,-5.267949192431122),dotstyle); dot((9.822416501605082,-3.5358983848622447),dotstyle); dot((7.822416501605082,-3.5358983848622443),dotstyle); dot((6.8224165016050815,-5.2679491924311215),dotstyle); dot((13.,-7.),dotstyle); dot((15.,-7.),dotstyle); dot((16.,-5.267949192431122),dotstyle); dot((15.,-3.5358983848622447),dotstyle); dot((13.,-3.5358983848622443),dotstyle); dot((12.,-5.2679491924311215),dotstyle); dot((18.,-7.),dotstyle); dot((20.,-7.),dotstyle); dot((21.,-5.267949192431122),dotstyle); dot((20.,-3.5358983848622447),dotstyle); dot((18.,-3.5358983848622443),dotstyle); dot((17.,-5.2679491924311215),dotstyle); clip((xmin,ymin)--(xmin,ymax)--(xmax,ymax)--(xmax,ymin)--cycle); /* end of picture */ [/asy][/asy] Now, consider the two sets of 3 vertices each of the hexagon such that no two vertices of the same set are adjacent to each other (equilateral triangles). Then, by the condition that the sum is odd ($2003^{2003}$), one of these sets must have odd sum. A reduction on $(a,c,e)$ is the following sequence of moves done on such a set of vertices who have the numbers $a\geq c\geq e$ assigned to them. [asy][asy] /* Geogebra to Asymptote conversion, documentation at artofproblemsolving.com/Wiki go to User:Azjps/geogebra */ import graph; size(13.cm); real labelscalefactor = 0.5; /* changes label-to-point distance */ pen dps = linewidth(0.7) + fontsize(10); defaultpen(dps); /* default pen style */ pen dotstyle = black; /* point style */ real xmin = -1., xmax = 24., ymin = -8., ymax = -3.; /* image dimensions */ pen zzttqq = rgb(0.6,0.2,0.); pen ttqqqq = rgb(0.2,0.,0.); draw((3.,-7.)--(5.,-7.)--(6.,-5.267949192431122)--(5.,-3.5358983848622447)--(3.,-3.5358983848622443)--(2.,-5.2679491924311215)--cycle, linewidth(2.) + zzttqq); draw((8.699595656034424,-7.120834642442454)--(10.699595656034424,-7.120834642442454)--(11.699595656034424,-5.388783834873577)--(10.699595656034424,-3.656733027304699)--(8.699595656034424,-3.6567330273046985)--(7.699595656034424,-5.388783834873575)--cycle, linewidth(2.) + zzttqq); draw((14.515606857455086,-7.204904036609521)--(16.51560685745509,-7.204904036609521)--(17.515606857455094,-5.4728532290406395)--(16.51560685745509,-3.7408024214717583)--(14.515606857455086,-3.7408024214717583)--(13.515606857455083,-5.472853229040639)--cycle, linewidth(2.) + zzttqq); draw((20.225599344307078,-7.3415067276825345)--(22.225599344307074,-7.3415067276825345)--(23.225599344307074,-5.609455920113662)--(22.225599344307078,-3.8774051125447864)--(20.22559934430708,-3.877405112544784)--(19.22559934430708,-5.609455920113657)--cycle, linewidth(2.) + zzttqq); /* draw figures */ draw((3.,-7.)--(5.,-7.), linewidth(2.) + zzttqq); draw((5.,-7.)--(6.,-5.267949192431122), linewidth(2.) + zzttqq); draw((6.,-5.267949192431122)--(5.,-3.5358983848622447), linewidth(2.) + zzttqq); draw((5.,-3.5358983848622447)--(3.,-3.5358983848622443), linewidth(2.) + zzttqq); draw((3.,-3.5358983848622443)--(2.,-5.2679491924311215), linewidth(2.) + zzttqq); draw((2.,-5.2679491924311215)--(3.,-7.), linewidth(2.) + zzttqq); label("$c$",(6.257207840994469,-4.943251144047536),SE*labelscalefactor,ttqqqq); label("$b$",(5.0414438904446435,-2.866890239737723),SE*labelscalefactor,red); label("$a$",(2.814820025954514,-2.9488518543815316),SE*labelscalefactor,ttqqqq); label("$d$",(5.20536711973226,-6.8966696263916365),SE*labelscalefactor,red); label("$f$",(1.6536971518338945,-4.88861006761833),W*labelscalefactor,red); label("$e$",(2.58259545113039,-6.787387473533226),SW*labelscalefactor,ttqqqq); draw((3.,-3.5358983848622443)--(3.,-7.), linewidth(2.) + blue); draw((3.,-7.)--(6.,-5.267949192431122), linewidth(2.) + blue); draw((6.,-5.267949192431122)--(3.,-3.5358983848622443), linewidth(2.) + blue); draw((8.699595656034424,-7.120834642442454)--(10.699595656034424,-7.120834642442454), linewidth(2.) + zzttqq); draw((10.699595656034424,-7.120834642442454)--(11.699595656034424,-5.388783834873577), linewidth(2.) + zzttqq); draw((11.699595656034424,-5.388783834873577)--(10.699595656034424,-3.656733027304699), linewidth(2.) + zzttqq); draw((10.699595656034424,-3.656733027304699)--(8.699595656034424,-3.6567330273046985), linewidth(2.) + zzttqq); draw((8.699595656034424,-3.6567330273046985)--(7.699595656034424,-5.388783834873575), linewidth(2.) + zzttqq); draw((7.699595656034424,-5.388783834873575)--(8.699595656034424,-7.120834642442454), linewidth(2.) + zzttqq); label("$c$",(11.953540058739156,-5.07985383512055),SE*labelscalefactor,ttqqqq); label("$a-c$",(10.792417184618536,-3.0034929308107374),SE*labelscalefactor); label("$a$",(8.5111522436992,-3.0171531999180385),SE*labelscalefactor,ttqqqq); label("$c-e$",(10.915359606584248,-7.033272317464651),SE*labelscalefactor); label("$a-e$",(6.84459941260843,-5.0115524895840435),NE*labelscalefactor); label("$e$",(8.183305785123967,-6.8966696263916365),SW*labelscalefactor,red); draw((8.699595656034424,-3.6567330273046985)--(8.699595656034424,-7.120834642442454), linewidth(2.) + blue); draw((8.699595656034424,-7.120834642442454)--(11.699595656034424,-5.388783834873577), linewidth(2.) + blue); draw((11.699595656034424,-5.388783834873577)--(8.699595656034424,-3.6567330273046985), linewidth(2.) + blue); draw((14.515606857455086,-7.204904036609521)--(16.51560685745509,-7.204904036609521), linewidth(2.) + zzttqq); draw((16.51560685745509,-7.204904036609521)--(17.515606857455094,-5.4728532290406395), linewidth(2.) + zzttqq); draw((17.515606857455094,-5.4728532290406395)--(16.51560685745509,-3.7408024214717583), linewidth(2.) + zzttqq); draw((16.51560685745509,-3.7408024214717583)--(14.515606857455086,-3.7408024214717583), linewidth(2.) + zzttqq); draw((14.515606857455086,-3.7408024214717583)--(13.515606857455083,-5.472853229040639), linewidth(2.) + zzttqq); draw((13.515606857455083,-5.472853229040639)--(14.515606857455086,-7.204904036609521), linewidth(2.) + zzttqq); label("$c$",(17.74549416023495,-5.17547571887166),SE*labelscalefactor,ttqqqq); label("$a-c$",(16.543390478792425,-3.0717942763472443),SE*labelscalefactor); label("$a$",(14.180163923229284,-3.12643535277645),SE*labelscalefactor,red); label("$c-e$",(16.59803155522163,-7.279157161396076),SE*labelscalefactor); label("$a-e$",(12.773156205177239,-5.07985383512055),NE*labelscalefactor); label("$a-c$",(13.797676388224845,-7.210855815859569),SE*labelscalefactor); draw((14.515606857455086,-3.7408024214717583)--(14.515606857455086,-7.204904036609521), linewidth(2.) + blue); draw((14.515606857455086,-7.204904036609521)--(17.515606857455094,-5.4728532290406395), linewidth(2.) + blue); draw((17.515606857455094,-5.4728532290406395)--(14.515606857455086,-3.7408024214717583), linewidth(2.) + blue); draw((20.225599344307078,-7.3415067276825345)--(22.225599344307074,-7.3415067276825345), linewidth(2.) + zzttqq); draw((22.225599344307074,-7.3415067276825345)--(23.225599344307074,-5.609455920113662), linewidth(2.) + zzttqq); draw((23.225599344307074,-5.609455920113662)--(22.225599344307078,-3.8774051125447864), linewidth(2.) + zzttqq); draw((22.225599344307078,-3.8774051125447864)--(20.22559934430708,-3.877405112544784), linewidth(2.) + zzttqq); draw((20.22559934430708,-3.877405112544784)--(19.22559934430708,-5.609455920113657), linewidth(2.) + zzttqq); draw((19.22559934430708,-5.609455920113657)--(20.225599344307078,-7.3415067276825345), linewidth(2.) + zzttqq); label("$c$",(23.57842906905265,-5.298418140837373),SE*labelscalefactor,ttqqqq); label("$a-c$",(22.253382965644413,-3.194736698312957),SE*labelscalefactor); label("$c-e$",(19.917476948295874,-3.1674161600983544),SE*labelscalefactor,ttqqqq); label("$c-e$",(22.38998565671743,-7.333798237825282),SE*labelscalefactor); label("$a-e$",(18.31922546274161,-5.230116795300866),NE*labelscalefactor); label("$a-c$",(19.548649682398736,-7.3474585069325835),SE*labelscalefactor); draw((20.22559934430708,-3.877405112544784)--(20.225599344307078,-7.3415067276825345), linewidth(2.) + blue); draw((20.225599344307078,-7.3415067276825345)--(23.225599344307074,-5.609455920113662), linewidth(2.) + blue); draw((23.225599344307074,-5.609455920113662)--(20.22559934430708,-3.877405112544784), linewidth(2.) + blue); /* dots and labels */ dot((3.,-7.),dotstyle); dot((5.,-7.),dotstyle); dot((6.,-5.267949192431122),dotstyle); dot((5.,-3.5358983848622447),dotstyle); dot((3.,-3.5358983848622443),dotstyle); dot((2.,-5.2679491924311215),dotstyle); dot((8.699595656034424,-7.120834642442454),dotstyle); dot((10.699595656034424,-7.120834642442454),dotstyle); dot((11.699595656034424,-5.388783834873577),dotstyle); dot((10.699595656034424,-3.656733027304699),dotstyle); dot((8.699595656034424,-3.6567330273046985),dotstyle); dot((7.699595656034424,-5.388783834873575),dotstyle); dot((14.515606857455086,-7.204904036609521),dotstyle); dot((16.51560685745509,-7.204904036609521),dotstyle); dot((17.515606857455094,-5.4728532290406395),dotstyle); dot((16.51560685745509,-3.7408024214717583),dotstyle); dot((14.515606857455086,-3.7408024214717583),dotstyle); dot((13.515606857455083,-5.472853229040639),dotstyle); dot((20.225599344307078,-7.3415067276825345),dotstyle); dot((22.225599344307074,-7.3415067276825345),dotstyle); dot((23.225599344307074,-5.609455920113662),dotstyle); dot((22.225599344307078,-3.8774051125447864),dotstyle); dot((20.22559934430708,-3.877405112544784),dotstyle); dot((19.22559934430708,-5.609455920113657),dotstyle); clip((xmin,ymin)--(xmin,ymax)--(xmax,ymax)--(xmax,ymin)--cycle); /* end of picture */ [/asy][/asy] Now, we have two cases. Case 1 : $e >0$. Then, $a,c>0$ as well. Now, notice that the sum of the blue equilateral triangle changes as $a+c+e \to a+c-e$. so, the new sum is strictly less than the previous. Further, the change is $(-2e)$ so the new sum must be odd as well. Thus, the sum of the blue equilateral triangle decreases and remains odd. Case 2 : $e=0$. Then, note that we cannot have $a=c$ since $a+c+e$ is odd by definition. Further, if $c=0$, then we can do a move on $d$ to make it 0 and obtain three adjacent zeroes, which we know terminates. Thus, assume $c>0$. Then, the new sum $a+c-e$ is actually equal to the previous sum but, the values at the blue triangle's vertices are now non-zero. This is because $c\neq 0$, $a\ne c$ as established before, and $c\neq e$ since $c\neq 0$. Then, we can implement the reduction again since we are in a setup similar to that of Case 1. Thus, the sum continually decreases until the sum of the vertices in the blue triangle becomes 1. At this point, we are forced to have $c=e=0$ from which point we know we can reach the all zeroes configuration. Thus, we are done.

I do personally think that this problem is easy for P6. Motivation : try to decrease the sum of the integers written and find the following problematic case $(k,k,0,k,k,0)$. Remark it can't be an initial case ( well trivially the problem has to work ), thus conclude parity has something to do with the working algorithm. Another natural monovariant is the maximum. So we just decrease it. I will write a full solution later.

Can we do with induction like this if i will prove that we can reduce the whole sum @IAmTheHazard ?

Just avoid the problematic case

Attachments:

Call a configuration $C$ to be special, if $C = (a_1, \cdots, a_6)$ we have $\sum a_i$ to be odd. Let $M(C)$ denote the maximum element of the configuration $C$ and let $x_k$ denote the operation at $k$th element (replacing $a_k$ with $|a_{k-1}-a_{k+1}|$) where the indices are taken modulo $6$. Call a configuration $C$ to be very special if it has alternating odd and even numbers. Consider the following two algorithms: Algorithm-1: $C$ is special but not very special. Then, consider the following cases: Case-1: $C$ has $5$ odd numbers. Then: $C \equiv (1, 1, 1, 1, 1, 0) \pmod 2$. Performing $x_2, x_4$ leads to very special config. Case-2: $C$ has $3$ odd numbers. Then: either $C \equiv (1, 1, 1, 0, 0, 0) \pmod 2$ or $C \equiv (1, 1, 0, 1, 0, 0) \pmod 2$. For the first sub-case $C \equiv (1, 1, 1, 0, 0, 0) \pmod 2$, performing $x_4, x_5$ leads to Case-1. For second sub-case, $C \equiv (1, 1, 0, 1, 0, 0) \pmod 2$, performing $x_4, x_6$ leads to the first sub-case. Case-3: $C$ has $1$ odd numbers. Then: $C \equiv (1, 0, 0, 0, 0, 0) \pmod 2$. Perform $x_2, x_3$ which leads to Case-2. Algorithm-2: $C$ is very special. Then, consider $C = (a_1, \cdots, a_6) \equiv (1, 0, 1, 0, 1, 0) \pmod 2$. If $a_1 = a_3 = a_5$, then perform $x_2, x_4, x_6$ and then $x_1, x_3, x_5$ to give the final desired config. If $M(C)$ is not an odd number, perform $x_2, x_4, x_6$ sufficient number of times to get the maximum element to be an odd number. Assume that $M(C) \neq a_1$ perform $x_3, x_5$ to get configuration $C'$ with $M(C') < M(C)$, which is to have only one odd number, and to Algorithm-1, Case-3. Proof that the algorithm gives the desired conclusion in finite moves: Note that, in every step of each algorithm, the parity of the numbers in respective configuration is monotonously changing and thus: the algorithms doesn't lead to any dead-lock situation (from where we cant make to the final desired configuration). Since $M(C)$ is mono-variant under each operation (it monotonously changes at the end of Algorithm $2$ every time until it terminates) and along with that, since each element is a non-negative integer in every valid configuration, we must have eventually $M(C) =0$ and we are done.