Real numbers, based on Cauchy sequences #2487

Taneb · 2024-09-27T09:29:43Z

Very much work-in-progress

From previous attempts, multiplication of real numbers will be the stalling point. But the HoTT book suggests this can be implemented in terms of addition, subtraction, and multiplication by a rational, which are all achievable, and squaring, which I don't know about.

MatthewDaggitt

This looks great!

I've left a review on the two files outside of Data.Real. I think it's probably easier to try and merge them in first and then tackle the Real files?

MatthewDaggitt · 2024-09-28T05:24:14Z

src/Data/Rational/Properties.agda

+d-indiscernable {p} {q} ∣p-q∣≡0 = begin
+  p               ≡˘⟨ +-identityʳ p ⟩
+  p - 0ℚ          ≡˘⟨ cong (_-_ p) (∣p∣≡0⇒p≡0 (p - q) ∣p-q∣≡0) ⟩
+  p - (p - q)     ≡⟨ cong (_+_ p) (neg-distrib-+ p (- q)) ⟩


It feels like p - (p - q) ≡ q should be a lemma in GroupProperties?

It actually requires commutativity! (this is hidden in neg-distrib-+). As far as I can tell it doesn't exist yet.

The following proof looks commutativity-free to me?

p - (p - q) = p + - (p + - q) = p + (-p + q) = (p + -p) + q = 0# + q = q

The step - (p + - q) = - p + q requires commutativity

Oh whoops. Yes, you don't get distributivity for free.

See Algebra.Properties.AbelianGroup.⁻¹-anti-homo‿- added in #2349 ?

src/Data/Rational/Properties.agda

MatthewDaggitt · 2024-09-28T05:27:11Z

src/Data/Rational/Properties.agda

+
+private
+  d : ℚ → ℚ → ℚ
+  d p q = ∣ p - q ∣


This is really very frustrating. Anyone have any nice ideas how we can make this a function in Data.Rational.Base? I guess we could use some weird unicode bars?

No idea on how to name this properly in Data.Rational.Base. But I was surprised that it is ℚ-valued - do we not have non-negative rationals as a type? That way this would be nonNegative by construction instead of requiring a proof.

See my global comment: we should have ℚ⁺ as a first class thing in the library before we proceed!

Re: notation. UPDATED since I learnt how to write the symbols ;-)
It is a norm, so does using the following offer any assistance?

Suggested change

d p q = ∣ p - q ∣

-- distance function

∥_─_∥ : ℚ → ℚ → ℚ

∥ p ─ q ∥ = ∣ p - q ∣

