order.filter.curry | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

d6fad0e5

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

63f84d91

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -94,7 +94,7 @@ theorem Tendsto.curry {f : α → β → γ} {la : Filter α} {lb : Filter β} {
   intro h
   rw [tendsto_def]
   simp only [curry, Filter.mem_mk, Set.mem_setOf_eq, Set.mem_preimage]
-  simp_rw [tendsto_def] at h 
+  simp_rw [tendsto_def] at h
   refine' fun s hs => h.mono fun a ha => eventually_iff.mpr _
   simpa [Function.HasUncurry.uncurry, Set.preimage] using ha s hs
 #align filter.tendsto.curry Filter.Tendsto.curry

63f84d91

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Kevin H. Wilson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin H. Wilson
 -/
-import Mathbin.Order.Filter.Prod
+import Order.Filter.Prod
 
 #align_import order.filter.curry from "leanprover-community/mathlib"@"63f84d91dd847f50bae04a01071f3a5491934e36"

63f84d91

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Kevin H. Wilson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin H. Wilson
-
-! This file was ported from Lean 3 source module order.filter.curry
-! leanprover-community/mathlib commit 63f84d91dd847f50bae04a01071f3a5491934e36
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Filter.Prod
 
+#align_import order.filter.curry from "leanprover-community/mathlib"@"63f84d91dd847f50bae04a01071f3a5491934e36"
+
 /-!
 # Curried Filters

63f84d91

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -73,11 +73,14 @@ def curry (f : Filter α) (g : Filter β) : Filter (α × β)
 #align filter.curry Filter.curry
 -/
 
+#print Filter.eventually_curry_iff /-
 theorem eventually_curry_iff {f : Filter α} {g : Filter β} {p : α × β → Prop} :
     (∀ᶠ x : α × β in f.curry g, p x) ↔ ∀ᶠ x : α in f, ∀ᶠ y : β in g, p (x, y) :=
   Iff.rfl
 #align filter.eventually_curry_iff Filter.eventually_curry_iff
+-/
 
+#print Filter.curry_le_prod /-
 theorem curry_le_prod {f : Filter α} {g : Filter β} : f.curry g ≤ f.Prod g :=
   by
   intro u hu
@@ -85,7 +88,9 @@ theorem curry_le_prod {f : Filter α} {g : Filter β} : f.curry g ≤ f.Prod g :
   rw [eventually_curry_iff]
   exact hu.curry
 #align filter.curry_le_prod Filter.curry_le_prod
+-/
 
+#print Filter.Tendsto.curry /-
 theorem Tendsto.curry {f : α → β → γ} {la : Filter α} {lb : Filter β} {lc : Filter γ} :
     (∀ᶠ a in la, Tendsto (fun b : β => f a b) lb lc) → Tendsto (↿f) (la.curry lb) lc :=
   by
@@ -96,6 +101,7 @@ theorem Tendsto.curry {f : α → β → γ} {la : Filter α} {lb : Filter β} {
   refine' fun s hs => h.mono fun a ha => eventually_iff.mpr _
   simpa [Function.HasUncurry.uncurry, Set.preimage] using ha s hs
 #align filter.tendsto.curry Filter.Tendsto.curry
+-/
 
 end Filter

63f84d91

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -60,7 +60,7 @@ in adding quantifiers to the middle of `tendsto`s. See
 `has_fderiv_at_of_tendsto_uniformly_on_filter`. -/
 def curry (f : Filter α) (g : Filter β) : Filter (α × β)
     where
-  sets := { s | ∀ᶠ a : α in f, ∀ᶠ b : β in g, (a, b) ∈ s }
+  sets := {s | ∀ᶠ a : α in f, ∀ᶠ b : β in g, (a, b) ∈ s}
   univ_sets := by simp only [Set.mem_setOf_eq, Set.mem_univ, eventually_true]
   sets_of_superset := by
     intro x y hx hxy

63f84d91

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -64,11 +64,11 @@ def curry (f : Filter α) (g : Filter β) : Filter (α × β)
   univ_sets := by simp only [Set.mem_setOf_eq, Set.mem_univ, eventually_true]
   sets_of_superset := by
     intro x y hx hxy
-    simp only [Set.mem_setOf_eq] at hx⊢
+    simp only [Set.mem_setOf_eq] at hx ⊢
     exact hx.mono fun a ha => ha.mono fun b hb => Set.mem_of_subset_of_mem hxy hb
   inter_sets := by
     intro x y hx hy
-    simp only [Set.mem_setOf_eq, Set.mem_inter_iff] at hx hy⊢
+    simp only [Set.mem_setOf_eq, Set.mem_inter_iff] at hx hy ⊢
     exact (hx.and hy).mono fun a ha => (ha.1.And ha.2).mono fun b hb => hb
 #align filter.curry Filter.curry
 -/
@@ -81,7 +81,7 @@ theorem eventually_curry_iff {f : Filter α} {g : Filter β} {p : α × β → P
 theorem curry_le_prod {f : Filter α} {g : Filter β} : f.curry g ≤ f.Prod g :=
   by
   intro u hu
-  rw [← eventually_mem_set] at hu⊢
+  rw [← eventually_mem_set] at hu ⊢
   rw [eventually_curry_iff]
   exact hu.curry
 #align filter.curry_le_prod Filter.curry_le_prod
@@ -92,7 +92,7 @@ theorem Tendsto.curry {f : α → β → γ} {la : Filter α} {lb : Filter β} {
   intro h
   rw [tendsto_def]
   simp only [curry, Filter.mem_mk, Set.mem_setOf_eq, Set.mem_preimage]
-  simp_rw [tendsto_def] at h
+  simp_rw [tendsto_def] at h 
   refine' fun s hs => h.mono fun a ha => eventually_iff.mpr _
   simpa [Function.HasUncurry.uncurry, Set.preimage] using ha s hs
 #align filter.tendsto.curry Filter.Tendsto.curry

63f84d91

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -73,23 +73,11 @@ def curry (f : Filter α) (g : Filter β) : Filter (α × β)
 #align filter.curry Filter.curry
 -/
 
-/- warning: filter.eventually_curry_iff -> Filter.eventually_curry_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β} {p : (Prod.{u1, u2} α β) -> Prop}, Iff (Filter.Eventually.{max u1 u2} (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => p x) (Filter.curry.{u1, u2} α β f g)) (Filter.Eventually.{u1} α (fun (x : α) => Filter.Eventually.{u2} β (fun (y : β) => p (Prod.mk.{u1, u2} α β x y)) g) f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : Filter.{u2} α} {g : Filter.{u1} β} {p : (Prod.{u2, u1} α β) -> Prop}, Iff (Filter.Eventually.{max u2 u1} (Prod.{u2, u1} α β) (fun (x : Prod.{u2, u1} α β) => p x) (Filter.curry.{u2, u1} α β f g)) (Filter.Eventually.{u2} α (fun (x : α) => Filter.Eventually.{u1} β (fun (y : β) => p (Prod.mk.{u2, u1} α β x y)) g) f)
-Case conversion may be inaccurate. Consider using '#align filter.eventually_curry_iff Filter.eventually_curry_iffₓ'. -/
 theorem eventually_curry_iff {f : Filter α} {g : Filter β} {p : α × β → Prop} :
     (∀ᶠ x : α × β in f.curry g, p x) ↔ ∀ᶠ x : α in f, ∀ᶠ y : β in g, p (x, y) :=
   Iff.rfl
 #align filter.eventually_curry_iff Filter.eventually_curry_iff
 
-/- warning: filter.curry_le_prod -> Filter.curry_le_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β}, LE.le.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Preorder.toHasLe.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Filter.partialOrder.{max u1 u2} (Prod.{u1, u2} α β)))) (Filter.curry.{u1, u2} α β f g) (Filter.prod.{u1, u2} α β f g)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : Filter.{u2} α} {g : Filter.{u1} β}, LE.le.{max u2 u1} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Preorder.toLE.{max u2 u1} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (PartialOrder.toPreorder.{max u2 u1} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Filter.instPartialOrderFilter.{max u2 u1} (Prod.{u2, u1} α β)))) (Filter.curry.{u2, u1} α β f g) (Filter.prod.{u2, u1} α β f g)
-Case conversion may be inaccurate. Consider using '#align filter.curry_le_prod Filter.curry_le_prodₓ'. -/
 theorem curry_le_prod {f : Filter α} {g : Filter β} : f.curry g ≤ f.Prod g :=
   by
   intro u hu
