data.set.pointwise.list_of_fn | 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

f694c7de

(last sync)

refactor(*): define list.replicate and migrate to it (#18127)

This definition differs from list.repeat by the order of arguments. The new order is in sync with the Lean 4 version.

Diff

@@ -44,6 +44,6 @@ end
 
 @[to_additive] lemma mem_pow {a : α} {n : ℕ} :
   a ∈ s ^ n ↔ ∃ f : fin n → s, (list.of_fn (λ i, (f i : α))).prod = a :=
-by rw [←mem_prod_list_of_fn, list.of_fn_const, list.prod_repeat]
+by rw [←mem_prod_list_of_fn, list.of_fn_const, list.prod_replicate]
 
 end set

9003f287

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

327c3c0d

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathbin.Data.Set.Pointwise.Basic
-import Mathbin.Data.List.OfFn
+import Data.Set.Pointwise.Basic
+import Data.List.OfFn
 
 #align_import data.set.pointwise.list_of_fn from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"

327c3c0d

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module data.set.pointwise.list_of_fn
-! leanprover-community/mathlib commit 327c3c0d9232d80e250dc8f65e7835b82b266ea5
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Pointwise.Basic
 import Mathbin.Data.List.OfFn
 
+#align_import data.set.pointwise.list_of_fn from "leanprover-community/mathlib"@"327c3c0d9232d80e250dc8f65e7835b82b266ea5"
+
 /-!
 # Pointwise operations with lists of sets

327c3c0d

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -29,6 +29,7 @@ variable [Monoid α] {s t : Set α} {a : α} {m n : ℕ}
 
 open scoped Pointwise
 
+#print Set.mem_prod_list_ofFn /-
 @[to_additive]
 theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
     a ∈ (List.ofFn s).Prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i => (f i : α)).Prod = a :=
@@ -41,7 +42,9 @@ theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
       exists_prop]
 #align set.mem_prod_list_of_fn Set.mem_prod_list_ofFn
 #align set.mem_sum_list_of_fn Set.mem_sum_list_ofFn
+-/
 
+#print Set.mem_list_prod /-
 @[to_additive]
 theorem mem_list_prod {l : List (Set α)} {a : α} :
     a ∈ l.Prod ↔
@@ -56,13 +59,16 @@ theorem mem_list_prod {l : List (Set α)} {a : α} :
   · rintro ⟨fi, rfl, rfl⟩; exact ⟨fun i => _, rfl⟩
 #align set.mem_list_prod Set.mem_list_prod
 #align set.mem_list_sum Set.mem_list_sum
+-/
 
+#print Set.mem_pow /-
 @[to_additive]
 theorem mem_pow {a : α} {n : ℕ} :
     a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i => (f i : α)).Prod = a := by
   rw [← mem_prod_list_of_fn, List.ofFn_const, List.prod_replicate]
 #align set.mem_pow Set.mem_pow
 #align set.mem_nsmul Set.mem_nsmul
+-/
 
 end Set

327c3c0d

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -45,7 +45,7 @@ theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
 @[to_additive]
 theorem mem_list_prod {l : List (Set α)} {a : α} :
     a ∈ l.Prod ↔
-      ∃ l' : List (Σs : Set α, ↥s),
+      ∃ l' : List (Σ s : Set α, ↥s),
         List.prod (l'.map fun x => (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l :=
   by
   induction' l using List.ofFnRec with n f

327c3c0d

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -27,7 +27,7 @@ variable {F α β γ : Type _}
 
 variable [Monoid α] {s t : Set α} {a : α} {m n : ℕ}
 
-open Pointwise
+open scoped Pointwise
 
 @[to_additive]
 theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :

327c3c0d

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -29,12 +29,6 @@ variable [Monoid α] {s t : Set α} {a : α} {m n : ℕ}
 
 open Pointwise
 
-/- warning: set.mem_prod_list_of_fn -> Set.mem_prod_list_ofFn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {n : Nat} {a : α} {s : (Fin n) -> (Set.{u1} α)}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (List.prod.{u1} (Set.{u1} α) (Set.mul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Set.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (List.ofFn.{u1} (Set.{u1} α) n s))) (Exists.{succ u1} (forall (i : Fin n), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (s i)) (fun (f : forall (i : Fin n), coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (s i)) => Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (List.ofFn.{u1} α n (fun (i : Fin n) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (s i)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (s i)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (s i)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (s i)) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (s i)))))) (f i)))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {n : Nat} {a : α} {s : (Fin n) -> (Set.{u1} α)}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (List.prod.{u1} (Set.{u1} α) (Set.mul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Set.one.{u1} α (Monoid.toOne.{u1} α _inst_1)) (List.ofFn.{u1} (Set.{u1} α) n s))) (Exists.{succ u1} (forall (i : Fin n), Set.Elem.{u1} α (s i)) (fun (f : forall (i : Fin n), Set.Elem.{u1} α (s i)) => Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (List.ofFn.{u1} α n (fun (i : Fin n) => Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (s i)) (f i)))) a))
-Case conversion may be inaccurate. Consider using '#align set.mem_prod_list_of_fn Set.mem_prod_list_ofFnₓ'. -/
 @[to_additive]
 theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
     a ∈ (List.ofFn s).Prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i => (f i : α)).Prod = a :=