which reuses the 'long minus' \ - - - (used in Data.List.Relation.Unary.Any so hopefully the two uses won't be in scope at the same time...), and whose "weird Unicode bars" here are in fact simply given by \ | |... so they aren't too bad, either...

MatthewDaggitt · 2024-09-28T05:31:10Z

src/Function/Metric/Rational/CauchySequence.agda

+open import Relation.Binary
+open import Relation.Binary.PropositionalEquality using (cong₂)
+
+record CauchySequence : Set a where


So I think this and the equality definition needs to be defined over a DistanceFunction rather than a full Metric with laws. Otherwise we're forced to define completeness over the whole metric space bundle, and we try and avoid defining predicates over bundles like that in the library.

The added advantage of this, is that we could definite the notion of Cauchy sequence generically, rather than just for Rational.

This record would also benefit from a constructor I think? Which would allow us to avoid writing sequence x and sequence y everywhere and instead write x and y?

Hmm. I want to make isCauchy irrelevant. Would both doing that and introducing a constructor run into Irrelevant Projections stuff?

Well we use a record constructor with irrelevant fields in Data.Rational.Base and I'm not aware we've run into any problems there...

See also Data.Refinement for an already-'officially-sanctioned' stdlib approach to such matters...

As for irrelevant projections, the discussion on agda/agda#7063 , upstream from #2199 (and others label:irrelevance/label:irrelevant-projections) suggest... (probably) not?

src/Function/Metric/Rational/CauchySequence.agda

JacquesCarette

This is looking really great. A variety of comments as I was leafing through the code.

JacquesCarette · 2024-09-28T13:45:17Z

src/Codata/Guarded/Stream/Relation/Binary/Pointwise.agda

+      ε : A
+
+  assoc : Associative _≈_ _∙_ → Associative (Pointwise _≈_) (Stream.zipWith _∙_)
+  head (assoc assoc₁ xs ys zs) = assoc₁ (head xs) (head ys) (head zs)


Here (and for all the newly added bits): assoc assoc₁ is super ugly. One of the two should be renamed.

JacquesCarette · 2024-09-28T13:52:39Z

src/Data/Rational/Properties.agda

+
+private
+  d : ℚ → ℚ → ℚ
+  d p q = ∣ p - q ∣


No idea on how to name this properly in Data.Rational.Base. But I was surprised that it is ℚ-valued - do we not have non-negative rationals as a type? That way this would be nonNegative by construction instead of requiring a proof.

JacquesCarette · 2024-09-28T13:55:26Z

src/Data/Rational/Properties.agda

+d-triangle p q r = begin
+  ∣ p - r ∣             ≡⟨ cong (λ # → ∣ # - r ∣) (+-identityʳ p) ⟨
+  ∣ p + 0ℚ - r ∣        ≡⟨ cong (λ # → ∣ p + # - r ∣) (+-inverseˡ q) ⟨
+  ∣ p + (- q + q) - r ∣ ≡⟨ cong (λ # → ∣ # - r ∣) (+-assoc p (- q) q) ⟨


Isn't this 'middle4' for semigroup? (i.e. all these +-assoc moves).

JacquesCarette · 2024-09-28T13:59:21Z

src/Data/Real/Base.agda

+      (lookup-zipWith m ℚ._+_ (sequence x) (sequence y))
+      (lookup-zipWith n ℚ._+_ (sequence x) (sequence y))
+    ⟩
+  ∣ (lookup (sequence x) m ℚ.+ lookup (sequence y) m) - (lookup (sequence x) n ℚ.+ lookup (sequence y) n) ∣


Looks like some notation for lookup (sequence x) m would make all of this way more readable.

JacquesCarette · 2024-09-28T14:01:28Z

src/Data/Real/Base.agda

+    open ≤-Reasoning
+    instance _ : Positive (½ * ε)
+    _ = pos*pos⇒pos ½ ε
+    [x] = isCauchy x (½ * ε)


you name isCauchy but only use its first component -- maybe name that instead, to save all the projections above?

I do use the second component, on lines 50 and 54. But I use the first component a lot more

src/Data/Real/Base.agda

JacquesCarette · 2024-09-28T14:08:47Z

src/Data/Real/Properties.agda

+    lemma = solve 4 (λ a b c d → ((a :+ b) :- (c :+ d)) , ((a :- c) :+ (b :- d))) refl
+      where open +-*-Solver
+
+-assoc : Associative _+_


all the next properties seem to be lifting properties, i.e. if some binary operation + has property P then its lift to streams will have the same property.

jamesmckinna · 2024-09-29T18:48:12Z

I've written this on every channel concerned with constructive formalisations of the reals, but for the sake of clarity, I'll repeat myself here: please please please do NOT base the representation of ℝ on Cauchy sequences, because the rates of convergence (be it by 1/n convergence, or by 1/2^n...) are so bad, and so much pointless arithmetic is involved, but instead use the development in Russell O' Connor's PhD thesis (which we have had for 15+ years already...) in terms of the monad for metric space completion, based on functions from ε ∈ ℚ⁺ to ℚ representing nested decreasing ε-balls around a point... (IIRC; but it's all very clear in Russell's thesis, Coq or no Coq...)

The opportunity when passing from 'classical'/'orthodox' constructions in mathematics to ones 'better adapted' to the activity for formalisation, is one of the outstanding research challenges for our field, and a much-neglected one. We can (and should!!!) do better!

Taneb · 2024-09-30T06:32:31Z

@jamesmckinna I'm reading Russel O'Connor's construction now. I haven't fully understood it yet, but I will note: I'm not using a fixed rate of convergence, so I don't think I have the rate of convergence issues you mention. For example, real number expressions involving only rational numbers so far converge immediately.

jamesmckinna · 2024-10-03T12:26:54Z

To press on my point: I think it's much more natural (Occam's Razor) to consider (regular) functions rather than streams for encoding the basic data underlying the 'Cauchy' property... and, given that stdlib does not commit to using HoTT-like quotients based on HI(I)Ts, in favour of a (legacy/historical, but still, ontologically less committed/more neutral) choice based on setoids, I don't see any especial need to mutually define distance-related concepts with the metric completion functor. But other opinions/design decisions are available!

Taneb · 2024-10-08T11:41:21Z

This has stalled while I've been going on a sidequest to implement O'Connor-style reals. It's a lot more up-front work, but it does seem like it's going to win some advantages:

It avoids going via a stream of rationals, skipping the potentially long indexing step and avoiding needing --guardedness
A lot of the work implementing operators is done "up front", making the actual operations a lot easier

Both in this branch and my branch implementing the O'Connor reals (not currently online), I'm using Data.Rational.Solver a lot. This would be a little nicer perhaps if #1879 had been done, and if we were more willing to use these solvers within stdlib itself. It would also be very nice to have an inequality solver for rationals, but I have no idea how one could go about implementing that. Alternatively, I could put a bit of effort into factoring out common lemmas (mostly relating to ½ * x + ½ * x ≡ x) which might be enough to make this a lot less tedious.

Another thing that would be useful would be a type of strictly positive rationals, for example:

record ℚ⁺ : Set where
  constructor 𝕢⁺
  field
    unℚ⁺ : ℚ
    instance .{{unℚ⁺-pos}} : Positive unℚ⁺

(see also #1118). This looks like Data.Refinement, but it's not because of the instance-iness.

O'Connor defines metric spaces in terms of balls rather than distance functions, which allows him to define "real" metrics prior to having real numbers. Most of the challenge has been defining completion as a (strong!) monad on the category of these metric spaces and universally continuous functions.

jamesmckinna · 2024-10-08T14:45:28Z

Very interesting! Thanks for the update regarding "O'Connor Reals" (he'd probably say they they were Bishop/Bridges/Richman...?), and while I'm sorry for holding things up, I'm not actually sorry ;-)

As for deciding inequalities between rationals, this is a classic in the Automated Reasoning literature, via Shostak's algorithm for combining decision procedures, but may be tackled directly via the decidability (via quantifier elimination) of (the theory of) Dense Linear Order... of which the Rationals are the unique up-to countable model. (I added the proofs for density a while back...)

Definitely agree that we should tackle solvers for this and other similar theories, but I haven't quite got my head round the Reflection machinery yet...

jamesmckinna · 2024-10-09T12:30:24Z

@Taneb writes:

Another thing that would be useful would be a type of strictly positive rationals, for example:
record ℚ⁺ : Set where
  constructor 𝕢⁺
  field
    unℚ⁺ : ℚ
    instance .{{unℚ⁺-pos}} : Positive unℚ⁺
(see also #1118). This looks like Data.Refinement, but it's not because of the instance-iness.

I'm confused... I though that the {{...}} bracketing would already mark the unℚ⁺-pos field as an instance, and available for proof search? What's the difference between your definition and eg.

record ℚ⁺ : Set where
  constructor 𝕢⁺
  field
    unℚ⁺ : ℚ
    .{{unℚ⁺-pos}} : Positive unℚ⁺

As for constructor/field names, my (ongoing; following PhIl Wadler) preference might be for 'minimum-ink' solutions, such as a postfix constructor _⁺ (or else as a pattern synonym taking explicit instance argument {{_}}?) and, whatever the actual field name chosen for the underlying value (though value springs to mind, echoing Data.Refinement... though I'd be inclined to keep it private?), a postfix synonym _⁻ to strip off the _⁺... but perhaps that might cause too much eye/mind strain? And pos would seem canonical for the associated irrelevant instance name?

Taneb · 2024-10-09T14:01:03Z

Thanks @jamesmckinna , I've taken those suggestions into account. I'd been over-cautious with the instance declaration, and assumed I was right when Agda didn't complain about the redundant keyword

MatthewDaggitt · 2024-12-09T02:58:40Z

Removing this from v2.2

jamesmckinna · 2024-12-10T06:32:01Z

Happy to help contribute to this! (Discuss offline?)

Taneb · 2024-12-10T10:08:03Z

I'd appreciate the help! I've been alternatingly ill, busy, and distracted for a little while. I'll message you on Zulip about this later.

MatthewDaggitt · 2024-12-11T07:05:19Z

@Taneb I think there's already an implementation of O'Connor style reals out there here:

https://github.com/bobatkey/agda-metric-reals

We should check with @bobatkey, but I think he'd be happy to have them form the basis of something added here?

Taneb · 2024-12-11T07:09:03Z

@MatthewDaggitt while that looks interesting, it doesn't seem to contain a full definition of real numbers, and isn't using O'Connor style reals (so far).

MatthewDaggitt · 2024-12-11T07:24:18Z

Ah sorry, my bad to you and @bobatkey! I have to confess I'm not too across the differences in the different formalisations and when I read the citations at the bottom, I assumed it was the same formalisation.

jamesmckinna · 2024-12-12T08:49:02Z

The merge conflict now reported is strange (and irritating! git can't do better?), so I wonder if, in the interests of making incremental progress, that the Data.Rational commits be split out as a smaller, simpler PR... or even two?

one for the nonPos/nonNeg instance arithmetic
another for the distance metric function, esp. modulo @JacquesCarette 's comment about

No idea on how to name this properly in Data.Rational.Base. But I was surprised that it is ℚ-valued - do we not have non-negative rationals as a type? That way this would be nonNegative by construction instead of requiring a proof.

Each of those would seem a useful contribution in and of themselves as 'infrastructure'...? (as well as making the reviewing task more manageable?)

Taneb · 2024-12-12T09:45:44Z

I already pulled the nonPos/nonNeg etc instance arithmetic out into PR #2496, it has since been merged, but I never updated this branch. Getting the distance metric function in would be great though.

bobatkey · 2024-12-12T17:13:55Z

@MatthewDaggitt while that looks interesting, it doesn't seem to contain a full definition of real numbers, and isn't using O'Connor style reals (so far).

Not everything is finished (esp multiplication) but my development does include a definition of the reals using O'Connor's definition (and the upper-semi-continuous reals):

There is a definition of Upper Semi-continuous reals, which turns O'Connor's definitions using balls into a more standard looking pseudometric space definition.
The completion monad is defined on pseudometric spaces, using regular functions.
The Cauchy Reals are the completion of the rationals as a metric space.
Addition and negation are defined, with the expected laws. Bounded multiplication is done, but unrestricted multiplication is unfinished because I never worked out how to incorporate the scaling properly. My memory is misty, but I think O'Connor does everything using uniformly continuous functions, and I'm using non-expansive functions, which made things a bit harder.

I do mean to go back and finish this, but the first thing I want to do is tidy up the Data.Real.UpperClosed to do proper Dedekind reals (with variations) before the reals as a metric space completion.

jamesmckinna · 2024-12-24T11:57:53Z

I'd appreciate the help! I've been alternatingly ill, busy, and distracted for a little while. I'll message you on Zulip about this later.

Sorry not have looped back to this before now. Happy to contribute, but it would be good to start form a clean PR, rebased against #2496 before looking at the diffs with @bobatkey 's incomplete development?

bsaul · 2025-01-18T15:12:09Z

This progress on the Reals is exciting to see. I've been noodling on Reals via the so-called Eudoxus construction here: https://git.sr.ht/~bradleysaul/eudoxus. I'm not nearly as far along in terms of theorems about the Reals as this PR, but I thought I'd share for comparison's sake.

This makes it easier to supply either explicitly

MatthewDaggitt reviewed Sep 28, 2024

View reviewed changes

MatthewDaggitt added the addition label Sep 28, 2024

MatthewDaggitt added this to the v2.2 milestone Sep 28, 2024

JacquesCarette reviewed Sep 28, 2024

View reviewed changes

MatthewDaggitt removed this from the v2.2 milestone Dec 9, 2024

Taneb added 7 commits January 21, 2025 14:31

WIP real numbers

b0c259a

Add left multiplication by a rational

2f83c32

cubical compatible

2b4bb62

Define square function

7b8988c

Implement negation

2eb083c

Start adding properties

fdf3da7

Simplify d-sym proof

978c945

Taneb added 9 commits January 21, 2025 14:31

Irrelevant positivity

4fa5d9d

Add and use pos*pos=>pos

84e02ab

Fiddle with order of instance arguments

c71b937

This makes it easier to supply either explicitly

Use new symmetric syntax in Data.Rational.Properties

16a497c

Use new symmetric syntax elsewhere

f40c085

Add some algebraic properties of pointwise relations on streams

3b796db

Simplify and continue algebraic properties of reals

e2ef3fb

Use new properties to simplify Real

a14f5fd

Don't know what this line was doing over there

84270bb

Taneb force-pushed the reals branch from 571b4bb to 84270bb Compare January 21, 2025 13:33

-  d p q = ∣ p - q ∣
+-- distance function
+∥_─_∥ : ℚ → ℚ → ℚ
+∥ p ─ q ∥ = ∣ p - q ∣

Real numbers, based on Cauchy sequences #2487

Are you sure you want to change the base?

Real numbers, based on Cauchy sequences #2487

Conversation

Taneb commented Sep 27, 2024

MatthewDaggitt left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jamesmckinna Oct 3, 2024 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

JacquesCarette left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jamesmckinna commented Sep 29, 2024 • edited Loading

Taneb commented Sep 30, 2024

jamesmckinna commented Oct 3, 2024 • edited Loading

Taneb commented Oct 8, 2024

jamesmckinna commented Oct 8, 2024

jamesmckinna commented Oct 9, 2024 • edited Loading

Taneb commented Oct 9, 2024

MatthewDaggitt commented Dec 9, 2024

jamesmckinna commented Dec 10, 2024 • edited Loading

Taneb commented Dec 10, 2024

MatthewDaggitt commented Dec 11, 2024

Taneb commented Dec 11, 2024

MatthewDaggitt commented Dec 11, 2024 • edited Loading

jamesmckinna commented Dec 12, 2024 • edited Loading

Taneb commented Dec 12, 2024

bobatkey commented Dec 12, 2024

jamesmckinna commented Dec 24, 2024

bsaul commented Jan 18, 2025

jamesmckinna Oct 3, 2024 •

edited

Loading

jamesmckinna commented Sep 29, 2024 •

edited

Loading

jamesmckinna commented Oct 3, 2024 •

edited

Loading

jamesmckinna commented Oct 9, 2024 •

edited

Loading

jamesmckinna commented Dec 10, 2024 •

edited

Loading

MatthewDaggitt commented Dec 11, 2024 •

edited

Loading

jamesmckinna commented Dec 12, 2024 •

edited

Loading