Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Padic extensions #126

Open
wants to merge 32 commits into
base: master
Choose a base branch
from
Open

Padic extensions #126

wants to merge 32 commits into from

Conversation

swewers
Copy link
Contributor

@swewers swewers commented Jun 28, 2021

On this branch we develop a new version of the functionality for p-adic number fields. The original goal was to overcome the restriction to the base field, which still has to be QQ_p in many places. We took this opportunity to complete rewrite and reorganize the p-adic code.

At the moment, this is only a preliminary version. So far, we have

  • replaced the classes FakepAdicCompletion, Fake.. by new classes, most importantly pAdicNumberField, which is the new base class for p-adic number fields and extensions for p-adic number fields.
  • implemented the concept of an "approximate irreducible factor"; this is basically an equivalence class of irreducible polynomials which are approximations of an irreducible factor of a polynomial over a p-adic number field.
  • done some minimal changes to the semistable reduction code so that experimenting with curves over an arbitrary number field is now possible (with many restrictions still).

TODOs:

  • rewrite the code on subfields and the ramification filtration
  • more extensive documentation
  • interface to the Berkovich and the semistable reduction code

The plan is to keep this branch separate from the master branch until these issues have been fixed.

@swewers
Realize p-adic extensions
37d65ba 
On this branch we intend realize a first version of extensions of 'fake' 
p-adic number fields. This means we 
have to implement the missing methods in `FakepAdicEmbedding` and 
`FakepAdicExtension`.

In this first commit, these modules are made to comply with pyflake 
rules.
@swewers
key additions to fake_padic_embeddings
c3fe671 
- added computation of approximation of 
  1. the generator
  2. an element
  3. a polynomial
- removed obsolete `improve_approximation`
- new function `extensions_of_inductive_valuation`:
  compute all extensions of an inductive
  valuation v on K[x] to L[x], when a
  *fake* embedding K->L is given. 
- helper function `_all_augmentations`:
  this is a variant of MacLane's algorithm
  that may be useful in many other places
- added a warning in `fake_padic_extensions` 
  about possible error
- cosmetic changes to comply with pyflakes
@swewers
big new step: approximate factorization
7dddfa4 
There is a new module, 
`padic_extensions.approximate_factorizations`.

This is now where a weak splitting field of a polynomial can be 
computed.
@swewers
Simplify
6e7b333 
The results of the methods 
`approximate_uniformizer` and
`approximate_evaluation` are
simplified before returned.

This should result in some modest speedup.
@swewers
Deleted elements_of_fake_padic_completion
d385c23 
There is no plan to actually implement this.
@swewers
Very preliminary new version
9d75985 
Computing the splitting field
of a polynomial over an arbitrary
(fake) p-adic number field now
essentially works.

- for alrge examples, the computation
of an embedding into the extension
field takes too long
- for some error, there is an
  ad hoc fix
@swewers
First working version
1d413d2 
There is a new module `pAdicNumberField` which replaces 
`FakepAdicCompletion`

In principal one can now compute the (weak) splitting field of a 
polynomial over an
arbitrary p-adic number field.
However, this is still very unpolished and there are still many bugs.
@swewers
Removed FakepAdicCompletion
d3adc6a
@swewers
Semistable reduction now works again
13f3b5b 
Only small changes were necessary.

It is not clear if semistable reduction works over an arbitrary base 
field.
@swewers
Added notes explaining what we still need to work over
17f8b7e 
an arbitrary base field.

The crucial places are in 
`reduction_trees`, in
`lower_components` and `splitting_field`, and in
`weak_padic_galois:extensions`
@swewers
added ToDos for this branch
ce51308
@swewers
changed fake_padic_embeddings
6c5c1b0 
to `padic_embeddings`

In addition to changing the name, the new class `pAdicEmbeddings` can 
only be initialized by specifying 
an approximation fo the generator which satisfies the condition of 
Hensels Lemma.

Improving the approximation is done with p-adic Newton.
@swewers
Removed fake_padic_embeddings
7901c27
@swewers
Improved approximate_evaluation
4163e42 
It is now done in a *linear* way.
@swewers
Improved computation of embedding of simpel extension
b79d846 
More of the computation is done module Z/p^N, which makes
everything faster. 

The bottleneck for computing the weak splitting field is now the "base 
change" of the
irreducible components.
@swewers
Fixed a small bug.
948cd43 
We can now compute the splitting field of 