@@ -48,9 +42,6 @@ theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
 #align set.mem_prod_list_of_fn Set.mem_prod_list_ofFn
 #align set.mem_sum_list_of_fn Set.mem_sum_list_ofFn
 
-/- warning: set.mem_list_prod -> Set.mem_list_prod is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align set.mem_list_prod Set.mem_list_prodₓ'. -/
 @[to_additive]
 theorem mem_list_prod {l : List (Set α)} {a : α} :
     a ∈ l.Prod ↔
@@ -66,12 +57,6 @@ theorem mem_list_prod {l : List (Set α)} {a : α} :
 #align set.mem_list_prod Set.mem_list_prod
 #align set.mem_list_sum Set.mem_list_sum
 
-/- warning: set.mem_pow -> Set.mem_pow is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {s : Set.{u1} α} {a : α} {n : Nat}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (HPow.hPow.{u1, 0, u1} (Set.{u1} α) Nat (Set.{u1} α) (instHPow.{u1, 0} (Set.{u1} α) Nat (Set.NPow.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) s n)) (Exists.{succ u1} ((Fin n) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (fun (f : (Fin n) -> (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) => Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (List.ofFn.{u1} α n (fun (i : Fin n) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) α (coeSubtype.{succ u1} α (fun (x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s))))) (f i)))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {s : Set.{u1} α} {a : α} {n : Nat}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (HPow.hPow.{u1, 0, u1} (Set.{u1} α) Nat (Set.{u1} α) (instHPow.{u1, 0} (Set.{u1} α) Nat (Set.NPow.{u1} α (Monoid.toOne.{u1} α _inst_1) (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)))) s n)) (Exists.{succ u1} ((Fin n) -> (Set.Elem.{u1} α s)) (fun (f : (Fin n) -> (Set.Elem.{u1} α s)) => Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (List.ofFn.{u1} α n (fun (i : Fin n) => Subtype.val.{succ u1} α (fun (x : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) (f i)))) a))
-Case conversion may be inaccurate. Consider using '#align set.mem_pow Set.mem_powₓ'. -/
 @[to_additive]
 theorem mem_pow {a : α} {n : ℕ} :
     a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i => (f i : α)).Prod = a := by

327c3c0d

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -61,10 +61,8 @@ theorem mem_list_prod {l : List (Set α)} {a : α} :
   simp_rw [List.exists_iff_exists_tuple, List.map_ofFn, List.ofFn_inj', and_left_comm,
     exists_and_left, exists_eq_left, heq_iff_eq, Function.comp, mem_prod_list_of_fn]
   constructor
-  · rintro ⟨fi, rfl⟩
-    exact ⟨fun i => ⟨_, fi i⟩, rfl, rfl⟩
-  · rintro ⟨fi, rfl, rfl⟩
-    exact ⟨fun i => _, rfl⟩
+  · rintro ⟨fi, rfl⟩; exact ⟨fun i => ⟨_, fi i⟩, rfl, rfl⟩
+  · rintro ⟨fi, rfl, rfl⟩; exact ⟨fun i => _, rfl⟩
 #align set.mem_list_prod Set.mem_list_prod
 #align set.mem_list_sum Set.mem_list_sum

327c3c0d

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -49,10 +49,7 @@ theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
 #align set.mem_sum_list_of_fn Set.mem_sum_list_ofFn
 
 /- warning: set.mem_list_prod -> Set.mem_list_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {l : List.{u1} (Set.{u1} α)} {a : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (List.prod.{u1} (Set.{u1} α) (Set.mul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Set.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) l)) (Exists.{succ u1} (List.{u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) (fun (l' : List.{u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s))) => And (Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (List.map.{u1, u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) α (fun (x : Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) x)) α (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) x)) α (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) x)) α (coeSubtype.{succ u1} α (fun (x_1 : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x_1 (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) x)))))) (Sigma.snd.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s) x)) l')) a) (Eq.{succ u1} (List.{u1} (Set.{u1} α)) (List.map.{u1, u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) (Set.{u1} α) (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => coeSort.{succ u1, succ (succ u1)} (Set.{u1} α) Type.{u1} (Set.hasCoeToSort.{u1} α) s)) l') l)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Monoid.{u1} α] {l : List.{u1} (Set.{u1} α)} {a : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (List.prod.{u1} (Set.{u1} α) (Set.mul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1))) (Set.one.{u1} α (Monoid.toOne.{u1} α _inst_1)) l)) (Exists.{succ u1} (List.{u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s))) (fun (l' : List.{u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s))) => And (Eq.{succ u1} α (List.prod.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α _inst_1)) (Monoid.toOne.{u1} α _inst_1) (List.map.{u1, u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s)) α (fun (x : Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s)) => Subtype.val.{succ u1} α (fun (x_1 : α) => Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x_1 (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s) x)) (Sigma.snd.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s) x)) l')) a) (Eq.{succ u1} (List.{u1} (Set.{u1} α)) (List.map.{u1, u1} (Sigma.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s)) (Set.{u1} α) (Sigma.fst.{u1, u1} (Set.{u1} α) (fun (s : Set.{u1} α) => Set.Elem.{u1} α s)) l') l)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align set.mem_list_prod Set.mem_list_prodₓ'. -/
 @[to_additive]
 theorem mem_list_prod {l : List (Set α)} {a : α} :

