Category Archives: Expository

Advent of Code: Day 3

This is the third notebook in my posts on the Advent of Code challenges. The notebook in its original format can be found on my github.

Day 3: Spiral Memory

Numbers are arranged in a spiral

17  16  15  14  13
18   5   4   3  12
19   6   1   2  11
20   7   8   9  10
21  22  23---> ...

Given an integer n, what is its Manhattan Distance from the center (1) of the spiral? For instance, the distance of 3 is $2 = 1 + 1$, since it’s one space to the right and one space up from the center.

Here’s my idea. The bottom right corner of the $k$th layer is the integer $(2k+1)^2$, since that’s how many integers are contained within that square. The other three corners in that layer are $(2k+1)^2 – 2k, (2k+1)^2 – 4k$, and $(2k+1)^2 – 6k$. Finally, the closest spot on the $k$th layer to the origin is at distance $k$: these are the four “axis locations” halfway between the corners, at $(2k+1)^2 – k, (2k+1)^2 – 3k, (2k+1)^2 – 5k$, and $(2k+1)^2 – 7k$.

For instance when $k = 1$, the bottom right is $(2 + 1)^2 = 9$, and the four “axis locations” are $9 – 1, 9 – 3, 9-5$, and $9-7$. The “axis locations” are $k$ away, and the corners are $2k$ away.

So I will first find which layer the number is on. Then I’ll figure out which side it’s on, and then how far away it is from the nearest “axis location” or “corner”.

My given number happens to be 289326.

In [1]:
import math

def find_lowest_larger_odd_square(n):
    upper = math.ceil(n**.5)
    if upper %2 == 0:
        upper += 1
    return upper
In [2]:
assert find_lowest_larger_odd_square(39) == 7
assert find_lowest_larger_odd_square(26) == 7
assert find_lowest_larger_odd_square(25) == 5
In [3]:
find_lowest_larger_odd_square(289326)
Out[3]:
539
In [4]:
539**2 - 289326
Out[4]:
1195

It happens to be that our integer is very close to an odd square.
The square is $539^2$, and the distance to that square is $538$ from the center.

Note that $539 = 2(269) + 1$, so this is the $269$th layer of the square.
The previous corner to $539^2$ is $539^2 – 538$, and the previous corner to that is $539^2 – 2\cdot538 = 539^2 – 1076$.
This is the nearest corner.
How far away from the square is this corner?

(more…)

Posted in Expository, Programming, Python | Tagged , , | Leave a comment

Advent of Code: Day 2

This is the second notebook in my posts on the Advent of Code challenges. This notebook in its original format can be found on my github.

Day 2: Corruption Checksum, part I

You are given a table of integers. Find the difference between the maximum and minimum of each row, and add these differences together.

There is not a lot to say about this challenge. The plan is to read the file linewise, compute the difference on each line, and sum them up.

In [1]:
with open("input.txt", "r") as f:
    lines = f.readlines()
lines[0]
Out[1]:
'5048\t177\t5280\t5058\t4504\t3805\t5735\t220\t4362\t1809\t1521\t230\t772\t1088\t178\t1794\n'
In [2]:
l = lines[0]
l = l.split()
l
Out[2]:
['5048',
 '177',
 '5280',
 '5058',
 '4504',
 '3805',
 '5735',
 '220',
 '4362',
 '1809',
 '1521',
 '230',
 '772',
 '1088',
 '178',
 '1794']
In [3]:
def max_minus_min(line):
    '''Compute the difference between the largest and smallest integer in a line'''
    line = list(map(int, line.split()))
    return max(line) - min(line)

def sum_differences(lines):
    '''Sum the value of `max_minus_min` for each line in `lines`'''
    return sum(max_minus_min(line) for line in lines)
In [4]:
testcase = ['5 1 9 5','7 5 3', '2 4 6 8']
assert sum_differences(testcase) == 18
In [5]:
sum_differences(lines)
Out[5]:
58975

Mathematical Interlude

In line with the first day’s challenge, I’m inclined to ask what we should “expect.” But what we should expect is not well-defined in this case. Let us rephrase the problem in a randomized sense.

Suppose we are given a table, $n$ lines long, where each line consists of $m$ elements, that are each uniformly randomly chosen integers from $1$ to $10$. We might ask what is the expected value of this operation, of summing the differences between the maxima and minima of each row, on this table. What should we expect?

As each line is independent of the others, we are really asking what is the expected value across a single row. So given $m$ integers uniformly randomly chosen from $1$ to $10$, what is the expected value of the maximum, and what is the expected value of the minimum?

 

Expected Minimum

Let’s begin with the minimum. The minimum is $1$ unless all the integers are greater than $2$. This has probability
$$ 1 – \left( \frac{9}{10} \right)^m = \frac{10^m – 9^m}{10^m}$$
of occurring. We rewrite it as the version on the right for reasons that will soon be clear.
The minimum is $2$ if all the integers are at least $2$ (which can occur in $9$ different ways for each integer), but not all the integers are at least $3$ (each integer has $8$ different ways of being at least $3$). Thus this has probability
$$ \frac{9^m – 8^m}{10^m}.$$
Continuing to do one more for posterity, the minimum is $3$ if all the integers are at least $3$ (each integer has $8$ different ways of being at least $3$), but not all integers are at least $4$ (each integer has $7$ different ways of being at least $4$). Thus this has probability

$$ \frac{8^m – 7^m}{10^m}.$$

And so on.

Recall that the expected value of a random variable is

$$ E[X] = \sum x_i P(X = x_i),$$

so the expected value of the minimum is

$$ \frac{1}{10^m} \big( 1(10^m – 9^m) + 2(9^m – 8^m) + 3(8^m – 7^m) + \cdots + 9(2^m – 1^m) + 10(1^m – 0^m)\big).$$

This simplifies nicely to

$$ \sum_ {k = 1}^{10} \frac{k^m}{10^m}. $$

Expected Maximum

The same style of thinking shows that the expected value of the maximum is

$$ \frac{1}{10^m} \big( 10(10^m – 9^m) + 9(9^m – 8^m) + 8(8^m – 7^m) + \cdots + 2(2^m – 1^m) + 1(1^m – 0^m)\big).$$

This simplifies to

$$ \frac{1}{10^m} \big( 10 \cdot 10^m – 9^m – 8^m – \cdots – 2^m – 1^m \big) = 10 – \sum_ {k = 1}^{9} \frac{k^m}{10^m}.$$

Expected Difference

Subtracting, we find that the expected difference is

$$ 9 – 2\sum_ {k=1}^{9} \frac{k^m}{10^m}. $$

From this we can compute this for each list-length $m$. It is good to note that as $m \to \infty$, the expected value is $9$. Does this make sense? Yes, as when there are lots of values we should expect one to be a $10$ and one to be a $1$. It’s also pretty straightforward to see how to extend this to values of integers from $1$ to $N$.

Looking at the data, it does not appear that the integers were randomly chosen. Instead, there are very many relatively small integers and some relatively large integers. So we shouldn’t expect this toy analysis to accurately model this problem — the distribution is definitely not uniform random.
But we can try it out anyway.

(more…)

Posted in Expository, Programming, Python | Tagged , , | Leave a comment

Advent of Code: Day 1

I thoroughly enjoyed reading through Peter Norvig’s extraordinarily clean and nice solutions to the Advent of Code challenge last year. Inspired by his clean, literate programming style and the convenience of jupyter notebook demonstrations, I will look at several of these challenges in my own jupyter notebooks.

My background and intentions aren’t the same as Peter Norvig’s: his expertise dwarfs mine. And timezones are not kind to those of us in the UK, and thus I won’t be competing for a position on the leaderboards. These are to be fun. And sometimes there are tidbits of math that want to come out of the challenges.

Enough of that. Let’s dive into the first day.

Day 1: Inverse Captcha, Part 1

Given a sequence of digits, find the sum of those digits which match the following digit. The sequence is presumed circular, so the first digit may match the last digit.

This would probably be done the fastest by looping through the sequence.

In [1]:
with open('input.txt', 'r') as f:
    seq = f.read()
seq = seq.strip()
seq[:10]
Out[1]:
'1118313623'
In [2]:
def sum_matched_digits(s):
    "Sum of digits which match following digit, and first digit if it matches last digit"
    total = 0
    for a,b in zip(s, s[1:]+s[0]):
        if a == b:
            total += int(a)
    return total

They provide a few test cases which we use to test our method against.

In [3]:
assert sum_matched_digits('1122') == 3
assert sum_matched_digits('1111') == 4
assert sum_matched_digits('1234') == 0
assert sum_matched_digits('91212129') == 9

For fun, this is a oneline version.

(more…)

Posted in Expository, Programming, Python | Tagged , , | 1 Comment

A Jupyter Notebook from a SageMath tutorial

I gave an introduction to sage tutorial at the University of Warwick Computational Group seminar today, 2 November 2017. Below is a conversion of the sage/jupyter notebook I based the rest of the tutorial on. I said many things which are not included in the notebook, and during the seminar we added a few additional examples and took extra consideration to a few different calls. But for reference, the notebook is here.

The notebook itself (as a jupyter notebook) can be found and viewed on my github (link to jupyter notebook). When written, this notebook used a Sage 8.0.0.rc1 backend kernel and ran fine on the standard Sage 8.0 release , though I expect it to work fine with any recent official version of sage. The last cell requires an active notebook to be seen (or some way to export jupyter widgets to standalone javascript or something; this either doesn’t yet exist, or I am not aware of it).

I will also note that I converted the notebook for display on this website using jupyter’s nbconvert package. I have some CSS and syntax coloring set up that affects the display.

Good luck learning sage, and happy hacking.

Sage

Sage (also known as SageMath) is a general purpose computer algebra system written on top of the python language. In Mathematica, Magma, and Maple, one writes code in the mathematica-language, the magma-language, or the maple-language. Sage is python.

But no python background is necessary for the rest of today’s guided tutorial. The purpose of today’s tutorial is to give an indication about how one really uses sage, and what might be available to you if you want to try it out.

I will spoil the surprise by telling you upfront the two main points I hope you’ll take away from this tutorial.

  1. With tab-completion and documentation, you can do many things in sage without ever having done them before.
  2. The ecosystem of libraries and functionality available in sage is tremendous, and (usually) pretty easy to use.

Lightning Preview

Let’s first get a small feel for sage by seeing some standard operations and what typical use looks like through a series of trivial, mostly unconnected examples.

In [1]:
# Fundamental manipulations work as you hope

2+3
Out[1]:
5

You can also subtract, multiply, divide, exponentiate…

>>> 3-2
1
>>> 2*3
6
>>> 2^3
8
>>> 2**3 # (also exponentiation)
8

There is an order of operations, but these things work pretty much as you want them to work. You might try out several different operations.

Sage includes a lot of functionality, too. For instance,

In [2]:
factor(-1008)
Out[2]:
-1 * 2^4 * 3^2 * 7
In [3]:
list(factor(1008))
Out[3]:
[(2, 4), (3, 2), (7, 1)]

In the background, Sage is actually calling on pari/GP to do this factorization. Sage bundles lots of free and open source math software within it (which is why it’s so large), and provides a common access point. The great thing here is that you can often use sage without needing to know much pari/GP (or other software).

Sage knows many functions and constants, and these are accessible.

(more…)

Posted in Expository, Mathematics, sage, sagemath | Tagged , , , , , | Leave a comment

Sage Days 87 Demo: Interfacing between sage and the LMFDB

Interfacing sage and the LMFDB — a prototype

The lmfdb and sagemath are both great things, but they don’t currently talk to each other. Much of the lmfdb calls sage, but the lmfdb also includes vast amounts of data on $L$-functions and modular forms (hence the name) that is not accessible from within sage.
This is an example prototype of an interface to the lmfdb from sage. Keep in mind that this is a prototype and every aspect can change. But we hope to show what may be possible in the future. If you have requests, comments, or questions, please request/comment/ask either now, or at my email: david@lowryduda.com.

Note that this notebook is available on http://davidlowryduda.com or https://gist.github.com/davidlowryduda/deb1f88cc60b6e1243df8dd8f4601cde, and the code is available at https://github.com/davidlowryduda/sage2lmfdb

