// FILE. . . . . d:/hak/hlt/src/hlt/fot/fuz/ArgumentPositionMaps.java // EDIT BY . . . Hassan Ait-Kaci // ON MACHINE. . Hak-Laptop // STARTED ON. . Sun Jul 15 07:37:57 2018 package hlt.fot.fuz; /** * @version Last modified on Fri Aug 23 11:54:07 2019 by hak * @author Hassan Aït-Kaci * @copyright © by the author */ import hlt.fot.Functor; import hlt.language.util.ArrayList; import hlt.language.util.IntArrayList; import hlt.language.util.DoubleArrayList; /** * This class represents a fuzzy set of ArgumentPositionMapping * objects. Given sim, a SignatureSimilarity on * sig a SimilarFunctorSignature, * an instance of this class (call it maps) specifies, for each * approximation degree α in sim.degrees(), * the following information: * * * * @see ../Functor * @see ../Signature * @see SignatureSimilarity * @see SimilarFunctorSignature * @see ArgumentPositionMapping */ public class ArgumentPositionMaps { /** * The signature similarity of this ArgumentPositionMaps object. */ private SignatureSimilarity similarity; /** * Returns the signature similarity of this ArgumentPositionMaps object. */ public SignatureSimilarity similarity () { return similarity; } /** * Returns this ArgumentPositionMaps object's similarity's signature. */ public SimilarFunctorSignature signature () { return similarity.signature(); } /** * Returns the list of doubles that are the fuzzy * approximation degrees of the mappings that constitute this * ArgumentPositionMaps object as a * DoubleArrayList. By construction, it will always be sorted * in strictly increasing order; i.e., if 0 ≤ * i < j < size(), then * degrees().get(i) < degrees().get(j). */ public DoubleArrayList degrees () { return similarity.degrees(); } /** * Returns the number of maps. */ public int size () { return degrees().size(); } /* ************************************************************************ */ /** * The list argumentMappings is an ArrayList of * ArgumentPositionMapping objects. It has the same size as * degrees(). For each fuzzy degree α in * degrees(), it associates to each pair * ⟨f,g⟩ of distinct but * α-similar functors an argument position mapping in * the form of a list of pairs of argument positions i:j, * where 1 ≤ i ≤ f.arity() and * 1 ≤ j ≤ g.arity(). */ private ArrayList argumentMappings = new ArrayList(size()); /** * Returns the list of ArgumentPositionMapping objects. This * is an ArrayList that has the same size as the * DoubleArrayList degrees(). An * ArgumentPositionMapping specifies a set of pairs of * argument positions for a given approximation degree * α in degrees() and a pair of distinct but * α-similar functors * ⟨f,g⟩. */ public ArrayList argumentMappings () { return argumentMappings; } /* ************************************************************************ */ /** * This defines an argument position mapping for the approximation * degree at specified index, functors, and list of position pairs. * In order to take into account a signature similarity during * unification and generalization, for each similarity degree * α in degrees() (i.e., in * similarity().degrees() inherited from hlt.math.fuzzy.FuzzyMatrix * that returns them as a DoubleArrayList sorted in * increasing order), we must specify for any pair of distinct but * α-similar functors ⟨f,g⟩ * the number and order of argument positions to take into account to * propagate the unification or generalization operations to their * respective corresponding subterms. There are conditions that must * be verified such that these mappings be consistent with the * reflexivity, symmetry, and transitivity of the similarity (click * here for details). This is done by the * ArgumentPositionMapping which throws a * BadArgumentPositionMappingException when these conditions * are violated. If the constructor is verified, this means that the * mapping is consistent and complete, or was completed as necessary * to the least consistent reflexive, symmetric, and transitive * argument-position mapping containing the specified pairs. If the * mapping is found inconsistent, an exception is raised and no * mapping is defined. */ public void defineArgumentMapping (int index, Functor f, Functor g, IntArrayList positionPairs) { try { ArgumentPositionMapping map = new ArgumentPositionMapping(this,index,f,g,positionPairs); // set the index of this mapping in the set of ArgumentPositionMaps containing this map: map.setMappingIndex(index); // and add map to this set of argument maps argumentMappings.add(map); } catch (BadArgumentPositionMappingException e) { System.err.println(e+" (ignored)"); } } /* ************************************************************************ */ /** * The method invocation verifyConsistency() has for purpose * to verify the consistency of the declared argument-position * mappings that were declared for this * ArgumentPositionMaps. It ensures that the declared * mappings respect: * *

* *

* * * * * * * * * * * * * * * * * *
approximation consistency: * ∀ f ∈ Σm , * ∀ g ∈ Σn , * if α ≤ β then * μαf,g * ⊆ μβf,g * (as sets of pairs) *
reflexive consistency: * ∀ f ∈ Σn , * μαf,f = * Id{1,...,n} *
symmetric consistency: * ∀ f ∈ Σm , * ∀ g ∈ Σn , * μαf,g = * (μαg,f)-1 *
transitive consistency: * ∀ f ∈ Σm , * ∀ g ∈ Σn , * ∀ h ∈ Σp , * μαh,f = * μαg,f * ∘ μαh,g *
*
* *

* for all approximation degrees α and * β in degrees() obtained from the pairs * declared in this ArgumentPositionMaps by completing the * declared set of mappings with their reflexive, symmetric, and * transitive closures. */ public void verifyConsistency () { try { System.out.println ("+++ Verifying consistency of specified similar functor argument-position mappings"); // verifyApproximationConsistency(); // verifyReflexiveConsistency(); // verifySymmetryConsistency(); // verifyTransitiveConsistency(); } catch (BadArgumentPositionMappingException e) { System.err.println(e+" (please fix before recompiling)"); } } /* ************************************************************************ */ }