f =  x^8+28*x^2+28

in reasonable time. But this example also reveals a mysterious error in 
`weak_splitting_field`.
@swewers
New, preliminary version of approximate_factors
ad26f2e 
We use systematically `EnhancedValuations` which are
inductive valuations together with an equivalence class of key 
polynomials.
@swewers
Removed some obsolete stuff from approximate_factorizations
53daaa1
@swewers
Update of ToDo-List
4a78f38
@swewers
Implemented composition of embeddings of p-aidc number fields
7203968 
This is preliminary:

- it remains to choose the precision in such a way that the computation 
of the composition is guaranteed to succeed
- updated `weak_splitting_field` in an ad hoc manner. These changes 
should rather be done inside `pAdicExtensions`.
@swewers
New structure of p-adic extensions
c665f2e 
Main points:

- `fake_padic_extensions` has been replaced by `padic_extensions`
- `pAdicExtension` is a subclass of `pAdicNumberField`
- `pAdicExtension` has two subclasses, `ExactpAdicExtension` and 
`ApproximatepAdicExternsion`
- similar for `pAdicEmbeddings`

This is not yet working, but an experimental concept.
@swewers
The new structure now mostly works
9712280 
It remains to:

- implement "exact_extension"
- use this in `weak_splitting_field`
- deal with precision issues
- test, test, test
@swewers
First working version
398c103 
It is now possible to compute the weak splitting field of a 
polynomial over an arbitrary p-adic number field

But htis is a very preliminary version. Obvious problems:

- confusion between absolute and relative number fields
- inertai and ramification degrees are computed incorrectly; therefore 
several checks fail
@swewers
Preliminary commit
8191dbc 
This is only to wrote down where the problem lies at the moment:

- if pAdicNumberField is initialized with a relative number field, some 
things don't work properly. However, the concept of an exact extension 
uses relative number fields. 
- in ApproximatepAdicExtension.exact_extension there are many things 
unclear. In particular, the precison issue
- precision issue when initializing ApproximatepAdicEmbedding
@swewers
Another preliminary commit
dfaf7cb 
Most of the errors of the previous version have been fixed.

There remains an error we haven't noticed before, in 
ApproximatepAdicExtension.exact_extension. The problem occurs if f is 
not "Krasner separable".

Possible solution: an approximate irreducible factor may have extra 
precision, to distinguish factors of f.
@swewers
A version that works in most cases
d362be9 
The problems mentioned in the previous commit have been fixed (in a 
somewhat ad hoc way) by change the algorithm in 
`approximate_factorization`, so that the resulting factorization is fine 
enough to distinguish different factors.
@swewers
Small changes in padic_number_fields
2d9268f 
- improved some docstrings
- experimentally set the initial precision in `SimpleExtension` to 5
- deleted some obselete comments
- allow input (K_0, p) for `pAdicNumberField`
@swewers
Further progress
c9618b7 
- bug in creation of simple extension corrected: there is now a 
guaranteed choice of a generator

- documented an error from Sage in the valuation code, which shows up in 
`approximate_factorizations`

Up to errors due to Sage, everything seems to work now.
@swewers
Fixed problem with bug in Sage
027750a 
By using the option `compute_unit=False` in `equivalence_decomposition` 
the obnoxious error seems to be avoided.

There is also a new comment in the docstring of `weak_splitting_field` 
on how the speed may be improved.
@swewers
Some small improvements
d460cf0 
- `pAdicNumberField` now has its own method to approximate roots
- there is also now an inbuild estimate for the precision required to 
approximate the root of the minimal polynomial of the generator
@swewers
first version were computing semistable reduction over arbitrary base…
d5fde01 
… field works (in some cases)

- corrected error in `weak_splitting_field`, related to the minimal 
ramification.
- corrected an error in `EnhancedValuation.base_change`
- implemented the *base change* in reduction tree, in a very ad hoc way
@swewers
Some small changes and improvement
7b1651d 
- added `compute_unit=False` in two more places, to avoid a Sage error

- added method `required_precision` to `InertialComponent`; this is not 
used yet
- improved computation of integral basis of a p-adic number field; new 
option `int_basis` when converting field elements to vectors and vice 
versa
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers
No reviews
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
1 participant
@swewers