Let’s dive into an example.

In [1]:
# These names will change
from sage.all import *
import LMFDB2sage.elliptic_curves as lmfdb_ecurve
In [2]:
lmfdb_ecurve.search(rank=1)
Out[2]:
[Elliptic Curve defined by y^2 + x*y = x^3 - 887688*x - 321987008 over Rational Field,
 Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 + 10795*x - 97828 over Rational Field,
 Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 2294115305*x - 42292668425178 over Rational Field,
 Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 3170*x - 49318 over Rational Field,
 Elliptic Curve defined by y^2 + y = x^3 + 1050*x - 26469 over Rational Field,
 Elliptic Curve defined by y^2 + x*y = x^3 - x^2 - 1240542*x - 531472509 over Rational Field,
 Elliptic Curve defined by y^2 + y = x^3 - x^2 + 8100*x - 263219 over Rational Field,
 Elliptic Curve defined by y^2 + x*y = x^3 + 637*x - 68783 over Rational Field,
 Elliptic Curve defined by y^2 + y = x^3 + x^2 + 36*x - 380 over Rational Field,
 Elliptic Curve defined by y^2 + y = x^3 + x^2 - 2535*x - 49982 over Rational Field]
This returns 10 elliptic curves of rank 1. But these are a bit different than sage’s elliptic curves.

In [3]:
Es = lmfdb_ecurve.search(rank=1)
E = Es[0]
print(type(E))
<class 'LMFDB2sage.ell_lmfdb.EllipticCurve_rational_field_lmfdb_with_category'>
Note that the class of an elliptic curve is an lmfdb ElliptcCurve. But don’t worry, this is a subclass of a normal elliptic curve. So we can call the normal things one might call on an elliptic curve.

th

In [4]:
# Try autocompleting the following. It has all the things!
print(dir(E))
['CPS_height_bound', 'CartesianProduct',
'Chow_form', 'Hom',
'Jacobian', 'Jacobian_matrix',
'Lambda', 'Np',
'S_integral_points', '_AlgebraicScheme__A',
'_AlgebraicScheme__divisor_group', '_AlgebraicScheme_subscheme__polys',
'_EllipticCurve_generic__ainvs', '_EllipticCurve_generic__b_invariants',
'_EllipticCurve_generic__base_ring', '_EllipticCurve_generic__discriminant',
'_EllipticCurve_generic__is_over_RationalField', '_EllipticCurve_generic__multiple_x_denominator',
'_EllipticCurve_generic__multiple_x_numerator', '_EllipticCurve_rational_field__conductor_pari',
'_EllipticCurve_rational_field__generalized_congruence_number', '_EllipticCurve_rational_field__generalized_modular_degree',
'_EllipticCurve_rational_field__gens', '_EllipticCurve_rational_field__modular_degree',
'_EllipticCurve_rational_field__np', '_EllipticCurve_rational_field__rank',
'_EllipticCurve_rational_field__regulator', '_EllipticCurve_rational_field__torsion_order',
'_Hom_', '__add__', '__cached_methods', '__call__',
'__class__', '__cmp__', '__contains__', '__delattr__',
'__dict__', '__dir__', '__div__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__getstate__', '__gt__', '__hash__',
'__init__', '__le__', '__lt__', '__make_element_class__',
'__module__', '__mul__', '__ne__', '__new__',
'__nonzero__', '__pari__', '__pow__', '__pyx_vtable__',
'__rdiv__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmul__', '__setattr__', '__setstate__', '__sizeof__',
'__str__', '__subclasshook__', '__temporarily_change_names', '__truediv__',
'__weakref__', '_abstract_element_class', '_adjust_heegner_index', '_an_element_',
'_ascii_art_', '_assign_names', '_axiom_', '_axiom_init_',
'_base', '_base_ring', '_base_scheme', '_best_affine_patch',
'_cache__point_homset', '_cache_an_element', '_cache_key', '_check_satisfies_equations',
'_cmp_', '_coerce_map_from_', '_coerce_map_via', '_coercions_used',
'_compute_gens', '_convert_map_from_', '_convert_method_name', '_defining_names',
'_defining_params_', '_doccls', '_element_constructor', '_element_constructor_',
'_element_constructor_from_element_class', '_element_init_pass_parent', '_factory_data', '_first_ngens',
'_forward_image', '_fricas_', '_fricas_init_', '_gap_',
'_gap_init_', '_generalized_congmod_numbers', '_generic_coerce_map', '_generic_convert_map',
'_get_action_', '_get_local_data', '_giac_', '_giac_init_',
'_gp_', '_gp_init_', '_heegner_best_tau', '_heegner_forms_list',
'_heegner_index_in_EK', '_homset', '_init_category_', '_initial_action_list',
'_initial_coerce_list', '_initial_convert_list', '_interface_', '_interface_init_',
'_interface_is_cached_', '_internal_coerce_map_from', '_internal_convert_map_from', '_introspect_coerce',
'_is_category_initialized', '_is_valid_homomorphism_', '_isoclass', '_json',
'_kash_', '_kash_init_', '_known_points', '_latex_',
'_lmfdb_label', '_lmfdb_regulator', '_macaulay2_', '_macaulay2_init_',
'_magma_init_', '_maple_', '_maple_init_', '_mathematica_',
'_mathematica_init_', '_maxima_', '_maxima_init_', '_maxima_lib_',
'_maxima_lib_init_', '_modsym', '_modular_symbol_normalize', '_morphism',
'_multiple_of_degree_of_isogeny_to_optimal_curve', '_multiple_x_denominator', '_multiple_x_numerator', '_names',
'_normalize_padic_lseries', '_octave_', '_octave_init_', '_p_primary_torsion_basis',
'_pari_', '_pari_init_', '_point', '_point_homset',
'_polymake_', '_polymake_init_', '_populate_coercion_lists_', '_r_init_',
'_reduce_model', '_reduce_point', '_reduction', '_refine_category_',
'_repr_', '_repr_option', '_repr_type', '_sage_',
'_scale_by_units', '_set_conductor', '_set_cremona_label', '_set_element_constructor',
'_set_gens', '_set_modular_degree', '_set_rank', '_set_torsion_order',
'_shortest_paths', '_singular_', '_singular_init_', '_symbolic_',
'_test_an_element', '_test_cardinality', '_test_category', '_test_elements',
'_test_elements_eq_reflexive', '_test_elements_eq_symmetric', '_test_elements_eq_transitive', '_test_elements_neq',
'_test_eq', '_test_new', '_test_not_implemented_methods', '_test_pickling',
'_test_some_elements', '_tester', '_torsion_bound', '_unicode_art_',
'_unset_category', '_unset_coercions_used', '_unset_embedding', 'a1',
'a2', 'a3', 'a4', 'a6',
'a_invariants', 'abelian_variety', 'affine_patch', 'ainvs',
'algebra', 'ambient_space', 'an', 'an_element',
'analytic_rank', 'analytic_rank_upper_bound', 'anlist', 'antilogarithm',
'ap', 'aplist', 'arithmetic_genus', 'automorphisms',
'b2', 'b4', 'b6', 'b8',
'b_invariants', 'base', 'base_extend', 'base_field',
'base_morphism', 'base_ring', 'base_scheme', 'c4',
'c6', 'c_invariants', 'cartesian_product', 'categories',
'category', 'change_ring', 'change_weierstrass_model', 'cm_discriminant',
'codimension', 'coerce', 'coerce_embedding', 'coerce_map_from',
'complement', 'conductor', 'congruence_number', 'construction',
'convert_map_from', 'coordinate_ring', 'count_points', 'cremona_label',
'database_attributes', 'database_curve', 'db', 'defining_ideal',
'defining_polynomial', 'defining_polynomials', 'degree', 'descend_to',
'dimension', 'dimension_absolute', 'dimension_relative', 'discriminant',
'division_field', 'division_polynomial', 'division_polynomial_0', 'divisor',
'divisor_group', 'divisor_of_function', 'dual', 'dump',
'dumps', 'element_class', 'elliptic_exponential', 'embedding_center',
'embedding_morphism', 'eval_modular_form', 'excellent_position', 'formal',
'formal_group', 'fundamental_group', 'galois_representation', 'gen',
'gens', 'gens_certain', 'gens_dict', 'gens_dict_recursive',
'genus', 'geometric_genus', 'get_action', 'global_integral_model',
'global_minimal_model', 'global_minimality_class', 'has_additive_reduction', 'has_bad_reduction',
'has_base', 'has_cm', 'has_coerce_map_from', 'has_global_minimal_model',
'has_good_reduction', 'has_good_reduction_outside_S', 'has_multiplicative_reduction', 'has_nonsplit_multiplicative_reduction',
'has_rational_cm', 'has_split_multiplicative_reduction', 'hasse_invariant', 'heegner_discriminants',
'heegner_discriminants_list', 'heegner_index', 'heegner_index_bound', 'heegner_point',
'heegner_point_height', 'heegner_sha_an', 'height', 'height_function',
'height_pairing_matrix', 'hom', 'hyperelliptic_polynomials', 'identity_morphism',
'inject_variables', 'integral_model', 'integral_points', 'integral_short_weierstrass_model',
'integral_weierstrass_model', 'integral_x_coords_in_interval', 'intersection', 'intersection_multiplicity',
'intersection_points', 'intersects_at', 'irreducible_components', 'is_atomic_repr',
'is_coercion_cached', 'is_complete_intersection', 'is_conversion_cached', 'is_exact',
'is_global_integral_model', 'is_global_minimal_model', 'is_good', 'is_integral',
'is_irreducible', 'is_isogenous', 'is_isomorphic', 'is_local_integral_model',
'is_minimal', 'is_on_curve', 'is_ordinary', 'is_ordinary_singularity',
'is_p_integral', 'is_p_minimal', 'is_parent_of', 'is_projective',
'is_quadratic_twist', 'is_quartic_twist', 'is_semistable', 'is_sextic_twist',
'is_singular', 'is_smooth', 'is_supersingular', 'is_transverse',
'is_x_coord', 'isogenies_prime_degree', 'isogeny', 'isogeny_class',
'isogeny_codomain', 'isogeny_degree', 'isogeny_graph', 'isomorphism_to',
'isomorphisms', 'j_invariant', 'kodaira_symbol', 'kodaira_type',
'kodaira_type_old', 'kolyvagin_point', 'label', 'latex_name',
'latex_variable_names', 'lift_x', 'lll_reduce', 'lmfdb_page',
'local_coordinates', 'local_data', 'local_integral_model', 'local_minimal_model',
'lseries', 'lseries_gross_zagier', 'manin_constant', 'matrix_of_frobenius',
'minimal_discriminant_ideal', 'minimal_model', 'minimal_quadratic_twist', 'mod5family',
'modular_degree', 'modular_form', 'modular_parametrization', 'modular_symbol',
'modular_symbol_numerical', 'modular_symbol_space', 'multiplication_by_m', 'multiplication_by_m_isogeny',
'multiplicity', 'mwrank', 'mwrank_curve', 'neighborhood',
'newform', 'ngens', 'non_minimal_primes', 'nth_iterate',
'objgen', 'objgens', 'optimal_curve', 'orbit',
'ordinary_model', 'ordinary_primes', 'padic_E2', 'padic_height',
'padic_height_pairing_matrix', 'padic_height_via_multiply', 'padic_lseries', 'padic_regulator',
'padic_sigma', 'padic_sigma_truncated', 'parent', 'pari_curve',
'pari_mincurve', 'period_lattice', 'plane_projection', 'plot',
'point', 'point_homset', 'point_search', 'point_set',
'pollack_stevens_modular_symbol', 'preimage', 'projection', 'prove_BSD',
'q_eigenform', 'q_expansion', 'quadratic_transform', 'quadratic_twist',
'quartic_twist', 'rank', 'rank_bound', 'rank_bounds',
'rational_parameterization', 'rational_points', 'real_components', 'reduce',
'reduction', 'register_action', 'register_coercion', 'register_conversion',
'register_embedding', 'regulator', 'regulator_of_points', 'rename',
'reset_name', 'root_number', 'rst_transform', 'satisfies_heegner_hypothesis',
'saturation', 'save', 'scale_curve', 'selmer_rank',
'sextic_twist', 'sha', 'short_weierstrass_model', 'silverman_height_bound',
'simon_two_descent', 'singular_points', 'singular_subscheme', 'some_elements',
'specialization', 'structure_morphism', 'supersingular_primes', 'tamagawa_exponent',
'tamagawa_number', 'tamagawa_number_old', 'tamagawa_numbers', 'tamagawa_product',
'tamagawa_product_bsd', 'tangents', 'tate_curve', 'three_selmer_rank',
'torsion_order', 'torsion_points', 'torsion_polynomial', 'torsion_subgroup',
'two_descent', 'two_descent_simon', 'two_division_polynomial', 'two_torsion_rank',
'union', 'variable_name', 'variable_names', 'weierstrass_p',
'weil_restriction', 'zeta_series']
All the things
This gives quick access to some data that is not stored within the LMFDB, but which is relatively quickly computable. For example,

