Functions which change internal repr but not the semantics

[JohnAAbbott]

The convention in Julia/Oscar is that functions which (may) change at least one argument have names ending in !

Here is a simplified excerpt from my revision of PBFAlgebraQuo

function iszero(a::PBWAlgQuoElem)
  # why not call simplify! here?
  I = parent(a).I
  groebner_assure!(I)
  return iszero(Singular.reduce(a.data.sdata, I.gb))
end

Internally the function must reduce a modulo the ideal I and check whether the result is 0.
Now, in this context a and a mod I are semantically equivalent (but their representations may
differ). The function simplify! does the reduction, and then updates its argument.

May the function iszero silently update its argument to a "reduced" but equivalent value?
This could be a problem if iszero(a) is called while the caller has a reference to part of the
internal structure of a.

[JohnAAbbott]

It can happen that the "simplified" form is a large/uglier data-structure; but at least in the case that iszero(a)
determines that a is indeed 0, we could allow the value of a to be updated to 0... of course, this does complicate
the semantics of iszero for PBWAlgQuoElem values.

[fieker]

On Tue, Mar 07, 2023 at 07:28:47AM -0800, JohnAAbbott wrote: The convention in Julia/Oscar is that functions which (may) change at least one argument have names ending in !

We interpret this for mathematical changes, i.e. an element in a residue ring might be reduced to a unique rep without an "!"

…

Here is a simplified excerpt from my revision of PBFAlgebraQuo ``` function iszero(a::PBWAlgQuoElem) # why not call simplify! here? I = parent(a).I groebner_assure!(I) return iszero(Singular.reduce(a.data.sdata, I.gb)) end ``` Internally the function must reduce `a` modulo the ideal `I` and check whether the result is 0. Now, in this context `a` and `a mod I` are semantically equivalent (but their representations may differ). The function `simplify!` does the reduction, and then updates its argument. May the function `iszero` silently update its argument to a "reduced" but equivalent value? This could be a problem if `iszero(a)` is called while the caller has a reference to part of the internal structure of `a`. -- Reply to this email directly or view it on GitHub: #2014 You are receiving this because you are subscribed to this thread. Message ID: ***@***.***>

[thofma]

I think @wdecker explained to me a while ago that this should be simplify instead of simplify!, since it does not change the mathematical object.

Internally the function must reduce a modulo the ideal I and check whether the result is 0. Now, in this context a and a mod I are semantically equivalent (but their representations may differ). The function simplify! does the reduction, and then updates its argument.

May the function iszero silently update its argument to a "reduced" but equivalent value? This could be a problem if iszero(a) is called while the caller has a reference to part of the internal structure of a.

I think iszero is allowed to just call simplify!. If at someplace we are holding a reference to the internal structure of a, it is either a bug (because it is illegal), or at this point we know what we are doing.

[wdecker]

In MPolyQuo, the simplify! function for arguments of typeMPolyQuoRingElem was deleted. Now, we only have:

simplify(f::MPolyQuoRingElem)

If f is an element of the quotient of a multivariate polynomial ring R by an ideal I of R, say, replace the internal polynomial representative of f by its normal form mod I with respect to the default_ordering on R.

This should be handled similarly in PBWAlgebraQuo.

Out of curiosity: Where did you find the set-up of the iszero function as mentioned above?
In my version of PBWAlgebraQuo this looks different.

I support using simplify in iszero in the context of quotient rings. If there are no objections, I will change the function in MPolyQuo accordingly.

@JohnAAbbott Did you find other things of this type?

[JohnAAbbott]

In the file /home/zez25zuh/.julia/packages/Oscar/Iei9b/src/Rings/PBWAlgebraQuo.jl (without my changes) there is:

function iszero(a::PBWAlgQuoElem)
  iszero(a.data) && return true
  I = parent(a).I
  groebner_assure!(I)
  return iszero(Singular.reduce(a.data.sdata, I.gb))
end

The function simplify! still has the exclamation-mark, but is only internal (i.e. not exported). I can easily rename it to simplify (without exclamation mark), since all the changes are local.

[wdecker]

A check shoes that is_zero does already behave correctly for elements of type MPolyQuoRingElem.