Can we introduce a convention to ask whether or not a property of an object is known?

[HechtiDerLachs]

This has been touched upon in triage today when discussing #2721: Many times one has properties of an object which are potentially expensive to compute; one example being the dimension of an ideal. For MPolyQuoIdeals this is not known a priori. Yet one eventually wants to make an informed decision based on whether this property is known.

A dirty way to do this is to look whether or not a (hopefully corresponding) attribute is set; like for instance

if has_attribute(I, :dim) && dim(I) == 0
  # do something which takes advantage of the information that we have a 0-dimensional ideal
else
  # do something else
end

This has the disadvantage that not every concrete type of ideals has the information stored as an attribute. Maybe some of them use fields in the struct? So what one really wants to have is an official way to ask whether this information is present; just like

if has_known_dim(I) && dim(I) == 0
  # do something which takes advantage of the information that we have a 0-dimensional ideal
else
  # do something else
end

I would propose exactly this syntax: has_known_XYZ where XYZ is the name of the usual getter for the respective property.

But I'm afraid that similar things already have emerged and spread over OSCAR in other areas and people have used other names. If you are aware of such instances: Could you point them out here, so that we can gather them?

Then we could eventually make progress towards some informed decision whether we really want this feature and if so, in which form.

[lgoettgens]

For a lot of properties of GAP-backed objects we already have has_XYZ has the current existing method. Have e.g. a look in the exports.jl file and search for has_. Many results are on the same line as the corresponding export XYZ.

[joschmitt]

In Hecke there are some is_X_known where X is an (expensive to compute) property and the corresponding function that actually computes something would then be called is_X.

[HechtiDerLachs]

Thanks for the comments so far!

Imho the syntax is_X_known has the disadvantage that is_XYZ is already used for properties. So is_<TAB> will clutter my screen with all these functions, too, when I'm looking for something. has_known_XYZ is not yet taken and seems to me like a not-too-far stretch. Even though it is not as intuitive as is_XYZ_known.

has_XYZ seems a bit ambiguous to me. Of course, every ring has a dimension, so I would expect has_dim to always return true. I think has_known_dim is more clear here.

But that's just my five pennys.

[thofma]

Just to add to what @joschmitt said: is_*_known is used for predicates as well as attributes. The idea is that both is_prime_known(x) and is_primary_decomposition_known(x) make sense, and one can get the information by calling is_prime(x) respectively primary_decomposition(x). I find it intuitive that is_prime tab-completes to is_prime and is_prime_known.

(And I agree that that has_* without known is ambiguous.)

[fingolfin]

Just to mention another variant: In GAP the general way to do this is Tester(property)(object), i.e. Tester maps any attribute/property to a function which tests if the function/property is known.

We could do something similar in OSCAR with a different name; and of course we could also do it with 2 arguments instead of "single argument and returns a test function. I.e., some variants of this idea:

• tester(is_prime)(x)
• is_known(is_prime)(x)
• is_known(is_prime, x)
• known(is_prime, x)
  etc.

The two argument version then is very flexible. E.g.

# generic: assume property stored as attribute
is_known(p::Function, x) = has_attribute(x, nameof(p))

# for GAP objects: check if there is an underlying GAP filter and test that
is_known(p::Function, x::GapObj) = ...

# for an integer, testing whether it is even is basically free, so
# consider this as :known"
is_known(::typeof(is_even), x::Integer) = true

One could then also have a 3 argument variant that checks if the attribute is known and equal to the given value, i.e.:

is_known(p, x, val) = is_known(p,x) && p(x) == val

(though perhaps it should have a different name like is_known_and_equal_to. dunno)

[mjrodgers]

We need to think about how it is possible to handle this issue; it needs more discussion (is there a way to tab-complete possible properties to check?)

[thofma]

The minor problem with is_known(is_even, x) is that it makes it hard to find out which functions are supported. (Or maybe the idea is to have it default to false?). I think it would help if we change it to is_known(x, is_even). then is_known(x, TAB will do something useful.

Here I am mainly thinking about implementing things like

function is_known(x, ::typeof(is_maximal))
end

[fingolfin]

Oh, good point. Yeah, if we have the property last then tab completion is relatively helpful.

julia> is_known(x::Float64, ::typeof(isnan)) = true;

julia> is_known(x::Integer, ::typeof(iseven)) = true;

julia> is_known(x::Integer, ::typeof(isodd)) = true;

julia> is_known(1,   # pressing TAB after that gives:
is_known(x::Integer, ::typeof(isodd)) @ Main REPL[9]:1
is_known(x::Integer, ::typeof(iseven)) @ Main REPL[8]:1
julia> is_known(     # pressing TAB after that gives:
is_known(x::Float64, ::typeof(isnan)) @ Main REPL[7]:1
is_known(x::Integer, ::typeof(isodd)) @ Main REPL[9]:1
is_known(x::Integer, ::typeof(iseven)) @ Main REPL[8]:1
julia> is_known(1.,  # pressing TAB after that gives:
is_known(x::Float64, ::typeof(isnan)) @ Main REPL[7]:1

[fingolfin]

In addition, perhaps we could start providing something like can_compute(x, isBLA) or implements(x, isBLA) or so; that might be useful (in some cases) for certain algorithms, and certainly also for the conformance tests.

[fieker]

since we're dreaming, what about indirect properties? e.g. given a ring R can we do factoring in R[x]?

[fingolfin]

We agreed on the is_known(x, ::typeof(is_maximal)) variant suggested by @thofma and @HechtiDerLachs will make a first PR implementing it for dim in Oscar; but first a PR in AA adding a is_known stub there so we have the same is_known in all our packages.

[HechtiDerLachs]

See #4507 and Nemocas/AbstractAlgebra.jl#1974 in AbstractAlgebra.jl