In [5]:
E.defining_ideal()
Out[5]:
Ideal (-x^3 + x*y*z + y^2*z + 887688*x*z^2 + 321987008*z^3) of Multivariate Polynomial Ring in x, y, z over Rational Field
But one of the great powers is that there are some things which are computed and stored in the LMFDB, and not in sage. We can now immediately give many examples of rank 3 elliptic curves with:

In [6]:
Es = lmfdb_ecurve.search(conductor=11050, torsion_order=2)
print("There are {} curves returned.".format(len(Es)))
E = Es[0]
print(E)
There are 10 curves returned.
Elliptic Curve defined by y^2 + x*y + y = x^3 - 3476*x - 79152 over Rational Field
And for these curves, the lmfdb contains data on its rank, generators, regulator, and so on.

In [7]:
print(E.gens())
print(E.rank())
print(E.regulator())
[(-34 : 17 : 1)]
1
1.63852610029
In [8]:
res = []
%time for E in Es: res.append(E.gens()); res.append(E.rank()); res.append(E.regulator())
CPU times: user 971 ms, sys: 6.82 ms, total: 978 ms
Wall time: 978 ms
That’s pretty fast, and this is because all of this was pulled from the LMFDB when the curves were returned by the search() function.
In this case, elliptic curves over the rationals are only an okay example, as they’re really well studied and sage can compute much of the data very quickly. On the other hand, through the LMFDB there are millions of examples and corresponding data at one’s fingertips.

This is where we’re really looking for input.

Think of what you might want to have easy access to through an interface from sage to the LMFDB, and tell us. We’re actively seeking comments, suggestions, and requests. Elliptic curves over the rationals are a prototype, and the LMFDB has lots of (much more challenging to compute) data. There is data on the LMFDB that is simply not accessible from within sage.
email: david@lowryduda.com, or post an issue on https://github.com/LMFDB/lmfdb/issues

Now let’s describe what’s going on under the hood a little bit

There is an API for the LMFDB at http://beta.lmfdb.org/api/. This API is a bit green, and we will change certain aspects of it to behave better in the future. A call to the API looks like

http://beta.lmfdb.org/api/elliptic_curves/curves/?rank=i1&conductor=i11050

The result is a large mess of data, which can be exported as json and parsed.
But that’s hard, and the resulting data are not sage objects. They are just strings or ints, and these require time and thought to parse.
So we created a module in sage that writes the API call and parses the output back into sage objects. The 22 curves given by the above API call are the same 22 curves returned by this call:

In [9]:
Es = lmfdb_ecurve.search(rank=1, conductor=11050, max_items=25)
print(len(Es))
E = Es[0]
22
The total functionality of this search function is visible from its current documentation.

In [10]:
# Execute this cell for the documentation
print(lmfdb_ecurve.search.__doc__)
    Search the LMFDB for an elliptic curve.

    Note that all inputs are optional, but at least one input is necessary.

    INPUT:

    -  ``label=l`` -- a string ``l`` representing a label in the LMFDB.

    -  ``degree=d`` -- an int ``d`` giving the minimum degree of a
       parameterization of the modular curve

    -  ``conductor=c`` -- an int ``c`` giving the conductor of the curve

    -  ``min_conductor=mc`` -- an int ``mc`` giving a lower bound on the
       conductor for desired curves

    -  ``max_conductor=mc`` -- an int ``mc`` giving an upper bound on the
       conductor for desired curves

    -  ``torsion_order=t`` -- an int ``t`` giving the order of the torsion
       subgroup of the curve

    -  ``rank=r`` -- an int ``r`` giving the rank of the curve

    -  ``regulator=f`` -- a float ``f`` giving the regulator of the curve

    -  ``max_items=m`` -- an int ``m`` (default: 10, max: 100) indicating the
       maximum number of results to return

    -  ``base_item=b`` -- an int ``b`` (default: 0) specifying where to start
       returning values from. The search will begin by returning the ``b``th
       curve. Combined with ``max_items`` to return data in chunks.

    -  ``sort=s`` -- a string ``s`` specifying what database field to sort the
       results on. See the LMFDB api for more info.

    EXAMPLES::

        sage: Es = search(conductor=11050, rank=2)
        [Elliptic Curve defined by y^2 + x*y = x^3 - x^2 - 442*x + 1716 over Rational Field, Elliptic Curve defined by y^2 + x*y = x^3 - x^2 + 1558*x + 11716 over Rational Field]
        sage: E = E[0]
        sage: E.conductor()
        11050
    
In [11]:
# So, for instance, one could perform the following search, finding a unique elliptic curve
lmfdb_ecurve.search(rank=2, torsion_order=3, degree=4608)
Out[11]:
[Elliptic Curve defined by y^2 + y = x^3 + x^2 - 5155*x + 140756 over Rational Field]

What if there are no curves?

If there are no curves satisfying the search criteria, then a message is displayed and that’s that. These searches may take a couple of seconds to complete.
For example, no elliptic curve in the database has rank 5.

In [12]:
lmfdb_ecurve.search(rank=5)
No fields were found satisfying input criteria.

How does one step through the data?

Right now, at most 100 curves are returned in a single API call. This is the limit even from directly querying the API. But one can pass in the argument base_item (the name will probably change… to skip? or perhaps to offset?) to start returning at the base_itemth element.

In [13]:
from pprint import pprint
pprint(lmfdb_ecurve.search(rank=1, max_items=3))              # The last item in this list
print('')
pprint(lmfdb_ecurve.search(rank=1, max_items=3, base_item=2)) # should be the first item in this list
[Elliptic Curve defined by y^2 + x*y = x^3 - 887688*x - 321987008 over Rational Field,
 Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 + 10795*x - 97828 over Rational Field,
 Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 2294115305*x - 42292668425178 over Rational Field]

[Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 2294115305*x - 42292668425178 over Rational Field,
 Elliptic Curve defined by y^2 + x*y + y = x^3 - x^2 - 3170*x - 49318 over Rational Field,
 Elliptic Curve defined by y^2 + y = x^3 + 1050*x - 26469 over Rational Field]
Included in the documentation is also a bit of hopefulness. Right now, the LMFDB API does not actually accept max_conductor or min_conductor (or arguments of that type). But it will sometime. (This introduces a few extra difficulties on the server side, and so it will take some extra time to decide how to do this).

In [14]:
lmfdb_ecurve.search(rank=1, min_conductor=500, max_conductor=10000)  # Not implemented
---------------------------------------------------------------------------
NotImplementedError                       Traceback (most recent call last)
<ipython-input-14-3d98f2cf7a13> in <module>()
----> 1 lmfdb_ecurve.search(rank=Integer(1), min_conductor=Integer(500), max_conductor=Integer(10000))  # Not implemented

/home/djlowry/Dropbox/EllipticCurve_LMFDB/LMFDB2sage/elliptic_curves.py in search(**kwargs)
     76             kwargs[item]
     77             raise NotImplementedError("This would be a great thing to have, " +
---> 78                 "but the LMFDB api does not yet provide this functionality.")
     79         except KeyError:
     80             pass

NotImplementedError: This would be a great thing to have, but the LMFDB api does not yet provide this functionality.
Our EllipticCurve_rational_field_lmfdb class constructs a sage elliptic curve from the json and overrides (somem of the) the default methods in sage if there is quicker data available on the LMFDB. In principle, this new object is just a sage object with some slightly different methods.
Generically, documentation and introspection on objects from this class should work. Much of sage’s documentation carries through directly.

In [15]:
print(E.gens.__doc__)
        Return generators for the Mordell-Weil group E(Q) *modulo*
        torsion.

        .. warning::

           If the program fails to give a provably correct result, it
           prints a warning message, but does not raise an
           exception. Use :meth:`~gens_certain` to find out if this
           warning message was printed.

        INPUT:

        - ``proof`` -- bool or None (default None), see
          ``proof.elliptic_curve`` or ``sage.structure.proof``

        - ``verbose`` - (default: None), if specified changes the
           verbosity of mwrank computations

        - ``rank1_search`` - (default: 10), if the curve has analytic
          rank 1, try to find a generator by a direct search up to
          this logarithmic height.  If this fails, the usual mwrank
          procedure is called.

        - algorithm -- one of the following:

          - ``'mwrank_shell'`` (default) -- call mwrank shell command

          - ``'mwrank_lib'`` -- call mwrank C library

        - ``only_use_mwrank`` -- bool (default True) if False, first
          attempts to use more naive, natively implemented methods

        - ``use_database`` -- bool (default True) if True, attempts to
          find curve and gens in the (optional) database

        - ``descent_second_limit`` -- (default: 12) used in 2-descent

        - ``sat_bound`` -- (default: 1000) bound on primes used in
          saturation.  If the computed bound on the index of the
          points found by two-descent in the Mordell-Weil group is
          greater than this, a warning message will be displayed.

        OUTPUT:

        - ``generators`` - list of generators for the Mordell-Weil
           group modulo torsion

        IMPLEMENTATION: Uses Cremona's mwrank C library.

        EXAMPLES::

            sage: E = EllipticCurve('389a')
            sage: E.gens()                 # random output
            [(-1 : 1 : 1), (0 : 0 : 1)]

        A non-integral example::

            sage: E = EllipticCurve([-3/8,-2/3])
            sage: E.gens() # random (up to sign)
            [(10/9 : 29/54 : 1)]

        A non-minimal example::

            sage: E = EllipticCurve('389a1')
            sage: E1 = E.change_weierstrass_model([1/20,0,0,0]); E1
            Elliptic Curve defined by y^2 + 8000*y = x^3 + 400*x^2 - 320000*x over Rational Field
            sage: E1.gens() # random (if database not used)
            [(-400 : 8000 : 1), (0 : -8000 : 1)]
        
Modified methods should have a note indicating that the data comes from the LMFDB, and then give sage’s documentation. This is not yet implemented. (So if you examine the current version, you can see some incomplete docstrings like regulator().)

In [16]:
print(E.regulator.__doc__)
        Return the regulator of the curve. This is taken from the lmfdb if available.

        NOTE:
            In later implementations, this docstring will probably include the
            docstring from sage's regular implementation. But that's not
            currently the case.
        

This concludes our demo of an interface between sage and the LMFDB.

Thank you, and if you have any questions, comments, or concerns, please find me/email me/raise an issue on LMFDB’s github.
XKCD's automation

Posted in Expository, LMFDB, Math.NT, Mathematics, Programming, Python, sagemath | Tagged , , , , , , , | Leave a comment

Smooth Sums to Sharp Sums 1

In this note, I describe a combination of two smoothed integral transforms that has been very useful in my collaborations with Alex Walker, Chan Ieong Kuan, and Tom Hulse. I suspect that this particular technique was once very well-known. But we were not familiar with it, and so I describe it here.

In application, this is somewhat more complicated. But to show the technique, I apply it to reprove some classic bounds on $\text{GL}(2)$ $L$-functions.

This note is also available as a pdf. This was first written as a LaTeX document, and then modified to fit into wordpress through latex2jax.

Introduction

