Edit detail for SandBoxPolynomialQuizExplained revision 1 of 1

Coming Soon! (Or you can provide them!) Please insert comments after each problem. Original quizzes on SandBoxPolynomials#quizzes

)clear all

   All user variables and function definitions have been cleared.

)set mess bot on

variables (2*x+1/x)$DMP([x], EXPR INT)

 Function Selection for *
      Arguments: (PI, VARIABLE(x)) 
   -> no appropriate * found in PositiveInteger 
   -> no appropriate * found in Variable(x) 
   -> no appropriate * found in Integer 
   -> no appropriate * found in Symbol 
   -> no appropriate * found in Polynomial(Integer) 
   -> no appropriate * found in PositiveInteger 
   -> no appropriate * found in Variable(x) 
   -> no appropriate * found in Integer 
   -> no appropriate * found in Symbol 

 [1]  signature:   (INT, POLY(INT)) -> POLY(INT)
      implemented: slot $(Integer)$ from POLY(INT)
 [2]  signature:   (INT, POLY(INT)) -> POLY(INT)
      implemented: slot $(Integer)$ from POLY(INT)
 [3]  signature:   (NNI, POLY(INT)) -> POLY(INT)
      implemented: slot $(NonNegativeInteger)$ from POLY(INT)
 [4]  signature:   (PI, POLY(INT)) -> POLY(INT)
      implemented: slot $(PositiveInteger)$ from POLY(INT)
 [5]  signature:   (POLY(INT), POLY(INT)) -> POLY(INT)
      implemented: slot $$$ from POLY(INT)

 Function Selection for /
      Arguments: (PI, VARIABLE(x)) 
      Default target type: Fraction(Polynomial(Integer)) 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in Variable(x) 
   -> no appropriate / found in Integer 
   -> no appropriate / found in Symbol 
   -> no appropriate / found in Fraction(Polynomial(Integer)) 
   -> no appropriate / found in Polynomial(Integer) 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in Variable(x) 
   -> no appropriate / found in Integer 
   -> no appropriate / found in Symbol 
   -> no appropriate / found in Polynomial(Integer) 

 [1]  signature:   (FRAC(POLY(INT)), FRAC(POLY(INT))) -> FRAC(POLY(INT))
      implemented: slot $$$ from FRAC(POLY(INT))
 [2]  signature:   (POLY(INT), POLY(INT)) -> FRAC(POLY(INT))
      implemented: slot $(Polynomial (Integer))(Polynomial (Integer)) from FRAC(POLY(INT))

 Function Selection for +
      Arguments: (POLY(INT), FRAC(POLY(INT))) 
   -> no appropriate + found in Polynomial(Integer) 
   -> no appropriate + found in Fraction(Polynomial(Integer)) 
   -> no appropriate + found in Polynomial(Integer) 

 [1]  signature:   (FRAC(POLY(INT)), FRAC(POLY(INT))) -> FRAC(POLY(INT))
      implemented: slot $$$ from FRAC(POLY(INT))

 Function Selection for variables
      Arguments: FRAC(POLY(INT)) 
      Target type: LIST(OVAR([x])) 
      From:      DMP([x],EXPR(INT)) 

 [1]  signature:   DMP([x],EXPR(INT)) -> LIST(OVAR([x]))
      implemented: slot (List (OrderedVariableList (x)))$ from DMP([x],EXPR(INT))

(1)

---

)set mess bot on

