Initial addition of Python scripts

correspondence.py

@@ -0,0 +1,189 @@
+from workspace import workspace
+from workspaceStructure import WorkspaceStructure
+from formulas import getMappings
+
+class Correspondence(WorkspaceStructure):
+	def __init__(self,objectFromInitial,objectFromTarget,conceptMappings,flipTargetObject):
+		WorkspaceStructure.__init__(self)
+		self.objectFromInitial = objectFromInitial
+		self.objectFromTarget = objectFromTarget
+		self.conceptMappings = conceptMappings
+		self.flipTargetObject = flipTargetObject
+		self.accessoryConceptMappings = []
+
+	def __repr__(self):
+		return '<%s>' % self.__str__()
+
+	def __str__(self):
+		return 'Correspondence between %s and %s' % (self.objectFromInitial,self.objectFromTarget)
+
+	def distinguishingConceptMappings(self):
+		return [ m for m in self.conceptMappings if m.distinguishing() ]
+
+	def relevantDistinguishingConceptMappings(self):
+		return [ m for m in self.conceptMappings if m.distinguishing() and m.relevant() ]
+
+	def extract_target_bond(self):
+		targetBond = False
+		if self.objectFromTarget.leftmost:
+			targetBond = self.objectFromTarget.rightBond
+		elif self.objectFromTarget.rightmost:
+			targetBond = self.objectFromTarget.leftBond
+		return targetBond
+
+	def extract_initial_bond(self):
+		initialBond = False
+		if self.objectFromInitial.leftmost:
+			initialBond = self.objectFromInitial.rightBond
+		elif self.objectFromInitial.rightmost:
+			initialBond = self.objectFromInitial.leftBond
+		return initialBond
+
+	def getIncompatibleBond(self):
+		initialBond = self.extract_initial_bond()
+		if not initialBond:
+			return None
+		targetBond = self.extract_target_bond()
+		if not targetBond:
+			return None
+		from conceptMapping import ConceptMapping
+		from slipnet import slipnet
+		if initialBond.directionCategory and targetBond.directionCategory:
+			mapping = ConceptMapping(
+				slipnet.directionCategory,
+				slipnet.directionCategory,
+				initialBond.directionCategory,
+				targetBond.directionCategory,
+				None,
+				None
+			)
+			for m in self.conceptMappings:
+				if m.incompatible(mapping):
+					return targetBond
+		return None
+
+	def getIncompatibleCorrespondences(self):
+		return [ o.correspondence for o in workspace.initial.objects if o and self.incompatible(o.correspondence) ]
+
+	def incompatible(self,other):
+		if not other:
+			return False
+		if self.objectFromInitial == other.objectFromInitial:
+			return True
+		if self.objectFromTarget == other.objectFromTarget:
+			return True
+		for mapping in self.conceptMappings:
+			for otherMapping in other.conceptMappings:
+				if mapping.incompatible(otherMapping):
+					return True
+		return False
+
+	def supporting(self,other):
+		if self == other:
+			return False
+		if self.objectFromInitial == other.objectFromInitial:
+			return False
+		if self.objectFromTarget == other.objectFromTarget:
+			return False
+		if self.incompatible(other):
+			return False
+		for mapping in self.distinguishingConceptMappings():
+			for otherMapping in other.distinguishingConceptMappings():
+				if mapping.supports(otherMapping):
+					return True
+		return False
+
+	def support(self):
+		from letter import Letter
+		if isinstance(self.objectFromInitial,Letter) and self.objectFromInitial.spansString():
+			return 100.0
+		if isinstance(self.objectFromTarget,Letter) and self.objectFromTarget.spansString():
+			return 100.0
+		total = sum([ c.totalStrength for c in workspace.correspondences() if self.supporting(c) ])
+		total = min(total,100.0)
+		return total
+
+	def updateInternalStrength(self):
+		"""A function of how many conceptMappings there are, their strength and how well they cohere"""
+		relevantDistinguishingMappings = self.relevantDistinguishingConceptMappings()
+		numberOfConceptMappings = len(relevantDistinguishingMappings)
+		if numberOfConceptMappings < 1:
+			self.internalStrength = 0.0
+			return
+		totalStrength = sum([ m.strength() for m in relevantDistinguishingMappings ])
+		averageStrength = totalStrength / numberOfConceptMappings
+		if numberOfConceptMappings == 1.0:
+			numberOfConceptMappingsFactor = 0.8
+		elif numberOfConceptMappings == 2.0:
+			numberOfConceptMappingsFactor = 1.2
+		else:
+			numberOfConceptMappingsFactor = 1.6
+		if self.internallyCoherent():
+			internalCoherenceFactor = 2.5
+		else:
+			internalCoherenceFactor = 1.0
+		internalStrength = averageStrength * internalCoherenceFactor * numberOfConceptMappingsFactor
+		self.internalStrength = min(internalStrength,100.0)
+
+	def updateExternalStrength(self):
+		self.externalStrength = self.support()
+
+		def internallyCoherent(self):
+			"""Whether any pair of relevant distinguishing mappings support each other"""
+			mappings = self.relevantDistinguishingConceptMappings()
+			for i in range(0,len(mappings)):
+				for j in range(0,len(mappings)):
+					if i != j:
+						if mappings[i].supports(mappings[j]):
+							return True
+			return False
+
+	def slippages(self):
+		mappings = [ m for m in self.conceptMappings if m.slippage() ]
+		mappings += [ m for m in self.accessoryConceptMappings if m.slippage() ]
+		return mappings
+
+	def reflexive(self):
+		if not self.objectFromInitial.correspondence:
+			return False
+		if self.objectFromInitial.correspondence.objectFromTarget == self.objectFromTarget:
+			return True
+		return False
+
+	def buildCorrespondence(self):
+		workspace.structures += [ self ]
+		if self.objectFromInitial.correspondence:
+			self.objectFromInitial.correspondence.breakCorrespondence()
+		if self.objectFromTarget.correspondence:
+			self.objectFromTarget.correspondence.breakCorrespondence()
+		self.objectFromInitial.correspondence = self
+		self.objectFromTarget.correspondence = self
+		# add mappings to accessory-concept-mapping-list
+		relevantMappings = self.relevantDistinguishingConceptMappings()
+		for mapping in relevantMappings:
+			if mapping.slippage():
+				self.accessoryConceptMappings += [ mapping.symmetricVersion() ]
+		from group import Group
+		if isinstance(self.objectFromInitial,Group) and isinstance(self.objectFromTarget,Group):
+			bondMappings = getMappings(
+				self.objectFromInitial,
+				self.objectFromTarget,
+				self.objectFromInitial.bondDescriptions,
+				self.objectFromTarget.bondDescriptions
+			)
+			for mapping in bondMappings:
+				self.accessoryConceptMappings += [ mapping ]
+				if mapping.slippage():
+					self.accessoryConceptMappings += [ mapping.symmetricVersion() ]
+		for mapping in self.conceptMappings:
+			if mapping.label:
+				mapping.label.activation = 100.0
+
+	def break_the_structure(self):
+		self.breakCorrespondence()
+
+	def breakCorrespondence(self):
+		workspace.structures.remove(self)
+		self.objectFromInitial.correspondence = None
+		self.objectFromTarget.correspondence = None
+