FunctionFieldCategory(F, UP, UPUP)
curve.spad line 1
[edit on github]
This category is a model for the function field of a plane algebraic curve.
- * : (%, %) -> %
- from Magma
- * : (%, Fraction(UP)) -> %
- from RightModule(Fraction(UP))
- * : (%, Fraction(Integer)) -> %
- from RightModule(Fraction(Integer))
- * : (%, Integer) -> % if Fraction(UP) has LinearlyExplicitOver(Integer)
- from RightModule(Integer)
- * : (Fraction(UP), %) -> %
- from LeftModule(Fraction(UP))
- * : (Fraction(Integer), %) -> %
- from LeftModule(Fraction(Integer))
- * : (Integer, %) -> %
- from AbelianGroup
- * : (NonNegativeInteger, %) -> %
- from AbelianMonoid
- * : (PositiveInteger, %) -> %
- from AbelianSemiGroup
- + : (%, %) -> %
- from AbelianSemiGroup
- - : % -> %
- from AbelianGroup
- - : (%, %) -> %
- from AbelianGroup
- / : (%, %) -> %
- from Field
- 0 : () -> %
- from AbelianMonoid
- 1 : () -> %
- from MagmaWithUnit
- = : (%, %) -> Boolean
- from BasicType
- D : % -> % if Fraction(UP) has DifferentialRing
- from DifferentialRing
- D : (%, List(Symbol)) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- D : (%, List(Symbol), List(NonNegativeInteger)) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- D : (%, Mapping(Fraction(UP), Fraction(UP))) -> %
- from DifferentialExtension(Fraction(UP))
- D : (%, Mapping(Fraction(UP), Fraction(UP)), NonNegativeInteger) -> %
- from DifferentialExtension(Fraction(UP))
- D : (%, NonNegativeInteger) -> % if Fraction(UP) has DifferentialRing
- from DifferentialRing
- D : (%, Symbol) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- D : (%, Symbol, NonNegativeInteger) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- ^ : (%, Integer) -> %
- from DivisionRing
- ^ : (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- ^ : (%, PositiveInteger) -> %
- from Magma
- absolutelyIrreducible? : () -> Boolean
absolutelyIrreducible?() tests if the curve absolutely irreducible?
- algSplitSimple : (%, Mapping(UP, UP)) -> Record(num : %, den : UP, derivden : UP, gd : UP)
algSplitSimple(f, D) returns [h, d, d', g] such that f=h/d, h is integral at all the normal places w.r.t. D, d' = Dd, g = gcd(d, discriminant()) and D is the derivation to use. f must have at most simple finite poles.
- annihilate? : (%, %) -> Boolean
- from Rng
- antiCommutator : (%, %) -> %
- from NonAssociativeSemiRng
- associates? : (%, %) -> Boolean
- from EntireRing
- associator : (%, %, %) -> %
- from NonAssociativeRng
- basis : () -> Vector(%)
- from FramedModule(Fraction(UP))
- branchPoint? : F -> Boolean
branchPoint?(a) tests whether x = a is a branch point.
- branchPoint? : UP -> Boolean
branchPoint?(p) tests whether p(x) = 0 is a branch point.
- branchPointAtInfinity? : () -> Boolean
branchPointAtInfinity?() tests if there is a branch point at infinity.
- characteristic : () -> NonNegativeInteger
- from NonAssociativeRing
- characteristicPolynomial : % -> UPUP
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- charthRoot : % -> % if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- charthRoot : % -> Union(%, "failed") if Fraction(UP) has CharacteristicNonZero
- from CharacteristicNonZero
- coerce : % -> %
- from Algebra(%)
- coerce : Fraction(UP) -> %
- from Algebra(Fraction(UP))
- coerce : Fraction(Integer) -> %
- from Algebra(Fraction(Integer))
- coerce : Integer -> %
- from NonAssociativeRing
- coerce : % -> OutputForm
- from CoercibleTo(OutputForm)
- commutator : (%, %) -> %
- from NonAssociativeRng
- complementaryBasis : Vector(%) -> Vector(%)
complementaryBasis(b1, ..., bn) returns the complementary basis (b1', ..., bn') of (b1, ..., bn).
- conditionP : Matrix(%) -> Union(Vector(%), "failed") if Fraction(UP) has FiniteFieldCategory
- from PolynomialFactorizationExplicit
- convert : UPUP -> %
- from MonogenicAlgebra(Fraction(UP), UPUP)
- convert : Vector(Fraction(UP)) -> %
- from FramedModule(Fraction(UP))
- convert : % -> UPUP
- from ConvertibleTo(UPUP)
- convert : % -> InputForm if Fraction(UP) has Finite
- from ConvertibleTo(InputForm)
- convert : % -> Vector(Fraction(UP))
- from FramedModule(Fraction(UP))
- coordinates : Vector(%) -> Matrix(Fraction(UP))
- from FramedModule(Fraction(UP))
- coordinates : (Vector(%), Vector(%)) -> Matrix(Fraction(UP))
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- coordinates : % -> Vector(Fraction(UP))
- from FramedModule(Fraction(UP))
- coordinates : (%, Vector(%)) -> Vector(Fraction(UP))
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- createPrimitiveElement : () -> % if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- definingPolynomial : () -> UPUP
- from MonogenicAlgebra(Fraction(UP), UPUP)
- derivationCoordinates : (Vector(%), Mapping(Fraction(UP), Fraction(UP))) -> Matrix(Fraction(UP))
- from MonogenicAlgebra(Fraction(UP), UPUP)
- differentiate : % -> % if Fraction(UP) has DifferentialRing
- from DifferentialRing
- differentiate : (%, List(Symbol)) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- differentiate : (%, Mapping(UP, UP)) -> %
differentiate(x, d) extends the derivation d from UP to $ and applies it to x.
- differentiate : (%, Mapping(Fraction(UP), Fraction(UP))) -> %
- from DifferentialExtension(Fraction(UP))
- differentiate : (%, Mapping(Fraction(UP), Fraction(UP)), NonNegativeInteger) -> %
- from DifferentialExtension(Fraction(UP))
- differentiate : (%, NonNegativeInteger) -> % if Fraction(UP) has DifferentialRing
- from DifferentialRing
- differentiate : (%, Symbol) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- differentiate : (%, Symbol, NonNegativeInteger) -> % if Fraction(UP) has PartialDifferentialRing(Symbol)
- from PartialDifferentialRing(Symbol)
- discreteLog : % -> NonNegativeInteger if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- discreteLog : (%, %) -> Union(NonNegativeInteger, "failed") if Fraction(UP) has FiniteFieldCategory
- from FieldOfPrimeCharacteristic
- discriminant : () -> Fraction(UP)
- from FramedAlgebra(Fraction(UP), UPUP)
- discriminant : Vector(%) -> Fraction(UP)
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- divide : (%, %) -> Record(quotient : %, remainder : %)
- from EuclideanDomain
- elliptic : () -> Union(UP, "failed")
elliptic() returns p(x) if the curve is the elliptic defined by y^2 = p(x), "failed" otherwise.
- elt : (%, F, F) -> F
elt(f, a, b) or f(a, b) returns the value of f at the point (x = a, y = b) if it is not singular.
- enumerate : () -> List(%) if Fraction(UP) has Finite
- from Finite
- euclideanSize : % -> NonNegativeInteger
- from EuclideanDomain
- expressIdealMember : (List(%), %) -> Union(List(%), "failed")
- from PrincipalIdealDomain
- exquo : (%, %) -> Union(%, "failed")
- from EntireRing
- extendedEuclidean : (%, %) -> Record(coef1 : %, coef2 : %, generator : %)
- from EuclideanDomain
- extendedEuclidean : (%, %, %) -> Union(Record(coef1 : %, coef2 : %), "failed")
- from EuclideanDomain
- factor : % -> Factored(%)
- from UniqueFactorizationDomain
- factorPolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Fraction(UP) has FiniteFieldCategory
- from PolynomialFactorizationExplicit
- factorSquareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Fraction(UP) has FiniteFieldCategory
- from PolynomialFactorizationExplicit
- factorsOfCyclicGroupSize : () -> List(Record(factor : Integer, exponent : NonNegativeInteger)) if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- gcd : (%, %) -> %
- from GcdDomain
- gcd : List(%) -> %
- from GcdDomain
- gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)
- from GcdDomain
- generator : () -> %
- from MonogenicAlgebra(Fraction(UP), UPUP)
- genus : () -> NonNegativeInteger
genus() returns the genus of one absolutely irreducible component
- hash : % -> SingleInteger if Fraction(UP) has Hashable
- from Hashable
- hashUpdate! : (HashState, %) -> HashState if Fraction(UP) has Hashable
- from Hashable
- hyperelliptic : () -> Union(UP, "failed")
hyperelliptic() returns p(x) if the curve is the hyperelliptic defined by y^2 = p(x), "failed" otherwise.
- index : PositiveInteger -> % if Fraction(UP) has Finite
- from Finite
- init : () -> % if Fraction(UP) has FiniteFieldCategory
- from StepThrough
- integral? : % -> Boolean
integral?(f) tests if f is integral over k[x].
- integral? : (%, F) -> Boolean
integral?(f, a) tests whether f is locally integral at x = a.
- integral? : (%, UP) -> Boolean
integral?(f, p) tests whether f is locally integral at p(x) = 0.
- integralAtInfinity? : % -> Boolean
integralAtInfinity?(f) tests if f is locally integral at infinity.
- integralBasis : () -> Vector(%)
integralBasis() returns the integral basis for the curve.
- integralBasisAtInfinity : () -> Vector(%)
integralBasisAtInfinity() returns the local integral basis at infinity.
- integralCoordinates : % -> Record(num : Vector(UP), den : UP)
integralCoordinates(f) returns [[A1, ..., An], D] such that f = (A1 w1 +...+ An wn) / D where (w1, ..., wn) is the integral basis returned by integralBasis().
- integralDerivationMatrix : Mapping(UP, UP) -> Record(num : Matrix(UP), den : UP)
integralDerivationMatrix(d) extends the derivation d from UP to $ and returns (M, Q) such that the i^th row of M divided by Q form the coordinates of d(wi) with respect to (w1, ..., wn) where (w1, ..., wn) is the integral basis returned by integralBasis().
- integralMatrix : () -> Matrix(Fraction(UP))
integralMatrix() returns M such that (w1, ..., wn) = M (1, y, ..., y^(n-1)), where (w1, ..., wn) is the integral basis of integralBasis.
- integralMatrixAtInfinity : () -> Matrix(Fraction(UP))
integralMatrixAtInfinity() returns M such that (v1, ..., vn) = M (1, y, ..., y^(n-1)) where (v1, ..., vn) is the local integral basis at infinity returned by infIntBasis().
- integralRepresents : (Vector(UP), UP) -> %
integralRepresents([A1, ..., An], D) returns (A1 w1+...+An wn)/D where (w1, ..., wn) is the integral basis of integralBasis().
- inv : % -> %
- from DivisionRing
- inverseIntegralMatrix : () -> Matrix(Fraction(UP))
inverseIntegralMatrix() returns M such that M (w1, ..., wn) = (1, y, ..., y^(n-1)) where (w1, ..., wn) is the integral basis of integralBasis.
- inverseIntegralMatrixAtInfinity : () -> Matrix(Fraction(UP))
inverseIntegralMatrixAtInfinity() returns M such that M (v1, ..., vn) = (1, y, ..., y^(n-1)) where (v1, ..., vn) is the local integral basis at infinity returned by infIntBasis().
- latex : % -> String
- from SetCategory
- lcm : (%, %) -> %
- from GcdDomain
- lcm : List(%) -> %
- from GcdDomain
- lcmCoef : (%, %) -> Record(llcm_res : %, coeff1 : %, coeff2 : %)
- from LeftOreRing
- leftPower : (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- leftPower : (%, PositiveInteger) -> %
- from Magma
- leftRecip : % -> Union(%, "failed")
- from MagmaWithUnit
- lift : % -> UPUP
- from MonogenicAlgebra(Fraction(UP), UPUP)
- lookup : % -> PositiveInteger if Fraction(UP) has Finite
- from Finite
- minimalPolynomial : % -> UPUP
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- multiEuclidean : (List(%), %) -> Union(List(%), "failed")
- from EuclideanDomain
- nextItem : % -> Union(%, "failed") if Fraction(UP) has FiniteFieldCategory
- from StepThrough
- nonSingularModel : Symbol -> List(Polynomial(F)) if F has Field
nonSingularModel(u) returns the equations in u1, ..., un of an affine non-singular model for the curve.
- norm : % -> Fraction(UP)
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- normalizeAtInfinity : Vector(%) -> Vector(%)
normalizeAtInfinity(v) makes v normal at infinity.
- numberOfComponents : () -> NonNegativeInteger
numberOfComponents() returns the number of absolutely irreducible components.
- one? : % -> Boolean
- from MagmaWithUnit
- opposite? : (%, %) -> Boolean
- from AbelianMonoid
- order : % -> OnePointCompletion(PositiveInteger) if Fraction(UP) has FiniteFieldCategory
- from FieldOfPrimeCharacteristic
- order : % -> PositiveInteger if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- plenaryPower : (%, PositiveInteger) -> %
- from NonAssociativeAlgebra(%)
- prime? : % -> Boolean
- from UniqueFactorizationDomain
- primeFrobenius : % -> % if Fraction(UP) has FiniteFieldCategory
- from FieldOfPrimeCharacteristic
- primeFrobenius : (%, NonNegativeInteger) -> % if Fraction(UP) has FiniteFieldCategory
- from FieldOfPrimeCharacteristic
- primitive? : % -> Boolean if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- primitiveElement : () -> % if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- primitivePart : % -> %
primitivePart(f) removes the content of the denominator and the common content of the numerator of f.
- principalIdeal : List(%) -> Record(coef : List(%), generator : %)
- from PrincipalIdealDomain
- quo : (%, %) -> %
- from EuclideanDomain
- ramified? : F -> Boolean
ramified?(a) tests whether x = a is ramified.
- ramified? : UP -> Boolean
ramified?(p) tests whether p(x) = 0 is ramified.
- ramifiedAtInfinity? : () -> Boolean
ramifiedAtInfinity?() tests if infinity is ramified.
- random : () -> % if Fraction(UP) has Finite
- from Finite
- rank : () -> PositiveInteger
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- rationalPoint? : (F, F) -> Boolean
rationalPoint?(a, b) tests if (x=a, y=b) is on the curve.
- rationalPoints : () -> List(List(F)) if F has Finite
rationalPoints() returns the list of all the affine rational points.
- recip : % -> Union(%, "failed")
- from MagmaWithUnit
- reduce : UPUP -> %
- from MonogenicAlgebra(Fraction(UP), UPUP)
- reduce : Fraction(UPUP) -> Union(%, "failed")
- from MonogenicAlgebra(Fraction(UP), UPUP)
- reduceBasisAtInfinity : Vector(%) -> Vector(%)
reduceBasisAtInfinity(b1, ..., bn) returns (x^i * bj) for all i, j such that x^i*bj is locally integral at infinity.
- reducedSystem : Matrix(%) -> Matrix(Fraction(UP))
- from LinearlyExplicitOver(Fraction(UP))
- reducedSystem : Matrix(%) -> Matrix(Integer) if Fraction(UP) has LinearlyExplicitOver(Integer)
- from LinearlyExplicitOver(Integer)
- reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Fraction(UP)), vec : Vector(Fraction(UP)))
- from LinearlyExplicitOver(Fraction(UP))
- reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if Fraction(UP) has LinearlyExplicitOver(Integer)
- from LinearlyExplicitOver(Integer)
- regularRepresentation : % -> Matrix(Fraction(UP))
- from FramedAlgebra(Fraction(UP), UPUP)
- regularRepresentation : (%, Vector(%)) -> Matrix(Fraction(UP))
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- rem : (%, %) -> %
- from EuclideanDomain
- representationType : () -> Union("prime", "polynomial", "normal", "cyclic") if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- represents : (Vector(UP), UP) -> %
represents([A0, ..., A(n-1)], D) returns (A0 + A1 y +...+ A(n-1)*y^(n-1))/D.
- represents : Vector(Fraction(UP)) -> %
- from FramedModule(Fraction(UP))
- represents : (Vector(Fraction(UP)), Vector(%)) -> %
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- retract : % -> Fraction(UP)
- from RetractableTo(Fraction(UP))
- retract : % -> Fraction(Integer) if Fraction(UP) has RetractableTo(Fraction(Integer))
- from RetractableTo(Fraction(Integer))
- retract : % -> Integer if Fraction(UP) has RetractableTo(Integer)
- from RetractableTo(Integer)
- retractIfCan : % -> Union(Fraction(UP), "failed")
- from RetractableTo(Fraction(UP))
- retractIfCan : % -> Union(Fraction(Integer), "failed") if Fraction(UP) has RetractableTo(Fraction(Integer))
- from RetractableTo(Fraction(Integer))
- retractIfCan : % -> Union(Integer, "failed") if Fraction(UP) has RetractableTo(Integer)
- from RetractableTo(Integer)
- rightPower : (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- rightPower : (%, PositiveInteger) -> %
- from Magma
- rightRecip : % -> Union(%, "failed")
- from MagmaWithUnit
- sample : () -> %
- from AbelianMonoid
- singular? : F -> Boolean
singular?(a) tests whether x = a is singular.
- singular? : UP -> Boolean
singular?(p) tests whether p(x) = 0 is singular.
- singularAtInfinity? : () -> Boolean
singularAtInfinity?() tests if there is a singularity at infinity.
- size : () -> NonNegativeInteger if Fraction(UP) has Finite
- from Finite
- sizeLess? : (%, %) -> Boolean
- from EuclideanDomain
- smaller? : (%, %) -> Boolean if Fraction(UP) has Finite
- from Comparable
- solveLinearPolynomialEquation : (List(SparseUnivariatePolynomial(%)), SparseUnivariatePolynomial(%)) -> Union(List(SparseUnivariatePolynomial(%)), "failed") if Fraction(UP) has FiniteFieldCategory
- from PolynomialFactorizationExplicit
- special_order : (%, List(UP)) -> Integer
special_order(f, lp) computes sum of orders at special places, that is at infinite places and at places over zeros in polynomials in lp. Elements of lp must be relatively prime.
- squareFree : % -> Factored(%)
- from UniqueFactorizationDomain
- squareFreePart : % -> %
- from UniqueFactorizationDomain
- squareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Fraction(UP) has FiniteFieldCategory
- from PolynomialFactorizationExplicit
- subtractIfCan : (%, %) -> Union(%, "failed")
- from CancellationAbelianMonoid
- tableForDiscreteLogarithm : Integer -> Table(PositiveInteger, NonNegativeInteger) if Fraction(UP) has FiniteFieldCategory
- from FiniteFieldCategory
- trace : % -> Fraction(UP)
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- traceMatrix : () -> Matrix(Fraction(UP))
- from FramedAlgebra(Fraction(UP), UPUP)
- traceMatrix : Vector(%) -> Matrix(Fraction(UP))
- from FiniteRankAlgebra(Fraction(UP), UPUP)
- unit? : % -> Boolean
- from EntireRing
- unitCanonical : % -> %
- from EntireRing
- unitNormal : % -> Record(unit : %, canonical : %, associate : %)
- from EntireRing
- yCoordinates : % -> Record(num : Vector(UP), den : UP)
yCoordinates(f) returns [[A1, ..., An], D] such that f = (A1 + A2 y +...+ An y^(n-1)) / D.
- zero? : % -> Boolean
- from AbelianMonoid
- ~= : (%, %) -> Boolean
- from BasicType
Module(Fraction(Integer))
NonAssociativeSemiRing
BiModule(%, %)
ConvertibleTo(InputForm)
Field
canonicalUnitNormal
FramedModule(Fraction(UP))
Rng
CoercibleFrom(Fraction(UP))
DifferentialExtension(Fraction(UP))
MonogenicAlgebra(Fraction(UP), UPUP)
CoercibleFrom(Integer)
TwoSidedRecip
SemiRing
EntireRing
NonAssociativeAlgebra(Fraction(UP))
NonAssociativeAlgebra(Fraction(Integer))
unitsKnown
CharacteristicNonZero
MagmaWithUnit
CoercibleTo(OutputForm)
RetractableTo(Fraction(Integer))
Magma
FullyLinearlyExplicitOver(Fraction(UP))
SemiGroup
RightModule(Fraction(Integer))
GcdDomain
IntegralDomain
LeftModule(%)
RetractableTo(Fraction(UP))
NonAssociativeRing
RightModule(Fraction(UP))
NonAssociativeAlgebra(%)
PartialDifferentialRing(Symbol)
CharacteristicZero
BiModule(Fraction(UP), Fraction(UP))
UniqueFactorizationDomain
CommutativeRing
Ring
Algebra(%)
CoercibleFrom(Fraction(Integer))
DifferentialRing
PolynomialFactorizationExplicit
DivisionRing
canonicalsClosed
ConvertibleTo(UPUP)
PrincipalIdealDomain
NonAssociativeSemiRng
CancellationAbelianMonoid
EuclideanDomain
Comparable
RetractableTo(Integer)
FramedAlgebra(Fraction(UP), UPUP)
AbelianMonoid
CommutativeStar
RightModule(%)
Hashable
FiniteRankAlgebra(Fraction(UP), UPUP)
Module(%)
LinearlyExplicitOver(Fraction(UP))
LinearlyExplicitOver(Integer)
SemiRng
Module(Fraction(UP))
LeftOreRing
Monoid
FiniteFieldCategory
LeftModule(Fraction(UP))
Finite
Algebra(Fraction(Integer))
BasicType
Algebra(Fraction(UP))
RightModule(Integer)
AbelianSemiGroup
SetCategory
noZeroDivisors
LeftModule(Fraction(Integer))
NonAssociativeRng
FieldOfPrimeCharacteristic
BiModule(Fraction(Integer), Fraction(Integer))
StepThrough
AbelianGroup
FullyRetractableTo(Fraction(UP))