variables (2*y+1/y)$DMP([y], INT)

 Function Selection for *
      Arguments: (PI, VARIABLE(y)) 
   -> no appropriate * found in PositiveInteger 
   -> no appropriate * found in Variable(y) 
   -> no appropriate * found in Integer 
   -> no appropriate * found in Symbol 
   -> no appropriate * found in Polynomial(Integer) 
   -> no appropriate * found in PositiveInteger 
   -> no appropriate * found in Variable(y) 
   -> no appropriate * found in Integer 
   -> no appropriate * found in Symbol 

 [1]  signature:   (INT, POLY(INT)) -> POLY(INT)
      implemented: slot $(Integer)$ from POLY(INT)
 [2]  signature:   (INT, POLY(INT)) -> POLY(INT)
      implemented: slot $(Integer)$ from POLY(INT)
 [3]  signature:   (NNI, POLY(INT)) -> POLY(INT)
      implemented: slot $(NonNegativeInteger)$ from POLY(INT)
 [4]  signature:   (PI, POLY(INT)) -> POLY(INT)
      implemented: slot $(PositiveInteger)$ from POLY(INT)
 [5]  signature:   (POLY(INT), POLY(INT)) -> POLY(INT)
      implemented: slot $$$ from POLY(INT)

 Function Selection for /
      Arguments: (PI, VARIABLE(y)) 
      Default target type: Fraction(Polynomial(Integer)) 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in Variable(y) 
   -> no appropriate / found in Integer 
   -> no appropriate / found in Symbol 
   -> no appropriate / found in Fraction(Polynomial(Integer)) 
   -> no appropriate / found in Polynomial(Integer) 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in Variable(y) 
   -> no appropriate / found in Integer 
   -> no appropriate / found in Symbol 
   -> no appropriate / found in Polynomial(Integer) 

 [1]  signature:   (FRAC(POLY(INT)), FRAC(POLY(INT))) -> FRAC(POLY(INT))
      implemented: slot $$$ from FRAC(POLY(INT))
 [2]  signature:   (POLY(INT), POLY(INT)) -> FRAC(POLY(INT))
      implemented: slot $(Polynomial (Integer))(Polynomial (Integer)) from FRAC(POLY(INT))

 Function Selection for +
      Arguments: (POLY(INT), FRAC(POLY(INT))) 

 [1]  signature:   (FRAC(POLY(INT)), FRAC(POLY(INT))) -> FRAC(POLY(INT))
      implemented: slot $$$ from FRAC(POLY(INT))

 Function Selection for variables
      Arguments: FRAC(POLY(INT)) 
      Target type: LIST(OVAR([y])) 
      From:      DMP([y],INT) 
   -> no appropriate variables found in DistributedMultivariatePolynomial([y],Integer) 
           function not found in (DistributedMultivariatePolynomial ( [ y ] , Integer )) 

   -> no function variables found for arguments FRAC(POLY(INT)) 

 Function Selection for map by coercion facility (map) 
      Arguments: ((POLY(INT) -> INT), FRAC(POLY(INT))) 
      Target type: FRAC(INT) 
   -> no appropriate map found in Fraction(Polynomial(Integer)) 
   -> no appropriate map found in Fraction(Integer) 
   -> no appropriate map found in Integer 
   -> no appropriate map found in Polynomial(Integer) 
   -> no appropriate map found in Integer 

 Modemaps from Associated Packages 
   [1] ((D7 -> D11),FractionalIdeal(D7,D8,D9,D10)) -> FractionalIdeal(
            D11,D1,D2,D3)
            from FractionalIdealFunctions2(D7,D8,D9,D10,D11,D1,D2,D3)
            if D7 has EUCDOM and D8 has QFCAT(D7) and D9 has UPOLYC(D8)
            and D10 has Join(FRAMALG(D8,D9),RETRACT(D8)) and D11 has 
            EUCDOM and D1 has QFCAT(D11) and D2 has UPOLYC(D1) and D3 
            has Join(FRAMALG(D1,D2),RETRACT(D1))
   [2] ((D4 -> D5),Fraction(D4)) -> Fraction(D5)
            from FractionFunctions2(D4,D5)
            if D4 has INTDOM and D5 has INTDOM

 [1]  signature:   ((POLY(INT) -> INT), FRAC(POLY(INT))) -> FRAC(INT)
      implemented: slot (Fraction (Integer))(Mapping (Integer) (Polynomial (Integer)))(Fraction (Polynomial (Integer))) from FRAC2(POLY(INT),INT)

   There are 4 exposed and 7 unexposed library operations named 
      variables having 1 argument(s) but none was determined to be 
      applicable. Use HyperDoc Browse, or issue
                            )display op variables
      to learn more about the available operations. Perhaps 
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named 
      variables with argument type(s) 
                        Fraction(Polynomial(Integer))

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

