In [1]:
from itertools import repeat
from sympy import *
#from type_system import *
In [2]:
%run ../../src/commons.py
In [3]:
%run ./type-system.py
In [4]:
init_printing()
In [5]:
x,y,m,n,t,z = symbols('x y m n t z', commutative=True)
alpha, beta, gamma, eta = symbols(r'\alpha \beta \gamma \eta', commutative=True)
f,g = Function('f'), Function('g')
In [17]:
((1/(1-w[0]*z))*(1/(1-w[1]*z))).diff(z).series(z, n=6)
Out[17]:
In [7]:
define(f(z), z/((1-z)**2),ctor=FEq).series(z,n=10)
Out[7]:
In [8]:
define(f(z), 1/(1-alpha*z), ctor=FEq).series(z,n=10)
Out[8]:
In [9]:
define(f(z), 1/(1-(u[0]+u[1])*z), ctor=FEq).series(z,n=4)
Out[9]:
In [10]:
define(f(z), 1/(1-(o[0]+o[1])*z), ctor=FEq).series(z,n=4)
Out[10]:
In [14]:
define(f(z), z*(1/(1-z))*(1/(1-z)), ctor=FEq).series(z,n=10)
Out[14]:
In [15]:
define(f(z), z**3,ctor=FEq).series(z, n=10, kernel='exponential')
Out[15]:
In [16]:
define(f(z), exp(z),ctor=FEq).series(z, n=10, kernel='exponential')
Out[16]:
In [11]:
define(f(z), z*exp(z), ctor=FEq).series(z, n=10, kernel='exponential')
Out[11]:
In [13]:
define(f(z), z**2*exp(z)/factorial(2,evaluate=False),
ctor=FEq).series(z, n=10, kernel='exponential')
Out[13]:
In [14]:
define(f(z), z**3*exp(z)/factorial(3, evaluate=False),
ctor=FEq).series(z, n=10, kernel='exponential')
Out[14]:
In [15]:
define(f(z), (exp(z)+exp(-z))/2, ctor=FEq).series(z, n=20, kernel='exponential')
Out[15]:
In [16]:
define(f(z), exp(m*z), ctor=FEq).series(z, n=10, kernel='exponential')
Out[16]:
In [17]:
define(f(z), (exp(z)-1)/z, ctor=FEq).series(z, n=10, kernel='exponential')
Out[17]:
In [18]:
define(f(z), 1/(1-z), ctor=FEq).series(z, n=10, kernel='exponential')
Out[18]:
In [19]:
define(f(z), (1/(1-z))*(1/(1-z)), ctor=FEq).series(z, n=10, kernel='exponential')
Out[19]:
In [20]:
define(f(z), exp(z)**2, ctor=FEq).series(z, n=10, kernel='exponential')
Out[20]:
In [7]:
tyvar(x).gf()
Out[7]:
In [8]:
(tyvar(u[0]) * tyvar(u[1]) * tyvar(u[2])).gf()
Out[8]:
In [9]:
(tyvar(o[0]) * tyvar(o[1]) * tyvar(o[2])).gf()
Out[9]:
In [10]:
(tyvar(u[0]) | tyvar(u[1]) | tyvar(u[2])).gf()
Out[10]:
In [18]:
(tyvar(o[0]) | tyvar(o[1]) | tyvar(o[2])).gf()
Out[18]:
In [19]:
truth.gf() + falsehood.gf()
Out[19]:
In [20]:
boolean.gf()
Out[20]:
In [21]:
maybe(tyvar(alpha)[z]).gf()
Out[21]:
In [22]:
nel = 4
syms=[u[i] for i in range(nel)]
occ_prb, = cp(maybe(tyvar(u[i]*z)) for i in range(nel)).gf() # here we can use the `[z]` notation too.
occ_prb
Out[22]:
In [23]:
occupancy(occ_prb, syms, objects='unlike', boxes='unlike').series(z)
Out[23]:
In [8]:
occupancy(occ_prb, syms, objects='unlike', boxes='like').series(z)
Out[8]:
In [9]:
occupancy(occ_prb, syms, objects='like', boxes='unlike').series(z)
Out[9]:
In [10]:
occupancy(occ_prb, syms, objects='like', boxes='like').series(z)
Out[10]:
In [26]:
u_hat = symbols(r'␣_0:10')
nel = 3
occ_prb, = cp(tyvar(z*(sum(u[j] for j in range(nel) if j != i))) | tyvar(u_hat[i])
for i in range(nel)).gf()
occ_prb
Out[26]:
In [27]:
syms=[u[i] for i in range(nel)]+[u_hat[i] for i in range(nel)]
occupancy(occ_prb, syms, objects='unlike', boxes='unlike').series(z)
Out[27]:
In [28]:
occupancy(occ_prb, syms, objects='unlike', boxes='like').series(z)
Out[28]:
In [29]:
occupancy(occ_prb, syms, objects='like', boxes='unlike').series(z)
Out[29]:
In [30]:
occupancy(occ_prb, syms, objects='like', boxes='like').series(z)
Out[30]:
In [31]:
occupancy_problem, = cp(maybe(du(tyvar((u[i]*z)**(j+1)) for j in range(i+1)))
for i in range(3)).gf()
occupancy_problem
Out[31]:
In [32]:
occupancy(occupancy_problem, syms=[u[i] for i in range(3)], objects='unlike', boxes='unlike').series(z)
Out[32]:
In [33]:
occupancy(occupancy_problem, syms=[u[i] for i in range(3)], objects='unlike', boxes='like').series(z)
Out[33]:
In [34]:
occupancy(occupancy_problem, syms=[u[i] for i in range(3)], objects='like', boxes='unlike').series(z)
Out[34]:
In [35]:
occupancy(occupancy_problem, syms=[u[i] for i in range(3)], objects='like', boxes='like').series(z)
Out[35]:
In [36]:
((1+t)*(1+t+t**2)*(1+t+t**2+t**3)).series(t,n=10) # just for checking
Out[36]:
In [34]:
def sums_of_powers(boxes, base):
p = IndexedBase('\space')
return cp(cp() | tyvar(p[j]*z**(base**i))
for i in range(0,boxes)
for j in [Pow(base,i,evaluate=False)] # implicit let
).gf()
In [35]:
occupancy, = sums_of_powers(boxes=4, base=2)
occupancy.series(z, n=32)
Out[35]:
In [36]:
occupancy, = sums_of_powers(boxes=4, base=3)
occupancy.series(z, n=100)
Out[36]:
In [37]:
occupancy, = sums_of_powers(boxes=4, base=5)
occupancy.series(z, n=200)
Out[37]:
In [38]:
occupancy, = sums_of_powers(boxes=4, base=7)
occupancy.series(z, n=500)
Out[38]:
In [39]:
assert 393 == 7**0 + 7**2 + 7**3 # _.rhs.rhs.coeff(z, 393)
In [119]:
difference = (cp() | tyvar(-gamma*z))
ones = nats * difference
ones_gf, = ones.gf()
ones_gf
Out[119]:
In [121]:
ones_gf(z,1,1,1).series(z, n=10) # check!
Out[121]:
In [123]:
one_gf, = (ones * difference).gf()
one_gf.series(z, n=10).rhs.rhs.subs({w[0]:1, w[1]:1, gamma:1})
Out[123]:
In [6]:
l = IndexedBase(r'\circ')
def linear_comb_of_powers(boxes, base):
return cp(lst(tyvar(Mul(l[j], z**(base**i), evaluate=False)))
for i in range(boxes)
for j in [Pow(base,i,evaluate=False)]).gf()
In [7]:
occupancy, = linear_comb_of_powers(boxes=4, base=Integer(2))
occupancy.series(z, n=8)
Out[7]:
In [59]:
occupancy, = linear_comb_of_powers(boxes=4, base=3)
occupancy.series(z, n=9)
Out[59]:
In [60]:
occupancy, = linear_comb_of_powers(boxes=4, base=5)
occupancy.series(z, n=10)
Out[60]:
In [399]:
def uniform_rv(n):
return tyvar(S(1)/nel) * lst(tyvar(x))
occupancy, = uniform_rv(n=10).gf()
occupancy.series(x,n=10)
Out[399]:
In [394]:
class lst_structure_w(rec):
def definition(self, alpha):
me = self.me()
return alpha | lst(me)
def label(self):
return r'\mathcal{L}_{w}' # `_s` stands for "structure"
In [193]:
lst_structure_w(tyvar(alpha)).gf()
Out[193]:
In [194]:
[gf.series(alpha) for gf in _]
Out[194]:
In [8]:
class lst_structure(rec):
def definition(self, alpha):
me = self.me()
return alpha | (lst(me) * me * me)
def label(self):
return r'\mathcal{L}_{s}' # `_s` stands for "structure"
In [9]:
lst_structure(tyvar(alpha)).gf()
Out[9]:
In [10]:
_[0].series(alpha, n=10)
Out[10]:
In [13]:
class structure(rec):
def definition(self, alpha):
me = self.me()
return alpha | (bin_tree(me) * me * me)
def label(self):
return r'\mathcal{S}'
In [16]:
structure(tyvar(alpha)).gf()
Out[16]:
In [17]:
gf = _[0]
In [33]:
gf.simplify()
Out[33]:
In [37]:
nel = 7
s = gf.simplify().series(alpha, n=nel).rhs.rhs
[s.coeff(alpha, n=i).subs({pow(-1,S(1)/3):-1}).radsimp().powsimp() for i in range(nel)]
Out[37]:
In [48]:
class structure(rec):
def definition(self, alpha):
me = self.me()
return alpha | (nnbin_tree(me) * me)
def label(self):
return r'\mathcal{S}'
In [49]:
structure(tyvar(alpha)).gf()
Out[49]:
In [50]:
gf = _[0]
In [51]:
gf.simplify()
Out[51]:
In [45]:
nel = 20
s = gf.simplify().series(alpha, n=nel).rhs.rhs
[s.coeff(alpha, n=i).subs({pow(-1,S(1)/3):-1}).radsimp().powsimp() for i in range(nel)]
Out[45]:
In [52]:
class nn_structure(rec):
def definition(self, alpha):
me = self.me()
return alpha * bin_tree(nnbin_tree(me))
def label(self):
return r'\mathcal{L}_{s}^{+}' # `_s` stands for "structure"
In [ ]:
nn_structure(tyvar(alpha)).gf()
In [202]:
_[0].series(alpha, n=10)
Out[202]:
In [199]:
class nnlst_structure(rec):
def definition(self, alpha):
me = self.me()
return alpha * lst(nnlst(me))
def label(self):
return r'\mathcal{L}_{s}^{+}' # `_s` stands for "structure"
In [201]:
nnlst_structure(tyvar(alpha)).gf()
Out[201]:
In [202]:
_[0].series(alpha, n=10)
Out[202]:
In [203]:
class tree(rec):
def definition(self, alpha):
return alpha * lst(self.me())
def label(self):
return r'\mathcal{T}'
In [204]:
tree(tyvar(alpha)).gf()
Out[204]:
In [205]:
_[0].series(alpha, n=10)
Out[205]:
In [206]:
class combination(rec):
def definition(self, alpha):
me = self.me()
return alpha | (me * me)
def label(self):
return r'\mathcal{C}'
In [209]:
combination(tyvar(alpha)).gf()
Out[209]:
In [210]:
_[0].series(alpha, n=10)
Out[210]:
In [211]:
class ab_tree(rec):
def definition(self, alpha, beta):
me = self.me()
return beta | (alpha * me * me)
def label(self):
return r'\mathcal{T}_{a,b}'
In [212]:
ab_tree_gfs = ab_tree(tyvar(alpha), tyvar(beta)).gf()
ab_tree_gfs
Out[212]:
In [213]:
ab_tree_gf = ab_tree_gfs[0]
In [214]:
fab_eq = FEq(ab_tree_gf.lhs, ab_tree_gf.rhs.series(beta, n=20).removeO(), evaluate=False)
fab_eq
Out[214]:
In [215]:
fab_eq(x,x)
Out[215]:
In [216]:
(_*alpha).expand()
Out[216]:
In [217]:
#with lift_to_Lambda(fab_eq) as F:
B = fab_eq(x,1)
A = fab_eq(1,x)
A,B,
Out[217]:
In [218]:
(A+B).expand()
Out[218]:
In [219]:
((1+x)*A).expand()
Out[219]:
In [223]:
class dyck(rec):
def definition(self, alpha, beta):
me = self.me()
return cp() | (alpha * me * beta * me)
def label(self):
return r'\mathcal{D}'
In [225]:
dyck_gfs = dyck(tyvar(alpha*x), tyvar(beta*x)).gf()
dyck_gfs
Out[225]:
In [226]:
dyck_gf = dyck_gfs[0]
In [229]:
dyck_gf.series(x,n=10)
Out[229]:
In [233]:
class motzkin(rec):
def definition(self, alpha, beta, gamma):
me = self.me()
return cp() | (alpha * me * beta * me) | (gamma * me)
def label(self):
return r'\mathcal{M}'
In [235]:
motzkin_gfs = motzkin(tyvar(alpha*x), tyvar(beta*x), tyvar(gamma*x),).gf()
motzkin_gfs
Out[235]:
In [236]:
motzkin_gf = motzkin_gfs[0]
In [237]:
motzkin_gf.series(x,n=10)
Out[237]:
In [238]:
motzkin_gf(x,1,1,1).series(x,n=10)
Out[238]:
In [294]:
class motzkin_p(rec):
def definition(self, alpha, beta, gamma, eta):
me = self.me()
return cp() | (alpha * me * beta * me) | (gamma * me) | (eta * me)
def label(self):
return r'\mathcal{M}^{+}'
In [295]:
motzkinp_gfs = motzkin_p(tyvar(alpha*x), tyvar(beta*x), tyvar(gamma*x), tyvar(eta*x),).gf()
motzkinp_gfs
Out[295]:
In [298]:
motzkinp_gf = motzkinp_gfs[0]
In [300]:
motzkinp_gf.series(x,n=6)
Out[300]:
In [301]:
motzkinp_gf(x,1,1,1,1).series(x,n=10)
Out[301]:
In [245]:
class fibo(rec):
def definition(self, alpha, beta):
me = self.me()
return cp() | alpha | ((beta | (alpha * beta)) * me)
def label(self):
return r'\mathcal{F}'
In [248]:
fibo_gf, = fibo(tyvar(alpha*x), tyvar(beta*x),).gf()
fibo_gf
Out[248]:
In [249]:
fibo_gf.series(x,n=10)
Out[249]:
In [250]:
fibo_gf(1,x,1).series(x,n=10)
Out[250]:
In [512]:
lst_of_truth_gf, = lst(tyvar(x)).gf()
lst_of_truth_gf.series(x, n=10, is_exp=True)
Out[512]:
In [520]:
lst_of_boolean_gf.series(x,n=10,is_exp=True)
Out[520]:
In [515]:
_.rhs.rhs.subs({w[0]:1,w[1]:1})
Out[515]:
In [521]:
sum((_.rhs.rhs.coeff(x,i)/factorial(i))*x**i for i in range(1,10))
Out[521]:
In [17]:
class powerset(ty):
def gf_rhs(self, ty):
return [exp(self.mulfactor() * gf.rhs) for gf in ty.gf()]
def mulfactor(self):
return 1
def label(self):
return r'\mathcal{P}'
In [478]:
powerset_of_tyvar_gf, = (2**(nnlst(tyvar(alpha)))).gf()
powerset_of_tyvar_gf
Out[478]:
In [479]:
powerset_of_tyvar_gf.series(alpha, n=10, is_exp=True)
Out[479]:
In [480]:
powerset_of_tyvar_gf, = (2**(nnlst(boolean))).gf()
powerset_of_tyvar_gf
Out[480]:
In [481]:
powerset_of_tyvar_gf.series(x, n=5, is_exp=True)
Out[481]:
In [421]:
_.rhs.rhs.subs({w[0]:1,w[1]:1})
Out[421]:
In [273]:
powerset_of_tyvar_gf, _ = (2**(bin_tree(tyvar(alpha)))).gf()
powerset_of_tyvar_gf
Out[273]:
In [274]:
powerset_of_tyvar_gf.series(alpha, n=10, is_exp=True)
Out[274]:
In [288]:
l, = (2**(2**(nnlst(tyvar(alpha))))).gf()
define(l.lhs, l.rhs.ratsimp(), ctor=FEq).series(alpha,n=8,is_exp=True)
Out[288]:
In [494]:
class cycle(ty):
def gf_rhs(self, ty):
return [log(gf.rhs) for gf in ty.gf()]
def label(self):
return r'\mathcal{C}'
In [501]:
cycle_of_tyvar_gf, = (~(lst(tyvar(alpha)))).gf()
cycle_of_tyvar_gf
Out[501]:
In [502]:
cycle_of_tyvar_gf.series(alpha, n=10, is_exp=True)
Out[502]:
In [506]:
cycle_of_tyvar_gf, = (~(lst(boolean))).gf()
cycle_of_tyvar_gf
Out[506]:
In [507]:
cycle_of_tyvar_gf.series(x, n=8, is_exp=True)
Out[507]:
In [508]:
_.rhs.rhs.subs({w[0]:1,w[1]:1})
Out[508]:
In [524]:
Pstar_gf, = (2**(~(lst(tyvar(alpha))))).gf()
Pstar_gf.series(alpha, n=10, is_exp=True)
Out[524]:
In [542]:
class ipowerset(powerset):
def mulfactor(self):
return -1
In [545]:
derangements_gf, = ((-2)**tyvar(alpha)).gf()
derangements_gf.series(alpha, n=10, is_exp=True)
Out[545]:
In [549]:
derangements_gf, = ((-2)**nnlst(tyvar(alpha))).gf()
derangements_gf.series(alpha, n=10, is_exp=True)
Out[549]:
In [38]:
[1,2][1:]
Out[38]:
In [45]:
def foldr(f, l, i):
if not l:
return i
else:
car, *cdr = l
return f(car, foldr(f, cdr, i))
class arrow(ty):
def label(self):
return r'\rightarrow'
def gf_rhs(self, alpha, beta):
v = Dummy()
return [foldr(lambda gf, acc: Lambda([x], acc(gf.rhs)),
gfs[:-1],
Lambda([x], gfs[-1].rhs))(x)
for gfs in self.gfs_space()]
return [foldr(lambda gf, acc: acc**gf.rhs, gfs[:-1], gfs[-1].rhs)
for gfs in self.gfs_space()]
In [46]:
arr, = arrow(boolean, boolean).gf()
arr
Out[46]:
In [49]:
arr.series(x,n=5,is_exp=False)
Out[49]:
In [50]:
_.rhs.rhs.removeO().subs({w[0]:1,w[1]:1})
Out[50]:
In [51]:
arr, = arrow(lst(boolean), lst(boolean)).gf()
arr
Out[51]:
In [56]:
arr.series(x,n=5,is_exp=False)
Out[56]:
In [57]:
_.rhs.rhs.removeO().subs({w[0]:1,w[1]:1})
Out[57]:
In [293]:
lamda_gf = lamda(tyvar(x)).gf_rhs(tyvar(x))
lamda_gf
Out[293]:
In [112]:
lamda_gf.rhs.series(x,n=10)
Out[112]:
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.