Consider a Dirichlet series
$$\begin{equation}
D(s) = \sum_{n \geq 1} \frac{a(n)}{n^s}. \notag
\end{equation}$$
Suppose that this Dirichlet series converges absolutely for $\Re s > 1$, has meromorphic continuation to the complex plane, and satisfies a functional equation of shape
$$\begin{equation}
\Lambda(s) := G(s) D(s) = \epsilon \Lambda(1-s), \notag
\end{equation}$$
where $\lvert \epsilon \rvert = 1$ and $G(s)$ is a product of Gamma factors.

Dirichlet series are often used as a tool to study number theoretic functions with multiplicative properties. By studying the analytic properties of the Dirichlet series, one hopes to extract information about the coefficients $a(n)$. Some of the most common interesting information within Dirichlet series comes from partial sums
$$\begin{equation}
S(n) = \sum_{m \leq n} a(m). \notag
\end{equation}$$
For example, the Gauss Circle and Dirichlet Divisor problems can both be stated as problems concerning sums of coefficients of Dirichlet series.

One can try to understand the partial sum directly by understanding the integral transform
$$\begin{equation}
S(n) = \frac{1}{2\pi i} \int_{(2)} D(s) \frac{X^s}{s} ds, \notag
\end{equation}$$
a Perron integral. However, it is often challenging to understand this integral, as delicate properties concerning the convergence of the integral often come into play.

Instead, one often tries to understand a smoothed sum of the form
$$\begin{equation}
\sum_{m \geq 1} a(m) v(m) \notag
\end{equation}$$
where $v(m)$ is a smooth function that vanishes or decays extremely quickly for values of $m$ larger than $n$. A large class of smoothed sums can be obtained by starting with a very nicely behaved weight function $v(m)$ and take its Mellin transform
$$\begin{equation}
V(s) = \int_0^\infty v(x) x^s \frac{dx}{x}. \notag
\end{equation}$$
Then Mellin inversion gives that
$$\begin{equation}
\sum_{m \geq 1} a(m) v(m/X) = \frac{1}{2\pi i} \int_{(2)} D(s) X^s V(s) ds, \notag
\end{equation}$$
as long as $v$ and $V$ are nice enough functions.

In this note, we will use two smoothing integral transforms and corresponding smoothed sums. We will use one smooth function $v_1$ (which depends on another parameter $Y$) with the property that
$$\begin{equation}
\sum_{m \geq 1} a(m) v_1(m/X) \approx \sum_{\lvert m – X \rvert < X/Y} a(m). \notag
\end{equation}$$
And we will use another smooth function $v_2$ (which also depends on $Y$) with the property that
$$\begin{equation}
\sum_{m \geq 1} a(m) v_2(m/X) = \sum_{m \leq X} a(m) + \sum_{X < m < X + X/Y} a(m) v_2(m/X). \notag
\end{equation}$$
Further, as long as the coefficients $a(m)$ are nonnegative, it will be true that
$$\begin{equation}
\sum_{X < m < X + X/Y} a(m) v_2(m/X) \ll \sum_{\lvert m – X \rvert < X/Y} a(m), \notag
\end{equation}$$
which is exactly what $\sum a(m) v_1(m/X)$ estimates. Therefore
$$\begin{equation}\label{eq:overall_plan}
\sum_{m \leq X} a(m) = \sum_{m \geq 1} a(m) v_2(m/X) + O\Big(\sum_{m \geq 1} a(m) v_1(m/X) \Big).
\end{equation}$$

Hence sufficient understanding of $\sum a(m) v_1(m/X)$ and $\sum a(m) v_2(m/X)$ allows one to understand the sharp sum
$$\begin{equation}
\sum_{m \leq X} a(m). \notag
\end{equation}$$

(more…)

Posted in Expository, Math.NT, Mathematics | Tagged , , , , | 3 Comments

Computing pi with tools from Calculus

Computing $\pi$

This note was originally written in the context of my fall Math 100 class at Brown University. It is also available as a pdf note.

While investigating Taylor series, we proved that
\begin{equation}\label{eq:base}
\frac{\pi}{4} = 1 – \frac{1}{3} + \frac{1}{5} – \frac{1}{7} + \frac{1}{9} + \cdots
\end{equation}
Let’s remind ourselves how. Begin with the geometric series
\begin{equation}
\frac{1}{1 + x^2} = 1 – x^2 + x^4 – x^6 + x^8 + \cdots = \sum_{n = 0}^\infty (-1)^n x^{2n}. \notag
\end{equation}
(We showed that this has interval of convergence $\lvert x \rvert < 1$). Integrating this geometric series yields
\begin{equation}
\int_0^x \frac{1}{1 + t^2} dt = x – \frac{x^3}{3} + \frac{x^5}{5} – \frac{x^7}{7} + \cdots = \sum_{n = 0}^\infty (-1)^n \frac{x^{2n+1}}{2n+1}. \notag
\end{equation}
Note that this has interval of convergence $-1 < x \leq 1$.

We also recognize this integral as
\begin{equation}
\int_0^x \frac{1}{1 + t^2} dt = \text{arctan}(x), \notag
\end{equation}
one of the common integrals arising from trigonometric substitution. Putting these together, we find that
\begin{equation}
\text{arctan}(x) = x – \frac{x^3}{3} + \frac{x^5}{5} – \frac{x^7}{7} + \cdots = \sum_{n = 0}^\infty (-1)^n \frac{x^{2n+1}}{2n+1}. \notag
\end{equation}
As $x = 1$ is within the interval of convergence, we can substitute $x = 1$ into the series to find the representation
\begin{equation}
\text{arctan}(1) = 1 – \frac{1}{3} + \frac{1}{5} – \frac{1}{7} + \cdots = \sum_{n = 0}^\infty (-1)^n \frac{1}{2n+1}. \notag
\end{equation}
Since $\text{arctan}(1) = \frac{\pi}{4}$, this gives the representation for $\pi/4$ given in \eqref{eq:base}.

However, since $x=1$ was at the very edge of the interval of convergence, this series converges very, very slowly. For instance, using the first $50$ terms gives the approximation
\begin{equation}
\pi \approx 3.121594652591011. \notag
\end{equation}
The expansion of $\pi$ is actually
\begin{equation}
\pi = 3.141592653589793238462\ldots \notag
\end{equation}
So the first $50$ terms of \eqref{eq:base} gives two digits of accuracy. That’s not very good.

I think it is very natural to ask: can we do better? This series converges slowly — can we find one that converges more quickly?

(more…)

Posted in Brown University, Expository, Math 100, Mathematics, Teaching | Tagged , , , | 1 Comment

“On Functions Whose Mean Value Abscissas are Midpoints, with Connections to Harmonic Functions” (with Paul Carter)

This is joint work with Paul Carter. Humorously, we completed this while on a cross-country drive as we moved the newly minted Dr. Carter from Brown to Arizona.

I’ve had a longtime fascination with the standard mean value theorem of calculus.

Mean Value Theorem
Suppose $f$ is a differentiable function. Then there is some $c \in (a,b)$ such that
\begin{equation}
\frac{f(b) – f(a)}{b-a} = f'(c).
\end{equation}

The idea for this project started with a simple question: what happens when we interpret the mean value theorem as a differential equation and try to solve it? As stated, this is too broad. To narrow it down, we might specify some restriction on the $c$, which we refer to as the mean value abscissa, guaranteed by the Mean Value Theorem.

So I thought to try to find functions satisfying
\begin{equation}
\frac{f(b) – f(a)}{b-a} = f’ \left( \frac{a + b}{2} \right)
\end{equation}
for all $a$ and $b$ as a differential equation. In other words, let’s try to find all functions whose mean value abscissas are midpoints.

This looks like a differential equation, which I only know some things about. But my friend and colleague Paul Carter knows a lot about them, so I thought it would be fun to ask him about it.

He very quickly told me that it’s essentially impossible to solve this from the perspective of differential equations. But like a proper mathematician with applied math leanings, he thought we should explore some potential solutions in terms of their Taylor expansions. Proceeding naively in this way very quickly leads to the answer that those (assumed smooth) solutions are precisely quadratic polynomials.

It turns out that was too simple. It was later pointed out to us that verifying that quadratic polynomials satisfy the midpoint mean value property is a common exercise in calculus textbooks, including the one we use to teach from at Brown. Digging around a bit reveals that this was even known (in geometric terms) to Archimedes.

So I thought we might try to go one step higher, and see what’s up with
\begin{equation}\label{eq:original_midpoint}
\frac{f(b) – f(a)}{b-a} = f’ (\lambda a + (1-\lambda) b), \tag{1}
\end{equation}
where $\lambda \in (0,1)$ is a weight. So let’s find all functions whose mean value abscissas are weighted averages. A quick analysis with Taylor expansions show that (assumed smooth) solutions are precisely linear polynomials, except when $\lambda = \frac{1}{2}$ (in which case we’re looking back at the original question).

That’s a bit odd. It turns out that the midpoint itself is distinguished in this way. Why might that be the case?

It is beneficial to look at the mean value property as an integral property instead of a differential property,
\begin{equation}
\frac{1}{b-a} \int_a^b f'(t) dt = f’\big(c(a,b)\big).
\end{equation}
We are currently examining cases when $c = c_\lambda(a,b) = \lambda a + (1-\lambda b)$. We can see the right-hand side is differentiable by differentiating the left-hand side directly. Since any point can be a weighted midpoint, one sees that $f$ is at least twice-differentiable. One can actually iterate this argument to show that any $f$ satisfying one of the weighted mean value properties is actually smooth, justifying the Taylor expansion analysis indicated above.

An attentive eye might notice that the midpoint mean value theorem, written as the integral property
\begin{equation}
\frac{1}{b-a} \int_a^b f'(t) dt = f’ \left( \frac{a + b}{2} \right)
\end{equation}
is exactly the one-dimensional case of the harmonic mean value property, usually written
\begin{equation}
\frac{1}{\lvert B_h \rvert} = \int_{B_h(x)} g(t) dV = g(x).
\end{equation}
Here, $B_h(x)$ is the ball of radius $h$ and center $x$. Any harmonic function satisfies this mean value property, and any function satisfying this mean value property is harmonic.

From this viewpoint, functions satisfying our original midpoint mean value property~\eqref{eq:original_midpoint} have harmonic derivatives. But the only one-dimensional harmonic functions are affine functions $g(x) = cx + d$. This gives immediately that the set of solutions to~\eqref{eq:original_midpoint} are quadratic polynomials.

The weighted mean value property can also be written as an integral property. Trying to connect it similarly to harmonic functions led us to consider functions satisfying
\begin{equation}
\frac{1}{\lvert B_h \rvert} = \int_{B_h(x)} g(t) dV = g(c_\lambda(x,h)),
\end{equation}
where $c_\lambda(x,h)$ should be thought of as some distinguished point in the ball $B_h(x)$ with a weight parameter $\lambda$. More specifically,

Are there weighted harmonic functions corresponding to a weighted harmonic mean value property?
In one dimension, the answer is no, as seen above. But there are many more multivariable harmonic functions [in fact, I’ve never thought of harmonic functions on $\mathbb{R}^1$ until this project, as they’re too trivial]. So maybe there are weighted harmonic functions in higher dimensions?

This ends up being the focus of the latter half of our paper. Unexpectedly (to us), an analogous methodology to our approach in the one-dimensional case works, with only a few differences.

It turns out that no, there are no weighted harmonic functions on $\mathbb{R}^n$ other than trivial extensions of harmonic functions from $\mathbb{R}^{n-1}$.

Harmonic functions are very special, and even more special than we had thought. The paper is a fun read, and can be found on the arxiv now. It has been accepted and will appear in American Mathematical Monthly.

Posted in Expository, Math.CA, Mathematics | Tagged , , | Leave a comment

Math 420: Supplement on Gaussian Integers II

This is a secondary supplemental note on the Gaussian integers, written for my Spring 2016 Elementary Number Theory Class at Brown University. This note is also available as a pdf document.

In this note, we cover the following topics.

  1. Assumed prerequisites from other lectures.
  2. Which regular integer primes are sums of squares?
  3. How can we classify all Gaussian primes?

1. Assumed Prerequisites

Although this note comes shortly after the previous note on the Gaussian integers, we covered some material from the book in the middle. In particular, we will assume use the results from chapters 20 and 21 from the textbook.