---

)set mess bot on

a:=(2*x+1/x)$DMP([x], EXPR INT); variables a

 Function Selection for *
      Arguments: (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) 
      Target type: DMP([x],EXPR(INT)) 
   -> no appropriate * found in Expression(Integer) 

 [1]  signature:   (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) -> DMP([x],EXPR(INT))
      implemented: slot $$$ from DMP([x],EXPR(INT))

 Function Selection for /
      Arguments: (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) 
      Target type: DMP([x],EXPR(INT)) 
   -> no appropriate / found in DistributedMultivariatePolynomial([x],Expression(Integer)) 
   -> no appropriate / found in Expression(Integer) 

 [1]  signature:   (DMP([x],EXPR(INT)), EXPR(INT)) -> DMP([x],EXPR(INT))
      implemented: slot $$(Expression (Integer)) from DMP([x],EXPR(INT))
 [2]  signature:   (EXPR(INT), EXPR(INT)) -> EXPR(INT)
      implemented: slot $$$ from EXPR(INT)

 Function Selection for +
      Arguments: (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) 
      Target type: DMP([x],EXPR(INT)) 
      From:      DMP([x],EXPR(INT)) 

 [1]  signature:   (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) -> DMP([x],EXPR(INT))
      implemented: slot $$$ from DMP([x],EXPR(INT))

 Function Selection for variables
      Arguments: DMP([x],EXPR(INT)) 

 [1]  signature:   DMP([x],EXPR(INT)) -> LIST(OVAR([x]))
      implemented: slot (List (OrderedVariableList (x)))$ from DMP([x],EXPR(INT))

(2)

---

)set mess bot on

