at their Matrix marathon?” Viv nodded. “Why didn’t you join them Audrey? You love The Matrix.” “Fourth one soured me to it. Neo ended up back in the Matrix” “Ah, that’s where you got it wrong. See, the matrix is defective. It’s never about escaping the matrix. It’s really about reducing the matrix to its eigenbasis. Once you have found your eigenvectors and eigenvalues, then you can orthogonalize the subspace,” said Edith, before finishing with a flourish, “Then you’re the Superman. The Thought Robot.”
their Matrix marathon?" Viv nodded. "Why didn't you join them Audrey? You love The Matrix." "Fourth one soured me to it. Neo ended up back in the Matrix" "Ah, that's where you got it wrong. See, the matrix is defective. It was never about leaving. It’s all about reducing the matrix to its eigenbasis. Once you have found your eigenvectors and dominant eigenvalues, you can then orthogonalize the subspace," said Edith before finishing with a flourish, “then, you’ll be free” Mort chuckled as Audrey playfully punched her elder sister.
2. Parameterize by t to make it a screw. 3. Find the cross product E × E. 4. Apply an involution function (a1, a2) ↦ (-a1, -a2) . 5. Fibrate over P1 into an elliptic surface. 6. Apply Cox-Zucker machine to find basis. 7. ??? 8. Profit!
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia)
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia)
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia)
of a cylinder can be thought of as a bundle of fibres going from the base space of a circle. The surface of a Möbius strip can be thought of as a bundle of fibres going from a base space of a circle.
type Q big.Rat // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // QFn represents a rational function. type QFn struct { n, d Poly } // Point is a point on an elliptic curve. type Point struct { x, y *Q } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } Elliptic Curve & Surface // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section }
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia)
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia)
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia)
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia)
binary operation, · such that a · b = c, where a, b, c ∈ A A = ℤ = {..., -3, -2, -1, 0, 1, 2, 3,…} + type Int int func Add(a, b Int) Int { return a + b } Rules • A has identity/“zero” element • (a · b) · c = a · (b· c) type String string func Add(a, b String) String { return a + b }
binary operation, · such that a · b = c, where a, b, c ∈ A A = ℤ = {..., -3, -2, -1, 0, 1, 2, 3,…} + type Int int func Add(a, b Int) Int { return a + b } Rules • A has identity/“zero” element • (a · b) · c = a · (b· c) • a · b = b · a • A has inverse element type String string func Add(a, b String) String { return a + b }
binary operation, · such that a · b = c, where a, b, c ∈ A A = ℤ = {..., -3, -2, -1, 0, 1, 2, 3,…} + type Int int func (a Int) Add(b Int) Int { return a + b } Rules • A has identity/“zero” element • (a · b) · c = a · (b· c) • a · b = b · a • A has inverse element type String string func Add(a, b String) String { return a + b } // Not handled: commutativity and associativity. type Group interface { Add(elem Group) Group Neg() Group }
binary operation, · such that a · b = c, where a, b, c ∈ A A = ℤ = {..., -3, -2, -1, 0, 1, 2, 3,…} + type Int int type String string func (a String) Add(b String) String { return a + b } func (a Int) Add(b Int) Int { return a + b } type Magma interface { Add(elem Magma) Magma IsZero() bool }
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia) Set of points on the surface whose coordinates are rational numbers
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia) Set of points on the surface whose coordinates are rational numbers
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q struct { n, d *big.Int } // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia) set of points Set of points on the surface whose coordinates are rational numbers
of sections provides a basis (up to torsion) for the Mordell–Weil group of an elliptic surface E → S, where S is isomorphic to the projective line. (Wikipedia) set of points Set of points on the surface whose coordinates are rational numbers
is a basis of the Mordell-Weil group if and only if: det(<σ i , σ j >) = N2 / Πm s m s is the number of components of multiplicity 1 N is the number of elements in the torsion subgroup of the Mordell-Weil Group r is the rank of the Mordell-Weil Group
for i := range mat { mat[i] = make([]*Q, n) } for i := 0; i < n; i++ { for j := 0; j < n; j++ { mat[i][j] = es.HeightPair(sections[i], sections[j]) } } det := qMatDet(mat) thresh := ExpectedDeterminant(es) return det.Eq(thresh)
as dead pixels on a blazing white OLED screen, dissolves into view. Orthogonal to each other, they intersect at sixteen nodal points, their vector dance playing out in every direction – ahead of, behind, and through Mort. A grey volume precipitates from these lines, sweeping across space to connect the dark axes. This precision-crafted mirage skews, rotates then disintegrates A different set of four lines appear. Again, a grey volume materializes, only to vanish after a scale and tilt. This sequence repeats, hypnotic – lines shifting, grey form cohering, size changing, dissolving – an infinite recursion of ephemeral functions. Then, sudden stillness: the grey volume suffusing space, stark lines permeating every dimension.
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q big.Rat // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface
field f type EC[K Field] struct { a, b K points []Point[K] } // Field is a representation of an abstract, finite field. type Field interface { Add(x Num) Num Sub(x Num) Num Mul(x Num) Num Div(x Num) Num Neg() Num IsZero(x Num) bool CharNum() int }
finite field. type Field[T any] interface { Add(x, y T) T Sub(x, y T) T Mul(x, y T) T Div(x, y T) T Neg(x T) T IsZero(x T) bool CharNum() int } // EC represents an elliptic curve over a field f type EC[T any] struct { a, b T f Field[T] points []Point }
representation of an abstract, finite field. type Field[T any] interface { Add(x, y T) T Sub(x, y T) T Mul(x, y T) T Div(x, y T) T Neg(x T) T IsZero(x T) bool CharNum() int } // Field is a representation of an abstract, finite field. type Field interface { Add(x Num) Num Sub(x Num) Num Mul(x Num) Num Div(x Num) Num Neg() Num IsZero(x Num) bool CharNum() int } As a collection of things with rules applied? As an Engine that does things to data?
Num Mul(x Num) Num Div(x Num) Num Neg() Num IsZero(x Num) bool CharNum() int } type Field interface { Add(x, y T) T Sub(x, y T) T Mul(x, y T) T Div(x, y T) T Neg(x T) T IsZero(x T) bool CharNum() int } Closer to theory Closer to practice
{ a, b K points []Point[K] } // Field is a representation of an abstract, finite field. type Field interface { Add(x Num) Num Sub(x Num) Num Mul(x Num) Num Div(x Num) Num Neg() Num IsZero(x Num) bool CharNum() int }
{ a, b K points []Point[K] } // Field is a representation of an abstract, finite field. type Field interface { Add(x Num) Num Sub(x Num) Num Mul(x Num) Num Div(x Num) Num Neg() Num IsZero(x Num) bool CharNum() int }
{ a, b K points []Point[K] } // Field is a representation of an abstract, finite field. type Field interface { Add(x Field) Field Sub(x Field) Field Mul(x Field) Field Div(x Field) Field Neg() Field IsZero(x Field) bool CharNum() int }
Field[N]] struct { a, b K points []Point[N, K] } // Field is a representation of an abstract, finite field. type Field[T any] interface { Add(x T) T Sub(x T) T Mul(x T) T Div(x T) T Neg() T IsZero(x T) bool CharNum() int }
Q = big.Rat type Q struct { big.Rat } type Q *big.Rat type Q big.Rat Variations of Implementing Q Original implementation Too much to refactor! Not allowed to define methods Sigh, OK
Field[N]] struct { a, b K points []Point[N, K] } // Field is a representation of an abstract, finite field. type Field[T any] interface { Add(x T) T Sub(x T) T Mul(x T) T Div(x T) T Neg() T IsZero(x T) bool CharNum() int } func NewEC[N Num, K Field[DT]](...) {...} ec := NewEC[*Q, *Q](...)
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q struct { n, d *big.Int } // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q struct { n, d *big.Int } // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q struct { n, d *big.Int } // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface Field: A set of things with + - × ÷ defined // Field is a representation of an abstract, finite field. type Field[T Num] interface { Add(x T) T Sub(x T) T Mul(x T) T Div(x T) T Neg() T IsZero(x T) bool CharNum() int }
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q struct { n, d *big.Int } // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface Ring: A set of things with + and × defined // Ring is a representation of a ring type Ring[T Num] interface { Add(x T) T Mul(x T) T IsZero(x T) bool CharNum() int }
(p Poly) Div(q Poly) *Q[Poly] { return &Q[Poly]{N: q, D: q} } type Field[T Num] interface { Add(x T) T Sub(x T) T Mul(x T) T Div(x T) T Neg() T IsZero(x T) bool CharNum() int }
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q struct { n, d *big.Int } // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface Magma: A set of things with + defined // Magma is a representation of a magma. type Magma[T Num] interface { Add(x T) T IsZero(x T) bool }
{ n, d Poly } // ES represents an elliptic surface. type ES struct { a, b QFn sections []*Section } // EC represents an elliptic curve. type EC struct { a, b *Q points []Point } // Q is a representation of a rat number. type Q struct { n, d *big.Int } // Section is a section on an elliptic surface type Section struct { x, y QFn } // Polynomial is a representation of a polynomial. // The slice stores coefficients in ascending order of power. type Poly []*Q // Point is a point on an elliptic curve. type Point struct { x, y *Q } Elliptic Curve & Surface Magma: A set of things with + defined // Magma is a representation of a magma. type Magma[T any] interface { Add(x T) T IsZero(x T) bool }
shook her head. “We store things to tianyuan.” Alice paused momentarily as she gathered her thoughts, “I suppose tianyuan is just a bunch of computers and they need to store things. You know, Bob loves retro computers. He’s showed me a few in his collection. They store data on the machine itself, but there’s no such glass things. How does it work?” “These glass things have been the standard in cloud storage — er, tianyuan storage — for the past 300 years. How do you not know this?”
Surfaces: • Review by Matthias Schütt and Tetsuji Shioda (2010) • Chao Li’s homepage https://www.math.columbia.edu/~chaoli/docs/EllipticSurfaces.html p/s: Ask ChatGPT/Claude/Gemini if you want to get confused. Textbooks are way better.
chewxy
vtryo
autifyhq
tamaiyutaro
toshiblues
gaqzi
ham0215
itkr2305
kazeburo
hgsgtk
makky_tyuyan
taka_aki
kworkdev
garrettdimon
reverentgeek
jonrohan
jcasabona
jnunemaker
tammyeverts
eileencodes
bermonpainter
aleyda
thoeni
![bsky.chewxy.com The Algorithm n := len(sections) mat := make([][]*Q, n)](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_59.jpg){kind=link}
![bsky.chewxy.com On Types and Data Types type EC[K Field] struct](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_81.jpg){kind=link}
![bsky.chewxy.com On Types and Data Types type EC[K Field] struct](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_82.jpg){kind=link}
![bsky.chewxy.com On Types and Data Types type EC[K Field] struct](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_83.jpg){kind=link}
![bsky.chewxy.com Implementing Q type Q[T ???] struct { N, D](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_92.jpg){kind=link}
![bsky.chewxy.com Implementing Q type Q[R Ring] struct { N, D](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_93.jpg){kind=link}
![bsky.chewxy.com Implementing Q type Q[R Ring] struct { N, D](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_94.jpg){kind=link}
![bsky.chewxy.com Implementing Q type Q[T Num, R Ring[T]] struct {](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_95.jpg){kind=link}
![bsky.chewxy.com Implementing Rings type Poly []*Q[*Z] type Z big.Int func](https://files.speakerdeck.com/presentations/3c09fa8a9fa747a3a60aa69ca6d8df4b/slide_97.jpg){kind=link}
