Hallo Ralf,

I found a criterium for binomials over finite fields to be irreducible,
this can be easily applied to your problem and I will implement this
criterium into FiniteFieldPolynomials in my revision:

(1) -> )r ffproblemSolved
-- of Ralf Hemmecke of Nov. 2019
P ==> PositiveInteger

                                                                                
         
Type: Void
                                                                                
        
Time: 0 sec
Z ==> Integer

                                                                                
         
Type: Void
                                                                                
        
Time: 0 sec
SI ==> SingleInteger

                                                                                
         
Type: Void
                                                                                
        
Time: 0 sec
maxi2 ==> shift(max()$SI, -1)::Z

                                                                                
         
Type: Void
                                                                                
        
Time: 0 sec
p := qcoerce(prevPrime(maxi2)$IntegerPrimesPackage(Z))@P


   (5)  2305843009213693921
                                                                              
Type: PositiveInteger
                                                                         
Time: 0.00 (OT) = 0.00 sec

p := nextPrime 1000000


   (6)  1000003
                                                                              
Type: PositiveInteger
                                                                                
        
Time: 0 sec
F ==> PrimeField p

                                                                                
         
Type: Void
                                                                                
        
Time: 0 sec
f := (x^4+x+1)::UP('x, F)


         4
   (8)  x  + x + 1
                                                   Type:
UnivariatePolynomial(x,PrimeField(1000003))
                                                                                
        
Time: 0 sec
factor f


         4
   (9)  x  + x + 1
                                         Type:
Factored(UnivariatePolynomial(x,PrimeField(1000003)))
                                                                                
        
Time: 0 sec
F2 ==> FiniteField(p, 2)

                                                                                
         
Type: Void
                                                                                
        
Time: 0 sec
ff := factor(f::UP('x, F2))


           2                                      2
   (11)  (x  + 264505 %B x + 244860 %B + 157432)(x  + 735498 %B x +
755143 %B + 157432)
                                      Type:
Factored(UnivariatePolynomial(x,FiniteField(1000003,2)))
                                                  Time: 0.00 (IN) + 0.00
(EV) + 0.00 (OT) = 0.00 sec
fl := factorList ff


   (12)
                               2
   [[flag = "prime", factor = x  + 264505 %B x + 244860 %B + 157432,
exponent = 1],
                               2
    [flag = "prime", factor = x  + 735498 %B x + 755143 %B + 157432,
exponent = 1]]
Type: List(Record(flag: Union("nil","sqfr","irred","prime"),factor:
UnivariatePolynomial(x,FiniteField(1000003,2)),exponent:
NonNegativeInteger))
                                                                                
        
Time: 0 sec
c2 := coefficient(fl.1.factor, 0)


   (13)  244860 %B + 157432
                                                                       
Type: FiniteField(1000003,2)
                                                                                
        
Time: 0 sec

w : F2 := primitiveElement()


   (14)  %B + 2
                                                                       
Type: FiniteField(1000003,2)
                                                                                
        
Time: 0 sec
order w


   (15)  1000006000008
                                                                              
Type: PositiveInteger
                                                                                
        
Time: 0 sec
f2 : SUP F2 := monomial(1,2) - w


          2
   (16)  ?  + 1000002 %B + 1000001
                                            Type:
SparseUnivariatePolynomial(FiniteField(1000003,2))
                                                                                
        
Time: 0 sec

--F4 ==> FiniteFieldExtension(F2, 2)
F4 ==> FiniteFieldExtensionByPolynomial(F2, f2)

                                                                                
         
Type: Void
                                                                                
        
Time: 0 sec
coerce(c2)$F4


   (18)  244860 %B + 157432
             Type:
FiniteFieldExtensionByPolynomial(FiniteField(1000003,2),?^2+(1000002*%B+1000001))
                                                                                
        
Time: 0 sec




Am 22.11.19 um 17:45 schrieb Ralf Hemmecke:
> Hello Johannes,
>
> That sounds like great news.
>
> For implementation of an ACF a la Steel, it would be good to also have
> the algebraic closure of GF(p) implemented. I think that should be
> doable by reducing by a triangular set of extension polynomials.
>
> Will you also look into this or should I implement it myself?
>
> Thank you
> Ralf
>
> PS: In Aldor instead of "without", I've seen "Meet" (the dual to Join),
> but I think that it is also not really implemented in Aldor.
>
> https://github.com/pippijn/aldor/blob/master/aldor/lib/aldor/src/lang/sal_lang.as#L93
>
>
> On 11/22/19 9:45 AM, Prof. Dr. Johannes Grabmeier privat wrote:
>> Hi all,
>>
>> I started a revision of the field stuff. E.g. Simple algebraic
>> extensions are MonogenicAlgebra 's, so I included this and learnt, that
>> in this case one inherits DifferentialExtension with more differential
>> operators.
>> I think noone needs them (please indicate, if there are other
>> opionons).  Actuallly, I also do not know, why we have a trivial
>> differential operator ( 0) in FiniteFieldCategory, because this category
>> claims to inherit vom DifferentialRing. Can anyone tell me, who needs
>> this, otherwise I would like to drop it. In any case, some domains have
>> functions inherited, which are no longer needed. E.g.
>> We have a degree function with values in OnePointCompletion
>> PositiveInteger to allow the degree of a transcendent element to be
>> infinite. However, in an algebraic extension of a finite field we never
>> have a transcendent element, hence degree should map to PositiveInteger.
>> So I want to drop the inherited degree function, because it is
>> superfluous. .
>>
>> A suggestion an question to the compiler specialists: Similar to "with"
>> can't we have a "without" to drop Categories or single functions.
>>

-- 
Mit freundlichen Grüßen

Johannes Grabmeier

Prof. Dr. Johannes Grabmeier
Köckstraße 1, D-94469 Deggendorf
Tel. +49-(0)-991-2979584, Tel. +49-(0)-151-681-70756
Tel. +49-(0)-991-3615-141 (d),  Fax: +49-(0)-32224-192688

-- 
You received this message because you are subscribed to the Google Groups 
"FriCAS - computer algebra system" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To view this discussion on the web visit 
https://groups.google.com/d/msgid/fricas-devel/d2672571-586d-7501-7c1f-6e1b01ec0d05%40grabmeier.net.
-- of Ralf Hemmecke of Nov. 2019
P ==> PositiveInteger
Z ==> Integer
SI ==> SingleInteger
maxi2 ==> shift(max()$SI, -1)::Z
p := qcoerce(prevPrime(maxi2)$IntegerPrimesPackage(Z))@P

p := nextPrime 1000000
F ==> PrimeField p
f := (x^4+x+1)::UP('x, F)
factor f
F2 ==> FiniteField(p, 2)
ff := factor(f::UP('x, F2))
fl := factorList ff
c2 := coefficient(fl.1.factor, 0)

w : F2 := primitiveElement()
order w
f2 : SUP F2 := monomial(1,2) - w

--F4 ==> FiniteFieldExtension(F2, 2)
F4 ==> FiniteFieldExtensionByPolynomial(F2, f2)
coerce(c2)$F4

Reply via email to