b:=(2*y+1/y)$DMP([y], INT); variables b

 Function Selection for *
      Arguments: (DMP([y],INT), DMP([y],INT)) 
      Target type: DMP([y],INT) 
   -> no appropriate * found in Integer 

 [1]  signature:   (DMP([y],INT), DMP([y],INT)) -> DMP([y],INT)
      implemented: slot $$$ from DMP([y],INT)

 Function Selection for /
      Arguments: (DMP([y],INT), DMP([y],INT)) 
      Target type: DMP([y],INT) 
   -> no appropriate / found in DistributedMultivariatePolynomial([y],Integer) 
   -> no appropriate / found in Integer 
   -> no appropriate / found in DistributedMultivariatePolynomial([y],Integer) 
   -> no appropriate / found in Integer 

 Modemaps from Associated Packages 
   no modemaps

 Remaining General Modemaps 
   [1] (D,D1) -> D from D if D has XF(D1) and D1 has FIELD
   [2] (D,D1) -> D from D
            if D has RMATCAT(D2,D3,D1,D4,D5) and D1 has Join(SRNG,
            ABELMON) and D4 has DIRPCAT(D3,D1) and D5 has DIRPCAT(D2,D1
            ) and D1 has FIELD
   [3] (D1,D1) -> D from D if D has QFCAT(D1) and D1 has INTDOM
   [4] (D,D1) -> D from D
            if D has MATCAT(D1,D2,D3) and D1 has ABELMON and D2 has 
            FLAGG(D1) and D3 has FLAGG(D1) and D1 has FIELD
   [5] (D,D1) -> D from D
            if D has LIECAT(D1) and D1 has COMRING and D1 has FIELD
   [6] (D,D) -> D from D if D has GROUP
   [7] (SparseMultivariatePolynomial(D2,Kernel(D)),
            SparseMultivariatePolynomial(D2,Kernel(D))) -> D
            from D if D2 has INTDOM and D2 has COMPAR and D has FS(D2)

   [8] (D,Integer) -> D from D if D has FPS
   [9] (D,D) -> D from D if D has FIELD
   [10] (D,D) -> D from D
            if D = EQ(D1) and D1 has FIELD and D1 has TYPE or D = EQ(D1
            ) and D1 has GROUP and D1 has TYPE
   [11] (D,D1) -> D from D
            if D has AMR(D1,D2) and D1 has Join(SRNG,ABELMON) and D2 
            has OAMON and D1 has FIELD

 [1]  signature:   (FRAC(DMP([y],INT)), FRAC(DMP([y],INT))) -> FRAC(DMP([y],INT))
      implemented: slot $$$ from FRAC(DMP([y],INT))

 Function Selection for +
      Arguments: (DMP([y],INT), FRAC(DMP([y],INT))) 
      Target type: DMP([y],INT) 
      From:      DMP([y],INT) 
   -> no appropriate + found in DistributedMultivariatePolynomial([y],Integer) 
           function not found in (DistributedMultivariatePolynomial ( [ y ] , Integer )) 

   -> no function + found for arguments (DMP([y],INT), FRAC(DMP([y],INT))) 

 Function Selection for map by coercion facility (map) 
      Arguments: ((DMP([y],INT) -> INT), FRAC(DMP([y],INT))) 
      Target type: FRAC(INT) 
   -> no appropriate map found in Fraction(DistributedMultivariatePolynomial([y],Integer)) 
   -> no appropriate map found in Fraction(Integer) 
   -> no appropriate map found in Integer 
   -> no appropriate map found in DistributedMultivariatePolynomial([y],Integer) 
   -> no appropriate map found in Integer 

 Modemaps from Associated Packages 
   [1] ((D7 -> D11),FractionalIdeal(D7,D8,D9,D10)) -> FractionalIdeal(
            D11,D1,D2,D3)
            from FractionalIdealFunctions2(D7,D8,D9,D10,D11,D1,D2,D3)
            if D7 has EUCDOM and D8 has QFCAT(D7) and D9 has UPOLYC(D8)
            and D10 has Join(FRAMALG(D8,D9),RETRACT(D8)) and D11 has 
            EUCDOM and D1 has QFCAT(D11) and D2 has UPOLYC(D1) and D3 
            has Join(FRAMALG(D1,D2),RETRACT(D1))
   [2] ((D4 -> D5),Fraction(D4)) -> Fraction(D5)
            from FractionFunctions2(D4,D5)
            if D4 has INTDOM and D5 has INTDOM

 [1]  signature:   ((DMP([y],INT) -> INT), FRAC(DMP([y],INT))) -> FRAC(INT)
      implemented: slot (Fraction (Integer))(Mapping (Integer) (DistributedMultivariatePolynomial (y) (Integer)))(Fraction (DistributedMultivariatePolynomial (y) (Integer))) from FRAC2(DMP([y],INT),INT)

   There are 13 exposed and 11 unexposed library operations named + 
      having 2 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                                )display op +
      to learn more about the available operations. Perhaps 
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named + 
      with argument type(s) 
               DistributedMultivariatePolynomial([y],Integer)
          Fraction(DistributedMultivariatePolynomial([y],Integer))

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

---

)set mess bot on

x:DMP([x], EXPR INT):=x; variables (2*x+1/x)

 Function Selection for *
      Arguments: (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) 

 [1]  signature:   (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) -> DMP([x],EXPR(INT))
      implemented: slot $$$ from DMP([x],EXPR(INT))

 Function Selection for /
      Arguments: (PI, DMP([x],EXPR(INT))) 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in DistributedMultivariatePolynomial([x],Expression(Integer)) 
   -> no appropriate / found in Integer 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in Integer 

 [1]  signature:   (DMP([x],EXPR(INT)), EXPR(INT)) -> DMP([x],EXPR(INT))
      implemented: slot $$(Expression (Integer)) from DMP([x],EXPR(INT))

 Function Selection for +
      Arguments: (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) 

 [1]  signature:   (DMP([x],EXPR(INT)), DMP([x],EXPR(INT))) -> DMP([x],EXPR(INT))
      implemented: slot $$$ from DMP([x],EXPR(INT))

 Function Selection for variables
      Arguments: DMP([x],EXPR(INT)) 

 [1]  signature:   DMP([x],EXPR(INT)) -> LIST(OVAR([x]))
      implemented: slot (List (OrderedVariableList (x)))$ from DMP([x],EXPR(INT))

(3)

---

)set mess bot on

