def recur(level, values_flag):
		values, flag_v = values_flag
		#assert values in trees_values[level]
		if level == 1:
			if values == (0,) * len(values):
				yield Const(0)
			if values == (1,) * len(values):
				yield Const(1)
			if values == tuple(keys):
				yield Var()
			return
		remain = level - 1
		for op in ops:
			ar = get_arity(op)
			if ar == 1:
				for (prev_value, flag) in trees_values[remain]:
					if flag > flag_v:
						continue
					if (flag == 1) and (op != "not"):
						continue
					if tuple(map(lambda x: op1_getx(op, x), prev_value)) == values:
						for prev_tree in recur(remain, (prev_value, flag)):
							#assert tuple(map(lambda x: Op1(op, prev_tree).getx(x), keys)) == values
							yield Op1(op, prev_tree)
			elif ar == 2:
				if flag_v == 0:
					continue
				for c1 in xrange(1, remain):
					c2 = remain - c1
					#assert c2 > 0
					if c1 > c2: break
					for (prev_value1, flag1) in trees_values[c1]:
						for (prev_value2, flag2) in trees_values[c2]:
							if tuple(map(lambda x, y: op2_getxy(op, x, y), prev_value1, prev_value2)) == values:
								for prev_tree1 in recur(c1, (prev_value1, flag1)):
									for prev_tree2 in recur(c2, (prev_value2, flag2)):
										#assert tuple(map(lambda x: Op2(op, prev_tree1, prev_tree2).getx(x), keys)) == values
										yield Op2(op, prev_tree1, prev_tree2)
			elif ar == 3:
				if flag_v == 0:
					continue
				for c1 in xrange(1, remain):
					for c2 in xrange(1, remain - c1):
						c3 = remain - c1 - c2
						#assert c3 > 0
						for (prev_value1, flag1) in trees_values[c1]:
							for (prev_value2, flag2) in trees_values[c2]:
								for (prev_value3, flag3) in trees_values[c3]:
									if tuple(map(lambda x, y, z: if0(x, y, z), prev_value1, prev_value2, prev_value3)) == values:
										for prev_tree1 in recur(c1, (prev_value1, flag1)):
											for prev_tree2 in recur(c2, (prev_value2, flag2)):
												for prev_tree3 in recur(c3, (prev_value3, flag3)):
													#assert tuple(map(lambda x: If0(prev_tree1, prev_tree2, prev_tree3).getx(x), keys)) == values
													yield If0(prev_tree1, prev_tree2, prev_tree3)
def gen_tree_values(last, ops, keys, right_answer = ()):
	if last > 10:
		last = 10

	result = [None] * (last + 1)
	result[1] = set([((0,)*len(keys), 0), ((1,)*len(keys), 0), (tuple(keys), 0)])

	for i in xrange(2, last + 1):
		st = set()
		for op in ops:
			ar = get_arity(op)
			remain = i - 1
			if ar == 1:
				for (prev_value, flag) in result[remain]:
					if (flag == 1) and (op != "not"):
						continue
					new_value = tuple(map(lambda x: op1_getx(op, x), prev_value))
					if flag == 0:
						st.add((new_value, 0))
					st.add((new_value, 1))
			elif ar == 2:
				for c1 in xrange(1, remain):
					c2 = remain - c1
					#assert c2 > 0
					if c1 > c2: break
					for (prev_value1, flag1) in result[c1]:
						for (prev_value2, flag2) in result[c2]:
							new_value = tuple(map(lambda x, y: op2_getxy(op, x, y), prev_value1, prev_value2))
							st.add((new_value, 1))
			elif ar == 3:
				for c1 in xrange(1, remain):
					for c2 in xrange(1, remain - c1):
						c3 = remain - c1 - c2
						#assert c3 > 0
						for (prev_value1, flag1) in result[c1]:
							for (prev_value2, flag2) in result[c2]:
								for (prev_value3, flag3) in result[c3]:
									new_value = tuple(map(lambda x, y, z: if0(x, y, z), prev_value1, prev_value2, prev_value3))
									st.add((new_value, 1))
			print op,
		print
		result[i] = st
		if right_answer != ():
			if ((right_answer, 0) in st) or ((right_answer, 1) in st):
				return result[:i+1]
		print "%d step is done, size = %d" % (i, len(st))

	return result