@@ -98,12 +86,6 @@ theorem curry_le_prod {f : Filter α} {g : Filter β} : f.curry g ≤ f.Prod g :
   exact hu.curry
 #align filter.curry_le_prod Filter.curry_le_prod
 
-/- warning: filter.tendsto.curry -> Filter.Tendsto.curry is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β -> γ} {la : Filter.{u1} α} {lb : Filter.{u2} β} {lc : Filter.{u3} γ}, (Filter.Eventually.{u1} α (fun (a : α) => Filter.Tendsto.{u2, u3} β γ (fun (b : β) => f a b) lb lc) la) -> (Filter.Tendsto.{max u1 u2, u3} (Prod.{u1, u2} α β) γ (Function.HasUncurry.uncurry.{max u1 u2 u3, max u1 u2, u3} (α -> β -> γ) (Prod.{u1, u2} α β) γ (Function.hasUncurryInduction.{u1, max u2 u3, u2, u3} α (β -> γ) β γ (Function.hasUncurryBase.{u2, u3} β γ)) f) (Filter.curry.{u1, u2} α β la lb) lc)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {f : α -> β -> γ} {la : Filter.{u3} α} {lb : Filter.{u2} β} {lc : Filter.{u1} γ}, (Filter.Eventually.{u3} α (fun (a : α) => Filter.Tendsto.{u2, u1} β γ (fun (b : β) => f a b) lb lc) la) -> (Filter.Tendsto.{max u3 u2, u1} (Prod.{u3, u2} α β) γ (Function.HasUncurry.uncurry.{max (max u3 u2) u1, max u3 u2, u1} (α -> β -> γ) (Prod.{u3, u2} α β) γ (Function.hasUncurryInduction.{u3, max u2 u1, u2, u1} α (β -> γ) β γ (Function.hasUncurryBase.{u2, u1} β γ)) f) (Filter.curry.{u3, u2} α β la lb) lc)
-Case conversion may be inaccurate. Consider using '#align filter.tendsto.curry Filter.Tendsto.curryₓ'. -/
 theorem Tendsto.curry {f : α → β → γ} {la : Filter α} {lb : Filter β} {lc : Filter γ} :
     (∀ᶠ a in la, Tendsto (fun b : β => f a b) lb lc) → Tendsto (↿f) (la.curry lb) lc :=
   by