Most importantly, for $latex {p}$ a prime and $latex {a}$ an integer not divisible by $latex {p}$, recall the Legendre symbol $latex {\left(\frac{a}{p}\right)}$, which is defined to be $latex {1}$ if $latex {a}$ is a square mod $latex {p}$ and $latex {-1}$ if $latex {a}$ is not a square mod $latex {p}$. Then we have shown Euler’s Criterion, which states that

$$ a^{\frac{p-1}{2}} \equiv \left(\frac{a}{p}\right) \pmod p, \tag{1}$$
and which gives a very efficient way of determining whether a given number $latex {a}$ is a square mod $latex {p}$.

We used Euler’s Criterion to find out exactly when $latex {-1}$ is a square mod $latex {p}$. In particular, we concluded that for each odd prime $latex {p}$, we have

$$ \left(\frac{-1}{p}\right) = \begin{cases} 1 & \text{ if } p \equiv 1 \pmod 4 \ -1 & \text{ if } p \equiv 3 \pmod 4 \end{cases}. \tag{2}$$
Finally, we assume familiarity with the notation and ideas from the previous note on the Gaussian integers.

2. Understanding When $latex {p = a^2 + b^2}$.

Throughout this section, $latex {p}$ will be a normal odd prime. The case $latex {p = 2}$ is a bit different, and we will need to handle it separately. When used, the letters $latex {a}$ and $latex {b}$ will denote normal integers, and $latex {q_1,q_2}$ will denote Gaussian integers.

We will be looking at the following four statements.

  1. $latex {p \equiv 1 \pmod 4}$
  2. $latex {\left(\frac{-1}{p}\right) = 1}$
  3. $latex {p}$ is not a Gaussian prime
  4. $latex {p = a^2 + b^2}$

Our goal will be to show that each of these statements are equivalent. In order to show this, we will show that

$$ (1) \implies (2) \implies (3) \implies (4) \implies (1). \tag{3}$$
Do you see why this means that they are all equivalent?

This naturally breaks down into four lemmas.

We have actually already shown one.

Lemma 1 $latex {(1) \implies (2)}$.

Proof: We have already proved this claim! This is exactly what we get from Euler’s Criterion applied to $latex {-1}$, as mentioned in the first section. $latex \Box$

There is one more that is somewhat straightfoward, and which does not rely on going up to the Gaussian integers.

Lemma 2 $latex {(4) \implies (1)}$.

Proof: We have an odd prime $latex {p}$ which is a sum of squares $latex {p = a^2 + b^2}$. If we look mod $latex {4}$, we are led to consider $$ p = a^2 + b^2 \pmod 4. \tag{4}$$
What are the possible values of $latex {a^2 \pmod 4}$? A quick check shows that the only possibilites are $latex {a^2 \equiv 0, 1 \pmod 4}$.

So what are the possible values of $latex {a^2 + b^2 \pmod 4}$? We must have one of $latex {p \equiv 0, 1, 2 \pmod 4}$. Clearly, we cannot have $latex {p \equiv 0 \pmod 4}$, as then $latex {4 \mid p}$. Similarly, we cannot have $latex {p \equiv 2 \pmod 4}$, as then $latex {2 \mid p}$. So we necessarily have $latex {p \equiv 1 \pmod 4}$, which is what we were trying to prove. $latex \Box$

For the remaining two pieces, we will dive into the Gaussian integers.

Lemma 3 $latex {(2) \implies (3)}$.

Proof: As $latex {\left(\frac{-1}{p}\right) = 1}$, we know there is some $latex {a}$ so that $latex {a^2 \equiv -1 \pmod p}$. Rearranging, this becomes $latex {a^2 + 1 \equiv 0 \pmod p}$.

Over the normal integers, we are at an impasse, as all this tells us is that $latex {p \mid (a^2 + 1)}$. But if we suddenly view this within the Gaussian integers, then $latex {a^2 + 1}$ factors as $latex {a^2 + 1 = (a + i)(a – i)}$.

So we have that $latex {p \mid (a+i)(a-i)}$. If $latex {p}$ were a Gaussian prime, then we would necessarily have $latex {p \mid (a+i)}$ or $latex {p \mid (a-i)}$. (Do you see why?)

But is it true that $latex {p}$ divides $latex {a + i}$ or $latex {a – i}$? For instance, does $latex {p}$ divide $latex {a + i}$? No! If so, then $latex {\frac{a}{p} + \frac{i}{p}}$ would be a Gaussian integer, which is clearly not true.

So $latex {p}$ does not divide $latex {a + i}$ or $latex {a-i}$, and we must therefore conclude that $latex {p}$ is not a Gaussian prime. $latex \Box$

Lemma 4 $latex {(3) \implies (4)}$.

Proof: We now know that $latex {p}$ is not a Gaussian prime. In particular, this means that $latex {p}$ is not irreducible, and so it has a nontrivial factorization in the Gaussian integers. (For example, $latex {5}$ is a regular prime, but it is not a Gaussian prime. It factors as $latex {5 = (1 + 2i)(1 – 2i)}$ in the Gaussian integers.)

Let’s denote this nontrivial factorization as $latex {p = q_1 q_2}$. By nontrivial, we mean that neither $latex {q_1}$ nor $latex {q_2}$ are units, i.e. $latex {N(q_1), N(q_2) > 1}$. Taking norms, we see that $latex {N(p) = N(q_1) N(q_2)}$.

We can evaluate $latex {N(p) = p^2}$, so we have that $latex {p^2 = N(q_1) N(q_2)}$. Both $latex {N(q_1)}$ and $latex {N(q_2)}$ are integers, and their product is $latex {p^2}$. Yet $latex {p^2}$ has exactly two different factorizations: $latex {p^2 = 1 \cdot p^2 = p \cdot p}$. Since $latex {N(q_1), N(q_2) > 1}$, we must have the latter.

So we see that $latex {N(q_1) = N(q_2) = p}$. As $latex {q_1, q_2}$ are Gaussian integers, we can write $latex {q_1 = a + bi}$ for some $latex {a, b}$. Then since $latex {N(q_1) = p}$, we see that $latex {N(q_1) = a^2 + b^2}$. And so $latex {p}$ is a sum of squares, ending the proof. $latex \Box$

Notice that $latex {2 = 1 + 1}$ is also a sum of squares. Then all together, we can say the following theorem.

Theorem 5 A regular prime $latex {p}$ can be written as a sum of two squares, $$ p = a^2 + b^2, \tag{5}$$
exactly when $latex {p = 2}$ or $latex {p \equiv 1 \pmod 4}$.

A remarkable aspect of this theorem is that it is entirely a statement about the behaviour of the regular integers. Yet in our proof, we used the Gaussian integers in a very fundamental way. Isn’t that strange?

You might notice that in the textbook, Dr. Silverman presents a proof that does not rely on the Gaussian integers. While interesting and clever, I find that the proof using the Gaussian integers better illustrates the deep connections between and around the structures we have been studying in this course so far. Everything connects!

Example 1 The prime $latex {5}$ is $latex {1 \pmod 4}$, and so $latex {5}$ is a sum of squares. In particular, $latex {5 = 1^2 + 2^2}$.

Example 2 The prime $latex {101}$ is $latex {1 \pmod 4}$, and so is a sum of squares. Our proof is not constructive, so a priori we do not know what squares sum to $latex {101}$. But in this case, we see that $latex {101 = 1^2 + 10^2}$.

Example 3 The prime $latex {97}$ is $latex {1 \pmod 4}$, and so it also a sum of squares. It’s less obvious what the squares are in this case. It turns out that $latex {97 = 4^2 + 9^2}$.

Example 4 The prime $latex {43}$ is $latex {3 \pmod 4}$, and so is not a sum of squares.

3. Classification of Gaussian Primes

In the previous section, we showed that each integer prime $latex {p \equiv 1 \pmod 4}$ actually splits into a product of two Gaussian numbers $latex {q_1}$ and $latex {q_2}$. In fact, since $latex {N(q_1) = p}$ is a regular prime, $latex {q_1}$ is a Gaussian irreducible and therefore a Gaussian prime (can you prove this? This is a nice midterm question.)

So in fact, $latex {p \equiv 1 \pmod 4}$ splits in to the product of two Gaussian primes $latex {q_1}$ and $latex {q_2}$.

In this way, we’ve found infinitely many Gaussian primes. Take a regular prime congruent to $latex {1 \pmod 4}$. Then we know that it splits into two Gaussian primes. Further, if we know how to write $latex {p = a^2 + b^2}$, then we know that $latex {q_1 = a + bi}$ and $latex {q_2 = a – bi}$ are those two Gaussian primes.

In general, we will find all Gaussian primes by determining their interaction with regular primes.

Suppose $latex {q}$ is a Gaussian prime. Then on the one hand, $latex {N(q) = q \overline{q}}$. On the other hand, $latex {N(q) = p_1^{a_1} p_2^{a_2} \cdots p_k^{a_k}}$ is some regular integer. Since $latex {q}$ is a Gaussian prime (and so $latex {q \mid w_1 w_2}$ means that $latex {q \mid w_1}$ or $latex {q \mid w_2}$), we know that $latex {q \mid p_j}$ for some regular integer prime $latex {p_j}$.

So one way to classify Gaussian primes is to look at every regular integer prime and see which Gaussian primes divide it. We have figured this out for all primes $latex {p \equiv 1 \pmod 4}$. We can handle $latex {2}$ by noticing that $latex {2 = (1 + i) (1-i)}$. Both $latex {(1+i)}$ and $latex {(1-i)}$ are Gaussian primes.

The only primes left are those regular primes with $latex {p \equiv 3 \pmod 4}$. We actually already covered the key idea in the previous section.

Lemma 6 If $latex {p \equiv 3 \pmod 4}$ is a regular prime, then $latex {p}$ is also a Gaussian prime.

Proof: In the previous section, we showed that if $latex {p}$ is not a Gaussian prime, then $latex {p = a^2 + b^2}$ for some integers $latex {a,b}$, and then $latex { p \equiv 1 \pmod 4}$. Since $latex {p \not \equiv 1 \pmod 4}$, we see that $latex {p}$ is a Gaussian prime. $latex \Box$

In total, we have classified all Gaussian primes.

Theorem 7 The Gaussian primes are given by

  1. $latex {(1+i), (1-i)}$
  2. Regular primes $latex {p \equiv 3 \pmod 4}$
  3. The factors $latex {q_1 q_2}$ of a regular prime $latex {p \equiv 1 \pmod 4}$. Further, these primes are given by $latex {a \pm bi}$, where $latex {p = a^2 + b^2}$.

 

4. Concluding Remarks

I hope that it’s clear that the regular integers and the Gaussian integers are deeply connected and intertwined. Number theoretic questions in one constantly lead us to investigate the other. As one dives deeper into number theory, more and different integer-like rings appear, all deeply connected.

Each time I teach the Gaussian integers, I cannot help but feel the sense that this is a hint at a deep structural understanding of what is really going on. The interplay between the Gaussian integers and the regular integers is one of my favorite aspects of elementary number theory, which is one reason why I deviated so strongly from the textbook to include it. I hope you enjoyed it too.

Posted in Brown University, Expository, Math 420, Mathematics, Teaching | Tagged , , , , , | Leave a comment

Math 420: Supplement on Gaussian Integers

This is a brief supplemental note on the Gaussian integers, written for my Spring 2016 Elementary Number Class at Brown University. With respect to the book, the nearest material is the material in Chapters 35 and 36, but we take a very different approach.

A pdf of this note can be found here. I’m sure there are typos, so feel free to ask me or correct me if you think something is amiss.

In this note, we cover the following topics.

  1. What are the Gaussian integers?
  2. Unique factorization within the Gaussian integers.
  3. An application of the Gaussian integers to the Diophantine equation $latex {y^2 = x^3 – 1}$.
  4. Other integer-like sets: general rings.
  5. Specific examples within $latex {\mathbb{Z}[\sqrt{2}]}$ and $latex {\mathbb{Z}[\sqrt{-5}]}$.

1. What are the Gaussian Integers?