y:DMP([y], INT):=y; variables (2*y+1/y)

 Function Selection for *
      Arguments: (DMP([y],INT), DMP([y],INT)) 

 [1]  signature:   (DMP([y],INT), DMP([y],INT)) -> DMP([y],INT)
      implemented: slot $$$ from DMP([y],INT)

 Function Selection for /
      Arguments: (PI, DMP([y],INT)) 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in DistributedMultivariatePolynomial([y],Integer) 
   -> no appropriate / found in Integer 
   -> no appropriate / found in PositiveInteger 
   -> no appropriate / found in DistributedMultivariatePolynomial([y],Integer) 
   -> no appropriate / found in Integer 

 Modemaps from Associated Packages 
   no modemaps

 Remaining General Modemaps 
   [1] (D,D1) -> D from D if D has XF(D1) and D1 has FIELD
   [2] (D,D1) -> D from D
            if D has RMATCAT(D2,D3,D1,D4,D5) and D1 has Join(SRNG,
            ABELMON) and D4 has DIRPCAT(D3,D1) and D5 has DIRPCAT(D2,D1
            ) and D1 has FIELD
   [3] (D1,D1) -> D from D if D has QFCAT(D1) and D1 has INTDOM
   [4] (D,D1) -> D from D
            if D has MATCAT(D1,D2,D3) and D1 has ABELMON and D2 has 
            FLAGG(D1) and D3 has FLAGG(D1) and D1 has FIELD
   [5] (D,D1) -> D from D
            if D has LIECAT(D1) and D1 has COMRING and D1 has FIELD
   [6] (D,D) -> D from D if D has GROUP
   [7] (SparseMultivariatePolynomial(D2,Kernel(D)),
            SparseMultivariatePolynomial(D2,Kernel(D))) -> D
            from D if D2 has INTDOM and D2 has COMPAR and D has FS(D2)

   [8] (D,Integer) -> D from D if D has FPS
   [9] (D,D) -> D from D if D has FIELD
   [10] (D,D) -> D from D
            if D = EQ(D1) and D1 has FIELD and D1 has TYPE or D = EQ(D1
            ) and D1 has GROUP and D1 has TYPE
   [11] (D,D1) -> D from D
            if D has AMR(D1,D2) and D1 has Join(SRNG,ABELMON) and D2 
            has OAMON and D1 has FIELD

 [1]  signature:   (FRAC(DMP([y],INT)), FRAC(DMP([y],INT))) -> FRAC(DMP([y],INT))
      implemented: slot $$$ from FRAC(DMP([y],INT))

 Function Selection for +
      Arguments: (DMP([y],INT), FRAC(DMP([y],INT))) 
   -> no appropriate + found in DistributedMultivariatePolynomial([y],Integer) 
   -> no appropriate + found in Fraction(DistributedMultivariatePolynomial([y],Integer)) 
   -> no appropriate + found in DistributedMultivariatePolynomial([y],Integer) 

 [1]  signature:   (FRAC(DMP([y],INT)), FRAC(DMP([y],INT))) -> FRAC(DMP([y],INT))
      implemented: slot $$$ from FRAC(DMP([y],INT))

 Function Selection for variables
      Arguments: FRAC(DMP([y],INT)) 
   -> no appropriate variables found in Fraction(DistributedMultivariatePolynomial([y],Integer)) 
   -> no appropriate variables found in Fraction(DistributedMultivariatePolynomial([y],Integer)) 

 Modemaps from Associated Packages 
   no modemaps

 Remaining General Modemaps 
   [1] Fraction(Polynomial(D3)) -> List(Symbol) from RationalFunction(
            D3)
            if D3 has INTDOM
   [2] D -> List(D4) from D
            if D has PSETCAT(D2,D3,D4,D5) and D2 has RING and D3 has 
            OAMONS and D4 has ORDSET and D5 has RPOLCAT(D2,D3,D4)
   [3] D -> List(Symbol) from D if D has FS(D2) and D2 has COMPAR
   [4] List(D) -> List(Symbol) from D if D has FS(D3) and D3 has COMPAR

 [1]  signature:   FRAC(POLY(INT)) -> LIST(SYMBOL)
      implemented: slot (List (Symbol))(Fraction (Polynomial (Integer))) from RF(INT)
 [2]  signature:   EXPR(DMP([y],INT)) -> LIST(SYMBOL)
      implemented: slot (List (Symbol))$ from EXPR(DMP([y],INT))

 Function Selection for map by coercion facility (map) 
      Arguments: ((DMP([y],INT) -> POLY(INT)), FRAC(DMP([y],INT))) 
      Target type: FRAC(POLY(INT)) 
   -> no appropriate map found in Fraction(DistributedMultivariatePolynomial([y],Integer)) 
   -> no appropriate map found in Fraction(Polynomial(Integer)) 
   -> no appropriate map found in Polynomial(Integer) 
   -> no appropriate map found in DistributedMultivariatePolynomial([y],Integer) 
   -> no appropriate map found in Polynomial(Integer) 

 Modemaps from Associated Packages 
   [1] ((D7 -> D11),FractionalIdeal(D7,D8,D9,D10)) -> FractionalIdeal(
            D11,D1,D2,D3)
            from FractionalIdealFunctions2(D7,D8,D9,D10,D11,D1,D2,D3)
            if D7 has EUCDOM and D8 has QFCAT(D7) and D9 has UPOLYC(D8)
            and D10 has Join(FRAMALG(D8,D9),RETRACT(D8)) and D11 has 
            EUCDOM and D1 has QFCAT(D11) and D2 has UPOLYC(D1) and D3 
            has Join(FRAMALG(D1,D2),RETRACT(D1))
   [2] ((D4 -> D5),Fraction(D4)) -> Fraction(D5)
            from FractionFunctions2(D4,D5)
            if D4 has INTDOM and D5 has INTDOM

 [1]  signature:   ((DMP([y],INT) -> POLY(INT)), FRAC(DMP([y],INT))) -> FRAC(POLY(INT))
      implemented: slot (Fraction (Polynomial (Integer)))(Mapping (Polynomial (Integer)) (DistributedMultivariatePolynomial (y) (Integer)))(Fraction (DistributedMultivariatePolynomial (y) (Integer))) from FRAC2(DMP([y],INT),POLY(INT))

