Python:

-- in the new_context() class: # just simm applied to relevant kets def pattern_recognition(self,pattern,op,t=0): if type(op) == ket: op = op.label[4:] result = superposition() for label in self.ket_rules_dict: if op in self.ket_rules_dict[label]: candidate_pattern = self.recall(op,label,True) value = silent_simm(pattern,candidate_pattern) if value > t: result.data.append(ket(label,value)) # "result += ket(label,value)" when we swap in fast_superposition return result.coeff_sort() -- in the ket() class: # implements: similar[op] |x> def similar(self,context,op): f = self.apply_op(context,op) return context.pattern_recognition(f,op).delete_ket(self)Now, try to explain in English what is going on.

Consider: similar[example-operator] |x>

First, find the superposition resulting from "example-operator" applied to |x>.

f = self.apply_op(context,op)Then find all the kets that support the "example-operator" operator.

for label in self.ket_rules_dict: if op in self.ket_rules_dict[label]:Then find the superpositions resulting from "example-operator" applied to each of them.

candidate_pattern = self.recall(op,label,True)Then find how similar they are to f/pattern:

value = silent_simm(pattern,candidate_pattern)Keep only the interesting ones:

if value > t: result.data.append(ket(label,value))Sort and return the result:

return result.coeff_sort()Delete |x> since we are always 100% similar with ourselves:

return context.pattern_recognition(f,op).delete_ket(self)Update: Tweaked the code so we have a version of similar[op] that doesn't delete |x>

-- in the ket() class: # implements: self-similar[op] |x> def self_similar(self,context,op): f = self.apply_op(context,op) return context.pattern_recognition(f,op)Update: tweaked similar so that if we want, the operator we apply to |x> is different to the operator we use in looking for matching patterns.

The new python:

-- in the ket() class: def similar(self,context,ops): try: op1,op2 = ops.split(',') except: op1 = ops op2 = ops f = self.apply_op(context,op1) return context.pattern_recognition(f,op2).delete_ket(self) def self_similar(self,context,ops): try: op1,op2 = ops.split(',') except: op1 = ops op2 = ops f = self.apply_op(context,op1) return context.pattern_recognition(f,op2)Update: It should be rather trivial to write a parallel version of context.pattern_recognition() in the case of large sw files. Roughly, partition the sw file. Calculate the resulting superposition for each. Add them up, do a coeff sort. Done.

## No comments:

## Post a Comment