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

f7fc89d5

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

68d1483e

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
 -/
-import Data.Set.Pointwise.Smul
-import Algebra.Support
+import Data.Set.Pointwise.SMul
+import Algebra.Function.Support
 
 #align_import data.set.pointwise.support from "leanprover-community/mathlib"@"68d1483e8a718ec63219f0e227ca3f0140361086"

68d1483e

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 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
 -/
-import Mathbin.Data.Set.Pointwise.Smul
-import Mathbin.Algebra.Support
+import Data.Set.Pointwise.Smul
+import Algebra.Support
 
 #align_import data.set.pointwise.support from "leanprover-community/mathlib"@"68d1483e8a718ec63219f0e227ca3f0140361086"

68d1483e

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 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
-
-! This file was ported from Lean 3 source module data.set.pointwise.support
-! leanprover-community/mathlib commit 68d1483e8a718ec63219f0e227ca3f0140361086
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Pointwise.Smul
 import Mathbin.Algebra.Support
 
+#align_import data.set.pointwise.support from "leanprover-community/mathlib"@"68d1483e8a718ec63219f0e227ca3f0140361086"
+
 /-!
 # Support of a function composed with a scalar action

68d1483e

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -29,15 +29,19 @@ section Group
 
 variable {α β γ : Type _} [Group α] [MulAction α β]
 
+#print mulSupport_comp_inv_smul /-
 theorem mulSupport_comp_inv_smul [One γ] (c : α) (f : β → γ) :
     (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem, mem_mul_support]
 #align mul_support_comp_inv_smul mulSupport_comp_inv_smul
+-/
 
+#print support_comp_inv_smul /-
 theorem support_comp_inv_smul [Zero γ] (c : α) (f : β → γ) :
     (support fun x => f (c⁻¹ • x)) = c • support f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem, mem_support]
 #align support_comp_inv_smul support_comp_inv_smul
+-/
 
 attribute [to_additive support_comp_inv_smul] mulSupport_comp_inv_smul
 
@@ -47,15 +51,19 @@ section GroupWithZero
 
 variable {α β γ : Type _} [GroupWithZero α] [MulAction α β]
 