Beispiel #3
0
	def recur(level, values):
		#assert values in trees_values[level]
		if level == 1:
			if values == (0,) * len(values):
				yield Const(0)
			if values == (1,) * len(values):
				yield Const(1)
			if values == tuple(keys):
				yield Var()
			return
		if time() > stop_time + 5:
			return
		remain = level - 1
		for op in ops:
			ar = get_arity(op)
			if ar == 1:
				for prev_value in trees_values[remain]:
					if tuple(map(lambda x: op1_getx(op, x), prev_value)) == values:
						for prev_tree in recur(remain, prev_value):
							#assert tuple(map(lambda x: Op1(op, prev_tree).getx(x), keys)) == values
							yield Op1(op, prev_tree)
			elif ar == 2:
				for c1 in xrange(1, remain):
					c2 = remain - c1
					#assert c2 > 0
					if c1 > c2: break
					for prev_value1 in trees_values[c1]:
						for prev_value2 in trees_values[c2]:
							if tuple(map(lambda x, y: op2_getxy(op, x, y), prev_value1, prev_value2)) == values:
								for prev_tree1 in recur(c1, prev_value1):
									for prev_tree2 in recur(c2, prev_value2):
										#assert tuple(map(lambda x: Op2(op, prev_tree1, prev_tree2).getx(x), keys)) == values
										yield Op2(op, prev_tree1, prev_tree2)
			elif ar == 3:
				for c1 in xrange(1, remain):
					for c2 in xrange(1, remain - c1):
						c3 = remain - c1 - c2
						#assert c3 > 0
						for prev_value1 in trees_values[c1]:
							for prev_value2 in trees_values[c2]:
								for prev_value3 in trees_values[c3]:
									if tuple(map(lambda x, y, z: if0(x, y, z), prev_value1, prev_value2, prev_value3)) == values:
										for prev_tree1 in recur(c1, prev_value1):
											for prev_tree2 in recur(c2, prev_value2):
												for prev_tree3 in recur(c3, prev_value3):
													#assert tuple(map(lambda x: If0(prev_tree1, prev_tree2, prev_tree3).getx(x), keys)) == values
													yield If0(prev_tree1, prev_tree2, prev_tree3)
def gen_tree_values(last, ops, keys, right_answer = ()):
	result = [None] * (last + 1)
	result[1] = set([(0,)*len(keys), (1,)*len(keys), tuple(keys)])

	for i in xrange(2, last + 1):
		st = set()
		for op in ops:
			ar = get_arity(op)
			remain = i - 1
			if ar == 1:
				for prev_value in result[remain]:
					new_value = tuple(map(lambda x: op1_getx(op, x), prev_value))
					st.add(new_value)
			elif ar == 2:
				for c1 in xrange(1, remain):
					c2 = remain - c1
					#assert c2 > 0
					if c1 > c2: break
					for prev_value1 in result[c1]:
						for prev_value2 in result[c2]:
							new_value = tuple(map(lambda x, y: op2_getxy(op, x, y), prev_value1, prev_value2))
							st.add(new_value)
			elif ar == 3:
				for c1 in xrange(1, remain):
					for c2 in xrange(1, remain - c1):
						c3 = remain - c1 - c2
						#assert c3 > 0
						for prev_value1 in result[c1]:
							for prev_value2 in result[c2]:
								for prev_value3 in result[c3]:
									new_value = tuple(map(lambda x, y, z: if0(x, y, z), prev_value1, prev_value2, prev_value3))
									st.add(new_value)
			print op,
		print
		result[i] = st
		if right_answer != ():
			if right_answer in st:
				return result[:i+1]
		print "%d step is done, size = %d" % (i, len(st))
		if len(st) > 1000:
			print "Size is too big, tryin to RUSH"
			return result[:i+1]

	return result