The Gaussian Integers are the set of numbers of the form $latex {a + bi}$, where $latex {a}$ and $latex {b}$ are normal integers and $latex {i}$ is a number satisfying $latex {i^2 = -1}$. As a collection, the Gaussian Integers are represented by the symbol $latex {\mathbb{Z}[i]}$, or sometimes $latex {\mathbb{Z}[\sqrt{-1}]}$. These might be pronounced either as The Gaussian Integers or as Z append i.

In many ways, the Gaussian integers behave very much like the regular integers. We’ve been studying the qualities of the integers, but we should ask — which properties are really properties of the integers, and which properties hold in greater generality? Is it the integers themselves that are special, or is there something bigger and deeper going on?

These are the main questions that we ask and make some progress towards in these notes. But first, we need to describe some properties of Gaussian integers.

We will usually use the symbols $latex {z = a + bi}$ to represent our typical Gaussian integer. One adds and multiples two Gaussian integers just as you would add and multiply two complex numbers. Informally, you treat $latex {i}$ like a polynomial indeterminate $latex {X}$, except that it satisfies the relation $latex {X^2 = -1}$.

Definition 1 For each complex number $latex {z = a + bi}$, we define the conjugate of $latex {z}$, written as $latex {\overline{z}}$, by
\begin{equation}
\overline{z} = a – bi.
\end{equation}
We also define the norm of $latex {z}$, written as $latex {N(z)}$, by
\begin{equation}
N(z) = a^2 + b^2.
\end{equation}

You can check that $latex {N(z) = z \overline{z}}$ (and in fact this is one of your assigned problems). You can also chack that $latex {N(zw) = N(z)N(w)}$, or rather that the norm is multiplicative (this is also one of your assigned problems).

Even from our notation, it’s intuitive that $latex {z = a + bi}$ has two parts, the part corresponding to $latex {a}$ and the part corresponding to $latex {b}$. We call $latex {a}$ the real part of $latex {z}$, written as $latex {\Re z = a}$, and we call $latex {b}$ the imaginary part of $latex {z}$, written as $latex {\Im z = b}$. I should add that the name ”imaginary number” is a poor name that reflects historical reluctance to view complex numbers as acceptable. For that matter, the name ”complex number” is also a poor name.

As a brief example, consider the Gaussian integer $latex {z = 2 + 5i}$. Then $latex {N(z) = 4 + 25 = 29}$, $latex {\Re z = 2}$, $latex {\Im z = 5}$, and $latex {\overline{z} = 2 – 5i}$.

We can ask similar questions to those we asked about the regular integers. What does it mean for $latex {z \mid w}$ in the complex case?

Definition 2 We say that a Gaussian integer $latex {z}$ divides another Gaussian integer $latex {w}$ if there is some Gaussian integer $latex {k}$ so that $latex {zk = w}$. In this case, we write $latex {z \mid w}$, just as we write for regular integers.

For the integers, we immediately began to study the properties of the primes, which in many ways were the building blocks of the integers. Recall that for the regular integers, we said $latex {p}$ was a prime if its only divisors were $latex {\pm 1}$ and $latex {\pm p}$. In the Gaussian integers, the four numbers $latex {\pm 1, \pm i}$ play the same role as $latex {\pm 1}$ in the usual integers. These four numbers are distinguished as being the only four Gaussian integers with norm equal to $latex {1}$.

That is, the only solutions to $latex {N(z) = 1}$ where $latex {z}$ is a Gaussian integer are $latex {z = \pm 1, \pm i}$. We call these four numbers the Gaussian units.

With this in mind, we are ready to define the notion of a prime for the Gaussian integers.

Definition 3 We say that a Gaussian integer $latex {z}$ with $latex {N(z) > 1}$ is a Gaussian prime if the only divisors of $latex {z}$ are $latex {u}$ and $latex {uz}$, where $latex {u = \pm 1, \pm i}$ is a Gaussian unit.

Remark 1 When we look at other integer-like sets, we will actually use a different definition of a prime.

It’s natural to ask whether the normal primes in $latex {\mathbb{Z}}$ are also primes in $latex {\mathbb{Z}[i]}$. And the answer is no. For instance, $latex {5}$ is a prime in $latex {\mathbb{Z}}$, but
\begin{equation}
5 = (1 + 2i)(1 – 2i)
\end{equation}
in the Gaussian integers. However, the two Gaussian integers $latex {1 + 4i}$ and $latex {1 – 4i}$ are prime. It also happens to be that $latex {3}$ is a Gaussian prime. We will continue to investigate which numbers are Gaussian primes over the next few lectures.

With a concept of a prime, it’s also natural to ask whether or not the primes form the building blocks for the Gaussian integers like they form the building blocks for the regular integers. We take up this in our next topic.

2. Unique Factorization in the Gaussian Integers

Let us review the steps that we followed to prove unique factorization for $latex {\mathbb{Z}}$.

  1. We proved that for $latex {a,b}$ in $latex {\mathbb{Z}}$ with $latex {b \neq 0}$, there exist unique $latex {q}$ and $latex {r}$ such that $latex {a = bq + r}$ with $latex {0 \leq r < b}$. This is called the Division Algorithm.
  2. By repeatedly applying the Division Algorithm, we proved the Euclidean Algorithm. In particular, we showed that the last nonzero remainder was the GCD of our initial numbers.
  3. By performing reverse substition on the steps of the Euclidean Algorithm, we showed that there are integer solutions in $latex {x,y}$ to the Diophantine equation $latex {ax + by = \gcd(a,b)}$. This is often called Bezout’s Theorem or Bezout’s Lemma, although we never called it by that name in class.
  4. With Bezout’s Theorem, we showed that if a prime $latex {p}$ divides $latex {ab}$, then $latex {p \mid a}$ or $latex {p \mid b}$. This is the crucial step towards proving Unique Factorization.
  5. We then proved Unique Factorization.

Each step of this process can be repeated for the Gaussian integers, with a few notable differences. Remarkably, once we have the division algorithm, each proof is almost identical for $latex {\mathbb{Z}[i]}$ as it is for $latex {\mathbb{Z}}$. So we will prove the division algorithm, and then give sketches of the remaining ideas, highlighting the differences that come up along the way.

In the division algorithm, we require the remainder $latex {r}$ to ”be less than what we are dividing by.” A big problem in translating this to the Gaussian integers is that the Gaussian integers are not ordered. That is, we don’t have a concept of being greater than or less than for $latex {\mathbb{Z}[i]}$.

When this sort of problem emerges, we will get around this by taking norms. Since the norm of a Gaussian integer is a typical integer, we will be able to use the ordering of the integers to order our norms.

Theorem 4 For $latex {z,w}$ in $latex {\mathbb{Z}[i]}$ with $latex {w \neq 0}$, there exist $latex {q}$ and $latex {r}$ in $latex {\mathbb{Z}[i]}$ such that $latex {z = qw + r}$ with $latex {N(r) < N(w)}$.

Proof: Here, we will cheat a little bit and use properties about general complex numbers and the rationals to perform this proof. One can give an entirely intrinsic proof, but I like the approach I give as it also informs how to actually compute the $latex {q}$ and $latex {r}$.

The entire proof boils down to the idea of writing $latex {z/w}$ as a fraction and approximating the real and imaginary parts by the nearest integers.

Let us now transcribe that idea. We will need to introduce some additional symbols. Let $latex {z = a_1 + b_1 i}$ and $latex {w = a_2 + b_2 i}$.

Then
\begin{align}
\frac{z}{w} &= \frac{a_1 + b_1 i}{a_2 + b_2 i} = \frac{a_1 + b_1 i}{a_2 + b_2 i} \frac{a_2 – b_2 i}{a_2 – b_2 i} \\
&= \frac{a_1a_2 + b_1 b_2}{a_2^2 + b_2^2} + i \frac{b_1 a_2 – a_1 b_2}{a_2^2 + b_2 ^2} \\
&= u + iv.
\end{align}
By rationalizing the denominator by multiplying by $latex {\overline{w}/ \overline{w}}$, we are able to separate out the real and imaginary parts. In this final expression, we have named $latex {u}$ to be the real part and $latex {v}$ to be the imaginary part. Notice that $latex {u}$ and $latex {v}$ are normal rational numbers.

We know that for any rational number $latex {u}$, there is an integer $latex {u’}$ such that $latex {\lvert u – u’ \rvert \leq \frac{1}{2}}$. Let $latex {u’}$ and $latex {v’}$ be integers within $latex {1/2}$ of $latex {u}$ and $latex {v}$ above, respectively.

Then we claim that we can choose $latex {q = u’ + i v’}$ to be the $latex {q}$ in the theorem statement, and let $latex {r}$ be the resulting remainder, $latex {r = z – qw}$. We need to check that $latex {N(r) < N(w)}$. We will check that explicitly.

We compute
\begin{align}
N(r) &= N(z – qw) = N\left(w \left(\frac{z}{w} – q\right)\right) = N(w) N\left(\frac{z}{w} – q\right).
\end{align}
Note that we have used that $latex {N(ab) = N(a)N(b)}$. In this final expression, we have already come across $latex {\frac{z}{w}}$ before — it’s exactly what we called $latex {u + iv}$. And we called $latex {q = u’ + i v’}$. So our final expression is the same as
\begin{equation}
N(r) = N(w) N(u + iv – u’ – i v’) = N(w) N\left( (u – u’) + i (v – v’)\right).
\end{equation}
How large can the real and imaginary parts of $latex {(u-u’) + i (v – v’)}$ be? By our choice of $latex {u’}$ and $latex {v’}$, they can be at most $latex {1/2}$.

So we have that
\begin{equation}
N(r) \leq N(w) N\left( (\tfrac{1}{2})^2 + (\tfrac{1}{2})^2\right) = \frac{1}{2} N(w).
\end{equation}
And so in particular, we have that $latex {N(r) < N(w)}$ as we needed. $latex \Box$

Note that in this proof, we did not actually show that $latex {q}$ or $latex {r}$ are unique. In fact, unlike the case in the regular integers, it is not true that $latex {q}$ and $latex {r}$ are unique.

Example 1 Consider $latex {3+5i, 1 + 2i}$. Then we compute
\begin{equation}
\frac{3+5i}{1+2i} = \frac{3+5i}{1+2i}\frac{1-2i}{1-2i} = \frac{13}{5} + i \frac{-1}{5}.
\end{equation}
The closest integer to $latex {13/5}$ is $latex {3}$, and the closest integer to $latex {-1/5}$ is $latex {0}$. So we take $latex {q = 3}$. Then $latex {r = (3+5i) – (1+2i)3 = -i}$, and we see in total that
\begin{equation}
3+5i = (1+2i) 3 – i.
\end{equation}
Note that $latex {N(-i) = 1}$ and $latex {N(1 + 2i) = 5}$, so this choice of $latex {q}$ and $latex {r}$ works.

As $latex {13/5}$ is sort of close to $latex {2}$, what if we chose $latex {q = 2}$ instead? Then $latex {r = (3 + 5i) – (1 + 2i)2 = 1 + i}$, leading to the overall expression
\begin{equation}
3_5i = (1 + 2i) 2 + (1 + i).
\end{equation}
Note that $latex {N(1+i) = 2 < N(1+2i) = 5}$, so that this choice of $latex {q}$ and $latex {r}$ also works.

This is an example of how the choice of $latex {q}$ and $latex {r}$ is not well-defined for the Gaussian integers. In fact, even if one decides to choose $latex {q}$ to that $latex {N(r)}$ is minimal, the resulting choices are still not necessarily unique.

This may come as a surprise. The letters $latex {q}$ and $latex {r}$ come from our tendency to call those numbers the quotient and remainder after division. We have shown that the quotient and remainder are not well-defined, so it does not make sense to talk about ”the remainder” or ”the quotient.” This is a bit strange!

Are we able to prove unique factorization when the process of division itself seems to lead to ambiguities? Let us proceed forwards and try to see.

Our next goal is to prove the Euclidean Algorithm. By this, we mean that by repeatedly performing the division algorithm starting with two Gaussian integers $latex {z}$ and $latex {w}$, we hope to get a sequence of remainders with the last nonzero remainder giving a greatest common divisor of $latex {z}$ and $latex {w}$.