(4)

)set mess bot off

no cheating (1) variables (2*x+1/x)$DMP([x]?, EXPR INT)

(Got you, right? It got me too.

Yes. It took me a minute to realize that the interpreter parses this as:

(variables$DMP([x]?, EXPR INT))(2*x+1/x)

To understand this, repeat with )set mess bot on. You must understand what the Interpreter was doing before starting quiz (2))

Ok, that was pretty easy. :)

)set mess bot off (2) variables (2*y+1/y)$DMP([y]?, INT)

(Got me again! Repeat with )set mess bot on, read carefully, and compare with that from (1)).

This one is obvious. The only operation '/ in this domain is ?/? : (%,Integer) -> %' and y is not an Integer.

)set mess bot off (3) a:=(2*x + 1/x)$DMP([x]?, EXPR INT); variables a

Obvious result: [x]? What is hard about that?

)set mess bot off (4) b:=(2*y+1/y)$DMP([y]?, INT); variables b

Same error as in (2). But b is interpreted as a Variable which can be coerced to EXPR INT so result is [b]?

)set mess bot off (5) x:DMP([x]?, EXPR INT); variables (2*x+1/x)

Obvious. Result: [x]?. Essentially the same as (3)

)set mess bot off (6) y:DMP([y]?, INT); variables (2*y+1/y)

I wrote: "Error same as in (2)". So I have to admit I got this one wrong but I should not have. The explanation is simple. This is not a package call as it was in (2), so the interpreter is free to apply the usual coercion to 'FRAC DMP([y]?, INT) in order to obtain a selection for /'.

My apologies for putting up the wrong questions in Quizzes (5) and(6). The correct problems were given correctly on the Wiki pages but not in the email. In (5) x should have been assigned the value x (not just declared to be in DMP. Same for (6), where y should have been assigned the value y. In the version with the omissions, the first lines have no effect on the second lines.

William