Re: [Axiom-developer] how does the interpreter choose signatures?

[Martin Rubey]

I understand a tiny little bit now.  There is a function orderMms in
i-funsel.boot that orders the pre-selected signatures by cost, which is
computed in mmCost.  In the case of integrate(p, s), the costs turn out to be
all the same, namely 86999.  In the case of foo$TEST, they are

|cost: |
(((|Test|) (|Expression| (|Integer|)) (|Expression| (|Integer|)))
 ((|Expression| (|Integer|)) (|Expression| (|Integer|))) (NIL))
53600
|cost: |
(((|Test|) (|Fraction| (|Integer|)) (|Fraction| (|Integer|)))
 ((|Fraction| (|Integer|)) (|Fraction| (|Integer|))) (NIL))
52500
|cost: |
(((|Test|) (|PrimeField| 5) (|PrimeField| 5))
 ((|PrimeField| 5) (|PrimeField| 5)) (NIL))
51500

I do not understand yet how cost is assigned to the various signatures, but the
results look slightly fishy to me...

Martin

Martin Rubey <address@hidden> writes:

> Dear all,
> 
> I'd like to understand the following behaviour.  Consider
> 
> -------------------------------------------------------------------------------
> )abb package TEST Test
> Test(): with
> 
>      foo: Fraction Integer -> Fraction Integer
>      foo: PrimeField 5 -> PrimeField 5
>      foo: Expression Integer -> Expression Integer
> 
>   == add
> 
>     foo(n: Fraction Integer) == n
>     foo(n: PrimeField 5) == n
>     foo(n: Expression Integer) == n
> -------------------------------------------------------------------------------
> 
> Then we have:
> 
> (4) -> foo 3
> 
>  Function Selection for foo
>       Arguments: PI 
>    -> no appropriate foo found in PositiveInteger 
>    -> no appropriate foo found in Integer 
>    -> no appropriate foo found in PositiveInteger 
>    -> no appropriate foo found in Integer 
> 
>  Modemaps from Associated Packages 
>    no modemaps
> 
>  Remaining General Modemaps 
>    [1] Expression Integer -> Expression Integer from Test
>    [2] PrimeField 5 -> PrimeField 5 from Test
>    [3] Fraction Integer -> Fraction Integer from Test
>  
>  [1]  signature:   PF 5 -> PF 5
>       implemented: slot (PrimeField 5)(PrimeField 5) from TEST
>  [2]  signature:   FRAC INT -> FRAC INT
>       implemented: slot (Fraction (Integer))(Fraction (Integer)) from TEST
>  [3]  signature:   EXPR INT -> EXPR INT
>       implemented: slot (Expression (Integer))(Expression (Integer)) from TEST
>  
> 
>    (4)  3
>                                                            Type: PrimeField 5
> -------------------------------------------------------------------------------
> 
> Note that the interpreter seems to prefer PF 5 over FRAC INT over EXPR INT.
> Now consider:
> 
> p := z^10; s:=z=0..1; 
> 
> (6) -> integrate(p, s)
> 
>  Function Selection for integrate
>       Arguments: (POLY INT,SEGBIND NNI) 
>    -> no appropriate integrate found in Polynomial Integer 
>    -> no appropriate integrate found in SegmentBinding NonNegativeInteger 
>    -> no appropriate integrate found in Polynomial Integer 
>    -> no appropriate integrate found in SegmentBinding NonNegativeInteger 
> 
>  Modemaps from Associated Packages 
>    [1] (Polynomial D2,Symbol) -> Polynomial D2 from Polynomial D2
>             if D2 has ALGEBRA FRAC INT and D2 has RING
> 
>  Remaining General Modemaps 
>    [1] (D,D1) -> D from D
>             if D1 = SYMBOL and D has UTSCAT D2 and D2 has RING and D2 
>             has ACFS INT and D2 has PRIMCAT and D2 has TRANFUN and D2 
>             has ALGEBRA FRAC INT or D1 = SYMBOL and D has UTSCAT D2 and
>             D2 has RING and D2 has variables: D2 -> List D1 and D2 has 
>             integrate: (D2,D1) -> D2 and D2 has ALGEBRA FRAC INT
>    [2] (D,D1) -> D from D
>             if D1 = SYMBOL and D has UPXSCAT D2 and D2 has RING and D2 
>             has ACFS INT and D2 has PRIMCAT and D2 has TRANFUN and D2 
>             has ALGEBRA FRAC INT or D1 = SYMBOL and D has UPXSCAT D2 
>             and D2 has RING and D2 has variables: D2 -> List D1 and D2 
>             has integrate: (D2,D1) -> D2 and D2 has ALGEBRA FRAC INT
>          
>    [3] (D,D1) -> D from D
>             if D1 = SYMBOL and D has ULSCAT D2 and D2 has RING and D2 
>             has ACFS INT and D2 has PRIMCAT and D2 has TRANFUN and D2 
>             has ALGEBRA FRAC INT or D1 = SYMBOL and D has ULSCAT D2 and
>             D2 has RING and D2 has variables: D2 -> List D1 and D2 has 
>             integrate: (D2,D1) -> D2 and D2 has ALGEBRA FRAC INT
>    [4] (D,D1) -> D from D
>             if D has MTSCAT(D2,D1) and D2 has RING and D1 has ORDSET 
>             and D2 has ALGEBRA FRAC INT
>    [5] (Fraction Polynomial D4,Symbol) -> Union(Expression D4,List 
>             Expression D4)
>             from IntegrationResultRFToFunction D4
>             if D4 has CHARZ and D4 has Join(GcdDomain,RetractableTo 
>             Integer,OrderedSet,LinearlyExplicitRingOver Integer)
>    [6] (GeneralUnivariatePowerSeries(D2,D3,D4),Variable D3) -> 
>             GeneralUnivariatePowerSeries(D2,D3,D4)
>             from GeneralUnivariatePowerSeries(D2,D3,D4)
>             if D3: SYMBOL and D2 has ALGEBRA FRAC INT and D2 has RING 
>             and D4: D2
>    [7] (D2,Symbol) -> Union(D2,List D2) from FunctionSpaceIntegration(
>             D4,D2)
>             if D4 has Join(EuclideanDomain,OrderedSet,
>             CharacteristicZero,RetractableTo Integer,
>             LinearlyExplicitRingOver Integer) and D2 has Join(
>             TranscendentalFunctionCategory,PrimitiveFunctionCategory,
>             AlgebraicallyClosedFunctionSpace D4)
>    [8] (Fraction Polynomial D4,SegmentBinding OrderedCompletion 
>             Fraction Polynomial D4) -> Union(f1: OrderedCompletion Expression
>             D4,f2: List OrderedCompletion Expression D4,fail: failed,
>             pole: potentialPole)
>             from RationalFunctionDefiniteIntegration D4
>             if D4 has Join(EuclideanDomain,OrderedSet,
>             CharacteristicZero,RetractableTo Integer,
>             LinearlyExplicitRingOver Integer)
>    [9] (Fraction Polynomial D4,SegmentBinding OrderedCompletion 
>             Expression D4) -> Union(f1: OrderedCompletion Expression D4,f2: 
>             List OrderedCompletion Expression D4,fail: failed,pole: 
>             potentialPole)
>             from RationalFunctionDefiniteIntegration D4
>             if D4 has Join(EuclideanDomain,OrderedSet,
>             CharacteristicZero,RetractableTo Integer,
>             LinearlyExplicitRingOver Integer)
>    [10] (D2,SegmentBinding OrderedCompletion D2) -> Union(f1: 
>             OrderedCompletion D2,f2: List OrderedCompletion D2,fail: failed,
>             pole: potentialPole)
>             from ElementaryFunctionDefiniteIntegration(D4,D2)
>             if D2 has Join(TranscendentalFunctionCategory,
>             PrimitiveFunctionCategory,AlgebraicallyClosedFunctionSpace 
>             D4) and D4 has Join(EuclideanDomain,OrderedSet,
>             CharacteristicZero,RetractableTo Integer,
>             LinearlyExplicitRingOver Integer)
>  
>  [1]  signature:   (EXPR INT,SEGBIND ORDCOMP EXPR INT) -> Union(f1: ORDCOMP 
> EXPR INT,f2: LIST ORDCOMP EXPR INT,fail: failed,pole: potentialPole)
>       implemented: slot (Union (: f1 (OrderedCompletion (Expression 
> (Integer)))) (: f2 (List (OrderedCompletion (Expression (Integer))))) (: fail 
> failed) (: pole potentialPole))(Expression (Integer))(SegmentBinding 
> (OrderedCompletion (Expression (Integer)))) from DEFINTEF(INT,EXPR INT)
>  [2]  signature:   (FRAC POLY INT,SEGBIND ORDCOMP EXPR INT) -> Union(f1: 
> ORDCOMP EXPR INT,f2: LIST ORDCOMP EXPR INT,fail: failed,pole: potentialPole)
>       implemented: slot (Union (: f1 (OrderedCompletion (Expression 
> (Integer)))) (: f2 (List (OrderedCompletion (Expression (Integer))))) (: fail 
> failed) (: pole potentialPole))(Fraction (Polynomial 
> (Integer)))(SegmentBinding (OrderedCompletion (Expression (Integer)))) from 
> DEFINTRF INT
>  [3]  signature:   (FRAC POLY INT,SEGBIND ORDCOMP FRAC POLY INT) -> Union(f1: 
> ORDCOMP EXPR INT,f2: LIST ORDCOMP EXPR INT,fail: failed,pole: potentialPole)
>       implemented: slot (Union (: f1 (OrderedCompletion (Expression 
> (Integer)))) (: f2 (List (OrderedCompletion (Expression (Integer))))) (: fail 
> failed) (: pole potentialPole))(Fraction (Polynomial 
> (Integer)))(SegmentBinding (OrderedCompletion (Fraction (Polynomial 
> (Integer))))) from DEFINTRF INT
>  
> 
>  Function Selection for map by coercion facility (map) 
>       Arguments: ((NNI -> ORDCOMP EXPR INT),SEGBIND NNI) 
>       Target type: SEGBIND ORDCOMP EXPR INT 
>    -> no appropriate map found in SegmentBinding NonNegativeInteger 
>    -> no appropriate map found in SegmentBinding OrderedCompletion Expression 
> Integer 
>    -> no appropriate map found in OrderedCompletion Expression Integer 
>    -> no appropriate map found in NonNegativeInteger 
>    -> no appropriate map found in OrderedCompletion Expression Integer 
> 
>  Modemaps from Associated Packages 
>    [1] ((D4 -> D5),SegmentBinding D4) -> SegmentBinding D5
>             from SegmentBindingFunctions2(D4,D5)
>             if D4 has TYPE and D5 has TYPE
>  
>  [1]  signature:   ((NNI -> ORDCOMP EXPR INT),SEGBIND NNI) -> SEGBIND ORDCOMP 
> EXPR INT
>       implemented: slot (SegmentBinding (OrderedCompletion (Expression 
> (Integer))))(Mapping (OrderedCompletion (Expression (Integer))) 
> (NonNegativeInteger))(SegmentBinding (NonNegativeInteger)) from 
> SEGBIND2(NNI,ORDCOMP EXPR INT)
>  
> 
>          1
>    (6)  --
>         11
>                     Type: Union(f1: OrderedCompletion Expression Integer,...)
> 
> There are many things I do not understand:
> 
> 1) why doesn't the interpreter choose the "General Modemap"
> 
>    [8] (Fraction Polynomial D4,SegmentBinding OrderedCompletion 
>             Fraction Polynomial D4)
> 
>   ?
> 
> 2) why is its preference different now:
> 
> 
>  [1]  signature:   (EXPR INT,SEGBIND ORDCOMP EXPR INT) -> Union(f1: ORDCOMP 
> EXPR INT,f2: LIST ORDCOMP EXPR INT,fail: failed,pole: potentialPole)
>       implemented: slot (Union (: f1 (OrderedCompletion (Expression 
> (Integer)))) (: f2 (List (OrderedCompletion (Expression (Integer))))) (: fail 
> failed) (: pole potentialPole))(Expression (Integer))(SegmentBinding 
> (OrderedCompletion (Expression (Integer)))) from DEFINTEF(INT,EXPR INT)
>  [2]  signature:   (FRAC POLY INT,SEGBIND ORDCOMP EXPR INT) -> Union(f1: 
> ORDCOMP EXPR INT,f2: LIST ORDCOMP EXPR INT,fail: failed,pole: potentialPole)
>       implemented: slot (Union (: f1 (OrderedCompletion (Expression 
> (Integer)))) (: f2 (List (OrderedCompletion (Expression (Integer))))) (: fail 
> failed) (: pole potentialPole))(Fraction (Polynomial 
> (Integer)))(SegmentBinding (OrderedCompletion (Expression (Integer)))) from 
> DEFINTRF INT
>  [3]  signature:   (FRAC POLY INT,SEGBIND ORDCOMP FRAC POLY INT) -> Union(f1: 
> ORDCOMP EXPR INT,f2: LIST ORDCOMP EXPR INT,fail: failed,pole: potentialPole)
>       implemented: slot (Union (: f1 (OrderedCompletion (Expression 
> (Integer)))) (: f2 (List (OrderedCompletion (Expression (Integer))))) (: fail 
> failed) (: pole potentialPole))(Fraction (Polynomial 
> (Integer)))(SegmentBinding (OrderedCompletion (Fraction (Polynomial 
> (Integer))))) from DEFINTRF INT
>  
> I.e., in package DEFINTRF, it seems to prefer (FRAC POLY INT,SEGBIND ORDCOMP
> EXPR INT) over (FRAC POLY INT,SEGBIND ORDCOMP FRAC POLY INT).
> 
> 3) why does it prefer DEFINTEF(INT,EXPR INT) over DEFINTRF INT ?
> 
> 
> ANY hints?
> 
> Martin
> 
> 
> 
> _______________________________________________
> Axiom-developer mailing list
> address@hidden
> http://lists.nongnu.org/mailman/listinfo/axiom-developer