Before we can do that, we need to ask a much more basic question. What do we mean by a greatest common divisor? In particular, the Gaussian integers are not ordered, so it does not make sense to say whether one Gaussian integer is bigger than another.

For instance, is it true that $latex {i > 1}$? If so, then certainly $latex {i}$ is positive. We know that multiplying both sides of an inequality by a positive number doesn’t change that inequality. So multiplying $latex {i > 1}$ by $latex {i}$ leads to $latex {-1 > i}$, which is absurd if $latex {i}$ was supposed to be positive!

To remedy this problem, we will choose a common divisor of $latex {z}$ and $latex {w}$ with the greatest norm (which makes sense, as the norm is a regular integer and thus is well-ordered). But the problem here, just as with the division algorithm, is that there may or may not be multiple such numbers. So we cannot talk about ”the greatest common divisor” and instead talk about ”a greatest common divisor.” To paraphrase Lewis Carroll’s\footnote{Carroll was also a mathematician, and hid some nice mathematics inside some of his works.} Alice, things are getting curiouser and curiouser!

Definition 5 For nonzero $latex {z,w}$ in $latex {\mathbb{Z}[i]}$, a greatest common divisor of $latex {z}$ and $latex {w}$, denoted by $latex {\gcd(z,w)}$, is a common divisor with largest norm. That is, if $latex {c}$ is another common divisor of $latex {z}$ and $latex {w}$, then $latex {N(c) \leq N(\gcd(z,w))}$.

If $latex {N(\gcd(z,w)) = 1}$, then we say that $latex {z}$ and $latex {w}$ are relatively prime. Said differently, if $latex {1}$ is a greatest common divisor of $latex {z}$ and $latex {w}$, then we say that $latex {z}$ and $latex {w}$ are relatively prime.

Remark 2 Note that $latex {\gcd(z,w)}$ as we’re writing it is not actually well-defined, and may stand for any greatest common divisor of $latex {z}$ and $latex {w}$.

With this definition in mind, the proof of the Euclidean Algorithm is almost identical to the proof of the Euclidean Algorithm for the regular integers. As with the regular integers, we need the following result, which we will use over and over again.

Lemma 6 Suppose that $latex {z \mid w_1}$ and $latex {z \mid w_2}$. Then for any $latex {x,y}$ in $latex {\mathbb{Z}[i]}$, we have that $latex {z \mid (x w_1 + y w_2)}$.

Proof: As $latex {z \mid w_1}$, there is some Gaussian integer $latex {k_1}$ such that $latex {z k_1 = w_1}$. Similarly, there is some Gaussian integer $latex {k_2}$ such that $latex {z k_2 = w_2}$.

Then $latex {xw_1 + yw_2 = zxk_1 + zyk_2 = z(xk_1 + yk_2)}$, which is divisible by $latex {z}$ as this is the definition of divisibility. $latex \Box$

Notice that this proof is identical to the analogous statement in the integers, except with differently chosen symbols. That is how the proof of the Euclidean Algorithm goes as well.

Theorem 7 let $latex {z,w}$ be nonzero Gaussian integers. Recursively apply the division algorithm, starting with the pair $latex {z, w}$ and then choosing the quotient and remainder in one equation the new pair for the next. The last nonzero remainder is divisible by all common divisors of $latex {z,w}$, is itself a common divisor, and so the last nonzero remainder is a greatest common divisor of $latex {z}$ and $latex {w}$.

Symbolically, this looks like
\begin{align}
z &= q_1 w + r_1, \quad N(r_1) < N(w) \\\\
w &= q_2 r_1 + r_2, \quad N(r_2) < N(r_1) \\\\
r_1 &= q_3 r_2 + r_3, \quad N(r_3) < N(r_2) \\\\
\cdots &= \cdots \\\\
r_k &= q_{k+2} r_{k+1} + r_{k+2}, \quad N(r_{k+2}) < N(r_{k+1}) \\\\
r_{k+1} &= q_{k+3} r_{k+2} + 0,
\end{align}
where $latex {r_{k+2}}$ is the last nonzero remainder, which we claim is a greatest common divisor of $latex {z}$ and $latex {w}$.

Proof: We are claiming several thing. Firstly, we should prove our implicit claim that this algorithm terminates at all. Is it obvious that we should eventually reach a zero remainder?

In order to see this, we look at the norms of the remainders. After each step in the algorithm, the norm of the remainder is smaller than the previous step. As the norms are always nonnegative integers, and we know there does not exist an infinite list of decreasing positive integers, we see that the list of nonzero remainders is finite. So the algorithm terminates.

We now want to prove that the last nonzero remainder is a common divisor and is in fact a greatest common divisor. The proof is actually identical to the proof in the integer case, merely with a different choice of symbols.

Here, we only sketch the argument. Then the rest of the argument can be found by comparing with the proof of the Euclidean Algorithm for $latex {\mathbb{Z}}$ as found in the course textbook.

For ease of exposition, suppose that the algorithm terminated in exatly 3 steps, so that we have
\begin{align}
z &= q_1 w + r_1, \\
w &= q_2 r_1 + r_2 \\
r_1 &= q_3 r_2 + 0.
\end{align}

On the one hand, suppose that $latex {d}$ is a common divisor of $latex {z}$ and $latex {w}$. Then by our previous lemma, $latex {d \mid z – q_1 w = r_1}$, so that we see that $latex {d}$ is a divisor of $latex {r_1}$ as well. Applying to the next line, we have that $latex {d \mid w}$ and $latex {d \mid r_1}$, so that $latex {d \mid w – q_2 r_1 = r_2}$. So every common divisor of $latex {z}$ and $latex {w}$ is a divisor of the last nonzero remainder $latex {r_2}$.

On the other hand, $latex {r_2 \mid r_1}$ by the last line of the algorithm. Then as $latex {r_2 \mid r_1}$ and $latex {r_2 \mid r_1}$, we know that $latex {r_2 \mid q_2 r_1 + r_2 = w}$. Applying this to the first line, as $latex {r_2 \mid r_1}$ and $latex {r_2 \mid w}$, we know that $latex {r_2 \mid q_1 w + r_1 = z}$. So $latex {r_2}$ is a common divisor.

We have shown that $latex {r_2}$ is a common divisor of $latex {z}$ and $latex {w}$, and that every common divisor of $latex {z}$ and $latex {w}$ divides $latex {r_2}$. How do we show that $latex {r_2}$ is a greatest common divisor?

Suppose that $latex {d}$ is a common divisor of $latex {z}$ and $latex {w}$, so that we know that $latex {d \mid r_2}$. In particular, this means that there is some nonzero $latex {k}$ so that $latex {dk = r_2}$. Taking norms, this means that $latex {N(dk) = N(d)N(k) = N(r_2)}$. As $latex {N(d)}$ and $latex {N(k)}$ are both at least $latex {1}$, this means that $latex {N(d) \leq N(r_2)}$.

This is true for every common divisor $latex {d}$, and so $latex {N(r_2)}$ is at least as large as the norm of any common divisor of $latex {z}$ and $latex {w}$. Thus $latex {r_2}$ is a greatest common divisor.

The argument carries on in the same way for when there are more steps in the algorithm. $latex \Box$

Theorem 8 The greatest common divisor of $latex {z}$ and $latex {w}$ is well-defined, up to multiplication by $latex {\pm 1, \pm i}$. In other words, if $latex {\gcd(z,w)}$ is a greatest common divisor of $latex {z}$ and $latex {w}$, then all greatest common divisors of $latex {z}$ and $latex {w}$ are given by $latex {\pm \gcd(z,w), \pm i \gcd(z,w)}$.