+#print mulSupport_comp_inv_smul₀ /-
 theorem mulSupport_comp_inv_smul₀ [One γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
     (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_mul_support]
 #align mul_support_comp_inv_smul₀ mulSupport_comp_inv_smul₀
+-/
 
+#print support_comp_inv_smul₀ /-
 theorem support_comp_inv_smul₀ [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
     (support fun x => f (c⁻¹ • x)) = c • support f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_support]
 #align support_comp_inv_smul₀ support_comp_inv_smul₀
+-/
 
 attribute [to_additive support_comp_inv_smul₀] mulSupport_comp_inv_smul₀

68d1483e

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -21,7 +21,7 @@ We show that the support of `x ↦ f (c⁻¹ • x)` is equal to `c • support
 -/
 
 
-open Pointwise
+open scoped Pointwise
 
 open Function Set

68d1483e

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -29,23 +29,11 @@ section Group
 
 variable {α β γ : Type _} [Group α] [MulAction α β]
 
-/- warning: mul_support_comp_inv_smul -> mulSupport_comp_inv_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : One.{u3} γ] (c : α) (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.mulSupport.{u2, u3} β γ _inst_3 (fun (x : β) => f (SMul.smul.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) c) x))) (SMul.smul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) c (Function.mulSupport.{u2, u3} β γ _inst_3 f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : One.{u3} γ] (c : α) (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.mulSupport.{u2, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) c) x))) (HSMul.hSMul.{u1, u2, u2} α (Set.{u2} β) (Set.{u2} β) (instHSMul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2))) c (Function.mulSupport.{u2, u3} β γ _inst_3 f))
-Case conversion may be inaccurate. Consider using '#align mul_support_comp_inv_smul mulSupport_comp_inv_smulₓ'. -/
 theorem mulSupport_comp_inv_smul [One γ] (c : α) (f : β → γ) :
     (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem, mem_mul_support]
 #align mul_support_comp_inv_smul mulSupport_comp_inv_smul
 
-/- warning: support_comp_inv_smul -> support_comp_inv_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : Zero.{u3} γ] (c : α) (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.support.{u2, u3} β γ _inst_3 (fun (x : β) => f (SMul.smul.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) c) x))) (SMul.smul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) c (Function.support.{u2, u3} β γ _inst_3 f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : Zero.{u3} γ] (c : α) (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.support.{u2, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) c) x))) (HSMul.hSMul.{u1, u2, u2} α (Set.{u2} β) (Set.{u2} β) (instHSMul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2))) c (Function.support.{u2, u3} β γ _inst_3 f))
-Case conversion may be inaccurate. Consider using '#align support_comp_inv_smul support_comp_inv_smulₓ'. -/
 theorem support_comp_inv_smul [Zero γ] (c : α) (f : β → γ) :
     (support fun x => f (c⁻¹ • x)) = c • support f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem, mem_support]
@@ -59,23 +47,11 @@ section GroupWithZero
 
 variable {α β γ : Type _} [GroupWithZero α] [MulAction α β]
 
-/- warning: mul_support_comp_inv_smul₀ -> mulSupport_comp_inv_smul₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : GroupWithZero.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))] [_inst_3 : One.{u3} γ] {c : α}, (Ne.{succ u1} α c (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) -> (forall (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.mulSupport.{u2, u3} β γ _inst_3 (fun (x : β) => f (SMul.smul.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)) _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)) c) x))) (SMul.smul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)) _inst_2)) c (Function.mulSupport.{u2, u3} β γ _inst_3 f)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u3}} [_inst_1 : GroupWithZero.{u2} α] [_inst_2 : MulAction.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))] [_inst_3 : One.{u3} γ] {c : α}, (Ne.{succ u2} α c (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))))) -> (forall (f : β -> γ), Eq.{succ u1} (Set.{u1} β) (Function.mulSupport.{u1, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u2, u1, u1} α β β (instHSMul.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2)) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_1) c) x))) (HSMul.hSMul.{u2, u1, u1} α (Set.{u1} β) (Set.{u1} β) (instHSMul.{u2, u1} α (Set.{u1} β) (Set.smulSet.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2))) c (Function.mulSupport.{u1, u3} β γ _inst_3 f)))
-Case conversion may be inaccurate. Consider using '#align mul_support_comp_inv_smul₀ mulSupport_comp_inv_smul₀ₓ'. -/
 theorem mulSupport_comp_inv_smul₀ [One γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
     (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_mul_support]
 #align mul_support_comp_inv_smul₀ mulSupport_comp_inv_smul₀
 
-/- warning: support_comp_inv_smul₀ -> support_comp_inv_smul₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : GroupWithZero.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1))] [_inst_3 : Zero.{u3} γ] {c : α}, (Ne.{succ u1} α c (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)))))))) -> (forall (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.support.{u2, u3} β γ _inst_3 (fun (x : β) => f (SMul.smul.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)) _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_1)) c) x))) (SMul.smul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toHasSmul.{u1, u2} α β (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_1)) _inst_2)) c (Function.support.{u2, u3} β γ _inst_3 f)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u3}} [_inst_1 : GroupWithZero.{u2} α] [_inst_2 : MulAction.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))] [_inst_3 : Zero.{u3} γ] {c : α}, (Ne.{succ u2} α c (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))))) -> (forall (f : β -> γ), Eq.{succ u1} (Set.{u1} β) (Function.support.{u1, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u2, u1, u1} α β β (instHSMul.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2)) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_1) c) x))) (HSMul.hSMul.{u2, u1, u1} α (Set.{u1} β) (Set.{u1} β) (instHSMul.{u2, u1} α (Set.{u1} β) (Set.smulSet.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2))) c (Function.support.{u1, u3} β γ _inst_3 f)))
-Case conversion may be inaccurate. Consider using '#align support_comp_inv_smul₀ support_comp_inv_smul₀ₓ'. -/
 theorem support_comp_inv_smul₀ [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
     (support fun x => f (c⁻¹ • x)) = c • support f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_support]

68d1483e

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -36,9 +36,7 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : One.{u3} γ] (c : α) (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.mulSupport.{u2, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) c) x))) (HSMul.hSMul.{u1, u2, u2} α (Set.{u2} β) (Set.{u2} β) (instHSMul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2))) c (Function.mulSupport.{u2, u3} β γ _inst_3 f))
 Case conversion may be inaccurate. Consider using '#align mul_support_comp_inv_smul mulSupport_comp_inv_smulₓ'. -/
 theorem mulSupport_comp_inv_smul [One γ] (c : α) (f : β → γ) :
-    (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f :=
-  by
-  ext x
+    (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem, mem_mul_support]
 #align mul_support_comp_inv_smul mulSupport_comp_inv_smul
 
@@ -49,9 +47,7 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Group.{u1} α] [_inst_2 : MulAction.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))] [_inst_3 : Zero.{u3} γ] (c : α) (f : β -> γ), Eq.{succ u2} (Set.{u2} β) (Function.support.{u2, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u1, u2, u2} α β β (instHSMul.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2)) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) c) x))) (HSMul.hSMul.{u1, u2, u2} α (Set.{u2} β) (Set.{u2} β) (instHSMul.{u1, u2} α (Set.{u2} β) (Set.smulSet.{u1, u2} α β (MulAction.toSMul.{u1, u2} α β (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) _inst_2))) c (Function.support.{u2, u3} β γ _inst_3 f))
 Case conversion may be inaccurate. Consider using '#align support_comp_inv_smul support_comp_inv_smulₓ'. -/
 theorem support_comp_inv_smul [Zero γ] (c : α) (f : β → γ) :
-    (support fun x => f (c⁻¹ • x)) = c • support f :=
-  by
-  ext x
+    (support fun x => f (c⁻¹ • x)) = c • support f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem, mem_support]
 #align support_comp_inv_smul support_comp_inv_smul
 
@@ -70,9 +66,7 @@ but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u3}} [_inst_1 : GroupWithZero.{u2} α] [_inst_2 : MulAction.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))] [_inst_3 : One.{u3} γ] {c : α}, (Ne.{succ u2} α c (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))))) -> (forall (f : β -> γ), Eq.{succ u1} (Set.{u1} β) (Function.mulSupport.{u1, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u2, u1, u1} α β β (instHSMul.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2)) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_1) c) x))) (HSMul.hSMul.{u2, u1, u1} α (Set.{u1} β) (Set.{u1} β) (instHSMul.{u2, u1} α (Set.{u1} β) (Set.smulSet.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2))) c (Function.mulSupport.{u1, u3} β γ _inst_3 f)))
 Case conversion may be inaccurate. Consider using '#align mul_support_comp_inv_smul₀ mulSupport_comp_inv_smul₀ₓ'. -/
 theorem mulSupport_comp_inv_smul₀ [One γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
-    (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f :=
-  by
-  ext x
+    (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_mul_support]
 #align mul_support_comp_inv_smul₀ mulSupport_comp_inv_smul₀
 
@@ -83,9 +77,7 @@ but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u3}} [_inst_1 : GroupWithZero.{u2} α] [_inst_2 : MulAction.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))] [_inst_3 : Zero.{u3} γ] {c : α}, (Ne.{succ u2} α c (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1))))) -> (forall (f : β -> γ), Eq.{succ u1} (Set.{u1} β) (Function.support.{u1, u3} β γ _inst_3 (fun (x : β) => f (HSMul.hSMul.{u2, u1, u1} α β β (instHSMul.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2)) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_1) c) x))) (HSMul.hSMul.{u2, u1, u1} α (Set.{u1} β) (Set.{u1} β) (instHSMul.{u2, u1} α (Set.{u1} β) (Set.smulSet.{u2, u1} α β (MulAction.toSMul.{u2, u1} α β (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_1)) _inst_2))) c (Function.support.{u1, u3} β γ _inst_3 f)))
 Case conversion may be inaccurate. Consider using '#align support_comp_inv_smul₀ support_comp_inv_smul₀ₓ'. -/
 theorem support_comp_inv_smul₀ [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
-    (support fun x => f (c⁻¹ • x)) = c • support f :=
-  by
-  ext x
+    (support fun x => f (c⁻¹ • x)) = c • support f := by ext x;
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_support]
 #align support_comp_inv_smul₀ support_comp_inv_smul₀

68d1483e

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

f7fc89d5

chore: Sink Algebra.Support down the import tree (#8919)

Function.support is a very basic definition. Nevertheless, it is a pretty heavy import because it imports most objects a support lemma can be written about.

This PR reverses the dependencies between those objects and Function.support, so that the latter can become a much more lightweight import.

Only two import could not easily be reversed, namely the ones to Data.Set.Finite and Order.ConditionallyCompleteLattice.Basic, so I created two new files instead.

I credit:

Yury for https://github.com/leanprover-community/mathlib/pull/6791
Oliver for https://github.com/leanprover-community/mathlib/pull/7439

82ddb54f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
 -/
+import Mathlib.Algebra.Function.Support
 import Mathlib.Data.Set.Pointwise.SMul
-import Mathlib.Algebra.Support
 
 #align_import data.set.pointwise.support from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"

f7fc89d5

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

@@ -21,7 +21,7 @@ open Function Set
 
 section Group
 
-variable {α β γ : Type _} [Group α] [MulAction α β]
+variable {α β γ : Type*} [Group α] [MulAction α β]
 
 theorem mulSupport_comp_inv_smul [One γ] (c : α) (f : β → γ) :
     (mulSupport fun x ↦ f (c⁻¹ • x)) = c • mulSupport f := by
@@ -43,7 +43,7 @@ end Group
 
 section GroupWithZero
 
-variable {α β γ : Type _} [GroupWithZero α] [MulAction α β]
+variable {α β γ : Type*} [GroupWithZero α] [MulAction α β]
 
 theorem mulSupport_comp_inv_smul₀ [One γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
     (mulSupport fun x ↦ f (c⁻¹ • x)) = c • mulSupport f := by

f7fc89d5

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 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
-
-! This file was ported from Lean 3 source module data.set.pointwise.support
-! leanprover-community/mathlib commit f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Pointwise.SMul
 import Mathlib.Algebra.Support
 
+#align_import data.set.pointwise.support from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
+
 /-!
 # Support of a function composed with a scalar action

f7fc89d5

feat: add to_additive linter checking whether additive decl exists (#1881)

Force the user to specify whether the additive declaration already exists.
Will raise a linter error if the user specified it wrongly
Requested on Zulip

77e63150

Diff

@@ -32,13 +32,15 @@ theorem mulSupport_comp_inv_smul [One γ] (c : α) (f : β → γ) :
   simp only [mem_smul_set_iff_inv_smul_mem, mem_mulSupport]
 #align mul_support_comp_inv_smul mulSupport_comp_inv_smul
 
+/- Note: to_additive also automatically translates `SMul` to `VAdd`, so we give the additive version
+manually. -/
 theorem support_comp_inv_smul [Zero γ] (c : α) (f : β → γ) :
     (support fun x ↦ f (c⁻¹ • x)) = c • support f := by
   ext x
   simp only [mem_smul_set_iff_inv_smul_mem, mem_support]
 #align support_comp_inv_smul support_comp_inv_smul
 
-attribute [to_additive support_comp_inv_smul] mulSupport_comp_inv_smul
+attribute [to_additive existing support_comp_inv_smul] mulSupport_comp_inv_smul
 
 end Group
 
@@ -52,12 +54,14 @@ theorem mulSupport_comp_inv_smul₀ [One γ] {c : α} (hc : c ≠ 0) (f : β →
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_mulSupport]
 #align mul_support_comp_inv_smul₀ mulSupport_comp_inv_smul₀
 
+/- Note: to_additive also automatically translates `SMul` to `VAdd`, so we give the additive version
+manually. -/
 theorem support_comp_inv_smul₀ [Zero γ] {c : α} (hc : c ≠ 0) (f : β → γ) :
     (support fun x ↦ f (c⁻¹ • x)) = c • support f := by
   ext x
   simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_support]
 #align support_comp_inv_smul₀ support_comp_inv_smul₀
 
-attribute [to_additive support_comp_inv_smul₀] mulSupport_comp_inv_smul₀
+attribute [to_additive existing support_comp_inv_smul₀] mulSupport_comp_inv_smul₀
 
 end GroupWithZero

f7fc89d5

feat: port Data.Set.Pointwise.Support (#1915)

96c597b8

`data.set.pointwise.support` ⟷ `Mathlib.Data.Set.Pointwise.Support`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 7 + 238

data.set.pointwise.support ⟷ Mathlib.Data.Set.Pointwise.Support

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 7 + 238

`data.set.pointwise.support` ⟷ `Mathlib.Data.Set.Pointwise.Support`