It is ok to post!
# Name:Treasa Bency Biju Jose
# Date: 09-13-2020
# Assignment #2

I.
# F(a,b,c) = G(a,b,c) FOR all a,b,c >= 0
# INITIAL CONDITIONS F(a,b,c) = F(a-1,b,c) + F(a,b-1,c) + F(a,b,c-1)
# G(a,b,c) = (a+b+c)! / (a!*b!*c!)
# G(a,b,c) = G(a-1,b,c) + G(a,b-1,c) + G(a,b,c-1)
# 1 = G(a-1,b,c)/G(a,b,c) + G(a,b-1,c)/G(a,b,c) + G(a,b,c-1)/G(a,b,c)
# solving them equates to 1
# Hence proved!


Verified using MAPLE:
G := (a, b, c) -> (a + b + c)!/(a!*b!*c!);
G := proc (a, b, c) options operator, arrow; factorial(a+b+c)/(f\

  actorial(a)*factorial(b)*factorial(c)) end proc



1 = G(a - 1, b, c)/G(a, b, c) + G(a, b - 1, c)/G(a, b, c) + G(a, b, c - 1)/G(a, b, c);
               factorial(a - 1 + b + c) factorial(a)
           1 = -------------------------------------
               factorial(a - 1) factorial(a + b + c)

                factorial(a - 1 + b + c) factorial(b)
              + -------------------------------------
                factorial(b - 1) factorial(a + b + c)

                factorial(a - 1 + b + c) factorial(c)
              + -------------------------------------
                factorial(c - 1) factorial(a + b + c)


simplify(G(a - 1, b, c)/G(a, b, c));
                               a    
                           ---------
                           a + b + c

simplify(G(a, b - 1, c)/G(a, b, c));
                               b    
                           ---------
                           a + b + c

simplify(G(a, b, c - 1)/G(a, b, c));
                               c    
                           ---------
                           a + b + c

`%%%` + `%%` + %;
                   a           b           c    
               --------- + --------- + ---------
               a + b + c   a + b + c   a + b + c

simplify(%);
                               1



II.

Both k-dimensional Manhattan lattice from [0,0...,0] to [a[1], ..., a[k]] 
and the number of words in the "alphabet" {1,2,...k} with the letter i showing up exactly a[i] times (i=1..k) are counting problems, 
and so they use the same general formula. 


III. 
# The number of words in the "alphabet" {1,2,...k} with the letter i showing up exactly a[i] times (i=1..k) is given by
# (a[1]+...+a[k])!/(a[1]!*...*a[k]!)
# Assuming k=3
# G:= (a1,a2,a3)-G(a1-1,a2,a3)-G(a1,a2-1,a3)-G(a1,a2,a3-1) = 0
G3 := (a1, a2, a3) -> (a1 + a2 + a3)!/(a1!*a2!*a3!);
G3 := proc (a1, a2, a3) options operator, arrow; factorial(a1+a2\

  +a3)/(factorial(a1)*factorial(a2)*factorial(a3)) end proc


simplify(G3(a1, a2, a3) - G3(a1 - 1, a2, a3) - G3(a1, a2 - 1, a3) - G3(a1, a2, a3 - 1));
                               0

G4 := (a1, a2, a3, a4) -> (a1 + a2 + a3 + a4)!/(a1!*a2!*a3!*a4!);
G4 := proc (a1, a2, a3, a4) options operator, arrow; 

   factorial(a1+a2+a3+a4)/(factorial(a1)*factorial(a2)*factorial\

  (a3)*factorial(a4)) end proc


simplify(G4(a1, a2, a3, a4) - G4(a1 - 1, a2, a3, a4) - G4(a1, a2 - 1, a3, a4) - G4(a1, a2, a3 - 1, a4) - G4(a1, a2, a3, a4 - 1));
                               0


Hence proved!