Proof: Suppose $latex {d}$ is a greatest common divisor, and let $latex {\gcd(z,w)}$ denote a greatest common divisor resulting from an application of the Euclidean Algorithm. Then we know that $latex {d \mid \gcd(z,w)}$, so that there is some $latex {k}$ so that $latex {dk = \gcd(z,w)}$. Taking norms, we see that $latex {N(d)N(k) = N(\gcd(z,w)}$.

But as both $latex {d}$ and $latex {\gcd(z,w)}$ are greatest common divisors, we must have that $latex {N(d) = N(\gcd(z,w))}$. So $latex {N(k) = 1}$. The only Gaussian integers with norm one are $latex {\pm 1, \pm i}$, so we have that $latex {du = \gcd(z,w)}$ where $latex {u}$ is one of the four Gaussian units, $latex {\pm 1, \pm i}$.

Conversely, it’s clear that the four numbers $latex {\pm \gcd(z,w), \pm i \gcd(z,w)}$ are all greatest common divisors. $latex \Box$

Now that we have the Euclidean Algorithm, we can go towards unique factorization in $latex {\mathbb{Z}[i]}$. Let $latex {g}$ denote a greatest common divisor of $latex {z}$ and $latex {w}$. Reverse substitution in the Euclidean Algorithm shows that we can find Gaussian integer solutions $latex {x,y}$ to the (complex) linear Diophantine equation
\begin{equation}
zx + wy = g.
\end{equation}
Let’s see an example.

Example 2 Consider $latex {32 + 9i}$ and $latex {4 + 11i}$. The Euclidean Algorithm looks like
\begin{align}
32 + 9i &= (4 + 11i)(2 – 2i) + 2 – 5i, \\\\
4 + 11i &= (2 – 5i)(-2 + i) + 3 – i, \\\\
2 – 5i &= (3-i)(1-i) – i, \\\\
3 – i &= -i (1 + 3i) + 0.
\end{align}
So we know that $latex {-i}$ is a greatest common divisor of $latex {32 + 9i}$ and $latex {4 + 11i}$, and so we know that $latex {32+9i}$ and $latex {4 + 11i}$ are relatively prime. Let us try to find a solution to the Diophantine equation
\begin{equation}
x(32 + 9i) + y(4 + 11i) = 1.
\end{equation}
Performing reverse substition, we see that
\begin{align}
-i &= (2 – 5i) – (3-i)(1-i) \\\\
&= (2 – 5i) – (4 + 11i – (2-5i)(-2 + i))(1-i) \\\\
&= (2 – 5i) – (4 + 11i)(1 – i) + (2 – 5i)(-2 + 1)(1 – i) \\\\
&= (2 – 5i)(3i) – (4 + 11i)(1 – i) \\\\
&= (32 + 9i – (4 + 11i)(2 – 2i))(3i) – (4 + 11i)(1 – i) \\\\
&= (32 + 9i) 3i – (4 + 11i)(2 – 2i)(3i) – (4 + 11i)(1-i) \\\\
&= (32 + 9i) 3i – (4 + 11i)(7 + 5i).
\end{align}
Multiplying this through by $latex {i}$, we have that
\begin{equation}
1 = (32 + 9i) (-3) + (4 + 11i)(5 – 7i).
\end{equation}
So one solution is $latex {(x,y) = (-3, 5 – 7i)}$.

Although this looks more complicated, the process is the same as in the case over the regular integers. The apparent higher difficulty comes mostly from our lack of familiarity with basic arithmetic in $latex {\mathbb{Z}[i]}$.

The rest of the argument is now exactly as in the integers.

Theorem 9 Suppose that $latex {z, w}$ are relatively prime, and that $latex {z \mid wv}$. Then $latex {z \mid v}$.

Proof: This is left as an exercise (and will appear on the next midterm in some form — cheers to you if you’ve read this far in these notes). But it’s now the almost the same as in the regular integers. $latex \Box$

Theorem 10 Let $latex {z}$ be a Gaussian integer with $latex {N(z) > 1}$. Then $latex {z}$ can be written uniquely as a product of Gaussian primes, up to multiplication by one of the Gaussian units $latex {\pm 1, \pm i}$.

Proof: We only sketch part of the proof. There are multiple ways of doing this, but we present the one most similar to what we’ve done for the integers. If there are Gaussian integers without unique factorization, then there are some (maybe they tie) with minimal norm. So let $latex {z}$ be a Gaussian integer of minimal norm without unique factorization. Then we can write
\begin{equation}
p_1 p_2 \cdots p_k = z = q_1 q_2 \cdots q_\ell,
\end{equation}
where the $latex {p}$ and $latex {q}$ are all primes. As $latex {p_1 \mid z = q_1 q_2 \cdots q_\ell}$, we know that $latex {p_1}$ divides one of the $latex {q}$ (by Theorem~9), and so (up to units) we can say that $latex {p_1}$ is one of the $latex {q}$ primes. We can divide each side by $latex {p_1}$ and we get two supposedly different factorizations of a Gaussian integer of norm $latex {N(z)/N(p_1) < N(z)}$, which is less than the least norm of an integer without unique factorization (by what we supposed). This is a contradiction, and we can conclude that there are no Gaussian integers without unique factorization. $latex \Box$

If this seems unclear, I recommend reviewing this proof and the proof of unique factroziation for the regular integers. I should also mention that one can modify the proof of unique factorization for $latex {\mathbb{Z}}$ as given in the course textbook as well (since it is a bit different than what we have done). Further, the course textbook does proof of unique factorization for $latex {\mathbb{Z}[i]}$ in Chapter 36, which is very similar to the proof sketched above (although the proof of Theorem~9 is very different.)

3. An application to $latex {y^2 = x^3 – 1}$.

We now consider the nonlinear Diophantine equation $latex {y^2 = x^3 – 1}$, where $latex {x,y}$ are in $latex {\mathbb{Z}}$. This is hard to solve over the integers, but by going up to $latex {\mathbb{Z}[i]}$, we can determine all solutions.

In $latex {\mathbb{Z}[i]}$, we can rewrite $$ y^2 + 1 = (y + i)(y – i) = x^3. \tag{1}$$
We claim that $latex {y+i}$ and $latex {y-i}$ are relatively prime. To see this, suppose that $latex {d}$ is a common divisor of $latex {y+i}$ and $latex {y-i}$. Then $latex {d \mid (y + i) – (y – i) = 2i}$. It happens to be that $latex {2i = (1 + i)^2}$, and that $latex {(1 + i)}$ is prime. To see this, we show the following.

Lemma 11 Suppose $latex {z}$ is a Gaussian integer, and $latex {N(z) = p}$ is a regular prime. Then $latex {z}$ is a Gaussian prime.

Proof: Suppose that $latex {z}$ factors nontrivially as $latex {z = ab}$. Then taking norms, $latex {N(z) = N(a)N(b)}$, and so we get a nontrivial factorization of $latex {N(z)}$. When $latex {N(z)}$ is a prime, then there are no nontrivial factorizations of $latex {N(z)}$, and so $latex {z}$ must have no nontrivial factorization. $latex \Box$

As $latex {N(1+i) = 2}$, which is a prime, we see that $latex {(1 + i)}$ is a Gaussian prime. So $latex {d \mid (1 + i)^2}$, which means that $latex {d}$ is either $latex {1, (1 + i)}$, or $latex {(1+i)^2}$ (up to multiplication by a Gaussian unit).

Suppose we are in the case of the latter two, so that $latex {(1+i) \mid d}$. Then as $latex {d \mid (y + i)}$, we know that $latex {(1 + i) \mid x^3}$. Taking norms, we have that $latex {2 \mid x^6}$.

By unique factorization in $latex {\mathbb{Z}}$, we know that $latex {2 \mid x}$. This means that $latex {4 \mid x^2}$, which allows us to conclude that $latex {x^3 \equiv 0 \pmod 4}$. Going back to the original equation $latex {y^2 + 1 = x^3}$, we see that $latex {y^2 + 1 \equiv 0 \pmod 4}$, which means that $latex {y^2 \equiv 3 \pmod 4}$. A quick check shows that $latex {y^2 \equiv 3 \pmod 4}$ has no solutions $latex {y}$ in $latex {\mathbb{Z}/4\mathbb{Z}}$.

So we rule out the case then $latex {(1 + i) \mid d}$, and we are left with $latex {d}$ being a unit. This es exactly the case that $latex {y+i}$ and $latex {y-i}$ are relatively prime.

Recall that $latex {(y+i)(y-i) = x^3}$. As $latex {y+i}$ and $latex {y-i}$ are relatively prime and their product is a cube, by unique factorization in $latex {\mathbb{Z}[i]}$ we know that $latex {y+i}$ and $latex {y-i}$ much each be Gaussian cubes. Then we can write $latex {y+i = (m + ni)^3}$ for some Gaussian integer $latex {m + ni}$. Expanding, we see that
\begin{equation}
y+i = m^3 – 3mn^2 + i(3m^2n – n^3).
\end{equation}
Equating real and imaginary parts, we have that
\begin{align}
y &= m(m^2 – 3n^2) \\
1 &= n(3m^2 – n^2).
\end{align}
This second line shows that $latex {n \mid 1}$. As $latex {n}$ is a regular integer, we see that $latex {n = 1}$ or $latex {-1}$.

If $latex {n = 1}$, then that line becomes $latex {1 = (3m^2 – 1)}$, or after rearranging $latex {2 = 3m^2}$. This has no solutions.

If $latex {n = -1}$, then that line becomes $latex {1 = -(3m^2 – 1)}$, or after rearranging $latex {0 = 3m^2}$. This has the solution $latex {m = 0}$, so that $latex {y+i = (-i)^3 = i}$, which means that $latex {y = 0}$. Then from $latex {y^2 + 1 = x^3}$, we see that $latex {x = 1}$.

And so the only solution is $latex {(x,y) = (1,0)}$, and there are no other solutions.

4. Other Rings

The Gaussian integers have many of the same properties as the regular integers, even though there are some differences. We could go further. For example, we might consider the following integer-like sets,
\begin{equation}
\mathbb{Z}(\sqrt{d}) = { a + b \sqrt{d} : a,b \in \mathbb{Z} }.
\end{equation}
One can add, subtract, and multiply these together in similar ways to how we can add, subtract, and multiply together integers, or Gaussian integers.

We might ask what properties these other integer-like sets have. For instance, do they have unique factorization?

More generally, there is a better name than ”integer-like set” for this sort of construction.

Suppose $latex {R}$ is a collection of elements, and it makes sense to add, subtract, and multiply these elements together. Further, we want addition and multiplication to behave similarly to how they behave for the regular integers. In particular, if $latex {r}$ and $latex {s}$ are elements in $latex {R}$, then we want $latex {r + s = s + r}$ to be in $latex {R}$; we want something that behaves like $latex {0}$ in the sense that $latex {r + 0 = r}$; for each $latex {r}$, want another element $latex {-r}$ so that $latex {r + (-r) = 0}$; we want $latex {r \cdot s = s \cdot r}$; we want something that behaves like $latex {1}$ in the sense that $latex {r \cdot 1 = r}$ for all $latex {r \neq 0}$; and we want $latex {r(s_1 + s_2) = r s_1 + r s_2}$. Such a collection is called a ring. (More completely, this is called a commutative unital ring, but that’s not important.)

It is not important that you explicitly remember exactly what the definition of a ring is. The idea is that there is a name for things that are ”integer-like” and that we might wonder what properties we have been thinking of as properties of the integers are actually properties of rings.

As a total aside: there are very many more rings too, things that look much more different than the integers. This is one of the fundamental questions that leads to the area of mathematics called Abstract Algebra. With an understanding of abstract algebra, one could then focus on these general number theoretic problems in an area of math called Algebraic Number Theory.

5. The rings $latex {\mathbb{Z}[\sqrt{d}]}$

We can describe some of the specific properties of $latex {\mathbb{Z}[\sqrt{d}]}$, and suggest how some of the ideas we’ve been considering do (or don’t) generalize. For a general element $latex {n = a + b \sqrt{d}}$, we can define the conjugate $latex {\overline{n} = a – b\sqrt {d}}$ and the norm $latex {N(n) = n \cdot \overline{n} = a^2 – d b^2}$. We call those elements $latex {u}$ with $latex {N(u) = 1}$ the units in $latex {\mathbb{Z}[\sqrt{d}]}$.

Some of the definitions we’ve been using turn out to not generalize so easily, or in quite the ways we expect. If $latex {n}$ doesn’t have a nontrivial factoriation (meaning that we cannot write $latex {n = ab}$ with $latex {N(a), N(b) \neq 1}$), then we call $latex {n}$ an irreducible. In the cases of $latex {\mathbb{Z}}$ and $latex {\mathbb{Z}[i]}$, we would have called these elements prime.

In general, we call a number $latex {p}$ in $latex {\mathbb{Z}{\sqrt{d}}}$ a prime if $latex {p}$ has the property that $latex {p \mid ab}$ means that $latex {p \mid a}$ or $latex {p \mid b}$. Of course, in the cases of $latex {\mathbb{Z}}$ and $latex {\mathbb{Z}[i]}$, we showed that irreducibles are primes. But it turns out that this is not usually the case.

Let us look at $latex {\mathbb{Z}{\sqrt{-5}}}$ for a moment. In particular, we can write $latex {6}$ in two ways as
\begin{equation}
6 = 2 \cdot 3 = (1 + \sqrt{-5})(1 – \sqrt{-5}).
\end{equation}
Although it’s a bit challenging to show, these are the only two fundamentally different factorizations of $latex {6}$ in $latex {\mathbb{Z}[\sqrt{-5}]}$. One can show (it’s not very hard, but it’s not particularly illuminating to do here) that neither $latex {2}$ or $latex {3}$ divides $latex {(1 + \sqrt{-5})}$ or $latex {(1 – \sqrt{-5})}$ (and vice versa), which means that none of these four numbers are primes in our more general definition. One can also show that all four numbers are irreducible.

What does this mean? This means that $latex {6}$ can be factored into irreducibles in fundamentally different ways, and that $latex {\mathbb{Z}[\sqrt{-5}]}$ does not have unique factorization.

It’s a good thought exercise to think about what is really different between $latex {\mathbb{Z}[\sqrt{-5}]}$ and $latex {\mathbb{Z}}$. At the beginning of this course, it seemed extremely obvious that $latex {\mathbb{Z}}$ had unique factorization. But in hindsight, is it really so obvious?

Understanding when there is and is not unique factorization in $latex {\mathbb{Z}[\sqrt{d}]}$ is something that people are still trying to understand today. The fact is that we don’t know! In particular, we really don’t know very much when $latex {d}$ is positive.

One reason why can be seen in $latex {\mathbb{Z}[\sqrt{2}]}$. If $latex {n = a + b \sqrt{2}}$, then $latex {N(n) = a^2 – 2 b^2}$. A very basic question that we can ask is what are the units? That is, which $latex {n}$ have $latex {N(n) = 1}$?

Here, that means trying to solve the equation $$ a^2 – 2 b^2 = 1. \tag{2}$$
We have seen this equation a few times before. On the second homework assignment, I asked you to show that there were infinitely many solutions to this equation by finding lines and intersecting them with hyperbolas. We began to investigate this Diophantine equation because each solution leads to another square-triangular number.

So there are infinitely many units in $latex {\mathbb{Z}[\sqrt{2}]}$. This is strange! For instance, $latex {3 + 2 \sqrt{2}}$ is a unit, which means that it behaves just like $latex {\pm 1}$ in $latex {\mathbb{Z}}$, or like $latex {\pm 1, \pm i}$ in $latex {\mathbb{Z}[i]}$. Very often, the statements we’ve been looking at and proving are true ”up to multiplication by units.” Since there are infinitely many in $latex {\mathbb{Z}[\sqrt 2]}$, it can mean that it’s annoying to determine even if two numbers are actually the same up to multiplication by units.

As you look further, there are many more strange and interesting behaviours. It is really interesting to see what properties are very general, and what properties vary a lot. It is also interesting to see the different ways in which properties we’re used to, like unique factorization, can fail.

For instance, we have seen that $latex {\mathbb{Z}[\sqrt -5]}$ does not have unique factorization. We showed this by seeing that $latex {6}$ factors in two fundamentally different ways. In fact, some numbers in $latex {\mathbb{Z}[\sqrt -5]}$ do factor uniquely, and others do not. But if one does not, then it factors in at most two fundamentally different ways.

In other rings, you can have numbers which factor in more fundamentally different ways. The actual behaviour here is also really poorly understood, and there are mathematicians who are actively pursuing these topics.

It’s a very large playground out there.

Posted in Brown University, Expository, Math 420, Math.NT, Mathematics, Teaching | Tagged , , , , , | 2 Comments