def create_hypobj(self):
res = Rec()
depfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T,Type):
res.addfield(l,T.create_hypobj())
else: depfields.addfield(l,T)
return ProcessDepFields(depfields,res,self,'hyp')
def create_hypobj(self):
res = Rec()
depfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T,Type):
res.addfield(l,T.create_hypobj())
else: depfields.addfield(l,T)
return ProcessDepFields(depfields,res,self,'hyp')
def create(self):
res = Rec()
depfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T, TypeClass):
res.addfield(l, T.in_poss(self.poss).create())
else:
depfields.addfield(l, T)
return ProcessDepFields(depfields, res, self)
def __init__(self, d={}):
self.comps = Rec()
for item in d.items():
if isinstance(item[1], dict):
self.addfield(item[0], RecType(item[1]))
else:
self.addfield(item[0], item[1])
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [ \
lambda r: isinstance(r, Rec) and RecOfRecType(r,self,self.poss)]
self.poss = ''
def __init__(self, T1, T2):
self.comps = Rec({'domain': T1, 'range': T2})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [lambda f: isinstance(f,Fun) \
and f.domain_type == self.comps.domain \
and self.comps.range.query(f.app(self.comps.domain.create_hypobj()))]
def __init__(self, T):
self.comps = Rec({'base_type': T})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [
lambda l: isinstance(l, list) and forall(l, lambda x: T.query(x))
]
def __init__(self, pred, args):
self.comps = Rec({'pred': pred, 'args': args})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = []
self.witness_types = []
self.poss = ''
def __init__(self, name='', cs={}):
self.name = name
if self.name == '': self.name = gensym('T')
self.comps = Rec(cs)
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = []
def __init__(self, T, a):
self.comps = Rec({'base_type': T, 'obj': a})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [lambda x: x == a and T.query(x),\
lambda x: isinstance(a,LazyObj)\
and show(x) == show(a.eval()) and T.query(x)]
def __init__(self, T1, T2):
self.comps = Rec({'left': T1, 'right': T2})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [lambda a: self.comps.left.in_poss(self.poss).query(a), \
lambda a: self.comps.right.in_poss(self.poss).query(a)]
self.witness_types = []
self.poss = ''
def __init__(self, name=gensym('BT')):
self.name = name
self.comps = Rec({})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = []
self.witness_types = []
self.poss = ''
def __init__(self, list):
self.comps = Rec({'types': list})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = \
[lambda s: isinstance(s,TTRString) \
and len(s.items) == len(self.comps.types) \
and forall([x for x in range(len(self.comps.types))], \
lambda i: self.comps.types[i].in_poss(self.poss).query(s.items[i]))]
self.poss = ''
def __init__(self, T):
self.comps = Rec({'base_type': T})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = \
[lambda s: isinstance(s,TTRString) \
and len(s.items)>0 \
and forall(s.items,
lambda a: self.comps.base_type.in_poss(self.poss).query(a))]
self.poss = ''
def __init__(self, strT):
self.comps = Rec({'base_type': strT})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = \
[lambda s: isinstance(s,TTRString) and s.startswith_recursive(self.comps.base_type)]
# and len(s.items)>0 \
# and forall(s.items,
# lambda a: self.comps.base_type.in_poss(self.poss).query(a))]
self.witness_types = []
self.poss = _M
def __init__(self,d={}):
self.comps = Rec()
for item in d.items():
if isinstance(item[1], dict):
self.addfield(item[0], RecType(item[1]))
else:
self.addfield(item[0], item[1])
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [ \
lambda r: isinstance(r, Rec) and RecOfRecType(r,self,self.poss)]
self.witness_types = []
self.poss = ''
def __init__(self, T):
self.comps = Rec({'base_type': T})
self.witness_conditions = [
lambda a, c, oracle: PNeg(self.comps.base_type.query(a, c, oracle))
]
class RecType(Type):
def __init__(self,d={}):
self.comps = Rec()
for item in d.items():
if isinstance(item[1], dict):
self.addfield(item[0], RecType(item[1]))
else:
self.addfield(item[0], item[1])
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [ \
lambda r: isinstance(r, Rec) and RecOfRecType(r,self,self.poss)]
self.witness_types = []
self.poss = ''
def in_poss(self,poss):
self.poss = poss
return self
def show(self):
s = ""
for kvp in self.comps.__dict__.items():
if s == "":
s = s + kvp[0] + " : "
else:
s = s + ", "+kvp[0] + " : "
if(isinstance(kvp[1], RecType)):
s = s + kvp[1].show()
else:
s = s + show(kvp[1])
return "{"+s+"}"
def to_latex(self,vars):
s = ""
for kvp in self.comps.__dict__.items():
if s == "":
s = s + to_latex(kvp[0]) + " &:& "
else:
s = s + "\\\\\n"+to_latex(kvp[0]) + " &:& "
if(isinstance(kvp[1], RecType)):
s = s + kvp[1].to_latex(vars)
else:
s = s + to_latex(kvp[1],vars)
return "\\left[\\begin{array}{lcl}\n"+s+"\n\\end{array}\\right]"
def validate(self):
if forall(list(self.comps.__dict__.items()),lambda x: CheckField(x,self)) and not self.create_hypobj() == None:
return True
else:
return False
def addfield(self, label, value):
if label in self.comps.__dict__.keys():
print("\"" +label + "\"" + " is already a label in this record type")
else:
self.comps.__setattr__(label, value)
# def pathvalue(self,path):
# if len(path) == 1:
# return self.comps.__getattribute__(str(path[0]))
# else:
# return Rec.pathvalue(self.comps.__getattribute__(path[0]), path[1:])
def pathvalue(self, path):
splits=deque(path.split("."))
if (len(splits) == 1):
if splits[0] in dir(self.comps):
return self.comps.__getattribute__(splits[0])
else:
if ttracing('pathvalue'):
print(splits[0]+' not a label in '+self.show())
return None
else:
addr = splits.popleft()
if 'pathvalue' not in dir(self.comps.__getattribute__(addr)):
if ttracing('pathvalue'):
print('No paths into '+show(self.comps.__getattribute__(addr)))
return None
else:
return self.comps.__getattribute__(addr).pathvalue(".".join(splits))
def learn_witness_condition(self,c):
logtype(self,c)
def learn_witness_type(self,c):
logtype_t(self,c)
def create(self):
res = Rec()
depfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T,Type):
res.addfield(l,T.in_poss(self.poss).create())
else: depfields.addfield(l,T)
return ProcessDepFields(depfields,res,self)
def create_hypobj(self):
res = Rec()
depfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T,Type):
res.addfield(l,T.create_hypobj())
else: depfields.addfield(l,T)
return ProcessDepFields(depfields,res,self,'hyp')
#Recursive for future use??
def Relabel(self, oldlabel, newlabel, recursive=False):
if oldlabel in self.comps.__dict__.keys():
value = self.comps.__dict__[oldlabel]
self.comps.__delattr__(oldlabel)
self.comps.__setattr__(newlabel, value)
return
def subst(self,v,a):
res = RecType()
for l in self.comps.__dict__.keys():
if self.comps.__getattribute__(l) == v:
res.addfield(l,a)
elif isinstance(self.comps.__getattribute__(l),str):
res.addfield(l,self.comps.__getattribute__(l))
else:
res.addfield(l,substitute(self.comps.__getattribute__(l),v,a))
#print(show(res))
return res
def eval(self):
self.comps.eval()
return self
def merge(self,T):
if isinstance(T,RecType):
res = RecType({})
SharedLabels = [l for l in LabelsRecType(self) if l in LabelsRecType(T)]
OtherLabelsSelf = [l for l in LabelsRecType(self) if l not in LabelsRecType(T)]
OtherLabelsT = [l for l in LabelsRecType(T) if l not in LabelsRecType(self)]
for label in SharedLabels:
T1 = AttValRecType(self,label)
T2 = AttValRecType(T,label)
if isinstance(T1, tuple) and isinstance(T2, tuple):
if T1[1] == T2[1]:
f1 = T1[0]
f2 = T2[0]
res.addfield(label, (merge_dep_types(f1,f2),T1[1]))
else:
f1 = T1[0]
f2 = T2[0]
res.addfield(label, (combine_dep_types(f1,f2),T1[1]+T2[1]))
elif isinstance(T1,tuple) and isinstance(T2,Type):
res.addfield(label, (combine_dep_types(T1[0],T2),T1[1]))
elif isinstance(T1,Type) and isinstance(T2,tuple):
res.addfield(label, (combine_dep_types(T1,T2[0]),T2[1]))
else:
res.addfield(label, T1.merge(T2))
for label in OtherLabelsSelf:
res.addfield(label,AttValRecType(self,label))
for label in OtherLabelsT:
res.addfield(label,AttValRecType(T,label))
return res
elif self.subtype_of(T):
return self
else:
return MeetType(self,T)
def amerge(self,T):
if isinstance(T,RecType):
res = RecType({})
SharedLabels = [l for l in LabelsRecType(self) if l in LabelsRecType(T)]
OtherLabelsSelf = [l for l in LabelsRecType(self) if l not in LabelsRecType(T)]
OtherLabelsT = [l for l in LabelsRecType(T) if l not in LabelsRecType(self)]
for label in SharedLabels:
T1 = AttValRecType(self,label)
T2 = AttValRecType(T,label)
if isinstance(T1, tuple) and isinstance(T2, tuple):
if T1[1] == T2[1]:
f1 = T1[0]
f2 = T2[0]
if subtype_of_dep_types(f1,f2):
res.addfield(label, T1)
else:
res.addfield(label, T2)
else:
res.addfield(label, T2)
elif isinstance(T1,tuple) and isinstance(T2,Type):
res.addfield(label, T2)
elif isinstance(T1,Type) and isinstance(T2,tuple):
res.addfield(label,T2)
elif isinstance(T1,Type) and isinstance(T2,Type):
if T1.subtype_of(T2):
res.addfield(label, T1)
else:
res.addfield(label, T1.amerge(T2))
else:
res.addfield(label,T2)
for label in OtherLabelsSelf:
res.addfield(label,AttValRecType(self,label))
for label in OtherLabelsT:
res.addfield(label,AttValRecType(T,label))
return res
elif self.subtype_of(T):
return self
else:
return T
class RecType(Type):
def __init__(self, d={}):
self.comps = Rec()
for item in d.items():
if isinstance(item[1], dict):
self.addfield(item[0], RecType(item[1]))
else:
self.addfield(item[0], item[1])
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [ \
lambda r: isinstance(r, Rec) and RecOfRecType(r,self,self.poss)]
self.witness_types = []
self.poss = ''
def in_poss(self, poss):
self.poss = poss
return self
def show(self):
s = ""
for kvp in self.comps.__dict__.items():
if s == "":
s = s + kvp[0] + " : "
else:
s = s + ", " + kvp[0] + " : "
if (isinstance(kvp[1], RecType)):
s = s + kvp[1].show()
else:
s = s + show(kvp[1])
return "{" + s + "}"
def to_latex(self, vars):
s = ""
for kvp in self.comps.__dict__.items():
if s == "":
s = s + to_latex(kvp[0]) + " &:& "
else:
s = s + "\\\\\n" + to_latex(kvp[0]) + " &:& "
if (isinstance(kvp[1], RecType)):
s = s + kvp[1].to_latex(vars)
else:
s = s + to_latex(kvp[1], vars)
return "\\left[\\begin{array}{lcl}\n" + s + "\n\\end{array}\\right]"
def validate(self):
if forall(list(self.comps.__dict__.items()), lambda x: CheckField(
x, self)) and not self.create_hypobj() == None:
return True
else:
return False
def addfield(self, label, value):
if label in self.comps.__dict__.keys():
print("\"" + label + "\"" +
" is already a label in this record type")
else:
self.comps.__setattr__(label, value)
# def pathvalue(self,path):
# if len(path) == 1:
# return self.comps.__getattribute__(str(path[0]))
# else:
# return Rec.pathvalue(self.comps.__getattribute__(path[0]), path[1:])
def pathvalue(self, path):
splits = deque(path.split("."))
if (len(splits) == 1):
if splits[0] in dir(self.comps):
return self.comps.__getattribute__(splits[0])
else:
if ttracing('pathvalue'):
print(splits[0] + ' not a label in ' + self.show())
return None
else:
addr = splits.popleft()
if 'pathvalue' not in dir(self.comps.__getattribute__(addr)):
if ttracing('pathvalue'):
print('No paths into ' +
show(self.comps.__getattribute__(addr)))
return None
else:
return self.comps.__getattribute__(addr).pathvalue(
".".join(splits))
def learn_witness_condition(self, c):
logtype(self, c)
def learn_witness_type(self, c):
logtype_t(self, c)
def create(self):
res = Rec()
depfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T, Type):
res.addfield(l, T.in_poss(self.poss).create())
else:
depfields.addfield(l, T)
return ProcessDepFields(depfields, res, self)
def create_hypobj(self):
res = Rec()
depfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T, Type):
res.addfield(l, T.create_hypobj())
else:
depfields.addfield(l, T)
return ProcessDepFields(depfields, res, self, 'hyp')
#Recursive for future use??
def Relabel(self, oldlabel, newlabel, recursive=False):
if oldlabel in self.comps.__dict__.keys():
value = self.comps.__dict__[oldlabel]
self.comps.__delattr__(oldlabel)
self.comps.__setattr__(newlabel, value)
return
def subst(self, v, a):
res = RecType()
for l in self.comps.__dict__.keys():
if self.comps.__getattribute__(l) == v:
res.addfield(l, a)
elif isinstance(self.comps.__getattribute__(l), str):
res.addfield(l, self.comps.__getattribute__(l))
else:
res.addfield(l, substitute(self.comps.__getattribute__(l), v,
a))
#print(show(res))
return res
def eval(self):
self.comps.eval()
return self
def merge(self, T):
if isinstance(T, RecType):
res = RecType({})
SharedLabels = [
l for l in LabelsRecType(self) if l in LabelsRecType(T)
]
OtherLabelsSelf = [
l for l in LabelsRecType(self) if l not in LabelsRecType(T)
]
OtherLabelsT = [
l for l in LabelsRecType(T) if l not in LabelsRecType(self)
]
for label in SharedLabels:
T1 = AttValRecType(self, label)
T2 = AttValRecType(T, label)
if isinstance(T1, tuple) and isinstance(T2, tuple):
if T1[1] == T2[1]:
f1 = T1[0]
f2 = T2[0]
res.addfield(label, (merge_dep_types(f1, f2), T1[1]))
else:
f1 = T1[0]
f2 = T2[0]
res.addfield(
label, (combine_dep_types(f1, f2), T1[1] + T2[1]))
elif isinstance(T1, tuple) and isinstance(T2, Type):
res.addfield(label, (combine_dep_types(T1[0], T2), T1[1]))
elif isinstance(T1, Type) and isinstance(T2, tuple):
res.addfield(label, (combine_dep_types(T1, T2[0]), T2[1]))
else:
res.addfield(label, T1.merge(T2))
for label in OtherLabelsSelf:
res.addfield(label, AttValRecType(self, label))
for label in OtherLabelsT:
res.addfield(label, AttValRecType(T, label))
return res
elif self.subtype_of(T):
return self
else:
return MeetType(self, T)
def amerge(self, T):
if isinstance(T, RecType):
res = RecType({})
SharedLabels = [
l for l in LabelsRecType(self) if l in LabelsRecType(T)
]
OtherLabelsSelf = [
l for l in LabelsRecType(self) if l not in LabelsRecType(T)
]
OtherLabelsT = [
l for l in LabelsRecType(T) if l not in LabelsRecType(self)
]
for label in SharedLabels:
T1 = AttValRecType(self, label)
T2 = AttValRecType(T, label)
if isinstance(T1, tuple) and isinstance(T2, tuple):
if T1[1] == T2[1]:
f1 = T1[0]
f2 = T2[0]
if subtype_of_dep_types(f1, f2):
res.addfield(label, T1)
else:
res.addfield(label, T2)
else:
res.addfield(label, T2)
elif isinstance(T1, tuple) and isinstance(T2, Type):
res.addfield(label, T2)
elif isinstance(T1, Type) and isinstance(T2, tuple):
res.addfield(label, T2)
elif isinstance(T1, Type) and isinstance(T2, Type):
if T1.subtype_of(T2):
res.addfield(label, T1)
else:
res.addfield(label, T1.amerge(T2))
else:
res.addfield(label, T2)
for label in OtherLabelsSelf:
res.addfield(label, AttValRecType(self, label))
for label in OtherLabelsT:
res.addfield(label, AttValRecType(T, label))
return res
elif self.subtype_of(T):
return self
else:
return T
"""
Created on Tue Mar 3 15:05:58 2015
@author: cooper
"""
from records import Rec
from utils import show
r = Rec({
'f': {
'f': {
'ff': 'a',
'gg': 'b'
},
'g': 'c'
},
'g': {
'h': {
'g': 'a',
'h': 'd'
}
}
})
print(show(r))
print(show(r.f))
print(show(r.g.h))
print(show(r.f.f.ff))
print(show(r.subst('a', 'z')))
def __init__(self, T1, T2):
self.comps = Rec({'left': T1, 'right': T2})
self.witness_cache = []
self.supertype_cache = []
self.witness_conditions = [lambda a: self.comps.left.query(a) \
and self.comps.right.query(a)]
print(show(Fun('x', Ind, PType(man, ['x'])).app('j')))
print(show(manj))
print(manj.query_nonspec())
M = Possibility('M')
manj.in_poss(M)
print(Fun('x', Ind, PType(man, ['x'])).app('j').in_poss(M).query_nonspec())
print(show(M))
print(Ty.query(RecType({'x': Ind})))
print(RecType({'x': Ind}).query(Rec({'x': 'j'})))
print(RecType({'x': Ind}).query(Rec({'x': 'j', 'y': 'k', 'z': 'e1'})))
print(RecType({'x': Ind, 'y': Ind}).query(Rec({'x': 'j'}))) #False
print(
RecTy.query(
RecType({
'x': Ind,
'c': (Fun('v', Ind, PType(man, ['v'])), ['x'])
})))
T_man = RecType({'x': Ind, 'c': (Fun('v', Ind, PType(man, ['v'])), ['x'])})
print(T_man.query(Rec({'x': 'j', 'c': '_e1'})))
def sample(self, n=config.sample_size):
chart = {}
count = -1
nondepfields = RecType()
for l in self.comps.__dict__:
T = self.comps.__getattribute__(l)
if isinstance(T, RecType):
count = count + 1
chart[count] = []
vals = T.in_poss(self.poss).sample(n)
#print(show(T.in_poss(self.poss)))
#print(vals)
if count == 0:
for r in vals:
chart[count].append(Rec({l: r}))
#print(chart)
else:
for r in vals:
for rec in chart[count - 1]:
combrec = rec.addrec(Rec({l: r}))
if combrec:
chart[count].append(combrec)
else:
pass
elif isinstance(T, TypeClass):
nondepfields.addfield(l, T)
else:
count = count + 1
chart[count] = []
matches = T[0].matches(self.poss, n)
#print('matches: ', show(matches))
for m in matches:
for s in m[0].in_poss(self.poss).sample(n):
r = Rec({l: s})
#print('r: ',show(r))
#print('T[1]',show(T[1]))
for p in T[1]:
newrec = Rec({})
newrec.addpath(p, m[1][T[1].index(p)])
#print('newrec:',show(newrec))
r = r.addrec(newrec)
#print('r after addrec: ',show(r))
if count == 0:
chart[count].append(r)
else:
for rec in chart[count - 1]:
combrec = rec.addrec(r)
if combrec:
chart[count].append(combrec)
count = count + 1
chart[count] = []
#print(show(nondepfields))
if count == 0:
newrecs = []
for l in nondepfields.comps.__dict__:
matches = nondepfields.comps.__getattribute__(l).in_poss(
self.poss).sample(n)
if newrecs == []:
for i in range(2 * n):
m = np.random.choice(matches)
newrecs.append(Rec({l: m}))
else:
for i in range(len(newrecs)):
m = np.random.choice(matches)
newrecs[i] = newrecs[i].addrec(Rec({l: m}))
for r in newrecs:
chart[count].append(r)
else:
for rec in chart[count - 1]:
#print([l for l in rec.__dict__],[l for l in nondepfields.comps.__dict__])
if set([l for l in nondepfields.comps.__dict__
]).issubset(set([l for l in rec.__dict__])):
chart[count].append(rec)
else:
newrecs = []
for l in [
l for l in nondepfields.comps.__dict__
if not l in rec.__dict__
]:
matches = nondepfields.comps.__getattribute__(
l).in_poss(self.poss).sample(n)
if newrecs == []:
for i in range(2 * n):
m = np.random.choice(matches)
newrecs.append(Rec({l: m}))
# for m in matches:
# newrecs.append(Rec({l:m}))
else:
for i in range(len(newrecs)):
m = np.random.choice(matches)
newrecs[i] = newrecs[i].addrec(Rec({l: m}))
# for r in newrecs:
# m = np.random.choice(matches)
# r.addrec(Rec({l:m}))
for r in newrecs:
chart[count].append(rec.addrec(r))
#print(show(chart))
res = []
for r in chart[count]:
if not any(map(lambda x: equal(x, r), res)):
res.append(r)
if len(res) <= n:
return res
else:
return list(np.random.choice(res, n, False))