327c3c0d

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

f694c7de

chore(Data/List): Do not depend on algebra (#11845)

Remove dependencies on algebra in the Data.List folder except for:

Data.List.EditDistance: Actually relies on algebra. Maybe should be moved?
Data.List.Card: Completely unused and redundant.
Data.List.Cycle: Relies on Fintype, which shouldn't rely on algebra but it's hard to fix right now. Maybe should be moved?
Data.List.Func: Completely unused and redundant.
Data.List.Lex: That's order theory. Could be moved.
Data.List.Prime. That's algebra. Should definitely be moved.
Data.List.Sym: Relies on Multiset, which shouldn't rely on algebra but it's hard to fix right now. Maybe should be moved?
Data.List.ToFinsupp: That's algebra. Should definitely be moved.

As a consequence, move the big operators lemmas that were in there to Algebra.BigOperators.List.Basic. For the lemmas that were Nat-specific and not about auxiliary definitions, keep a version of them in the original file but stated using Nat.sum.

Before pre_11845

After post_11845

f9e043cb

Diff

@@ -3,8 +3,9 @@ Copyright (c) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathlib.Data.Set.Pointwise.Basic
+import Mathlib.Algebra.BigOperators.List.Basic
 import Mathlib.Data.List.OfFn
+import Mathlib.Data.Set.Pointwise.Basic
 
 #align_import data.set.pointwise.list_of_fn from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"

f694c7de

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -17,7 +17,6 @@ This file proves some lemmas about pointwise algebraic operations with lists of
 namespace Set
 
 variable {F α β γ : Type*}
-
 variable [Monoid α] {s t : Set α} {a : α} {m n : ℕ}
 
 open Pointwise

f694c7de

refactor(*): change definition of Set.image2 etc (#9275)

Redefine Set.image2 to use ∃ a ∈ s, ∃ b ∈ t, f a b = c instead of ∃ a b, a ∈ s ∧ b ∈ t ∧ f a b = c.
Redefine Set.seq as Set.image2. The new definition is equal to the old one but rw [Set.seq] gives a different result.
Redefine Filter.map₂ to use ∃ u ∈ f, ∃ v ∈ g, image2 m u v ⊆ s instead of ∃ u v, u ∈ f ∧ v ∈ g ∧ ...
Update lemmas like Set.mem_image2, Finset.mem_image₂, Set.mem_mul, Finset.mem_div etc

The two reasons to make the change are:

∃ a ∈ s, ∃ b ∈ t, _ is a simp-normal form, and
it looks a bit nicer.

8f17470f

Diff

@@ -28,7 +28,7 @@ theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
   induction' n with n ih generalizing a
   · simp_rw [List.ofFn_zero, List.prod_nil, Fin.exists_fin_zero_pi, eq_comm, Set.mem_one]
   · simp_rw [List.ofFn_succ, List.prod_cons, Fin.exists_fin_succ_pi, Fin.cons_zero, Fin.cons_succ,
-      mem_mul, @ih, exists_and_left, exists_exists_eq_and, SetCoe.exists, exists_prop]
+      mem_mul, @ih, exists_exists_eq_and, SetCoe.exists, exists_prop]
 #align set.mem_prod_list_of_fn Set.mem_prod_list_ofFn
 #align set.mem_sum_list_of_fn Set.mem_sum_list_ofFn

f694c7de

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

@@ -16,7 +16,7 @@ This file proves some lemmas about pointwise algebraic operations with lists of
 
 namespace Set
 
-variable {F α β γ : Type _}
+variable {F α β γ : Type*}
 
 variable [Monoid α] {s t : Set α} {a : α} {m n : ℕ}

f694c7de

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,15 +2,12 @@
 Copyright (c) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module data.set.pointwise.list_of_fn
-! leanprover-community/mathlib commit f694c7dead66f5d4c80f446c796a5aad14707f0e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Pointwise.Basic
 import Mathlib.Data.List.OfFn
 
+#align_import data.set.pointwise.list_of_fn from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
+
 /-!
 # Pointwise operations with lists of sets

f694c7de

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -27,8 +27,7 @@ open Pointwise
 
 @[to_additive]
 theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
-    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i ↦ (f i : α)).prod = a :=
-  by
+    a ∈ (List.ofFn s).prod ↔ ∃ f : ∀ i : Fin n, s i, (List.ofFn fun i ↦ (f i : α)).prod = a := by
   induction' n with n ih generalizing a
   · simp_rw [List.ofFn_zero, List.prod_nil, Fin.exists_fin_zero_pi, eq_comm, Set.mem_one]
   · simp_rw [List.ofFn_succ, List.prod_cons, Fin.exists_fin_succ_pi, Fin.cons_zero, Fin.cons_succ,
@@ -40,8 +39,7 @@ theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
 theorem mem_list_prod {l : List (Set α)} {a : α} :
     a ∈ l.prod ↔
       ∃ l' : List (Σs : Set α, ↥s),
-        List.prod (l'.map fun x ↦ (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l :=
-  by
+        List.prod (l'.map fun x ↦ (Sigma.snd x : α)) = a ∧ l'.map Sigma.fst = l := by
   induction' l using List.ofFnRec with n f
   simp only [mem_prod_list_ofFn, List.exists_iff_exists_tuple, List.map_ofFn, Function.comp,
     List.ofFn_inj', Sigma.mk.inj_iff, and_left_comm, exists_and_left, exists_eq_left, heq_eq_eq]

f694c7de

feat: implement intermediate state for simp_rw (#3738)

closes #3680, see https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Stepping.20through.20simp_rw/near/326712986

ff334843

Diff

@@ -31,10 +31,8 @@ theorem mem_prod_list_ofFn {a : α} {s : Fin n → Set α} :
   by
   induction' n with n ih generalizing a
   · simp_rw [List.ofFn_zero, List.prod_nil, Fin.exists_fin_zero_pi, eq_comm, Set.mem_one]
-  ·
-    simp_rw [List.ofFn_succ, List.prod_cons, Fin.exists_fin_succ_pi, Fin.cons_zero, Fin.cons_succ,
-      mem_mul, @ih, exists_and_left, exists_exists_eq_and, SetCoe.exists, Subtype.coe_mk,
-      exists_prop]
+  · simp_rw [List.ofFn_succ, List.prod_cons, Fin.exists_fin_succ_pi, Fin.cons_zero, Fin.cons_succ,
+      mem_mul, @ih, exists_and_left, exists_exists_eq_and, SetCoe.exists, exists_prop]
 #align set.mem_prod_list_of_fn Set.mem_prod_list_ofFn
 #align set.mem_sum_list_of_fn Set.mem_sum_list_ofFn

f694c7de

chore: update SHA sums (#2133)

Part of the List.repeat -> List.replicate refactor. On Mathlib 4 side, I removed mentions of List.repeat in #1475 and #1579

060d1a48

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 
 ! This file was ported from Lean 3 source module data.set.pointwise.list_of_fn
-! leanprover-community/mathlib commit 9003f28797c0664a49e4179487267c494477d853
+! leanprover-community/mathlib commit f694c7dead66f5d4c80f446c796a5aad14707f0e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

9003f287

fix: misaligned to_additive in Data/Set/Pointwise/ListOfFn (#1946)

A misaligned to_additive causes some proofs to fail in #1911. No backport needed, the misalign happened due to a mathlib4 exclusive mistake as I understand.

b1096710

Diff

@@ -55,10 +55,11 @@ theorem mem_list_prod {l : List (Set α)} {a : α} :
 #align set.mem_list_prod Set.mem_list_prod
 #align set.mem_list_sum Set.mem_list_sum
 
-@[to_additive mem_mul]
+@[to_additive]
 theorem mem_pow {a : α} {n : ℕ} :
     a ∈ s ^ n ↔ ∃ f : Fin n → s, (List.ofFn fun i ↦ (f i : α)).prod = a := by
   rw [← mem_prod_list_ofFn, List.ofFn_const, List.prod_replicate]
 #align set.mem_pow Set.mem_pow
+#align set.mem_nsmul Set.mem_nsmul
 
 end Set

9003f287

feat: port Data.Set.Pointwise.ListOfFn (#1634)

0387edcc

`data.set.pointwise.list_of_fn` ⟷ `Mathlib.Data.Set.Pointwise.ListOfFn`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 135

data.set.pointwise.list_of_fn ⟷ Mathlib.Data.Set.Pointwise.ListOfFn

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 135

`data.set.pointwise.list_of_fn` ⟷ `Mathlib.Data.Set.Pointwise.ListOfFn`