63f84d91

bump to nightly-2023-05-16-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

9cb92e8c

Diff

@@ -86,7 +86,7 @@ theorem eventually_curry_iff {f : Filter α} {g : Filter β} {p : α × β → P
 
 /- warning: filter.curry_le_prod -> Filter.curry_le_prod is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β}, LE.le.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Preorder.toLE.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Filter.partialOrder.{max u1 u2} (Prod.{u1, u2} α β)))) (Filter.curry.{u1, u2} α β f g) (Filter.prod.{u1, u2} α β f g)
+  forall {α : Type.{u1}} {β : Type.{u2}} {f : Filter.{u1} α} {g : Filter.{u2} β}, LE.le.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Preorder.toHasLe.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (PartialOrder.toPreorder.{max u1 u2} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Filter.partialOrder.{max u1 u2} (Prod.{u1, u2} α β)))) (Filter.curry.{u1, u2} α β f g) (Filter.prod.{u1, u2} α β f g)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {f : Filter.{u2} α} {g : Filter.{u1} β}, LE.le.{max u2 u1} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Preorder.toLE.{max u2 u1} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (PartialOrder.toPreorder.{max u2 u1} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Filter.instPartialOrderFilter.{max u2 u1} (Prod.{u2, u1} α β)))) (Filter.curry.{u2, u1} α β f g) (Filter.prod.{u2, u1} α β f g)
 Case conversion may be inaccurate. Consider using '#align filter.curry_le_prod Filter.curry_le_prodₓ'. -/

