logic.function.conjugate | 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

c4658a64

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2024-02-23-08

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

ac9421d6

Diff

@@ -190,16 +190,16 @@ theorem comp {f' : β → γ} {gc : γ → γ → γ} (hf' : Semiconj₂ f' gb g
 -/
 
 #print Function.Semiconj₂.isAssociative_right /-
-theorem isAssociative_right [IsAssociative α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
-    IsAssociative β gb :=
-  ⟨h_surj.forall₃.2 fun x₁ x₂ x₃ => by simp only [← h.eq, @IsAssociative.assoc _ ga]⟩
+theorem isAssociative_right [Std.Associative α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
+    Std.Associative β gb :=
+  ⟨h_surj.forall₃.2 fun x₁ x₂ x₃ => by simp only [← h.eq, @Std.Associative.assoc _ ga]⟩
 #align function.semiconj₂.is_associative_right Function.Semiconj₂.isAssociative_right
 -/
 
 #print Function.Semiconj₂.isAssociative_left /-
-theorem isAssociative_left [IsAssociative β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
-    IsAssociative α ga :=
-  ⟨fun x₁ x₂ x₃ => h_inj <| by simp only [h.eq, @IsAssociative.assoc _ gb]⟩
+theorem isAssociative_left [Std.Associative β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
+    Std.Associative α ga :=
+  ⟨fun x₁ x₂ x₃ => h_inj <| by simp only [h.eq, @Std.Associative.assoc _ gb]⟩
 #align function.semiconj₂.is_associative_left Function.Semiconj₂.isAssociative_left
 -/

448144f7

bump to nightly-2024-02-05-08

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

516c6ec2

Diff

@@ -204,16 +204,16 @@ theorem isAssociative_left [IsAssociative β gb] (h : Semiconj₂ f ga gb) (h_in
 -/
 
 #print Function.Semiconj₂.isIdempotent_right /-
-theorem isIdempotent_right [IsIdempotent α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
-    IsIdempotent β gb :=
-  ⟨h_surj.forall.2 fun x => by simp only [← h.eq, @IsIdempotent.idempotent _ ga]⟩
+theorem isIdempotent_right [Std.IdempotentOp α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
+    Std.IdempotentOp β gb :=
+  ⟨h_surj.forall.2 fun x => by simp only [← h.eq, @Std.IdempotentOp.idempotent _ ga]⟩
 #align function.semiconj₂.is_idempotent_right Function.Semiconj₂.isIdempotent_right
 -/
 
 #print Function.Semiconj₂.isIdempotent_left /-
-theorem isIdempotent_left [IsIdempotent β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
-    IsIdempotent α ga :=
-  ⟨fun x => h_inj <| by rw [h.eq, @IsIdempotent.idempotent _ gb]⟩
+theorem isIdempotent_left [Std.IdempotentOp β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
+    Std.IdempotentOp α ga :=
+  ⟨fun x => h_inj <| by rw [h.eq, @Std.IdempotentOp.idempotent _ gb]⟩
 #align function.semiconj₂.is_idempotent_left Function.Semiconj₂.isIdempotent_left
 -/

448144f7

bump to nightly-2024-01-18-06

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

d4b8c2fa

Diff

@@ -58,10 +58,10 @@ theorem comp_right (h : Semiconj f ga gb) (h' : Semiconj f ga' gb') :
 #align function.semiconj.comp_right Function.Semiconj.comp_right
 -/
 
-#print Function.Semiconj.comp_left /-
-theorem comp_left (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) :
-    Semiconj (fbc ∘ fab) ga gc := fun x => by simp only [comp_app, hab.eq, hbc.eq]
-#align function.semiconj.comp_left Function.Semiconj.comp_left
+#print Function.Semiconj.trans /-
+theorem trans (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) : Semiconj (fbc ∘ fab) ga gc :=
+  fun x => by simp only [comp_app, hab.eq, hbc.eq]
+#align function.semiconj.comp_left Function.Semiconj.trans
 -/
 
 #print Function.Semiconj.id_right /-

448144f7

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) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathbin.Logic.Function.Basic
+import Logic.Function.Basic
 
 #align_import logic.function.conjugate from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

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) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module logic.function.conjugate
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Logic.Function.Basic
 
+#align_import logic.function.conjugate from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Semiconjugate and commuting maps

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -43,39 +43,53 @@ namespace Semiconj
 
 variable {f fab : α → β} {fbc : β → γ} {ga ga' : α → α} {gb gb' : β → β} {gc gc' : γ → γ}
 
+#print Function.Semiconj.comp_eq /-
 protected theorem comp_eq (h : Semiconj f ga gb) : f ∘ ga = gb ∘ f :=
   funext h
 #align function.semiconj.comp_eq Function.Semiconj.comp_eq
+-/
 
+#print Function.Semiconj.eq /-
 protected theorem eq (h : Semiconj f ga gb) (x : α) : f (ga x) = gb (f x) :=
   h x
 #align function.semiconj.eq Function.Semiconj.eq
+-/
 
+#print Function.Semiconj.comp_right /-
 theorem comp_right (h : Semiconj f ga gb) (h' : Semiconj f ga' gb') :
     Semiconj f (ga ∘ ga') (gb ∘ gb') := fun x => by rw [comp_app, h.eq, h'.eq]
 #align function.semiconj.comp_right Function.Semiconj.comp_right
+-/
 
+#print Function.Semiconj.comp_left /-
 theorem comp_left (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) :
     Semiconj (fbc ∘ fab) ga gc := fun x => by simp only [comp_app, hab.eq, hbc.eq]
 #align function.semiconj.comp_left Function.Semiconj.comp_left
+-/
 
+#print Function.Semiconj.id_right /-
 theorem id_right : Semiconj f id id := fun _ => rfl
 #align function.semiconj.id_right Function.Semiconj.id_right
+-/
 
 #print Function.Semiconj.id_left /-
 theorem id_left : Semiconj id ga ga := fun _ => rfl
 #align function.semiconj.id_left Function.Semiconj.id_left
 -/
 
+#print Function.Semiconj.inverses_right /-
 theorem inverses_right (h : Semiconj f ga gb) (ha : RightInverse ga' ga) (hb : LeftInverse gb' gb) :
     Semiconj f ga' gb' := fun x => by rw [← hb (f (ga' x)), ← h.eq, ha x]
 #align function.semiconj.inverses_right Function.Semiconj.inverses_right
+-/
 
+#print Function.Semiconj.option_map /-
 theorem option_map {f : α → β} {ga : α → α} {gb : β → β} (h : Semiconj f ga gb) :
     Semiconj (Option.map f) (Option.map ga) (Option.map gb)
   | none => rfl
   | some a => congr_arg some <| h _
 #align function.semiconj.option_map Function.Semiconj.option_map
+-/
 
 end Semiconj
 
@@ -155,27 +169,35 @@ namespace Semiconj₂
 
 variable {f : α → β} {ga : α → α → α} {gb : β → β → β}
 
+#print Function.Semiconj₂.eq /-
 protected theorem eq (h : Semiconj₂ f ga gb) (x y : α) : f (ga x y) = gb (f x) (f y) :=
   h x y
 #align function.semiconj₂.eq Function.Semiconj₂.eq
+-/
 
+#print Function.Semiconj₂.comp_eq /-
 protected theorem comp_eq (h : Semiconj₂ f ga gb) : bicompr f ga = bicompl gb f f :=
   funext fun x => funext <| h x
 #align function.semiconj₂.comp_eq Function.Semiconj₂.comp_eq
+-/
 
 #print Function.Semiconj₂.id_left /-
 theorem id_left (op : α → α → α) : Semiconj₂ id op op := fun _ _ => rfl
 #align function.semiconj₂.id_left Function.Semiconj₂.id_left
 -/
 
+#print Function.Semiconj₂.comp /-
 theorem comp {f' : β → γ} {gc : γ → γ → γ} (hf' : Semiconj₂ f' gb gc) (hf : Semiconj₂ f ga gb) :
     Semiconj₂ (f' ∘ f) ga gc := fun x y => by simp only [hf'.eq, hf.eq, comp_app]
 #align function.semiconj₂.comp Function.Semiconj₂.comp
+-/
 
+#print Function.Semiconj₂.isAssociative_right /-
 theorem isAssociative_right [IsAssociative α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
     IsAssociative β gb :=
   ⟨h_surj.forall₃.2 fun x₁ x₂ x₃ => by simp only [← h.eq, @IsAssociative.assoc _ ga]⟩
 #align function.semiconj₂.is_associative_right Function.Semiconj₂.isAssociative_right
+-/
 
 #print Function.Semiconj₂.isAssociative_left /-
 theorem isAssociative_left [IsAssociative β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
@@ -184,10 +206,12 @@ theorem isAssociative_left [IsAssociative β gb] (h : Semiconj₂ f ga gb) (h_in
 #align function.semiconj₂.is_associative_left Function.Semiconj₂.isAssociative_left
 -/
 
+#print Function.Semiconj₂.isIdempotent_right /-
 theorem isIdempotent_right [IsIdempotent α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
     IsIdempotent β gb :=
   ⟨h_surj.forall.2 fun x => by simp only [← h.eq, @IsIdempotent.idempotent _ ga]⟩
 #align function.semiconj₂.is_idempotent_right Function.Semiconj₂.isIdempotent_right
+-/
 
 #print Function.Semiconj₂.isIdempotent_left /-
 theorem isIdempotent_left [IsIdempotent β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -43,52 +43,22 @@ namespace Semiconj
 
 variable {f fab : α → β} {fbc : β → γ} {ga ga' : α → α} {gb gb' : β → β} {gc gc' : γ → γ}
 
-/- warning: function.semiconj.comp_eq -> Function.Semiconj.comp_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α} {gb : β -> β}, (Function.Semiconj.{u1, u2} α β f ga gb) -> (Eq.{max (succ u1) (succ u2)} (α -> β) (Function.comp.{succ u1, succ u1, succ u2} α α β f ga) (Function.comp.{succ u1, succ u2, succ u2} α β β gb f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α} {gb : β -> β}, (Function.Semiconj.{u2, u1} α β f ga gb) -> (Eq.{max (succ u2) (succ u1)} (α -> β) (Function.comp.{succ u2, succ u2, succ u1} α α β f ga) (Function.comp.{succ u2, succ u1, succ u1} α β β gb f))
-Case conversion may be inaccurate. Consider using '#align function.semiconj.comp_eq Function.Semiconj.comp_eqₓ'. -/
 protected theorem comp_eq (h : Semiconj f ga gb) : f ∘ ga = gb ∘ f :=
   funext h
 #align function.semiconj.comp_eq Function.Semiconj.comp_eq
 
-/- warning: function.semiconj.eq -> Function.Semiconj.eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α} {gb : β -> β}, (Function.Semiconj.{u1, u2} α β f ga gb) -> (forall (x : α), Eq.{succ u2} β (f (ga x)) (gb (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α} {gb : β -> β}, (Function.Semiconj.{u2, u1} α β f ga gb) -> (forall (x : α), Eq.{succ u1} β (f (ga x)) (gb (f x)))
-Case conversion may be inaccurate. Consider using '#align function.semiconj.eq Function.Semiconj.eqₓ'. -/
 protected theorem eq (h : Semiconj f ga gb) (x : α) : f (ga x) = gb (f x) :=
   h x
 #align function.semiconj.eq Function.Semiconj.eq
 
-/- warning: function.semiconj.comp_right -> Function.Semiconj.comp_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α} {ga' : α -> α} {gb : β -> β} {gb' : β -> β}, (Function.Semiconj.{u1, u2} α β f ga gb) -> (Function.Semiconj.{u1, u2} α β f ga' gb') -> (Function.Semiconj.{u1, u2} α β f (Function.comp.{succ u1, succ u1, succ u1} α α α ga ga') (Function.comp.{succ u2, succ u2, succ u2} β β β gb gb'))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α} {ga' : α -> α} {gb : β -> β} {gb' : β -> β}, (Function.Semiconj.{u2, u1} α β f ga gb) -> (Function.Semiconj.{u2, u1} α β f ga' gb') -> (Function.Semiconj.{u2, u1} α β f (Function.comp.{succ u2, succ u2, succ u2} α α α ga ga') (Function.comp.{succ u1, succ u1, succ u1} β β β gb gb'))
-Case conversion may be inaccurate. Consider using '#align function.semiconj.comp_right Function.Semiconj.comp_rightₓ'. -/
 theorem comp_right (h : Semiconj f ga gb) (h' : Semiconj f ga' gb') :
     Semiconj f (ga ∘ ga') (gb ∘ gb') := fun x => by rw [comp_app, h.eq, h'.eq]
 #align function.semiconj.comp_right Function.Semiconj.comp_right
 
-/- warning: function.semiconj.comp_left -> Function.Semiconj.comp_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {fab : α -> β} {fbc : β -> γ} {ga : α -> α} {gb : β -> β} {gc : γ -> γ}, (Function.Semiconj.{u1, u2} α β fab ga gb) -> (Function.Semiconj.{u2, u3} β γ fbc gb gc) -> (Function.Semiconj.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ fbc fab) ga gc)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {fab : α -> β} {fbc : β -> γ} {ga : α -> α} {gb : β -> β} {gc : γ -> γ}, (Function.Semiconj.{u3, u2} α β fab ga gb) -> (Function.Semiconj.{u2, u1} β γ fbc gb gc) -> (Function.Semiconj.{u3, u1} α γ (Function.comp.{succ u3, succ u2, succ u1} α β γ fbc fab) ga gc)
-Case conversion may be inaccurate. Consider using '#align function.semiconj.comp_left Function.Semiconj.comp_leftₓ'. -/
 theorem comp_left (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) :
     Semiconj (fbc ∘ fab) ga gc := fun x => by simp only [comp_app, hab.eq, hbc.eq]
 #align function.semiconj.comp_left Function.Semiconj.comp_left
 
-/- warning: function.semiconj.id_right -> Function.Semiconj.id_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β}, Function.Semiconj.{u1, u2} α β f (id.{succ u1} α) (id.{succ u2} β)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β}, Function.Semiconj.{u2, u1} α β f (id.{succ u2} α) (id.{succ u1} β)
-Case conversion may be inaccurate. Consider using '#align function.semiconj.id_right Function.Semiconj.id_rightₓ'. -/
 theorem id_right : Semiconj f id id := fun _ => rfl
 #align function.semiconj.id_right Function.Semiconj.id_right
 
@@ -97,22 +67,10 @@ theorem id_left : Semiconj id ga ga := fun _ => rfl
 #align function.semiconj.id_left Function.Semiconj.id_left
 -/
 
-/- warning: function.semiconj.inverses_right -> Function.Semiconj.inverses_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α} {ga' : α -> α} {gb : β -> β} {gb' : β -> β}, (Function.Semiconj.{u1, u2} α β f ga gb) -> (Function.RightInverse.{succ u1, succ u1} α α ga' ga) -> (Function.LeftInverse.{succ u2, succ u2} β β gb' gb) -> (Function.Semiconj.{u1, u2} α β f ga' gb')
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α} {ga' : α -> α} {gb : β -> β} {gb' : β -> β}, (Function.Semiconj.{u2, u1} α β f ga gb) -> (Function.RightInverse.{succ u2, succ u2} α α ga' ga) -> (Function.LeftInverse.{succ u1, succ u1} β β gb' gb) -> (Function.Semiconj.{u2, u1} α β f ga' gb')
-Case conversion may be inaccurate. Consider using '#align function.semiconj.inverses_right Function.Semiconj.inverses_rightₓ'. -/
 theorem inverses_right (h : Semiconj f ga gb) (ha : RightInverse ga' ga) (hb : LeftInverse gb' gb) :
     Semiconj f ga' gb' := fun x => by rw [← hb (f (ga' x)), ← h.eq, ha x]
 #align function.semiconj.inverses_right Function.Semiconj.inverses_right
 
-/- warning: function.semiconj.option_map -> Function.Semiconj.option_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α} {gb : β -> β}, (Function.Semiconj.{u1, u2} α β f ga gb) -> (Function.Semiconj.{u1, u2} (Option.{u1} α) (Option.{u2} β) (Option.map.{u1, u2} α β f) (Option.map.{u1, u1} α α ga) (Option.map.{u2, u2} β β gb))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α} {gb : β -> β}, (Function.Semiconj.{u2, u1} α β f ga gb) -> (Function.Semiconj.{u2, u1} (Option.{u2} α) (Option.{u1} β) (Option.map.{u2, u1} α β f) (Option.map.{u2, u2} α α ga) (Option.map.{u1, u1} β β gb))
-Case conversion may be inaccurate. Consider using '#align function.semiconj.option_map Function.Semiconj.option_mapₓ'. -/
 theorem option_map {f : α → β} {ga : α → α} {gb : β → β} (h : Semiconj f ga gb) :
     Semiconj (Option.map f) (Option.map ga) (Option.map gb)
   | none => rfl
@@ -197,22 +155,10 @@ namespace Semiconj₂
 
 variable {f : α → β} {ga : α → α → α} {gb : β → β → β}
 
-/- warning: function.semiconj₂.eq -> Function.Semiconj₂.eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β}, (Function.Semiconj₂.{u1, u2} α β f ga gb) -> (forall (x : α) (y : α), Eq.{succ u2} β (f (ga x y)) (gb (f x) (f y)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β}, (Function.Semiconj₂.{u2, u1} α β f ga gb) -> (forall (x : α) (y : α), Eq.{succ u1} β (f (ga x y)) (gb (f x) (f y)))
-Case conversion may be inaccurate. Consider using '#align function.semiconj₂.eq Function.Semiconj₂.eqₓ'. -/
 protected theorem eq (h : Semiconj₂ f ga gb) (x y : α) : f (ga x y) = gb (f x) (f y) :=
   h x y
 #align function.semiconj₂.eq Function.Semiconj₂.eq
 
-/- warning: function.semiconj₂.comp_eq -> Function.Semiconj₂.comp_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β}, (Function.Semiconj₂.{u1, u2} α β f ga gb) -> (Eq.{max (succ u1) (succ u2)} (α -> α -> β) (Function.bicompr.{u1, u1, u1, u2} α α α β f ga) (Function.bicompl.{u1, u1, u2, u2, u2} α α β β β gb f f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β}, (Function.Semiconj₂.{u2, u1} α β f ga gb) -> (Eq.{max (succ u2) (succ u1)} (α -> α -> β) (Function.bicompr.{u2, u2, u2, u1} α α α β f ga) (Function.bicompl.{u2, u2, u1, u1, u1} α α β β β gb f f))
-Case conversion may be inaccurate. Consider using '#align function.semiconj₂.comp_eq Function.Semiconj₂.comp_eqₓ'. -/
 protected theorem comp_eq (h : Semiconj₂ f ga gb) : bicompr f ga = bicompl gb f f :=
   funext fun x => funext <| h x
 #align function.semiconj₂.comp_eq Function.Semiconj₂.comp_eq
@@ -222,22 +168,10 @@ theorem id_left (op : α → α → α) : Semiconj₂ id op op := fun _ _ => rfl
 #align function.semiconj₂.id_left Function.Semiconj₂.id_left
 -/
 
-/- warning: function.semiconj₂.comp -> Function.Semiconj₂.comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β} {f' : β -> γ} {gc : γ -> γ -> γ}, (Function.Semiconj₂.{u2, u3} β γ f' gb gc) -> (Function.Semiconj₂.{u1, u2} α β f ga gb) -> (Function.Semiconj₂.{u1, u3} α γ (Function.comp.{succ u1, succ u2, succ u3} α β γ f' f) ga gc)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β} {f' : β -> γ} {gc : γ -> γ -> γ}, (Function.Semiconj₂.{u3, u2} β γ f' gb gc) -> (Function.Semiconj₂.{u1, u3} α β f ga gb) -> (Function.Semiconj₂.{u1, u2} α γ (Function.comp.{succ u1, succ u3, succ u2} α β γ f' f) ga gc)
-Case conversion may be inaccurate. Consider using '#align function.semiconj₂.comp Function.Semiconj₂.compₓ'. -/
 theorem comp {f' : β → γ} {gc : γ → γ → γ} (hf' : Semiconj₂ f' gb gc) (hf : Semiconj₂ f ga gb) :
     Semiconj₂ (f' ∘ f) ga gc := fun x y => by simp only [hf'.eq, hf.eq, comp_app]
 #align function.semiconj₂.comp Function.Semiconj₂.comp
 
-/- warning: function.semiconj₂.is_associative_right -> Function.Semiconj₂.isAssociative_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β} [_inst_1 : IsAssociative.{u1} α ga], (Function.Semiconj₂.{u1, u2} α β f ga gb) -> (Function.Surjective.{succ u1, succ u2} α β f) -> (IsAssociative.{u2} β gb)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β} [_inst_1 : IsAssociative.{u2} α ga], (Function.Semiconj₂.{u2, u1} α β f ga gb) -> (Function.Surjective.{succ u2, succ u1} α β f) -> (IsAssociative.{u1} β gb)
-Case conversion may be inaccurate. Consider using '#align function.semiconj₂.is_associative_right Function.Semiconj₂.isAssociative_rightₓ'. -/
 theorem isAssociative_right [IsAssociative α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
     IsAssociative β gb :=
   ⟨h_surj.forall₃.2 fun x₁ x₂ x₃ => by simp only [← h.eq, @IsAssociative.assoc _ ga]⟩
@@ -250,12 +184,6 @@ theorem isAssociative_left [IsAssociative β gb] (h : Semiconj₂ f ga gb) (h_in
 #align function.semiconj₂.is_associative_left Function.Semiconj₂.isAssociative_left
 -/
 
-/- warning: function.semiconj₂.is_idempotent_right -> Function.Semiconj₂.isIdempotent_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β} [_inst_1 : IsIdempotent.{u1} α ga], (Function.Semiconj₂.{u1, u2} α β f ga gb) -> (Function.Surjective.{succ u1, succ u2} α β f) -> (IsIdempotent.{u2} β gb)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {f : α -> β} {ga : α -> α -> α} {gb : β -> β -> β} [_inst_1 : IsIdempotent.{u2} α ga], (Function.Semiconj₂.{u2, u1} α β f ga gb) -> (Function.Surjective.{succ u2, succ u1} α β f) -> (IsIdempotent.{u1} β gb)
-Case conversion may be inaccurate. Consider using '#align function.semiconj₂.is_idempotent_right Function.Semiconj₂.isIdempotent_rightₓ'. -/
 theorem isIdempotent_right [IsIdempotent α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
     IsIdempotent β gb :=
   ⟨h_surj.forall.2 fun x => by simp only [← h.eq, @IsIdempotent.idempotent _ ga]⟩

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

c4658a64

chore: unify date formatting in lemma deprecations (#12334)

consistently use the YYYY-MM-DD format
when easily possible, put the date on the same line as the deprecated attribute
when easily possible, format the entire declaration on the same line

Why these changes?

consistency makes it easier for tools to parse this information
compactness: I don't see a good reason for these declarations taking up more space than needed; as I understand it, deprecated lemmas are not supposed to be used in mathlib anyway
putting the date on the same line as the attribute makes it easier to discover un-dated deprecations; they also ease writing a tool to replace these by a machine-readable version using leanprover/lean4#3968

7e72dffd

Diff

@@ -67,7 +67,7 @@ then `fbc ∘ fab` semiconjugates `ga` to `gc`.
 
 See also `Function.Semiconj.trans` for a version with reversed arguments.
 
-**Backward compatibility note:** before 2024/01/13,
+**Backward compatibility note:** before 2024-01-13,
 this lemma used to have the same order of arguments that `Function.Semiconj.trans` has now. -/
 theorem comp_left (hbc : Semiconj fbc gb gc) (hab : Semiconj fab ga gb) :
     Semiconj (fbc ∘ fab) ga gc :=

c4658a64

chore: move to v4.6.0-rc1, merging adaptations from bump/v4.6.0 (#10176)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de>

490d2d48

Diff

@@ -191,24 +191,24 @@ theorem comp {f' : β → γ} {gc : γ → γ → γ} (hf' : Semiconj₂ f' gb g
     Semiconj₂ (f' ∘ f) ga gc := fun x y ↦ by simp only [hf'.eq, hf.eq, comp_apply]
 #align function.semiconj₂.comp Function.Semiconj₂.comp
 
-theorem isAssociative_right [IsAssociative α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
-    IsAssociative β gb :=
-  ⟨h_surj.forall₃.2 fun x₁ x₂ x₃ ↦ by simp only [← h.eq, @IsAssociative.assoc _ ga]⟩
+theorem isAssociative_right [Std.Associative ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
+    Std.Associative gb :=
+  ⟨h_surj.forall₃.2 fun x₁ x₂ x₃ ↦ by simp only [← h.eq, Std.Associative.assoc (op := ga)]⟩
 #align function.semiconj₂.is_associative_right Function.Semiconj₂.isAssociative_right
 
-theorem isAssociative_left [IsAssociative β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
-    IsAssociative α ga :=
-  ⟨fun x₁ x₂ x₃ ↦ h_inj <| by simp only [h.eq, @IsAssociative.assoc _ gb]⟩
+theorem isAssociative_left [Std.Associative gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
+    Std.Associative ga :=
+  ⟨fun x₁ x₂ x₃ ↦ h_inj <| by simp only [h.eq, Std.Associative.assoc (op := gb)]⟩
 #align function.semiconj₂.is_associative_left Function.Semiconj₂.isAssociative_left
 
-theorem isIdempotent_right [IsIdempotent α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
-    IsIdempotent β gb :=
-  ⟨h_surj.forall.2 fun x ↦ by simp only [← h.eq, @IsIdempotent.idempotent _ ga]⟩
+theorem isIdempotent_right [Std.IdempotentOp ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
+    Std.IdempotentOp gb :=
+  ⟨h_surj.forall.2 fun x ↦ by simp only [← h.eq, Std.IdempotentOp.idempotent (op := ga)]⟩
 #align function.semiconj₂.is_idempotent_right Function.Semiconj₂.isIdempotent_right
 
-theorem isIdempotent_left [IsIdempotent β gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
-    IsIdempotent α ga :=
-  ⟨fun x ↦ h_inj <| by rw [h.eq, @IsIdempotent.idempotent _ gb]⟩
+theorem isIdempotent_left [Std.IdempotentOp gb] (h : Semiconj₂ f ga gb) (h_inj : Injective f) :
+    Std.IdempotentOp ga :=
+  ⟨fun x ↦ h_inj <| by rw [h.eq, Std.IdempotentOp.idempotent (op := gb)]⟩
 #align function.semiconj₂.is_idempotent_left Function.Semiconj₂.isIdempotent_left
 
 end Semiconj₂

c4658a64

feat(Function/Conjugate): add Semiconj.inverse_left (#9724)

Add Function.semiconj_iff_comp_eq and Function.Semiconj.inverse_left.
Swap arguments of Function.Semiconj.comp_left. The old version is available as Function.Semiconj.trans.
Add docstrings.

ef9852fc

Diff

@@ -36,37 +36,67 @@ namespace Semiconj
 
 variable {f fab : α → β} {fbc : β → γ} {ga ga' : α → α} {gb gb' : β → β} {gc gc' : γ → γ}
 
-protected theorem comp_eq (h : Semiconj f ga gb) : f ∘ ga = gb ∘ f :=
-  funext h
+/-- Definition of `Function.Semiconj` in terms of functional equality. -/
+lemma _root_.Function.semiconj_iff_comp_eq : Semiconj f ga gb ↔ f ∘ ga = gb ∘ f := funext_iff.symm
+
+protected alias ⟨comp_eq, _⟩ := semiconj_iff_comp_eq
 #align function.semiconj.comp_eq Function.Semiconj.comp_eq
 
 protected theorem eq (h : Semiconj f ga gb) (x : α) : f (ga x) = gb (f x) :=
   h x
 #align function.semiconj.eq Function.Semiconj.eq
 
+/-- If `f` semiconjugates `ga` to `gb` and `ga'` to `gb'`,
+then it semiconjugates `ga ∘ ga'` to `gb ∘ gb'`. -/
 theorem comp_right (h : Semiconj f ga gb) (h' : Semiconj f ga' gb') :
-    Semiconj f (ga ∘ ga') (gb ∘ gb') :=
-  fun x ↦ by simp only [comp_apply, h.eq, h'.eq]
+    Semiconj f (ga ∘ ga') (gb ∘ gb') := fun x ↦ by
+  simp only [comp_apply, h.eq, h'.eq]
 #align function.semiconj.comp_right Function.Semiconj.comp_right
 
-theorem comp_left (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) :
+/-- If `fab : α → β` semiconjugates `ga` to `gb` and `fbc : β → γ` semiconjugates `gb` to `gc`,
+then `fbc ∘ fab` semiconjugates `ga` to `gc`.
+
+See also `Function.Semiconj.comp_left` for a version with reversed arguments. -/
+protected theorem trans (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) :
+    Semiconj (fbc ∘ fab) ga gc := fun x ↦ by
+  simp only [comp_apply, hab.eq, hbc.eq]
+#align function.semiconj.comp_left Function.Semiconj.trans
+
+/-- If `fbc : β → γ` semiconjugates `gb` to `gc` and `fab : α → β` semiconjugates `ga` to `gb`,
+then `fbc ∘ fab` semiconjugates `ga` to `gc`.
+
+See also `Function.Semiconj.trans` for a version with reversed arguments.
+
+**Backward compatibility note:** before 2024/01/13,
+this lemma used to have the same order of arguments that `Function.Semiconj.trans` has now. -/
+theorem comp_left (hbc : Semiconj fbc gb gc) (hab : Semiconj fab ga gb) :
     Semiconj (fbc ∘ fab) ga gc :=
-  fun x ↦ by simp only [comp_apply, hab.eq, hbc.eq]
-#align function.semiconj.comp_left Function.Semiconj.comp_left
+  hab.trans hbc
 
-theorem id_right : Semiconj f id id :=
-  fun _ ↦ rfl
+/-- Any function semiconjugates the identity function to the identity function. -/
+theorem id_right : Semiconj f id id := fun _ ↦ rfl
 #align function.semiconj.id_right Function.Semiconj.id_right
 
-theorem id_left : Semiconj id ga ga :=
-  fun _ ↦ rfl
+/-- The identity function semiconjugates any function to itself. -/
+theorem id_left : Semiconj id ga ga := fun _ ↦ rfl
 #align function.semiconj.id_left Function.Semiconj.id_left
 
+/-- If `f : α → β` semiconjugates `ga : α → α` to `gb : β → β`,
+`ga'` is a right inverse of `ga`, and `gb'` is a left inverse of `gb`,
+then `f` semiconjugates `ga'` to `gb'` as well. -/
 theorem inverses_right (h : Semiconj f ga gb) (ha : RightInverse ga' ga) (hb : LeftInverse gb' gb) :
-    Semiconj f ga' gb' :=
-  fun x ↦ by rw [← hb (f (ga' x)), ← h.eq, ha x]
+    Semiconj f ga' gb' := fun x ↦ by
+  rw [← hb (f (ga' x)), ← h.eq, ha x]
 #align function.semiconj.inverses_right Function.Semiconj.inverses_right
 
+/-- If `f` semiconjugates `ga` to `gb` and `f'` is both a left and a right inverse of `f`,
+then `f'` semiconjugates `gb` to `ga`. -/
+lemma inverse_left {f' : β → α} (h : Semiconj f ga gb)
+    (hf₁ : LeftInverse f' f) (hf₂ : RightInverse f' f) : Semiconj f' gb ga := fun x ↦ by
+  rw [← hf₁.injective.eq_iff, h, hf₂, hf₂]
+
+/-- If `f : α → β` semiconjugates `ga : α → α` to `gb : β → β`,
+then `Option.map f` semiconjugates `Option.map ga` to `Option.map gb`. -/
 theorem option_map {f : α → β} {ga : α → α} {gb : β → β} (h : Semiconj f ga gb) :
     Semiconj (Option.map f) (Option.map ga) (Option.map gb)
   | none => rfl
@@ -100,33 +130,35 @@ definitionally equal but have different dot-notation lemmas. -/
 theorem semiconj (h : Commute f g) : Semiconj f g g := h
 
 @[refl]
-theorem refl (f : α → α) : Commute f f :=
-  fun _ ↦ Eq.refl _
+theorem refl (f : α → α) : Commute f f := fun _ ↦ Eq.refl _
 #align function.commute.refl Function.Commute.refl
 
 @[symm]
-theorem symm (h : Commute f g) : Commute g f :=
-  fun x ↦ (h x).symm
+theorem symm (h : Commute f g) : Commute g f := fun x ↦ (h x).symm
 #align function.commute.symm Function.Commute.symm
 
+/-- If `f` commutes with `g` and `g'`, then it commutes with `g ∘ g'`. -/
 theorem comp_right (h : Commute f g) (h' : Commute f g') : Commute f (g ∘ g') :=
   Semiconj.comp_right h h'
 #align function.commute.comp_right Function.Commute.comp_right
 
-theorem comp_left (h : Commute f g) (h' : Commute f' g) : Commute (f ∘ f') g :=
-  (h.symm.comp_right h'.symm).symm
+/-- If `f` and `f'` commute with `g`, then `f ∘ f'` commutes with `g` as well. -/
+nonrec theorem comp_left (h : Commute f g) (h' : Commute f' g) : Commute (f ∘ f') g :=
+  h.comp_left h'
 #align function.commute.comp_left Function.Commute.comp_left
 
-theorem id_right : Commute f id :=
-  Semiconj.id_right
+/-- Any self-map commutes with the identity map. -/
+theorem id_right : Commute f id := Semiconj.id_right
 #align function.commute.id_right Function.Commute.id_right
 
+/-- The identity map commutes with any self-map. -/
 theorem id_left : Commute id f :=
   Semiconj.id_left
 #align function.commute.id_left Function.Commute.id_left
 
-theorem option_map {f g : α → α} : Commute f g → Commute (Option.map f) (Option.map g) :=
-  Semiconj.option_map
+/-- If `f` commutes with `g`, then `Option.map f` commutes with `Option.map g`. -/
+nonrec theorem option_map {f g : α → α} (h : Commute f g) : Commute (Option.map f) (Option.map g) :=
+  h.option_map
 #align function.commute.option_map Function.Commute.option_map
 
 end Commute

c4658a64

chore: bump dependencies (#7767)

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

d478563b

Diff

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
 import Mathlib.Logic.Function.Basic
-import Mathlib.Tactic.Relation.Rfl
 
 #align_import logic.function.conjugate from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"

c4658a64

refactor(*): Protect Function.Commute (#6456)

This PR protects Function.Commute, so that it no longer clashes with Commute in the root namespace, as suggested by @j-loreaux in #6290.

abbba041

Diff

@@ -81,10 +81,12 @@ Two maps `f g : α → α` commute if `f (g x) = g (f x)` for all `x : α`.
 Given `h : Function.commute f g` and `a : α`, we have `h a : f (g a) = g (f a)` and
 `h.comp_eq : f ∘ g = g ∘ f`.
 -/
-def Commute (f g : α → α) : Prop :=
+protected def Commute (f g : α → α) : Prop :=
   Semiconj f g g
 #align function.commute Function.Commute
 
+open Function (Commute)
+
 /-- Reinterpret `Function.Semiconj f g g` as `Function.Commute f g`. These two predicates are
 definitionally equal but have different dot-notation lemmas. -/
 theorem Semiconj.commute {f g : α → α} (h : Semiconj f g g) : Commute f g := h

c4658a64

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

@@ -22,7 +22,7 @@ We define the following predicates:
 
 namespace Function
 
-variable {α : Type _} {β : Type _} {γ : Type _}
+variable {α : Type*} {β : Type*} {γ : Type*}
 
 /--
 We say that `f : α → β` semiconjugates `ga : α → α` to `gb : β → β` if `f ∘ ga = gb ∘ f`.

c4658a64

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) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module logic.function.conjugate
-! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Logic.Function.Basic
 import Mathlib.Tactic.Relation.Rfl
 
+#align_import logic.function.conjugate from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
+
 /-!
 # Semiconjugate and commuting maps

c4658a64

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -34,6 +34,7 @@ We use `∀ x, f (ga x) = gb (f x)` as the definition, so given `h : Function.Se
 -/
 def Semiconj (f : α → β) (ga : α → α) (gb : β → β) : Prop :=
   ∀ x, f (ga x) = gb (f x)
+#align function.semiconj Function.Semiconj
 
 namespace Semiconj
 
@@ -41,32 +42,40 @@ variable {f fab : α → β} {fbc : β → γ} {ga ga' : α → α} {gb gb' : β
 
 protected theorem comp_eq (h : Semiconj f ga gb) : f ∘ ga = gb ∘ f :=
   funext h
+#align function.semiconj.comp_eq Function.Semiconj.comp_eq
 
 protected theorem eq (h : Semiconj f ga gb) (x : α) : f (ga x) = gb (f x) :=
   h x
+#align function.semiconj.eq Function.Semiconj.eq
 
 theorem comp_right (h : Semiconj f ga gb) (h' : Semiconj f ga' gb') :
     Semiconj f (ga ∘ ga') (gb ∘ gb') :=
   fun x ↦ by simp only [comp_apply, h.eq, h'.eq]
+#align function.semiconj.comp_right Function.Semiconj.comp_right
 
 theorem comp_left (hab : Semiconj fab ga gb) (hbc : Semiconj fbc gb gc) :
     Semiconj (fbc ∘ fab) ga gc :=
   fun x ↦ by simp only [comp_apply, hab.eq, hbc.eq]
+#align function.semiconj.comp_left Function.Semiconj.comp_left
 
 theorem id_right : Semiconj f id id :=
   fun _ ↦ rfl
+#align function.semiconj.id_right Function.Semiconj.id_right
 
 theorem id_left : Semiconj id ga ga :=
   fun _ ↦ rfl
+#align function.semiconj.id_left Function.Semiconj.id_left
 
 theorem inverses_right (h : Semiconj f ga gb) (ha : RightInverse ga' ga) (hb : LeftInverse gb' gb) :
     Semiconj f ga' gb' :=
   fun x ↦ by rw [← hb (f (ga' x)), ← h.eq, ha x]
+#align function.semiconj.inverses_right Function.Semiconj.inverses_right
 
 theorem option_map {f : α → β} {ga : α → α} {gb : β → β} (h : Semiconj f ga gb) :
     Semiconj (Option.map f) (Option.map ga) (Option.map gb)
   | none => rfl
   | some _ => congr_arg some <| h _
+#align function.semiconj.option_map Function.Semiconj.option_map
 
 end Semiconj
 
@@ -77,10 +86,12 @@ Given `h : Function.commute f g` and `a : α`, we have `h a : f (g a) = g (f a)`
 -/
 def Commute (f g : α → α) : Prop :=
   Semiconj f g g
+#align function.commute Function.Commute
 
 /-- Reinterpret `Function.Semiconj f g g` as `Function.Commute f g`. These two predicates are
 definitionally equal but have different dot-notation lemmas. -/
 theorem Semiconj.commute {f g : α → α} (h : Semiconj f g g) : Commute f g := h
+#align function.semiconj.commute Function.Semiconj.commute
 
 namespace Commute
 
@@ -93,25 +104,32 @@ theorem semiconj (h : Commute f g) : Semiconj f g g := h
 @[refl]
 theorem refl (f : α → α) : Commute f f :=
   fun _ ↦ Eq.refl _
+#align function.commute.refl Function.Commute.refl
 
 @[symm]
 theorem symm (h : Commute f g) : Commute g f :=
   fun x ↦ (h x).symm
+#align function.commute.symm Function.Commute.symm
 
 theorem comp_right (h : Commute f g) (h' : Commute f g') : Commute f (g ∘ g') :=
   Semiconj.comp_right h h'
+#align function.commute.comp_right Function.Commute.comp_right
 
 theorem comp_left (h : Commute f g) (h' : Commute f' g) : Commute (f ∘ f') g :=
   (h.symm.comp_right h'.symm).symm
+#align function.commute.comp_left Function.Commute.comp_left
 
 theorem id_right : Commute f id :=
   Semiconj.id_right
+#align function.commute.id_right Function.Commute.id_right
 
 theorem id_left : Commute id f :=
   Semiconj.id_left
+#align function.commute.id_left Function.Commute.id_left
 
 theorem option_map {f g : α → α} : Commute f g → Commute (Option.map f) (Option.map g) :=
   Semiconj.option_map
+#align function.commute.option_map Function.Commute.option_map
 
 end Commute
 
@@ -122,6 +140,7 @@ semiconjugates `(*)` to `(*)`.
 -/
 def Semiconj₂ (f : α → β) (ga : α → α → α) (gb : β → β → β) : Prop :=
   ∀ x y, f (ga x y) = gb (f x) (f y)
+#align function.semiconj₂ Function.Semiconj₂
 
 namespace Semiconj₂
 
@@ -129,14 +148,18 @@ variable {f : α → β} {ga : α → α → α} {gb : β → β → β}
 
 protected theorem eq (h : Semiconj₂ f ga gb) (x y : α) : f (ga x y) = gb (f x) (f y) :=
   h x y
+#align function.semiconj₂.eq Function.Semiconj₂.eq
 
 protected theorem comp_eq (h : Semiconj₂ f ga gb) : bicompr f ga = bicompl gb f f :=
   funext fun x ↦ funext <| h x
+#align function.semiconj₂.comp_eq Function.Semiconj₂.comp_eq
 
 theorem id_left (op : α → α → α) : Semiconj₂ id op op := fun _ _ ↦ rfl
+#align function.semiconj₂.id_left Function.Semiconj₂.id_left
 
 theorem comp {f' : β → γ} {gc : γ → γ → γ} (hf' : Semiconj₂ f' gb gc) (hf : Semiconj₂ f ga gb) :
     Semiconj₂ (f' ∘ f) ga gc := fun x y ↦ by simp only [hf'.eq, hf.eq, comp_apply]
+#align function.semiconj₂.comp Function.Semiconj₂.comp
 
 theorem isAssociative_right [IsAssociative α ga] (h : Semiconj₂ f ga gb) (h_surj : Surjective f) :
     IsAssociative β gb :=

c4658a64

chore: fix casing errors per naming scheme (#1670)

526ab32a

Diff

@@ -72,7 +72,7 @@ end Semiconj
 
 /--
 Two maps `f g : α → α` commute if `f (g x) = g (f x)` for all `x : α`.
-Given `h : function.commute f g` and `a : α`, we have `h a : f (g a) = g (f a)` and
+Given `h : Function.commute f g` and `a : α`, we have `h a : f (g a) = g (f a)` and
 `h.comp_eq : f ∘ g = g ∘ f`.
 -/
 def Commute (f g : α → α) : Prop :=

c4658a64

Feat: port Order.Filter.Basic (#1750)

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>

caa949fb

Diff

@@ -78,12 +78,18 @@ Given `h : function.commute f g` and `a : α`, we have `h a : f (g a) = g (f a)`
 def Commute (f g : α → α) : Prop :=
   Semiconj f g g
 
+/-- Reinterpret `Function.Semiconj f g g` as `Function.Commute f g`. These two predicates are
+definitionally equal but have different dot-notation lemmas. -/
 theorem Semiconj.commute {f g : α → α} (h : Semiconj f g g) : Commute f g := h
 
 namespace Commute
 
 variable {f f' g g' : α → α}
 
+/-- Reinterpret `Function.Commute f g` as `Function.Semiconj f g g`. These two predicates are
+definitionally equal but have different dot-notation lemmas. -/
+theorem semiconj (h : Commute f g) : Semiconj f g g := h
+
 @[refl]
 theorem refl (f : α → α) : Commute f f :=
   fun _ ↦ Eq.refl _

c4658a64

chore: add source headers to ported theory files (#1094)

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2020 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
+
+! This file was ported from Lean 3 source module logic.function.conjugate
+! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Logic.Function.Basic
 import Mathlib.Tactic.Relation.Rfl

`logic.function.conjugate` ⟷ `Mathlib.Logic.Function.Conjugate`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4

logic.function.conjugate ⟷ Mathlib.Logic.Function.Conjugate

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4

`logic.function.conjugate` ⟷ `Mathlib.Logic.Function.Conjugate`