63f84d91

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

d6fad0e5

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -45,7 +45,7 @@ uniform convergence, curried filters, product filters
 
 namespace Filter
 
-variable {α β γ : Type _}
+variable {α β γ : Type*}
 
 /-- This filter is characterized by `Filter.eventually_curry_iff`:
 `(∀ᶠ (x : α × β) in f.curry g, p x) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in g, p (x, y)`. Useful

d6fad0e5

chore: tidy various files (#6158)

0bcfc2d2

Diff

@@ -25,7 +25,7 @@ filter (see `Filter.curry_le_prod` and `Filter.eventually.curry`), but the conve
 
 Another way to think about the curried versus the product filter is that tending to some limit on
 the product filter is a version of uniform convergence (see `tendsto_prod_filter_iff`) whereas
-tending to some limit on a curried filter is just iterated limits (see `tendsto.curry`).
+tending to some limit on a curried filter is just iterated limits (see `Filter.Tendsto.curry`).
 
 ## Main definitions
 
@@ -49,8 +49,8 @@ variable {α β γ : Type _}
 
 /-- This filter is characterized by `Filter.eventually_curry_iff`:
 `(∀ᶠ (x : α × β) in f.curry g, p x) ↔ ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in g, p (x, y)`. Useful
-in adding quantifiers to the middle of `tendsto`s. See
-`has_fderiv_at_of_tendsto_uniformly_on_filter`. -/
+in adding quantifiers to the middle of `Tendsto`s. See
+`hasFDerivAt_of_tendstoUniformlyOnFilter`. -/
 def curry (f : Filter α) (g : Filter β) : Filter (α × β) where
   sets := { s | ∀ᶠ a : α in f, ∀ᶠ b : β in g, (a, b) ∈ s }
   univ_sets := by simp only [Set.mem_setOf_eq, Set.mem_univ, eventually_true]

d6fad0e5

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Kevin H. Wilson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin H. Wilson
-
-! This file was ported from Lean 3 source module order.filter.curry
-! leanprover-community/mathlib commit d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Filter.Prod
 
+#align_import order.filter.curry from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
+
 /-!
 # Curried Filters

d6fad0e5

chore: cleanup whitespace (#5988)

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

12343aa5

Diff

@@ -74,7 +74,7 @@ theorem curry_le_prod {f : Filter α} {g : Filter β} : f.curry g ≤ f.prod g :
 
 theorem Tendsto.curry {f : α → β → γ} {la : Filter α} {lb : Filter β} {lc : Filter γ}
     (h : ∀ᶠ a in la, Tendsto (fun b : β => f a b) lb lc) : Tendsto (↿f) (la.curry lb) lc :=
-  fun _s hs => h.mono fun _a ha =>  ha hs
+  fun _s hs => h.mono fun _a ha => ha hs
 #align filter.tendsto.curry Filter.Tendsto.curry
 
 end Filter

d6fad0e5

refactor: use the typeclass SProd to implement overloaded notation · ×ˢ · (#4200)

Currently, the following notations are changed from · ×ˢ · because Lean 4 can't deal with ambiguous notations. | Definition | Notation | | :

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

6c01dc6e

Diff

@@ -22,7 +22,7 @@ yields the quantifier order `∃ ∀ ∃ ∀`. For instance,
 `∀ᶠ n in at_top.curry at_top, p n ↔ ∃ M, ∀ m ≥ M, ∃ N, ∀ n ≥ N, p (m, n)`.
 
 This is different from a product filter, which instead yields a quantifier order `∃ ∃ ∀ ∀`. For
-instance, `∀ᶠ n in at_top ×ᶠ at_top, p n ↔ ∃ M, ∃ N, ∀ m ≥ M, ∀ n ≥ N, p (m, n)`. This makes it
+instance, `∀ᶠ n in at_top ×ˢ at_top, p n ↔ ∃ M, ∃ N, ∀ m ≥ M, ∀ n ≥ N, p (m, n)`. This makes it
 clear that if something eventually occurs on the product filter, it eventually occurs on the curried
 filter (see `Filter.curry_le_prod` and `Filter.eventually.curry`), but the converse is not true.

d6fad0e5

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -14,7 +14,7 @@ import Mathlib.Order.Filter.Prod
 # Curried Filters
 
 This file provides an operation (`Filter.curry`) on filters which provides the equivalence
-`∀ᶠ a in l, ∀ᶠ b in l', p (a, b) ↔ ∀ᶠ c in (l.curry l'), p c` (see `filter.eventually_curry_iff`).
+`∀ᶠ a in l, ∀ᶠ b in l', p (a, b) ↔ ∀ᶠ c in (l.curry l'), p c` (see `Filter.eventually_curry_iff`).
 
 To understand when this operation might arise, it is helpful to think of `∀ᶠ` as a combination of
 the quantifiers `∃ ∀`. For instance, `∀ᶠ n in at_top, p n ↔ ∃ N, ∀ n ≥ N, p n`. A curried filter

d6fad0e5

chore: fix some names in comments (#3276)

Co-authored-by: Moritz Firsching <firsching@google.com>

b57ede59

Diff

@@ -13,7 +13,7 @@ import Mathlib.Order.Filter.Prod
 /-!
 # Curried Filters
 
-This file provides an operation (`filter.curry`) on filters which provides the equivalence
+This file provides an operation (`Filter.curry`) on filters which provides the equivalence
 `∀ᶠ a in l, ∀ᶠ b in l', p (a, b) ↔ ∀ᶠ c in (l.curry l'), p c` (see `filter.eventually_curry_iff`).
 
 To understand when this operation might arise, it is helpful to think of `∀ᶠ` as a combination of
@@ -24,7 +24,7 @@ yields the quantifier order `∃ ∀ ∃ ∀`. For instance,
 This is different from a product filter, which instead yields a quantifier order `∃ ∃ ∀ ∀`. For
 instance, `∀ᶠ n in at_top ×ᶠ at_top, p n ↔ ∃ M, ∃ N, ∀ m ≥ M, ∀ n ≥ N, p (m, n)`. This makes it
 clear that if something eventually occurs on the product filter, it eventually occurs on the curried
-filter (see `filter.curry_le_prod` and `filter.eventually.curry`), but the converse is not true.
+filter (see `Filter.curry_le_prod` and `Filter.eventually.curry`), but the converse is not true.
 
 Another way to think about the curried versus the product filter is that tending to some limit on
 the product filter is a version of uniform convergence (see `tendsto_prod_filter_iff`) whereas

d6fad0e5

Feat: port Order.Filter.Curry (#1773)

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Eric Rodriguez <ericrboidi@gmail.com> Co-authored-by: Yury G. Kudryashov <urkud@urkud.name> Co-authored-by: ADedecker <anatolededecker@gmail.com>

cdcd203e

`order.filter.curry` ⟷ `Mathlib.Order.Filter.Curry`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 6 + 216

order.filter.curry ⟷ Mathlib.Order.Filter.Curry

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 6 + 216

`order.filter.curry` ⟷ `Mathlib.Order.Filter.Curry`